id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c6900 | "5"
} else {
e = "6"
}
} else {
if f.ObserveAction.ObserveContinue() {
e = "7"
} else if f.ObserveAction.ObserveApply() {
e = "8"
} else {
e = "9"
}
}
return e
} | |
c6901 | case "4":
return Observe | Reject, ObserveContinue, nil
case "5":
return Observe | Reject, ObserveApply, nil
case "6":
return Reject, ObserveNone, nil
case "7":
return Observe, ObserveContinue, nil
case "8":
return Observe, ObserveApply, nil
case "9":
return 0, ObserveNone, nil
}
return 0, 0, error... | |
c6902 | len(l))
for i, v := range l {
list[i] = v
}
return list
} | |
c6903 | v := range l {
list[i] = v
}
return list
} | |
c6904 | make(TagSelectorList, len(t))
for i, v := range t {
list[i] = v
}
return list
} | |
c6905 | := ExtendedMap{}
for k, v := range s {
c[k] = v
}
return c
} | |
c6906 | ok := s[key]
return value, ok
} | |
c6907 |
secret string,
statsClient statsclient.StatsClient,
collector statscollector.Collector,
debugClient debugclient.DebugClient,
) (*RemoteEnforcer, error) {
return nil, nil
} | |
c6908 | cgroupCache: cache.NewCache("secrets pu cache"),
policyCache: cache.NewCache("policy cache"),
}
} | |
c6909 | }
s.server = &http.Server{
Handler: http.HandlerFunc(s.apiProcessor),
}
go func() {
<-ctx.Done()
s.server.Close() // nolint errcheck
}()
go s.server.Serve(server.NewUIDListener(nl)) // nolint errcheck
return nil
} | |
c6910 | error {
return s.updateService(puInfo)
} | |
c6911 | - invalid type", http.StatusInternalServerError)
return
}
// Search the API cache for matching rules.
found, _ := apiCache.FindAndMatchScope(r.Method, r.RequestURI, scopes)
if !found {
httpError(w, fmt.Errorf("Unauthorized service"), "Unauthorized access", http.StatusUnauthorized)
return
}
// Retrieve th... | |
c6912 | }
ppid, err := process.Ppid()
if err != nil {
return "", fmt.Errorf("Parent process not found: %s", err)
}
parentPidCgroup, err := processCgroups(strconv.Itoa(int(ppid)), "net_cls,net_prio")
if err != nil {
return "", fmt.Errorf("Parent cgroup not found: %s", err)
}
if parentPidCgroup != "/" {
return "", ... | |
c6913 |
for i := len(cgroup) - 1; i > 0; i-- {
if cgroup[i:i+1] == "/" {
return cgroup[:i], nil
}
}
if strings.HasPrefix(cgroup, "/docker/") && len(cgroup) > 8 {
return cgroup[8:20], nil
}
return "", fmt.Errorf("Cannot find parent cgroup: %s", pid)
} | |
c6914 | fmt.Errorf("unable to initialize supervisor controllers: %s", err)
}
return &Config{
mode: mode,
impl: impl,
versionTracker: cache.NewCache("SupVersionTracker"),
collector: collector,
filterQueue: filterQueue,
service: p,
cfg: cfg,
}, nil
} | |
c6915 |
return err
}
if s.service != nil {
s.service.Initialize(s.filterQueue, s.impl.ACLProvider())
}
return nil
} | |
c6916 | ContextID is not found in Cache, New PU: Do create.
return s.doCreatePU(contextID, pu)
}
// Context already in the cache. Just run update
return s.doUpdatePU(contextID, pu)
} | |
c6917 | := cfg.containerInfo.Runtime.PUType()
// TODO (varks): Similar to configureRules and UpdateRules, DeleteRules should take
// only contextID and *policy.PUInfo as function parameters.
if err := s.impl.DeleteRules(cfg.version, contextID, cfg.tcpPorts, cfg.udpPorts, cfg.mark, cfg.username, port, puType); err != nil {... | |
c6918 |
defer s.Unlock()
return s.impl.CleanUp()
} | |
c6919 | error {
s.Lock()
defer s.Unlock()
return s.impl.SetTargetNetworks(cfg)
} | |
c6920 |
if err := s.impl.UpdateRules(c.version, contextID, pu, c.containerInfo); err != nil {
// Try to clean up, even though this is fatal and it will most likely fail
s.Unlock()
s.Unsupervise(contextID) // nolint
return err
}
// Updated the policy in the cached processing unit.
c.containerInfo.Policy = pu.Polic... | |
c6921 | flush debug iptables after interval
go func() {
for {
select {
case <-ctx.Done():
case <-time.After(interval):
for _, rule := range iptablesRules {
if err := ipt.Delete(rule[0], rule[1], rule[2:]...); err != nil {
zap.L().Debug("Unable to delete trace rules", zap.Error(err))
}
}
... | |
c6922 | &tokenAccessor{
tokens: tokenEngine,
serverID: serverID,
validity: validity,
}, nil
} | |
c6923 | serverID, secret)
if err != nil {
return err
}
t.tokens = tokenEngine
return nil
} | |
c6924 | LCL: auth.LocalContext,
RMT: auth.RemoteContext,
}
token, err := t.getToken().CreateAndSign(true, claims, auth.LocalContext, claimsheader.NewClaimsHeader())
if err != nil {
return []byte{}, err
}
return token, nil
} | |
c6925 | claims := &tokens.ConnectionClaims{
T: context.Identity(),
EK: auth.LocalServiceContext,
}
if token, err = t.getToken().CreateAndSign(false, claims, auth.LocalContext, claimsheader.NewClaimsHeader()); err != nil {
return []byte{}, nil
}
context.UpdateCachedTokenAndServiceContext(token, auth.LocalServiceCo... | |
c6926 | }
if token, err = t.getToken().CreateAndSign(false, claims, auth.LocalContext, claimsHeader); err != nil {
return []byte{}, nil
}
return token, nil
} | |
c6927 | if !ok {
return nil, errors.New("no transmitter label")
}
auth.RemotePublicKey = cert
auth.RemoteContext = nonce
auth.RemoteContextID = remoteContextID
auth.RemoteServiceContext = claims.EK
return claims, nil
} | |
c6928 | matchLocal := bytes.Compare(claims.RMT, auth.LocalContext)
matchRemote := bytes.Compare(claims.LCL, auth.RemoteContext)
if matchLocal != 0 || matchRemote != 0 {
return nil, errors.New("failed to match context in ack packet")
}
return claims, nil
} | |
c6929 | ctrl}
mock.recorder = &MockEventCollectorMockRecorder{mock}
return mock
} | |
c6930 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectFlowEvent", reflect.TypeOf((*MockEventCollector)(nil).CollectFlowEvent), record)
} | |
c6931 | }
}
v.clientConfig = &oauth2.Config{
ClientID: v.ClientID,
ClientSecret: v.ClientSecret,
Endpoint: provider.Endpoint(),
RedirectURL: v.RedirectURL,
Scopes: scopes,
}
// Google does not honor the OIDC standard to refresh tokens
// with a proper scope. Instead it requires a prompt paramet... | |
c6932 | the main
// step where the OAUTH provider will match the code to the token.
oauth2Token, err := v.clientConfig.Exchange(r.Context(), r.URL.Query().Get("code"), oauth2.AccessTypeOffline)
if err != nil {
return "", "", http.StatusInternalServerError, fmt.Errorf("bad code: %s", err)
}
// We extract the rawID toke... | |
c6933 | if rule.Policy.Action.Accepted() {
return c.accept.addRule(rule)
}
return c.reject.addRule(rule)
} | |
c6934 |
}
c.reject.reverseSort()
c.accept.reverseSort()
c.observe.reverseSort()
return
} | |
c6935 |
report, packet, err = c.observe.getMatchingAction(ip, port, report)
if err == nil {
return
}
if report == nil {
report = catchAllPolicy
}
if packet == nil {
packet = catchAllPolicy
}
return report, packet, errors.New("no match")
} | |
c6936 | s.prochdl.KillRemoteEnforcer(contextID, true) // nolint errcheck
return err
}
}
enforcerPayload := &rpcwrapper.EnforcePayload{
ContextID: contextID,
Policy: puInfo.Policy.ToPublicPolicy(),
}
//Only the secrets need to be under lock. They can change async to the enforce call from Updatesecrets
s.RLo... | |
c6937 | {
zap.L().Error("failed to send message to remote enforcer", zap.Error(err))
}
return s.prochdl.KillRemoteEnforcer(contextID, true)
} | |
c6938 | err.Error()
}
}
if len(allErrors) > 0 {
return fmt.Errorf("Remote enforcers failed: %s", allErrors)
}
return nil
} | |
c6939 | },
}
if err := s.rpchdl.RemoteCall(contextID, remoteenforcer.EnableDatapathPacketTracing, request, resp); err != nil {
return fmt.Errorf("unable to enable datapath packet tracing %s -- %s", err, resp.Status)
}
return nil
} | |
c6940 |
allErrors = allErrors + " contextID " + contextID + ":" + err.Error()
}
}
s.Lock()
s.cfg = cfg
s.Unlock()
if len(allErrors) > 0 {
return fmt.Errorf("Remote enforcers failed: %s", allErrors)
}
return nil
} | |
c6941 | server for statistics collection.
go statsServer.StartServer(ctx, "unix", constants.StatsChannel, rpcServer) // nolint
return nil
} | |
c6942 | s.serverID,
ExternalIPCacheTimeout: s.ExternalIPCacheTimeout,
PacketLogs: s.packetLogs,
Secrets: s.Secrets.PublicSecrets(),
Configuration: s.cfg,
},
}
return s.rpchdl.RemoteCall(contextID, remoteenforcer.InitEnforcer, request, resp)
} | |
c6943 | stats reporting", zap.Error(err))
// We will use current time as the secret
statsServersecret = time.Now().String()
}
rpcClient := rpcwrapper.NewRPCWrapper()
return &ProxyInfo{
mutualAuth: mutualAuth,
Secrets: secrets,
serverID: serverID,
validity: ... | |
c6944 | {
r.collector.CollectFlowEvent(record)
}
for _, record := range payload.Users {
r.collector.CollectUserEvent(record)
}
return nil
} | |
c6945 | payload := req.Payload.(rpcwrapper.DebugPacketPayload)
for _, record := range payload.PacketRecords {
r.collector.CollectPacketEvent(record)
}
return nil
} | |
c6946 | caPool,
applicationProxy: applicationProxy,
mark: mark,
secrets: secrets,
localIPs: markedconn.GetInterfaces(),
registry: registry,
tlsClientConfig: &tls.Config{
RootCAs: caPool,
},
}
} | |
c6947 |
}
if portContext.Service.UserAuthorizationType == policy.UserAuthorizationMutualTLS || portContext.Service.UserAuthorizationType == policy.UserAuthorizationJWT {
clientCAs := p.ca
if portContext.ClientTrustedRoots != nil {
clientCAs = portContext.ClientTrustedRoots
}
config := p.newBaseTLSConfig()
... | |
c6948 | SessionTicketsDisabled: true,
CipherSuites: []uint16{
tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
},
}
} | |
c6949 | = s
p.certPEM = certPEM
p.keyPEM = keyPEM
p.tlsClientConfig.RootCAs = caPool
} | |
c6950 |
service := portContext.Service
if service.PublicNetworkInfo != nil && service.PublicNetworkInfo.Ports.Min == uint16(port) && len(service.PublicServiceCertificate) > 0 {
tlsCert, err := tls.X509KeyPair(service.PublicServiceCertificate, service.PublicServiceCertificateKey)
if err != nil {
return nil, ... | |
c6951 | batchTablesMap[t] = true
}
}
b := &BatchProvider{
ipt: ipt,
rules: map[string]map[string][]string{},
batchTables: batchTablesMap,
}
b.commitFunc = b.restore
return b, nil
} | |
c6952 | return &BatchProvider{
ipt: ipt,
rules: map[string]map[string][]string{},
batchTables: batchTablesMap,
commitFunc: commit,
}
} | |
c6953 |
if _, ok := b.rules[table][chain]; !ok {
b.rules[table][chain] = []string{}
}
rule := strings.Join(rulespec, " ")
b.rules[table][chain] = append(b.rules[table][chain], rule)
return nil
} | |
c6954 | {
b.rules[table][chain] = append(b.rules[table][chain], rule)
} else {
b.rules[table][chain] = append(b.rules[table][chain], "newvalue")
copy(b.rules[table][chain][pos-1:], b.rules[table][chain][pos-2:])
b.rules[table][chain][pos-1] = rule
}
return nil
} | |
c6955 | 1 {
b.rules[table][chain] = []string{}
} else {
b.rules[table][chain] = b.rules[table][chain][1:]
}
case len(b.rules[table][chain]) - 1:
b.rules[table][chain] = b.rules[table][chain][:index]
default:
b.rules[table][chain] = append(b.rules[table][chain][:index], b.rules[table][chain][ind... | |
c6956 |
defer b.Unlock()
return b.ipt.ListChains(table)
} | |
c6957 |
b.rules[table] = map[string][]string{}
}
b.rules[table][chain] = []string{}
return nil
} | |
c6958 | := b.createDataBuffer()
if err != nil {
return fmt.Errorf("Failed to crete buffer %s", err)
}
return b.commitFunc(buf)
} | |
c6959 | defer b.Unlock()
return b.rules
} | |
c6960 | again, _ := b.createDataBuffer()
zap.L().Error("Failed to execute command", zap.Error(err),
zap.ByteString("Output", out),
zap.String("Output", again.String()),
)
return fmt.Errorf("Failed to execute iptables-restore: %s", err)
}
return nil
} | |
c6961 | string) error) {
m.currentMocks(t).NewRPCClientMock = impl
} | |
c6962 |
m.currentMocks(t).GetRPCClientMock = impl
} | |
c6963 | resp *Response) error) {
m.currentMocks(t).RemoteCallMock = impl
} | |
c6964 |
m.currentMocks(t).DestroyRPCClientMock = impl
} | |
c6965 | handler interface{}) error) {
m.currentMocks(t).StartServerMock = impl
} | |
c6966 | {
m.currentMocks(t).ProcessMessageMock = impl
} | |
c6967 |
m.currentMocks(t).ContextListMock = impl
} | |
c6968 | {
m.currentMocks(t).CheckValidityMock = impl
} | |
c6969 | {
return mock.NewRPCClientMock(contextID, channel, secret)
}
return nil
} | |
c6970 | return mock.GetRPCClientMock(contextID)
}
return nil, nil
} | |
c6971 | != nil {
return mock.RemoteCallMock(contextID, methodName, req, resp)
}
return nil
} | |
c6972 | mock.DestroyRPCClientMock != nil {
mock.DestroyRPCClientMock(contextID)
return
}
} | |
c6973 | mock != nil && mock.DestroyRPCClientMock != nil {
return mock.CheckValidityMock(req, secret)
}
return false
} | |
c6974 | && mock.StartServerMock != nil {
return mock.StartServerMock(ctx, protocol, path, handler)
}
return nil
} | |
c6975 | mock != nil && mock.ProcessMessageMock != nil {
return mock.ProcessMessageMock(req, secret)
}
return true
} | |
c6976 | mock != nil && mock.ContextListMock != nil {
return mock.ContextListMock()
}
return []string{}
} | |
c6977 |
mocks := m.mocks[t]
if mocks == nil {
mocks = &mockedMethods{}
m.mocks[t] = mocks
}
return mocks
} | |
c6978 | ApplicationACLs: acls.NewACLCache(),
networkACLs: acls.NewACLCache(),
mark: puInfo.Runtime.Options().CgroupMark,
scopes: puInfo.Policy.Scopes(),
CancelFunc: cancelFunc,
}
pu.CreateRcvRules(puInfo.Policy.ReceiverRules())
pu.CreateTxtRules(puInfo.Policy.TransmitterRules())
tc... | |
c6979 | string) (interface{}, error) {
return p.externalIPCache.Get(id)
} | |
c6980 |
return p.networkACLs.GetMatchingAction(packet.SourceAddress(), packet.DestPort())
} | |
c6981 | action *policy.FlowPolicy, err error) {
defer p.RUnlock()
p.RLock()
return p.networkACLs.GetMatchingAction(addr, port)
} | |
c6982 | error {
defer p.Unlock()
p.Lock()
return p.ApplicationACLs.AddRuleList(rules)
} | |
c6983 | error {
defer p.Unlock()
p.Lock()
return p.networkACLs.AddRuleList(rules)
} | |
c6984 | p.externalIPCache.AddOrUpdate(packet.SourceAddress().String()+":"+strconv.Itoa(int(packet.SourcePort())), plc)
} | |
c6985 | return p.mark, p.tcpPorts, p.udpPorts
} | |
c6986 | defer p.RUnlock()
return p.synServiceContext
} | |
c6987 | p.Lock()
p.synServiceContext = synServiceContext
p.Unlock()
} | |
c6988 | make([]byte, len(p.synToken))
copy(token, p.synToken)
return token, p.synServiceContext, nil
}
return nil, nil, fmt.Errorf("expired Token")
} | |
c6989 | = time.Now().Add(time.Millisecond * 500)
p.synServiceContext = serviceContext
p.Unlock()
} | |
c6990 | defer p.RUnlock()
return p.scopes
} | |
c6991 | p.jwtExpiration.After(time.Now()) && len(p.jwt) > 0 {
return p.jwt, nil
}
return "", fmt.Errorf("expired token")
} | |
c6992 | {
p.Lock()
defer p.Unlock()
p.jwt = jwt
p.jwtExpiration = expiration
} | |
c6993 | if rule.Policy.Action.Rejected() {
policyDB.observeRejectRules.AddPolicy(rule)
}
} else if rule.Policy.ObserveAction.ObserveApply() {
policyDB.observeApplyRules.AddPolicy(rule)
} else if rule.Policy.Action.Accepted() {
policyDB.acceptRules.AddPolicy(rule)
} else if rule.Policy.Action.Rejected() {
... | |
c6994 | policy.TagSelectorList) {
p.rcv = p.createRuleDBs(policyRules)
} | |
c6995 | policy.TagSelectorList) {
p.txt = p.createRuleDBs(policyRules)
} | |
c6996 | packetAction = &policy.FlowPolicy{
Action: policy.Accept | policy.Encrypt,
PolicyID: finalAction.PolicyID,
ServiceID: finalAction.ServiceID,
}
}
if reportingAction == nil {
reportingAction = packetAction
}
return reportingAction, packetAction
}
// Look for observe apply rules
observeI... | |
c6997 | *policy.FlowPolicy) {
return p.searchRules(p.txt, tags, skipRejectPolicies)
} | |
c6998 | *policy.FlowPolicy) {
return p.searchRules(p.rcv, tags, false)
} | |
c6999 | nobody will be affected.
r.indexByPort.DeleteByID(puID, true)
r.indexByPort.DeleteByID(puID, false)
if err := r.updateDependentServices(sctx); err != nil {
return nil, err
}
if err := r.updateExposedServices(sctx, secrets); err != nil {
return nil, err
}
r.indexByName[puID] = sctx
return sctx, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.