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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,400 |
aporeto-inc/trireme-lib
|
controller/pkg/usertokens/usetokens.go
|
NewVerifier
|
func NewVerifier(v Verifier) (Verifier, error) {
if v == nil {
return nil, nil
}
switch v.VerifierType() {
case common.PKI:
p := v.(*pkitokens.PKIJWTVerifier)
v, err := pkitokens.NewVerifier(p)
if err != nil {
return nil, err
}
return v, nil
case common.OIDC:
p := v.(*oidc.TokenVerifier)
verifier, err := oidc.NewClient(context.Background(), p)
if err != nil {
return nil, err
}
return verifier, nil
}
return nil, fmt.Errorf("uknown verifier type")
}
|
go
|
func NewVerifier(v Verifier) (Verifier, error) {
if v == nil {
return nil, nil
}
switch v.VerifierType() {
case common.PKI:
p := v.(*pkitokens.PKIJWTVerifier)
v, err := pkitokens.NewVerifier(p)
if err != nil {
return nil, err
}
return v, nil
case common.OIDC:
p := v.(*oidc.TokenVerifier)
verifier, err := oidc.NewClient(context.Background(), p)
if err != nil {
return nil, err
}
return verifier, nil
}
return nil, fmt.Errorf("uknown verifier type")
}
|
[
"func",
"NewVerifier",
"(",
"v",
"Verifier",
")",
"(",
"Verifier",
",",
"error",
")",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"switch",
"v",
".",
"VerifierType",
"(",
")",
"{",
"case",
"common",
".",
"PKI",
":",
"p",
":=",
"v",
".",
"(",
"*",
"pkitokens",
".",
"PKIJWTVerifier",
")",
"\n",
"v",
",",
"err",
":=",
"pkitokens",
".",
"NewVerifier",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"v",
",",
"nil",
"\n",
"case",
"common",
".",
"OIDC",
":",
"p",
":=",
"v",
".",
"(",
"*",
"oidc",
".",
"TokenVerifier",
")",
"\n",
"verifier",
",",
"err",
":=",
"oidc",
".",
"NewClient",
"(",
"context",
".",
"Background",
"(",
")",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"verifier",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// NewVerifier initializes data structures based on the interface that
// is transmitted over the RPC between main and remote enforcers.
|
[
"NewVerifier",
"initializes",
"data",
"structures",
"based",
"on",
"the",
"interface",
"that",
"is",
"transmitted",
"over",
"the",
"RPC",
"between",
"main",
"and",
"remote",
"enforcers",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/usertokens/usetokens.go#L26-L47
|
7,401 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/mockenforcer/mockenforcer.go
|
NewMockEnforcer
|
func NewMockEnforcer(ctrl *gomock.Controller) *MockEnforcer {
mock := &MockEnforcer{ctrl: ctrl}
mock.recorder = &MockEnforcerMockRecorder{mock}
return mock
}
|
go
|
func NewMockEnforcer(ctrl *gomock.Controller) *MockEnforcer {
mock := &MockEnforcer{ctrl: ctrl}
mock.recorder = &MockEnforcerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockEnforcer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockEnforcer",
"{",
"mock",
":=",
"&",
"MockEnforcer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockEnforcerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockEnforcer creates a new mock instance
// nolint
|
[
"NewMockEnforcer",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L35-L39
|
7,402 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/mockenforcer/mockenforcer.go
|
Unenforce
|
func (m *MockEnforcer) Unenforce(contextID string) error {
ret := m.ctrl.Call(m, "Unenforce", contextID)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockEnforcer) Unenforce(contextID string) error {
ret := m.ctrl.Call(m, "Unenforce", contextID)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockEnforcer",
")",
"Unenforce",
"(",
"contextID",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// Unenforce mocks base method
// nolint
|
[
"Unenforce",
"mocks",
"base",
"method",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L63-L67
|
7,403 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/mockenforcer/mockenforcer.go
|
GetFilterQueue
|
func (m *MockEnforcer) GetFilterQueue() *fqconfig.FilterQueue {
ret := m.ctrl.Call(m, "GetFilterQueue")
ret0, _ := ret[0].(*fqconfig.FilterQueue)
return ret0
}
|
go
|
func (m *MockEnforcer) GetFilterQueue() *fqconfig.FilterQueue {
ret := m.ctrl.Call(m, "GetFilterQueue")
ret0, _ := ret[0].(*fqconfig.FilterQueue)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockEnforcer",
")",
"GetFilterQueue",
"(",
")",
"*",
"fqconfig",
".",
"FilterQueue",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"fqconfig",
".",
"FilterQueue",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// GetFilterQueue mocks base method
// nolint
|
[
"GetFilterQueue",
"mocks",
"base",
"method",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L77-L81
|
7,404 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/mockenforcer/mockenforcer.go
|
GetFilterQueue
|
func (mr *MockEnforcerMockRecorder) GetFilterQueue() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilterQueue", reflect.TypeOf((*MockEnforcer)(nil).GetFilterQueue))
}
|
go
|
func (mr *MockEnforcerMockRecorder) GetFilterQueue() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilterQueue", reflect.TypeOf((*MockEnforcer)(nil).GetFilterQueue))
}
|
[
"func",
"(",
"mr",
"*",
"MockEnforcerMockRecorder",
")",
"GetFilterQueue",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockEnforcer",
")",
"(",
"nil",
")",
".",
"GetFilterQueue",
")",
")",
"\n",
"}"
] |
// GetFilterQueue indicates an expected call of GetFilterQueue
// nolint
|
[
"GetFilterQueue",
"indicates",
"an",
"expected",
"call",
"of",
"GetFilterQueue",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L85-L87
|
7,405 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/mockenforcer/mockenforcer.go
|
CleanUp
|
func (m *MockEnforcer) CleanUp() error {
ret := m.ctrl.Call(m, "CleanUp")
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockEnforcer) CleanUp() error {
ret := m.ctrl.Call(m, "CleanUp")
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockEnforcer",
")",
"CleanUp",
"(",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// CleanUp mocks base method
// nolint
|
[
"CleanUp",
"mocks",
"base",
"method",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L133-L137
|
7,406 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/mockenforcer/mockenforcer.go
|
EnableIPTablesPacketTracing
|
func (m *MockDebugInfo) EnableIPTablesPacketTracing(ctx context.Context, contextID string, interval time.Duration) error {
ret := m.ctrl.Call(m, "EnableIPTablesPacketTracing", ctx, contextID, interval)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockDebugInfo) EnableIPTablesPacketTracing(ctx context.Context, contextID string, interval time.Duration) error {
ret := m.ctrl.Call(m, "EnableIPTablesPacketTracing", ctx, contextID, interval)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockDebugInfo",
")",
"EnableIPTablesPacketTracing",
"(",
"ctx",
"context",
".",
"Context",
",",
"contextID",
"string",
",",
"interval",
"time",
".",
"Duration",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"ctx",
",",
"contextID",
",",
"interval",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// EnableIPTablesPacketTracing mocks base method
// nolint
|
[
"EnableIPTablesPacketTracing",
"mocks",
"base",
"method",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/mockenforcer/mockenforcer.go#L216-L220
|
7,407 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
GetUDPData
|
func (p *Packet) GetUDPData() []byte {
return p.ipHdr.Buffer[p.ipHdr.ipHeaderLen+UDPDataPos:]
}
|
go
|
func (p *Packet) GetUDPData() []byte {
return p.ipHdr.Buffer[p.ipHdr.ipHeaderLen+UDPDataPos:]
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"GetUDPData",
"(",
")",
"[",
"]",
"byte",
"{",
"return",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
"+",
"UDPDataPos",
":",
"]",
"\n",
"}"
] |
// GetUDPData return additional data in packet
|
[
"GetUDPData",
"return",
"additional",
"data",
"in",
"packet"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L143-L145
|
7,408 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
DropTCPDetachedBytes
|
func (p *Packet) DropTCPDetachedBytes() {
p.tcpHdr.tcpOptions = []byte{}
p.tcpHdr.tcpData = []byte{}
}
|
go
|
func (p *Packet) DropTCPDetachedBytes() {
p.tcpHdr.tcpOptions = []byte{}
p.tcpHdr.tcpData = []byte{}
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"DropTCPDetachedBytes",
"(",
")",
"{",
"p",
".",
"tcpHdr",
".",
"tcpOptions",
"=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpData",
"=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"}"
] |
// DropTCPDetachedBytes removes any bytes that have been detached and stored locally
|
[
"DropTCPDetachedBytes",
"removes",
"any",
"bytes",
"that",
"have",
"been",
"detached",
"and",
"stored",
"locally"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L168-L172
|
7,409 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
Print
|
func (p *Packet) Print(context uint64) {
if p.ipHdr.ipProto != IPProtocolTCP {
return
}
logPkt := false
detailed := false
if PacketLogLevel || context == 0 {
logPkt = true
detailed = true
}
var buf string
print := false
if logPkt {
if printCount%200 == 0 {
buf += fmt.Sprintf("Packet: %5s %5s %25s %15s %5s %15s %5s %6s %20s %20s %6s %20s %20s %2s %5s %5s\n",
"IPID", "Dir", "Comment", "SIP", "SP", "DIP", "DP", "Flags", "TCPSeq", "TCPAck", "TCPLen", "ExpAck", "ExpSeq", "DO", "Acsum", "Ccsum")
}
printCount++
offset := 0
if (p.GetTCPFlags() & TCPSynMask) == TCPSynMask {
offset = 1
}
expAck := p.tcpHdr.tcpSeq + uint32(uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes()) + uint32(offset)
ccsum := p.computeTCPChecksum()
csumValidationStr := ""
if p.tcpHdr.tcpChecksum != ccsum {
csumValidationStr = "Bad Checksum"
}
buf += fmt.Sprintf("Packet: %5d %5s %25s %15s %5d %15s %5d %6s %20d %20d %6d %20d %20d %2d %5d %5d %12s\n",
p.ipHdr.ipID,
flagsToDir(p.context|context),
flagsToStr(p.context|context),
p.ipHdr.sourceAddress.To4().String(), p.tcpHdr.sourcePort,
p.ipHdr.destinationAddress.To4().String(), p.tcpHdr.destinationPort,
tcpFlagsToStr(p.GetTCPFlags()),
p.tcpHdr.tcpSeq, p.tcpHdr.tcpAck, uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes(),
expAck, expAck, p.tcpHdr.tcpDataOffset,
p.tcpHdr.tcpChecksum, ccsum, csumValidationStr)
print = true
}
if detailed {
pktBytes := []byte{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 8, 0}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
buf += fmt.Sprintf("%s\n", hex.Dump(pktBytes))
print = true
}
if print {
zap.L().Debug(buf)
}
}
|
go
|
func (p *Packet) Print(context uint64) {
if p.ipHdr.ipProto != IPProtocolTCP {
return
}
logPkt := false
detailed := false
if PacketLogLevel || context == 0 {
logPkt = true
detailed = true
}
var buf string
print := false
if logPkt {
if printCount%200 == 0 {
buf += fmt.Sprintf("Packet: %5s %5s %25s %15s %5s %15s %5s %6s %20s %20s %6s %20s %20s %2s %5s %5s\n",
"IPID", "Dir", "Comment", "SIP", "SP", "DIP", "DP", "Flags", "TCPSeq", "TCPAck", "TCPLen", "ExpAck", "ExpSeq", "DO", "Acsum", "Ccsum")
}
printCount++
offset := 0
if (p.GetTCPFlags() & TCPSynMask) == TCPSynMask {
offset = 1
}
expAck := p.tcpHdr.tcpSeq + uint32(uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes()) + uint32(offset)
ccsum := p.computeTCPChecksum()
csumValidationStr := ""
if p.tcpHdr.tcpChecksum != ccsum {
csumValidationStr = "Bad Checksum"
}
buf += fmt.Sprintf("Packet: %5d %5s %25s %15s %5d %15s %5d %6s %20d %20d %6d %20d %20d %2d %5d %5d %12s\n",
p.ipHdr.ipID,
flagsToDir(p.context|context),
flagsToStr(p.context|context),
p.ipHdr.sourceAddress.To4().String(), p.tcpHdr.sourcePort,
p.ipHdr.destinationAddress.To4().String(), p.tcpHdr.destinationPort,
tcpFlagsToStr(p.GetTCPFlags()),
p.tcpHdr.tcpSeq, p.tcpHdr.tcpAck, uint16(len(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]))-p.TCPDataStartBytes(),
expAck, expAck, p.tcpHdr.tcpDataOffset,
p.tcpHdr.tcpChecksum, ccsum, csumValidationStr)
print = true
}
if detailed {
pktBytes := []byte{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 8, 0}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
buf += fmt.Sprintf("%s\n", hex.Dump(pktBytes))
print = true
}
if print {
zap.L().Debug(buf)
}
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"Print",
"(",
"context",
"uint64",
")",
"{",
"if",
"p",
".",
"ipHdr",
".",
"ipProto",
"!=",
"IPProtocolTCP",
"{",
"return",
"\n",
"}",
"\n\n",
"logPkt",
":=",
"false",
"\n",
"detailed",
":=",
"false",
"\n\n",
"if",
"PacketLogLevel",
"||",
"context",
"==",
"0",
"{",
"logPkt",
"=",
"true",
"\n",
"detailed",
"=",
"true",
"\n",
"}",
"\n\n",
"var",
"buf",
"string",
"\n",
"print",
":=",
"false",
"\n\n",
"if",
"logPkt",
"{",
"if",
"printCount",
"%",
"200",
"==",
"0",
"{",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"printCount",
"++",
"\n",
"offset",
":=",
"0",
"\n\n",
"if",
"(",
"p",
".",
"GetTCPFlags",
"(",
")",
"&",
"TCPSynMask",
")",
"==",
"TCPSynMask",
"{",
"offset",
"=",
"1",
"\n",
"}",
"\n\n",
"expAck",
":=",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"+",
"uint32",
"(",
"uint16",
"(",
"len",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
")",
")",
"-",
"p",
".",
"TCPDataStartBytes",
"(",
")",
")",
"+",
"uint32",
"(",
"offset",
")",
"\n",
"ccsum",
":=",
"p",
".",
"computeTCPChecksum",
"(",
")",
"\n",
"csumValidationStr",
":=",
"\"",
"\"",
"\n\n",
"if",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
"!=",
"ccsum",
"{",
"csumValidationStr",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"p",
".",
"ipHdr",
".",
"ipID",
",",
"flagsToDir",
"(",
"p",
".",
"context",
"|",
"context",
")",
",",
"flagsToStr",
"(",
"p",
".",
"context",
"|",
"context",
")",
",",
"p",
".",
"ipHdr",
".",
"sourceAddress",
".",
"To4",
"(",
")",
".",
"String",
"(",
")",
",",
"p",
".",
"tcpHdr",
".",
"sourcePort",
",",
"p",
".",
"ipHdr",
".",
"destinationAddress",
".",
"To4",
"(",
")",
".",
"String",
"(",
")",
",",
"p",
".",
"tcpHdr",
".",
"destinationPort",
",",
"tcpFlagsToStr",
"(",
"p",
".",
"GetTCPFlags",
"(",
")",
")",
",",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
",",
"p",
".",
"tcpHdr",
".",
"tcpAck",
",",
"uint16",
"(",
"len",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
")",
")",
"-",
"p",
".",
"TCPDataStartBytes",
"(",
")",
",",
"expAck",
",",
"expAck",
",",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
",",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
",",
"ccsum",
",",
"csumValidationStr",
")",
"\n",
"print",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"detailed",
"{",
"pktBytes",
":=",
"[",
"]",
"byte",
"{",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"1",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"2",
",",
"8",
",",
"0",
"}",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"ipHdr",
".",
"Buffer",
"...",
")",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"tcpHdr",
".",
"tcpOptions",
"...",
")",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"tcpHdr",
".",
"tcpData",
"...",
")",
"\n",
"buf",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"hex",
".",
"Dump",
"(",
"pktBytes",
")",
")",
"\n",
"print",
"=",
"true",
"\n",
"}",
"\n\n",
"if",
"print",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"buf",
")",
"\n",
"}",
"\n",
"}"
] |
// Print is a print helper function
|
[
"Print",
"is",
"a",
"print",
"helper",
"function"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L185-L247
|
7,410 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
GetTCPBytes
|
func (p *Packet) GetTCPBytes() []byte {
pktBytes := []byte{}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
return pktBytes
}
|
go
|
func (p *Packet) GetTCPBytes() []byte {
pktBytes := []byte{}
pktBytes = append(pktBytes, p.ipHdr.Buffer...)
pktBytes = append(pktBytes, p.tcpHdr.tcpOptions...)
pktBytes = append(pktBytes, p.tcpHdr.tcpData...)
return pktBytes
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"GetTCPBytes",
"(",
")",
"[",
"]",
"byte",
"{",
"pktBytes",
":=",
"[",
"]",
"byte",
"{",
"}",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"ipHdr",
".",
"Buffer",
"...",
")",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"tcpHdr",
".",
"tcpOptions",
"...",
")",
"\n",
"pktBytes",
"=",
"append",
"(",
"pktBytes",
",",
"p",
".",
"tcpHdr",
".",
"tcpData",
"...",
")",
"\n",
"return",
"pktBytes",
"\n",
"}"
] |
//GetTCPBytes returns the bytes in the packet. It consolidates in case of changes as well
|
[
"GetTCPBytes",
"returns",
"the",
"bytes",
"in",
"the",
"packet",
".",
"It",
"consolidates",
"in",
"case",
"of",
"changes",
"as",
"well"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L250-L257
|
7,411 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
ReadTCPData
|
func (p *Packet) ReadTCPData() []byte {
return p.ipHdr.Buffer[uint16(p.ipHdr.ipHeaderLen)+p.TCPDataStartBytes():]
}
|
go
|
func (p *Packet) ReadTCPData() []byte {
return p.ipHdr.Buffer[uint16(p.ipHdr.ipHeaderLen)+p.TCPDataStartBytes():]
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"ReadTCPData",
"(",
")",
"[",
"]",
"byte",
"{",
"return",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"uint16",
"(",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
")",
"+",
"p",
".",
"TCPDataStartBytes",
"(",
")",
":",
"]",
"\n",
"}"
] |
// ReadTCPData returns ths payload in a string variable
// It does not remove the payload from the packet
|
[
"ReadTCPData",
"returns",
"ths",
"payload",
"in",
"a",
"string",
"variable",
"It",
"does",
"not",
"remove",
"the",
"payload",
"from",
"the",
"packet"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L267-L269
|
7,412 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
CheckTCPAuthenticationOption
|
func (p *Packet) CheckTCPAuthenticationOption(iOptionLength int) (err error) {
tcpDataStart := p.TCPDataStartBytes()
if tcpDataStart <= minTCPIPPacketLen {
return errTCPAuthOption
}
optionLength := uint16(iOptionLength)
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
// Our option was not found in the right place. We don't do anything
// for this packet.
if buffer[tcpDataStart-optionLength] != TCPAuthenticationOption {
return errTCPAuthOption
}
return
}
|
go
|
func (p *Packet) CheckTCPAuthenticationOption(iOptionLength int) (err error) {
tcpDataStart := p.TCPDataStartBytes()
if tcpDataStart <= minTCPIPPacketLen {
return errTCPAuthOption
}
optionLength := uint16(iOptionLength)
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
// Our option was not found in the right place. We don't do anything
// for this packet.
if buffer[tcpDataStart-optionLength] != TCPAuthenticationOption {
return errTCPAuthOption
}
return
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"CheckTCPAuthenticationOption",
"(",
"iOptionLength",
"int",
")",
"(",
"err",
"error",
")",
"{",
"tcpDataStart",
":=",
"p",
".",
"TCPDataStartBytes",
"(",
")",
"\n\n",
"if",
"tcpDataStart",
"<=",
"minTCPIPPacketLen",
"{",
"return",
"errTCPAuthOption",
"\n",
"}",
"\n\n",
"optionLength",
":=",
"uint16",
"(",
"iOptionLength",
")",
"\n",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"// Our option was not found in the right place. We don't do anything",
"// for this packet.",
"if",
"buffer",
"[",
"tcpDataStart",
"-",
"optionLength",
"]",
"!=",
"TCPAuthenticationOption",
"{",
"return",
"errTCPAuthOption",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckTCPAuthenticationOption ensures authentication option exists at the offset provided
|
[
"CheckTCPAuthenticationOption",
"ensures",
"authentication",
"option",
"exists",
"at",
"the",
"offset",
"provided"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L272-L289
|
7,413 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
FixupIPHdrOnDataModify
|
func (p *Packet) FixupIPHdrOnDataModify(old, new uint16) {
// IP Header Processing
// IP chekcsum fixup.
p.ipHdr.ipChecksum = incCsum16(p.ipHdr.ipChecksum, old, new)
// Update IP Total Length.
p.ipHdr.ipTotalLength = p.ipHdr.ipTotalLength + new - old
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4LengthPos:ipv4LengthPos+2], p.ipHdr.ipTotalLength)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
}
|
go
|
func (p *Packet) FixupIPHdrOnDataModify(old, new uint16) {
// IP Header Processing
// IP chekcsum fixup.
p.ipHdr.ipChecksum = incCsum16(p.ipHdr.ipChecksum, old, new)
// Update IP Total Length.
p.ipHdr.ipTotalLength = p.ipHdr.ipTotalLength + new - old
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4LengthPos:ipv4LengthPos+2], p.ipHdr.ipTotalLength)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"FixupIPHdrOnDataModify",
"(",
"old",
",",
"new",
"uint16",
")",
"{",
"// IP Header Processing",
"// IP chekcsum fixup.",
"p",
".",
"ipHdr",
".",
"ipChecksum",
"=",
"incCsum16",
"(",
"p",
".",
"ipHdr",
".",
"ipChecksum",
",",
"old",
",",
"new",
")",
"\n",
"// Update IP Total Length.",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
"=",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
"+",
"new",
"-",
"old",
"\n\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4LengthPos",
":",
"ipv4LengthPos",
"+",
"2",
"]",
",",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"ipv4ChecksumPos",
":",
"ipv4ChecksumPos",
"+",
"2",
"]",
",",
"p",
".",
"ipHdr",
".",
"ipChecksum",
")",
"\n",
"}"
] |
// FixupIPHdrOnDataModify modifies the IP header fields and checksum
|
[
"FixupIPHdrOnDataModify",
"modifies",
"the",
"IP",
"header",
"fields",
"and",
"checksum"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L292-L301
|
7,414 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
IncreaseTCPSeq
|
func (p *Packet) IncreaseTCPSeq(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq + incr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
}
|
go
|
func (p *Packet) IncreaseTCPSeq(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq + incr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"IncreaseTCPSeq",
"(",
"incr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"=",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"+",
"incr",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"buffer",
"[",
"tcpSeqPos",
":",
"tcpSeqPos",
"+",
"4",
"]",
",",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
")",
"\n",
"}"
] |
// IncreaseTCPSeq increases TCP seq number by incr
|
[
"IncreaseTCPSeq",
"increases",
"TCP",
"seq",
"number",
"by",
"incr"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L304-L308
|
7,415 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
DecreaseTCPSeq
|
func (p *Packet) DecreaseTCPSeq(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq - decr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
}
|
go
|
func (p *Packet) DecreaseTCPSeq(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpSeq = p.tcpHdr.tcpSeq - decr
binary.BigEndian.PutUint32(buffer[tcpSeqPos:tcpSeqPos+4], p.tcpHdr.tcpSeq)
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"DecreaseTCPSeq",
"(",
"decr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"=",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
"-",
"decr",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"buffer",
"[",
"tcpSeqPos",
":",
"tcpSeqPos",
"+",
"4",
"]",
",",
"p",
".",
"tcpHdr",
".",
"tcpSeq",
")",
"\n",
"}"
] |
// DecreaseTCPSeq decreases TCP seq number by decr
|
[
"DecreaseTCPSeq",
"decreases",
"TCP",
"seq",
"number",
"by",
"decr"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L311-L315
|
7,416 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
IncreaseTCPAck
|
func (p *Packet) IncreaseTCPAck(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck + incr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
}
|
go
|
func (p *Packet) IncreaseTCPAck(incr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck + incr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"IncreaseTCPAck",
"(",
"incr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpAck",
"=",
"p",
".",
"tcpHdr",
".",
"tcpAck",
"+",
"incr",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"buffer",
"[",
"tcpAckPos",
":",
"tcpAckPos",
"+",
"4",
"]",
",",
"p",
".",
"tcpHdr",
".",
"tcpAck",
")",
"\n",
"}"
] |
// IncreaseTCPAck increases TCP ack number by incr
|
[
"IncreaseTCPAck",
"increases",
"TCP",
"ack",
"number",
"by",
"incr"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L318-L322
|
7,417 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
DecreaseTCPAck
|
func (p *Packet) DecreaseTCPAck(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck - decr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
}
|
go
|
func (p *Packet) DecreaseTCPAck(decr uint32) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpAck = p.tcpHdr.tcpAck - decr
binary.BigEndian.PutUint32(buffer[tcpAckPos:tcpAckPos+4], p.tcpHdr.tcpAck)
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"DecreaseTCPAck",
"(",
"decr",
"uint32",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpAck",
"=",
"p",
".",
"tcpHdr",
".",
"tcpAck",
"-",
"decr",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"buffer",
"[",
"tcpAckPos",
":",
"tcpAckPos",
"+",
"4",
"]",
",",
"p",
".",
"tcpHdr",
".",
"tcpAck",
")",
"\n",
"}"
] |
// DecreaseTCPAck decreases TCP ack number by decr
|
[
"DecreaseTCPAck",
"decreases",
"TCP",
"ack",
"number",
"by",
"decr"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L325-L329
|
7,418 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
FixuptcpHdrOnTCPDataDetach
|
func (p *Packet) FixuptcpHdrOnTCPDataDetach(dataLength uint16, optionLength uint16) {
// Update DataOffset
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset - uint8(optionLength/4)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
}
|
go
|
func (p *Packet) FixuptcpHdrOnTCPDataDetach(dataLength uint16, optionLength uint16) {
// Update DataOffset
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset - uint8(optionLength/4)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"FixuptcpHdrOnTCPDataDetach",
"(",
"dataLength",
"uint16",
",",
"optionLength",
"uint16",
")",
"{",
"// Update DataOffset",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
"=",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
"-",
"uint8",
"(",
"optionLength",
"/",
"4",
")",
"\n",
"buffer",
"[",
"tcpDataOffsetPos",
"]",
"=",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
"<<",
"4",
"\n",
"}"
] |
// FixuptcpHdrOnTCPDataDetach modifies the TCP header fields and checksum
|
[
"FixuptcpHdrOnTCPDataDetach",
"modifies",
"the",
"TCP",
"header",
"fields",
"and",
"checksum"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L332-L338
|
7,419 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
FixuptcpHdrOnTCPDataAttach
|
func (p *Packet) FixuptcpHdrOnTCPDataAttach(tcpOptions []byte, tcpData []byte) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
numberOfOptions := len(tcpOptions) / 4
// Modify the fields
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset + uint8(numberOfOptions)
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
}
|
go
|
func (p *Packet) FixuptcpHdrOnTCPDataAttach(tcpOptions []byte, tcpData []byte) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
numberOfOptions := len(tcpOptions) / 4
// Modify the fields
p.tcpHdr.tcpDataOffset = p.tcpHdr.tcpDataOffset + uint8(numberOfOptions)
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
buffer[tcpDataOffsetPos] = p.tcpHdr.tcpDataOffset << 4
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"FixuptcpHdrOnTCPDataAttach",
"(",
"tcpOptions",
"[",
"]",
"byte",
",",
"tcpData",
"[",
"]",
"byte",
")",
"{",
"buffer",
":=",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"p",
".",
"ipHdr",
".",
"ipHeaderLen",
":",
"]",
"\n",
"numberOfOptions",
":=",
"len",
"(",
"tcpOptions",
")",
"/",
"4",
"\n\n",
"// Modify the fields",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
"=",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
"+",
"uint8",
"(",
"numberOfOptions",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buffer",
"[",
"tcpChecksumPos",
":",
"tcpChecksumPos",
"+",
"2",
"]",
",",
"p",
".",
"tcpHdr",
".",
"tcpChecksum",
")",
"\n",
"buffer",
"[",
"tcpDataOffsetPos",
"]",
"=",
"p",
".",
"tcpHdr",
".",
"tcpDataOffset",
"<<",
"4",
"\n",
"}"
] |
// FixuptcpHdrOnTCPDataAttach modifies the TCP header fields and checksum
|
[
"FixuptcpHdrOnTCPDataAttach",
"modifies",
"the",
"TCP",
"header",
"fields",
"and",
"checksum"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L382-L390
|
7,420 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
TCPDataAttach
|
func (p *Packet) TCPDataAttach(tcpOptions []byte, tcpData []byte) (err error) {
if err = p.tcpDataAttach(tcpOptions, tcpData); err != nil {
return fmt.Errorf("tcp data attachment failed: %s", err)
}
// We are increasing tcpOptions by 1 32-bit word. We are always adding
// our option last.
packetLenIncrease := uint16(len(tcpData) + len(tcpOptions))
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLength+packetLenIncrease)
// TCP Header Processing
p.FixuptcpHdrOnTCPDataAttach(tcpOptions, tcpData)
return
}
|
go
|
func (p *Packet) TCPDataAttach(tcpOptions []byte, tcpData []byte) (err error) {
if err = p.tcpDataAttach(tcpOptions, tcpData); err != nil {
return fmt.Errorf("tcp data attachment failed: %s", err)
}
// We are increasing tcpOptions by 1 32-bit word. We are always adding
// our option last.
packetLenIncrease := uint16(len(tcpData) + len(tcpOptions))
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLength+packetLenIncrease)
// TCP Header Processing
p.FixuptcpHdrOnTCPDataAttach(tcpOptions, tcpData)
return
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"TCPDataAttach",
"(",
"tcpOptions",
"[",
"]",
"byte",
",",
"tcpData",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"p",
".",
"tcpDataAttach",
"(",
"tcpOptions",
",",
"tcpData",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// We are increasing tcpOptions by 1 32-bit word. We are always adding",
"// our option last.",
"packetLenIncrease",
":=",
"uint16",
"(",
"len",
"(",
"tcpData",
")",
"+",
"len",
"(",
"tcpOptions",
")",
")",
"\n",
"// IP Header Processing",
"p",
".",
"FixupIPHdrOnDataModify",
"(",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
",",
"p",
".",
"ipHdr",
".",
"ipTotalLength",
"+",
"packetLenIncrease",
")",
"\n\n",
"// TCP Header Processing",
"p",
".",
"FixuptcpHdrOnTCPDataAttach",
"(",
"tcpOptions",
",",
"tcpData",
")",
"\n\n",
"return",
"\n",
"}"
] |
// TCPDataAttach modifies the TCP and IP header fields and checksum
|
[
"TCPDataAttach",
"modifies",
"the",
"TCP",
"and",
"IP",
"header",
"fields",
"and",
"checksum"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L406-L422
|
7,421 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
L4FlowHash
|
func (p *Packet) L4FlowHash() string {
return p.ipHdr.sourceAddress.String() + ":" + p.ipHdr.destinationAddress.String() + ":" + strconv.Itoa(int(p.SourcePort())) + ":" + strconv.Itoa(int(p.DestPort()))
}
|
go
|
func (p *Packet) L4FlowHash() string {
return p.ipHdr.sourceAddress.String() + ":" + p.ipHdr.destinationAddress.String() + ":" + strconv.Itoa(int(p.SourcePort())) + ":" + strconv.Itoa(int(p.DestPort()))
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"L4FlowHash",
"(",
")",
"string",
"{",
"return",
"p",
".",
"ipHdr",
".",
"sourceAddress",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"p",
".",
"ipHdr",
".",
"destinationAddress",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"p",
".",
"SourcePort",
"(",
")",
")",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"p",
".",
"DestPort",
"(",
")",
")",
")",
"\n",
"}"
] |
// L4FlowHash calculate a hash string based on the 4-tuple
|
[
"L4FlowHash",
"calculate",
"a",
"hash",
"string",
"based",
"on",
"the",
"4",
"-",
"tuple"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L425-L427
|
7,422 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
ID
|
func (p *Packet) ID() string {
return strconv.Itoa(int(p.ipHdr.ipID))
}
|
go
|
func (p *Packet) ID() string {
return strconv.Itoa(int(p.ipHdr.ipID))
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"ID",
"(",
")",
"string",
"{",
"return",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"p",
".",
"ipHdr",
".",
"ipID",
")",
")",
"\n",
"}"
] |
// ID returns the IP ID of the packet
|
[
"ID",
"returns",
"the",
"IP",
"ID",
"of",
"the",
"packet"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L444-L446
|
7,423 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/packet.go
|
GetBuffer
|
func (p *Packet) GetBuffer(offset int) []byte {
return p.ipHdr.Buffer[offset:]
}
|
go
|
func (p *Packet) GetBuffer(offset int) []byte {
return p.ipHdr.Buffer[offset:]
}
|
[
"func",
"(",
"p",
"*",
"Packet",
")",
"GetBuffer",
"(",
"offset",
"int",
")",
"[",
"]",
"byte",
"{",
"return",
"p",
".",
"ipHdr",
".",
"Buffer",
"[",
"offset",
":",
"]",
"\n",
"}"
] |
//GetBuffer returns the slice representing the buffer at offset specified
|
[
"GetBuffer",
"returns",
"the",
"slice",
"representing",
"the",
"buffer",
"at",
"offset",
"specified"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/packet.go#L502-L504
|
7,424 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
NewInstance
|
func NewInstance(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration) (*Instance, error) {
ipt, err := provider.NewGoIPTablesProvider([]string{"mangle"})
if err != nil {
return nil, fmt.Errorf("unable to initialize iptables provider: %s", err)
}
ips := provider.NewGoIPsetProvider()
return newInstanceWithProviders(fqc, mode, cfg, ipt, ips)
}
|
go
|
func NewInstance(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration) (*Instance, error) {
ipt, err := provider.NewGoIPTablesProvider([]string{"mangle"})
if err != nil {
return nil, fmt.Errorf("unable to initialize iptables provider: %s", err)
}
ips := provider.NewGoIPsetProvider()
return newInstanceWithProviders(fqc, mode, cfg, ipt, ips)
}
|
[
"func",
"NewInstance",
"(",
"fqc",
"*",
"fqconfig",
".",
"FilterQueue",
",",
"mode",
"constants",
".",
"ModeType",
",",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"(",
"*",
"Instance",
",",
"error",
")",
"{",
"ipt",
",",
"err",
":=",
"provider",
".",
"NewGoIPTablesProvider",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"ips",
":=",
"provider",
".",
"NewGoIPsetProvider",
"(",
")",
"\n",
"return",
"newInstanceWithProviders",
"(",
"fqc",
",",
"mode",
",",
"cfg",
",",
"ipt",
",",
"ips",
")",
"\n",
"}"
] |
// NewInstance creates a new iptables controller instance
|
[
"NewInstance",
"creates",
"a",
"new",
"iptables",
"controller",
"instance"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L105-L114
|
7,425 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
newInstanceWithProviders
|
func newInstanceWithProviders(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration, ipt provider.IptablesProvider, ips provider.IpsetProvider) (*Instance, error) {
if cfg == nil {
cfg = &runtime.Configuration{}
}
i := &Instance{
fqc: fqc,
ipt: ipt,
ipset: ips,
appPacketIPTableContext: "mangle",
netPacketIPTableContext: "mangle",
appProxyIPTableContext: "nat",
mode: mode,
appPacketIPTableSection: ipTableSectionOutput,
appCgroupIPTableSection: TriremeOutput,
netLinuxIPTableSection: TriremeInput,
netPacketIPTableSection: ipTableSectionInput,
appSynAckIPTableSection: ipTableSectionOutput,
contextIDToPortSetMap: cache.NewCache("contextIDToPortSetMap"),
createPUPortSet: ipsetCreatePortset,
isLegacyKernel: buildflags.IsLegacyKernel(),
serviceIDToIPsets: map[string]*ipsetInfo{},
puToServiceIDs: map[string][]string{},
cfg: cfg,
conntrackCmd: flushUDPConntrack,
}
lock.Lock()
instance = i
defer lock.Unlock()
return i, nil
}
|
go
|
func newInstanceWithProviders(fqc *fqconfig.FilterQueue, mode constants.ModeType, cfg *runtime.Configuration, ipt provider.IptablesProvider, ips provider.IpsetProvider) (*Instance, error) {
if cfg == nil {
cfg = &runtime.Configuration{}
}
i := &Instance{
fqc: fqc,
ipt: ipt,
ipset: ips,
appPacketIPTableContext: "mangle",
netPacketIPTableContext: "mangle",
appProxyIPTableContext: "nat",
mode: mode,
appPacketIPTableSection: ipTableSectionOutput,
appCgroupIPTableSection: TriremeOutput,
netLinuxIPTableSection: TriremeInput,
netPacketIPTableSection: ipTableSectionInput,
appSynAckIPTableSection: ipTableSectionOutput,
contextIDToPortSetMap: cache.NewCache("contextIDToPortSetMap"),
createPUPortSet: ipsetCreatePortset,
isLegacyKernel: buildflags.IsLegacyKernel(),
serviceIDToIPsets: map[string]*ipsetInfo{},
puToServiceIDs: map[string][]string{},
cfg: cfg,
conntrackCmd: flushUDPConntrack,
}
lock.Lock()
instance = i
defer lock.Unlock()
return i, nil
}
|
[
"func",
"newInstanceWithProviders",
"(",
"fqc",
"*",
"fqconfig",
".",
"FilterQueue",
",",
"mode",
"constants",
".",
"ModeType",
",",
"cfg",
"*",
"runtime",
".",
"Configuration",
",",
"ipt",
"provider",
".",
"IptablesProvider",
",",
"ips",
"provider",
".",
"IpsetProvider",
")",
"(",
"*",
"Instance",
",",
"error",
")",
"{",
"if",
"cfg",
"==",
"nil",
"{",
"cfg",
"=",
"&",
"runtime",
".",
"Configuration",
"{",
"}",
"\n",
"}",
"\n\n",
"i",
":=",
"&",
"Instance",
"{",
"fqc",
":",
"fqc",
",",
"ipt",
":",
"ipt",
",",
"ipset",
":",
"ips",
",",
"appPacketIPTableContext",
":",
"\"",
"\"",
",",
"netPacketIPTableContext",
":",
"\"",
"\"",
",",
"appProxyIPTableContext",
":",
"\"",
"\"",
",",
"mode",
":",
"mode",
",",
"appPacketIPTableSection",
":",
"ipTableSectionOutput",
",",
"appCgroupIPTableSection",
":",
"TriremeOutput",
",",
"netLinuxIPTableSection",
":",
"TriremeInput",
",",
"netPacketIPTableSection",
":",
"ipTableSectionInput",
",",
"appSynAckIPTableSection",
":",
"ipTableSectionOutput",
",",
"contextIDToPortSetMap",
":",
"cache",
".",
"NewCache",
"(",
"\"",
"\"",
")",
",",
"createPUPortSet",
":",
"ipsetCreatePortset",
",",
"isLegacyKernel",
":",
"buildflags",
".",
"IsLegacyKernel",
"(",
")",
",",
"serviceIDToIPsets",
":",
"map",
"[",
"string",
"]",
"*",
"ipsetInfo",
"{",
"}",
",",
"puToServiceIDs",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"cfg",
":",
"cfg",
",",
"conntrackCmd",
":",
"flushUDPConntrack",
",",
"}",
"\n\n",
"lock",
".",
"Lock",
"(",
")",
"\n",
"instance",
"=",
"i",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"i",
",",
"nil",
"\n",
"}"
] |
// newInstanceWithProviders is called after ipt and ips have been created. This helps
// with all the unit testing to be able to mock the providers.
|
[
"newInstanceWithProviders",
"is",
"called",
"after",
"ipt",
"and",
"ips",
"have",
"been",
"created",
".",
"This",
"helps",
"with",
"all",
"the",
"unit",
"testing",
"to",
"be",
"able",
"to",
"mock",
"the",
"providers",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L118-L151
|
7,426 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
Run
|
func (i *Instance) Run(ctx context.Context) error {
go func() {
<-ctx.Done()
zap.L().Debug("Stop the supervisor")
i.CleanUp() // nolint
}()
// Clean any previous ACLs. This is needed in case we crashed at some
// earlier point or there are other ACLs that create conflicts. We
// try to clean only ACLs related to Trireme.
if err := i.cleanACLs(); err != nil {
return fmt.Errorf("Unable to clean previous acls while starting the supervisor: %s", err)
}
// Create all the basic target sets. These are the global target sets
// that do not depend on policy configuration. If they already exist
// we will delete them and start again.
targetTCPSet, targetUDPSet, excludedSet, err := createGlobalSets(i.ipset)
if err != nil {
return fmt.Errorf("unable to create global sets: %s", err)
}
i.targetTCPSet = targetTCPSet
i.targetUDPSet = targetUDPSet
i.excludedNetworksSet = excludedSet
if err := i.updateAllTargetNetworks(i.cfg, &runtime.Configuration{}); err != nil {
// If there is a failure try to clean up on exit.
i.ipset.DestroyAll(chainPrefix) // nolint errcheck
return fmt.Errorf("unable to initialize target networks: %s", err)
}
// Initialize all the global Trireme chains. There are several global chaims
// that apply to all PUs:
// Tri-App/Tri-Net are the main chains for the egress/ingress directions
// UID related chains for any UID PUs.
// Host, Service, Pid chains for the different modes of operation (host mode, pu mode, host service).
// The priority is explicit (Pid activations take precedence of Service activations and Host Services)
if err := i.initializeChains(); err != nil {
return fmt.Errorf("Unable to initialize chains: %s", err)
}
// Insert the global ACLS. These are the main ACLs that will direct traffic from
// the INPUT/OUTPUT chains to the Trireme chains. They also includes the main
// rules of the main chains. These rules are never touched again, unless
// if we gracefully terminate.
if err := i.setGlobalRules(); err != nil {
return fmt.Errorf("failed to update synack networks: %s", err)
}
return nil
}
|
go
|
func (i *Instance) Run(ctx context.Context) error {
go func() {
<-ctx.Done()
zap.L().Debug("Stop the supervisor")
i.CleanUp() // nolint
}()
// Clean any previous ACLs. This is needed in case we crashed at some
// earlier point or there are other ACLs that create conflicts. We
// try to clean only ACLs related to Trireme.
if err := i.cleanACLs(); err != nil {
return fmt.Errorf("Unable to clean previous acls while starting the supervisor: %s", err)
}
// Create all the basic target sets. These are the global target sets
// that do not depend on policy configuration. If they already exist
// we will delete them and start again.
targetTCPSet, targetUDPSet, excludedSet, err := createGlobalSets(i.ipset)
if err != nil {
return fmt.Errorf("unable to create global sets: %s", err)
}
i.targetTCPSet = targetTCPSet
i.targetUDPSet = targetUDPSet
i.excludedNetworksSet = excludedSet
if err := i.updateAllTargetNetworks(i.cfg, &runtime.Configuration{}); err != nil {
// If there is a failure try to clean up on exit.
i.ipset.DestroyAll(chainPrefix) // nolint errcheck
return fmt.Errorf("unable to initialize target networks: %s", err)
}
// Initialize all the global Trireme chains. There are several global chaims
// that apply to all PUs:
// Tri-App/Tri-Net are the main chains for the egress/ingress directions
// UID related chains for any UID PUs.
// Host, Service, Pid chains for the different modes of operation (host mode, pu mode, host service).
// The priority is explicit (Pid activations take precedence of Service activations and Host Services)
if err := i.initializeChains(); err != nil {
return fmt.Errorf("Unable to initialize chains: %s", err)
}
// Insert the global ACLS. These are the main ACLs that will direct traffic from
// the INPUT/OUTPUT chains to the Trireme chains. They also includes the main
// rules of the main chains. These rules are never touched again, unless
// if we gracefully terminate.
if err := i.setGlobalRules(); err != nil {
return fmt.Errorf("failed to update synack networks: %s", err)
}
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"go",
"func",
"(",
")",
"{",
"<-",
"ctx",
".",
"Done",
"(",
")",
"\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"i",
".",
"CleanUp",
"(",
")",
"// nolint",
"\n",
"}",
"(",
")",
"\n\n",
"// Clean any previous ACLs. This is needed in case we crashed at some",
"// earlier point or there are other ACLs that create conflicts. We",
"// try to clean only ACLs related to Trireme.",
"if",
"err",
":=",
"i",
".",
"cleanACLs",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Create all the basic target sets. These are the global target sets",
"// that do not depend on policy configuration. If they already exist",
"// we will delete them and start again.",
"targetTCPSet",
",",
"targetUDPSet",
",",
"excludedSet",
",",
"err",
":=",
"createGlobalSets",
"(",
"i",
".",
"ipset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"i",
".",
"targetTCPSet",
"=",
"targetTCPSet",
"\n",
"i",
".",
"targetUDPSet",
"=",
"targetUDPSet",
"\n",
"i",
".",
"excludedNetworksSet",
"=",
"excludedSet",
"\n\n",
"if",
"err",
":=",
"i",
".",
"updateAllTargetNetworks",
"(",
"i",
".",
"cfg",
",",
"&",
"runtime",
".",
"Configuration",
"{",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"// If there is a failure try to clean up on exit.",
"i",
".",
"ipset",
".",
"DestroyAll",
"(",
"chainPrefix",
")",
"// nolint errcheck",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Initialize all the global Trireme chains. There are several global chaims",
"// that apply to all PUs:",
"// Tri-App/Tri-Net are the main chains for the egress/ingress directions",
"// UID related chains for any UID PUs.",
"// Host, Service, Pid chains for the different modes of operation (host mode, pu mode, host service).",
"// The priority is explicit (Pid activations take precedence of Service activations and Host Services)",
"if",
"err",
":=",
"i",
".",
"initializeChains",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Insert the global ACLS. These are the main ACLs that will direct traffic from",
"// the INPUT/OUTPUT chains to the Trireme chains. They also includes the main",
"// rules of the main chains. These rules are never touched again, unless",
"// if we gracefully terminate.",
"if",
"err",
":=",
"i",
".",
"setGlobalRules",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Run starts the iptables controller
|
[
"Run",
"starts",
"the",
"iptables",
"controller"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L154-L207
|
7,427 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
ConfigureRules
|
func (i *Instance) ConfigureRules(version int, contextID string, pu *policy.PUInfo) error {
var err error
var cfg *ACLInfo
// First we create an IPSet for destination matching ports. This only
// applies to Linux type PUs. A port set is associated with every PU,
// and packets matching this destination get associated with the context
// of the PU.
if err = i.createPortSet(contextID, pu); err != nil {
return err
}
// We create the generic ACL object that is used for all the templates.
cfg, err = i.newACLInfo(version, contextID, pu, pu.Runtime.PUType())
if err != nil {
return err
}
// Create the proxy sets. These are the target sets that will match
// traffic towards the L4 and L4 services. There are two sets created
// for every PU in this context (for outgoing and incoming traffic).
// The outgoing sets capture all traffic towards specific destinations
// as proxied traffic. Incoming sets correspond to the listening
// services.
if err = i.createProxySets(cfg.ProxySetName); err != nil {
return err
}
// At this point we can install all the ACL rules that will direct
// traffic to user space, allow for external access or direct
// traffic towards the proxies
if err = i.installRules(cfg, pu); err != nil {
return err
}
// We commit the ACLs at the end. Note, that some of the ACLs in the
// NAT table are not committed as a group. The commit function only
// applies when newer versions of tables are installed (1.6.2 and above).
if err = i.ipt.Commit(); err != nil {
zap.L().Error("unable to configure rules", zap.Error(err))
return err
}
i.conntrackCmd(i.cfg.UDPTargetNetworks)
return nil
}
|
go
|
func (i *Instance) ConfigureRules(version int, contextID string, pu *policy.PUInfo) error {
var err error
var cfg *ACLInfo
// First we create an IPSet for destination matching ports. This only
// applies to Linux type PUs. A port set is associated with every PU,
// and packets matching this destination get associated with the context
// of the PU.
if err = i.createPortSet(contextID, pu); err != nil {
return err
}
// We create the generic ACL object that is used for all the templates.
cfg, err = i.newACLInfo(version, contextID, pu, pu.Runtime.PUType())
if err != nil {
return err
}
// Create the proxy sets. These are the target sets that will match
// traffic towards the L4 and L4 services. There are two sets created
// for every PU in this context (for outgoing and incoming traffic).
// The outgoing sets capture all traffic towards specific destinations
// as proxied traffic. Incoming sets correspond to the listening
// services.
if err = i.createProxySets(cfg.ProxySetName); err != nil {
return err
}
// At this point we can install all the ACL rules that will direct
// traffic to user space, allow for external access or direct
// traffic towards the proxies
if err = i.installRules(cfg, pu); err != nil {
return err
}
// We commit the ACLs at the end. Note, that some of the ACLs in the
// NAT table are not committed as a group. The commit function only
// applies when newer versions of tables are installed (1.6.2 and above).
if err = i.ipt.Commit(); err != nil {
zap.L().Error("unable to configure rules", zap.Error(err))
return err
}
i.conntrackCmd(i.cfg.UDPTargetNetworks)
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"ConfigureRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"pu",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"var",
"cfg",
"*",
"ACLInfo",
"\n\n",
"// First we create an IPSet for destination matching ports. This only",
"// applies to Linux type PUs. A port set is associated with every PU,",
"// and packets matching this destination get associated with the context",
"// of the PU.",
"if",
"err",
"=",
"i",
".",
"createPortSet",
"(",
"contextID",
",",
"pu",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// We create the generic ACL object that is used for all the templates.",
"cfg",
",",
"err",
"=",
"i",
".",
"newACLInfo",
"(",
"version",
",",
"contextID",
",",
"pu",
",",
"pu",
".",
"Runtime",
".",
"PUType",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Create the proxy sets. These are the target sets that will match",
"// traffic towards the L4 and L4 services. There are two sets created",
"// for every PU in this context (for outgoing and incoming traffic).",
"// The outgoing sets capture all traffic towards specific destinations",
"// as proxied traffic. Incoming sets correspond to the listening",
"// services.",
"if",
"err",
"=",
"i",
".",
"createProxySets",
"(",
"cfg",
".",
"ProxySetName",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// At this point we can install all the ACL rules that will direct",
"// traffic to user space, allow for external access or direct",
"// traffic towards the proxies",
"if",
"err",
"=",
"i",
".",
"installRules",
"(",
"cfg",
",",
"pu",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// We commit the ACLs at the end. Note, that some of the ACLs in the",
"// NAT table are not committed as a group. The commit function only",
"// applies when newer versions of tables are installed (1.6.2 and above).",
"if",
"err",
"=",
"i",
".",
"ipt",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"i",
".",
"conntrackCmd",
"(",
"i",
".",
"cfg",
".",
"UDPTargetNetworks",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ConfigureRules implments the ConfigureRules interface. It will create the
// port sets and then it will call install rules to create all the ACLs for
// the given chains. PortSets are only created here. Updates will use the
// exact same logic.
|
[
"ConfigureRules",
"implments",
"the",
"ConfigureRules",
"interface",
".",
"It",
"will",
"create",
"the",
"port",
"sets",
"and",
"then",
"it",
"will",
"call",
"install",
"rules",
"to",
"create",
"all",
"the",
"ACLs",
"for",
"the",
"given",
"chains",
".",
"PortSets",
"are",
"only",
"created",
"here",
".",
"Updates",
"will",
"use",
"the",
"exact",
"same",
"logic",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L213-L260
|
7,428 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
DeleteRules
|
func (i *Instance) DeleteRules(version int, contextID string, tcpPorts, udpPorts string, mark string, username string, proxyPort string, puType common.PUType) error {
cfg, err := i.newACLInfo(version, contextID, nil, puType)
if err != nil {
zap.L().Error("unable to create cleanup configuration", zap.Error(err))
return err
}
cfg.UDPPorts = udpPorts
cfg.TCPPorts = tcpPorts
cfg.CgroupMark = mark
cfg.Mark = mark
cfg.UID = username
cfg.PUType = puType
cfg.ProxyPort = proxyPort
// We clean up the chain rules first, so that we can delete the chains.
// If any rule is not deleted, then the chain will show as busy.
if err := i.deleteChainRules(cfg); err != nil {
zap.L().Warn("Failed to clean rules", zap.Error(err))
}
// We can now delete the chains we have created for this PU. Note that
// in every case we only create two chains for every PU. All other
// chains are global.
if err = i.deletePUChains(cfg.AppChain, cfg.NetChain); err != nil {
zap.L().Warn("Failed to clean container chains while deleting the rules", zap.Error(err))
}
// We call commit to update all the changes, before destroying the ipsets.
// References must be deleted for ipset deletion to succeed.
if err := i.ipt.Commit(); err != nil {
zap.L().Warn("Failed to commit ACL changes", zap.Error(err))
}
// We delete the set that captures all destination ports of the
// PU. This only holds for Linux PUs.
if err := i.deletePortSet(contextID); err != nil {
zap.L().Warn("Failed to remove port set")
}
// We delete the proxy port sets that were created for this PU.
if err := i.deleteProxySets(cfg.ProxySetName); err != nil {
zap.L().Warn("Failed to delete proxy sets", zap.Error(err))
}
// Destroy all the ACL related IPSets that were created
// on demand for any external services.
i.destroyACLIPsets(contextID)
return nil
}
|
go
|
func (i *Instance) DeleteRules(version int, contextID string, tcpPorts, udpPorts string, mark string, username string, proxyPort string, puType common.PUType) error {
cfg, err := i.newACLInfo(version, contextID, nil, puType)
if err != nil {
zap.L().Error("unable to create cleanup configuration", zap.Error(err))
return err
}
cfg.UDPPorts = udpPorts
cfg.TCPPorts = tcpPorts
cfg.CgroupMark = mark
cfg.Mark = mark
cfg.UID = username
cfg.PUType = puType
cfg.ProxyPort = proxyPort
// We clean up the chain rules first, so that we can delete the chains.
// If any rule is not deleted, then the chain will show as busy.
if err := i.deleteChainRules(cfg); err != nil {
zap.L().Warn("Failed to clean rules", zap.Error(err))
}
// We can now delete the chains we have created for this PU. Note that
// in every case we only create two chains for every PU. All other
// chains are global.
if err = i.deletePUChains(cfg.AppChain, cfg.NetChain); err != nil {
zap.L().Warn("Failed to clean container chains while deleting the rules", zap.Error(err))
}
// We call commit to update all the changes, before destroying the ipsets.
// References must be deleted for ipset deletion to succeed.
if err := i.ipt.Commit(); err != nil {
zap.L().Warn("Failed to commit ACL changes", zap.Error(err))
}
// We delete the set that captures all destination ports of the
// PU. This only holds for Linux PUs.
if err := i.deletePortSet(contextID); err != nil {
zap.L().Warn("Failed to remove port set")
}
// We delete the proxy port sets that were created for this PU.
if err := i.deleteProxySets(cfg.ProxySetName); err != nil {
zap.L().Warn("Failed to delete proxy sets", zap.Error(err))
}
// Destroy all the ACL related IPSets that were created
// on demand for any external services.
i.destroyACLIPsets(contextID)
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"DeleteRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"tcpPorts",
",",
"udpPorts",
"string",
",",
"mark",
"string",
",",
"username",
"string",
",",
"proxyPort",
"string",
",",
"puType",
"common",
".",
"PUType",
")",
"error",
"{",
"cfg",
",",
"err",
":=",
"i",
".",
"newACLInfo",
"(",
"version",
",",
"contextID",
",",
"nil",
",",
"puType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"cfg",
".",
"UDPPorts",
"=",
"udpPorts",
"\n",
"cfg",
".",
"TCPPorts",
"=",
"tcpPorts",
"\n",
"cfg",
".",
"CgroupMark",
"=",
"mark",
"\n",
"cfg",
".",
"Mark",
"=",
"mark",
"\n",
"cfg",
".",
"UID",
"=",
"username",
"\n",
"cfg",
".",
"PUType",
"=",
"puType",
"\n",
"cfg",
".",
"ProxyPort",
"=",
"proxyPort",
"\n\n",
"// We clean up the chain rules first, so that we can delete the chains.",
"// If any rule is not deleted, then the chain will show as busy.",
"if",
"err",
":=",
"i",
".",
"deleteChainRules",
"(",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"// We can now delete the chains we have created for this PU. Note that",
"// in every case we only create two chains for every PU. All other",
"// chains are global.",
"if",
"err",
"=",
"i",
".",
"deletePUChains",
"(",
"cfg",
".",
"AppChain",
",",
"cfg",
".",
"NetChain",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"// We call commit to update all the changes, before destroying the ipsets.",
"// References must be deleted for ipset deletion to succeed.",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"// We delete the set that captures all destination ports of the",
"// PU. This only holds for Linux PUs.",
"if",
"err",
":=",
"i",
".",
"deletePortSet",
"(",
"contextID",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// We delete the proxy port sets that were created for this PU.",
"if",
"err",
":=",
"i",
".",
"deleteProxySets",
"(",
"cfg",
".",
"ProxySetName",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"// Destroy all the ACL related IPSets that were created",
"// on demand for any external services.",
"i",
".",
"destroyACLIPsets",
"(",
"contextID",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// DeleteRules implements the DeleteRules interface. This is responsible
// for cleaning all ACLs and associated chains, as well as ll the sets
// that we have created. Note, that this only clears up the state
// for a given processing unit.
|
[
"DeleteRules",
"implements",
"the",
"DeleteRules",
"interface",
".",
"This",
"is",
"responsible",
"for",
"cleaning",
"all",
"ACLs",
"and",
"associated",
"chains",
"as",
"well",
"as",
"ll",
"the",
"sets",
"that",
"we",
"have",
"created",
".",
"Note",
"that",
"this",
"only",
"clears",
"up",
"the",
"state",
"for",
"a",
"given",
"processing",
"unit",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L266-L317
|
7,429 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
UpdateRules
|
func (i *Instance) UpdateRules(version int, contextID string, containerInfo *policy.PUInfo, oldContainerInfo *policy.PUInfo) error {
policyrules := containerInfo.Policy
if policyrules == nil {
return errors.New("policy rules cannot be nil")
}
// We cache the old config and we use it to delete the previous
// rules. Every time we update the policy the version changes to
// its binary complement.
newCfg, err := i.newACLInfo(version, contextID, containerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
oldCfg, err := i.newACLInfo(version^1, contextID, oldContainerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
// Install all the new rules. The hooks to the new chains are appended
// and do not take effect yet.
if err := i.installRules(newCfg, containerInfo); err != nil {
return nil
}
// Remove mapping from old chain. By removing the old hooks the new
// hooks take priority.
if err := i.deleteChainRules(oldCfg); err != nil {
return err
}
// Delete the old chains, since there are not references any more.
if err := i.deletePUChains(oldCfg.AppChain, oldCfg.NetChain); err != nil {
return err
}
// Commit all actions in on iptables-restore function.
if err := i.ipt.Commit(); err != nil {
return err
}
// Sync all the IPSets with any new information coming from the policy.
i.synchronizePUACLs(contextID, policyrules.ApplicationACLs(), policyrules.NetworkACLs())
return nil
}
|
go
|
func (i *Instance) UpdateRules(version int, contextID string, containerInfo *policy.PUInfo, oldContainerInfo *policy.PUInfo) error {
policyrules := containerInfo.Policy
if policyrules == nil {
return errors.New("policy rules cannot be nil")
}
// We cache the old config and we use it to delete the previous
// rules. Every time we update the policy the version changes to
// its binary complement.
newCfg, err := i.newACLInfo(version, contextID, containerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
oldCfg, err := i.newACLInfo(version^1, contextID, oldContainerInfo, containerInfo.Runtime.PUType())
if err != nil {
return err
}
// Install all the new rules. The hooks to the new chains are appended
// and do not take effect yet.
if err := i.installRules(newCfg, containerInfo); err != nil {
return nil
}
// Remove mapping from old chain. By removing the old hooks the new
// hooks take priority.
if err := i.deleteChainRules(oldCfg); err != nil {
return err
}
// Delete the old chains, since there are not references any more.
if err := i.deletePUChains(oldCfg.AppChain, oldCfg.NetChain); err != nil {
return err
}
// Commit all actions in on iptables-restore function.
if err := i.ipt.Commit(); err != nil {
return err
}
// Sync all the IPSets with any new information coming from the policy.
i.synchronizePUACLs(contextID, policyrules.ApplicationACLs(), policyrules.NetworkACLs())
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"UpdateRules",
"(",
"version",
"int",
",",
"contextID",
"string",
",",
"containerInfo",
"*",
"policy",
".",
"PUInfo",
",",
"oldContainerInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"policyrules",
":=",
"containerInfo",
".",
"Policy",
"\n",
"if",
"policyrules",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// We cache the old config and we use it to delete the previous",
"// rules. Every time we update the policy the version changes to",
"// its binary complement.",
"newCfg",
",",
"err",
":=",
"i",
".",
"newACLInfo",
"(",
"version",
",",
"contextID",
",",
"containerInfo",
",",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"oldCfg",
",",
"err",
":=",
"i",
".",
"newACLInfo",
"(",
"version",
"^",
"1",
",",
"contextID",
",",
"oldContainerInfo",
",",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Install all the new rules. The hooks to the new chains are appended",
"// and do not take effect yet.",
"if",
"err",
":=",
"i",
".",
"installRules",
"(",
"newCfg",
",",
"containerInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Remove mapping from old chain. By removing the old hooks the new",
"// hooks take priority.",
"if",
"err",
":=",
"i",
".",
"deleteChainRules",
"(",
"oldCfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Delete the old chains, since there are not references any more.",
"if",
"err",
":=",
"i",
".",
"deletePUChains",
"(",
"oldCfg",
".",
"AppChain",
",",
"oldCfg",
".",
"NetChain",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Commit all actions in on iptables-restore function.",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"Commit",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Sync all the IPSets with any new information coming from the policy.",
"i",
".",
"synchronizePUACLs",
"(",
"contextID",
",",
"policyrules",
".",
"ApplicationACLs",
"(",
")",
",",
"policyrules",
".",
"NetworkACLs",
"(",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// UpdateRules implements the update part of the interface. Update will call
// installrules to install the new rules and then it will delete the old rules.
// For installations that do not have latests iptables-restore we time
// the operations so that the switch is almost atomic, by creating the new rules
// first. For latest kernel versions iptables-restorce will update all the rules
// in one shot.
|
[
"UpdateRules",
"implements",
"the",
"update",
"part",
"of",
"the",
"interface",
".",
"Update",
"will",
"call",
"installrules",
"to",
"install",
"the",
"new",
"rules",
"and",
"then",
"it",
"will",
"delete",
"the",
"old",
"rules",
".",
"For",
"installations",
"that",
"do",
"not",
"have",
"latests",
"iptables",
"-",
"restore",
"we",
"time",
"the",
"operations",
"so",
"that",
"the",
"switch",
"is",
"almost",
"atomic",
"by",
"creating",
"the",
"new",
"rules",
"first",
".",
"For",
"latest",
"kernel",
"versions",
"iptables",
"-",
"restorce",
"will",
"update",
"all",
"the",
"rules",
"in",
"one",
"shot",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L325-L371
|
7,430 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
CleanUp
|
func (i *Instance) CleanUp() error {
if err := i.cleanACLs(); err != nil {
zap.L().Error("Failed to clean acls while stopping the supervisor", zap.Error(err))
}
if err := i.ipset.DestroyAll(chainPrefix); err != nil {
zap.L().Error("Failed to clean up ipsets", zap.Error(err))
}
return nil
}
|
go
|
func (i *Instance) CleanUp() error {
if err := i.cleanACLs(); err != nil {
zap.L().Error("Failed to clean acls while stopping the supervisor", zap.Error(err))
}
if err := i.ipset.DestroyAll(chainPrefix); err != nil {
zap.L().Error("Failed to clean up ipsets", zap.Error(err))
}
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"CleanUp",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"i",
".",
"cleanACLs",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"ipset",
".",
"DestroyAll",
"(",
"chainPrefix",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// CleanUp requires the implementor to clean up all ACLs and destroy all
// the IP sets.
|
[
"CleanUp",
"requires",
"the",
"implementor",
"to",
"clean",
"up",
"all",
"ACLs",
"and",
"destroy",
"all",
"the",
"IP",
"sets",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L375-L386
|
7,431 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
initializeChains
|
func (i *Instance) initializeChains() error {
cfg, err := i.newACLInfo(0, "", nil, 0)
if err != nil {
return err
}
tmpl := template.Must(template.New(triremChains).Funcs(template.FuncMap{
"isLocalServer": func() bool {
return i.mode == constants.LocalServer
},
}).Parse(triremChains))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
return fmt.Errorf("unable to create trireme chains:%s", err)
}
for _, rule := range rules {
if len(rule) != 4 {
continue
}
if err := i.ipt.NewChain(rule[1], rule[3]); err != nil {
return err
}
}
return nil
}
|
go
|
func (i *Instance) initializeChains() error {
cfg, err := i.newACLInfo(0, "", nil, 0)
if err != nil {
return err
}
tmpl := template.Must(template.New(triremChains).Funcs(template.FuncMap{
"isLocalServer": func() bool {
return i.mode == constants.LocalServer
},
}).Parse(triremChains))
rules, err := extractRulesFromTemplate(tmpl, cfg)
if err != nil {
return fmt.Errorf("unable to create trireme chains:%s", err)
}
for _, rule := range rules {
if len(rule) != 4 {
continue
}
if err := i.ipt.NewChain(rule[1], rule[3]); err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"initializeChains",
"(",
")",
"error",
"{",
"cfg",
",",
"err",
":=",
"i",
".",
"newACLInfo",
"(",
"0",
",",
"\"",
"\"",
",",
"nil",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"tmpl",
":=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"triremChains",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"func",
"(",
")",
"bool",
"{",
"return",
"i",
".",
"mode",
"==",
"constants",
".",
"LocalServer",
"\n",
"}",
",",
"}",
")",
".",
"Parse",
"(",
"triremChains",
")",
")",
"\n\n",
"rules",
",",
"err",
":=",
"extractRulesFromTemplate",
"(",
"tmpl",
",",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"rule",
":=",
"range",
"rules",
"{",
"if",
"len",
"(",
"rule",
")",
"!=",
"4",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"err",
":=",
"i",
".",
"ipt",
".",
"NewChain",
"(",
"rule",
"[",
"1",
"]",
",",
"rule",
"[",
"3",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// InitializeChains initializes the chains.
|
[
"InitializeChains",
"initializes",
"the",
"chains",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L445-L473
|
7,432 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
configureLinuxRules
|
func (i *Instance) configureLinuxRules(cfg *ACLInfo) error {
// These checks are for rather unusal error scenarios. We should
// never see errors here. But better safe than sorry.
if cfg.CgroupMark == "" {
return errors.New("no mark value found")
}
if cfg.TCPPortSet == "" {
return fmt.Errorf("port set was not found for the contextID. This should not happen")
}
return i.addChainRules(cfg)
}
|
go
|
func (i *Instance) configureLinuxRules(cfg *ACLInfo) error {
// These checks are for rather unusal error scenarios. We should
// never see errors here. But better safe than sorry.
if cfg.CgroupMark == "" {
return errors.New("no mark value found")
}
if cfg.TCPPortSet == "" {
return fmt.Errorf("port set was not found for the contextID. This should not happen")
}
return i.addChainRules(cfg)
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"configureLinuxRules",
"(",
"cfg",
"*",
"ACLInfo",
")",
"error",
"{",
"// These checks are for rather unusal error scenarios. We should",
"// never see errors here. But better safe than sorry.",
"if",
"cfg",
".",
"CgroupMark",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"TCPPortSet",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"i",
".",
"addChainRules",
"(",
"cfg",
")",
"\n",
"}"
] |
// configureLinuxRules adds the chain rules for a linux process or a UID process.
|
[
"configureLinuxRules",
"adds",
"the",
"chain",
"rules",
"for",
"a",
"linux",
"process",
"or",
"a",
"UID",
"process",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L483-L496
|
7,433 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
installRules
|
func (i *Instance) installRules(cfg *ACLInfo, containerInfo *policy.PUInfo) error {
var err error
var appACLIPset, netACLIPset []aclIPset
policyrules := containerInfo.Policy
if err := i.updateProxySet(containerInfo.Policy, cfg.ProxySetName); err != nil {
return err
}
if appACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.ApplicationACLs()); err != nil {
return err
}
if netACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.NetworkACLs()); err != nil {
return err
}
// Install the PU specific chain first.
if err := i.addContainerChain(cfg.AppChain, cfg.NetChain); err != nil {
return err
}
// If its a remote and thus container, configure container rules.
if i.mode == constants.RemoteContainer || i.mode == constants.Sidecar {
if err := i.configureContainerRules(cfg); err != nil {
return err
}
}
// If its a Linux process configure the Linux rules.
if i.mode == constants.LocalServer {
if err := i.configureLinuxRules(cfg); err != nil {
return err
}
}
isHostPU := extractors.IsHostPU(containerInfo.Runtime, i.mode)
if err := i.addExternalACLs(cfg.ContextID, cfg.AppChain, cfg.NetChain, appACLIPset, true); err != nil {
return err
}
if err := i.addExternalACLs(cfg.ContextID, cfg.NetChain, cfg.AppChain, netACLIPset, false); err != nil {
return err
}
if err := i.addPacketTrap(cfg, isHostPU); err != nil {
return err
}
return nil
}
|
go
|
func (i *Instance) installRules(cfg *ACLInfo, containerInfo *policy.PUInfo) error {
var err error
var appACLIPset, netACLIPset []aclIPset
policyrules := containerInfo.Policy
if err := i.updateProxySet(containerInfo.Policy, cfg.ProxySetName); err != nil {
return err
}
if appACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.ApplicationACLs()); err != nil {
return err
}
if netACLIPset, err = i.createACLIPSets(cfg.ContextID, policyrules.NetworkACLs()); err != nil {
return err
}
// Install the PU specific chain first.
if err := i.addContainerChain(cfg.AppChain, cfg.NetChain); err != nil {
return err
}
// If its a remote and thus container, configure container rules.
if i.mode == constants.RemoteContainer || i.mode == constants.Sidecar {
if err := i.configureContainerRules(cfg); err != nil {
return err
}
}
// If its a Linux process configure the Linux rules.
if i.mode == constants.LocalServer {
if err := i.configureLinuxRules(cfg); err != nil {
return err
}
}
isHostPU := extractors.IsHostPU(containerInfo.Runtime, i.mode)
if err := i.addExternalACLs(cfg.ContextID, cfg.AppChain, cfg.NetChain, appACLIPset, true); err != nil {
return err
}
if err := i.addExternalACLs(cfg.ContextID, cfg.NetChain, cfg.AppChain, netACLIPset, false); err != nil {
return err
}
if err := i.addPacketTrap(cfg, isHostPU); err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"i",
"*",
"Instance",
")",
"installRules",
"(",
"cfg",
"*",
"ACLInfo",
",",
"containerInfo",
"*",
"policy",
".",
"PUInfo",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"var",
"appACLIPset",
",",
"netACLIPset",
"[",
"]",
"aclIPset",
"\n",
"policyrules",
":=",
"containerInfo",
".",
"Policy",
"\n\n",
"if",
"err",
":=",
"i",
".",
"updateProxySet",
"(",
"containerInfo",
".",
"Policy",
",",
"cfg",
".",
"ProxySetName",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"appACLIPset",
",",
"err",
"=",
"i",
".",
"createACLIPSets",
"(",
"cfg",
".",
"ContextID",
",",
"policyrules",
".",
"ApplicationACLs",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"netACLIPset",
",",
"err",
"=",
"i",
".",
"createACLIPSets",
"(",
"cfg",
".",
"ContextID",
",",
"policyrules",
".",
"NetworkACLs",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Install the PU specific chain first.",
"if",
"err",
":=",
"i",
".",
"addContainerChain",
"(",
"cfg",
".",
"AppChain",
",",
"cfg",
".",
"NetChain",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// If its a remote and thus container, configure container rules.",
"if",
"i",
".",
"mode",
"==",
"constants",
".",
"RemoteContainer",
"||",
"i",
".",
"mode",
"==",
"constants",
".",
"Sidecar",
"{",
"if",
"err",
":=",
"i",
".",
"configureContainerRules",
"(",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If its a Linux process configure the Linux rules.",
"if",
"i",
".",
"mode",
"==",
"constants",
".",
"LocalServer",
"{",
"if",
"err",
":=",
"i",
".",
"configureLinuxRules",
"(",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"isHostPU",
":=",
"extractors",
".",
"IsHostPU",
"(",
"containerInfo",
".",
"Runtime",
",",
"i",
".",
"mode",
")",
"\n\n",
"if",
"err",
":=",
"i",
".",
"addExternalACLs",
"(",
"cfg",
".",
"ContextID",
",",
"cfg",
".",
"AppChain",
",",
"cfg",
".",
"NetChain",
",",
"appACLIPset",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"addExternalACLs",
"(",
"cfg",
".",
"ContextID",
",",
"cfg",
".",
"NetChain",
",",
"cfg",
".",
"AppChain",
",",
"netACLIPset",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"i",
".",
"addPacketTrap",
"(",
"cfg",
",",
"isHostPU",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Install rules will install all the rules and update the port sets.
|
[
"Install",
"rules",
"will",
"install",
"all",
"the",
"rules",
"and",
"update",
"the",
"port",
"sets",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L742-L793
|
7,434 |
aporeto-inc/trireme-lib
|
controller/internal/supervisor/iptablesctrl/iptables.go
|
puPortSetName
|
func puPortSetName(contextID string, prefix string) string {
hash := murmur3.New64()
if _, err := io.WriteString(hash, contextID); err != nil {
return ""
}
output := base64.URLEncoding.EncodeToString(hash.Sum(nil))
if len(contextID) > 4 {
contextID = contextID[:4] + output[:4]
} else {
contextID = contextID + output[:4]
}
if len(prefix) > 16 {
prefix = prefix[:16]
}
return (prefix + contextID)
}
|
go
|
func puPortSetName(contextID string, prefix string) string {
hash := murmur3.New64()
if _, err := io.WriteString(hash, contextID); err != nil {
return ""
}
output := base64.URLEncoding.EncodeToString(hash.Sum(nil))
if len(contextID) > 4 {
contextID = contextID[:4] + output[:4]
} else {
contextID = contextID + output[:4]
}
if len(prefix) > 16 {
prefix = prefix[:16]
}
return (prefix + contextID)
}
|
[
"func",
"puPortSetName",
"(",
"contextID",
"string",
",",
"prefix",
"string",
")",
"string",
"{",
"hash",
":=",
"murmur3",
".",
"New64",
"(",
")",
"\n\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"WriteString",
"(",
"hash",
",",
"contextID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"output",
":=",
"base64",
".",
"URLEncoding",
".",
"EncodeToString",
"(",
"hash",
".",
"Sum",
"(",
"nil",
")",
")",
"\n\n",
"if",
"len",
"(",
"contextID",
")",
">",
"4",
"{",
"contextID",
"=",
"contextID",
"[",
":",
"4",
"]",
"+",
"output",
"[",
":",
"4",
"]",
"\n",
"}",
"else",
"{",
"contextID",
"=",
"contextID",
"+",
"output",
"[",
":",
"4",
"]",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"prefix",
")",
">",
"16",
"{",
"prefix",
"=",
"prefix",
"[",
":",
"16",
"]",
"\n",
"}",
"\n\n",
"return",
"(",
"prefix",
"+",
"contextID",
")",
"\n",
"}"
] |
// puPortSetName returns the name of the pu portset.
|
[
"puPortSetName",
"returns",
"the",
"name",
"of",
"the",
"pu",
"portset",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/supervisor/iptablesctrl/iptables.go#L796-L816
|
7,435 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
NewProtoListener
|
func NewProtoListener(mark int) *ProtoListener {
return &ProtoListener{
connection: make(chan net.Conn),
mark: mark,
}
}
|
go
|
func NewProtoListener(mark int) *ProtoListener {
return &ProtoListener{
connection: make(chan net.Conn),
mark: mark,
}
}
|
[
"func",
"NewProtoListener",
"(",
"mark",
"int",
")",
"*",
"ProtoListener",
"{",
"return",
"&",
"ProtoListener",
"{",
"connection",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
")",
",",
"mark",
":",
"mark",
",",
"}",
"\n",
"}"
] |
// NewProtoListener creates a listener for a particular protocol.
|
[
"NewProtoListener",
"creates",
"a",
"listener",
"for",
"a",
"particular",
"protocol",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L24-L29
|
7,436 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
Accept
|
func (p *ProtoListener) Accept() (net.Conn, error) {
c, ok := <-p.connection
if !ok {
return nil, fmt.Errorf("mux: listener closed")
}
return c, nil
}
|
go
|
func (p *ProtoListener) Accept() (net.Conn, error) {
c, ok := <-p.connection
if !ok {
return nil, fmt.Errorf("mux: listener closed")
}
return c, nil
}
|
[
"func",
"(",
"p",
"*",
"ProtoListener",
")",
"Accept",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"c",
",",
"ok",
":=",
"<-",
"p",
".",
"connection",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// Accept accepts new connections over the channel.
|
[
"Accept",
"accepts",
"new",
"connections",
"over",
"the",
"channel",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L32-L38
|
7,437 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
NewMultiplexedListener
|
func NewMultiplexedListener(l net.Listener, mark int, registry *serviceregistry.Registry, puID string) *MultiplexedListener {
return &MultiplexedListener{
root: l,
done: make(chan struct{}),
shutdown: make(chan struct{}),
wg: sync.WaitGroup{},
protomap: map[common.ListenerType]*ProtoListener{},
registry: registry,
localIPs: markedconn.GetInterfaces(),
mark: mark,
puID: puID,
}
}
|
go
|
func NewMultiplexedListener(l net.Listener, mark int, registry *serviceregistry.Registry, puID string) *MultiplexedListener {
return &MultiplexedListener{
root: l,
done: make(chan struct{}),
shutdown: make(chan struct{}),
wg: sync.WaitGroup{},
protomap: map[common.ListenerType]*ProtoListener{},
registry: registry,
localIPs: markedconn.GetInterfaces(),
mark: mark,
puID: puID,
}
}
|
[
"func",
"NewMultiplexedListener",
"(",
"l",
"net",
".",
"Listener",
",",
"mark",
"int",
",",
"registry",
"*",
"serviceregistry",
".",
"Registry",
",",
"puID",
"string",
")",
"*",
"MultiplexedListener",
"{",
"return",
"&",
"MultiplexedListener",
"{",
"root",
":",
"l",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"shutdown",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"wg",
":",
"sync",
".",
"WaitGroup",
"{",
"}",
",",
"protomap",
":",
"map",
"[",
"common",
".",
"ListenerType",
"]",
"*",
"ProtoListener",
"{",
"}",
",",
"registry",
":",
"registry",
",",
"localIPs",
":",
"markedconn",
".",
"GetInterfaces",
"(",
")",
",",
"mark",
":",
"mark",
",",
"puID",
":",
"puID",
",",
"}",
"\n",
"}"
] |
// NewMultiplexedListener returns a new multiplexed listener. Caller
// must register protocols outside of the new object creation.
|
[
"NewMultiplexedListener",
"returns",
"a",
"new",
"multiplexed",
"listener",
".",
"Caller",
"must",
"register",
"protocols",
"outside",
"of",
"the",
"new",
"object",
"creation",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L59-L72
|
7,438 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
RegisterListener
|
func (m *MultiplexedListener) RegisterListener(ltype common.ListenerType) (*ProtoListener, error) {
m.Lock()
defer m.Unlock()
if _, ok := m.protomap[ltype]; ok {
return nil, fmt.Errorf("Cannot register same listener type multiple times")
}
p := &ProtoListener{
Listener: m.root,
connection: make(chan net.Conn),
mark: m.mark,
}
m.protomap[ltype] = p
return p, nil
}
|
go
|
func (m *MultiplexedListener) RegisterListener(ltype common.ListenerType) (*ProtoListener, error) {
m.Lock()
defer m.Unlock()
if _, ok := m.protomap[ltype]; ok {
return nil, fmt.Errorf("Cannot register same listener type multiple times")
}
p := &ProtoListener{
Listener: m.root,
connection: make(chan net.Conn),
mark: m.mark,
}
m.protomap[ltype] = p
return p, nil
}
|
[
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"RegisterListener",
"(",
"ltype",
"common",
".",
"ListenerType",
")",
"(",
"*",
"ProtoListener",
",",
"error",
")",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"m",
".",
"protomap",
"[",
"ltype",
"]",
";",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"p",
":=",
"&",
"ProtoListener",
"{",
"Listener",
":",
"m",
".",
"root",
",",
"connection",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
")",
",",
"mark",
":",
"m",
".",
"mark",
",",
"}",
"\n",
"m",
".",
"protomap",
"[",
"ltype",
"]",
"=",
"p",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] |
// RegisterListener registers a new listener. It returns the listener that the various
// protocol servers should use. If defaultListener is set, this will become
// the default listener if no match is found. Obviously, there cannot be more
// than one default.
|
[
"RegisterListener",
"registers",
"a",
"new",
"listener",
".",
"It",
"returns",
"the",
"listener",
"that",
"the",
"various",
"protocol",
"servers",
"should",
"use",
".",
"If",
"defaultListener",
"is",
"set",
"this",
"will",
"become",
"the",
"default",
"listener",
"if",
"no",
"match",
"is",
"found",
".",
"Obviously",
"there",
"cannot",
"be",
"more",
"than",
"one",
"default",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L78-L94
|
7,439 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
UnregisterListener
|
func (m *MultiplexedListener) UnregisterListener(ltype common.ListenerType) error {
m.Lock()
defer m.Unlock()
delete(m.protomap, ltype)
return nil
}
|
go
|
func (m *MultiplexedListener) UnregisterListener(ltype common.ListenerType) error {
m.Lock()
defer m.Unlock()
delete(m.protomap, ltype)
return nil
}
|
[
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"UnregisterListener",
"(",
"ltype",
"common",
".",
"ListenerType",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"m",
".",
"protomap",
",",
"ltype",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// UnregisterListener unregisters a listener. It returns an error if there are services
// associated with this listener.
|
[
"UnregisterListener",
"unregisters",
"a",
"listener",
".",
"It",
"returns",
"an",
"error",
"if",
"there",
"are",
"services",
"associated",
"with",
"this",
"listener",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L98-L105
|
7,440 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
RegisterDefaultListener
|
func (m *MultiplexedListener) RegisterDefaultListener(p *ProtoListener) error {
m.Lock()
defer m.Unlock()
if m.defaultListener != nil {
return fmt.Errorf("Default listener already registered")
}
m.defaultListener = p
return nil
}
|
go
|
func (m *MultiplexedListener) RegisterDefaultListener(p *ProtoListener) error {
m.Lock()
defer m.Unlock()
if m.defaultListener != nil {
return fmt.Errorf("Default listener already registered")
}
m.defaultListener = p
return nil
}
|
[
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"RegisterDefaultListener",
"(",
"p",
"*",
"ProtoListener",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"defaultListener",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
".",
"defaultListener",
"=",
"p",
"\n",
"return",
"nil",
"\n",
"}"
] |
// RegisterDefaultListener registers a default listener.
|
[
"RegisterDefaultListener",
"registers",
"a",
"default",
"listener",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L108-L118
|
7,441 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
UnregisterDefaultListener
|
func (m *MultiplexedListener) UnregisterDefaultListener() error {
m.Lock()
defer m.Unlock()
if m.defaultListener == nil {
return fmt.Errorf("No default listener registered")
}
m.defaultListener = nil
return nil
}
|
go
|
func (m *MultiplexedListener) UnregisterDefaultListener() error {
m.Lock()
defer m.Unlock()
if m.defaultListener == nil {
return fmt.Errorf("No default listener registered")
}
m.defaultListener = nil
return nil
}
|
[
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"UnregisterDefaultListener",
"(",
")",
"error",
"{",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
".",
"defaultListener",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
".",
"defaultListener",
"=",
"nil",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// UnregisterDefaultListener unregisters the default listener.
|
[
"UnregisterDefaultListener",
"unregisters",
"the",
"default",
"listener",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L121-L132
|
7,442 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/protomux/protomux.go
|
Serve
|
func (m *MultiplexedListener) Serve(ctx context.Context) error {
defer func() {
close(m.done)
m.wg.Wait()
m.RLock()
defer m.RUnlock()
for _, l := range m.protomap {
close(l.connection)
// Drain the connections enqueued for the listener.
for c := range l.connection {
c.Close() // nolint
}
}
}()
for {
select {
case <-ctx.Done():
return nil
case <-m.shutdown:
return nil
default:
c, err := m.root.Accept()
if err != nil {
return err
}
m.wg.Add(1)
go m.serve(c)
}
}
}
|
go
|
func (m *MultiplexedListener) Serve(ctx context.Context) error {
defer func() {
close(m.done)
m.wg.Wait()
m.RLock()
defer m.RUnlock()
for _, l := range m.protomap {
close(l.connection)
// Drain the connections enqueued for the listener.
for c := range l.connection {
c.Close() // nolint
}
}
}()
for {
select {
case <-ctx.Done():
return nil
case <-m.shutdown:
return nil
default:
c, err := m.root.Accept()
if err != nil {
return err
}
m.wg.Add(1)
go m.serve(c)
}
}
}
|
[
"func",
"(",
"m",
"*",
"MultiplexedListener",
")",
"Serve",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"defer",
"func",
"(",
")",
"{",
"close",
"(",
"m",
".",
"done",
")",
"\n",
"m",
".",
"wg",
".",
"Wait",
"(",
")",
"\n\n",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"l",
":=",
"range",
"m",
".",
"protomap",
"{",
"close",
"(",
"l",
".",
"connection",
")",
"\n",
"// Drain the connections enqueued for the listener.",
"for",
"c",
":=",
"range",
"l",
".",
"connection",
"{",
"c",
".",
"Close",
"(",
")",
"// nolint",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"case",
"<-",
"m",
".",
"shutdown",
":",
"return",
"nil",
"\n",
"default",
":",
"c",
",",
"err",
":=",
"m",
".",
"root",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"m",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"m",
".",
"serve",
"(",
"c",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Serve will demux the connections
|
[
"Serve",
"will",
"demux",
"the",
"connections"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/protomux/protomux.go#L140-L173
|
7,443 |
aporeto-inc/trireme-lib
|
controller/pkg/env/parameters.go
|
GetParameters
|
func GetParameters() (logToConsole bool, logID string, logLevel string, logFormat string, compressedTagsVersion claimsheader.CompressionType) {
logLevel = os.Getenv(constants.EnvLogLevel)
if logLevel == "" {
logLevel = "info"
}
logFormat = os.Getenv(constants.EnvLogFormat)
if logLevel == "" {
logFormat = "json"
}
if console := os.Getenv(constants.EnvLogToConsole); console == constants.EnvLogToConsoleEnable {
logToConsole = true
}
logID = os.Getenv(constants.EnvLogID)
compressedTagsVersion = claimsheader.CompressionTypeNone
if console := os.Getenv(constants.EnvCompressedTags); console != string(claimsheader.CompressionTypeNone) {
if console == string(claimsheader.CompressionTypeV1) {
compressedTagsVersion = claimsheader.CompressionTypeV1
} else if console == string(claimsheader.CompressionTypeV2) {
compressedTagsVersion = claimsheader.CompressionTypeV2
}
}
return
}
|
go
|
func GetParameters() (logToConsole bool, logID string, logLevel string, logFormat string, compressedTagsVersion claimsheader.CompressionType) {
logLevel = os.Getenv(constants.EnvLogLevel)
if logLevel == "" {
logLevel = "info"
}
logFormat = os.Getenv(constants.EnvLogFormat)
if logLevel == "" {
logFormat = "json"
}
if console := os.Getenv(constants.EnvLogToConsole); console == constants.EnvLogToConsoleEnable {
logToConsole = true
}
logID = os.Getenv(constants.EnvLogID)
compressedTagsVersion = claimsheader.CompressionTypeNone
if console := os.Getenv(constants.EnvCompressedTags); console != string(claimsheader.CompressionTypeNone) {
if console == string(claimsheader.CompressionTypeV1) {
compressedTagsVersion = claimsheader.CompressionTypeV1
} else if console == string(claimsheader.CompressionTypeV2) {
compressedTagsVersion = claimsheader.CompressionTypeV2
}
}
return
}
|
[
"func",
"GetParameters",
"(",
")",
"(",
"logToConsole",
"bool",
",",
"logID",
"string",
",",
"logLevel",
"string",
",",
"logFormat",
"string",
",",
"compressedTagsVersion",
"claimsheader",
".",
"CompressionType",
")",
"{",
"logLevel",
"=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvLogLevel",
")",
"\n",
"if",
"logLevel",
"==",
"\"",
"\"",
"{",
"logLevel",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"logFormat",
"=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvLogFormat",
")",
"\n",
"if",
"logLevel",
"==",
"\"",
"\"",
"{",
"logFormat",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"console",
":=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvLogToConsole",
")",
";",
"console",
"==",
"constants",
".",
"EnvLogToConsoleEnable",
"{",
"logToConsole",
"=",
"true",
"\n",
"}",
"\n\n",
"logID",
"=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvLogID",
")",
"\n\n",
"compressedTagsVersion",
"=",
"claimsheader",
".",
"CompressionTypeNone",
"\n",
"if",
"console",
":=",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvCompressedTags",
")",
";",
"console",
"!=",
"string",
"(",
"claimsheader",
".",
"CompressionTypeNone",
")",
"{",
"if",
"console",
"==",
"string",
"(",
"claimsheader",
".",
"CompressionTypeV1",
")",
"{",
"compressedTagsVersion",
"=",
"claimsheader",
".",
"CompressionTypeV1",
"\n",
"}",
"else",
"if",
"console",
"==",
"string",
"(",
"claimsheader",
".",
"CompressionTypeV2",
")",
"{",
"compressedTagsVersion",
"=",
"claimsheader",
".",
"CompressionTypeV2",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetParameters retrieves log parameters for Remote Enforcer.
|
[
"GetParameters",
"retrieves",
"log",
"parameters",
"for",
"Remote",
"Enforcer",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/env/parameters.go#L21-L49
|
7,444 |
aporeto-inc/trireme-lib
|
monitor/extractors/kubernetes.go
|
isPodInfraContainer
|
func isPodInfraContainer(runtime policy.RuntimeReader) bool {
// The Infra container can be found by checking env. variable.
tagContent, ok := runtime.Tag(KubernetesContainerNameIdentifier)
if !ok || tagContent != KubernetesInfraContainerName {
return false
}
return true
}
|
go
|
func isPodInfraContainer(runtime policy.RuntimeReader) bool {
// The Infra container can be found by checking env. variable.
tagContent, ok := runtime.Tag(KubernetesContainerNameIdentifier)
if !ok || tagContent != KubernetesInfraContainerName {
return false
}
return true
}
|
[
"func",
"isPodInfraContainer",
"(",
"runtime",
"policy",
".",
"RuntimeReader",
")",
"bool",
"{",
"// The Infra container can be found by checking env. variable.",
"tagContent",
",",
"ok",
":=",
"runtime",
".",
"Tag",
"(",
"KubernetesContainerNameIdentifier",
")",
"\n",
"if",
"!",
"ok",
"||",
"tagContent",
"!=",
"KubernetesInfraContainerName",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// isPodInfraContainer returns true if the runtime represents the infra container for the POD
|
[
"isPodInfraContainer",
"returns",
"true",
"if",
"the",
"runtime",
"represents",
"the",
"infra",
"container",
"for",
"the",
"POD"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/extractors/kubernetes.go#L95-L103
|
7,445 |
aporeto-inc/trireme-lib
|
controller/pkg/remoteenforcer/internal/statsclient/client.go
|
NewStatsClient
|
func NewStatsClient(cr statscollector.Collector) (StatsClient, error) {
sc := &statsClient{
collector: cr,
rpchdl: rpcwrapper.NewRPCWrapper(),
secret: os.Getenv(constants.EnvStatsSecret),
statsChannel: os.Getenv(constants.EnvStatsChannel),
statsInterval: defaultStatsIntervalMiliseconds * time.Millisecond,
userRetention: defaultUserRetention * time.Minute,
stop: make(chan bool),
}
if sc.statsChannel == "" {
return nil, errors.New("no path to stats socket provided")
}
if sc.secret == "" {
return nil, errors.New("no secret provided for stats channel")
}
return sc, nil
}
|
go
|
func NewStatsClient(cr statscollector.Collector) (StatsClient, error) {
sc := &statsClient{
collector: cr,
rpchdl: rpcwrapper.NewRPCWrapper(),
secret: os.Getenv(constants.EnvStatsSecret),
statsChannel: os.Getenv(constants.EnvStatsChannel),
statsInterval: defaultStatsIntervalMiliseconds * time.Millisecond,
userRetention: defaultUserRetention * time.Minute,
stop: make(chan bool),
}
if sc.statsChannel == "" {
return nil, errors.New("no path to stats socket provided")
}
if sc.secret == "" {
return nil, errors.New("no secret provided for stats channel")
}
return sc, nil
}
|
[
"func",
"NewStatsClient",
"(",
"cr",
"statscollector",
".",
"Collector",
")",
"(",
"StatsClient",
",",
"error",
")",
"{",
"sc",
":=",
"&",
"statsClient",
"{",
"collector",
":",
"cr",
",",
"rpchdl",
":",
"rpcwrapper",
".",
"NewRPCWrapper",
"(",
")",
",",
"secret",
":",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvStatsSecret",
")",
",",
"statsChannel",
":",
"os",
".",
"Getenv",
"(",
"constants",
".",
"EnvStatsChannel",
")",
",",
"statsInterval",
":",
"defaultStatsIntervalMiliseconds",
"*",
"time",
".",
"Millisecond",
",",
"userRetention",
":",
"defaultUserRetention",
"*",
"time",
".",
"Minute",
",",
"stop",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"}",
"\n\n",
"if",
"sc",
".",
"statsChannel",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"sc",
".",
"secret",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"sc",
",",
"nil",
"\n",
"}"
] |
// NewStatsClient initializes a new stats client
|
[
"NewStatsClient",
"initializes",
"a",
"new",
"stats",
"client"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L36-L57
|
7,446 |
aporeto-inc/trireme-lib
|
controller/pkg/remoteenforcer/internal/statsclient/client.go
|
sendStats
|
func (s *statsClient) sendStats(ctx context.Context) {
ticker := time.NewTicker(s.statsInterval)
userTicker := time.NewTicker(s.userRetention)
// nolint : gosimple
for {
select {
case <-ticker.C:
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
continue
}
s.sendRequest(flows, users)
case <-userTicker.C:
s.collector.FlushUserCache()
case <-ctx.Done():
return
}
}
}
|
go
|
func (s *statsClient) sendStats(ctx context.Context) {
ticker := time.NewTicker(s.statsInterval)
userTicker := time.NewTicker(s.userRetention)
// nolint : gosimple
for {
select {
case <-ticker.C:
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
continue
}
s.sendRequest(flows, users)
case <-userTicker.C:
s.collector.FlushUserCache()
case <-ctx.Done():
return
}
}
}
|
[
"func",
"(",
"s",
"*",
"statsClient",
")",
"sendStats",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"s",
".",
"statsInterval",
")",
"\n",
"userTicker",
":=",
"time",
".",
"NewTicker",
"(",
"s",
".",
"userRetention",
")",
"\n",
"// nolint : gosimple",
"for",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"flows",
":=",
"s",
".",
"collector",
".",
"GetAllRecords",
"(",
")",
"\n",
"users",
":=",
"s",
".",
"collector",
".",
"GetUserRecords",
"(",
")",
"\n",
"if",
"flows",
"==",
"nil",
"&&",
"users",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"s",
".",
"sendRequest",
"(",
"flows",
",",
"users",
")",
"\n",
"case",
"<-",
"userTicker",
".",
"C",
":",
"s",
".",
"collector",
".",
"FlushUserCache",
"(",
")",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"}"
] |
// sendStats async function which makes a rpc call to send stats every STATS_INTERVAL
|
[
"sendStats",
"async",
"function",
"which",
"makes",
"a",
"rpc",
"call",
"to",
"send",
"stats",
"every",
"STATS_INTERVAL"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L60-L83
|
7,447 |
aporeto-inc/trireme-lib
|
controller/pkg/remoteenforcer/internal/statsclient/client.go
|
SendStats
|
func (s *statsClient) SendStats() {
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
zap.L().Debug("Flows and UserRecords are nil while sending stats to collector")
return
}
s.sendRequest(flows, users)
}
|
go
|
func (s *statsClient) SendStats() {
flows := s.collector.GetAllRecords()
users := s.collector.GetUserRecords()
if flows == nil && users == nil {
zap.L().Debug("Flows and UserRecords are nil while sending stats to collector")
return
}
s.sendRequest(flows, users)
}
|
[
"func",
"(",
"s",
"*",
"statsClient",
")",
"SendStats",
"(",
")",
"{",
"flows",
":=",
"s",
".",
"collector",
".",
"GetAllRecords",
"(",
")",
"\n",
"users",
":=",
"s",
".",
"collector",
".",
"GetUserRecords",
"(",
")",
"\n",
"if",
"flows",
"==",
"nil",
"&&",
"users",
"==",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"s",
".",
"sendRequest",
"(",
"flows",
",",
"users",
")",
"\n",
"}"
] |
// SendStats sends all the stats from the cache
|
[
"SendStats",
"sends",
"all",
"the",
"stats",
"from",
"the",
"cache"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L105-L115
|
7,448 |
aporeto-inc/trireme-lib
|
controller/pkg/remoteenforcer/internal/statsclient/client.go
|
Run
|
func (s *statsClient) Run(ctx context.Context) error {
if err := s.rpchdl.NewRPCClient(statsContextID, s.statsChannel, s.secret); err != nil {
zap.L().Error("Stats RPC client cannot connect", zap.Error(err))
return err
}
go s.sendStats(ctx)
return nil
}
|
go
|
func (s *statsClient) Run(ctx context.Context) error {
if err := s.rpchdl.NewRPCClient(statsContextID, s.statsChannel, s.secret); err != nil {
zap.L().Error("Stats RPC client cannot connect", zap.Error(err))
return err
}
go s.sendStats(ctx)
return nil
}
|
[
"func",
"(",
"s",
"*",
"statsClient",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"rpchdl",
".",
"NewRPCClient",
"(",
"statsContextID",
",",
"s",
".",
"statsChannel",
",",
"s",
".",
"secret",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"go",
"s",
".",
"sendStats",
"(",
"ctx",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Start This is an private function called by the remoteenforcer to connect back
// to the controller over a stats channel
|
[
"Start",
"This",
"is",
"an",
"private",
"function",
"called",
"by",
"the",
"remoteenforcer",
"to",
"connect",
"back",
"to",
"the",
"controller",
"over",
"a",
"stats",
"channel"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/remoteenforcer/internal/statsclient/client.go#L119-L128
|
7,449 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
New
|
func New(serverID string, mode constants.ModeType, opts ...Option) TriremeController {
c := &config{
serverID: serverID,
collector: collector.NewDefaultCollector(),
mode: mode,
fq: fqconfig.NewFilterQueueWithDefaults(),
mutualAuth: true,
validity: time.Hour * 8760,
procMountPoint: constants.DefaultProcMountPoint,
externalIPcacheTimeout: -1,
remoteParameters: &env.RemoteParameters{
LogToConsole: true,
LogFormat: "console",
LogLevel: "info",
LogWithID: false,
CompressedTags: claimsheader.CompressionTypeV1,
},
}
for _, opt := range opts {
opt(c)
}
zap.L().Debug("Trireme configuration", zap.String("configuration", fmt.Sprintf("%+v", c)))
return newTrireme(c)
}
|
go
|
func New(serverID string, mode constants.ModeType, opts ...Option) TriremeController {
c := &config{
serverID: serverID,
collector: collector.NewDefaultCollector(),
mode: mode,
fq: fqconfig.NewFilterQueueWithDefaults(),
mutualAuth: true,
validity: time.Hour * 8760,
procMountPoint: constants.DefaultProcMountPoint,
externalIPcacheTimeout: -1,
remoteParameters: &env.RemoteParameters{
LogToConsole: true,
LogFormat: "console",
LogLevel: "info",
LogWithID: false,
CompressedTags: claimsheader.CompressionTypeV1,
},
}
for _, opt := range opts {
opt(c)
}
zap.L().Debug("Trireme configuration", zap.String("configuration", fmt.Sprintf("%+v", c)))
return newTrireme(c)
}
|
[
"func",
"New",
"(",
"serverID",
"string",
",",
"mode",
"constants",
".",
"ModeType",
",",
"opts",
"...",
"Option",
")",
"TriremeController",
"{",
"c",
":=",
"&",
"config",
"{",
"serverID",
":",
"serverID",
",",
"collector",
":",
"collector",
".",
"NewDefaultCollector",
"(",
")",
",",
"mode",
":",
"mode",
",",
"fq",
":",
"fqconfig",
".",
"NewFilterQueueWithDefaults",
"(",
")",
",",
"mutualAuth",
":",
"true",
",",
"validity",
":",
"time",
".",
"Hour",
"*",
"8760",
",",
"procMountPoint",
":",
"constants",
".",
"DefaultProcMountPoint",
",",
"externalIPcacheTimeout",
":",
"-",
"1",
",",
"remoteParameters",
":",
"&",
"env",
".",
"RemoteParameters",
"{",
"LogToConsole",
":",
"true",
",",
"LogFormat",
":",
"\"",
"\"",
",",
"LogLevel",
":",
"\"",
"\"",
",",
"LogWithID",
":",
"false",
",",
"CompressedTags",
":",
"claimsheader",
".",
"CompressionTypeV1",
",",
"}",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"c",
")",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
")",
")",
")",
"\n\n",
"return",
"newTrireme",
"(",
"c",
")",
"\n",
"}"
] |
// New returns a trireme interface implementation based on configuration provided.
|
[
"New",
"returns",
"a",
"trireme",
"interface",
"implementation",
"based",
"on",
"configuration",
"provided",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L44-L71
|
7,450 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
Run
|
func (t *trireme) Run(ctx context.Context) error {
// Start all the supervisors.
for _, s := range t.supervisors {
if err := s.Run(ctx); err != nil {
zap.L().Error("Error when starting the supervisor", zap.Error(err))
return fmt.Errorf("Error while starting supervisor %v", err)
}
}
// Start all the enforcers.
for _, e := range t.enforcers {
if err := e.Run(ctx); err != nil {
return fmt.Errorf("unable to start the enforcer: %s", err)
}
}
go t.runIPTraceCollector(ctx)
return nil
}
|
go
|
func (t *trireme) Run(ctx context.Context) error {
// Start all the supervisors.
for _, s := range t.supervisors {
if err := s.Run(ctx); err != nil {
zap.L().Error("Error when starting the supervisor", zap.Error(err))
return fmt.Errorf("Error while starting supervisor %v", err)
}
}
// Start all the enforcers.
for _, e := range t.enforcers {
if err := e.Run(ctx); err != nil {
return fmt.Errorf("unable to start the enforcer: %s", err)
}
}
go t.runIPTraceCollector(ctx)
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"Run",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"// Start all the supervisors.",
"for",
"_",
",",
"s",
":=",
"range",
"t",
".",
"supervisors",
"{",
"if",
"err",
":=",
"s",
".",
"Run",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Start all the enforcers.",
"for",
"_",
",",
"e",
":=",
"range",
"t",
".",
"enforcers",
"{",
"if",
"err",
":=",
"e",
".",
"Run",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"t",
".",
"runIPTraceCollector",
"(",
"ctx",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Run starts the supervisor and the enforcer and go routines. It doesn't try to clean
// up if something went wrong. It will be up to the caller to decide what to do.
|
[
"Run",
"starts",
"the",
"supervisor",
"and",
"the",
"enforcer",
"and",
"go",
"routines",
".",
"It",
"doesn",
"t",
"try",
"to",
"clean",
"up",
"if",
"something",
"went",
"wrong",
".",
"It",
"will",
"be",
"up",
"to",
"the",
"caller",
"to",
"decide",
"what",
"to",
"do",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L75-L93
|
7,451 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
CleanUp
|
func (t *trireme) CleanUp() error {
for _, s := range t.supervisors {
s.CleanUp() // nolint
}
for _, e := range t.enforcers {
e.CleanUp() // nolint
}
return nil
}
|
go
|
func (t *trireme) CleanUp() error {
for _, s := range t.supervisors {
s.CleanUp() // nolint
}
for _, e := range t.enforcers {
e.CleanUp() // nolint
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"CleanUp",
"(",
")",
"error",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"t",
".",
"supervisors",
"{",
"s",
".",
"CleanUp",
"(",
")",
"// nolint",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"t",
".",
"enforcers",
"{",
"e",
".",
"CleanUp",
"(",
")",
"// nolint",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CleanUp cleans all the acls and all the remote supervisors
|
[
"CleanUp",
"cleans",
"all",
"the",
"acls",
"and",
"all",
"the",
"remote",
"supervisors"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L96-L105
|
7,452 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
Enforce
|
func (t *trireme) Enforce(ctx context.Context, puID string, policy *policy.PUPolicy, runtime *policy.PURuntime) error {
lock, _ := t.locks.LoadOrStore(puID, &sync.Mutex{})
lock.(*sync.Mutex).Lock()
defer lock.(*sync.Mutex).Unlock()
return t.doHandleCreate(puID, policy, runtime)
}
|
go
|
func (t *trireme) Enforce(ctx context.Context, puID string, policy *policy.PUPolicy, runtime *policy.PURuntime) error {
lock, _ := t.locks.LoadOrStore(puID, &sync.Mutex{})
lock.(*sync.Mutex).Lock()
defer lock.(*sync.Mutex).Unlock()
return t.doHandleCreate(puID, policy, runtime)
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"Enforce",
"(",
"ctx",
"context",
".",
"Context",
",",
"puID",
"string",
",",
"policy",
"*",
"policy",
".",
"PUPolicy",
",",
"runtime",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"lock",
",",
"_",
":=",
"t",
".",
"locks",
".",
"LoadOrStore",
"(",
"puID",
",",
"&",
"sync",
".",
"Mutex",
"{",
"}",
")",
"\n",
"lock",
".",
"(",
"*",
"sync",
".",
"Mutex",
")",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"(",
"*",
"sync",
".",
"Mutex",
")",
".",
"Unlock",
"(",
")",
"\n",
"return",
"t",
".",
"doHandleCreate",
"(",
"puID",
",",
"policy",
",",
"runtime",
")",
"\n",
"}"
] |
// Enforce asks the controller to enforce policy to a processing unit
|
[
"Enforce",
"asks",
"the",
"controller",
"to",
"enforce",
"policy",
"to",
"a",
"processing",
"unit"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L108-L113
|
7,453 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
UpdateSecrets
|
func (t *trireme) UpdateSecrets(secrets secrets.Secrets) error {
for _, enforcer := range t.enforcers {
if err := enforcer.UpdateSecrets(secrets); err != nil {
zap.L().Error("unable to update secrets", zap.Error(err))
}
}
return nil
}
|
go
|
func (t *trireme) UpdateSecrets(secrets secrets.Secrets) error {
for _, enforcer := range t.enforcers {
if err := enforcer.UpdateSecrets(secrets); err != nil {
zap.L().Error("unable to update secrets", zap.Error(err))
}
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"UpdateSecrets",
"(",
"secrets",
"secrets",
".",
"Secrets",
")",
"error",
"{",
"for",
"_",
",",
"enforcer",
":=",
"range",
"t",
".",
"enforcers",
"{",
"if",
"err",
":=",
"enforcer",
".",
"UpdateSecrets",
"(",
"secrets",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UpdateSecrets updates the secrets of the controllers.
|
[
"UpdateSecrets",
"updates",
"the",
"secrets",
"of",
"the",
"controllers",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L135-L142
|
7,454 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
UpdateConfiguration
|
func (t *trireme) UpdateConfiguration(cfg *runtime.Configuration) error {
failure := false
for _, s := range t.supervisors {
err := s.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in supervisor", zap.Error(err))
failure = true
}
}
for _, e := range t.enforcers {
err := e.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in cotnroller", zap.Error(err))
failure = true
}
}
if failure {
return fmt.Errorf("configuration update failed")
}
return nil
}
|
go
|
func (t *trireme) UpdateConfiguration(cfg *runtime.Configuration) error {
failure := false
for _, s := range t.supervisors {
err := s.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in supervisor", zap.Error(err))
failure = true
}
}
for _, e := range t.enforcers {
err := e.SetTargetNetworks(cfg)
if err != nil {
zap.L().Error("Failed to update target networks in cotnroller", zap.Error(err))
failure = true
}
}
if failure {
return fmt.Errorf("configuration update failed")
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"UpdateConfiguration",
"(",
"cfg",
"*",
"runtime",
".",
"Configuration",
")",
"error",
"{",
"failure",
":=",
"false",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"t",
".",
"supervisors",
"{",
"err",
":=",
"s",
".",
"SetTargetNetworks",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"failure",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"e",
":=",
"range",
"t",
".",
"enforcers",
"{",
"err",
":=",
"e",
".",
"SetTargetNetworks",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"failure",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"failure",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// UpdateConfiguration updates the configuration of the controller. Only
// a limited number of parameters can be updated at run time.
|
[
"UpdateConfiguration",
"updates",
"the",
"configuration",
"of",
"the",
"controller",
".",
"Only",
"a",
"limited",
"number",
"of",
"parameters",
"can",
"be",
"updated",
"at",
"run",
"time",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L146-L171
|
7,455 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
doHandleCreate
|
func (t *trireme) doHandleCreate(contextID string, policyInfo *policy.PUPolicy, runtimeInfo *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, policyInfo, runtimeInfo)
logEvent := &collector.ContainerRecord{
ContextID: contextID,
IPAddress: policyInfo.IPAddresses(),
Tags: policyInfo.Annotations(),
Event: collector.ContainerStart,
}
defer func() {
t.config.collector.CollectContainerEvent(logEvent)
}()
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
logEvent.Event = collector.ContainerIgnored
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup enforcer: %s", err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up state after failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup supervisor: %s", err)
}
return nil
}
|
go
|
func (t *trireme) doHandleCreate(contextID string, policyInfo *policy.PUPolicy, runtimeInfo *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, policyInfo, runtimeInfo)
logEvent := &collector.ContainerRecord{
ContextID: contextID,
IPAddress: policyInfo.IPAddresses(),
Tags: policyInfo.Annotations(),
Event: collector.ContainerStart,
}
defer func() {
t.config.collector.CollectContainerEvent(logEvent)
}()
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
logEvent.Event = collector.ContainerIgnored
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup enforcer: %s", err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up state after failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
logEvent.Event = collector.ContainerFailed
return fmt.Errorf("unable to setup supervisor: %s", err)
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"doHandleCreate",
"(",
"contextID",
"string",
",",
"policyInfo",
"*",
"policy",
".",
"PUPolicy",
",",
"runtimeInfo",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"containerInfo",
":=",
"policy",
".",
"PUInfoFromPolicyAndRuntime",
"(",
"contextID",
",",
"policyInfo",
",",
"runtimeInfo",
")",
"\n\n",
"logEvent",
":=",
"&",
"collector",
".",
"ContainerRecord",
"{",
"ContextID",
":",
"contextID",
",",
"IPAddress",
":",
"policyInfo",
".",
"IPAddresses",
"(",
")",
",",
"Tags",
":",
"policyInfo",
".",
"Annotations",
"(",
")",
",",
"Event",
":",
"collector",
".",
"ContainerStart",
",",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"t",
".",
"config",
".",
"collector",
".",
"CollectContainerEvent",
"(",
"logEvent",
")",
"\n",
"}",
"(",
")",
"\n\n",
"addTransmitterLabel",
"(",
"contextID",
",",
"containerInfo",
")",
"\n",
"if",
"!",
"mustEnforce",
"(",
"contextID",
",",
"containerInfo",
")",
"{",
"logEvent",
".",
"Event",
"=",
"collector",
".",
"ContainerIgnored",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"t",
".",
"enforcers",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Enforce",
"(",
"contextID",
",",
"containerInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"logEvent",
".",
"Event",
"=",
"collector",
".",
"ContainerFailed",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"t",
".",
"supervisors",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Supervise",
"(",
"contextID",
",",
"containerInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"werr",
":=",
"t",
".",
"enforcers",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Unenforce",
"(",
"contextID",
")",
";",
"werr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"werr",
")",
",",
")",
"\n",
"}",
"\n\n",
"logEvent",
".",
"Event",
"=",
"collector",
".",
"ContainerFailed",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// doHandleCreate is the detailed implementation of the create event.
|
[
"doHandleCreate",
"is",
"the",
"detailed",
"implementation",
"of",
"the",
"create",
"event",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L174-L213
|
7,456 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
doHandleDelete
|
func (t *trireme) doHandleDelete(contextID string, runtime *policy.PURuntime) error {
errS := t.supervisors[t.puTypeToEnforcerType[runtime.PUType()]].Unsupervise(contextID)
errE := t.enforcers[t.puTypeToEnforcerType[runtime.PUType()]].Unenforce(contextID)
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: nil,
Event: collector.ContainerDelete,
})
if errS != nil || errE != nil {
return fmt.Errorf("unable to delete context id %s, supervisor %s, enforcer %s", contextID, errS, errE)
}
return nil
}
|
go
|
func (t *trireme) doHandleDelete(contextID string, runtime *policy.PURuntime) error {
errS := t.supervisors[t.puTypeToEnforcerType[runtime.PUType()]].Unsupervise(contextID)
errE := t.enforcers[t.puTypeToEnforcerType[runtime.PUType()]].Unenforce(contextID)
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: nil,
Event: collector.ContainerDelete,
})
if errS != nil || errE != nil {
return fmt.Errorf("unable to delete context id %s, supervisor %s, enforcer %s", contextID, errS, errE)
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"doHandleDelete",
"(",
"contextID",
"string",
",",
"runtime",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"errS",
":=",
"t",
".",
"supervisors",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Unsupervise",
"(",
"contextID",
")",
"\n",
"errE",
":=",
"t",
".",
"enforcers",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Unenforce",
"(",
"contextID",
")",
"\n\n",
"t",
".",
"config",
".",
"collector",
".",
"CollectContainerEvent",
"(",
"&",
"collector",
".",
"ContainerRecord",
"{",
"ContextID",
":",
"contextID",
",",
"IPAddress",
":",
"runtime",
".",
"IPAddresses",
"(",
")",
",",
"Tags",
":",
"nil",
",",
"Event",
":",
"collector",
".",
"ContainerDelete",
",",
"}",
")",
"\n\n",
"if",
"errS",
"!=",
"nil",
"||",
"errE",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"contextID",
",",
"errS",
",",
"errE",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// doHandleDelete is the detailed implementation of the delete event.
|
[
"doHandleDelete",
"is",
"the",
"detailed",
"implementation",
"of",
"the",
"delete",
"event",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L216-L233
|
7,457 |
aporeto-inc/trireme-lib
|
controller/controller.go
|
doUpdatePolicy
|
func (t *trireme) doUpdatePolicy(contextID string, newPolicy *policy.PUPolicy, runtime *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, newPolicy, runtime)
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
//We lost communication with the remote and killed it lets restart it here by feeding a create event in the request channel
if werr := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unsupervise(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("unable to update policy for pu %s: %s", contextID, err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("supervisor failed to update policy for pu %s: %s", contextID, err)
}
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: containerInfo.Runtime.Tags(),
Event: collector.ContainerUpdate,
})
return nil
}
|
go
|
func (t *trireme) doUpdatePolicy(contextID string, newPolicy *policy.PUPolicy, runtime *policy.PURuntime) error {
containerInfo := policy.PUInfoFromPolicyAndRuntime(contextID, newPolicy, runtime)
addTransmitterLabel(contextID, containerInfo)
if !mustEnforce(contextID, containerInfo) {
return nil
}
if err := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Enforce(contextID, containerInfo); err != nil {
//We lost communication with the remote and killed it lets restart it here by feeding a create event in the request channel
if werr := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unsupervise(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("unable to update policy for pu %s: %s", contextID, err)
}
if err := t.supervisors[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Supervise(contextID, containerInfo); err != nil {
if werr := t.enforcers[t.puTypeToEnforcerType[containerInfo.Runtime.PUType()]].Unenforce(contextID); werr != nil {
zap.L().Warn("Failed to clean up after enforcerments failures",
zap.String("contextID", contextID),
zap.Error(werr),
)
}
return fmt.Errorf("supervisor failed to update policy for pu %s: %s", contextID, err)
}
t.config.collector.CollectContainerEvent(&collector.ContainerRecord{
ContextID: contextID,
IPAddress: runtime.IPAddresses(),
Tags: containerInfo.Runtime.Tags(),
Event: collector.ContainerUpdate,
})
return nil
}
|
[
"func",
"(",
"t",
"*",
"trireme",
")",
"doUpdatePolicy",
"(",
"contextID",
"string",
",",
"newPolicy",
"*",
"policy",
".",
"PUPolicy",
",",
"runtime",
"*",
"policy",
".",
"PURuntime",
")",
"error",
"{",
"containerInfo",
":=",
"policy",
".",
"PUInfoFromPolicyAndRuntime",
"(",
"contextID",
",",
"newPolicy",
",",
"runtime",
")",
"\n\n",
"addTransmitterLabel",
"(",
"contextID",
",",
"containerInfo",
")",
"\n\n",
"if",
"!",
"mustEnforce",
"(",
"contextID",
",",
"containerInfo",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"t",
".",
"enforcers",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Enforce",
"(",
"contextID",
",",
"containerInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"//We lost communication with the remote and killed it lets restart it here by feeding a create event in the request channel",
"if",
"werr",
":=",
"t",
".",
"supervisors",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Unsupervise",
"(",
"contextID",
")",
";",
"werr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"werr",
")",
",",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"contextID",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"t",
".",
"supervisors",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Supervise",
"(",
"contextID",
",",
"containerInfo",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"werr",
":=",
"t",
".",
"enforcers",
"[",
"t",
".",
"puTypeToEnforcerType",
"[",
"containerInfo",
".",
"Runtime",
".",
"PUType",
"(",
")",
"]",
"]",
".",
"Unenforce",
"(",
"contextID",
")",
";",
"werr",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"contextID",
")",
",",
"zap",
".",
"Error",
"(",
"werr",
")",
",",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"contextID",
",",
"err",
")",
"\n",
"}",
"\n\n",
"t",
".",
"config",
".",
"collector",
".",
"CollectContainerEvent",
"(",
"&",
"collector",
".",
"ContainerRecord",
"{",
"ContextID",
":",
"contextID",
",",
"IPAddress",
":",
"runtime",
".",
"IPAddresses",
"(",
")",
",",
"Tags",
":",
"containerInfo",
".",
"Runtime",
".",
"Tags",
"(",
")",
",",
"Event",
":",
"collector",
".",
"ContainerUpdate",
",",
"}",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// doUpdatePolicy is the detailed implementation of the update policy event.
|
[
"doUpdatePolicy",
"is",
"the",
"detailed",
"implementation",
"of",
"the",
"update",
"policy",
"event",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/controller.go#L236-L275
|
7,458 |
aporeto-inc/trireme-lib
|
controller/pkg/packet/types.go
|
TCPFlagsToStr
|
func TCPFlagsToStr(flags uint8) string {
s := ""
if flags&0x20 == 0 {
s = s + "."
} else {
s = s + "U"
}
if flags&0x10 == 0 {
s = s + "."
} else {
s = s + "A"
}
if flags&0x08 == 0 {
s = s + "."
} else {
s = s + "P"
}
if flags&0x04 == 0 {
s = s + "."
} else {
s = s + "R"
}
if flags&0x02 == 0 {
s = s + "."
} else {
s = s + "S"
}
if flags&0x01 == 0 {
s = s + "."
} else {
s = s + "F"
}
return s
}
|
go
|
func TCPFlagsToStr(flags uint8) string {
s := ""
if flags&0x20 == 0 {
s = s + "."
} else {
s = s + "U"
}
if flags&0x10 == 0 {
s = s + "."
} else {
s = s + "A"
}
if flags&0x08 == 0 {
s = s + "."
} else {
s = s + "P"
}
if flags&0x04 == 0 {
s = s + "."
} else {
s = s + "R"
}
if flags&0x02 == 0 {
s = s + "."
} else {
s = s + "S"
}
if flags&0x01 == 0 {
s = s + "."
} else {
s = s + "F"
}
return s
}
|
[
"func",
"TCPFlagsToStr",
"(",
"flags",
"uint8",
")",
"string",
"{",
"s",
":=",
"\"",
"\"",
"\n",
"if",
"flags",
"&",
"0x20",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"flags",
"&",
"0x10",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"flags",
"&",
"0x08",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"flags",
"&",
"0x04",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"flags",
"&",
"0x02",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"flags",
"&",
"0x01",
"==",
"0",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] |
// TCPFlagsToStr converts the TCP Flags to a string value that is human readable
|
[
"TCPFlagsToStr",
"converts",
"the",
"TCP",
"Flags",
"to",
"a",
"string",
"value",
"that",
"is",
"human",
"readable"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/packet/types.go#L103-L136
|
7,459 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
DialMarkedWithContext
|
func DialMarkedWithContext(ctx context.Context, network string, addr string, mark int) (net.Conn, error) {
d := net.Dialer{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetNonblock(int(fd), false); err != nil {
zap.L().Error("unable to set socket options", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to assing mark to socket", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 30, 1); err != nil {
zap.L().Debug("Failed to set fast open socket option", zap.Error(err))
}
})
},
}
conn, err := d.DialContext(ctx, network, addr)
if err != nil {
zap.L().Error("Failed to dial to downstream node",
zap.Error(err),
zap.String("Address", addr),
zap.String("Network type", network),
)
}
return conn, err
}
|
go
|
func DialMarkedWithContext(ctx context.Context, network string, addr string, mark int) (net.Conn, error) {
d := net.Dialer{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetNonblock(int(fd), false); err != nil {
zap.L().Error("unable to set socket options", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to assing mark to socket", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 30, 1); err != nil {
zap.L().Debug("Failed to set fast open socket option", zap.Error(err))
}
})
},
}
conn, err := d.DialContext(ctx, network, addr)
if err != nil {
zap.L().Error("Failed to dial to downstream node",
zap.Error(err),
zap.String("Address", addr),
zap.String("Network type", network),
)
}
return conn, err
}
|
[
"func",
"DialMarkedWithContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"network",
"string",
",",
"addr",
"string",
",",
"mark",
"int",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"d",
":=",
"net",
".",
"Dialer",
"{",
"Control",
":",
"func",
"(",
"_",
",",
"_",
"string",
",",
"c",
"syscall",
".",
"RawConn",
")",
"error",
"{",
"return",
"c",
".",
"Control",
"(",
"func",
"(",
"fd",
"uintptr",
")",
"{",
"if",
"err",
":=",
"syscall",
".",
"SetNonblock",
"(",
"int",
"(",
"fd",
")",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"syscall",
".",
"SetsockoptInt",
"(",
"int",
"(",
"fd",
")",
",",
"syscall",
".",
"SOL_SOCKET",
",",
"syscall",
".",
"SO_MARK",
",",
"mark",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"syscall",
".",
"SetsockoptInt",
"(",
"int",
"(",
"fd",
")",
",",
"syscall",
".",
"SOL_TCP",
",",
"30",
",",
"1",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}",
",",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"d",
".",
"DialContext",
"(",
"ctx",
",",
"network",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"addr",
")",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"network",
")",
",",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"err",
"\n",
"}"
] |
// DialMarkedWithContext will dial a TCP connection to the provide address and mark the socket
// with the provided mark.
|
[
"DialMarkedWithContext",
"will",
"dial",
"a",
"TCP",
"connection",
"to",
"the",
"provide",
"address",
"and",
"mark",
"the",
"socket",
"with",
"the",
"provided",
"mark",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L23-L50
|
7,460 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
NewSocketListener
|
func NewSocketListener(ctx context.Context, port string, mark int) (net.Listener, error) {
listenerCfg := net.ListenConfig{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to mark connection", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 23, 16*1024); err != nil {
zap.L().Error("Cannot set tcp fast open options", zap.Error(err))
}
})
},
}
listener, err := listenerCfg.Listen(ctx, "tcp4", port)
if err != nil {
return nil, fmt.Errorf("Failed to create listener: %s", err)
}
return ProxiedListener{netListener: listener, mark: mark}, nil
}
|
go
|
func NewSocketListener(ctx context.Context, port string, mark int) (net.Listener, error) {
listenerCfg := net.ListenConfig{
Control: func(_, _ string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
zap.L().Error("Failed to mark connection", zap.Error(err))
}
if err := syscall.SetsockoptInt(int(fd), syscall.SOL_TCP, 23, 16*1024); err != nil {
zap.L().Error("Cannot set tcp fast open options", zap.Error(err))
}
})
},
}
listener, err := listenerCfg.Listen(ctx, "tcp4", port)
if err != nil {
return nil, fmt.Errorf("Failed to create listener: %s", err)
}
return ProxiedListener{netListener: listener, mark: mark}, nil
}
|
[
"func",
"NewSocketListener",
"(",
"ctx",
"context",
".",
"Context",
",",
"port",
"string",
",",
"mark",
"int",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"listenerCfg",
":=",
"net",
".",
"ListenConfig",
"{",
"Control",
":",
"func",
"(",
"_",
",",
"_",
"string",
",",
"c",
"syscall",
".",
"RawConn",
")",
"error",
"{",
"return",
"c",
".",
"Control",
"(",
"func",
"(",
"fd",
"uintptr",
")",
"{",
"if",
"err",
":=",
"syscall",
".",
"SetsockoptInt",
"(",
"int",
"(",
"fd",
")",
",",
"syscall",
".",
"SOL_SOCKET",
",",
"syscall",
".",
"SO_MARK",
",",
"mark",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"syscall",
".",
"SetsockoptInt",
"(",
"int",
"(",
"fd",
")",
",",
"syscall",
".",
"SOL_TCP",
",",
"23",
",",
"16",
"*",
"1024",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}",
",",
"}",
"\n\n",
"listener",
",",
"err",
":=",
"listenerCfg",
".",
"Listen",
"(",
"ctx",
",",
"\"",
"\"",
",",
"port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"ProxiedListener",
"{",
"netListener",
":",
"listener",
",",
"mark",
":",
"mark",
"}",
",",
"nil",
"\n",
"}"
] |
// NewSocketListener will create a listener and mark the socket with the provided mark.
|
[
"NewSocketListener",
"will",
"create",
"a",
"listener",
"and",
"mark",
"the",
"socket",
"with",
"the",
"provided",
"mark",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L53-L73
|
7,461 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
LocalAddr
|
func (p *ProxiedConnection) LocalAddr() net.Addr {
addr, err := net.ResolveTCPAddr("tcp", p.originalIP.String()+":"+strconv.Itoa(p.originalPort))
if err != nil {
return nil
}
return addr
}
|
go
|
func (p *ProxiedConnection) LocalAddr() net.Addr {
addr, err := net.ResolveTCPAddr("tcp", p.originalIP.String()+":"+strconv.Itoa(p.originalPort))
if err != nil {
return nil
}
return addr
}
|
[
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"LocalAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"p",
".",
"originalIP",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"p",
".",
"originalPort",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"addr",
"\n",
"}"
] |
// LocalAddr implements the corresponding method of net.Conn, but returns the original
// address.
|
[
"LocalAddr",
"implements",
"the",
"corresponding",
"method",
"of",
"net",
".",
"Conn",
"but",
"returns",
"the",
"original",
"address",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L95-L103
|
7,462 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
SetDeadline
|
func (p *ProxiedConnection) SetDeadline(t time.Time) error {
return p.originalTCPConnection.SetDeadline(t)
}
|
go
|
func (p *ProxiedConnection) SetDeadline(t time.Time) error {
return p.originalTCPConnection.SetDeadline(t)
}
|
[
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"p",
".",
"originalTCPConnection",
".",
"SetDeadline",
"(",
"t",
")",
"\n",
"}"
] |
// SetDeadline passes the read deadline to the original TCP connection.
|
[
"SetDeadline",
"passes",
"the",
"read",
"deadline",
"to",
"the",
"original",
"TCP",
"connection",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L126-L128
|
7,463 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
SetReadDeadline
|
func (p *ProxiedConnection) SetReadDeadline(t time.Time) error {
return p.originalTCPConnection.SetReadDeadline(t)
}
|
go
|
func (p *ProxiedConnection) SetReadDeadline(t time.Time) error {
return p.originalTCPConnection.SetReadDeadline(t)
}
|
[
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"SetReadDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"p",
".",
"originalTCPConnection",
".",
"SetReadDeadline",
"(",
"t",
")",
"\n",
"}"
] |
// SetReadDeadline implements the call by passing it to the original connection.
|
[
"SetReadDeadline",
"implements",
"the",
"call",
"by",
"passing",
"it",
"to",
"the",
"original",
"connection",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L131-L133
|
7,464 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
SetWriteDeadline
|
func (p *ProxiedConnection) SetWriteDeadline(t time.Time) error {
return p.originalTCPConnection.SetWriteDeadline(t)
}
|
go
|
func (p *ProxiedConnection) SetWriteDeadline(t time.Time) error {
return p.originalTCPConnection.SetWriteDeadline(t)
}
|
[
"func",
"(",
"p",
"*",
"ProxiedConnection",
")",
"SetWriteDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"p",
".",
"originalTCPConnection",
".",
"SetWriteDeadline",
"(",
"t",
")",
"\n",
"}"
] |
// SetWriteDeadline implements the call by passing it to the original connection.
|
[
"SetWriteDeadline",
"implements",
"the",
"call",
"by",
"passing",
"it",
"to",
"the",
"original",
"connection",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L136-L138
|
7,465 |
aporeto-inc/trireme-lib
|
controller/internal/enforcer/applicationproxy/markedconn/markedconn.go
|
GetInterfaces
|
func GetInterfaces() map[string]struct{} {
ipmap := map[string]struct{}{}
ifaces, _ := net.Interfaces()
for _, intf := range ifaces {
addrs, _ := intf.Addrs()
for _, addr := range addrs {
ip, _, _ := net.ParseCIDR(addr.String())
if ip.To4() != nil {
ipmap[ip.String()] = struct{}{}
}
}
}
return ipmap
}
|
go
|
func GetInterfaces() map[string]struct{} {
ipmap := map[string]struct{}{}
ifaces, _ := net.Interfaces()
for _, intf := range ifaces {
addrs, _ := intf.Addrs()
for _, addr := range addrs {
ip, _, _ := net.ParseCIDR(addr.String())
if ip.To4() != nil {
ipmap[ip.String()] = struct{}{}
}
}
}
return ipmap
}
|
[
"func",
"GetInterfaces",
"(",
")",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"ipmap",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"ifaces",
",",
"_",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"for",
"_",
",",
"intf",
":=",
"range",
"ifaces",
"{",
"addrs",
",",
"_",
":=",
"intf",
".",
"Addrs",
"(",
")",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"ip",
",",
"_",
",",
"_",
":=",
"net",
".",
"ParseCIDR",
"(",
"addr",
".",
"String",
"(",
")",
")",
"\n",
"if",
"ip",
".",
"To4",
"(",
")",
"!=",
"nil",
"{",
"ipmap",
"[",
"ip",
".",
"String",
"(",
")",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ipmap",
"\n",
"}"
] |
// GetInterfaces retrieves all the local interfaces.
|
[
"GetInterfaces",
"retrieves",
"all",
"the",
"local",
"interfaces",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/enforcer/applicationproxy/markedconn/markedconn.go#L225-L239
|
7,466 |
aporeto-inc/trireme-lib
|
utils/cgnetcls/netcls.go
|
GetCgroupList
|
func GetCgroupList() []string {
var cgroupList []string
filelist, err := ioutil.ReadDir(filepath.Join(basePath, TriremeBasePath))
if err != nil {
return cgroupList
}
for _, file := range filelist {
if file.IsDir() {
cgroupList = append(cgroupList, file.Name())
}
}
return cgroupList
}
|
go
|
func GetCgroupList() []string {
var cgroupList []string
filelist, err := ioutil.ReadDir(filepath.Join(basePath, TriremeBasePath))
if err != nil {
return cgroupList
}
for _, file := range filelist {
if file.IsDir() {
cgroupList = append(cgroupList, file.Name())
}
}
return cgroupList
}
|
[
"func",
"GetCgroupList",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"cgroupList",
"[",
"]",
"string",
"\n",
"filelist",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"filepath",
".",
"Join",
"(",
"basePath",
",",
"TriremeBasePath",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"cgroupList",
"\n",
"}",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"filelist",
"{",
"if",
"file",
".",
"IsDir",
"(",
")",
"{",
"cgroupList",
"=",
"append",
"(",
"cgroupList",
",",
"file",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"cgroupList",
"\n",
"}"
] |
// GetCgroupList geta list of all cgroup names
|
[
"GetCgroupList",
"geta",
"list",
"of",
"all",
"cgroup",
"names"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/utils/cgnetcls/netcls.go#L26-L38
|
7,467 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionCollector
|
func OptionCollector(c collector.EventCollector) Option {
return func(cfg *config) {
cfg.collector = c
}
}
|
go
|
func OptionCollector(c collector.EventCollector) Option {
return func(cfg *config) {
cfg.collector = c
}
}
|
[
"func",
"OptionCollector",
"(",
"c",
"collector",
".",
"EventCollector",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"collector",
"=",
"c",
"\n",
"}",
"\n",
"}"
] |
// OptionCollector is an option to provide an external collector implementation.
|
[
"OptionCollector",
"is",
"an",
"option",
"to",
"provide",
"an",
"external",
"collector",
"implementation",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L52-L56
|
7,468 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionDatapathService
|
func OptionDatapathService(s packetprocessor.PacketProcessor) Option {
return func(cfg *config) {
cfg.service = s
}
}
|
go
|
func OptionDatapathService(s packetprocessor.PacketProcessor) Option {
return func(cfg *config) {
cfg.service = s
}
}
|
[
"func",
"OptionDatapathService",
"(",
"s",
"packetprocessor",
".",
"PacketProcessor",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"service",
"=",
"s",
"\n",
"}",
"\n",
"}"
] |
// OptionDatapathService is an option to provide an external datapath service implementation.
|
[
"OptionDatapathService",
"is",
"an",
"option",
"to",
"provide",
"an",
"external",
"datapath",
"service",
"implementation",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L59-L63
|
7,469 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionSecret
|
func OptionSecret(s secrets.Secrets) Option {
return func(cfg *config) {
cfg.secret = s
}
}
|
go
|
func OptionSecret(s secrets.Secrets) Option {
return func(cfg *config) {
cfg.secret = s
}
}
|
[
"func",
"OptionSecret",
"(",
"s",
"secrets",
".",
"Secrets",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"secret",
"=",
"s",
"\n",
"}",
"\n",
"}"
] |
// OptionSecret is an option to provide an external datapath service implementation.
|
[
"OptionSecret",
"is",
"an",
"option",
"to",
"provide",
"an",
"external",
"datapath",
"service",
"implementation",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L66-L70
|
7,470 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionEnforceFqConfig
|
func OptionEnforceFqConfig(f *fqconfig.FilterQueue) Option {
return func(cfg *config) {
cfg.fq = f
}
}
|
go
|
func OptionEnforceFqConfig(f *fqconfig.FilterQueue) Option {
return func(cfg *config) {
cfg.fq = f
}
}
|
[
"func",
"OptionEnforceFqConfig",
"(",
"f",
"*",
"fqconfig",
".",
"FilterQueue",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"fq",
"=",
"f",
"\n",
"}",
"\n",
"}"
] |
// OptionEnforceFqConfig is an option to override filter queues.
|
[
"OptionEnforceFqConfig",
"is",
"an",
"option",
"to",
"override",
"filter",
"queues",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L80-L84
|
7,471 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionRuntimeConfiguration
|
func OptionRuntimeConfiguration(c *runtime.Configuration) Option {
return func(cfg *config) {
cfg.runtimeCfg = c
}
}
|
go
|
func OptionRuntimeConfiguration(c *runtime.Configuration) Option {
return func(cfg *config) {
cfg.runtimeCfg = c
}
}
|
[
"func",
"OptionRuntimeConfiguration",
"(",
"c",
"*",
"runtime",
".",
"Configuration",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"runtimeCfg",
"=",
"c",
"\n",
"}",
"\n",
"}"
] |
// OptionRuntimeConfiguration is an option to provide target network configuration.
|
[
"OptionRuntimeConfiguration",
"is",
"an",
"option",
"to",
"provide",
"target",
"network",
"configuration",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L94-L98
|
7,472 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionRuntimeErrorChannel
|
func OptionRuntimeErrorChannel(errorChannel chan *policy.RuntimeError) Option {
return func(cfg *config) {
cfg.runtimeErrorChannel = errorChannel
}
}
|
go
|
func OptionRuntimeErrorChannel(errorChannel chan *policy.RuntimeError) Option {
return func(cfg *config) {
cfg.runtimeErrorChannel = errorChannel
}
}
|
[
"func",
"OptionRuntimeErrorChannel",
"(",
"errorChannel",
"chan",
"*",
"policy",
".",
"RuntimeError",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"runtimeErrorChannel",
"=",
"errorChannel",
"\n",
"}",
"\n\n",
"}"
] |
// OptionRuntimeErrorChannel configures the error channel for the policy engine.
|
[
"OptionRuntimeErrorChannel",
"configures",
"the",
"error",
"channel",
"for",
"the",
"policy",
"engine",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L108-L113
|
7,473 |
aporeto-inc/trireme-lib
|
controller/config.go
|
OptionRemoteParameters
|
func OptionRemoteParameters(p *env.RemoteParameters) Option {
return func(cfg *config) {
cfg.remoteParameters = p
}
}
|
go
|
func OptionRemoteParameters(p *env.RemoteParameters) Option {
return func(cfg *config) {
cfg.remoteParameters = p
}
}
|
[
"func",
"OptionRemoteParameters",
"(",
"p",
"*",
"env",
".",
"RemoteParameters",
")",
"Option",
"{",
"return",
"func",
"(",
"cfg",
"*",
"config",
")",
"{",
"cfg",
".",
"remoteParameters",
"=",
"p",
"\n",
"}",
"\n",
"}"
] |
// OptionRemoteParameters is an option to set the parameters for the remote
|
[
"OptionRemoteParameters",
"is",
"an",
"option",
"to",
"set",
"the",
"parameters",
"for",
"the",
"remote"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L123-L127
|
7,474 |
aporeto-inc/trireme-lib
|
controller/config.go
|
newTrireme
|
func newTrireme(c *config) TriremeController {
var err error
t := &trireme{
config: c,
enforcers: map[constants.ModeType]enforcer.Enforcer{},
supervisors: map[constants.ModeType]supervisor.Supervisor{},
puTypeToEnforcerType: map[common.PUType]constants.ModeType{},
locks: sync.Map{},
enablingTrace: make(chan *traceTrigger, 10),
}
zap.L().Debug("Creating Enforcers")
if err = t.newEnforcers(); err != nil {
zap.L().Error("Unable to create datapath enforcers", zap.Error(err))
return nil
}
zap.L().Debug("Creating Supervisors")
if err = t.newSupervisors(); err != nil {
zap.L().Error("Unable to start datapath supervisor", zap.Error(err))
return nil
}
if c.linuxProcess {
t.puTypeToEnforcerType[common.LinuxProcessPU] = constants.LocalServer
t.puTypeToEnforcerType[common.UIDLoginPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostNetworkPU] = constants.LocalServer
t.puTypeToEnforcerType[common.SSHSessionPU] = constants.LocalServer
}
if t.config.mode == constants.RemoteContainer {
t.puTypeToEnforcerType[common.ContainerPU] = constants.RemoteContainer
t.puTypeToEnforcerType[common.KubernetesPU] = constants.RemoteContainer
}
if t.config.mode == constants.Sidecar {
t.puTypeToEnforcerType[common.ContainerPU] = constants.Sidecar
}
return t
}
|
go
|
func newTrireme(c *config) TriremeController {
var err error
t := &trireme{
config: c,
enforcers: map[constants.ModeType]enforcer.Enforcer{},
supervisors: map[constants.ModeType]supervisor.Supervisor{},
puTypeToEnforcerType: map[common.PUType]constants.ModeType{},
locks: sync.Map{},
enablingTrace: make(chan *traceTrigger, 10),
}
zap.L().Debug("Creating Enforcers")
if err = t.newEnforcers(); err != nil {
zap.L().Error("Unable to create datapath enforcers", zap.Error(err))
return nil
}
zap.L().Debug("Creating Supervisors")
if err = t.newSupervisors(); err != nil {
zap.L().Error("Unable to start datapath supervisor", zap.Error(err))
return nil
}
if c.linuxProcess {
t.puTypeToEnforcerType[common.LinuxProcessPU] = constants.LocalServer
t.puTypeToEnforcerType[common.UIDLoginPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostPU] = constants.LocalServer
t.puTypeToEnforcerType[common.HostNetworkPU] = constants.LocalServer
t.puTypeToEnforcerType[common.SSHSessionPU] = constants.LocalServer
}
if t.config.mode == constants.RemoteContainer {
t.puTypeToEnforcerType[common.ContainerPU] = constants.RemoteContainer
t.puTypeToEnforcerType[common.KubernetesPU] = constants.RemoteContainer
}
if t.config.mode == constants.Sidecar {
t.puTypeToEnforcerType[common.ContainerPU] = constants.Sidecar
}
return t
}
|
[
"func",
"newTrireme",
"(",
"c",
"*",
"config",
")",
"TriremeController",
"{",
"var",
"err",
"error",
"\n\n",
"t",
":=",
"&",
"trireme",
"{",
"config",
":",
"c",
",",
"enforcers",
":",
"map",
"[",
"constants",
".",
"ModeType",
"]",
"enforcer",
".",
"Enforcer",
"{",
"}",
",",
"supervisors",
":",
"map",
"[",
"constants",
".",
"ModeType",
"]",
"supervisor",
".",
"Supervisor",
"{",
"}",
",",
"puTypeToEnforcerType",
":",
"map",
"[",
"common",
".",
"PUType",
"]",
"constants",
".",
"ModeType",
"{",
"}",
",",
"locks",
":",
"sync",
".",
"Map",
"{",
"}",
",",
"enablingTrace",
":",
"make",
"(",
"chan",
"*",
"traceTrigger",
",",
"10",
")",
",",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"=",
"t",
".",
"newEnforcers",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"zap",
".",
"L",
"(",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"=",
"t",
".",
"newSupervisors",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Error",
"(",
"\"",
"\"",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"linuxProcess",
"{",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"LinuxProcessPU",
"]",
"=",
"constants",
".",
"LocalServer",
"\n",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"UIDLoginPU",
"]",
"=",
"constants",
".",
"LocalServer",
"\n",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"HostPU",
"]",
"=",
"constants",
".",
"LocalServer",
"\n",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"HostNetworkPU",
"]",
"=",
"constants",
".",
"LocalServer",
"\n",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"SSHSessionPU",
"]",
"=",
"constants",
".",
"LocalServer",
"\n",
"}",
"\n\n",
"if",
"t",
".",
"config",
".",
"mode",
"==",
"constants",
".",
"RemoteContainer",
"{",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"ContainerPU",
"]",
"=",
"constants",
".",
"RemoteContainer",
"\n",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"KubernetesPU",
"]",
"=",
"constants",
".",
"RemoteContainer",
"\n",
"}",
"\n\n",
"if",
"t",
".",
"config",
".",
"mode",
"==",
"constants",
".",
"Sidecar",
"{",
"t",
".",
"puTypeToEnforcerType",
"[",
"common",
".",
"ContainerPU",
"]",
"=",
"constants",
".",
"Sidecar",
"\n",
"}",
"\n\n",
"return",
"t",
"\n",
"}"
] |
// newTrireme returns a reference to the trireme object based on the parameter subelements.
|
[
"newTrireme",
"returns",
"a",
"reference",
"to",
"the",
"trireme",
"object",
"based",
"on",
"the",
"parameter",
"subelements",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/config.go#L233-L276
|
7,475 |
aporeto-inc/trireme-lib
|
monitor/internal/linux/processor.go
|
generateContextID
|
func (l *linuxProcessor) generateContextID(eventInfo *common.EventInfo) (string, error) {
puID := eventInfo.PUID
if eventInfo.Cgroup == "" {
return puID, nil
}
if !l.regStop.Match([]byte(eventInfo.Cgroup)) {
return "", fmt.Errorf("invalid pu id: %s", eventInfo.Cgroup)
}
puID = baseName(eventInfo.Cgroup, "/")
if eventInfo.PUType == common.SSHSessionPU {
return "ssh-" + puID, nil
}
return puID, nil
}
|
go
|
func (l *linuxProcessor) generateContextID(eventInfo *common.EventInfo) (string, error) {
puID := eventInfo.PUID
if eventInfo.Cgroup == "" {
return puID, nil
}
if !l.regStop.Match([]byte(eventInfo.Cgroup)) {
return "", fmt.Errorf("invalid pu id: %s", eventInfo.Cgroup)
}
puID = baseName(eventInfo.Cgroup, "/")
if eventInfo.PUType == common.SSHSessionPU {
return "ssh-" + puID, nil
}
return puID, nil
}
|
[
"func",
"(",
"l",
"*",
"linuxProcessor",
")",
"generateContextID",
"(",
"eventInfo",
"*",
"common",
".",
"EventInfo",
")",
"(",
"string",
",",
"error",
")",
"{",
"puID",
":=",
"eventInfo",
".",
"PUID",
"\n",
"if",
"eventInfo",
".",
"Cgroup",
"==",
"\"",
"\"",
"{",
"return",
"puID",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"!",
"l",
".",
"regStop",
".",
"Match",
"(",
"[",
"]",
"byte",
"(",
"eventInfo",
".",
"Cgroup",
")",
")",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"eventInfo",
".",
"Cgroup",
")",
"\n",
"}",
"\n\n",
"puID",
"=",
"baseName",
"(",
"eventInfo",
".",
"Cgroup",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"eventInfo",
".",
"PUType",
"==",
"common",
".",
"SSHSessionPU",
"{",
"return",
"\"",
"\"",
"+",
"puID",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"puID",
",",
"nil",
"\n",
"}"
] |
// generateContextID creates the puID from the event information
|
[
"generateContextID",
"creates",
"the",
"puID",
"from",
"the",
"event",
"information"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/monitor/internal/linux/processor.go#L299-L317
|
7,476 |
aporeto-inc/trireme-lib
|
plugins/pam/uidmonitorpam.go
|
pam_sm_open_session
|
func pam_sm_open_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
C.initLog()
user := C.get_user(pamh)
service := C.get_service(pamh)
metadatamap := []string{}
userstring := "user=" + C.GoString(user)
metadatamap = append(metadatamap, userstring)
if groups, err := getGroupList(C.GoString(user)); err == nil {
metadatamap = append(metadatamap, groups...)
}
if service != nil {
metadatamap = append(metadatamap, "SessionType="+C.GoString(service))
} else {
metadatamap = append(metadatamap, "SessionType=login")
}
request := &common.EventInfo{
PUType: common.UIDLoginPU,
PUID: C.GoString(user),
Name: "login-" + C.GoString(user),
PID: int32(os.Getpid()),
Tags: metadatamap,
EventType: "start",
}
if C.is_root(user) == 1 {
//Do nothing this is login shell account
} else {
//Do something
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
defer func() {
_ = slog.Close()
}()
client, err := client.NewClient(common.TriremeSocket)
if err != nil {
return C.PAM_SUCCESS
}
slog.Alert("Calling Trireme") // nolit
if err := client.SendRequest(request); err != nil {
err = fmt.Errorf("Policy Server call failed %s", err)
_ = slog.Alert(err.Error())
return C.PAM_SESSION_ERR
}
}
return C.PAM_SUCCESS
}
|
go
|
func pam_sm_open_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
C.initLog()
user := C.get_user(pamh)
service := C.get_service(pamh)
metadatamap := []string{}
userstring := "user=" + C.GoString(user)
metadatamap = append(metadatamap, userstring)
if groups, err := getGroupList(C.GoString(user)); err == nil {
metadatamap = append(metadatamap, groups...)
}
if service != nil {
metadatamap = append(metadatamap, "SessionType="+C.GoString(service))
} else {
metadatamap = append(metadatamap, "SessionType=login")
}
request := &common.EventInfo{
PUType: common.UIDLoginPU,
PUID: C.GoString(user),
Name: "login-" + C.GoString(user),
PID: int32(os.Getpid()),
Tags: metadatamap,
EventType: "start",
}
if C.is_root(user) == 1 {
//Do nothing this is login shell account
} else {
//Do something
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
defer func() {
_ = slog.Close()
}()
client, err := client.NewClient(common.TriremeSocket)
if err != nil {
return C.PAM_SUCCESS
}
slog.Alert("Calling Trireme") // nolit
if err := client.SendRequest(request); err != nil {
err = fmt.Errorf("Policy Server call failed %s", err)
_ = slog.Alert(err.Error())
return C.PAM_SESSION_ERR
}
}
return C.PAM_SUCCESS
}
|
[
"func",
"pam_sm_open_session",
"(",
"pamh",
"*",
"C",
".",
"pam_handle_t",
",",
"flags",
",",
"argc",
"int",
",",
"argv",
"*",
"*",
"C",
".",
"char",
")",
"C",
".",
"int",
"{",
"C",
".",
"initLog",
"(",
")",
"\n",
"user",
":=",
"C",
".",
"get_user",
"(",
"pamh",
")",
"\n",
"service",
":=",
"C",
".",
"get_service",
"(",
"pamh",
")",
"\n",
"metadatamap",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"userstring",
":=",
"\"",
"\"",
"+",
"C",
".",
"GoString",
"(",
"user",
")",
"\n",
"metadatamap",
"=",
"append",
"(",
"metadatamap",
",",
"userstring",
")",
"\n",
"if",
"groups",
",",
"err",
":=",
"getGroupList",
"(",
"C",
".",
"GoString",
"(",
"user",
")",
")",
";",
"err",
"==",
"nil",
"{",
"metadatamap",
"=",
"append",
"(",
"metadatamap",
",",
"groups",
"...",
")",
"\n",
"}",
"\n\n",
"if",
"service",
"!=",
"nil",
"{",
"metadatamap",
"=",
"append",
"(",
"metadatamap",
",",
"\"",
"\"",
"+",
"C",
".",
"GoString",
"(",
"service",
")",
")",
"\n",
"}",
"else",
"{",
"metadatamap",
"=",
"append",
"(",
"metadatamap",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"request",
":=",
"&",
"common",
".",
"EventInfo",
"{",
"PUType",
":",
"common",
".",
"UIDLoginPU",
",",
"PUID",
":",
"C",
".",
"GoString",
"(",
"user",
")",
",",
"Name",
":",
"\"",
"\"",
"+",
"C",
".",
"GoString",
"(",
"user",
")",
",",
"PID",
":",
"int32",
"(",
"os",
".",
"Getpid",
"(",
")",
")",
",",
"Tags",
":",
"metadatamap",
",",
"EventType",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"if",
"C",
".",
"is_root",
"(",
"user",
")",
"==",
"1",
"{",
"//Do nothing this is login shell account",
"}",
"else",
"{",
"//Do something",
"slog",
",",
"_",
":=",
"syslog",
".",
"New",
"(",
"syslog",
".",
"LOG_ALERT",
"|",
"syslog",
".",
"LOG_AUTH",
",",
"\"",
"\"",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"_",
"=",
"slog",
".",
"Close",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"client",
",",
"err",
":=",
"client",
".",
"NewClient",
"(",
"common",
".",
"TriremeSocket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"C",
".",
"PAM_SUCCESS",
"\n",
"}",
"\n\n",
"slog",
".",
"Alert",
"(",
"\"",
"\"",
")",
"// nolit",
"\n",
"if",
"err",
":=",
"client",
".",
"SendRequest",
"(",
"request",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"_",
"=",
"slog",
".",
"Alert",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"C",
".",
"PAM_SESSION_ERR",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"C",
".",
"PAM_SUCCESS",
"\n",
"}"
] |
// nolint
//export pam_sm_open_session
|
[
"nolint",
"export",
"pam_sm_open_session"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/plugins/pam/uidmonitorpam.go#L55-L103
|
7,477 |
aporeto-inc/trireme-lib
|
plugins/pam/uidmonitorpam.go
|
pam_sm_close_session
|
func pam_sm_close_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
slog.Alert("pam_sm_close_session") // nolint
slog.Close() // nolint
return C.PAM_SUCCESS
}
|
go
|
func pam_sm_close_session(pamh *C.pam_handle_t, flags, argc int, argv **C.char) C.int {
slog, _ := syslog.New(syslog.LOG_ALERT|syslog.LOG_AUTH, "mypam")
slog.Alert("pam_sm_close_session") // nolint
slog.Close() // nolint
return C.PAM_SUCCESS
}
|
[
"func",
"pam_sm_close_session",
"(",
"pamh",
"*",
"C",
".",
"pam_handle_t",
",",
"flags",
",",
"argc",
"int",
",",
"argv",
"*",
"*",
"C",
".",
"char",
")",
"C",
".",
"int",
"{",
"slog",
",",
"_",
":=",
"syslog",
".",
"New",
"(",
"syslog",
".",
"LOG_ALERT",
"|",
"syslog",
".",
"LOG_AUTH",
",",
"\"",
"\"",
")",
"\n",
"slog",
".",
"Alert",
"(",
"\"",
"\"",
")",
"// nolint",
"\n",
"slog",
".",
"Close",
"(",
")",
"// nolint",
"\n",
"return",
"C",
".",
"PAM_SUCCESS",
"\n",
"}"
] |
// nolint
//export pam_sm_close_session
|
[
"nolint",
"export",
"pam_sm_close_session"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/plugins/pam/uidmonitorpam.go#L107-L112
|
7,478 |
aporeto-inc/trireme-lib
|
controller/internal/processmon/mockprocessmon/mockprocessmon.go
|
NewMockProcessManager
|
func NewMockProcessManager(ctrl *gomock.Controller) *MockProcessManager {
mock := &MockProcessManager{ctrl: ctrl}
mock.recorder = &MockProcessManagerMockRecorder{mock}
return mock
}
|
go
|
func NewMockProcessManager(ctrl *gomock.Controller) *MockProcessManager {
mock := &MockProcessManager{ctrl: ctrl}
mock.recorder = &MockProcessManagerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockProcessManager",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockProcessManager",
"{",
"mock",
":=",
"&",
"MockProcessManager",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockProcessManagerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockProcessManager creates a new mock instance
// nolint
|
[
"NewMockProcessManager",
"creates",
"a",
"new",
"mock",
"instance",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L28-L32
|
7,479 |
aporeto-inc/trireme-lib
|
controller/internal/processmon/mockprocessmon/mockprocessmon.go
|
KillRemoteEnforcer
|
func (m *MockProcessManager) KillRemoteEnforcer(contextID string, force bool) error {
ret := m.ctrl.Call(m, "KillRemoteEnforcer", contextID, force)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockProcessManager) KillRemoteEnforcer(contextID string, force bool) error {
ret := m.ctrl.Call(m, "KillRemoteEnforcer", contextID, force)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockProcessManager",
")",
"KillRemoteEnforcer",
"(",
"contextID",
"string",
",",
"force",
"bool",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
",",
"force",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// KillRemoteEnforcer mocks base method
// nolint
|
[
"KillRemoteEnforcer",
"mocks",
"base",
"method",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L42-L46
|
7,480 |
aporeto-inc/trireme-lib
|
controller/internal/processmon/mockprocessmon/mockprocessmon.go
|
KillRemoteEnforcer
|
func (mr *MockProcessManagerMockRecorder) KillRemoteEnforcer(contextID, force interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KillRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).KillRemoteEnforcer), contextID, force)
}
|
go
|
func (mr *MockProcessManagerMockRecorder) KillRemoteEnforcer(contextID, force interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KillRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).KillRemoteEnforcer), contextID, force)
}
|
[
"func",
"(",
"mr",
"*",
"MockProcessManagerMockRecorder",
")",
"KillRemoteEnforcer",
"(",
"contextID",
",",
"force",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockProcessManager",
")",
"(",
"nil",
")",
".",
"KillRemoteEnforcer",
")",
",",
"contextID",
",",
"force",
")",
"\n",
"}"
] |
// KillRemoteEnforcer indicates an expected call of KillRemoteEnforcer
// nolint
|
[
"KillRemoteEnforcer",
"indicates",
"an",
"expected",
"call",
"of",
"KillRemoteEnforcer",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L50-L52
|
7,481 |
aporeto-inc/trireme-lib
|
controller/internal/processmon/mockprocessmon/mockprocessmon.go
|
LaunchRemoteEnforcer
|
func (m *MockProcessManager) LaunchRemoteEnforcer(contextID string, refPid int, refNsPath, arg, statssecret, procMountPoint string) (bool, error) {
ret := m.ctrl.Call(m, "LaunchRemoteEnforcer", contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockProcessManager) LaunchRemoteEnforcer(contextID string, refPid int, refNsPath, arg, statssecret, procMountPoint string) (bool, error) {
ret := m.ctrl.Call(m, "LaunchRemoteEnforcer", contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockProcessManager",
")",
"LaunchRemoteEnforcer",
"(",
"contextID",
"string",
",",
"refPid",
"int",
",",
"refNsPath",
",",
"arg",
",",
"statssecret",
",",
"procMountPoint",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"contextID",
",",
"refPid",
",",
"refNsPath",
",",
"arg",
",",
"statssecret",
",",
"procMountPoint",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// LaunchRemoteEnforcer mocks base method
// nolint
|
[
"LaunchRemoteEnforcer",
"mocks",
"base",
"method",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L56-L61
|
7,482 |
aporeto-inc/trireme-lib
|
controller/internal/processmon/mockprocessmon/mockprocessmon.go
|
LaunchRemoteEnforcer
|
func (mr *MockProcessManagerMockRecorder) LaunchRemoteEnforcer(contextID, refPid, refNsPath, arg, statssecret, procMountPoint interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaunchRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).LaunchRemoteEnforcer), contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
}
|
go
|
func (mr *MockProcessManagerMockRecorder) LaunchRemoteEnforcer(contextID, refPid, refNsPath, arg, statssecret, procMountPoint interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaunchRemoteEnforcer", reflect.TypeOf((*MockProcessManager)(nil).LaunchRemoteEnforcer), contextID, refPid, refNsPath, arg, statssecret, procMountPoint)
}
|
[
"func",
"(",
"mr",
"*",
"MockProcessManagerMockRecorder",
")",
"LaunchRemoteEnforcer",
"(",
"contextID",
",",
"refPid",
",",
"refNsPath",
",",
"arg",
",",
"statssecret",
",",
"procMountPoint",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockProcessManager",
")",
"(",
"nil",
")",
".",
"LaunchRemoteEnforcer",
")",
",",
"contextID",
",",
"refPid",
",",
"refNsPath",
",",
"arg",
",",
"statssecret",
",",
"procMountPoint",
")",
"\n",
"}"
] |
// LaunchRemoteEnforcer indicates an expected call of LaunchRemoteEnforcer
// nolint
|
[
"LaunchRemoteEnforcer",
"indicates",
"an",
"expected",
"call",
"of",
"LaunchRemoteEnforcer",
"nolint"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/internal/processmon/mockprocessmon/mockprocessmon.go#L65-L67
|
7,483 |
aporeto-inc/trireme-lib
|
controller/pkg/claimsheader/claimsheader.go
|
NewClaimsHeader
|
func NewClaimsHeader(opts ...Option) *ClaimsHeader {
c := &ClaimsHeader{}
for _, opt := range opts {
opt(c)
}
return c
}
|
go
|
func NewClaimsHeader(opts ...Option) *ClaimsHeader {
c := &ClaimsHeader{}
for _, opt := range opts {
opt(c)
}
return c
}
|
[
"func",
"NewClaimsHeader",
"(",
"opts",
"...",
"Option",
")",
"*",
"ClaimsHeader",
"{",
"c",
":=",
"&",
"ClaimsHeader",
"{",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"c",
"\n",
"}"
] |
// NewClaimsHeader returns claims header handler
|
[
"NewClaimsHeader",
"returns",
"claims",
"header",
"handler"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/claimsheader/claimsheader.go#L4-L13
|
7,484 |
aporeto-inc/trireme-lib
|
controller/pkg/secrets/compactpki.go
|
NewCompactPKI
|
func NewCompactPKI(keyPEM []byte, certPEM []byte, caPEM []byte, txKey []byte, compress claimsheader.CompressionType) (*CompactPKI, error) {
zap.L().Warn("DEPRECATED. secrets.NewCompactPKI is deprecated in favor of secrets.NewCompactPKIWithTokenCA")
return NewCompactPKIWithTokenCA(keyPEM, certPEM, caPEM, [][]byte{caPEM}, txKey, compress)
}
|
go
|
func NewCompactPKI(keyPEM []byte, certPEM []byte, caPEM []byte, txKey []byte, compress claimsheader.CompressionType) (*CompactPKI, error) {
zap.L().Warn("DEPRECATED. secrets.NewCompactPKI is deprecated in favor of secrets.NewCompactPKIWithTokenCA")
return NewCompactPKIWithTokenCA(keyPEM, certPEM, caPEM, [][]byte{caPEM}, txKey, compress)
}
|
[
"func",
"NewCompactPKI",
"(",
"keyPEM",
"[",
"]",
"byte",
",",
"certPEM",
"[",
"]",
"byte",
",",
"caPEM",
"[",
"]",
"byte",
",",
"txKey",
"[",
"]",
"byte",
",",
"compress",
"claimsheader",
".",
"CompressionType",
")",
"(",
"*",
"CompactPKI",
",",
"error",
")",
"{",
"zap",
".",
"L",
"(",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"NewCompactPKIWithTokenCA",
"(",
"keyPEM",
",",
"certPEM",
",",
"caPEM",
",",
"[",
"]",
"[",
"]",
"byte",
"{",
"caPEM",
"}",
",",
"txKey",
",",
"compress",
")",
"\n",
"}"
] |
// NewCompactPKI creates new secrets for PKI implementation based on compact encoding
|
[
"NewCompactPKI",
"creates",
"new",
"secrets",
"for",
"PKI",
"implementation",
"based",
"on",
"compact",
"encoding"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/secrets/compactpki.go#L32-L36
|
7,485 |
aporeto-inc/trireme-lib
|
controller/pkg/secrets/compactpki.go
|
PublicSecrets
|
func (p *CompactPKI) PublicSecrets() PublicSecrets {
return &CompactPKIPublicSecrets{
Type: PKICompactType,
Key: p.PrivateKeyPEM,
Certificate: p.PublicKeyPEM,
CA: p.AuthorityPEM,
Token: p.txKey,
TokenCAs: p.TokenKeyPEMs,
Compressed: p.Compressed,
}
}
|
go
|
func (p *CompactPKI) PublicSecrets() PublicSecrets {
return &CompactPKIPublicSecrets{
Type: PKICompactType,
Key: p.PrivateKeyPEM,
Certificate: p.PublicKeyPEM,
CA: p.AuthorityPEM,
Token: p.txKey,
TokenCAs: p.TokenKeyPEMs,
Compressed: p.Compressed,
}
}
|
[
"func",
"(",
"p",
"*",
"CompactPKI",
")",
"PublicSecrets",
"(",
")",
"PublicSecrets",
"{",
"return",
"&",
"CompactPKIPublicSecrets",
"{",
"Type",
":",
"PKICompactType",
",",
"Key",
":",
"p",
".",
"PrivateKeyPEM",
",",
"Certificate",
":",
"p",
".",
"PublicKeyPEM",
",",
"CA",
":",
"p",
".",
"AuthorityPEM",
",",
"Token",
":",
"p",
".",
"txKey",
",",
"TokenCAs",
":",
"p",
".",
"TokenKeyPEMs",
",",
"Compressed",
":",
"p",
".",
"Compressed",
",",
"}",
"\n",
"}"
] |
// PublicSecrets returns the secrets that are marshallable over the RPC interface.
|
[
"PublicSecrets",
"returns",
"the",
"secrets",
"that",
"are",
"marshallable",
"over",
"the",
"RPC",
"interface",
"."
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/controller/pkg/secrets/compactpki.go#L117-L127
|
7,486 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
NewPUPolicyWithDefaults
|
func NewPUPolicyWithDefaults() *PUPolicy {
return NewPUPolicy("", AllowAll, nil, nil, nil, nil, nil, nil, nil, nil, 0, nil, nil, []string{})
}
|
go
|
func NewPUPolicyWithDefaults() *PUPolicy {
return NewPUPolicy("", AllowAll, nil, nil, nil, nil, nil, nil, nil, nil, 0, nil, nil, []string{})
}
|
[
"func",
"NewPUPolicyWithDefaults",
"(",
")",
"*",
"PUPolicy",
"{",
"return",
"NewPUPolicy",
"(",
"\"",
"\"",
",",
"AllowAll",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"0",
",",
"nil",
",",
"nil",
",",
"[",
"]",
"string",
"{",
"}",
")",
"\n",
"}"
] |
// NewPUPolicyWithDefaults sets up a PU policy with defaults
|
[
"NewPUPolicyWithDefaults",
"sets",
"up",
"a",
"PU",
"policy",
"with",
"defaults"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L141-L143
|
7,487 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
ManagementID
|
func (p *PUPolicy) ManagementID() string {
p.Lock()
defer p.Unlock()
return p.managementID
}
|
go
|
func (p *PUPolicy) ManagementID() string {
p.Lock()
defer p.Unlock()
return p.managementID
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"ManagementID",
"(",
")",
"string",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"managementID",
"\n",
"}"
] |
// ManagementID returns the management ID
|
[
"ManagementID",
"returns",
"the",
"management",
"ID"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L171-L176
|
7,488 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
TriremeAction
|
func (p *PUPolicy) TriremeAction() PUAction {
p.Lock()
defer p.Unlock()
return p.triremeAction
}
|
go
|
func (p *PUPolicy) TriremeAction() PUAction {
p.Lock()
defer p.Unlock()
return p.triremeAction
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"TriremeAction",
"(",
")",
"PUAction",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"triremeAction",
"\n",
"}"
] |
// TriremeAction returns the TriremeAction
|
[
"TriremeAction",
"returns",
"the",
"TriremeAction"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L179-L184
|
7,489 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
SetTriremeAction
|
func (p *PUPolicy) SetTriremeAction(action PUAction) {
p.Lock()
defer p.Unlock()
p.triremeAction = action
}
|
go
|
func (p *PUPolicy) SetTriremeAction(action PUAction) {
p.Lock()
defer p.Unlock()
p.triremeAction = action
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"SetTriremeAction",
"(",
"action",
"PUAction",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"triremeAction",
"=",
"action",
"\n",
"}"
] |
// SetTriremeAction returns the TriremeAction
|
[
"SetTriremeAction",
"returns",
"the",
"TriremeAction"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L187-L192
|
7,490 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
ApplicationACLs
|
func (p *PUPolicy) ApplicationACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.applicationACLs.Copy()
}
|
go
|
func (p *PUPolicy) ApplicationACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.applicationACLs.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"ApplicationACLs",
"(",
")",
"IPRuleList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"applicationACLs",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// ApplicationACLs returns a copy of IPRuleList
|
[
"ApplicationACLs",
"returns",
"a",
"copy",
"of",
"IPRuleList"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L195-L200
|
7,491 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
NetworkACLs
|
func (p *PUPolicy) NetworkACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.networkACLs.Copy()
}
|
go
|
func (p *PUPolicy) NetworkACLs() IPRuleList {
p.Lock()
defer p.Unlock()
return p.networkACLs.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"NetworkACLs",
"(",
")",
"IPRuleList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"networkACLs",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// NetworkACLs returns a copy of IPRuleList
|
[
"NetworkACLs",
"returns",
"a",
"copy",
"of",
"IPRuleList"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L203-L208
|
7,492 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
DNSNameACLs
|
func (p *PUPolicy) DNSNameACLs() DNSRuleList {
p.Lock()
defer p.Unlock()
return p.DNSACLs.Copy()
}
|
go
|
func (p *PUPolicy) DNSNameACLs() DNSRuleList {
p.Lock()
defer p.Unlock()
return p.DNSACLs.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"DNSNameACLs",
"(",
")",
"DNSRuleList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"DNSACLs",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// DNSNameACLs returns a copy of DNSRuleList
|
[
"DNSNameACLs",
"returns",
"a",
"copy",
"of",
"DNSRuleList"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L211-L216
|
7,493 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
ReceiverRules
|
func (p *PUPolicy) ReceiverRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.receiverRules.Copy()
}
|
go
|
func (p *PUPolicy) ReceiverRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.receiverRules.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"ReceiverRules",
"(",
")",
"TagSelectorList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"receiverRules",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// ReceiverRules returns a copy of TagSelectorList
|
[
"ReceiverRules",
"returns",
"a",
"copy",
"of",
"TagSelectorList"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L219-L224
|
7,494 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
AddReceiverRules
|
func (p *PUPolicy) AddReceiverRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.receiverRules = append(p.receiverRules, t)
}
|
go
|
func (p *PUPolicy) AddReceiverRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.receiverRules = append(p.receiverRules, t)
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"AddReceiverRules",
"(",
"t",
"TagSelector",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"receiverRules",
"=",
"append",
"(",
"p",
".",
"receiverRules",
",",
"t",
")",
"\n",
"}"
] |
// AddReceiverRules adds a receiver rule
|
[
"AddReceiverRules",
"adds",
"a",
"receiver",
"rule"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L227-L232
|
7,495 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
TransmitterRules
|
func (p *PUPolicy) TransmitterRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.transmitterRules.Copy()
}
|
go
|
func (p *PUPolicy) TransmitterRules() TagSelectorList {
p.Lock()
defer p.Unlock()
return p.transmitterRules.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"TransmitterRules",
"(",
")",
"TagSelectorList",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"transmitterRules",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// TransmitterRules returns a copy of TagSelectorList
|
[
"TransmitterRules",
"returns",
"a",
"copy",
"of",
"TagSelectorList"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L235-L240
|
7,496 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
AddTransmitterRules
|
func (p *PUPolicy) AddTransmitterRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.transmitterRules = append(p.transmitterRules, t)
}
|
go
|
func (p *PUPolicy) AddTransmitterRules(t TagSelector) {
p.Lock()
defer p.Unlock()
p.transmitterRules = append(p.transmitterRules, t)
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"AddTransmitterRules",
"(",
"t",
"TagSelector",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"transmitterRules",
"=",
"append",
"(",
"p",
".",
"transmitterRules",
",",
"t",
")",
"\n",
"}"
] |
// AddTransmitterRules adds a transmitter rule
|
[
"AddTransmitterRules",
"adds",
"a",
"transmitter",
"rule"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L243-L248
|
7,497 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
Identity
|
func (p *PUPolicy) Identity() *TagStore {
p.Lock()
defer p.Unlock()
return p.identity.Copy()
}
|
go
|
func (p *PUPolicy) Identity() *TagStore {
p.Lock()
defer p.Unlock()
return p.identity.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"Identity",
"(",
")",
"*",
"TagStore",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"identity",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// Identity returns a copy of the Identity
|
[
"Identity",
"returns",
"a",
"copy",
"of",
"the",
"Identity"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L251-L256
|
7,498 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
Annotations
|
func (p *PUPolicy) Annotations() *TagStore {
p.Lock()
defer p.Unlock()
return p.annotations.Copy()
}
|
go
|
func (p *PUPolicy) Annotations() *TagStore {
p.Lock()
defer p.Unlock()
return p.annotations.Copy()
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"Annotations",
"(",
")",
"*",
"TagStore",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"p",
".",
"annotations",
".",
"Copy",
"(",
")",
"\n",
"}"
] |
// Annotations returns a copy of the annotations
|
[
"Annotations",
"returns",
"a",
"copy",
"of",
"the",
"annotations"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L259-L264
|
7,499 |
aporeto-inc/trireme-lib
|
policy/policy.go
|
AddIdentityTag
|
func (p *PUPolicy) AddIdentityTag(k, v string) {
p.Lock()
defer p.Unlock()
p.identity.AppendKeyValue(k, v)
}
|
go
|
func (p *PUPolicy) AddIdentityTag(k, v string) {
p.Lock()
defer p.Unlock()
p.identity.AppendKeyValue(k, v)
}
|
[
"func",
"(",
"p",
"*",
"PUPolicy",
")",
"AddIdentityTag",
"(",
"k",
",",
"v",
"string",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"p",
".",
"identity",
".",
"AppendKeyValue",
"(",
"k",
",",
"v",
")",
"\n",
"}"
] |
// AddIdentityTag adds a policy tag
|
[
"AddIdentityTag",
"adds",
"a",
"policy",
"tag"
] |
009258cf9b4f3f70f71994d9fadebe564f7e0437
|
https://github.com/aporeto-inc/trireme-lib/blob/009258cf9b4f3f70f71994d9fadebe564f7e0437/policy/policy.go#L267-L272
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.