id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,700 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go | Count | func (m *MockCollector) Count() int {
ret := m.ctrl.Call(m, "Count")
ret0, _ := ret[0].(int)
return ret0
} | go | func (m *MockCollector) Count() int {
ret := m.ctrl.Call(m, "Count")
ret0, _ := ret[0].(int)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCollector",
")",
"Count",
"(",
")",
"int",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"int",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // Count mocks base method
// nolint | [
"Count",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go#L138-L142 |
6,701 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go | Count | func (mr *MockCollectorMockRecorder) Count() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockCollector)(nil).Count))
} | go | func (mr *MockCollectorMockRecorder) Count() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockCollector)(nil).Count))
} | [
"func",
"(",
"mr",
"*",
"MockCollectorMockRecorder",
")",
"Count",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCollector",
")",
"(",
"nil",
")",
".",
"Count",
")",
")",
"\n",
"}"
] | // Count indicates an expected call of Count
// nolint | [
"Count",
"indicates",
"an",
"expected",
"call",
"of",
"Count",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go#L146-L148 |
6,702 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go | GetAllRecords | func (m *MockCollector) GetAllRecords() map[string]*collector.FlowRecord {
ret := m.ctrl.Call(m, "GetAllRecords")
ret0, _ := ret[0].(map[string]*collector.FlowRecord)
return ret0
} | go | func (m *MockCollector) GetAllRecords() map[string]*collector.FlowRecord {
ret := m.ctrl.Call(m, "GetAllRecords")
ret0, _ := ret[0].(map[string]*collector.FlowRecord)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCollector",
")",
"GetAllRecords",
"(",
")",
"map",
"[",
"string",
"]",
"*",
"collector",
".",
"FlowRecord",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"map",
"[",
"string",
"]",
"*",
"collector",
".",
"FlowRecord",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetAllRecords mocks base method
// nolint | [
"GetAllRecords",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go#L152-L156 |
6,703 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go | GetAllDataPathPacketRecords | func (m *MockCollector) GetAllDataPathPacketRecords() []*collector.PacketReport {
ret := m.ctrl.Call(m, "GetAllDataPathPacketRecords")
ret0, _ := ret[0].([]*collector.PacketReport)
return ret0
} | go | func (m *MockCollector) GetAllDataPathPacketRecords() []*collector.PacketReport {
ret := m.ctrl.Call(m, "GetAllDataPathPacketRecords")
ret0, _ := ret[0].([]*collector.PacketReport)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockCollector",
")",
"GetAllDataPathPacketRecords",
"(",
")",
"[",
"]",
"*",
"collector",
".",
"PacketReport",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"[",
"]",
"*",
"collector",
".",
"PacketReport",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // GetAllDataPathPacketRecords mocks base method
// nolint | [
"GetAllDataPathPacketRecords",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go#L192-L196 |
6,704 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go | CollectUserEvent | func (mr *MockCollectorMockRecorder) CollectUserEvent(record interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectUserEvent", reflect.TypeOf((*MockCollector)(nil).CollectUserEvent), record)
} | go | func (mr *MockCollectorMockRecorder) CollectUserEvent(record interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectUserEvent", reflect.TypeOf((*MockCollector)(nil).CollectUserEvent), record)
} | [
"func",
"(",
"mr",
"*",
"MockCollectorMockRecorder",
")",
"CollectUserEvent",
"(",
"record",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCollector",
")",
"(",
"nil",
")",
".",
"CollectUserEvent",
")",
",",
"record",
")",
"\n",
"}"
] | // CollectUserEvent indicates an expected call of CollectUserEvent
// nolint | [
"CollectUserEvent",
"indicates",
"an",
"expected",
"call",
"of",
"CollectUserEvent",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statscollector/mockstatscollector/mockstatscollector.go#L236-L238 |
6,705 | aporeto-inc/trireme-lib | utils/portspec/portspec.go | NewPortSpec | 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 | 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
} | [
"func",
"NewPortSpec",
"(",
"min",
",",
"max",
"uint16",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"*",
"PortSpec",
",",
"error",
")",
"{",
"if",
"min",
">",
"max",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"PortSpec",
"{",
"Min",
":",
"min",
",",
"Max",
":",
"max",
",",
"value",
":",
"value",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewPortSpec creates a new port spec | [
"NewPortSpec",
"creates",
"a",
"new",
"port",
"spec"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portspec/portspec.go#L20-L31 |
6,706 | aporeto-inc/trireme-lib | utils/portspec/portspec.go | NewPortSpecFromString | 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(portMinMax[0])
if err != nil || min < 0 {
return nil, errors.New("Min is not a valid port")
}
max, err = strconv.Atoi(portMinMax[1])
if err != 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)
} | go | 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(portMinMax[0])
if err != nil || min < 0 {
return nil, errors.New("Min is not a valid port")
}
max, err = strconv.Atoi(portMinMax[1])
if err != 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)
} | [
"func",
"NewPortSpecFromString",
"(",
"ports",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"(",
"*",
"PortSpec",
",",
"error",
")",
"{",
"var",
"min",
",",
"max",
"int",
"\n",
"var",
"err",
"error",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"ports",
",",
"\"",
"\"",
")",
"{",
"portMinMax",
":=",
"strings",
".",
"SplitN",
"(",
"ports",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"portMinMax",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"min",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"portMinMax",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"min",
"<",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"max",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"portMinMax",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"max",
">=",
"65536",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"min",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"ports",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"min",
">=",
"65536",
"||",
"min",
"<",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"max",
"=",
"min",
"\n",
"}",
"\n\n",
"return",
"NewPortSpec",
"(",
"uint16",
"(",
"min",
")",
",",
"uint16",
"(",
"max",
")",
",",
"value",
")",
"\n",
"}"
] | // NewPortSpecFromString creates a new port spec | [
"NewPortSpecFromString",
"creates",
"a",
"new",
"port",
"spec"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portspec/portspec.go#L34-L62 |
6,707 | aporeto-inc/trireme-lib | utils/portspec/portspec.go | SinglePort | func (s *PortSpec) SinglePort() (uint16, error) {
if s.IsMultiPort() {
return 0, errors.New("Not a single port specification")
}
return s.Min, nil
} | go | func (s *PortSpec) SinglePort() (uint16, error) {
if s.IsMultiPort() {
return 0, errors.New("Not a single port specification")
}
return s.Min, nil
} | [
"func",
"(",
"s",
"*",
"PortSpec",
")",
"SinglePort",
"(",
")",
"(",
"uint16",
",",
"error",
")",
"{",
"if",
"s",
".",
"IsMultiPort",
"(",
")",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"Min",
",",
"nil",
"\n",
"}"
] | // SinglePort returns the port of a non multi-port spec | [
"SinglePort",
"returns",
"the",
"port",
"of",
"a",
"non",
"multi",
"-",
"port",
"spec"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portspec/portspec.go#L70-L76 |
6,708 | aporeto-inc/trireme-lib | utils/portspec/portspec.go | String | 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 | 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))
} | [
"func",
"(",
"s",
"*",
"PortSpec",
")",
"String",
"(",
")",
"string",
"{",
"if",
"s",
".",
"IsMultiPort",
"(",
")",
"{",
"return",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"s",
".",
"Min",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"s",
".",
"Max",
")",
")",
"\n",
"}",
"\n\n",
"return",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"s",
".",
"Min",
")",
")",
"\n",
"}"
] | // MultiPort returns the multi-port range as a string. | [
"MultiPort",
"returns",
"the",
"multi",
"-",
"port",
"range",
"as",
"a",
"string",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portspec/portspec.go#L84-L90 |
6,709 | aporeto-inc/trireme-lib | utils/portspec/portspec.go | Overlaps | 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 | 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
} | [
"func",
"(",
"s",
"*",
"PortSpec",
")",
"Overlaps",
"(",
"p",
"*",
"PortSpec",
")",
"bool",
"{",
"a",
":=",
"p",
"\n",
"b",
":=",
"s",
"\n",
"if",
"a",
".",
"Min",
">",
"b",
".",
"Min",
"{",
"a",
"=",
"s",
"\n",
"b",
"=",
"p",
"\n",
"}",
"\n",
"if",
"a",
".",
"Max",
">=",
"b",
".",
"Min",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // Overlaps returns true if the provided port spect overlaps with the given one. | [
"Overlaps",
"returns",
"true",
"if",
"the",
"provided",
"port",
"spect",
"overlaps",
"with",
"the",
"given",
"one",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portspec/portspec.go#L98-L109 |
6,710 | aporeto-inc/trireme-lib | utils/portspec/portspec.go | IsIncluded | func (s *PortSpec) IsIncluded(port int) bool {
p := uint16(port)
if s.Min <= p && p <= s.Max {
return true
}
return false
} | go | func (s *PortSpec) IsIncluded(port int) bool {
p := uint16(port)
if s.Min <= p && p <= s.Max {
return true
}
return false
} | [
"func",
"(",
"s",
"*",
"PortSpec",
")",
"IsIncluded",
"(",
"port",
"int",
")",
"bool",
"{",
"p",
":=",
"uint16",
"(",
"port",
")",
"\n",
"if",
"s",
".",
"Min",
"<=",
"p",
"&&",
"p",
"<=",
"s",
".",
"Max",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsIncluded returns trues if a port is within the range of the portspec | [
"IsIncluded",
"returns",
"trues",
"if",
"a",
"port",
"is",
"within",
"the",
"range",
"of",
"the",
"portspec"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/portspec/portspec.go#L112-L118 |
6,711 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | VerifyIPChecksum | func (p *Packet) VerifyIPChecksum() bool {
sum := p.computeIPChecksum()
return sum == p.ipHdr.ipChecksum
} | go | func (p *Packet) VerifyIPChecksum() bool {
sum := p.computeIPChecksum()
return sum == p.ipHdr.ipChecksum
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"VerifyIPChecksum",
"(",
")",
"bool",
"{",
"sum",
":=",
"p",
".",
"computeIPChecksum",
"(",
")",
"\n\n",
"return",
"sum",
"==",
"p",
".",
"ipHdr",
".",
"ipChecksum",
"\n",
"}"
] | // Helpher functions for the package, mainly for debugging and validation
// They are not used by the main package
// VerifyIPChecksum returns true if the IP header checksum is correct
// for this packet, false otherwise. Note that the checksum is not
// modified. | [
"Helpher",
"functions",
"for",
"the",
"package",
"mainly",
"for",
"debugging",
"and",
"validation",
"They",
"are",
"not",
"used",
"by",
"the",
"main",
"package",
"VerifyIPChecksum",
"returns",
"true",
"if",
"the",
"IP",
"header",
"checksum",
"is",
"correct",
"for",
"this",
"packet",
"false",
"otherwise",
".",
"Note",
"that",
"the",
"checksum",
"is",
"not",
"modified",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L21-L26 |
6,712 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | UpdateIPChecksum | func (p *Packet) UpdateIPChecksum() {
p.ipHdr.ipChecksum = p.computeIPChecksum()
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
} | go | func (p *Packet) UpdateIPChecksum() {
p.ipHdr.ipChecksum = p.computeIPChecksum()
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"UpdateIPChecksum",
"(",
")",
"{",
"p",
".",
"ipHdr",
".",
"ipChecksum",
"=",
"p",
".",
"computeIPChecksum",
"(",
")",
"\n\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4ChecksumPos",
":",
"ipv4ChecksumPos",
"+",
"2",
"]",
",",
"p",
".",
"ipHdr",
".",
"ipChecksum",
")",
"\n",
"}"
] | // UpdateIPChecksum computes the IP header checksum and updates the
// packet with the value. | [
"UpdateIPChecksum",
"computes",
"the",
"IP",
"header",
"checksum",
"and",
"updates",
"the",
"packet",
"with",
"the",
"value",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L30-L35 |
6,713 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | VerifyTCPChecksum | func (p *Packet) VerifyTCPChecksum() bool {
sum := p.computeTCPChecksum()
return sum == p.tcpHdr.tcpChecksum
} | go | func (p *Packet) VerifyTCPChecksum() bool {
sum := p.computeTCPChecksum()
return sum == p.tcpHdr.tcpChecksum
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"VerifyTCPChecksum",
"(",
")",
"bool",
"{",
"sum",
":=",
"p",
".",
"computeTCPChecksum",
"(",
")",
"\n\n",
"return",
"sum",
"==",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
"\n",
"}"
] | // VerifyTCPChecksum returns true if the TCP header checksum is correct
// for this packet, false otherwise. Note that the checksum is not
// modified. | [
"VerifyTCPChecksum",
"returns",
"true",
"if",
"the",
"TCP",
"header",
"checksum",
"is",
"correct",
"for",
"this",
"packet",
"false",
"otherwise",
".",
"Note",
"that",
"the",
"checksum",
"is",
"not",
"modified",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L40-L45 |
6,714 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | UpdateTCPChecksum | 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 | 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)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"UpdateTCPChecksum",
"(",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
"=",
"p",
".",
"computeTCPChecksum",
"(",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buffer",
"[",
"tcpChecksumPos",
":",
"tcpChecksumPos",
"+",
"2",
"]",
",",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
")",
"\n",
"}"
] | // UpdateTCPChecksum computes the TCP header checksum and updates the
// packet with the value. | [
"UpdateTCPChecksum",
"computes",
"the",
"TCP",
"header",
"checksum",
"and",
"updates",
"the",
"packet",
"with",
"the",
"value",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L49-L53 |
6,715 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | PacketToStringTCP | 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(" dstport=")
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()
} | go | 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(" dstport=")
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()
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"PacketToStringTCP",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n\n",
"header",
",",
"err",
":=",
"ipv4",
".",
"ParseHeader",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"buf",
".",
"Reset",
"(",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"header",
".",
"String",
"(",
")",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"p",
".",
"SourcePort",
"(",
")",
")",
")",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"p",
".",
"DestPort",
"(",
")",
")",
")",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
")",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"hex",
".",
"EncodeToString",
"(",
"p",
".",
"GetTCPBytes",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | //PacketToStringTCP returns a string representation of fields contained in this packet. | [
"PacketToStringTCP",
"returns",
"a",
"string",
"representation",
"of",
"fields",
"contained",
"in",
"this",
"packet",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L81-L101 |
6,716 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | computeIPChecksum | 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 checksum (whether correct or not, as this function doesn't change it)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
return sum
} | go | 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 checksum (whether correct or not, as this function doesn't change it)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
return sum
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"computeIPChecksum",
"(",
")",
"uint16",
"{",
"// IP packet checksum is computed with the checksum value set to zero",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4ChecksumPos",
"]",
"=",
"0",
"\n",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4ChecksumPos",
"+",
"1",
"]",
"=",
"0",
"\n\n",
"// Compute checksum, over IP header only",
"sum",
":=",
"checksum",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
":",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
"]",
")",
"\n\n",
"// Restore the previous checksum (whether correct or not, as this function doesn't change it)",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4ChecksumPos",
":",
"ipv4ChecksumPos",
"+",
"2",
"]",
",",
"p",
".",
"ipHdr",
".",
"ipChecksum",
")",
"\n\n",
"return",
"sum",
"\n",
"}"
] | // Computes the IP header checksum. The packet is not modified. | [
"Computes",
"the",
"IP",
"header",
"checksum",
".",
"The",
"packet",
"is",
"not",
"modified",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L104-L117 |
6,717 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | computeTCPChecksum | 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 will reset it back after the checksum
buffer[tcpChecksumPos] = 0
buffer[tcpChecksumPos+1] = 0
csum := partialChecksum(0, p.ipHdr.Buffer[ipv4SourceAddrPos:ipv4SourceAddrPos+4])
csum = partialChecksum(csum, p.ipHdr.Buffer[ipv4DestAddrPos:ipv4DestAddrPos+4])
// reserved 0 byte
buf[0] = 0
// tcp option 6
buf[1] = 6
csum = partialChecksum(csum, buf[:])
binary.BigEndian.PutUint16(buf[:], tcpBufSize)
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
return csum16
} | go | 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 will reset it back after the checksum
buffer[tcpChecksumPos] = 0
buffer[tcpChecksumPos+1] = 0
csum := partialChecksum(0, p.ipHdr.Buffer[ipv4SourceAddrPos:ipv4SourceAddrPos+4])
csum = partialChecksum(csum, p.ipHdr.Buffer[ipv4DestAddrPos:ipv4DestAddrPos+4])
// reserved 0 byte
buf[0] = 0
// tcp option 6
buf[1] = 6
csum = partialChecksum(csum, buf[:])
binary.BigEndian.PutUint16(buf[:], tcpBufSize)
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
return csum16
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"computeTCPChecksum",
"(",
")",
"uint16",
"{",
"var",
"buf",
"[",
"2",
"]",
"byte",
"\n",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"tcpBufSize",
":=",
"uint16",
"(",
"len",
"(",
"buffer",
")",
"+",
"len",
"(",
"p",
".",
"tcpHdr",
".",
"tcpData",
")",
"+",
"len",
"(",
"p",
".",
"tcpHdr",
".",
"tcpOptions",
")",
")",
"\n\n",
"oldCsumLow",
":=",
"buffer",
"[",
"tcpChecksumPos",
"]",
"\n",
"oldCsumHigh",
":=",
"buffer",
"[",
"tcpChecksumPos",
"+",
"1",
"]",
"\n\n",
"// Put 0 to calculate the checksum. We will reset it back after the checksum",
"buffer",
"[",
"tcpChecksumPos",
"]",
"=",
"0",
"\n",
"buffer",
"[",
"tcpChecksumPos",
"+",
"1",
"]",
"=",
"0",
"\n\n",
"csum",
":=",
"partialChecksum",
"(",
"0",
",",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4SourceAddrPos",
":",
"ipv4SourceAddrPos",
"+",
"4",
"]",
")",
"\n",
"csum",
"=",
"partialChecksum",
"(",
"csum",
",",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4DestAddrPos",
":",
"ipv4DestAddrPos",
"+",
"4",
"]",
")",
"\n\n",
"// reserved 0 byte",
"buf",
"[",
"0",
"]",
"=",
"0",
"\n",
"// tcp option 6",
"buf",
"[",
"1",
"]",
"=",
"6",
"\n\n",
"csum",
"=",
"partialChecksum",
"(",
"csum",
",",
"buf",
"[",
":",
"]",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buf",
"[",
":",
"]",
",",
"tcpBufSize",
")",
"\n",
"csum",
"=",
"partialChecksum",
"(",
"csum",
",",
"buf",
"[",
":",
"]",
")",
"\n\n",
"csum",
"=",
"partialChecksum",
"(",
"csum",
",",
"buffer",
")",
"\n",
"csum",
"=",
"partialChecksum",
"(",
"csum",
",",
"p",
".",
"tcpHdr",
".",
"tcpOptions",
")",
"\n",
"csum",
"=",
"partialChecksum",
"(",
"csum",
",",
"p",
".",
"tcpHdr",
".",
"tcpData",
")",
"\n\n",
"csum16",
":=",
"finalizeChecksum",
"(",
"csum",
")",
"\n\n",
"// restore the checksum",
"buffer",
"[",
"tcpChecksumPos",
"]",
"=",
"oldCsumLow",
"\n",
"buffer",
"[",
"tcpChecksumPos",
"+",
"1",
"]",
"=",
"oldCsumHigh",
"\n\n",
"return",
"csum16",
"\n",
"}"
] | // Computes the TCP header checksum. The packet is not modified. | [
"Computes",
"the",
"TCP",
"header",
"checksum",
".",
"The",
"packet",
"is",
"not",
"modified",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L120-L155 |
6,718 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | incCsum16 | 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 | 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)
} | [
"func",
"incCsum16",
"(",
"start",
",",
"old",
",",
"new",
"uint16",
")",
"uint16",
"{",
"start",
"=",
"start",
"^",
"0xffff",
"\n",
"old",
"=",
"old",
"^",
"0xffff",
"\n\n",
"csum",
":=",
"uint32",
"(",
"start",
")",
"+",
"uint32",
"(",
"old",
")",
"+",
"uint32",
"(",
"new",
")",
"\n",
"for",
"(",
"csum",
">>",
"16",
")",
">",
"0",
"{",
"csum",
"=",
"(",
"csum",
"&",
"0xffff",
")",
"+",
"(",
"(",
"csum",
">>",
"16",
")",
"&",
"0xffff",
")",
"\n",
"}",
"\n",
"csum",
"=",
"csum",
"^",
"0xffff",
"\n",
"return",
"uint16",
"(",
"csum",
")",
"\n",
"}"
] | // incCsum16 implements rfc1624, equation 3. | [
"incCsum16",
"implements",
"rfc1624",
"equation",
"3",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L158-L169 |
6,719 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | checksumDelta | 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 | 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
} | [
"func",
"checksumDelta",
"(",
"init",
"uint32",
",",
"buf",
"[",
"]",
"byte",
")",
"uint32",
"{",
"sum",
":=",
"init",
"\n\n",
"for",
";",
"len",
"(",
"buf",
")",
">=",
"2",
";",
"buf",
"=",
"buf",
"[",
"2",
":",
"]",
"{",
"sum",
"+=",
"uint32",
"(",
"buf",
"[",
"0",
"]",
")",
"<<",
"8",
"|",
"uint32",
"(",
"buf",
"[",
"1",
"]",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"buf",
")",
">",
"0",
"{",
"sum",
"+=",
"uint32",
"(",
"buf",
"[",
"0",
"]",
")",
"<<",
"8",
"\n",
"}",
"\n\n",
"return",
"sum",
"\n",
"}"
] | // Computes a sum of 16 bit numbers | [
"Computes",
"a",
"sum",
"of",
"16",
"bit",
"numbers"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L180-L193 |
6,720 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | checksum | func checksum(buf []byte) uint16 {
sum32 := checksumDelta(0, buf)
sum16 := csumConvert32To16bit(sum32)
csum := ^sum16
return csum
} | go | func checksum(buf []byte) uint16 {
sum32 := checksumDelta(0, buf)
sum16 := csumConvert32To16bit(sum32)
csum := ^sum16
return csum
} | [
"func",
"checksum",
"(",
"buf",
"[",
"]",
"byte",
")",
"uint16",
"{",
"sum32",
":=",
"checksumDelta",
"(",
"0",
",",
"buf",
")",
"\n",
"sum16",
":=",
"csumConvert32To16bit",
"(",
"sum32",
")",
"\n\n",
"csum",
":=",
"^",
"sum16",
"\n",
"return",
"csum",
"\n",
"}"
] | // Computes a checksum over the given slice. | [
"Computes",
"a",
"checksum",
"over",
"the",
"given",
"slice",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L196-L202 |
6,721 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | UpdateUDPChecksum | 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()
// update checksum.
binary.BigEndian.PutUint16(buffer[udpChecksumPos:udpChecksumPos+2], p.udpHdr.udpChecksum)
// update length.
binary.BigEndian.PutUint16(buffer[udpLengthPos:udpLengthPos+2], udpDataLen+8)
} | go | 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()
// update checksum.
binary.BigEndian.PutUint16(buffer[udpChecksumPos:udpChecksumPos+2], p.udpHdr.udpChecksum)
// update length.
binary.BigEndian.PutUint16(buffer[udpLengthPos:udpLengthPos+2], udpDataLen+8)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"UpdateUDPChecksum",
"(",
")",
"{",
"// checksum set to 0, ignored by the stack",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"ignoreCheckSum",
":=",
"[",
"]",
"byte",
"{",
"0",
",",
"0",
"}",
"\n",
"p",
".",
"udpHdr",
".",
"udpChecksum",
"=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"ignoreCheckSum",
"[",
":",
"]",
")",
"\n\n",
"curLen",
":=",
"uint16",
"(",
"len",
"(",
"buffer",
")",
")",
"\n",
"udpDataLen",
":=",
"curLen",
"-",
"p",
".",
"GetUDPDataStartBytes",
"(",
")",
"\n\n",
"// update checksum.",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buffer",
"[",
"udpChecksumPos",
":",
"udpChecksumPos",
"+",
"2",
"]",
",",
"p",
".",
"udpHdr",
".",
"udpChecksum",
")",
"\n",
"// update length.",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buffer",
"[",
"udpLengthPos",
":",
"udpLengthPos",
"+",
"2",
"]",
",",
"udpDataLen",
"+",
"8",
")",
"\n",
"}"
] | // UpdateUDPChecksum updates the UDP checksum field of packet | [
"UpdateUDPChecksum",
"updates",
"the",
"UDP",
"checksum",
"field",
"of",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L216-L230 |
6,722 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | ReadUDPToken | 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 | 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:]
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"ReadUDPToken",
"(",
")",
"[",
"]",
"byte",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"// 8 byte udp header, 20 byte udp marker",
"if",
"len",
"(",
"buffer",
")",
"<=",
"udpJwtTokenOffset",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
"\n",
"}",
"\n",
"return",
"buffer",
"[",
"udpJwtTokenOffset",
":",
"]",
"\n",
"}"
] | // ReadUDPToken returnthe UDP token. Gets called only during the handshake process. | [
"ReadUDPToken",
"returnthe",
"UDP",
"token",
".",
"Gets",
"called",
"only",
"during",
"the",
"handshake",
"process",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L233-L240 |
6,723 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | UDPTokenAttach | 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.ipTotalLength+packetLenIncrease)
// Attach Data @ the end of current buffer
p.ipHdr.Buffer = append(p.ipHdr.Buffer, udpData...)
p.UpdateUDPChecksum()
} | go | 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.ipTotalLength+packetLenIncrease)
// Attach Data @ the end of current buffer
p.ipHdr.Buffer = append(p.ipHdr.Buffer, udpData...)
p.UpdateUDPChecksum()
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"UDPTokenAttach",
"(",
"udpdata",
"[",
"]",
"byte",
",",
"udptoken",
"[",
"]",
"byte",
")",
"{",
"udpData",
":=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"udpData",
"=",
"append",
"(",
"udpData",
",",
"udpdata",
"...",
")",
"\n",
"udpData",
"=",
"append",
"(",
"udpData",
",",
"udptoken",
"...",
")",
"\n\n",
"packetLenIncrease",
":=",
"uint16",
"(",
"len",
"(",
"udpdata",
")",
"+",
"len",
"(",
"udptoken",
")",
")",
"\n\n",
"// IP Header Processing",
"p",
".",
"FixupIPHdrOnDataModify",
"(",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
",",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
"+",
"packetLenIncrease",
")",
"\n\n",
"// Attach Data @ the end of current buffer",
"p",
".",
"ipHdr",
".",
"Buffer",
"=",
"append",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
",",
"udpData",
"...",
")",
"\n\n",
"p",
".",
"UpdateUDPChecksum",
"(",
")",
"\n",
"}"
] | // UDPTokenAttach attached udp packet signature and tokens. | [
"UDPTokenAttach",
"attached",
"udp",
"packet",
"signature",
"and",
"tokens",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L243-L258 |
6,724 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | UDPDataAttach | 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.UpdateUDPChecksum()
} | go | 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.UpdateUDPChecksum()
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"UDPDataAttach",
"(",
"header",
",",
"udpdata",
"[",
"]",
"byte",
")",
"{",
"// Attach Data @ the end of current buffer",
"p",
".",
"ipHdr",
".",
"Buffer",
"=",
"append",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
",",
"header",
"...",
")",
"\n",
"p",
".",
"ipHdr",
".",
"Buffer",
"=",
"append",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
",",
"udpdata",
"...",
")",
"\n",
"// IP Header Processing",
"p",
".",
"FixupIPHdrOnDataModify",
"(",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
",",
"uint16",
"(",
"len",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
")",
")",
")",
"\n",
"p",
".",
"UpdateUDPChecksum",
"(",
")",
"\n",
"}"
] | // UDPDataAttach Attaches UDP data post encryption. | [
"UDPDataAttach",
"Attaches",
"UDP",
"data",
"post",
"encryption",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L261-L269 |
6,725 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | CreateReverseFlowPacket | 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.Buffer[ipv4SourceAddrPos:ipv4SourceAddrPos+4], destAddr)
binary.BigEndian.PutUint32(p.ipHdr.Buffer[ipv4DestAddrPos:ipv4DestAddrPos+4], srcAddr)
binary.BigEndian.PutUint16(buffer[udpSourcePortPos:udpSourcePortPos+2], p.udpHdr.destinationPort)
binary.BigEndian.PutUint16(buffer[udpDestPortPos:udpDestPortPos+2], destPort)
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, uint16(p.ipHdr.ipHeaderLen+UDPDataPos))
// Just get the IP/UDP header. 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.destinationPort = destPort
p.UpdateIPChecksum()
p.UpdateUDPChecksum()
} | go | 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.Buffer[ipv4SourceAddrPos:ipv4SourceAddrPos+4], destAddr)
binary.BigEndian.PutUint32(p.ipHdr.Buffer[ipv4DestAddrPos:ipv4DestAddrPos+4], srcAddr)
binary.BigEndian.PutUint16(buffer[udpSourcePortPos:udpSourcePortPos+2], p.udpHdr.destinationPort)
binary.BigEndian.PutUint16(buffer[udpDestPortPos:udpDestPortPos+2], destPort)
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, uint16(p.ipHdr.ipHeaderLen+UDPDataPos))
// Just get the IP/UDP header. 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.destinationPort = destPort
p.UpdateIPChecksum()
p.UpdateUDPChecksum()
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"CreateReverseFlowPacket",
"(",
"destIP",
"net",
".",
"IP",
",",
"destPort",
"uint16",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n\n",
"srcAddr",
":=",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"destIP",
".",
"To4",
"(",
")",
")",
"\n",
"destAddr",
":=",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4DestAddrPos",
":",
"ipv4DestAddrPos",
"+",
"4",
"]",
")",
"\n\n",
"// copy the fields",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4SourceAddrPos",
":",
"ipv4SourceAddrPos",
"+",
"4",
"]",
",",
"destAddr",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4DestAddrPos",
":",
"ipv4DestAddrPos",
"+",
"4",
"]",
",",
"srcAddr",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buffer",
"[",
"udpSourcePortPos",
":",
"udpSourcePortPos",
"+",
"2",
"]",
",",
"p",
".",
"udpHdr",
".",
"destinationPort",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buffer",
"[",
"udpDestPortPos",
":",
"udpDestPortPos",
"+",
"2",
"]",
",",
"destPort",
")",
"\n\n",
"p",
".",
"FixupIPHdrOnDataModify",
"(",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
",",
"uint16",
"(",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
"+",
"UDPDataPos",
")",
")",
"\n\n",
"// Just get the IP/UDP header. Ignore the rest. No need for packet",
"p",
".",
"ipHdr",
".",
"Buffer",
"=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
":",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
"+",
"UDPDataPos",
"]",
"\n\n",
"// change the fields",
"p",
".",
"ipHdr",
".",
"sourceAddress",
"=",
"net",
".",
"IP",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4SourceAddrPos",
":",
"ipv4SourceAddrPos",
"+",
"4",
"]",
")",
"\n",
"p",
".",
"ipHdr",
".",
"destinationAddress",
"=",
"destIP",
"\n\n",
"p",
".",
"udpHdr",
".",
"sourcePort",
"=",
"p",
".",
"udpHdr",
".",
"destinationPort",
"\n",
"p",
".",
"udpHdr",
".",
"destinationPort",
"=",
"destPort",
"\n\n",
"p",
".",
"UpdateIPChecksum",
"(",
")",
"\n",
"p",
".",
"UpdateUDPChecksum",
"(",
")",
"\n",
"}"
] | // CreateReverseFlowPacket modifies the packet for reverse flow. | [
"CreateReverseFlowPacket",
"modifies",
"the",
"packet",
"for",
"reverse",
"flow",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L278-L304 |
6,726 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | GetUDPType | 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,
// 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:])
} | go | 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,
// 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:])
} | [
"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,",
"// 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",
":",
"]",
")",
"\n",
"}"
] | // GetUDPType returns udp type of packet. | [
"GetUDPType",
"returns",
"udp",
"type",
"of",
"packet",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L307-L317 |
6,727 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | GetUDPTypeFromBuffer | 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 Packet")
return 0
}
// control packet. byte 0 has packet type information.
return marker[0] & UDPPacketMask
} | go | 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 Packet")
return 0
}
// control packet. byte 0 has packet type information.
return marker[0] & UDPPacketMask
} | [
"func",
"GetUDPTypeFromBuffer",
"(",
"buffer",
"[",
"]",
"byte",
")",
"byte",
"{",
"if",
"len",
"(",
"buffer",
")",
"<",
"(",
"UDPDataPos",
"+",
"UDPSignatureLen",
")",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"marker",
":=",
"buffer",
"[",
"UDPDataPos",
":",
"udpSignatureEnd",
"]",
"\n\n",
"// check for packet signature.",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"buffer",
"[",
"udpAuthMarkerOffset",
":",
"udpSignatureEnd",
"]",
",",
"[",
"]",
"byte",
"(",
"UDPAuthMarker",
")",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"0",
"\n",
"}",
"\n",
"// control packet. byte 0 has packet type information.",
"return",
"marker",
"[",
"0",
"]",
"&",
"UDPPacketMask",
"\n",
"}"
] | // GetUDPTypeFromBuffer gets the UDP packet from a raw buffer., | [
"GetUDPTypeFromBuffer",
"gets",
"the",
"UDP",
"packet",
"from",
"a",
"raw",
"buffer",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L320-L334 |
6,728 | aporeto-inc/trireme-lib | controller/pkg/packet/helpers.go | CreateUDPAuthMarker | 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 packet type,
// Byte 1: reserved for future use.
// Bytes [2:20]: Packet signature.
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
} | go | 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 packet type,
// Byte 1: reserved for future use.
// Bytes [2:20]: Packet signature.
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
} | [
"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 packet type,",
"// Byte 1: reserved for future use.",
"// Bytes [2:20]: Packet signature.",
"marker",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"UDPSignatureLen",
")",
"\n",
"// ignore version info as of now.",
"marker",
"[",
"0",
"]",
"|=",
"packetType",
"// byte 0",
"\n",
"marker",
"[",
"1",
"]",
"=",
"0",
"// byte 1",
"\n",
"// byte 2 - 19",
"copy",
"(",
"marker",
"[",
"2",
":",
"]",
",",
"[",
"]",
"byte",
"(",
"UDPAuthMarker",
")",
")",
"\n\n",
"return",
"marker",
"\n",
"}"
] | // CreateUDPAuthMarker creates a UDP auth marker. | [
"CreateUDPAuthMarker",
"creates",
"a",
"UDP",
"auth",
"marker",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/helpers.go#L347-L365 |
6,729 | aporeto-inc/trireme-lib | controller/pkg/tokens/jwt.go | NewJWT | 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.SigningMethod
compressionType := claimsheader.CompressionTypeNone
if s == nil {
return nil, errors.New("secrets can not be nil")
}
switch s.Type() {
case secrets.PKICompactType:
signMethod = jwt.SigningMethodES256
compressionType = s.(*secrets.CompactPKI).Compressed
default:
signMethod = jwt.SigningMethodNone
}
return &JWTConfig{
ValidityPeriod: validity,
Issuer: issuer,
signMethod: signMethod,
secrets: s,
tokenCache: cache.NewCacheWithExpiration("JWTTokenCache", time.Millisecond*500),
compressionType: compressionType,
compressionTagLength: claimsheader.CompressionTypeToTagLength(compressionType),
datapathVersion: claimsheader.DatapathVersion1,
}, nil
} | go | 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.SigningMethod
compressionType := claimsheader.CompressionTypeNone
if s == nil {
return nil, errors.New("secrets can not be nil")
}
switch s.Type() {
case secrets.PKICompactType:
signMethod = jwt.SigningMethodES256
compressionType = s.(*secrets.CompactPKI).Compressed
default:
signMethod = jwt.SigningMethodNone
}
return &JWTConfig{
ValidityPeriod: validity,
Issuer: issuer,
signMethod: signMethod,
secrets: s,
tokenCache: cache.NewCacheWithExpiration("JWTTokenCache", time.Millisecond*500),
compressionType: compressionType,
compressionTagLength: claimsheader.CompressionTypeToTagLength(compressionType),
datapathVersion: claimsheader.DatapathVersion1,
}, nil
} | [
"func",
"NewJWT",
"(",
"validity",
"time",
".",
"Duration",
",",
"issuer",
"string",
",",
"s",
"secrets",
".",
"Secrets",
")",
"(",
"*",
"JWTConfig",
",",
"error",
")",
"{",
"if",
"len",
"(",
"issuer",
")",
">",
"MaxServerName",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"MaxServerName",
",",
"issuer",
")",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"len",
"(",
"issuer",
")",
";",
"i",
"<",
"MaxServerName",
";",
"i",
"++",
"{",
"issuer",
"=",
"issuer",
"+",
"\"",
"\"",
"\n",
"}",
"\n\n",
"var",
"signMethod",
"jwt",
".",
"SigningMethod",
"\n",
"compressionType",
":=",
"claimsheader",
".",
"CompressionTypeNone",
"\n\n",
"if",
"s",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"s",
".",
"Type",
"(",
")",
"{",
"case",
"secrets",
".",
"PKICompactType",
":",
"signMethod",
"=",
"jwt",
".",
"SigningMethodES256",
"\n",
"compressionType",
"=",
"s",
".",
"(",
"*",
"secrets",
".",
"CompactPKI",
")",
".",
"Compressed",
"\n",
"default",
":",
"signMethod",
"=",
"jwt",
".",
"SigningMethodNone",
"\n",
"}",
"\n\n",
"return",
"&",
"JWTConfig",
"{",
"ValidityPeriod",
":",
"validity",
",",
"Issuer",
":",
"issuer",
",",
"signMethod",
":",
"signMethod",
",",
"secrets",
":",
"s",
",",
"tokenCache",
":",
"cache",
".",
"NewCacheWithExpiration",
"(",
"\"",
"\"",
",",
"time",
".",
"Millisecond",
"*",
"500",
")",
",",
"compressionType",
":",
"compressionType",
",",
"compressionTagLength",
":",
"claimsheader",
".",
"CompressionTypeToTagLength",
"(",
"compressionType",
")",
",",
"datapathVersion",
":",
"claimsheader",
".",
"DatapathVersion1",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewJWT creates a new JWT token processor | [
"NewJWT",
"creates",
"a",
"new",
"JWT",
"token",
"processor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/tokens/jwt.go#L54-L89 |
6,730 | aporeto-inc/trireme-lib | controller/pkg/tokens/jwt.go | CreateAndSign | 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).Unix(),
},
}
// For backward compatibility, keep the issuer in Ack packets.
if isAck {
allclaims.Issuer = c.Issuer
}
if !isAck {
zap.L().Debug("claims", zap.Reflect("all", allclaims), zap.String("type", string(c.compressionType)))
// Handling compression here. If we need to use compression, we will copy
// the claims to the C claim and remove all the other fields.
if c.compressionType != claimsheader.CompressionTypeNone {
tags := allclaims.T
allclaims.T = nil
for _, t := range tags.Tags {
if strings.HasPrefix(t, enforcerconstants.TransmitterLabel) {
claims.ID = t[len(enforcerconstants.TransmitterLabel)+1:]
} else {
claims.C = t
}
}
zap.L().Debug("claims (post)", zap.Reflect("all", allclaims))
}
}
// Set the appropriate claims header
claimsHeader.SetCompressionType(c.compressionType)
claimsHeader.SetDatapathVersion(c.datapathVersion)
claims.H = claimsHeader.ToBytes()
// Create the token and sign with our key
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()
totalLength := len(strtoken) + len(txKey) + noncePosition + NonceLength + 1
token := make([]byte, totalLength)
// Offset of public key
binary.BigEndian.PutUint16(token[0:noncePosition], uint16(len(strtoken)))
// Attach the nonse
copy(token[noncePosition:], nonce)
// Copy the JWT tokenn
copy(token[tokenPosition:], []byte(strtoken))
token[tokenPosition+len(strtoken)] = '%'
// Copy the public key
if len(txKey) > 0 {
copy(token[tokenPosition+len(strtoken)+1:], txKey)
}
return token, nil
}
return []byte(strtoken), nil
} | go | 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).Unix(),
},
}
// For backward compatibility, keep the issuer in Ack packets.
if isAck {
allclaims.Issuer = c.Issuer
}
if !isAck {
zap.L().Debug("claims", zap.Reflect("all", allclaims), zap.String("type", string(c.compressionType)))
// Handling compression here. If we need to use compression, we will copy
// the claims to the C claim and remove all the other fields.
if c.compressionType != claimsheader.CompressionTypeNone {
tags := allclaims.T
allclaims.T = nil
for _, t := range tags.Tags {
if strings.HasPrefix(t, enforcerconstants.TransmitterLabel) {
claims.ID = t[len(enforcerconstants.TransmitterLabel)+1:]
} else {
claims.C = t
}
}
zap.L().Debug("claims (post)", zap.Reflect("all", allclaims))
}
}
// Set the appropriate claims header
claimsHeader.SetCompressionType(c.compressionType)
claimsHeader.SetDatapathVersion(c.datapathVersion)
claims.H = claimsHeader.ToBytes()
// Create the token and sign with our key
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()
totalLength := len(strtoken) + len(txKey) + noncePosition + NonceLength + 1
token := make([]byte, totalLength)
// Offset of public key
binary.BigEndian.PutUint16(token[0:noncePosition], uint16(len(strtoken)))
// Attach the nonse
copy(token[noncePosition:], nonce)
// Copy the JWT tokenn
copy(token[tokenPosition:], []byte(strtoken))
token[tokenPosition+len(strtoken)] = '%'
// Copy the public key
if len(txKey) > 0 {
copy(token[tokenPosition+len(strtoken)+1:], txKey)
}
return token, nil
}
return []byte(strtoken), nil
} | [
"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",
")",
".",
"Unix",
"(",
")",
",",
"}",
",",
"}",
"\n\n",
"// For backward compatibility, keep the issuer in Ack packets.",
"if",
"isAck",
"{",
"allclaims",
".",
"Issuer",
"=",
"c",
".",
"Issuer",
"\n",
"}",
"\n\n",
"if",
"!",
"isAck",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Reflect",
"(",
"\"",
"\"",
",",
"allclaims",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"string",
"(",
"c",
".",
"compressionType",
")",
")",
")",
"\n\n",
"// Handling compression here. If we need to use compression, we will copy",
"// the claims to the C claim and remove all the other fields.",
"if",
"c",
".",
"compressionType",
"!=",
"claimsheader",
".",
"CompressionTypeNone",
"{",
"tags",
":=",
"allclaims",
".",
"T",
"\n",
"allclaims",
".",
"T",
"=",
"nil",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"tags",
".",
"Tags",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"t",
",",
"enforcerconstants",
".",
"TransmitterLabel",
")",
"{",
"claims",
".",
"ID",
"=",
"t",
"[",
"len",
"(",
"enforcerconstants",
".",
"TransmitterLabel",
")",
"+",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"claims",
".",
"C",
"=",
"t",
"\n",
"}",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Reflect",
"(",
"\"",
"\"",
",",
"allclaims",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Set the appropriate claims header",
"claimsHeader",
".",
"SetCompressionType",
"(",
"c",
".",
"compressionType",
")",
"\n",
"claimsHeader",
".",
"SetDatapathVersion",
"(",
"c",
".",
"datapathVersion",
")",
"\n",
"claims",
".",
"H",
"=",
"claimsHeader",
".",
"ToBytes",
"(",
")",
"\n\n",
"// Create the token and sign with our key",
"strtoken",
",",
"err",
":=",
"jwt",
".",
"NewWithClaims",
"(",
"c",
".",
"signMethod",
",",
"allclaims",
")",
".",
"SignedString",
"(",
"c",
".",
"secrets",
".",
"EncodingKey",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
"\n\n",
"totalLength",
":=",
"len",
"(",
"strtoken",
")",
"+",
"len",
"(",
"txKey",
")",
"+",
"noncePosition",
"+",
"NonceLength",
"+",
"1",
"\n\n",
"token",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"totalLength",
")",
"\n\n",
"// Offset of public key",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"token",
"[",
"0",
":",
"noncePosition",
"]",
",",
"uint16",
"(",
"len",
"(",
"strtoken",
")",
")",
")",
"\n\n",
"// Attach the nonse",
"copy",
"(",
"token",
"[",
"noncePosition",
":",
"]",
",",
"nonce",
")",
"\n\n",
"// Copy the JWT tokenn",
"copy",
"(",
"token",
"[",
"tokenPosition",
":",
"]",
",",
"[",
"]",
"byte",
"(",
"strtoken",
")",
")",
"\n\n",
"token",
"[",
"tokenPosition",
"+",
"len",
"(",
"strtoken",
")",
"]",
"=",
"'%'",
"\n",
"// Copy the public key",
"if",
"len",
"(",
"txKey",
")",
">",
"0",
"{",
"copy",
"(",
"token",
"[",
"tokenPosition",
"+",
"len",
"(",
"strtoken",
")",
"+",
"1",
":",
"]",
",",
"txKey",
")",
"\n",
"}",
"\n\n",
"return",
"token",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"[",
"]",
"byte",
"(",
"strtoken",
")",
",",
"nil",
"\n\n",
"}"
] | // CreateAndSign creates a new token, attaches an ephemeral key pair and signs with the issuer
// key. It also randomizes the source nonce of the token. It returns back the token and the private key. | [
"CreateAndSign",
"creates",
"a",
"new",
"token",
"attaches",
"an",
"ephemeral",
"key",
"pair",
"and",
"signs",
"with",
"the",
"issuer",
"key",
".",
"It",
"also",
"randomizes",
"the",
"source",
"nonce",
"of",
"the",
"token",
".",
"It",
"returns",
"back",
"the",
"token",
"and",
"the",
"private",
"key",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/tokens/jwt.go#L93-L170 |
6,731 | aporeto-inc/trireme-lib | controller/pkg/tokens/jwt.go | Randomize | 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 | 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
} | [
"func",
"(",
"c",
"*",
"JWTConfig",
")",
"Randomize",
"(",
"token",
"[",
"]",
"byte",
",",
"nonce",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"token",
")",
"<",
"tokenPosition",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"copy",
"(",
"token",
"[",
"noncePosition",
":",
"]",
",",
"nonce",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Randomize adds a nonce to an existing token. Returns the nonce | [
"Randomize",
"adds",
"a",
"nonce",
"to",
"an",
"existing",
"token",
".",
"Returns",
"the",
"nonce"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/tokens/jwt.go#L286-L295 |
6,732 | aporeto-inc/trireme-lib | controller/pkg/tokens/jwt.go | RetrieveNonce | 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 | 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
} | [
"func",
"(",
"c",
"*",
"JWTConfig",
")",
"RetrieveNonce",
"(",
"token",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"token",
")",
"<",
"tokenPosition",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"nonce",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"NonceLength",
")",
"\n",
"copy",
"(",
"nonce",
",",
"token",
"[",
"noncePosition",
":",
"tokenPosition",
"]",
")",
"\n\n",
"return",
"nonce",
",",
"nil",
"\n",
"}"
] | // RetrieveNonce returns the nonce of a token. It copies the value | [
"RetrieveNonce",
"returns",
"the",
"nonce",
"of",
"a",
"token",
".",
"It",
"copies",
"the",
"value"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/tokens/jwt.go#L298-L308 |
6,733 | aporeto-inc/trireme-lib | controller/helpers.go | addTransmitterLabel | 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.ManagementID())
}
} | go | 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.ManagementID())
}
} | [
"func",
"addTransmitterLabel",
"(",
"contextID",
"string",
",",
"containerInfo",
"*",
"policy",
".",
"PUInfo",
")",
"{",
"if",
"containerInfo",
".",
"Policy",
".",
"ManagementID",
"(",
")",
"==",
"\"",
"\"",
"{",
"containerInfo",
".",
"Policy",
".",
"AddIdentityTag",
"(",
"enforcerconstants",
".",
"TransmitterLabel",
",",
"contextID",
")",
"\n",
"}",
"else",
"{",
"containerInfo",
".",
"Policy",
".",
"AddIdentityTag",
"(",
"enforcerconstants",
".",
"TransmitterLabel",
",",
"containerInfo",
".",
"Policy",
".",
"ManagementID",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // addTransmitterLabel adds the enforcerconstants.TransmitterLabel as a fixed label in the policy.
// The ManagementID part of the policy is used as the enforcerconstants.TransmitterLabel.
// If the Policy didn't set the ManagementID, we use the Local contextID as the
// default enforcerconstants.TransmitterLabel. | [
"addTransmitterLabel",
"adds",
"the",
"enforcerconstants",
".",
"TransmitterLabel",
"as",
"a",
"fixed",
"label",
"in",
"the",
"policy",
".",
"The",
"ManagementID",
"part",
"of",
"the",
"policy",
"is",
"used",
"as",
"the",
"enforcerconstants",
".",
"TransmitterLabel",
".",
"If",
"the",
"Policy",
"didn",
"t",
"set",
"the",
"ManagementID",
"we",
"use",
"the",
"Local",
"contextID",
"as",
"the",
"default",
"enforcerconstants",
".",
"TransmitterLabel",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/helpers.go#L21-L28 |
6,734 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorLinuxExtractor | func SubOptionMonitorLinuxExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | func SubOptionMonitorLinuxExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | [
"func",
"SubOptionMonitorLinuxExtractor",
"(",
"extractor",
"extractors",
".",
"EventMetadataExtractor",
")",
"LinuxMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"linuxmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EventMetadataExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorLinuxExtractor provides a way to specify metadata extractor for linux monitors. | [
"SubOptionMonitorLinuxExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"linux",
"monitors",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L38-L42 |
6,735 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorCNIExtractor | func SubOptionMonitorCNIExtractor(extractor extractors.EventMetadataExtractor) CNIMonitorOption {
return func(cfg *cnimonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | func SubOptionMonitorCNIExtractor(extractor extractors.EventMetadataExtractor) CNIMonitorOption {
return func(cfg *cnimonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | [
"func",
"SubOptionMonitorCNIExtractor",
"(",
"extractor",
"extractors",
".",
"EventMetadataExtractor",
")",
"CNIMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"cnimonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EventMetadataExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorCNIExtractor provides a way to specify metadata extractor for CNI monitors. | [
"SubOptionMonitorCNIExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"CNI",
"monitors",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L78-L82 |
6,736 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorUIDExtractor | func SubOptionMonitorUIDExtractor(extractor extractors.EventMetadataExtractor) UIDMonitorOption {
return func(cfg *uidmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | func SubOptionMonitorUIDExtractor(extractor extractors.EventMetadataExtractor) UIDMonitorOption {
return func(cfg *uidmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | [
"func",
"SubOptionMonitorUIDExtractor",
"(",
"extractor",
"extractors",
".",
"EventMetadataExtractor",
")",
"UIDMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"uidmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EventMetadataExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorUIDExtractor provides a way to specify metadata extractor for UID monitors. | [
"SubOptionMonitorUIDExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"UID",
"monitors",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L99-L103 |
6,737 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorSSHExtractor | func SubOptionMonitorSSHExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | func SubOptionMonitorSSHExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | [
"func",
"SubOptionMonitorSSHExtractor",
"(",
"extractor",
"extractors",
".",
"EventMetadataExtractor",
")",
"LinuxMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"linuxmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EventMetadataExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorSSHExtractor provides a way to specify metadata extractor for SSH monitors. | [
"SubOptionMonitorSSHExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"SSH",
"monitors",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L120-L124 |
6,738 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorDockerExtractor | func SubOptionMonitorDockerExtractor(extractor extractors.DockerMetadataExtractor) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | go | func SubOptionMonitorDockerExtractor(extractor extractors.DockerMetadataExtractor) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
} | [
"func",
"SubOptionMonitorDockerExtractor",
"(",
"extractor",
"extractors",
".",
"DockerMetadataExtractor",
")",
"DockerMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"dockermonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EventMetadataExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorDockerExtractor provides a way to specify metadata extractor for docker. | [
"SubOptionMonitorDockerExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"docker",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L141-L145 |
6,739 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorDockerSocket | func SubOptionMonitorDockerSocket(socketType, socketAddress string) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.SocketType = socketType
cfg.SocketAddress = socketAddress
}
} | go | func SubOptionMonitorDockerSocket(socketType, socketAddress string) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.SocketType = socketType
cfg.SocketAddress = socketAddress
}
} | [
"func",
"SubOptionMonitorDockerSocket",
"(",
"socketType",
",",
"socketAddress",
"string",
")",
"DockerMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"dockermonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"SocketType",
"=",
"socketType",
"\n",
"cfg",
".",
"SocketAddress",
"=",
"socketAddress",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorDockerSocket provides a way to specify socket info for docker. | [
"SubOptionMonitorDockerSocket",
"provides",
"a",
"way",
"to",
"specify",
"socket",
"info",
"for",
"docker",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L148-L153 |
6,740 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorDockerFlags | func SubOptionMonitorDockerFlags(syncAtStart, killContainerOnPolicyError bool) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.KillContainerOnPolicyError = killContainerOnPolicyError
cfg.SyncAtStart = syncAtStart
}
} | go | func SubOptionMonitorDockerFlags(syncAtStart, killContainerOnPolicyError bool) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.KillContainerOnPolicyError = killContainerOnPolicyError
cfg.SyncAtStart = syncAtStart
}
} | [
"func",
"SubOptionMonitorDockerFlags",
"(",
"syncAtStart",
",",
"killContainerOnPolicyError",
"bool",
")",
"DockerMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"dockermonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"KillContainerOnPolicyError",
"=",
"killContainerOnPolicyError",
"\n",
"cfg",
".",
"SyncAtStart",
"=",
"syncAtStart",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorDockerFlags provides a way to specify configuration flags info for docker. | [
"SubOptionMonitorDockerFlags",
"provides",
"a",
"way",
"to",
"specify",
"configuration",
"flags",
"info",
"for",
"docker",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L156-L161 |
6,741 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorKubernetesKubeconfig | func SubOptionMonitorKubernetesKubeconfig(kubeconfig string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | go | func SubOptionMonitorKubernetesKubeconfig(kubeconfig string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | [
"func",
"SubOptionMonitorKubernetesKubeconfig",
"(",
"kubeconfig",
"string",
")",
"KubernetesMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"kubernetesmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"Kubeconfig",
"=",
"kubeconfig",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorKubernetesKubeconfig provides a way to specify a kubeconfig to use to connect to Kubernetes.
// In case of an in-cluter config, leave the kubeconfig field blank | [
"SubOptionMonitorKubernetesKubeconfig",
"provides",
"a",
"way",
"to",
"specify",
"a",
"kubeconfig",
"to",
"use",
"to",
"connect",
"to",
"Kubernetes",
".",
"In",
"case",
"of",
"an",
"in",
"-",
"cluter",
"config",
"leave",
"the",
"kubeconfig",
"field",
"blank"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L192-L196 |
6,742 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorKubernetesNodename | func SubOptionMonitorKubernetesNodename(nodename string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Nodename = nodename
}
} | go | func SubOptionMonitorKubernetesNodename(nodename string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Nodename = nodename
}
} | [
"func",
"SubOptionMonitorKubernetesNodename",
"(",
"nodename",
"string",
")",
"KubernetesMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"kubernetesmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"Nodename",
"=",
"nodename",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorKubernetesNodename provides a way to specify the kubernetes node name.
// This is useful for filtering | [
"SubOptionMonitorKubernetesNodename",
"provides",
"a",
"way",
"to",
"specify",
"the",
"kubernetes",
"node",
"name",
".",
"This",
"is",
"useful",
"for",
"filtering"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L200-L204 |
6,743 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorKubernetesHostPod | func SubOptionMonitorKubernetesHostPod(enableHostPods bool) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | go | func SubOptionMonitorKubernetesHostPod(enableHostPods bool) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | [
"func",
"SubOptionMonitorKubernetesHostPod",
"(",
"enableHostPods",
"bool",
")",
"KubernetesMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"kubernetesmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EnableHostPods",
"=",
"enableHostPods",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorKubernetesHostPod provides a way to specify if we want to activate Pods launched in host mode. | [
"SubOptionMonitorKubernetesHostPod",
"provides",
"a",
"way",
"to",
"specify",
"if",
"we",
"want",
"to",
"activate",
"Pods",
"launched",
"in",
"host",
"mode",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L207-L211 |
6,744 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorKubernetesExtractor | func SubOptionMonitorKubernetesExtractor(extractor extractors.KubernetesMetadataExtractorType) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.KubernetesExtractor = extractor
}
} | go | func SubOptionMonitorKubernetesExtractor(extractor extractors.KubernetesMetadataExtractorType) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.KubernetesExtractor = extractor
}
} | [
"func",
"SubOptionMonitorKubernetesExtractor",
"(",
"extractor",
"extractors",
".",
"KubernetesMetadataExtractorType",
")",
"KubernetesMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"kubernetesmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"KubernetesExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorKubernetesExtractor provides a way to specify metadata extractor for Kubernetes | [
"SubOptionMonitorKubernetesExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"Kubernetes"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L214-L218 |
6,745 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorKubernetesDockerExtractor | func SubOptionMonitorKubernetesDockerExtractor(extractor extractors.DockerMetadataExtractor) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.DockerExtractor = extractor
}
} | go | func SubOptionMonitorKubernetesDockerExtractor(extractor extractors.DockerMetadataExtractor) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.DockerExtractor = extractor
}
} | [
"func",
"SubOptionMonitorKubernetesDockerExtractor",
"(",
"extractor",
"extractors",
".",
"DockerMetadataExtractor",
")",
"KubernetesMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"kubernetesmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"DockerExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorKubernetesDockerExtractor provides a way to specify metadata extractor for docker. | [
"SubOptionMonitorKubernetesDockerExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"docker",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L221-L225 |
6,746 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorPodKubeconfig | func SubOptionMonitorPodKubeconfig(kubeconfig string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | go | func SubOptionMonitorPodKubeconfig(kubeconfig string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
} | [
"func",
"SubOptionMonitorPodKubeconfig",
"(",
"kubeconfig",
"string",
")",
"PodMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"podmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"Kubeconfig",
"=",
"kubeconfig",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorPodKubeconfig provides a way to specify a kubeconfig to use to connect to Kubernetes.
// In case of an in-cluter config, leave the kubeconfig field blank | [
"SubOptionMonitorPodKubeconfig",
"provides",
"a",
"way",
"to",
"specify",
"a",
"kubeconfig",
"to",
"use",
"to",
"connect",
"to",
"Kubernetes",
".",
"In",
"case",
"of",
"an",
"in",
"-",
"cluter",
"config",
"leave",
"the",
"kubeconfig",
"field",
"blank"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L242-L246 |
6,747 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorPodNodename | func SubOptionMonitorPodNodename(nodename string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Nodename = nodename
}
} | go | func SubOptionMonitorPodNodename(nodename string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Nodename = nodename
}
} | [
"func",
"SubOptionMonitorPodNodename",
"(",
"nodename",
"string",
")",
"PodMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"podmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"Nodename",
"=",
"nodename",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorPodNodename provides a way to specify the kubernetes node name.
// This is useful for filtering | [
"SubOptionMonitorPodNodename",
"provides",
"a",
"way",
"to",
"specify",
"the",
"kubernetes",
"node",
"name",
".",
"This",
"is",
"useful",
"for",
"filtering"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L250-L254 |
6,748 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorPodActivateHostPods | func SubOptionMonitorPodActivateHostPods(enableHostPods bool) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | go | func SubOptionMonitorPodActivateHostPods(enableHostPods bool) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
} | [
"func",
"SubOptionMonitorPodActivateHostPods",
"(",
"enableHostPods",
"bool",
")",
"PodMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"podmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"EnableHostPods",
"=",
"enableHostPods",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorPodActivateHostPods provides a way to specify if we want to activate Pods launched in host mode. | [
"SubOptionMonitorPodActivateHostPods",
"provides",
"a",
"way",
"to",
"specify",
"if",
"we",
"want",
"to",
"activate",
"Pods",
"launched",
"in",
"host",
"mode",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L257-L261 |
6,749 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorPodMetadataExtractor | func SubOptionMonitorPodMetadataExtractor(extractor extractors.PodMetadataExtractor) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.MetadataExtractor = extractor
}
} | go | func SubOptionMonitorPodMetadataExtractor(extractor extractors.PodMetadataExtractor) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.MetadataExtractor = extractor
}
} | [
"func",
"SubOptionMonitorPodMetadataExtractor",
"(",
"extractor",
"extractors",
".",
"PodMetadataExtractor",
")",
"PodMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"podmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"MetadataExtractor",
"=",
"extractor",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorPodMetadataExtractor provides a way to specify metadata extractor for Kubernetes | [
"SubOptionMonitorPodMetadataExtractor",
"provides",
"a",
"way",
"to",
"specify",
"metadata",
"extractor",
"for",
"Kubernetes"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L264-L268 |
6,750 | aporeto-inc/trireme-lib | monitor/options.go | SubOptionMonitorPodNetclsProgrammer | func SubOptionMonitorPodNetclsProgrammer(netclsprogrammer extractors.PodNetclsProgrammer) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.NetclsProgrammer = netclsprogrammer
}
} | go | func SubOptionMonitorPodNetclsProgrammer(netclsprogrammer extractors.PodNetclsProgrammer) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.NetclsProgrammer = netclsprogrammer
}
} | [
"func",
"SubOptionMonitorPodNetclsProgrammer",
"(",
"netclsprogrammer",
"extractors",
".",
"PodNetclsProgrammer",
")",
"PodMonitorOption",
"{",
"return",
"func",
"(",
"cfg",
"*",
"podmonitor",
".",
"Config",
")",
"{",
"cfg",
".",
"NetclsProgrammer",
"=",
"netclsprogrammer",
"\n",
"}",
"\n",
"}"
] | // SubOptionMonitorPodNetclsProgrammer provides a way to program the net_cls cgroup for host network pods in Kubernetes | [
"SubOptionMonitorPodNetclsProgrammer",
"provides",
"a",
"way",
"to",
"program",
"the",
"net_cls",
"cgroup",
"for",
"host",
"network",
"pods",
"in",
"Kubernetes"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L271-L275 |
6,751 | aporeto-inc/trireme-lib | monitor/options.go | OptionCollector | func OptionCollector(c collector.EventCollector) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Collector = c
}
} | go | func OptionCollector(c collector.EventCollector) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Collector = c
}
} | [
"func",
"OptionCollector",
"(",
"c",
"collector",
".",
"EventCollector",
")",
"Options",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
".",
"MonitorConfig",
")",
"{",
"cfg",
".",
"Common",
".",
"Collector",
"=",
"c",
"\n",
"}",
"\n",
"}"
] | // OptionCollector provide a way to add to the docker monitor the collector instance | [
"OptionCollector",
"provide",
"a",
"way",
"to",
"add",
"to",
"the",
"docker",
"monitor",
"the",
"collector",
"instance"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L286-L290 |
6,752 | aporeto-inc/trireme-lib | monitor/options.go | OptionPolicyResolver | func OptionPolicyResolver(p policy.Resolver) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Policy = p
}
} | go | func OptionPolicyResolver(p policy.Resolver) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Policy = p
}
} | [
"func",
"OptionPolicyResolver",
"(",
"p",
"policy",
".",
"Resolver",
")",
"Options",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
".",
"MonitorConfig",
")",
"{",
"cfg",
".",
"Common",
".",
"Policy",
"=",
"p",
"\n",
"}",
"\n",
"}"
] | // OptionPolicyResolver provides a way to add to the docker monitor the policy resolver instance | [
"OptionPolicyResolver",
"provides",
"a",
"way",
"to",
"add",
"to",
"the",
"docker",
"monitor",
"the",
"policy",
"resolver",
"instance"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L293-L297 |
6,753 | aporeto-inc/trireme-lib | monitor/options.go | NewMonitor | func NewMonitor(opts ...Options) *config.MonitorConfig {
cfg := &config.MonitorConfig{
Monitors: make(map[config.Type]interface{}),
}
for _, opt := range opts {
opt(cfg)
}
return cfg
} | go | func NewMonitor(opts ...Options) *config.MonitorConfig {
cfg := &config.MonitorConfig{
Monitors: make(map[config.Type]interface{}),
}
for _, opt := range opts {
opt(cfg)
}
return cfg
} | [
"func",
"NewMonitor",
"(",
"opts",
"...",
"Options",
")",
"*",
"config",
".",
"MonitorConfig",
"{",
"cfg",
":=",
"&",
"config",
".",
"MonitorConfig",
"{",
"Monitors",
":",
"make",
"(",
"map",
"[",
"config",
".",
"Type",
"]",
"interface",
"{",
"}",
")",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"cfg",
")",
"\n",
"}",
"\n\n",
"return",
"cfg",
"\n",
"}"
] | // NewMonitor provides a configuration for monitors. | [
"NewMonitor",
"provides",
"a",
"configuration",
"for",
"monitors",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/options.go#L300-L311 |
6,754 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | AddEthernetLayer | 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 mac given")
}
//MAC address of the destination
dstMAC, _ = net.ParseMAC(dstMACstr)
if dstMAC == nil {
return errors.New("no destination mac given")
}
//Ethernet packet header
p.ethernetLayer = &layers.Ethernet{
SrcMAC: srcMAC,
DstMAC: dstMAC,
EthernetType: layers.EthernetTypeIPv4,
}
return nil
} | go | 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 mac given")
}
//MAC address of the destination
dstMAC, _ = net.ParseMAC(dstMACstr)
if dstMAC == nil {
return errors.New("no destination mac given")
}
//Ethernet packet header
p.ethernetLayer = &layers.Ethernet{
SrcMAC: srcMAC,
DstMAC: dstMAC,
EthernetType: layers.EthernetTypeIPv4,
}
return nil
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"AddEthernetLayer",
"(",
"srcMACstr",
"string",
",",
"dstMACstr",
"string",
")",
"error",
"{",
"if",
"p",
".",
"ethernetLayer",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"srcMAC",
",",
"dstMAC",
"net",
".",
"HardwareAddr",
"\n\n",
"//MAC address of the source",
"srcMAC",
",",
"_",
"=",
"net",
".",
"ParseMAC",
"(",
"srcMACstr",
")",
"\n\n",
"if",
"srcMAC",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//MAC address of the destination",
"dstMAC",
",",
"_",
"=",
"net",
".",
"ParseMAC",
"(",
"dstMACstr",
")",
"\n\n",
"if",
"dstMAC",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//Ethernet packet header",
"p",
".",
"ethernetLayer",
"=",
"&",
"layers",
".",
"Ethernet",
"{",
"SrcMAC",
":",
"srcMAC",
",",
"DstMAC",
":",
"dstMAC",
",",
"EthernetType",
":",
"layers",
".",
"EthernetTypeIPv4",
",",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //AddEthernetLayer creates an Ethernet layer | [
"AddEthernetLayer",
"creates",
"an",
"Ethernet",
"layer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L22-L52 |
6,755 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | AddIPLayer | 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 destination
dstIP = net.ParseIP(dstIPstr)
if dstIP == nil {
return errors.New("no destination ip given")
}
//IP packet header
p.ipLayer = &layers.IPv4{
SrcIP: srcIP,
DstIP: dstIP,
Version: 4,
TTL: 64,
Protocol: layers.IPProtocolTCP,
}
return nil
} | go | 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 destination
dstIP = net.ParseIP(dstIPstr)
if dstIP == nil {
return errors.New("no destination ip given")
}
//IP packet header
p.ipLayer = &layers.IPv4{
SrcIP: srcIP,
DstIP: dstIP,
Version: 4,
TTL: 64,
Protocol: layers.IPProtocolTCP,
}
return nil
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"AddIPLayer",
"(",
"srcIPstr",
"string",
",",
"dstIPstr",
"string",
")",
"error",
"{",
"if",
"p",
".",
"ipLayer",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"srcIP",
",",
"dstIP",
"net",
".",
"IP",
"\n\n",
"//IP address of the source",
"srcIP",
"=",
"net",
".",
"ParseIP",
"(",
"srcIPstr",
")",
"\n\n",
"if",
"srcIP",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//IP address of the destination",
"dstIP",
"=",
"net",
".",
"ParseIP",
"(",
"dstIPstr",
")",
"\n\n",
"if",
"dstIP",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//IP packet header",
"p",
".",
"ipLayer",
"=",
"&",
"layers",
".",
"IPv4",
"{",
"SrcIP",
":",
"srcIP",
",",
"DstIP",
":",
"dstIP",
",",
"Version",
":",
"4",
",",
"TTL",
":",
"64",
",",
"Protocol",
":",
"layers",
".",
"IPProtocolTCP",
",",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //AddIPLayer creates an IP layer | [
"AddIPLayer",
"creates",
"an",
"IP",
"layer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L61-L93 |
6,756 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | AddTCPLayer | 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 packet header
p.tcpLayer = &layers.TCP{
SrcPort: srcPort,
DstPort: dstPort,
Window: 0,
Urgent: 0,
Seq: 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)
} | go | 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 packet header
p.tcpLayer = &layers.TCP{
SrcPort: srcPort,
DstPort: dstPort,
Window: 0,
Urgent: 0,
Seq: 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)
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"AddTCPLayer",
"(",
"srcPort",
"layers",
".",
"TCPPort",
",",
"dstPort",
"layers",
".",
"TCPPort",
")",
"error",
"{",
"if",
"p",
".",
"tcpLayer",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"srcPort",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"dstPort",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//TCP packet header",
"p",
".",
"tcpLayer",
"=",
"&",
"layers",
".",
"TCP",
"{",
"SrcPort",
":",
"srcPort",
",",
"DstPort",
":",
"dstPort",
",",
"Window",
":",
"0",
",",
"Urgent",
":",
"0",
",",
"Seq",
":",
"0",
",",
"Ack",
":",
"0",
",",
"ACK",
":",
"false",
",",
"SYN",
":",
"false",
",",
"FIN",
":",
"false",
",",
"RST",
":",
"false",
",",
"URG",
":",
"false",
",",
"ECE",
":",
"false",
",",
"CWR",
":",
"false",
",",
"NS",
":",
"false",
",",
"PSH",
":",
"false",
",",
"}",
"\n\n",
"return",
"p",
".",
"tcpLayer",
".",
"SetNetworkLayerForChecksum",
"(",
"p",
".",
"ipLayer",
")",
"\n",
"}"
] | //AddTCPLayer creates a TCP layer | [
"AddTCPLayer",
"creates",
"a",
"TCP",
"layer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L108-L142 |
6,757 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | SetTCPSynAck | func (p *Packet) SetTCPSynAck() {
p.tcpLayer.SYN = true
p.tcpLayer.ACK = true
p.tcpLayer.FIN = false
} | go | func (p *Packet) SetTCPSynAck() {
p.tcpLayer.SYN = true
p.tcpLayer.ACK = true
p.tcpLayer.FIN = false
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"SetTCPSynAck",
"(",
")",
"{",
"p",
".",
"tcpLayer",
".",
"SYN",
"=",
"true",
"\n",
"p",
".",
"tcpLayer",
".",
"ACK",
"=",
"true",
"\n",
"p",
".",
"tcpLayer",
".",
"FIN",
"=",
"false",
"\n",
"}"
] | //SetTCPSynAck changes the TCP SYN and ACK flag to true | [
"SetTCPSynAck",
"changes",
"the",
"TCP",
"SYN",
"and",
"ACK",
"flag",
"to",
"true"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L222-L227 |
6,758 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | NewTCPPayload | 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 | 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
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"NewTCPPayload",
"(",
"newPayload",
"string",
")",
"error",
"{",
"if",
"p",
".",
"tcpLayer",
".",
"Payload",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"p",
".",
"tcpLayer",
".",
"Payload",
"=",
"[",
"]",
"byte",
"(",
"newPayload",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | //NewTCPPayload adds new payload to TCP layer | [
"NewTCPPayload",
"adds",
"new",
"payload",
"to",
"TCP",
"layer"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L268-L277 |
6,759 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | DecodePacket | 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()
if ethernetLayer := p.packet.Layer(layers.LayerTypeEthernet); ethernetLayer != nil {
ethernet, _ := ethernetLayer.(*layers.Ethernet)
newEthernetPacket.SrcMAC = ethernet.SrcMAC
newEthernetPacket.DstMAC = ethernet.DstMAC
newEthernetPacket.EthernetType = ethernet.EthernetType
}
if ipLayer := p.packet.Layer(layers.LayerTypeIPv4); ipLayer != nil {
ip, _ := ipLayer.(*layers.IPv4)
newIPPacket.SrcIP = ip.SrcIP
newIPPacket.DstIP = ip.DstIP
newIPPacket.Version = ip.Version
newIPPacket.Length = ip.Length
newIPPacket.Protocol = ip.Protocol
newIPPacket.TTL = ip.TTL
}
if tcpLayer := p.packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
tcp, _ := tcpLayer.(*layers.TCP)
newTCPPacket.SrcPort = tcp.SrcPort
newTCPPacket.DstPort = tcp.DstPort
newTCPPacket.Seq = 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.Checksum = tcp.Checksum
newTCPPacket.Window = tcp.Window
}
packetData = &Packet{
ethernetLayer: &newEthernetPacket,
ipLayer: &newIPPacket,
tcpLayer: &newTCPPacket,
}
return packetData
} | go | 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()
if ethernetLayer := p.packet.Layer(layers.LayerTypeEthernet); ethernetLayer != nil {
ethernet, _ := ethernetLayer.(*layers.Ethernet)
newEthernetPacket.SrcMAC = ethernet.SrcMAC
newEthernetPacket.DstMAC = ethernet.DstMAC
newEthernetPacket.EthernetType = ethernet.EthernetType
}
if ipLayer := p.packet.Layer(layers.LayerTypeIPv4); ipLayer != nil {
ip, _ := ipLayer.(*layers.IPv4)
newIPPacket.SrcIP = ip.SrcIP
newIPPacket.DstIP = ip.DstIP
newIPPacket.Version = ip.Version
newIPPacket.Length = ip.Length
newIPPacket.Protocol = ip.Protocol
newIPPacket.TTL = ip.TTL
}
if tcpLayer := p.packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
tcp, _ := tcpLayer.(*layers.TCP)
newTCPPacket.SrcPort = tcp.SrcPort
newTCPPacket.DstPort = tcp.DstPort
newTCPPacket.Seq = 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.Checksum = tcp.Checksum
newTCPPacket.Window = tcp.Window
}
packetData = &Packet{
ethernetLayer: &newEthernetPacket,
ipLayer: &newIPPacket,
tcpLayer: &newTCPPacket,
}
return packetData
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"DecodePacket",
"(",
")",
"PacketManipulator",
"{",
"packetData",
":=",
"&",
"Packet",
"{",
"ethernetLayer",
":",
"&",
"layers",
".",
"Ethernet",
"{",
"}",
",",
"ipLayer",
":",
"&",
"layers",
".",
"IPv4",
"{",
"}",
",",
"tcpLayer",
":",
"&",
"layers",
".",
"TCP",
"{",
"}",
",",
"}",
"\n\n",
"newEthernetPacket",
":=",
"packetData",
".",
"GetEthernetPacket",
"(",
")",
"\n",
"newIPPacket",
":=",
"packetData",
".",
"GetIPPacket",
"(",
")",
"\n",
"newTCPPacket",
":=",
"packetData",
".",
"GetTCPPacket",
"(",
")",
"\n\n",
"if",
"ethernetLayer",
":=",
"p",
".",
"packet",
".",
"Layer",
"(",
"layers",
".",
"LayerTypeEthernet",
")",
";",
"ethernetLayer",
"!=",
"nil",
"{",
"ethernet",
",",
"_",
":=",
"ethernetLayer",
".",
"(",
"*",
"layers",
".",
"Ethernet",
")",
"\n",
"newEthernetPacket",
".",
"SrcMAC",
"=",
"ethernet",
".",
"SrcMAC",
"\n",
"newEthernetPacket",
".",
"DstMAC",
"=",
"ethernet",
".",
"DstMAC",
"\n",
"newEthernetPacket",
".",
"EthernetType",
"=",
"ethernet",
".",
"EthernetType",
"\n",
"}",
"\n\n",
"if",
"ipLayer",
":=",
"p",
".",
"packet",
".",
"Layer",
"(",
"layers",
".",
"LayerTypeIPv4",
")",
";",
"ipLayer",
"!=",
"nil",
"{",
"ip",
",",
"_",
":=",
"ipLayer",
".",
"(",
"*",
"layers",
".",
"IPv4",
")",
"\n\n",
"newIPPacket",
".",
"SrcIP",
"=",
"ip",
".",
"SrcIP",
"\n",
"newIPPacket",
".",
"DstIP",
"=",
"ip",
".",
"DstIP",
"\n",
"newIPPacket",
".",
"Version",
"=",
"ip",
".",
"Version",
"\n",
"newIPPacket",
".",
"Length",
"=",
"ip",
".",
"Length",
"\n",
"newIPPacket",
".",
"Protocol",
"=",
"ip",
".",
"Protocol",
"\n",
"newIPPacket",
".",
"TTL",
"=",
"ip",
".",
"TTL",
"\n",
"}",
"\n\n",
"if",
"tcpLayer",
":=",
"p",
".",
"packet",
".",
"Layer",
"(",
"layers",
".",
"LayerTypeTCP",
")",
";",
"tcpLayer",
"!=",
"nil",
"{",
"tcp",
",",
"_",
":=",
"tcpLayer",
".",
"(",
"*",
"layers",
".",
"TCP",
")",
"\n\n",
"newTCPPacket",
".",
"SrcPort",
"=",
"tcp",
".",
"SrcPort",
"\n",
"newTCPPacket",
".",
"DstPort",
"=",
"tcp",
".",
"DstPort",
"\n",
"newTCPPacket",
".",
"Seq",
"=",
"tcp",
".",
"Seq",
"\n",
"newTCPPacket",
".",
"Ack",
"=",
"tcp",
".",
"Ack",
"\n",
"newTCPPacket",
".",
"SYN",
"=",
"tcp",
".",
"SYN",
"\n",
"newTCPPacket",
".",
"FIN",
"=",
"tcp",
".",
"FIN",
"\n",
"newTCPPacket",
".",
"RST",
"=",
"tcp",
".",
"RST",
"\n",
"newTCPPacket",
".",
"PSH",
"=",
"tcp",
".",
"PSH",
"\n",
"newTCPPacket",
".",
"ACK",
"=",
"tcp",
".",
"ACK",
"\n",
"newTCPPacket",
".",
"URG",
"=",
"tcp",
".",
"URG",
"\n",
"newTCPPacket",
".",
"ECE",
"=",
"tcp",
".",
"ECE",
"\n",
"newTCPPacket",
".",
"CWR",
"=",
"tcp",
".",
"CWR",
"\n",
"newTCPPacket",
".",
"NS",
"=",
"tcp",
".",
"NS",
"\n",
"newTCPPacket",
".",
"Checksum",
"=",
"tcp",
".",
"Checksum",
"\n",
"newTCPPacket",
".",
"Window",
"=",
"tcp",
".",
"Window",
"\n",
"}",
"\n\n",
"packetData",
"=",
"&",
"Packet",
"{",
"ethernetLayer",
":",
"&",
"newEthernetPacket",
",",
"ipLayer",
":",
"&",
"newIPPacket",
",",
"tcpLayer",
":",
"&",
"newTCPPacket",
",",
"}",
"\n\n",
"return",
"packetData",
"\n",
"}"
] | //DecodePacket returns decoded packet which implements PacketManipulator | [
"DecodePacket",
"returns",
"decoded",
"packet",
"which",
"implements",
"PacketManipulator"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L321-L378 |
6,760 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | NewPacketFlow | 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 initialTupules
} | go | 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 initialTupules
} | [
"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",
")",
",",
"}",
"\n\n",
"return",
"initialTupules",
"\n",
"}"
] | //NewPacketFlow returns PacketFlow struct which implements PacketFlowManipulator | [
"NewPacketFlow",
"returns",
"PacketFlow",
"struct",
"which",
"implements",
"PacketFlowManipulator"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L381-L394 |
6,761 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | AppendPacket | func (p *PacketFlow) AppendPacket(pm PacketManipulator) int {
p.flow = append(p.flow, pm)
return p.GetNumPackets()
} | go | func (p *PacketFlow) AppendPacket(pm PacketManipulator) int {
p.flow = append(p.flow, pm)
return p.GetNumPackets()
} | [
"func",
"(",
"p",
"*",
"PacketFlow",
")",
"AppendPacket",
"(",
"pm",
"PacketManipulator",
")",
"int",
"{",
"p",
".",
"flow",
"=",
"append",
"(",
"p",
".",
"flow",
",",
"pm",
")",
"\n\n",
"return",
"p",
".",
"GetNumPackets",
"(",
")",
"\n",
"}"
] | //AppendPacket adds the packet to Flow field of PacketFlowManipulator interface | [
"AppendPacket",
"adds",
"the",
"packet",
"to",
"Flow",
"field",
"of",
"PacketFlowManipulator",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L509-L514 |
6,762 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | getMatchPackets | 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.AppendPacket(p.flow[j])
}
}
return packetsInFlow
} | go | 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.AppendPacket(p.flow[j])
}
}
return packetsInFlow
} | [
"func",
"(",
"p",
"*",
"PacketFlow",
")",
"getMatchPackets",
"(",
"syn",
",",
"ack",
",",
"fin",
"bool",
")",
"PacketFlowManipulator",
"{",
"packetsInFlow",
":=",
"NewPacketFlow",
"(",
"p",
".",
"sMAC",
",",
"p",
".",
"dMAC",
",",
"p",
".",
"sIP",
",",
"p",
".",
"dIP",
",",
"p",
".",
"sPort",
",",
"p",
".",
"dPort",
")",
"\n\n",
"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",
".",
"AppendPacket",
"(",
"p",
".",
"flow",
"[",
"j",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"packetsInFlow",
"\n",
"}"
] | //GetMatchPackets implicitly returns the matching packets requested by the user | [
"GetMatchPackets",
"implicitly",
"returns",
"the",
"matching",
"packets",
"requested",
"by",
"the",
"user"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L517-L528 |
6,763 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | GetUptoFirstSynAckPacket | 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.flow[j].GetTCPFin() {
flag = true
}
}
}
return packetsInFlow
} | go | 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.flow[j].GetTCPFin() {
flag = true
}
}
}
return packetsInFlow
} | [
"func",
"(",
"p",
"*",
"PacketFlow",
")",
"GetUptoFirstSynAckPacket",
"(",
")",
"PacketFlowManipulator",
"{",
"packetsInFlow",
":=",
"NewPacketFlow",
"(",
"p",
".",
"sMAC",
",",
"p",
".",
"dMAC",
",",
"p",
".",
"sIP",
",",
"p",
".",
"dIP",
",",
"p",
".",
"sPort",
",",
"p",
".",
"dPort",
")",
"\n",
"flag",
":=",
"false",
"\n\n",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"len",
"(",
"p",
".",
"flow",
")",
";",
"j",
"++",
"{",
"if",
"!",
"flag",
"{",
"packetsInFlow",
".",
"AppendPacket",
"(",
"p",
".",
"flow",
"[",
"j",
"]",
")",
"\n",
"if",
"p",
".",
"flow",
"[",
"j",
"]",
".",
"GetTCPSyn",
"(",
")",
"&&",
"p",
".",
"flow",
"[",
"j",
"]",
".",
"GetTCPAck",
"(",
")",
"&&",
"!",
"p",
".",
"flow",
"[",
"j",
"]",
".",
"GetTCPFin",
"(",
")",
"{",
"flag",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"packetsInFlow",
"\n",
"}"
] | //GetUptoFirstSynAckPacket will return packets upto first SynAck packet | [
"GetUptoFirstSynAckPacket",
"will",
"return",
"packets",
"upto",
"first",
"SynAck",
"packet"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L567-L582 |
6,764 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/packetgen/packet_gen.go | GetNthPacket | 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 | 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")
} | [
"func",
"(",
"p",
"*",
"PacketFlow",
")",
"GetNthPacket",
"(",
"index",
"int",
")",
"PacketManipulator",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"p",
".",
"flow",
")",
";",
"i",
"++",
"{",
"if",
"index",
"==",
"i",
"{",
"return",
"p",
".",
"flow",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | //GetNthPacket returns the packet requested by the user from the array | [
"GetNthPacket",
"returns",
"the",
"packet",
"requested",
"by",
"the",
"user",
"from",
"the",
"array"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/packetgen/packet_gen.go#L603-L612 |
6,765 | aporeto-inc/trireme-lib | common/service.go | ConvertServicesToPortList | 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 | 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
} | [
"func",
"ConvertServicesToPortList",
"(",
"services",
"[",
"]",
"Service",
")",
"string",
"{",
"portlist",
":=",
"\"",
"\"",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"services",
"{",
"portlist",
"=",
"portlist",
"+",
"s",
".",
"Ports",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"portlist",
")",
"==",
"0",
"{",
"portlist",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"portlist",
"=",
"portlist",
"[",
":",
"len",
"(",
"portlist",
")",
"-",
"1",
"]",
"\n",
"}",
"\n\n",
"return",
"portlist",
"\n",
"}"
] | // ConvertServicesToPortList converts an array of services to a port list | [
"ConvertServicesToPortList",
"converts",
"an",
"array",
"of",
"services",
"to",
"a",
"port",
"list"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/common/service.go#L29-L43 |
6,766 | aporeto-inc/trireme-lib | controller/pkg/remoteenforcer/internal/debugclient/client.go | NewDebugClient | 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 * time.Millisecond,
stop: 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
} | go | 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 * time.Millisecond,
stop: 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
} | [
"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",
"*",
"time",
".",
"Millisecond",
",",
"stop",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"}",
"\n\n",
"if",
"d",
".",
"debugChannel",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"d",
".",
"secret",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"d",
",",
"nil",
"\n",
"}"
] | // NewDebugClient initializes a new Debug Client | [
"NewDebugClient",
"initializes",
"a",
"new",
"Debug",
"Client"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/debugclient/client.go#L32-L51 |
6,767 | aporeto-inc/trireme-lib | controller/internal/enforcer/nfqdatapath/afinetrawsocket/afinetrawsocket.go | CreateSocket | 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 while setting socket Option SO_MARK", err)
}
if err := syscall.SetsockoptInt(fd, 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
} | go | 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 while setting socket Option SO_MARK", err)
}
if err := syscall.SetsockoptInt(fd, 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
} | [
"func",
"CreateSocket",
"(",
"mark",
"int",
",",
"deviceName",
"string",
")",
"(",
"SocketWriter",
",",
"error",
")",
"{",
"fd",
",",
"_",
":=",
"syscall",
".",
"Socket",
"(",
"syscall",
".",
"AF_INET",
",",
"syscall",
".",
"SOCK_RAW",
",",
"syscall",
".",
"IPPROTO_RAW",
")",
"\n",
"if",
"err",
":=",
"syscall",
".",
"SetsockoptInt",
"(",
"fd",
",",
"syscall",
".",
"SOL_SOCKET",
",",
"syscall",
".",
"SO_MARK",
",",
"mark",
")",
";",
"err",
"!=",
"nil",
"{",
"syscall",
".",
"Close",
"(",
"fd",
")",
"// nolint",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"syscall",
".",
"SetsockoptInt",
"(",
"fd",
",",
"syscall",
".",
"IPPROTO_IP",
",",
"syscall",
".",
"IP_HDRINCL",
",",
"1",
")",
";",
"err",
"!=",
"nil",
"{",
"syscall",
".",
"Close",
"(",
"fd",
")",
"// nolint",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"insock",
":=",
"&",
"syscall",
".",
"SockaddrInet4",
"{",
"Port",
":",
"0",
",",
"}",
"\n\n",
"return",
"&",
"rawsocket",
"{",
"fd",
":",
"fd",
",",
"insock",
":",
"insock",
",",
"}",
",",
"nil",
"\n\n",
"}"
] | // CreateSocket returns a handle to SocketWriter interface | [
"CreateSocket",
"returns",
"a",
"handle",
"to",
"SocketWriter",
"interface"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/nfqdatapath/afinetrawsocket/afinetrawsocket.go#L33-L53 |
6,768 | aporeto-inc/trireme-lib | policy/puinfo.go | NewPUInfo | 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 | 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)
} | [
"func",
"NewPUInfo",
"(",
"contextID",
"string",
",",
"puType",
"common",
".",
"PUType",
")",
"*",
"PUInfo",
"{",
"policy",
":=",
"NewPUPolicy",
"(",
"contextID",
",",
"AllowAll",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"0",
",",
"nil",
",",
"nil",
",",
"[",
"]",
"string",
"{",
"}",
")",
"\n",
"runtime",
":=",
"NewPURuntime",
"(",
"\"",
"\"",
",",
"0",
",",
"\"",
"\"",
",",
"nil",
",",
"nil",
",",
"puType",
",",
"nil",
")",
"\n",
"return",
"PUInfoFromPolicyAndRuntime",
"(",
"contextID",
",",
"policy",
",",
"runtime",
")",
"\n",
"}"
] | // NewPUInfo instantiates a new ContainerPolicy | [
"NewPUInfo",
"instantiates",
"a",
"new",
"ContainerPolicy"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/puinfo.go#L17-L21 |
6,769 | aporeto-inc/trireme-lib | policy/puinfo.go | PUInfoFromPolicyAndRuntime | func PUInfoFromPolicyAndRuntime(contextID string, policyInfo *PUPolicy, runtimeInfo *PURuntime) *PUInfo {
return &PUInfo{
ContextID: contextID,
Policy: policyInfo,
Runtime: runtimeInfo,
}
} | go | func PUInfoFromPolicyAndRuntime(contextID string, policyInfo *PUPolicy, runtimeInfo *PURuntime) *PUInfo {
return &PUInfo{
ContextID: contextID,
Policy: policyInfo,
Runtime: runtimeInfo,
}
} | [
"func",
"PUInfoFromPolicyAndRuntime",
"(",
"contextID",
"string",
",",
"policyInfo",
"*",
"PUPolicy",
",",
"runtimeInfo",
"*",
"PURuntime",
")",
"*",
"PUInfo",
"{",
"return",
"&",
"PUInfo",
"{",
"ContextID",
":",
"contextID",
",",
"Policy",
":",
"policyInfo",
",",
"Runtime",
":",
"runtimeInfo",
",",
"}",
"\n",
"}"
] | // PUInfoFromPolicyAndRuntime generates a ContainerInfo Struct from an existing RuntimeInfo and PolicyInfo | [
"PUInfoFromPolicyAndRuntime",
"generates",
"a",
"ContainerInfo",
"Struct",
"from",
"an",
"existing",
"RuntimeInfo",
"and",
"PolicyInfo"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/puinfo.go#L24-L30 |
6,770 | aporeto-inc/trireme-lib | policy/policyerror.go | ErrPUNotFound | func ErrPUNotFound(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotFound,
err: err,
}
} | go | func ErrPUNotFound(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotFound,
err: err,
}
} | [
"func",
"ErrPUNotFound",
"(",
"puID",
"string",
",",
"err",
"error",
")",
"error",
"{",
"return",
"&",
"Error",
"{",
"puID",
":",
"puID",
",",
"reason",
":",
"PUNotFound",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ErrPUNotFound creates a new context not found error | [
"ErrPUNotFound",
"creates",
"a",
"new",
"context",
"not",
"found",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L55-L61 |
6,771 | aporeto-inc/trireme-lib | policy/policyerror.go | ErrPUNotUnique | func ErrPUNotUnique(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotUnique,
err: err,
}
} | go | func ErrPUNotUnique(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotUnique,
err: err,
}
} | [
"func",
"ErrPUNotUnique",
"(",
"puID",
"string",
",",
"err",
"error",
")",
"error",
"{",
"return",
"&",
"Error",
"{",
"puID",
":",
"puID",
",",
"reason",
":",
"PUNotUnique",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ErrPUNotUnique creates a new not unique error | [
"ErrPUNotUnique",
"creates",
"a",
"new",
"not",
"unique",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L64-L70 |
6,772 | aporeto-inc/trireme-lib | policy/policyerror.go | ErrPUCreateFailed | func ErrPUCreateFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUCreateFailed,
err: err,
}
} | go | func ErrPUCreateFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUCreateFailed,
err: err,
}
} | [
"func",
"ErrPUCreateFailed",
"(",
"puID",
"string",
",",
"err",
"error",
")",
"error",
"{",
"return",
"&",
"Error",
"{",
"puID",
":",
"puID",
",",
"reason",
":",
"PUCreateFailed",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ErrPUCreateFailed creates a new PU create failed error | [
"ErrPUCreateFailed",
"creates",
"a",
"new",
"PU",
"create",
"failed",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L73-L79 |
6,773 | aporeto-inc/trireme-lib | policy/policyerror.go | ErrPUAlreadyActivated | func ErrPUAlreadyActivated(puID string, err error) error {
return &Error{
puID: puID,
reason: PUAlreadyActivated,
err: err,
}
} | go | func ErrPUAlreadyActivated(puID string, err error) error {
return &Error{
puID: puID,
reason: PUAlreadyActivated,
err: err,
}
} | [
"func",
"ErrPUAlreadyActivated",
"(",
"puID",
"string",
",",
"err",
"error",
")",
"error",
"{",
"return",
"&",
"Error",
"{",
"puID",
":",
"puID",
",",
"reason",
":",
"PUAlreadyActivated",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ErrPUAlreadyActivated creates a new PU already activated error | [
"ErrPUAlreadyActivated",
"creates",
"a",
"new",
"PU",
"already",
"activated",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L82-L88 |
6,774 | aporeto-inc/trireme-lib | policy/policyerror.go | ErrPUPolicyPending | func ErrPUPolicyPending(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyPending,
err: err,
}
} | go | func ErrPUPolicyPending(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyPending,
err: err,
}
} | [
"func",
"ErrPUPolicyPending",
"(",
"puID",
"string",
",",
"err",
"error",
")",
"error",
"{",
"return",
"&",
"Error",
"{",
"puID",
":",
"puID",
",",
"reason",
":",
"PUPolicyPending",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ErrPUPolicyPending creates a new PU policy pending error. | [
"ErrPUPolicyPending",
"creates",
"a",
"new",
"PU",
"policy",
"pending",
"error",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L91-L97 |
6,775 | aporeto-inc/trireme-lib | policy/policyerror.go | ErrPUPolicyEnforcementFailed | func ErrPUPolicyEnforcementFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyEnforcementFailed,
err: err,
}
} | go | func ErrPUPolicyEnforcementFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyEnforcementFailed,
err: err,
}
} | [
"func",
"ErrPUPolicyEnforcementFailed",
"(",
"puID",
"string",
",",
"err",
"error",
")",
"error",
"{",
"return",
"&",
"Error",
"{",
"puID",
":",
"puID",
",",
"reason",
":",
"PUPolicyEnforcementFailed",
",",
"err",
":",
"err",
",",
"}",
"\n",
"}"
] | // ErrPUPolicyEnforcementFailed creates a new PU policy pending error. | [
"ErrPUPolicyEnforcementFailed",
"creates",
"a",
"new",
"PU",
"policy",
"pending",
"error",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L100-L106 |
6,776 | aporeto-inc/trireme-lib | policy/policyerror.go | IsErrPUNotFound | func IsErrPUNotFound(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotFound
default:
return false
}
} | go | func IsErrPUNotFound(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotFound
default:
return false
}
} | [
"func",
"IsErrPUNotFound",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"return",
"t",
".",
"reason",
"==",
"PUNotFound",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // IsErrPUNotFound checks if this error is a PU not found error | [
"IsErrPUNotFound",
"checks",
"if",
"this",
"error",
"is",
"a",
"PU",
"not",
"found",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L109-L116 |
6,777 | aporeto-inc/trireme-lib | policy/policyerror.go | IsErrPUNotUnique | func IsErrPUNotUnique(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotUnique
default:
return false
}
} | go | func IsErrPUNotUnique(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotUnique
default:
return false
}
} | [
"func",
"IsErrPUNotUnique",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"return",
"t",
".",
"reason",
"==",
"PUNotUnique",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // IsErrPUNotUnique checks if this error is a PU not unique error | [
"IsErrPUNotUnique",
"checks",
"if",
"this",
"error",
"is",
"a",
"PU",
"not",
"unique",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L119-L126 |
6,778 | aporeto-inc/trireme-lib | policy/policyerror.go | IsErrPUCreateFailed | func IsErrPUCreateFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUCreateFailed
default:
return false
}
} | go | func IsErrPUCreateFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUCreateFailed
default:
return false
}
} | [
"func",
"IsErrPUCreateFailed",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"return",
"t",
".",
"reason",
"==",
"PUCreateFailed",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // IsErrPUCreateFailed checks if this error is a PU not unique error | [
"IsErrPUCreateFailed",
"checks",
"if",
"this",
"error",
"is",
"a",
"PU",
"not",
"unique",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L129-L136 |
6,779 | aporeto-inc/trireme-lib | policy/policyerror.go | IsErrPUAlreadyActivated | func IsErrPUAlreadyActivated(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUAlreadyActivated
default:
return false
}
} | go | func IsErrPUAlreadyActivated(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUAlreadyActivated
default:
return false
}
} | [
"func",
"IsErrPUAlreadyActivated",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"return",
"t",
".",
"reason",
"==",
"PUAlreadyActivated",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // IsErrPUAlreadyActivated checks if this error is a PU already activated error | [
"IsErrPUAlreadyActivated",
"checks",
"if",
"this",
"error",
"is",
"a",
"PU",
"already",
"activated",
"error"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L139-L146 |
6,780 | aporeto-inc/trireme-lib | policy/policyerror.go | IsErrPUPolicyPending | func IsErrPUPolicyPending(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyPending
default:
return false
}
} | go | func IsErrPUPolicyPending(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyPending
default:
return false
}
} | [
"func",
"IsErrPUPolicyPending",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"return",
"t",
".",
"reason",
"==",
"PUPolicyPending",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // IsErrPUPolicyPending checks if this error is a PU policy pending error. | [
"IsErrPUPolicyPending",
"checks",
"if",
"this",
"error",
"is",
"a",
"PU",
"policy",
"pending",
"error",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L149-L156 |
6,781 | aporeto-inc/trireme-lib | policy/policyerror.go | IsErrPUEnforcementFailed | func IsErrPUEnforcementFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyEnforcementFailed
default:
return false
}
} | go | func IsErrPUEnforcementFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyEnforcementFailed
default:
return false
}
} | [
"func",
"IsErrPUEnforcementFailed",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"t",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"return",
"t",
".",
"reason",
"==",
"PUPolicyEnforcementFailed",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // IsErrPUEnforcementFailed checks if this error is a PU policy pending error. | [
"IsErrPUEnforcementFailed",
"checks",
"if",
"this",
"error",
"is",
"a",
"PU",
"policy",
"pending",
"error",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policyerror.go#L159-L166 |
6,782 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | ExecuteCommandFromArguments | func ExecuteCommandFromArguments(arguments map[string]interface{}) error {
p := NewRequestProcessor()
c, err := p.ParseCommand(arguments)
if err != nil {
return err
}
return p.ExecuteRequest(c)
} | go | func ExecuteCommandFromArguments(arguments map[string]interface{}) error {
p := NewRequestProcessor()
c, err := p.ParseCommand(arguments)
if err != nil {
return err
}
return p.ExecuteRequest(c)
} | [
"func",
"ExecuteCommandFromArguments",
"(",
"arguments",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"p",
":=",
"NewRequestProcessor",
"(",
")",
"\n\n",
"c",
",",
"err",
":=",
"p",
".",
"ParseCommand",
"(",
"arguments",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"ExecuteRequest",
"(",
"c",
")",
"\n",
"}"
] | // ExecuteCommandFromArguments processes the command from the arguments | [
"ExecuteCommandFromArguments",
"processes",
"the",
"command",
"from",
"the",
"arguments"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L27-L37 |
6,783 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | NewCustomRequestProcessor | func NewCustomRequestProcessor(address string) *RequestProcessor {
r := NewRequestProcessor()
if address != "" {
r.address = address
}
return r
} | go | func NewCustomRequestProcessor(address string) *RequestProcessor {
r := NewRequestProcessor()
if address != "" {
r.address = address
}
return r
} | [
"func",
"NewCustomRequestProcessor",
"(",
"address",
"string",
")",
"*",
"RequestProcessor",
"{",
"r",
":=",
"NewRequestProcessor",
"(",
")",
"\n\n",
"if",
"address",
"!=",
"\"",
"\"",
"{",
"r",
".",
"address",
"=",
"address",
"\n",
"}",
"\n\n",
"return",
"r",
"\n",
"}"
] | // NewCustomRequestProcessor creates a new request processor | [
"NewCustomRequestProcessor",
"creates",
"a",
"new",
"request",
"processor"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L90-L98 |
6,784 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | CreateAndRun | 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.LookPath(c.Executable)
if err != nil {
return err
}
}
if c.ServiceName == "" {
c.ServiceName = c.Executable
}
}
puType := common.LinuxProcessPU
if c.NetworkOnly {
puType = common.HostNetworkPU
} else if c.HostPolicy {
puType = common.HostPU
}
// This 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.Labels,
PID: int32(os.Getpid()),
EventType: common.EventStart,
Services: c.Services,
NetworkOnlyTraffic: c.NetworkOnly,
HostService: c.HostPolicy,
AutoPort: c.AutoPort,
}
if err := sendRequest(r.address, request); err != nil {
return err
}
if c.HostPolicy {
return nil
}
env := os.Environ()
env = append(env, "APORETO_WRAP=1")
return syscall.Exec(c.Executable, append([]string{c.Executable}, c.Parameters...), env)
} | go | 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.LookPath(c.Executable)
if err != nil {
return err
}
}
if c.ServiceName == "" {
c.ServiceName = c.Executable
}
}
puType := common.LinuxProcessPU
if c.NetworkOnly {
puType = common.HostNetworkPU
} else if c.HostPolicy {
puType = common.HostPU
}
// This 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.Labels,
PID: int32(os.Getpid()),
EventType: common.EventStart,
Services: c.Services,
NetworkOnlyTraffic: c.NetworkOnly,
HostService: c.HostPolicy,
AutoPort: c.AutoPort,
}
if err := sendRequest(r.address, request); err != nil {
return err
}
if c.HostPolicy {
return nil
}
env := os.Environ()
env = append(env, "APORETO_WRAP=1")
return syscall.Exec(c.Executable, append([]string{c.Executable}, c.Parameters...), env)
} | [
"func",
"(",
"r",
"*",
"RequestProcessor",
")",
"CreateAndRun",
"(",
"c",
"*",
"CLIRequest",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// If its not hostPolicy and the command doesn't exist we return an error",
"if",
"!",
"c",
".",
"HostPolicy",
"{",
"if",
"c",
".",
"Executable",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"path",
".",
"IsAbs",
"(",
"c",
".",
"Executable",
")",
"{",
"c",
".",
"Executable",
",",
"err",
"=",
"exec",
".",
"LookPath",
"(",
"c",
".",
"Executable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"c",
".",
"ServiceName",
"==",
"\"",
"\"",
"{",
"c",
".",
"ServiceName",
"=",
"c",
".",
"Executable",
"\n",
"}",
"\n",
"}",
"\n\n",
"puType",
":=",
"common",
".",
"LinuxProcessPU",
"\n",
"if",
"c",
".",
"NetworkOnly",
"{",
"puType",
"=",
"common",
".",
"HostNetworkPU",
"\n",
"}",
"else",
"if",
"c",
".",
"HostPolicy",
"{",
"puType",
"=",
"common",
".",
"HostPU",
"\n",
"}",
"\n\n",
"// This 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",
".",
"Labels",
",",
"PID",
":",
"int32",
"(",
"os",
".",
"Getpid",
"(",
")",
")",
",",
"EventType",
":",
"common",
".",
"EventStart",
",",
"Services",
":",
"c",
".",
"Services",
",",
"NetworkOnlyTraffic",
":",
"c",
".",
"NetworkOnly",
",",
"HostService",
":",
"c",
".",
"HostPolicy",
",",
"AutoPort",
":",
"c",
".",
"AutoPort",
",",
"}",
"\n\n",
"if",
"err",
":=",
"sendRequest",
"(",
"r",
".",
"address",
",",
"request",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"HostPolicy",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"env",
":=",
"os",
".",
"Environ",
"(",
")",
"\n",
"env",
"=",
"append",
"(",
"env",
",",
"\"",
"\"",
")",
"\n",
"return",
"syscall",
".",
"Exec",
"(",
"c",
".",
"Executable",
",",
"append",
"(",
"[",
"]",
"string",
"{",
"c",
".",
"Executable",
"}",
",",
"c",
".",
"Parameters",
"...",
")",
",",
"env",
")",
"\n",
"}"
] | // CreateAndRun creates a processing unit | [
"CreateAndRun",
"creates",
"a",
"processing",
"unit"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L203-L255 |
6,785 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | DeleteService | 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 := sendRequest(r.address, request); err != nil {
return err
}
// Send destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
} | go | 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 := sendRequest(r.address, request); err != nil {
return err
}
// Send destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
} | [
"func",
"(",
"r",
"*",
"RequestProcessor",
")",
"DeleteService",
"(",
"c",
"*",
"CLIRequest",
")",
"error",
"{",
"request",
":=",
"&",
"common",
".",
"EventInfo",
"{",
"PUType",
":",
"common",
".",
"LinuxProcessPU",
",",
"PUID",
":",
"c",
".",
"ServiceName",
",",
"EventType",
":",
"common",
".",
"EventStop",
",",
"HostService",
":",
"c",
".",
"HostPolicy",
",",
"}",
"\n\n",
"if",
"c",
".",
"UIDPolicy",
"{",
"request",
".",
"PUType",
"=",
"common",
".",
"UIDLoginPU",
"\n",
"}",
"\n\n",
"// Send Stop request",
"if",
"err",
":=",
"sendRequest",
"(",
"r",
".",
"address",
",",
"request",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Send destroy request",
"request",
".",
"EventType",
"=",
"common",
".",
"EventDestroy",
"\n\n",
"return",
"sendRequest",
"(",
"r",
".",
"address",
",",
"request",
")",
"\n",
"}"
] | // DeleteService will issue a delete command | [
"DeleteService",
"will",
"issue",
"a",
"delete",
"command"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L258-L280 |
6,786 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | DeleteCgroup | 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)) {
return fmt.Errorf("invalid cgroup: %s", c.Cgroup)
}
var eventPUID string
var eventType common.PUType
if strings.HasPrefix(c.Cgroup, common.TriremeUIDCgroupPath) {
eventType = common.UIDLoginPU
eventPUID = c.Cgroup[len(common.TriremeUIDCgroupPath):]
} else if strings.HasPrefix(c.Cgroup, common.TriremeCgroupPath+"ssh-") {
eventType = common.SSHSessionPU
eventPUID = c.Cgroup[len(common.TriremeCgroupPath)+4:]
} else if strings.HasPrefix(c.Cgroup, common.TriremeCgroupPath) {
eventType = common.LinuxProcessPU
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 destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
} | go | 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)) {
return fmt.Errorf("invalid cgroup: %s", c.Cgroup)
}
var eventPUID string
var eventType common.PUType
if strings.HasPrefix(c.Cgroup, common.TriremeUIDCgroupPath) {
eventType = common.UIDLoginPU
eventPUID = c.Cgroup[len(common.TriremeUIDCgroupPath):]
} else if strings.HasPrefix(c.Cgroup, common.TriremeCgroupPath+"ssh-") {
eventType = common.SSHSessionPU
eventPUID = c.Cgroup[len(common.TriremeCgroupPath)+4:]
} else if strings.HasPrefix(c.Cgroup, common.TriremeCgroupPath) {
eventType = common.LinuxProcessPU
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 destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
} | [
"func",
"(",
"r",
"*",
"RequestProcessor",
")",
"DeleteCgroup",
"(",
"c",
"*",
"CLIRequest",
")",
"error",
"{",
"regexCgroup",
":=",
"regexp",
".",
"MustCompile",
"(",
"`^/trireme/(ssh-)?[a-zA-Z0-9_\\-:.$%]{1,64}$`",
")",
"\n",
"regexUser",
":=",
"regexp",
".",
"MustCompile",
"(",
"`^/trireme_uid/[a-zA-Z0-9_\\-]{1,32}(/[0-9]{1,32}){0,1}$`",
")",
"\n\n",
"if",
"!",
"regexCgroup",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"c",
".",
"Cgroup",
")",
")",
"&&",
"!",
"regexUser",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"c",
".",
"Cgroup",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
".",
"Cgroup",
")",
"\n",
"}",
"\n\n",
"var",
"eventPUID",
"string",
"\n",
"var",
"eventType",
"common",
".",
"PUType",
"\n\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"c",
".",
"Cgroup",
",",
"common",
".",
"TriremeUIDCgroupPath",
")",
"{",
"eventType",
"=",
"common",
".",
"UIDLoginPU",
"\n",
"eventPUID",
"=",
"c",
".",
"Cgroup",
"[",
"len",
"(",
"common",
".",
"TriremeUIDCgroupPath",
")",
":",
"]",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"c",
".",
"Cgroup",
",",
"common",
".",
"TriremeCgroupPath",
"+",
"\"",
"\"",
")",
"{",
"eventType",
"=",
"common",
".",
"SSHSessionPU",
"\n",
"eventPUID",
"=",
"c",
".",
"Cgroup",
"[",
"len",
"(",
"common",
".",
"TriremeCgroupPath",
")",
"+",
"4",
":",
"]",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"c",
".",
"Cgroup",
",",
"common",
".",
"TriremeCgroupPath",
")",
"{",
"eventType",
"=",
"common",
".",
"LinuxProcessPU",
"\n",
"eventPUID",
"=",
"c",
".",
"Cgroup",
"[",
"len",
"(",
"common",
".",
"TriremeCgroupPath",
")",
":",
"]",
"\n",
"}",
"else",
"{",
"// Not our Cgroup",
"return",
"nil",
"\n",
"}",
"\n\n",
"request",
":=",
"&",
"common",
".",
"EventInfo",
"{",
"PUType",
":",
"eventType",
",",
"PUID",
":",
"eventPUID",
",",
"EventType",
":",
"common",
".",
"EventStop",
",",
"}",
"\n\n",
"// Send Stop request",
"if",
"err",
":=",
"sendRequest",
"(",
"r",
".",
"address",
",",
"request",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Send destroy request",
"request",
".",
"EventType",
"=",
"common",
".",
"EventDestroy",
"\n\n",
"return",
"sendRequest",
"(",
"r",
".",
"address",
",",
"request",
")",
"\n",
"}"
] | // DeleteCgroup will issue a delete command based on the cgroup
// This is used mainly by the cleaner. | [
"DeleteCgroup",
"will",
"issue",
"a",
"delete",
"command",
"based",
"on",
"the",
"cgroup",
"This",
"is",
"used",
"mainly",
"by",
"the",
"cleaner",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L284-L324 |
6,787 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | ExecuteRequest | 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 | 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)
}
} | [
"func",
"(",
"r",
"*",
"RequestProcessor",
")",
"ExecuteRequest",
"(",
"c",
"*",
"CLIRequest",
")",
"error",
"{",
"switch",
"c",
".",
"Request",
"{",
"case",
"CreateRequest",
":",
"return",
"r",
".",
"CreateAndRun",
"(",
"c",
")",
"\n",
"case",
"DeleteCgroupRequest",
":",
"return",
"r",
".",
"DeleteCgroup",
"(",
"c",
")",
"\n",
"case",
"DeleteServiceRequest",
":",
"return",
"r",
".",
"DeleteService",
"(",
"c",
")",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
".",
"Request",
")",
"\n",
"}",
"\n",
"}"
] | // ExecuteRequest executes the command with an RPC request | [
"ExecuteRequest",
"executes",
"the",
"command",
"with",
"an",
"RPC",
"request"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L327-L339 |
6,788 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | sendRequest | func sendRequest(address string, event *common.EventInfo) error {
client, err := client.NewClient(address)
if err != nil {
return err
}
return client.SendRequest(event)
} | go | func sendRequest(address string, event *common.EventInfo) error {
client, err := client.NewClient(address)
if err != nil {
return err
}
return client.SendRequest(event)
} | [
"func",
"sendRequest",
"(",
"address",
"string",
",",
"event",
"*",
"common",
".",
"EventInfo",
")",
"error",
"{",
"client",
",",
"err",
":=",
"client",
".",
"NewClient",
"(",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"client",
".",
"SendRequest",
"(",
"event",
")",
"\n",
"}"
] | // sendRequest sends an RPC request to the provided address | [
"sendRequest",
"sends",
"an",
"RPC",
"request",
"to",
"the",
"provided",
"address"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L342-L350 |
6,789 | aporeto-inc/trireme-lib | cmd/systemdutil/systemdutil.go | ParseServices | 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 := range ports {
// check for port string of form port#/udp eg 8085/udp
portProtocolPair := strings.Split(p, "/")
if len(portProtocolPair) > 2 || len(portProtocolPair) <= 0 {
return nil, fmt.Errorf("Invalid port format. Expected format is of form 80 or 8085/udp")
}
if len(portProtocolPair) == 2 {
if portProtocolPair[1] == "tcp" {
protocol = packet.IPProtocolTCP
} else if portProtocolPair[1] == "udp" {
protocol = packet.IPProtocolUDP
} else {
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),
Ports: s,
})
}
return services, nil
} | go | 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 := range ports {
// check for port string of form port#/udp eg 8085/udp
portProtocolPair := strings.Split(p, "/")
if len(portProtocolPair) > 2 || len(portProtocolPair) <= 0 {
return nil, fmt.Errorf("Invalid port format. Expected format is of form 80 or 8085/udp")
}
if len(portProtocolPair) == 2 {
if portProtocolPair[1] == "tcp" {
protocol = packet.IPProtocolTCP
} else if portProtocolPair[1] == "udp" {
protocol = packet.IPProtocolUDP
} else {
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),
Ports: s,
})
}
return services, nil
} | [
"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",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Parse the ports and create the services. Cleanup any bad ports",
"services",
":=",
"[",
"]",
"common",
".",
"Service",
"{",
"}",
"\n",
"protocol",
":=",
"packet",
".",
"IPProtocolTCP",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"ports",
"{",
"// check for port string of form port#/udp eg 8085/udp",
"portProtocolPair",
":=",
"strings",
".",
"Split",
"(",
"p",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"portProtocolPair",
")",
">",
"2",
"||",
"len",
"(",
"portProtocolPair",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"portProtocolPair",
")",
"==",
"2",
"{",
"if",
"portProtocolPair",
"[",
"1",
"]",
"==",
"\"",
"\"",
"{",
"protocol",
"=",
"packet",
".",
"IPProtocolTCP",
"\n",
"}",
"else",
"if",
"portProtocolPair",
"[",
"1",
"]",
"==",
"\"",
"\"",
"{",
"protocol",
"=",
"packet",
".",
"IPProtocolUDP",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"portspec",
".",
"NewPortSpecFromString",
"(",
"portProtocolPair",
"[",
"0",
"]",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"services",
"=",
"append",
"(",
"services",
",",
"common",
".",
"Service",
"{",
"Protocol",
":",
"uint8",
"(",
"protocol",
")",
",",
"Ports",
":",
"s",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"services",
",",
"nil",
"\n",
"}"
] | // ParseServices parses strings with the services and returns them in an
// validated slice | [
"ParseServices",
"parses",
"strings",
"with",
"the",
"services",
"and",
"returns",
"them",
"in",
"an",
"validated",
"slice"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/cmd/systemdutil/systemdutil.go#L354-L394 |
6,790 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | ComputeHmac256 | 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), nil
} | go | 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), nil
} | [
"func",
"ComputeHmac256",
"(",
"tags",
"[",
"]",
"byte",
",",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buffer",
"bytes",
".",
"Buffer",
"\n",
"if",
"err",
":=",
"binary",
".",
"Write",
"(",
"&",
"buffer",
",",
"binary",
".",
"BigEndian",
",",
"tags",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"h",
":=",
"hmac",
".",
"New",
"(",
"sha256",
".",
"New",
",",
"key",
")",
"\n\n",
"if",
"_",
",",
"err",
":=",
"h",
".",
"Write",
"(",
"buffer",
".",
"Bytes",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"[",
"]",
"byte",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"h",
".",
"Sum",
"(",
"nil",
")",
",",
"nil",
"\n\n",
"}"
] | // ComputeHmac256 computes the HMAC256 of the message | [
"ComputeHmac256",
"computes",
"the",
"HMAC256",
"of",
"the",
"message"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L21-L36 |
6,791 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | VerifyHmac | 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 | func VerifyHmac(tags []byte, expectedMAC []byte, key []byte) bool {
messageMAC, err := ComputeHmac256(tags, key)
if err != nil {
return false
}
return hmac.Equal(messageMAC, expectedMAC)
} | [
"func",
"VerifyHmac",
"(",
"tags",
"[",
"]",
"byte",
",",
"expectedMAC",
"[",
"]",
"byte",
",",
"key",
"[",
"]",
"byte",
")",
"bool",
"{",
"messageMAC",
",",
"err",
":=",
"ComputeHmac256",
"(",
"tags",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"hmac",
".",
"Equal",
"(",
"messageMAC",
",",
"expectedMAC",
")",
"\n",
"}"
] | // VerifyHmac verifies if the HMAC of the message matches the one provided | [
"VerifyHmac",
"verifies",
"if",
"the",
"HMAC",
"of",
"the",
"message",
"matches",
"the",
"one",
"provided"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L39-L46 |
6,792 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | GenerateRandomBytes | 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 | 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
} | [
"func",
"GenerateRandomBytes",
"(",
"n",
"int",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"n",
")",
"\n",
"_",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"b",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"s",
":=",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"b",
")",
"\n\n",
"return",
"[",
"]",
"byte",
"(",
"s",
"[",
":",
"n",
"]",
")",
",",
"nil",
"\n",
"}"
] | // GenerateRandomBytes returns securely generated random bytes.
// It will return an error if the system's secure random
// number generator fails to function correctly, in which
// case the caller should not continue. | [
"GenerateRandomBytes",
"returns",
"securely",
"generated",
"random",
"bytes",
".",
"It",
"will",
"return",
"an",
"error",
"if",
"the",
"system",
"s",
"secure",
"random",
"number",
"generator",
"fails",
"to",
"function",
"correctly",
"in",
"which",
"case",
"the",
"caller",
"should",
"not",
"continue",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L52-L64 |
6,793 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | GenerateRandomString | func GenerateRandomString(s int) (string, error) {
b, err := GenerateRandomBytes(s)
return base64.URLEncoding.EncodeToString(b), err
} | go | func GenerateRandomString(s int) (string, error) {
b, err := GenerateRandomBytes(s)
return base64.URLEncoding.EncodeToString(b), err
} | [
"func",
"GenerateRandomString",
"(",
"s",
"int",
")",
"(",
"string",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"GenerateRandomBytes",
"(",
"s",
")",
"\n",
"return",
"base64",
".",
"URLEncoding",
".",
"EncodeToString",
"(",
"b",
")",
",",
"err",
"\n",
"}"
] | // GenerateRandomString returns a URL-safe, base64 encoded
// securely generated random string.
// It will return an error if the system's secure random
// number generator fails to function correctly, in which
// case the caller should not continue. | [
"GenerateRandomString",
"returns",
"a",
"URL",
"-",
"safe",
"base64",
"encoded",
"securely",
"generated",
"random",
"string",
".",
"It",
"will",
"return",
"an",
"error",
"if",
"the",
"system",
"s",
"secure",
"random",
"number",
"generator",
"fails",
"to",
"function",
"correctly",
"in",
"which",
"case",
"the",
"caller",
"should",
"not",
"continue",
"."
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L71-L74 |
6,794 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | LoadRootCertificates | 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 | 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
} | [
"func",
"LoadRootCertificates",
"(",
"rootPEM",
"[",
"]",
"byte",
")",
"*",
"x509",
".",
"CertPool",
"{",
"roots",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n\n",
"ok",
":=",
"roots",
".",
"AppendCertsFromPEM",
"(",
"rootPEM",
")",
"\n",
"if",
"!",
"ok",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"ByteString",
"(",
"\"",
"\"",
",",
"rootPEM",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"roots",
"\n\n",
"}"
] | // LoadRootCertificates loads the certificates in the provide PEM buffer in a CertPool | [
"LoadRootCertificates",
"loads",
"the",
"certificates",
"in",
"the",
"provide",
"PEM",
"buffer",
"in",
"a",
"CertPool"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L93-L105 |
6,795 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | LoadEllipticCurveKey | 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
}
return key, nil
} | go | 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
}
return key, nil
} | [
"func",
"LoadEllipticCurveKey",
"(",
"keyPEM",
"[",
"]",
"byte",
")",
"(",
"*",
"ecdsa",
".",
"PrivateKey",
",",
"error",
")",
"{",
"block",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"keyPEM",
")",
"\n",
"if",
"block",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"keyPEM",
")",
")",
"\n",
"}",
"\n\n",
"// Parse the key",
"key",
",",
"err",
":=",
"x509",
".",
"ParseECPrivateKey",
"(",
"block",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"key",
",",
"nil",
"\n",
"}"
] | // LoadEllipticCurveKey parses and creates an EC key | [
"LoadEllipticCurveKey",
"parses",
"and",
"creates",
"an",
"EC",
"key"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L108-L122 |
6,796 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | LoadAndVerifyCertificate | 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 | 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
} | [
"func",
"LoadAndVerifyCertificate",
"(",
"certPEM",
"[",
"]",
"byte",
",",
"roots",
"*",
"x509",
".",
"CertPool",
")",
"(",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"cert",
",",
"err",
":=",
"LoadCertificate",
"(",
"certPEM",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"opts",
":=",
"x509",
".",
"VerifyOptions",
"{",
"Roots",
":",
"roots",
",",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"cert",
".",
"Verify",
"(",
"opts",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"cert",
",",
"nil",
"\n\n",
"}"
] | // LoadAndVerifyCertificate parses, validates, and creates a certificate structure from a PEM buffer
// It must be provided with the a CertPool | [
"LoadAndVerifyCertificate",
"parses",
"validates",
"and",
"creates",
"a",
"certificate",
"structure",
"from",
"a",
"PEM",
"buffer",
"It",
"must",
"be",
"provided",
"with",
"the",
"a",
"CertPool"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L126-L143 |
6,797 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | LoadAndVerifyECSecrets | 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 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, rootCertPool, nil
} | go | 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 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, rootCertPool, nil
} | [
"func",
"LoadAndVerifyECSecrets",
"(",
"keyPEM",
",",
"certPEM",
",",
"caCertPEM",
"[",
"]",
"byte",
")",
"(",
"key",
"*",
"ecdsa",
".",
"PrivateKey",
",",
"cert",
"*",
"x509",
".",
"Certificate",
",",
"rootCertPool",
"*",
"x509",
".",
"CertPool",
",",
"err",
"error",
")",
"{",
"// Parse the key",
"key",
",",
"err",
"=",
"LoadEllipticCurveKey",
"(",
"keyPEM",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"rootCertPool",
"=",
"LoadRootCertificates",
"(",
"caCertPEM",
")",
"\n",
"if",
"rootCertPool",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"err",
"=",
"LoadAndVerifyCertificate",
"(",
"certPEM",
",",
"rootCertPool",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"key",
",",
"cert",
",",
"rootCertPool",
",",
"nil",
"\n\n",
"}"
] | // LoadAndVerifyECSecrets loads all the certificates and keys to memory in the right data structures | [
"LoadAndVerifyECSecrets",
"loads",
"all",
"the",
"certificates",
"and",
"keys",
"to",
"memory",
"in",
"the",
"right",
"data",
"structures"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L146-L166 |
6,798 | aporeto-inc/trireme-lib | utils/crypto/crypto.go | LoadCertificate | 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.Bytes)
if err != nil {
return nil, err
}
return cert, nil
} | go | 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.Bytes)
if err != nil {
return nil, err
}
return cert, nil
} | [
"func",
"LoadCertificate",
"(",
"certPEM",
"[",
"]",
"byte",
")",
"(",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"// Decode the certificate",
"certBlock",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"certPEM",
")",
"\n",
"if",
"certBlock",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"certPEM",
")",
")",
"\n",
"}",
"\n\n",
"// Create the certificate structure",
"cert",
",",
"err",
":=",
"x509",
".",
"ParseCertificate",
"(",
"certBlock",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"cert",
",",
"nil",
"\n",
"}"
] | // LoadCertificate loads a certificate from a PEM file without verifying
// Should only be used for loading a root CA certificate. It will only read
// the first certificate | [
"LoadCertificate",
"loads",
"a",
"certificate",
"from",
"a",
"PEM",
"file",
"without",
"verifying",
"Should",
"only",
"be",
"used",
"for",
"loading",
"a",
"root",
"CA",
"certificate",
".",
"It",
"will",
"only",
"read",
"the",
"first",
"certificate"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/crypto/crypto.go#L171-L186 |
6,799 | aporeto-inc/trireme-lib | controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go | NewRPCClient | 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 | func (m *MockRPCClient) NewRPCClient(contextID, channel, rpcSecret string) error {
ret := m.ctrl.Call(m, "NewRPCClient", contextID, channel, rpcSecret)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockRPCClient",
")",
"NewRPCClient",
"(",
"contextID",
",",
"channel",
",",
"rpcSecret",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
",",
"channel",
",",
"rpcSecret",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // NewRPCClient mocks base method
// nolint | [
"NewRPCClient",
"mocks",
"base",
"method",
"nolint"
] | 009258cf9b4f3f70f71994d9fadebe564f7e0437 | https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/utils/rpcwrapper/mockrpcwrapper/mockrpcwrapper.go#L44-L48 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.