id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c7300 | err
}
if _, err := digest.Write(hash); err != nil {
return err
}
req.HashAuth = digest.Sum(nil)
return rpcClient.Client.Call(methodName, req, resp)
} | |
c7301 | _, err := digest.Write(hash); err != nil {
return false
}
return hmac.Equal(req.HashAuth, digest.Sum(nil))
} | |
c7302 |
zap.L().Debug("Socket path already exists: removing", zap.String("path", path))
if rerr := os.Remove(path); rerr != nil {
return fmt.Errorf("unable to delete existing socket path %s: %s", path, rerr)
}
}
// Get listener
listen, err := net.Listen(protocol, path)
if err != nil {
return err
}
go http... | |
c7303 | zap.Error(err),
)
}
if err = os.Remove(rpcHdl.(*RPCHdl).Channel); err != nil {
zap.L().Debug("Failed to remove channel - already closed",
zap.String("contextID", contextID),
zap.Error(err),
)
}
if err = r.rpcClientMap.Remove(contextID); err != nil {
zap.L().Warn("Failed to remove item from cache"... | |
c7304 | for _, key := range keylist {
if kstring, ok := key.(string); ok {
contextArray = append(contextArray, kstring)
}
}
return contextArray
} | |
c7305 |
return r.CheckValidity(req, secret)
} | |
c7306 | make([]byte, 8)
binary.BigEndian.PutUint64(buf, hash)
return buf, nil
} | |
c7307 | gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.SetTargetNetworks_Payload", *(&SetTargetNetworksPayload{}))
gob.RegisterName("go.aporeto.io/trireme-lib/controller/internal/enforcer/utils/rpcwrapper.EnableIPTablesPacketTracing_PayLoad", *(&EnableIPTablesPacketTracingPayLoad{})... | |
c7308 | map[common.PUType]map[common.Event]common.EventHandler{},
}
} | |
c7309 |
r.addHandler(puType, common.EventCreate, ep.Create)
r.addHandler(puType, common.EventDestroy, ep.Destroy)
r.addHandler(puType, common.EventPause, ep.Pause)
r.addHandler(puType, common.EventResync, ep.Resync)
return nil
} | |
c7310 |
case packet.TCPAckMask:
return nil, d.processApplicationAckPacket(tcpPacket, context, conn)
case packet.TCPSynAckMask:
return nil, d.processApplicationSynAckPacket(tcpPacket, context, conn)
default:
return nil, nil
}
} | |
c7311 | nil, fmt.Errorf("No acls found for external services. Dropping application syn packet")
}
if policy, err := context.RetrieveCachedExternalFlowPolicy(tcpPacket.DestinationAddress().String() + ":" + strconv.Itoa(int(tcpPacket.DestPort()))); err == nil {
d.appOrigConnectionTracker.AddOrUpdate(tcpPacket.L4FlowHash(),... | |
c7312 | if err1 != nil || err2 != nil {
zap.L().Debug("Failed to remove cache entries")
}
return nil
}
// We now process packets that need authorization options
// Create TCP Option
tcpOptions := d.createTCPAuthenticationOption([]byte{})
claimsHeader := claimsheader.NewClaimsHeader(
claimsheader.OptionEncryp... | |
c7313 | tcpPacket)
case packet.TCPAckMask:
return d.processNetworkAckPacket(context, conn, tcpPacket)
case packet.TCPSynAckMask:
return d.processNetworkSynAckPacket(context, conn, tcpPacket)
default: // Ignore any other packet
return nil, nil, nil
}
} | |
c7314 | tokenLen, 0, 0}
if tokenLen != 0 {
options = append(options, token...)
}
return options
} | |
c7315 | := d.appOrigConnectionTracker.GetReset(p.L4FlowHash(), 0); err == nil {
return conn.(*connection.TCPConnection), nil
}
return connection.NewTCPConnection(context, p), nil
} | |
c7316 | // If this ack packet is from client, Did we see an Application Syn packet before?
conn, err = d.appOrigConnectionTracker.GetReset(hash, 0)
if err == nil {
if uerr := updateTimer(d.appOrigConnectionTracker, hash, conn.(*connection.TCPConnection)); uerr != nil {
return nil, uerr
}
return conn.(*connection.TC... | |
c7317 | p.CheckTCPAuthenticationOption(enforcerconstants.TCPAuthenticationOptionBaseLen); err != nil {
zap.L().Error("Syn received with tcp option not set", zap.Error(err))
return nil, errNonPUTraffic
}
if err = p.TCPDataDetach(enforcerconstants.TCPAuthenticationOptionBaseLen); err != nil {
zap.L().Error("Error ... | |
c7318 | != nil {
return nil, errNonPUTraffic
}
return conn.(*connection.TCPConnection), nil
} | |
c7319 | state.
if p.GetTCPFlags()&packet.TCPSynAckMask == packet.TCPAckMask {
// Let's try if its an existing connection
context, cerr := d.contextFromIP(false, p.Mark, p.DestPort(), packet.IPProtocolTCP)
if cerr != nil {
return nil, err
}
conn = connection.NewTCPConnection(context, p)
conn.(*connection.TCPCon... | |
c7320 |
defer conn.RUnlock()
if conn.ServiceConnection && conn.TimeOut > 0 {
return c.SetTimeOut(hash, conn.TimeOut)
}
return nil
} | |
c7321 | nil {
zap.L().Debug("Failed to clean cache sourcePortConnectionCache", zap.Error(err))
}
if err := d.conntrack.UpdateNetworkFlowMark(
tcpPacket.SourceAddress(),
tcpPacket.DestinationAddress(),
tcpPacket.IPProto(),
tcpPacket.SourcePort(),
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil ... | |
c7322 |
tcpPacket.DestPort(),
constants.DefaultConnMark,
); err != nil && !netlink.IsNotExist(errors.Cause(err)) {
zap.L().Error("Failed to update conntrack table", zap.Error(err))
}
} | |
c7323 | mock.recorder = &MockSupervisorMockRecorder{mock}
return mock
} | |
c7324 | error {
ret := m.ctrl.Call(m, "Supervise", contextID, puInfo)
ret0, _ := ret[0].(error)
return ret0
} | |
c7325 | reflect.TypeOf((*MockSupervisor)(nil).Supervise), contextID, puInfo)
} | |
c7326 | "Unsupervise", contextID)
ret0, _ := ret[0].(error)
return ret0
} | |
c7327 | := m.ctrl.Call(m, "SetTargetNetworks", cfg)
ret0, _ := ret[0].(error)
return ret0
} | |
c7328 |
mock.recorder = &MockImplementorMockRecorder{mock}
return mock
} | |
c7329 | error {
ret := m.ctrl.Call(m, "ConfigureRules", version, contextID, containerInfo)
ret0, _ := ret[0].(error)
return ret0
} | |
c7330 | "ConfigureRules", reflect.TypeOf((*MockImplementor)(nil).ConfigureRules), version, contextID, containerInfo)
} | |
c7331 | context, tcpPorts, udpPorts, mark, uid, proxyPort, puType)
ret0, _ := ret[0].(error)
return ret0
} | |
c7332 | "DeleteRules", reflect.TypeOf((*MockImplementor)(nil).DeleteRules), version, context, tcpPorts, udpPorts, mark, uid, proxyPort, puType)
} | |
c7333 | ret[0].(aclprovider.IptablesProvider)
return ret0
} | |
c7334 | nil, fmt.Errorf("Cannot create clean up socket: %s", err)
}
}
return &EventServer{
socketPath: address,
registerer: registerer,
}, nil
} | |
c7335 | r *http.Request) {
e.create(w, r)
} | |
c7336 | the socket accessible to all users: %s", err)
}
listener := &UIDListener{nl}
// Start serving HTTP requests in the background
go e.server.Serve(listener) // nolint
// Listen for context cancellation to close the socket.
go func() {
<-ctx.Done()
nl.Close() // nolint
}()
return nil
} | |
c7337 | err := validateEvent(event); err != nil {
http.Error(w, fmt.Sprintf("Bad request: %s", err), http.StatusBadRequest)
return
}
if err := e.processEvent(r.Context(), event); err != nil {
zap.L().Error("Error in processing event", zap.Error(err), zap.Reflect("Event", event))
http.Error(w, fmt.Sprintf("Cannot ha... | |
c7338 | e.registerer.GetHandler(eventInfo.PUType, eventInfo.EventType)
if err != nil {
return fmt.Errorf("Handler not found: %s", err)
}
return f(ctx, eventInfo)
} | |
c7339 | err := p.Uids()
if err != nil {
return fmt.Errorf("Unknown user ID")
}
match := false
for _, uid := range uids {
if strconv.Itoa(int(uid)) == parts[0] {
match = true
}
}
if !match {
return fmt.Errorf("Invalid user - no access to this process: %+v PARTS: %+v", event, parts)
}
return nil
} | |
c7340 | return fmt.Errorf("Invalid cgroup format: %s", event.Cgroup)
}
if !regexNS.Match([]byte(event.NS)) {
return fmt.Errorf("Namespace is not of the right format")
}
for k, v := range event.IPs {
if !regexStrings.Match([]byte(k)) {
return fmt.Errorf("Invalid IP name: %s", k)
}
if ip := net.ParseIP(v); ip... | |
c7341 |
}
}
if event.EventType == common.EventStop || event.EventType == common.EventDestroy {
regStop := regexp.MustCompile("^/trireme/[a-zA-Z0-9_]{1,11}$")
if event.Cgroup != "" && !regStop.Match([]byte(event.Cgroup)) {
return fmt.Errorf("Cgroup is not of the right format")
}
}
return nil
} | |
c7342 |
}
portSetName := puPortSetName(contextID, prefix)
if puseterr := i.createPUPortSet(portSetName); puseterr != nil {
return puseterr
}
i.contextIDToPortSetMap.AddOrUpdate(contextID, portSetName)
return nil
} | |
c7343 | if err := i.contextIDToPortSetMap.Remove(contextID); err != nil {
zap.L().Debug("portset not found for the contextID", zap.String("contextID", contextID))
}
return nil
} | |
c7344 | _, err := strconv.Atoi(port); err != nil {
return fmt.Errorf("invalid port: %s", err)
}
if err := ips.Del(port); err != nil {
return fmt.Errorf("unable to delete port from portset: %s", err)
}
return nil
} | |
c7345 | map[string]*collector.UserRecord{},
ProcessedUsers: map[string]bool{},
DatapathPacketReports: []*collector.PacketReport{},
}
} | |
c7346 | if len(strings.TrimSpace(k)) == 0 {
continue
}
value := v
if len(v) == 0 {
value = "<empty>"
}
if !strings.HasPrefix(k, UserLabelPrefix) {
tags.AppendKeyValue(UserLabelPrefix+k, value)
} else {
tags.AppendKeyValue(k, value)
}
}
ipa := policy.ExtendedMap{
"bridge": info.NetworkSettings.IP... | |
c7347 | }
for p := range dockerInfo.Config.ExposedPorts {
if p.Proto() == "tcp" {
s, err := portspec.NewPortSpecFromString(p.Port(), nil)
if err != nil {
continue
}
options.Services = append(options.Services, common.Service{
Protocol: uint8(6),
Ports: s,
})
}
}
return &options
} | |
c7348 | // nolint errcheck
hash.Write([]byte(r.ObservedAction.String())) // nolint errcheck
hash.Write([]byte(r.DropReason)) // nolint errcheck
hash.Write([]byte(r.Destination.URI)) // nolint errcheck
return fmt.Sprintf("%d", hash.Sum64())
} | |
c7349 | _, err := hash.Write([]byte(r.Claims[i])); err != nil {
return fmt.Errorf("Cannot create hash")
}
}
r.ID = fmt.Sprintf("%d", hash.Sum64())
return nil
} | |
c7350 | cache.NewCache(name),
ranges: []*portspec.PortSpec{},
}
} | |
c7351 | Insert the portspec
p.Lock()
p.ranges = append([]*portspec.PortSpec{s}, p.ranges...)
p.Unlock()
}
} | |
c7352 |
p.Lock()
p.ranges = append(p.ranges, s)
p.Unlock()
} | |
c7353 | return fmt.Errorf("Overlap detected: %d %d", r.Max, r.Min)
}
if s.Min == s.Max {
return p.ports.Add(s.Min, s)
}
p.ranges = append(p.ranges, s)
return nil
} | |
c7354 | if s.Min <= port && port < s.Max {
return s.Value(), nil
}
}
return nil, fmt.Errorf("No match for port %d", port)
} | |
c7355 | left := p.ranges[:i]
right := p.ranges[i+1:]
p.ranges = append(left, right...)
return nil
}
}
return fmt.Errorf("port not found")
} | |
c7356 | if err != nil {
return err
}
return p.Remove(s)
} | |
c7357 | mock.recorder = &MockRemoteIntfMockRecorder{mock}
return mock
} | |
c7358 | := m.ctrl.Call(m, "InitEnforcer", req, resp)
ret0, _ := ret[0].(error)
return ret0
} | |
c7359 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitEnforcer", reflect.TypeOf((*MockRemoteIntf)(nil).InitEnforcer), req, resp)
} | |
c7360 |
if e.transport != nil {
if err := e.transport.Run(ctx); err != nil {
return err
}
}
if e.secrets != nil {
if err := e.secrets.Run(ctx); err != nil {
return err
}
}
return nil
} | |
c7361 |
if e.proxy != nil {
if err := e.proxy.Enforce(context.Background(), contextID, puInfo); err != nil {
return fmt.Errorf("unable to enforce in proxy: %s", err)
}
}
if e.secrets != nil {
if err := e.secrets.Enforce(puInfo); err != nil {
return fmt.Errorf("unable to enforce in secrets proxy: %s", err)
}... | |
c7362 | if e.secrets != nil {
if serr = e.secrets.Unenforce(contextID); nerr != nil {
zap.L().Error("Failed to unenforce contextID in transport",
zap.String("ContextID", contextID),
zap.Error(nerr),
)
}
}
if perr != nil || nerr != nil || serr != nil {
return fmt.Errorf("Failed to unenforce %s %s", perr,... | |
c7363 | }
}
if e.transport != nil {
if err := e.transport.UpdateSecrets(secrets); err != nil {
return err
}
}
if e.secrets != nil {
if err := e.secrets.UpdateSecrets(secrets); err != nil {
return err
}
}
return nil
} | |
c7364 |
return e.transport.EnableDatapathPacketTracing(contextID, direction, interval)
} | |
c7365 | serverID,
validity,
service,
secrets,
mode,
procMountPoint,
externalIPCacheTimeout,
packetLogs,
tokenAccessor,
puFromContextID,
cfg,
)
tcpProxy, err := applicationproxy.NewAppProxy(tokenAccessor, collector, puFromContextID, nil, secrets)
if err != nil {
return nil, err
}
return &enforcer{... | |
c7366 | data := binary.LittleEndian.Uint32(h)
return data & mask
} | |
c7367 | return compressionTypeV2Mask
default:
return compressionTypeNoneMask
}
} | |
c7368 | return CompressionTypeV2
default:
return CompressionTypeNone
}
} | |
c7369 |
case CompressionTypeV2.toString():
return CompressionTypeV2
default:
return CompressionTypeNone
}
} | |
c7370 | handler,
metadataExtractor: metadataExtractor,
netclsProgrammer: netclsProgrammer,
nodeName: nodeName,
enableHostPods: enableHostPods,
// TODO: might move into configuration
handlePUEventTimeout: 5 * time.Second,
metadataExtractTimeout: 3 * time.Second,
netclsProgramTimeout: 2 * tim... | |
c7371 |
&source.Kind{Type: &corev1.Pod{}},
&handler.EnqueueRequestsFromMapFunc{ToRequests: mapper},
); err != nil {
return err
}
// we pass in a custom channel for events generated by resync
if err := c.Watch(
&source.Channel{Source: eventsCh},
&handler.EnqueueRequestsFromMapFunc{ToRequests: mapper},
); err !=... | |
c7372 | *Processor {
return &Processor{
aporetoJWT: servicetokens.NewVerifier(s, trustedCertificate),
}
} | |
c7373 | *x509.Certificate) {
p.aporetoJWT.UpdateSecrets(s, trustedCertificate)
} | |
c7374 |
p.apis = apis
p.userTokenMappings = mappings
p.userTokenHandler = handler
p.userAuthorizationType = serviceType
} | |
c7375 |
defer p.Unlock()
p.apis = apis
return nil
} | |
c7376 | return attributes, false, userToken, fmt.Errorf("Unable to decode JWT: %s", err)
}
attributes = append(attributes, jwtAttributes...)
}
return attributes, false, userToken, nil
case policy.UserAuthorizationOIDC:
// Now we can parse the user claims.
if p.userTokenHandler == nil {
zap.L().Error("Int... | |
c7377 | := p.aporetoJWT.ParseToken(aporetoToken, publicKey)
if err != nil {
return "", []string{}, fmt.Errorf("Invalid Aporeto Token: %s", err)
}
return id, append(profile, scopes...), nil
} | |
c7378 | transmit the information in the return payload for applications
// that choose to use it directly without a cookie.
data, err := json.MarshalIndent(cookie, " ", " ")
if err != nil {
http.Error(w, "Bad data", http.StatusInternalServerError)
return
}
// We redirect here to the original URL that the application... | |
c7379 | return p.apis.FindAndMatchScope(method, uri, claims)
} | |
c7380 |
p.RLock()
defer p.RUnlock()
return p.userTokenHandler.IssueRedirect(originURL)
} | |
c7381 | parts := strings.SplitN(claim, "=", 2)
if header, ok := p.userTokenMappings[parts[0]]; ok && len(parts) == 2 {
r.Header.Add(header, parts[1])
}
}
} | |
c7382 |
DefaultMarkValue,
DefaultQueueStart,
DefaultNumberOfQueues,
DefaultNumberOfQueues,
DefaultQueueSize,
DefaultQueueSize,
)
} | |
c7383 | sync <- struct{}{}
return
}
<-time.After(100 * time.Millisecond)
}
} | |
c7384 |
scanner := bufio.NewScanner(bytes.NewReader(data))
for scanner.Scan() {
line := scanner.Text()
lineParts := strings.Fields(line)
newNFQ := makeNFQLayout(lineParts)
n.contents[newNFQ.QueueNum] = newNFQ
}
return nil
} | |
c7385 |
defer n.Unlock()
content, ok := n.contents[queueNum]
if ok {
return &content
}
return nil
} | |
c7386 |
defer n.Unlock()
return n.contents
} | |
c7387 |
defer n.Unlock()
return n.nfqStr
} | |
c7388 | mock.recorder = &MockProcessorMockRecorder{mock}
return mock
} | |
c7389 | error {
ret := m.ctrl.Call(m, "Start", ctx, eventInfo)
ret0, _ := ret[0].(error)
return ret0
} | |
c7390 |
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockProcessor)(nil).Start), ctx, eventInfo)
} | |
c7391 | := range tags {
t.Tags[i] = k + "=" + v
i++
}
return t
} | |
c7392 | len(t.Tags))
copy(c, t.Tags)
return &TagStore{c}
} | |
c7393 | if key == parts[0] {
return parts[1], true
}
}
return "", false
} | |
c7394 | if _, ok := t.Get(parts[0]); !ok {
t.AppendKeyValue(parts[0], parts[1])
merged++
}
}
return merged
} | |
c7395 | t.Tags = append(t.Tags, key+"="+value)
} | |
c7396 | ok := data.(*connectionState)
if ok && state.cookie == nil {
return res, nil
}
if v := state.cookie.String(); v != "" {
res.Header.Add("Set-Cookie", v)
}
return res, nil
} | |
c7397 | error {
return u.proc.Resync(ctx, nil)
} | |
c7398 |
mock.recorder = &MockDebugClientMockRecorder{mock}
return mock
} | |
c7399 | {
ret := m.ctrl.Call(m, "Run", ctx)
ret0, _ := ret[0].(error)
return ret0
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.