_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q6700 | Count | train | func (m *MockCollector) Count() int {
ret := m.ctrl.Call(m, "Count")
ret0, _ := ret[0].(int)
return ret0
} | go | {
"resource": ""
} |
q6701 | Count | train | func (mr *MockCollectorMockRecorder) Count() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockCollector)(nil).Count))
} | go | {
"resource": ""
} |
q6702 | GetAllRecords | train | func (m *MockCollector) GetAllRecords() map[string]*collector.FlowRecord {
ret := m.ctrl.Call(m, "GetAllRecords")
ret0, _ := ret[0].(map[string]*collector.FlowRecord)
return ret0
} | go | {
"resource": ""
} |
q6703 | GetAllDataPathPacketRecords | train | func (m *MockCollector) GetAllDataPathPacketRecords() []*collector.PacketReport {
ret := m.ctrl.Call(m, "GetAllDataPathPacketRecords")
ret0, _ := ret[0].([]*collector.PacketReport)
return ret0
} | go | {
"resource": ""
} |
q6704 | CollectUserEvent | train | func (mr *MockCollectorMockRecorder) CollectUserEvent(record interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectUserEvent", reflect.TypeOf((*MockCollector)(nil).CollectUserEvent), record)
} | go | {
"resource": ""
} |
q6705 | NewPortSpec | train | func NewPortSpec(min, max uint16, value interface{}) (*PortSpec, error) {
if min > max {
return nil, errors.New("Min port greater than max")
}
return &PortSpec{
Min: min,
Max: max,
value: value,
}, nil
} | go | {
"resource": ""
} |
q6706 | NewPortSpecFromString | train | func NewPortSpecFromString(ports string, value interface{}) (*PortSpec, error) {
var min, max int
var err error
if strings.Contains(ports, ":") {
portMinMax := strings.SplitN(ports, ":", 2)
if len(portMinMax) != 2 {
return nil, errors.New("Invalid port specification")
}
min, err = strconv.Atoi(portMinMa... | go | {
"resource": ""
} |
q6707 | SinglePort | train | func (s *PortSpec) SinglePort() (uint16, error) {
if s.IsMultiPort() {
return 0, errors.New("Not a single port specification")
}
return s.Min, nil
} | go | {
"resource": ""
} |
q6708 | String | train | func (s *PortSpec) String() string {
if s.IsMultiPort() {
return strconv.Itoa(int(s.Min)) + ":" + strconv.Itoa(int(s.Max))
}
return strconv.Itoa(int(s.Min))
} | go | {
"resource": ""
} |
q6709 | Overlaps | train | func (s *PortSpec) Overlaps(p *PortSpec) bool {
a := p
b := s
if a.Min > b.Min {
a = s
b = p
}
if a.Max >= b.Min {
return true
}
return false
} | go | {
"resource": ""
} |
q6710 | IsIncluded | train | func (s *PortSpec) IsIncluded(port int) bool {
p := uint16(port)
if s.Min <= p && p <= s.Max {
return true
}
return false
} | go | {
"resource": ""
} |
q6711 | VerifyIPChecksum | train | func (p *Packet) VerifyIPChecksum() bool {
sum := p.computeIPChecksum()
return sum == p.ipHdr.ipChecksum
} | go | {
"resource": ""
} |
q6712 | UpdateIPChecksum | train | func (p *Packet) UpdateIPChecksum() {
p.ipHdr.ipChecksum = p.computeIPChecksum()
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
} | go | {
"resource": ""
} |
q6713 | VerifyTCPChecksum | train | func (p *Packet) VerifyTCPChecksum() bool {
sum := p.computeTCPChecksum()
return sum == p.tcpHdr.tcpChecksum
} | go | {
"resource": ""
} |
q6714 | UpdateTCPChecksum | train | func (p *Packet) UpdateTCPChecksum() {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpChecksum = p.computeTCPChecksum()
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
} | go | {
"resource": ""
} |
q6715 | PacketToStringTCP | train | func (p *Packet) PacketToStringTCP() string {
var buf bytes.Buffer
buf.WriteString("(error)")
header, err := ipv4.ParseHeader(p.ipHdr.Buffer)
if err == nil {
buf.Reset()
buf.WriteString(header.String())
buf.WriteString(" srcport=")
buf.WriteString(strconv.Itoa(int(p.SourcePort())))
buf.WriteString(" ds... | go | {
"resource": ""
} |
q6716 | computeIPChecksum | train | func (p *Packet) computeIPChecksum() uint16 {
// IP packet checksum is computed with the checksum value set to zero
p.ipHdr.Buffer[ipv4ChecksumPos] = 0
p.ipHdr.Buffer[ipv4ChecksumPos+1] = 0
// Compute checksum, over IP header only
sum := checksum(p.ipHdr.Buffer[:p.ipHdr.ipHeaderLen])
// Restore the previous ch... | go | {
"resource": ""
} |
q6717 | computeTCPChecksum | train | func (p *Packet) computeTCPChecksum() uint16 {
var buf [2]byte
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
tcpBufSize := uint16(len(buffer) + len(p.tcpHdr.tcpData) + len(p.tcpHdr.tcpOptions))
oldCsumLow := buffer[tcpChecksumPos]
oldCsumHigh := buffer[tcpChecksumPos+1]
// Put 0 to calculate the checksum. We w... | go | {
"resource": ""
} |
q6718 | incCsum16 | train | func incCsum16(start, old, new uint16) uint16 {
start = start ^ 0xffff
old = old ^ 0xffff
csum := uint32(start) + uint32(old) + uint32(new)
for (csum >> 16) > 0 {
csum = (csum & 0xffff) + ((csum >> 16) & 0xffff)
}
csum = csum ^ 0xffff
return uint16(csum)
} | go | {
"resource": ""
} |
q6719 | checksumDelta | train | func checksumDelta(init uint32, buf []byte) uint32 {
sum := init
for ; len(buf) >= 2; buf = buf[2:] {
sum += uint32(buf[0])<<8 | uint32(buf[1])
}
if len(buf) > 0 {
sum += uint32(buf[0]) << 8
}
return sum
} | go | {
"resource": ""
} |
q6720 | checksum | train | func checksum(buf []byte) uint16 {
sum32 := checksumDelta(0, buf)
sum16 := csumConvert32To16bit(sum32)
csum := ^sum16
return csum
} | go | {
"resource": ""
} |
q6721 | UpdateUDPChecksum | train | func (p *Packet) UpdateUDPChecksum() {
// checksum set to 0, ignored by the stack
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
ignoreCheckSum := []byte{0, 0}
p.udpHdr.udpChecksum = binary.BigEndian.Uint16(ignoreCheckSum[:])
curLen := uint16(len(buffer))
udpDataLen := curLen - p.GetUDPDataStartBytes()
// upd... | go | {
"resource": ""
} |
q6722 | ReadUDPToken | train | func (p *Packet) ReadUDPToken() []byte {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
// 8 byte udp header, 20 byte udp marker
if len(buffer) <= udpJwtTokenOffset {
return []byte{}
}
return buffer[udpJwtTokenOffset:]
} | go | {
"resource": ""
} |
q6723 | UDPTokenAttach | train | func (p *Packet) UDPTokenAttach(udpdata []byte, udptoken []byte) {
udpData := []byte{}
udpData = append(udpData, udpdata...)
udpData = append(udpData, udptoken...)
packetLenIncrease := uint16(len(udpdata) + len(udptoken))
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLe... | go | {
"resource": ""
} |
q6724 | UDPDataAttach | train | func (p *Packet) UDPDataAttach(header, udpdata []byte) {
// Attach Data @ the end of current buffer
p.ipHdr.Buffer = append(p.ipHdr.Buffer, header...)
p.ipHdr.Buffer = append(p.ipHdr.Buffer, udpdata...)
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, uint16(len(p.ipHdr.Buffer)))
p.UpdateU... | go | {
"resource": ""
} |
q6725 | CreateReverseFlowPacket | train | func (p *Packet) CreateReverseFlowPacket(destIP net.IP, destPort uint16) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
srcAddr := binary.BigEndian.Uint32(destIP.To4())
destAddr := binary.BigEndian.Uint32(p.ipHdr.Buffer[ipv4DestAddrPos : ipv4DestAddrPos+4])
// copy the fields
binary.BigEndian.PutUint32(p.ipHdr... | go | {
"resource": ""
} |
q6726 | GetUDPType | train | func (p *Packet) GetUDPType() byte {
// Every UDP control packet has a 20 byte packet signature. The
// first 2 bytes represent the following control information.
// Byte 0 : Bits 0,1 are reserved fields.
// Bits 2,3,4 represent version information.
// Bits 5,6 represent udp packet type,
// ... | go | {
"resource": ""
} |
q6727 | GetUDPTypeFromBuffer | train | func GetUDPTypeFromBuffer(buffer []byte) byte {
if len(buffer) < (UDPDataPos + UDPSignatureLen) {
return 0
}
marker := buffer[UDPDataPos:udpSignatureEnd]
// check for packet signature.
if !bytes.Equal(buffer[udpAuthMarkerOffset:udpSignatureEnd], []byte(UDPAuthMarker)) {
zap.L().Debug("Not an Aporeto control ... | go | {
"resource": ""
} |
q6728 | CreateUDPAuthMarker | train | func CreateUDPAuthMarker(packetType uint8) []byte {
// Every UDP control packet has a 20 byte packet signature. The
// first 2 bytes represent the following control information.
// Byte 0 : Bits 0,1 are reserved fields.
// Bits 2,3,4 represent version information.
// Bits 5, 6, 7 represent udp p... | go | {
"resource": ""
} |
q6729 | NewJWT | train | func NewJWT(validity time.Duration, issuer string, s secrets.Secrets) (*JWTConfig, error) {
if len(issuer) > MaxServerName {
return nil, fmt.Errorf("server id should be max %d chars. got %s", MaxServerName, issuer)
}
for i := len(issuer); i < MaxServerName; i++ {
issuer = issuer + " "
}
var signMethod jwt.S... | go | {
"resource": ""
} |
q6730 | CreateAndSign | train | func (c *JWTConfig) CreateAndSign(isAck bool, claims *ConnectionClaims, nonce []byte, claimsHeader *claimsheader.ClaimsHeader) (token []byte, err error) {
// Combine the application claims with the standard claims
allclaims := &JWTClaims{
claims,
jwt.StandardClaims{
ExpiresAt: time.Now().Add(c.ValidityPeriod)... | go | {
"resource": ""
} |
q6731 | Randomize | train | func (c *JWTConfig) Randomize(token []byte, nonce []byte) (err error) {
if len(token) < tokenPosition {
return errors.New("token is too small")
}
copy(token[noncePosition:], nonce)
return nil
} | go | {
"resource": ""
} |
q6732 | RetrieveNonce | train | func (c *JWTConfig) RetrieveNonce(token []byte) ([]byte, error) {
if len(token) < tokenPosition {
return []byte{}, errors.New("invalid token")
}
nonce := make([]byte, NonceLength)
copy(nonce, token[noncePosition:tokenPosition])
return nonce, nil
} | go | {
"resource": ""
} |
q6733 | addTransmitterLabel | train | func addTransmitterLabel(contextID string, containerInfo *policy.PUInfo) {
if containerInfo.Policy.ManagementID() == "" {
containerInfo.Policy.AddIdentityTag(enforcerconstants.TransmitterLabel, contextID)
} else {
containerInfo.Policy.AddIdentityTag(enforcerconstants.TransmitterLabel, containerInfo.Policy.Manage... | go | {
"resource": ""
} |
q6734 | SubOptionMonitorLinuxExtractor | train | func SubOptionMonitorLinuxExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | {
"resource": ""
} |
q6735 | SubOptionMonitorCNIExtractor | train | func SubOptionMonitorCNIExtractor(extractor extractors.EventMetadataExtractor) CNIMonitorOption {
return func(cfg *cnimonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | {
"resource": ""
} |
q6736 | SubOptionMonitorUIDExtractor | train | func SubOptionMonitorUIDExtractor(extractor extractors.EventMetadataExtractor) UIDMonitorOption {
return func(cfg *uidmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | {
"resource": ""
} |
q6737 | SubOptionMonitorSSHExtractor | train | func SubOptionMonitorSSHExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | {
"resource": ""
} |
q6738 | SubOptionMonitorDockerExtractor | train | func SubOptionMonitorDockerExtractor(extractor extractors.DockerMetadataExtractor) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | {
"resource": ""
} |
q6739 | SubOptionMonitorDockerSocket | train | func SubOptionMonitorDockerSocket(socketType, socketAddress string) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.SocketType = socketType
cfg.SocketAddress = socketAddress
}
} | go | {
"resource": ""
} |
q6740 | SubOptionMonitorDockerFlags | train | func SubOptionMonitorDockerFlags(syncAtStart, killContainerOnPolicyError bool) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.KillContainerOnPolicyError = killContainerOnPolicyError
cfg.SyncAtStart = syncAtStart
}
} | go | {
"resource": ""
} |
q6741 | SubOptionMonitorKubernetesKubeconfig | train | func SubOptionMonitorKubernetesKubeconfig(kubeconfig string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | go | {
"resource": ""
} |
q6742 | SubOptionMonitorKubernetesNodename | train | func SubOptionMonitorKubernetesNodename(nodename string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Nodename = nodename
}
} | go | {
"resource": ""
} |
q6743 | SubOptionMonitorKubernetesHostPod | train | func SubOptionMonitorKubernetesHostPod(enableHostPods bool) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | go | {
"resource": ""
} |
q6744 | SubOptionMonitorKubernetesExtractor | train | func SubOptionMonitorKubernetesExtractor(extractor extractors.KubernetesMetadataExtractorType) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.KubernetesExtractor = extractor
}
} | go | {
"resource": ""
} |
q6745 | SubOptionMonitorKubernetesDockerExtractor | train | func SubOptionMonitorKubernetesDockerExtractor(extractor extractors.DockerMetadataExtractor) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.DockerExtractor = extractor
}
} | go | {
"resource": ""
} |
q6746 | SubOptionMonitorPodKubeconfig | train | func SubOptionMonitorPodKubeconfig(kubeconfig string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | go | {
"resource": ""
} |
q6747 | SubOptionMonitorPodNodename | train | func SubOptionMonitorPodNodename(nodename string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Nodename = nodename
}
} | go | {
"resource": ""
} |
q6748 | SubOptionMonitorPodActivateHostPods | train | func SubOptionMonitorPodActivateHostPods(enableHostPods bool) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | go | {
"resource": ""
} |
q6749 | SubOptionMonitorPodMetadataExtractor | train | func SubOptionMonitorPodMetadataExtractor(extractor extractors.PodMetadataExtractor) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.MetadataExtractor = extractor
}
} | go | {
"resource": ""
} |
q6750 | SubOptionMonitorPodNetclsProgrammer | train | func SubOptionMonitorPodNetclsProgrammer(netclsprogrammer extractors.PodNetclsProgrammer) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.NetclsProgrammer = netclsprogrammer
}
} | go | {
"resource": ""
} |
q6751 | OptionCollector | train | func OptionCollector(c collector.EventCollector) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Collector = c
}
} | go | {
"resource": ""
} |
q6752 | OptionPolicyResolver | train | func OptionPolicyResolver(p policy.Resolver) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Policy = p
}
} | go | {
"resource": ""
} |
q6753 | NewMonitor | train | func NewMonitor(opts ...Options) *config.MonitorConfig {
cfg := &config.MonitorConfig{
Monitors: make(map[config.Type]interface{}),
}
for _, opt := range opts {
opt(cfg)
}
return cfg
} | go | {
"resource": ""
} |
q6754 | AddEthernetLayer | train | func (p *Packet) AddEthernetLayer(srcMACstr string, dstMACstr string) error {
if p.ethernetLayer != nil {
return errors.New("ethernet layer already exists")
}
var srcMAC, dstMAC net.HardwareAddr
//MAC address of the source
srcMAC, _ = net.ParseMAC(srcMACstr)
if srcMAC == nil {
return errors.New("no source... | go | {
"resource": ""
} |
q6755 | AddIPLayer | train | func (p *Packet) AddIPLayer(srcIPstr string, dstIPstr string) error {
if p.ipLayer != nil {
return errors.New("ip layer already exists")
}
var srcIP, dstIP net.IP
//IP address of the source
srcIP = net.ParseIP(srcIPstr)
if srcIP == nil {
return errors.New("no source ip given")
}
//IP address of the des... | go | {
"resource": ""
} |
q6756 | AddTCPLayer | train | func (p *Packet) AddTCPLayer(srcPort layers.TCPPort, dstPort layers.TCPPort) error {
if p.tcpLayer != nil {
return errors.New("tcp layer already exists")
}
if srcPort == 0 {
return errors.New("no source tcp port given")
}
if dstPort == 0 {
return errors.New("no destination tcp port given")
}
//TCP pack... | go | {
"resource": ""
} |
q6757 | SetTCPSynAck | train | func (p *Packet) SetTCPSynAck() {
p.tcpLayer.SYN = true
p.tcpLayer.ACK = true
p.tcpLayer.FIN = false
} | go | {
"resource": ""
} |
q6758 | NewTCPPayload | train | func (p *Packet) NewTCPPayload(newPayload string) error {
if p.tcpLayer.Payload != nil {
return errors.New("payload already exists")
}
p.tcpLayer.Payload = []byte(newPayload)
return nil
} | go | {
"resource": ""
} |
q6759 | DecodePacket | train | func (p *Packet) DecodePacket() PacketManipulator {
packetData := &Packet{
ethernetLayer: &layers.Ethernet{},
ipLayer: &layers.IPv4{},
tcpLayer: &layers.TCP{},
}
newEthernetPacket := packetData.GetEthernetPacket()
newIPPacket := packetData.GetIPPacket()
newTCPPacket := packetData.GetTCPPacket()
... | go | {
"resource": ""
} |
q6760 | NewPacketFlow | train | func NewPacketFlow(smac string, dmac string, sip string, dip string, sport layers.TCPPort, dport layers.TCPPort) PacketFlowManipulator {
initialTupules := &PacketFlow{
sMAC: smac,
dMAC: dmac,
sIP: sip,
dIP: dip,
sPort: sport,
dPort: dport,
flow: make([]PacketManipulator, 0),
}
return initialTu... | go | {
"resource": ""
} |
q6761 | AppendPacket | train | func (p *PacketFlow) AppendPacket(pm PacketManipulator) int {
p.flow = append(p.flow, pm)
return p.GetNumPackets()
} | go | {
"resource": ""
} |
q6762 | getMatchPackets | train | func (p *PacketFlow) getMatchPackets(syn, ack, fin bool) PacketFlowManipulator {
packetsInFlow := NewPacketFlow(p.sMAC, p.dMAC, p.sIP, p.dIP, p.sPort, p.dPort)
for j := 0; j < len(p.flow); j++ {
if p.flow[j].GetTCPSyn() == syn && p.flow[j].GetTCPAck() == ack && p.flow[j].GetTCPFin() == fin {
packetsInFlow.Appe... | go | {
"resource": ""
} |
q6763 | GetUptoFirstSynAckPacket | train | func (p *PacketFlow) GetUptoFirstSynAckPacket() PacketFlowManipulator {
packetsInFlow := NewPacketFlow(p.sMAC, p.dMAC, p.sIP, p.dIP, p.sPort, p.dPort)
flag := false
for j := 0; j < len(p.flow); j++ {
if !flag {
packetsInFlow.AppendPacket(p.flow[j])
if p.flow[j].GetTCPSyn() && p.flow[j].GetTCPAck() && !p.fl... | go | {
"resource": ""
} |
q6764 | GetNthPacket | train | func (p *PacketFlow) GetNthPacket(index int) PacketManipulator {
for i := 0; i < len(p.flow); i++ {
if index == i {
return p.flow[i]
}
}
panic("Index out of range")
} | go | {
"resource": ""
} |
q6765 | ConvertServicesToPortList | train | func ConvertServicesToPortList(services []Service) string {
portlist := ""
for _, s := range services {
portlist = portlist + s.Ports.String() + ","
}
if len(portlist) == 0 {
portlist = "0"
} else {
portlist = portlist[:len(portlist)-1]
}
return portlist
} | go | {
"resource": ""
} |
q6766 | NewDebugClient | train | func NewDebugClient(cr statscollector.Collector) (DebugClient, error) {
d := &debugClient{
collector: cr,
rpchdl: rpcwrapper.NewRPCWrapper(),
secret: os.Getenv(constants.EnvStatsSecret),
debugChannel: os.Getenv(constants.EnvStatsChannel),
debugInterval: defaultDebugIntervalMilliseconds * t... | go | {
"resource": ""
} |
q6767 | CreateSocket | train | func CreateSocket(mark int, deviceName string) (SocketWriter, error) {
fd, _ := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
syscall.Close(fd) // nolint
return nil, fmt.Errorf("Received error %s ... | go | {
"resource": ""
} |
q6768 | NewPUInfo | train | func NewPUInfo(contextID string, puType common.PUType) *PUInfo {
policy := NewPUPolicy(contextID, AllowAll, nil, nil, nil, nil, nil, nil, nil, nil, 0, nil, nil, []string{})
runtime := NewPURuntime("", 0, "", nil, nil, puType, nil)
return PUInfoFromPolicyAndRuntime(contextID, policy, runtime)
} | go | {
"resource": ""
} |
q6769 | PUInfoFromPolicyAndRuntime | train | func PUInfoFromPolicyAndRuntime(contextID string, policyInfo *PUPolicy, runtimeInfo *PURuntime) *PUInfo {
return &PUInfo{
ContextID: contextID,
Policy: policyInfo,
Runtime: runtimeInfo,
}
} | go | {
"resource": ""
} |
q6770 | ErrPUNotFound | train | func ErrPUNotFound(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotFound,
err: err,
}
} | go | {
"resource": ""
} |
q6771 | ErrPUNotUnique | train | func ErrPUNotUnique(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotUnique,
err: err,
}
} | go | {
"resource": ""
} |
q6772 | ErrPUCreateFailed | train | func ErrPUCreateFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUCreateFailed,
err: err,
}
} | go | {
"resource": ""
} |
q6773 | ErrPUAlreadyActivated | train | func ErrPUAlreadyActivated(puID string, err error) error {
return &Error{
puID: puID,
reason: PUAlreadyActivated,
err: err,
}
} | go | {
"resource": ""
} |
q6774 | ErrPUPolicyPending | train | func ErrPUPolicyPending(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyPending,
err: err,
}
} | go | {
"resource": ""
} |
q6775 | ErrPUPolicyEnforcementFailed | train | func ErrPUPolicyEnforcementFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyEnforcementFailed,
err: err,
}
} | go | {
"resource": ""
} |
q6776 | IsErrPUNotFound | train | func IsErrPUNotFound(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotFound
default:
return false
}
} | go | {
"resource": ""
} |
q6777 | IsErrPUNotUnique | train | func IsErrPUNotUnique(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotUnique
default:
return false
}
} | go | {
"resource": ""
} |
q6778 | IsErrPUCreateFailed | train | func IsErrPUCreateFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUCreateFailed
default:
return false
}
} | go | {
"resource": ""
} |
q6779 | IsErrPUAlreadyActivated | train | func IsErrPUAlreadyActivated(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUAlreadyActivated
default:
return false
}
} | go | {
"resource": ""
} |
q6780 | IsErrPUPolicyPending | train | func IsErrPUPolicyPending(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyPending
default:
return false
}
} | go | {
"resource": ""
} |
q6781 | IsErrPUEnforcementFailed | train | func IsErrPUEnforcementFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyEnforcementFailed
default:
return false
}
} | go | {
"resource": ""
} |
q6782 | ExecuteCommandFromArguments | train | func ExecuteCommandFromArguments(arguments map[string]interface{}) error {
p := NewRequestProcessor()
c, err := p.ParseCommand(arguments)
if err != nil {
return err
}
return p.ExecuteRequest(c)
} | go | {
"resource": ""
} |
q6783 | NewCustomRequestProcessor | train | func NewCustomRequestProcessor(address string) *RequestProcessor {
r := NewRequestProcessor()
if address != "" {
r.address = address
}
return r
} | go | {
"resource": ""
} |
q6784 | CreateAndRun | train | func (r *RequestProcessor) CreateAndRun(c *CLIRequest) error {
var err error
// If its not hostPolicy and the command doesn't exist we return an error
if !c.HostPolicy {
if c.Executable == "" {
return errors.New("command must be provided")
}
if !path.IsAbs(c.Executable) {
c.Executable, err = exec.LookPa... | go | {
"resource": ""
} |
q6785 | DeleteService | train | func (r *RequestProcessor) DeleteService(c *CLIRequest) error {
request := &common.EventInfo{
PUType: common.LinuxProcessPU,
PUID: c.ServiceName,
EventType: common.EventStop,
HostService: c.HostPolicy,
}
if c.UIDPolicy {
request.PUType = common.UIDLoginPU
}
// Send Stop request
if err :... | go | {
"resource": ""
} |
q6786 | DeleteCgroup | train | func (r *RequestProcessor) DeleteCgroup(c *CLIRequest) error {
regexCgroup := regexp.MustCompile(`^/trireme/(ssh-)?[a-zA-Z0-9_\-:.$%]{1,64}$`)
regexUser := regexp.MustCompile(`^/trireme_uid/[a-zA-Z0-9_\-]{1,32}(/[0-9]{1,32}){0,1}$`)
if !regexCgroup.Match([]byte(c.Cgroup)) && !regexUser.Match([]byte(c.Cgroup)) {
r... | go | {
"resource": ""
} |
q6787 | ExecuteRequest | train | func (r *RequestProcessor) ExecuteRequest(c *CLIRequest) error {
switch c.Request {
case CreateRequest:
return r.CreateAndRun(c)
case DeleteCgroupRequest:
return r.DeleteCgroup(c)
case DeleteServiceRequest:
return r.DeleteService(c)
default:
return fmt.Errorf("unknown request: %d", c.Request)
}
} | go | {
"resource": ""
} |
q6788 | sendRequest | train | func sendRequest(address string, event *common.EventInfo) error {
client, err := client.NewClient(address)
if err != nil {
return err
}
return client.SendRequest(event)
} | go | {
"resource": ""
} |
q6789 | ParseServices | train | func ParseServices(ports []string) ([]common.Service, error) {
// If no ports are provided, we add the default 0 port
if len(ports) == 0 {
ports = append(ports, "0")
}
// Parse the ports and create the services. Cleanup any bad ports
services := []common.Service{}
protocol := packet.IPProtocolTCP
for _, p :... | go | {
"resource": ""
} |
q6790 | ComputeHmac256 | train | func ComputeHmac256(tags []byte, key []byte) ([]byte, error) {
var buffer bytes.Buffer
if err := binary.Write(&buffer, binary.BigEndian, tags); err != nil {
return []byte{}, err
}
h := hmac.New(sha256.New, key)
if _, err := h.Write(buffer.Bytes()); err != nil {
return []byte{}, err
}
return h.Sum(nil), n... | go | {
"resource": ""
} |
q6791 | VerifyHmac | train | func VerifyHmac(tags []byte, expectedMAC []byte, key []byte) bool {
messageMAC, err := ComputeHmac256(tags, key)
if err != nil {
return false
}
return hmac.Equal(messageMAC, expectedMAC)
} | go | {
"resource": ""
} |
q6792 | GenerateRandomBytes | train | func GenerateRandomBytes(n int) ([]byte, error) {
b := make([]byte, n)
_, err := rand.Read(b)
if err != nil {
zap.L().Debug("GenerateRandomBytes failed", zap.Error(err))
return nil, err
}
s := base64.StdEncoding.EncodeToString(b)
return []byte(s[:n]), nil
} | go | {
"resource": ""
} |
q6793 | GenerateRandomString | train | func GenerateRandomString(s int) (string, error) {
b, err := GenerateRandomBytes(s)
return base64.URLEncoding.EncodeToString(b), err
} | go | {
"resource": ""
} |
q6794 | LoadRootCertificates | train | func LoadRootCertificates(rootPEM []byte) *x509.CertPool {
roots := x509.NewCertPool()
ok := roots.AppendCertsFromPEM(rootPEM)
if !ok {
zap.L().Error("AppendCertsFromPEM failed", zap.ByteString("rootPEM", rootPEM))
return nil
}
return roots
} | go | {
"resource": ""
} |
q6795 | LoadEllipticCurveKey | train | func LoadEllipticCurveKey(keyPEM []byte) (*ecdsa.PrivateKey, error) {
block, _ := pem.Decode(keyPEM)
if block == nil {
return nil, fmt.Errorf("LoadElliticCurveKey bad pem block: %s", string(keyPEM))
}
// Parse the key
key, err := x509.ParseECPrivateKey(block.Bytes)
if err != nil {
return nil, err
}
retur... | go | {
"resource": ""
} |
q6796 | LoadAndVerifyCertificate | train | func LoadAndVerifyCertificate(certPEM []byte, roots *x509.CertPool) (*x509.Certificate, error) {
cert, err := LoadCertificate(certPEM)
if err != nil {
return nil, err
}
opts := x509.VerifyOptions{
Roots: roots,
}
if _, err := cert.Verify(opts); err != nil {
return nil, err
}
return cert, nil
} | go | {
"resource": ""
} |
q6797 | LoadAndVerifyECSecrets | train | func LoadAndVerifyECSecrets(keyPEM, certPEM, caCertPEM []byte) (key *ecdsa.PrivateKey, cert *x509.Certificate, rootCertPool *x509.CertPool, err error) {
// Parse the key
key, err = LoadEllipticCurveKey(keyPEM)
if err != nil {
return nil, nil, nil, err
}
rootCertPool = LoadRootCertificates(caCertPEM)
if rootCe... | go | {
"resource": ""
} |
q6798 | LoadCertificate | train | func LoadCertificate(certPEM []byte) (*x509.Certificate, error) {
// Decode the certificate
certBlock, _ := pem.Decode(certPEM)
if certBlock == nil {
return nil, fmt.Errorf("unable to parse pem block: %s", string(certPEM))
}
// Create the certificate structure
cert, err := x509.ParseCertificate(certBlock.Byte... | go | {
"resource": ""
} |
q6799 | NewRPCClient | train | func (m *MockRPCClient) NewRPCClient(contextID, channel, rpcSecret string) error {
ret := m.ctrl.Call(m, "NewRPCClient", contextID, channel, rpcSecret)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.