id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c6700 | _ := ret[0].(int)
return ret0
} | |
c6701 | "Count", reflect.TypeOf((*MockCollector)(nil).Count))
} | |
c6702 | ret[0].(map[string]*collector.FlowRecord)
return ret0
} | |
c6703 | {
ret := m.ctrl.Call(m, "GetAllDataPathPacketRecords")
ret0, _ := ret[0].([]*collector.PacketReport)
return ret0
} | |
c6704 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectUserEvent", reflect.TypeOf((*MockCollector)(nil).CollectUserEvent), record)
} | |
c6705 | max")
}
return &PortSpec{
Min: min,
Max: max,
value: value,
}, nil
} | |
c6706 | != nil || max >= 65536 {
return nil, errors.New("Max is not a valid port")
}
} else {
min, err = strconv.Atoi(ports)
if err != nil || min >= 65536 || min < 0 {
return nil, errors.New("Port is larger than 2^16 or invalid port")
}
max = min
}
return NewPortSpec(uint16(min), uint16(max), value)
} | |
c6707 | {
return 0, errors.New("Not a single port specification")
}
return s.Min, nil
} | |
c6708 | strconv.Itoa(int(s.Max))
}
return strconv.Itoa(int(s.Min))
} | |
c6709 |
if a.Max >= b.Min {
return true
}
return false
} | |
c6710 | s.Max {
return true
}
return false
} | |
c6711 |
return sum == p.ipHdr.ipChecksum
} | |
c6712 | binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
} | |
c6713 |
return sum == p.tcpHdr.tcpChecksum
} | |
c6714 | = p.computeTCPChecksum()
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
} | |
c6715 | buf.WriteString(strconv.Itoa(int(p.DestPort())))
buf.WriteString(" tcpcksum=")
buf.WriteString(fmt.Sprintf("0x%0x", p.tcpHdr.tcpChecksum))
buf.WriteString(" data")
buf.WriteString(hex.EncodeToString(p.GetTCPBytes()))
}
return buf.String()
} | |
c6716 | or not, as this function doesn't change it)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
return sum
} | |
c6717 | csum = partialChecksum(csum, buf[:])
csum = partialChecksum(csum, buffer)
csum = partialChecksum(csum, p.tcpHdr.tcpOptions)
csum = partialChecksum(csum, p.tcpHdr.tcpData)
csum16 := finalizeChecksum(csum)
// restore the checksum
buffer[tcpChecksumPos] = oldCsumLow
buffer[tcpChecksumPos+1] = oldCsumHigh
retu... | |
c6718 | 0xffff) + ((csum >> 16) & 0xffff)
}
csum = csum ^ 0xffff
return uint16(csum)
} | |
c6719 | | uint32(buf[1])
}
if len(buf) > 0 {
sum += uint32(buf[0]) << 8
}
return sum
} | |
c6720 | csumConvert32To16bit(sum32)
csum := ^sum16
return csum
} | |
c6721 |
curLen := uint16(len(buffer))
udpDataLen := curLen - p.GetUDPDataStartBytes()
// update checksum.
binary.BigEndian.PutUint16(buffer[udpChecksumPos:udpChecksumPos+2], p.udpHdr.udpChecksum)
// update length.
binary.BigEndian.PutUint16(buffer[udpLengthPos:udpLengthPos+2], udpDataLen+8)
} | |
c6722 | if len(buffer) <= udpJwtTokenOffset {
return []byte{}
}
return buffer[udpJwtTokenOffset:]
} | |
c6723 | Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLength+packetLenIncrease)
// Attach Data @ the end of current buffer
p.ipHdr.Buffer = append(p.ipHdr.Buffer, udpData...)
p.UpdateUDPChecksum()
} | |
c6724 | Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, uint16(len(p.ipHdr.Buffer)))
p.UpdateUDPChecksum()
} | |
c6725 | Ignore the rest. No need for packet
p.ipHdr.Buffer = p.ipHdr.Buffer[:p.ipHdr.ipHeaderLen+UDPDataPos]
// change the fields
p.ipHdr.sourceAddress = net.IP(p.ipHdr.Buffer[ipv4SourceAddrPos : ipv4SourceAddrPos+4])
p.ipHdr.destinationAddress = destIP
p.udpHdr.sourcePort = p.udpHdr.destinationPort
p.udpHdr.destinati... | |
c6726 | Bit 7 represents encryption. (currently unused).
// Byte 1: reserved for future use.
// Bytes [2:20]: Packet signature.
return GetUDPTypeFromBuffer(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:])
} | |
c6727 | zap.L().Debug("Not an Aporeto control Packet")
return 0
}
// control packet. byte 0 has packet type information.
return marker[0] & UDPPacketMask
} | |
c6728 |
marker := make([]byte, UDPSignatureLen)
// ignore version info as of now.
marker[0] |= packetType // byte 0
marker[1] = 0 // byte 1
// byte 2 - 19
copy(marker[2:], []byte(UDPAuthMarker))
return marker
} | |
c6729 | signMethod,
secrets: s,
tokenCache: cache.NewCacheWithExpiration("JWTTokenCache", time.Millisecond*500),
compressionType: compressionType,
compressionTagLength: claimsheader.CompressionTypeToTagLength(compressionType),
datapathVersion: claimsheader.DatapathVersion1,
}, ... | |
c6730 |
strtoken, err := jwt.NewWithClaims(c.signMethod, allclaims).SignedString(c.secrets.EncodingKey())
if err != nil {
return []byte{}, err
}
// Copy the certificate if needed. Note that we don't send the certificate
// again for Ack packets to reduce overhead
if !isAck {
txKey := c.secrets.TransmittedKey()
... | |
c6731 | small")
}
copy(token[noncePosition:], nonce)
return nil
} | |
c6732 | make([]byte, NonceLength)
copy(nonce, token[noncePosition:tokenPosition])
return nonce, nil
} | |
c6733 | contextID)
} else {
containerInfo.Policy.AddIdentityTag(enforcerconstants.TransmitterLabel, containerInfo.Policy.ManagementID())
}
} | |
c6734 | func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | |
c6735 | func(cfg *cnimonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | |
c6736 | func(cfg *uidmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | |
c6737 | func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | |
c6738 | func(cfg *dockermonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | |
c6739 | {
return func(cfg *dockermonitor.Config) {
cfg.SocketType = socketType
cfg.SocketAddress = socketAddress
}
} | |
c6740 | {
return func(cfg *dockermonitor.Config) {
cfg.KillContainerOnPolicyError = killContainerOnPolicyError
cfg.SyncAtStart = syncAtStart
}
} | |
c6741 | *kubernetesmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | |
c6742 | *kubernetesmonitor.Config) {
cfg.Nodename = nodename
}
} | |
c6743 | *kubernetesmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | |
c6744 | func(cfg *kubernetesmonitor.Config) {
cfg.KubernetesExtractor = extractor
}
} | |
c6745 | func(cfg *kubernetesmonitor.Config) {
cfg.DockerExtractor = extractor
}
} | |
c6746 | *podmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | |
c6747 | *podmonitor.Config) {
cfg.Nodename = nodename
}
} | |
c6748 | *podmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | |
c6749 | func(cfg *podmonitor.Config) {
cfg.MetadataExtractor = extractor
}
} | |
c6750 | func(cfg *podmonitor.Config) {
cfg.NetclsProgrammer = netclsprogrammer
}
} | |
c6751 | *config.MonitorConfig) {
cfg.Common.Collector = c
}
} | |
c6752 | *config.MonitorConfig) {
cfg.Common.Policy = p
}
} | |
c6753 |
}
for _, opt := range opts {
opt(cfg)
}
return cfg
} | |
c6754 | return errors.New("no destination mac given")
}
//Ethernet packet header
p.ethernetLayer = &layers.Ethernet{
SrcMAC: srcMAC,
DstMAC: dstMAC,
EthernetType: layers.EthernetTypeIPv4,
}
return nil
} | |
c6755 | given")
}
//IP packet header
p.ipLayer = &layers.IPv4{
SrcIP: srcIP,
DstIP: dstIP,
Version: 4,
TTL: 64,
Protocol: layers.IPProtocolTCP,
}
return nil
} | |
c6756 | 0,
Ack: 0,
ACK: false,
SYN: false,
FIN: false,
RST: false,
URG: false,
ECE: false,
CWR: false,
NS: false,
PSH: false,
}
return p.tcpLayer.SetNetworkLayerForChecksum(p.ipLayer)
} | |
c6757 | = true
p.tcpLayer.FIN = false
} | |
c6758 |
}
p.tcpLayer.Payload = []byte(newPayload)
return nil
} | |
c6759 | = tcp.Seq
newTCPPacket.Ack = tcp.Ack
newTCPPacket.SYN = tcp.SYN
newTCPPacket.FIN = tcp.FIN
newTCPPacket.RST = tcp.RST
newTCPPacket.PSH = tcp.PSH
newTCPPacket.ACK = tcp.ACK
newTCPPacket.URG = tcp.URG
newTCPPacket.ECE = tcp.ECE
newTCPPacket.CWR = tcp.CWR
newTCPPacket.NS = tcp.NS
newTCPPacket.Checks... | |
c6760 | sIP: sip,
dIP: dip,
sPort: sport,
dPort: dport,
flow: make([]PacketManipulator, 0),
}
return initialTupules
} | |
c6761 | p.flow = append(p.flow, pm)
return p.GetNumPackets()
} | |
c6762 | && p.flow[j].GetTCPAck() == ack && p.flow[j].GetTCPFin() == fin {
packetsInFlow.AppendPacket(p.flow[j])
}
}
return packetsInFlow
} | |
c6763 |
packetsInFlow.AppendPacket(p.flow[j])
if p.flow[j].GetTCPSyn() && p.flow[j].GetTCPAck() && !p.flow[j].GetTCPFin() {
flag = true
}
}
}
return packetsInFlow
} | |
c6764 | 0; i < len(p.flow); i++ {
if index == i {
return p.flow[i]
}
}
panic("Index out of range")
} | |
c6765 | portlist = "0"
} else {
portlist = portlist[:len(portlist)-1]
}
return portlist
} | |
c6766 | make(chan bool),
}
if d.debugChannel == "" {
return nil, errors.New("no path to debug socket provided")
}
if d.secret == "" {
return nil, errors.New("no secret provided for debug channel")
}
return d, nil
} | |
c6767 | syscall.IPPROTO_IP, syscall.IP_HDRINCL, 1); err != nil {
syscall.Close(fd) // nolint
return nil, fmt.Errorf("Received error %s while setting socket Option IP_HDRINCL", err)
}
insock := &syscall.SockaddrInet4{
Port: 0,
}
return &rawsocket{
fd: fd,
insock: insock,
}, nil
} | |
c6768 | nil, nil, nil, nil, nil, 0, nil, nil, []string{})
runtime := NewPURuntime("", 0, "", nil, nil, puType, nil)
return PUInfoFromPolicyAndRuntime(contextID, policy, runtime)
} | |
c6769 | contextID,
Policy: policyInfo,
Runtime: runtimeInfo,
}
} | |
c6770 |
reason: PUNotFound,
err: err,
}
} | |
c6771 |
reason: PUNotUnique,
err: err,
}
} | |
c6772 | puID,
reason: PUCreateFailed,
err: err,
}
} | |
c6773 | puID,
reason: PUAlreadyActivated,
err: err,
}
} | |
c6774 | puID,
reason: PUPolicyPending,
err: err,
}
} | |
c6775 | puID,
reason: PUPolicyEnforcementFailed,
err: err,
}
} | |
c6776 | {
case *Error:
return t.reason == PUNotFound
default:
return false
}
} | |
c6777 | {
case *Error:
return t.reason == PUNotUnique
default:
return false
}
} | |
c6778 | PUCreateFailed
default:
return false
}
} | |
c6779 | PUAlreadyActivated
default:
return false
}
} | |
c6780 | PUPolicyPending
default:
return false
}
} | |
c6781 | PUPolicyEnforcementFailed
default:
return false
}
} | |
c6782 |
c, err := p.ParseCommand(arguments)
if err != nil {
return err
}
return p.ExecuteRequest(c)
} | |
c6783 | != "" {
r.address = address
}
return r
} | |
c6784 | is added since the release_notification comes in this format
// Easier to massage it while creation rather than change at the receiving end depending on event
request := &common.EventInfo{
PUType: puType,
Name: c.ServiceName,
Executable: c.Executable,
Tags: c.L... | |
c6785 |
// Send Stop request
if err := sendRequest(r.address, request); err != nil {
return err
}
// Send destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
} | |
c6786 | eventPUID = c.Cgroup[len(common.TriremeCgroupPath):]
} else {
// Not our Cgroup
return nil
}
request := &common.EventInfo{
PUType: eventType,
PUID: eventPUID,
EventType: common.EventStop,
}
// Send Stop request
if err := sendRequest(r.address, request); err != nil {
return err
}
// Send ... | |
c6787 | DeleteServiceRequest:
return r.DeleteService(c)
default:
return fmt.Errorf("unknown request: %d", c.Request)
}
} | |
c6788 | err := client.NewClient(address)
if err != nil {
return err
}
return client.SendRequest(event)
} | |
c6789 | return nil, fmt.Errorf("Invalid protocol specified. Only tcp/udp accepted")
}
}
s, err := portspec.NewPortSpecFromString(portProtocolPair[0], nil)
if err != nil {
return nil, fmt.Errorf("Invalid port spec: %s ", err)
}
services = append(services, common.Service{
Protocol: uint8(protocol),
Po... | |
c6790 |
if _, err := h.Write(buffer.Bytes()); err != nil {
return []byte{}, err
}
return h.Sum(nil), nil
} | |
c6791 | {
return false
}
return hmac.Equal(messageMAC, expectedMAC)
} | |
c6792 | nil, err
}
s := base64.StdEncoding.EncodeToString(b)
return []byte(s[:n]), nil
} | |
c6793 | return base64.URLEncoding.EncodeToString(b), err
} | |
c6794 |
if !ok {
zap.L().Error("AppendCertsFromPEM failed", zap.ByteString("rootPEM", rootPEM))
return nil
}
return roots
} | |
c6795 | bad pem block: %s", string(keyPEM))
}
// Parse the key
key, err := x509.ParseECPrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return key, nil
} | |
c6796 |
Roots: roots,
}
if _, err := cert.Verify(opts); err != nil {
return nil, err
}
return cert, nil
} | |
c6797 | return nil, nil, nil, err
}
rootCertPool = LoadRootCertificates(caCertPEM)
if rootCertPool == nil {
return nil, nil, nil, errors.New("unable to load root certificate pool")
}
cert, err = LoadAndVerifyCertificate(certPEM, rootCertPool)
if err != nil {
return nil, nil, nil, err
}
return key, cert, rootCe... | |
c6798 | certificate structure
cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return nil, err
}
return cert, nil
} | |
c6799 | {
ret := m.ctrl.Call(m, "NewRPCClient", contextID, channel, rpcSecret)
ret0, _ := ret[0].(error)
return ret0
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.