_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q30400 | Revoke | train | func Revoke(host string) error {
client, err := newACMEClient(new(Config), true)
if err != nil {
return err
}
return client.Revoke(host)
} | go | {
"resource": ""
} |
q30401 | Present | train | func (s tlsSniSolver) Present(domain, token, keyAuth string) error {
cert, acmeDomain, err := acme.TLSSNI01ChallengeCert(keyAuth)
if err != nil {
return err
}
cacheCertificate(Certificate{
Certificate: cert,
Names: []string{acmeDomain},
})
return nil
} | go | {
"resource": ""
} |
q30402 | CleanUp | train | func (s tlsSniSolver) CleanUp(domain, token, keyAuth string) error {
_, acmeDomain, err := acme.TLSSNI01ChallengeCert(keyAuth)
if err != nil {
return err
}
uncacheCertificate(acmeDomain)
return nil
} | go | {
"resource": ""
} |
q30403 | RegisterStorageProvider | train | func RegisterStorageProvider(name string, provider StorageConstructor) {
storageProviders[name] = provider
caddy.RegisterPlugin("tls.storage."+name, caddy.Plugin{})
} | go | {
"resource": ""
} |
q30404 | HTTPChallengeHandler | train | func HTTPChallengeHandler(w http.ResponseWriter, r *http.Request, listenHost, altPort string) bool {
if !strings.HasPrefix(r.URL.Path, challengeBasePath) {
return false
}
if !namesObtaining.Has(r.Host) {
return false
}
scheme := "http"
if r.TLS != nil {
scheme = "https"
}
if listenHost == "" {
listenH... | go | {
"resource": ""
} |
q30405 | FilterProfile | train | func (c *Client) FilterProfile(data interface{}) (interface{}, error) {
socket, err := net.Dial("unix", c.SocketPath)
if err != nil {
return nil, err
}
defer socket.Close()
return c.SendRequest("filter_profile", data, socket)
} | go | {
"resource": ""
} |
q30406 | AccessFilter | train | func (c *Client) AccessFilter(filter string, scope string, data interface{}) (interface{}, error) {
socket, err := net.Dial("unix", c.SocketPath)
if err != nil {
return nil, err
}
defer socket.Close()
return c.SendRequest(filter, []interface{}{scope, data}, socket)
} | go | {
"resource": ""
} |
q30407 | FilterVlan | train | func (c *Client) FilterVlan(scope string, data interface{}) (interface{}, error) {
return c.AccessFilter("filter_vlan", scope, data)
} | go | {
"resource": ""
} |
q30408 | FilterDhcp | train | func (c *Client) FilterDhcp(scope string, data interface{}) (interface{}, error) {
return c.AccessFilter("filter_dhcp", scope, data)
} | go | {
"resource": ""
} |
q30409 | FilterDns | train | func (c *Client) FilterDns(scope string, data interface{}) (interface{}, error) {
return c.AccessFilter("filter_dns", scope, data)
} | go | {
"resource": ""
} |
q30410 | FilterRadius | train | func (c *Client) FilterRadius(scope string, data interface{}) (interface{}, error) {
return c.AccessFilter("filter_radius", scope, data)
} | go | {
"resource": ""
} |
q30411 | SendRequest | train | func (c *Client) SendRequest(method string, params interface{}, conn net.Conn) (interface{}, error) {
request := Request{Method: method, Params: params}
b, err := json.Marshal(request)
if err != nil {
return nil, err
}
b = append(b, '\n')
_, err = conn.Write(b)
if err != nil {
return nil, err
}
reader := b... | go | {
"resource": ""
} |
q30412 | Start | train | func (fw *Checkpoint) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
p := fw.startRadiusPacket(ctx, info, timeout)
client := fw.getRadiusClient(ctx)
// Use the background context since we don't want the lib to use our context
ctx2, cancel := fw.RadiusContextWithTimeout()
defer canc... | go | {
"resource": ""
} |
q30413 | startRadiusPacket | train | func (fw *Checkpoint) startRadiusPacket(ctx context.Context, info map[string]string, timeout int) *radius.Packet {
r := radius.New(radius.CodeAccountingRequest, []byte(fw.Password))
rfc2866.AcctStatusType_Add(r, rfc2866.AcctStatusType_Value_Start)
rfc2866.AcctSessionID_AddString(r, "acct_pf-"+info["mac"])
rfc2865.U... | go | {
"resource": ""
} |
q30414 | Stop | train | func (fw *Checkpoint) Stop(ctx context.Context, info map[string]string) (bool, error) {
log.LoggerWContext(ctx).Warn("SSO Stop is not available for this firewall")
return false, nil
} | go | {
"resource": ""
} |
q30415 | setVersion | train | func setVersion() {
// A development build is one that's not at a tag or has uncommitted changes
devBuild = gitTag == "" || gitShortStat != ""
// Only set the appVersion if -ldflags was used
if gitNearestTag != "" || gitTag != "" {
if devBuild && gitNearestTag != "" {
appVersion = fmt.Sprintf("%s (+%s %s)",
... | go | {
"resource": ""
} |
q30416 | OnStartupMetrics | train | func OnStartupMetrics() error {
metricsOnce.Do(func() {
prometheus.MustRegister(RequestCount)
prometheus.MustRegister(RequestDuration)
})
return nil
} | go | {
"resource": ""
} |
q30417 | stapleOCSP | train | func stapleOCSP(cert *Certificate, pemBundle []byte) error {
if pemBundle == nil {
// The function in the acme package that gets OCSP requires a PEM-encoded cert
bundle := new(bytes.Buffer)
for _, derBytes := range cert.Certificate.Certificate {
pem.Encode(bundle, &pem.Block{Type: "CERTIFICATE", Bytes: derByt... | go | {
"resource": ""
} |
q30418 | makeSelfSignedCert | train | func makeSelfSignedCert(config *Config) error {
// start by generating private key
var privKey interface{}
var err error
switch config.KeyType {
case "", acme.EC256:
privKey, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
case acme.EC384:
privKey, err = ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
... | go | {
"resource": ""
} |
q30419 | fastHash | train | func fastHash(input []byte) string {
h := fnv.New32a()
h.Write([]byte(input))
return fmt.Sprintf("%x", h.Sum32())
} | go | {
"resource": ""
} |
q30420 | ErrorMessage | train | func (r *Request) ErrorMessage(rcode int) *dns.Msg {
m := new(dns.Msg)
m.SetRcode(r.Req, rcode)
return m
} | go | {
"resource": ""
} |
q30421 | NewFactory | train | func NewFactory(ctx context.Context) Factory {
f := Factory{}
f.typeRegistry = make(map[string]reflect.Type)
f.typeRegistry["BarracudaNG"] = reflect.TypeOf(&BarracudaNG{}).Elem()
f.typeRegistry["Iboss"] = reflect.TypeOf(&Iboss{}).Elem()
f.typeRegistry["PaloAlto"] = reflect.TypeOf(&PaloAlto{}).Elem()
f.typeRegistr... | go | {
"resource": ""
} |
q30422 | Instantiate | train | func (f *Factory) Instantiate(ctx context.Context, id string) (FirewallSSOInt, error) {
firewall := FirewallSSO{}
firewall.PfconfigHashNS = id
_, err := pfconfigdriver.FetchDecodeSocketCache(ctx, &firewall)
if err != nil {
return nil, err
}
if oType, ok := f.typeRegistry[firewall.Type]; ok {
or := reflect.New... | go | {
"resource": ""
} |
q30423 | Renew | train | func (c *ACMEClient) Renew(name string) error {
// Get access to ACME storage
storage, err := c.config.StorageFor(c.config.CAUrl)
if err != nil {
return err
}
waiter, err := storage.TryLock(name)
if err != nil {
return err
}
if waiter != nil {
log.Printf("[INFO] Certificate for %s is already being renewe... | go | {
"resource": ""
} |
q30424 | Revoke | train | func (c *ACMEClient) Revoke(name string) error {
storage, err := c.config.StorageFor(c.config.CAUrl)
if err != nil {
return err
}
siteExists, err := storage.SiteExists(name)
if err != nil {
return err
}
if !siteExists {
return errors.New("no certificate and key for " + name)
}
siteData, err := storage... | go | {
"resource": ""
} |
q30425 | Add | train | func (c *nameCoordinator) Add(names []string) {
c.mu.Lock()
for _, name := range names {
c.names[strings.ToLower(name)] = struct{}{}
}
c.mu.Unlock()
} | go | {
"resource": ""
} |
q30426 | Remove | train | func (c *nameCoordinator) Remove(names []string) {
c.mu.Lock()
for _, name := range names {
delete(c.names, strings.ToLower(name))
}
c.mu.Unlock()
} | go | {
"resource": ""
} |
q30427 | Has | train | func (c *nameCoordinator) Has(name string) bool {
hostname, _, err := net.SplitHostPort(name)
if err != nil {
hostname = name
}
c.mu.RLock()
_, ok := c.names[strings.ToLower(hostname)]
c.mu.RUnlock()
return ok
} | go | {
"resource": ""
} |
q30428 | OnShutdown | train | func (m *Metrics) OnShutdown() error {
if m.ln != nil {
return m.ln.Close()
}
return nil
} | go | {
"resource": ""
} |
q30429 | Inc | train | func Inc(ip net.IP) {
for j := len(ip) - 1; j >= 0; j-- {
ip[j]++
if ip[j] > 0 {
break
}
}
} | go | {
"resource": ""
} |
q30430 | Dec | train | func Dec(ip net.IP) {
for j := len(ip) - 1; j >= 0; j-- {
ip[j]--
if ip[j] == 255 {
continue
}
if ip[j] > 0 {
break
}
}
} | go | {
"resource": ""
} |
q30431 | ConvertToString | train | func ConvertToString(b []byte) string {
s := make([]string, len(b))
for i := range b {
s[i] = strconv.Itoa(int(b[i]))
}
return strings.Join(s, ",")
} | go | {
"resource": ""
} |
q30432 | ConvertToByte | train | func ConvertToByte(b string) []byte {
s := strings.Split(b, ",")
var result []byte
for i := range s {
value, _ := strconv.Atoi(s[i])
result = append(result, byte(value))
}
return result
} | go | {
"resource": ""
} |
q30433 | ByteToString | train | func ByteToString(a []byte) string {
const hexDigit = "0123456789abcdef"
if len(a) == 0 {
return ""
}
buf := make([]byte, 0, len(a)*3-1)
for i, b := range a {
if i > 0 {
buf = append(buf, ':')
}
buf = append(buf, hexDigit[b>>4])
buf = append(buf, hexDigit[b&0xF])
}
return string(buf)
} | go | {
"resource": ""
} |
q30434 | RenewCert | train | func (c *Config) RenewCert(name string, allowPrompts bool) error {
client, err := newACMEClient(c, allowPrompts)
if err != nil {
return err
}
return client.Renew(name)
} | go | {
"resource": ""
} |
q30435 | StorageFor | train | func (c *Config) StorageFor(caURL string) (Storage, error) {
// Validate CA URL
if caURL == "" {
caURL = DefaultCAUrl
}
if caURL == "" {
return nil, fmt.Errorf("cannot create storage without CA URL")
}
caURL = strings.ToLower(caURL)
// scheme required or host will be parsed as path (as of Go 1.6)
if !strin... | go | {
"resource": ""
} |
q30436 | Remove | train | func (z *Zones) Remove(name string) {
z.Lock()
if zo, ok := z.Z[name]; ok && !zo.NoReload {
zo.ReloadShutdown <- true
}
delete(z.Z, name)
// TODO(miek): just regenerate Names (might be bad if you have a lot of zones...)
z.names = []string{}
for n := range z.Z {
z.names = append(z.names, n)
}
z.Unlock()... | go | {
"resource": ""
} |
q30437 | init | train | func (fw *FirewallSSO) init(ctx context.Context) error {
for _, net := range fw.Networks {
err := net.init(ctx)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q30438 | init | train | func (fwn *FirewallSSONetwork) init(ctx context.Context) error {
var err error
fwn.Ip, fwn.IpNet, err = net.ParseCIDR(fwn.Cidr)
return err
} | go | {
"resource": ""
} |
q30439 | GetCacheTimeout | train | func (fw *FirewallSSO) GetCacheTimeout(ctx context.Context) int {
timeout, err := strconv.ParseInt(fw.CacheTimeout, 10, 32)
if err != nil {
log.LoggerWContext(ctx).Debug(fmt.Sprintf("Can't parse timeout '%s' into an int (%s).", fw.CacheTimeout, err))
return 0
} else {
return int(timeout)
}
} | go | {
"resource": ""
} |
q30440 | Start | train | func (fw *FirewallSSO) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
log.LoggerWContext(ctx).Debug("Sending SSO start")
return true, nil
} | go | {
"resource": ""
} |
q30441 | Stop | train | func (fw *FirewallSSO) Stop(ctx context.Context, info map[string]string) (bool, error) {
log.LoggerWContext(ctx).Debug("Sending SSO stop")
return true, nil
} | go | {
"resource": ""
} |
q30442 | getSourceIp | train | func (fw *FirewallSSO) getSourceIp(ctx context.Context) net.IP {
managementNetwork := pfconfigdriver.Config.Interfaces.ManagementNetwork
if managementNetwork.Vip != "" {
return net.ParseIP(managementNetwork.Vip)
} else {
return net.ParseIP(managementNetwork.Ip)
}
} | go | {
"resource": ""
} |
q30443 | getHttpClient | train | func (fw *FirewallSSO) getHttpClient(ctx context.Context) *http.Client {
// We don't check the TLS certificate if applicable
transport := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
return &http.Client{Transport: transport}
} | go | {
"resource": ""
} |
q30444 | getRadiusClient | train | func (fw *FirewallSSO) getRadiusClient(ctx context.Context) *radius.Client {
return &radius.Client{}
} | go | {
"resource": ""
} |
q30445 | logger | train | func (fw *FirewallSSO) logger(ctx context.Context) log15.Logger {
ctx = log.AddToLogContext(ctx, "firewall-id", fw.PfconfigHashNS)
return log.LoggerWContext(ctx)
} | go | {
"resource": ""
} |
q30446 | ExecuteStart | train | func ExecuteStart(ctx context.Context, fw FirewallSSOInt, info map[string]string, timeout int) (bool, error) {
ctx = log.AddToLogContext(ctx, "firewall-id", fw.GetFirewallSSO(ctx).PfconfigHashNS)
if !fw.CheckStatus(ctx, info) {
return false, nil
}
log.LoggerWContext(ctx).Info("Processing SSO Start")
if !fw.Matc... | go | {
"resource": ""
} |
q30447 | ExecuteStop | train | func ExecuteStop(ctx context.Context, fw FirewallSSOInt, info map[string]string) (bool, error) {
ctx = log.AddToLogContext(ctx, "firewall-id", fw.GetFirewallSSO(ctx).PfconfigHashNS)
log.LoggerWContext(ctx).Info("Processing SSO Stop")
if !fw.MatchesNetwork(ctx, info) {
log.LoggerWContext(ctx).Debug(fmt.Sprintf("No... | go | {
"resource": ""
} |
q30448 | New | train | func New(size int) *Cache {
ssize := size / shardSize
if ssize < 512 {
ssize = 512
}
c := &Cache{}
// Initialize all the shards
for i := 0; i < shardSize; i++ {
c.shards[i] = newShard(ssize)
}
return c
} | go | {
"resource": ""
} |
q30449 | Get | train | func (c *Cache) Get(key uint32) (interface{}, bool) {
shard := key & (shardSize - 1)
return c.shards[shard].Get(key)
} | go | {
"resource": ""
} |
q30450 | Add | train | func (s *shard) Add(key uint32, el interface{}) {
l := s.Len()
if l+1 > s.size {
s.Evict()
}
s.Lock()
s.items[key] = el
s.Unlock()
} | go | {
"resource": ""
} |
q30451 | Remove | train | func (s *shard) Remove(key uint32) {
s.Lock()
delete(s.items, key)
s.Unlock()
} | go | {
"resource": ""
} |
q30452 | Get | train | func (s *shard) Get(key uint32) (interface{}, bool) {
s.RLock()
el, found := s.items[key]
s.RUnlock()
return el, found
} | go | {
"resource": ""
} |
q30453 | ServePacket | train | func (s *Server) ServePacket(pc net.PacketConn) error {
if QUIC {
err := s.quicServer.Serve(pc.(*net.UDPConn))
return fmt.Errorf("serving QUIC connections: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q30454 | Start | train | func (fw *JuniperSRX) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
log.LoggerWContext(ctx).Info("Sending SSO to JuniperSRX using HTTP")
return fw.startHttp(ctx, info, timeout)
} | go | {
"resource": ""
} |
q30455 | startHttp | train | func (fw *JuniperSRX) startHttp(ctx context.Context, info map[string]string, timeout int) (bool, error) {
req, err := http.NewRequest("POST", "https://"+fw.PfconfigHashNS+":"+fw.Port+"/api/userfw/v1/post-entry", bytes.NewBuffer([]byte(fw.startHttpPayload(ctx, info))))
req.SetBasicAuth(fw.Username, fw.Password)
clie... | go | {
"resource": ""
} |
q30456 | Stop | train | func (fw *JuniperSRX) Stop(ctx context.Context, info map[string]string) (bool, error) {
log.LoggerWContext(ctx).Info("Sending SSO to JuniperSRX using HTTP")
return fw.stopHttp(ctx, info)
} | go | {
"resource": ""
} |
q30457 | getSshSession | train | func (fw *BarracudaNG) getSshSession(ctx context.Context) (*ssh.Session, error) {
sshConfig := &ssh.ClientConfig{
User: fw.Username,
Auth: []ssh.AuthMethod{
ssh.Password(fw.Password),
},
}
connection, err := ssh.Dial("tcp", fw.PfconfigHashNS+":"+fw.Port, sshConfig)
if err != nil {
return nil, err
}
s... | go | {
"resource": ""
} |
q30458 | Start | train | func (fw *BarracudaNG) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
session, err := fw.getSshSession(ctx)
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Cannot connect to BarracudaNG: %s", err))
return false, err
}
cmd := "phibstest 127.0.0.1 l peer=" + info["ip"... | go | {
"resource": ""
} |
q30459 | detectVIP | train | func detectVIP(management pfconfigdriver.ManagementNetwork) {
if pfconfigdriver.GetClusterSummary(ctx).ClusterEnabled == 1 {
var keyConfCluster pfconfigdriver.NetInterface
keyConfCluster.PfconfigNS = "config::Pf(CLUSTER," + pfconfigdriver.FindClusterName(ctx) + ")"
keyConfCluster.PfconfigHashNS = "interface " +... | go | {
"resource": ""
} |
q30460 | NewStaticUpstreams | train | func NewStaticUpstreams(c *caddyfile.Dispenser) ([]Upstream, error) {
var upstreams []Upstream
for c.Next() {
upstream := &staticUpstream{
from: ".",
HealthCheck: healthcheck.HealthCheck{
FailTimeout: 5 * time.Second,
MaxFails: 3,
},
ex: newDNSEx(),
}
if !c.Args(&upstream.netsource) {
... | go | {
"resource": ""
} |
q30461 | Fuzz | train | func Fuzz(data []byte) int {
c := caddy.NewTestController("dns", "proxy . 8.8.8.8:53")
up, err := NewStaticUpstreams(&c.Dispenser)
if err != nil {
return 0
}
p := &Proxy{Upstreams: &up}
return fuzz.Do(p, data)
} | go | {
"resource": ""
} |
q30462 | ensureRequestComplete | train | func (c *Client) ensureRequestComplete(ctx context.Context, resp *http.Response) {
if resp == nil {
return
}
defer resp.Body.Close()
io.Copy(ioutil.Discard, resp.Body)
} | go | {
"resource": ""
} |
q30463 | toMsg | train | func toMsg(g *googleMsg) (*dns.Msg, error) {
m := new(dns.Msg)
m.Response = true
m.Rcode = g.Status
m.Truncated = g.TC
m.RecursionDesired = g.RD
m.RecursionAvailable = g.RA
m.AuthenticatedData = g.AD
m.CheckingDisabled = g.CD
m.Question = make([]dns.Question, 1)
m.Answer = make([]dns.RR, len(g.Answer))
m.Ns... | go | {
"resource": ""
} |
q30464 | toRR | train | func toRR(g googleRR) (dns.RR, error) {
typ, ok := dns.TypeToString[g.Type]
if !ok {
return nil, fmt.Errorf("failed to convert type %q", g.Type)
}
str := fmt.Sprintf("%s %d %s %s", g.Name, g.TTL, typ, g.Data)
rr, err := dns.NewRR(str)
if err != nil {
return nil, fmt.Errorf("failed to parse %q: %s", str, err)... | go | {
"resource": ""
} |
q30465 | WriteMsg | train | func (w *ResponseWriter) WriteMsg(resp *dns.Msg) (writeErr error) {
writeErr = w.ResponseWriter.WriteMsg(resp)
writeEpoch := uint64(time.Now().Unix())
b := w.TapBuilder()
b.TimeSec = w.queryEpoch
if w.Send == nil || w.Send.Cq {
if err := func() (err error) {
err = b.AddrMsg(w.ResponseWriter.RemoteAddr(), w.... | go | {
"resource": ""
} |
q30466 | Start | train | func (fw *Iboss) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
req, err := fw.getRequest(ctx, "login", info)
if err != nil {
return false, err
}
resp, err := fw.getHttpClient(ctx).Do(req)
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Error contacting Iboss: %s"... | go | {
"resource": ""
} |
q30467 | getRequest | train | func (fw *Iboss) getRequest(ctx context.Context, action string, info map[string]string) (*http.Request, error) {
req, err := http.NewRequest(
"GET",
fmt.Sprintf(
"http://%s:%s/nacAgent?action=%s&user=%s&dc=%s&key=%s&ip=%s&cn=%s&g=%s",
fw.PfconfigHashNS,
fw.Port,
action,
info["username"],
fw.NacNa... | go | {
"resource": ""
} |
q30468 | RenewManagedCertificates | train | func RenewManagedCertificates(allowPrompts bool) (err error) {
var renewQueue, deleteQueue []Certificate
visitedNames := make(map[string]struct{})
certCacheMu.RLock()
for name, cert := range certCache {
if !cert.Config.Managed || cert.Config.SelfSigned {
continue
}
// the list of names on this cert shoul... | go | {
"resource": ""
} |
q30469 | freshOCSP | train | func freshOCSP(resp *ocsp.Response) bool {
// start checking OCSP staple about halfway through validity period for good measure
refreshTime := resp.ThisUpdate.Add(resp.NextUpdate.Sub(resp.ThisUpdate) / 2)
return time.Now().Before(refreshTime)
} | go | {
"resource": ""
} |
q30470 | initIPSet | train | func (IPSET *pfIPSET) initIPSet(ctx context.Context, db *sql.DB) {
logger := log.LoggerWContext(ctx)
IPSET.ListALL, _ = ipset.ListAll()
rows, err := db.Query("select distinct n.mac, i.ip, n.category_id as node_id from node as n left join locationlog as l on n.mac=l.mac left join ip4log as i on n.mac=i.mac where l.c... | go | {
"resource": ""
} |
q30471 | detectType | train | func (IPSET *pfIPSET) detectType(ctx context.Context) error {
IPSET.ListALL, _ = ipset.ListAll()
var NetIndex net.IPNet
IPSET.Network = make(map[*net.IPNet]string)
var interfaces pfconfigdriver.ListenInts
pfconfigdriver.FetchDecodeSocket(ctx, &interfaces)
var keyConfNet pfconfigdriver.PfconfigKeys
keyConfNet.P... | go | {
"resource": ""
} |
q30472 | cacheUnmanagedCertificatePEMFile | train | func cacheUnmanagedCertificatePEMFile(certFile, keyFile string) error {
cert, err := makeCertificateFromDisk(certFile, keyFile)
if err != nil {
return err
}
cacheCertificate(cert)
return nil
} | go | {
"resource": ""
} |
q30473 | cacheUnmanagedCertificatePEMBytes | train | func cacheUnmanagedCertificatePEMBytes(certBytes, keyBytes []byte) error {
cert, err := makeCertificate(certBytes, keyBytes)
if err != nil {
return err
}
cacheCertificate(cert)
return nil
} | go | {
"resource": ""
} |
q30474 | makeCertificate | train | func makeCertificate(certPEMBlock, keyPEMBlock []byte) (Certificate, error) {
var cert Certificate
// Convert to a tls.Certificate
tlsCert, err := tls.X509KeyPair(certPEMBlock, keyPEMBlock)
if err != nil {
return cert, err
}
if len(tlsCert.Certificate) == 0 {
return cert, errors.New("certificate is empty")
... | go | {
"resource": ""
} |
q30475 | fillCertFromLeaf | train | func fillCertFromLeaf(cert *Certificate, leaf *x509.Certificate) error {
if leaf.Subject.CommonName != "" {
cert.Names = []string{strings.ToLower(leaf.Subject.CommonName)}
}
for _, name := range leaf.DNSNames {
if name != leaf.Subject.CommonName {
cert.Names = append(cert.Names, strings.ToLower(name))
}
}
... | go | {
"resource": ""
} |
q30476 | cacheCertificate | train | func cacheCertificate(cert Certificate) {
if cert.Config == nil {
cert.Config = new(Config)
}
certCacheMu.Lock()
if _, ok := certCache[""]; !ok {
// use as default - must be *appended* to end of list, or bad things happen!
cert.Names = append(cert.Names, "")
certCache[""] = cert
}
for len(certCache)+len(c... | go | {
"resource": ""
} |
q30477 | uncacheCertificate | train | func uncacheCertificate(name string) {
certCacheMu.Lock()
delete(certCache, name)
certCacheMu.Unlock()
} | go | {
"resource": ""
} |
q30478 | setup | train | func setup(c *caddy.Controller) error {
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
return PoolHandler{Next: next, refreshLauncher: &sync.Once{}}
})
return nil
} | go | {
"resource": ""
} |
q30479 | ServeHTTP | train | func (h PoolHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
id, err := pfconfigdriver.PfconfigPool.ReadLock(r.Context())
if err == nil {
defer pfconfigdriver.PfconfigPool.ReadUnlock(r.Context(), id)
// We launch the refresh job once, the first time a request comes in
// This ensures t... | go | {
"resource": ""
} |
q30480 | Down | train | func (uh *UpstreamHost) Down() bool {
if uh.CheckDown == nil {
fails := atomic.LoadInt32(&uh.Fails)
return fails > 0
}
return uh.CheckDown(uh)
} | go | {
"resource": ""
} |
q30481 | Start | train | func (u *HealthCheck) Start() {
for i, h := range u.Hosts {
u.Hosts[i].CheckURL = u.normalizeCheckURL(h.Name)
}
u.stop = make(chan struct{})
if u.Path != "" {
u.wg.Add(1)
go func() {
defer u.wg.Done()
u.healthCheckWorker(u.stop)
}()
}
} | go | {
"resource": ""
} |
q30482 | HealthCheckURL | train | func (uh *UpstreamHost) HealthCheckURL() {
// Lock for our bool check. We don't just defer the unlock because
// we don't want the lock held while http.Get runs.
uh.Lock()
// We call HealthCheckURL from proxy.go and lookup.go, bail out when nothing
// is configured to healthcheck. Or we mid check? Don't run ano... | go | {
"resource": ""
} |
q30483 | Select | train | func (u *HealthCheck) Select() *UpstreamHost {
pool := u.Hosts
if len(pool) == 1 {
if pool[0].Down() && u.Spray == nil {
return nil
}
return pool[0]
}
allDown := true
for _, host := range pool {
if !host.Down() {
allDown = false
break
}
}
if allDown {
if u.Spray == nil {
return nil
}
... | go | {
"resource": ""
} |
q30484 | normalizeCheckURL | train | func (u *HealthCheck) normalizeCheckURL(name string) string {
// The DNS server might be an HTTP server. If so, extract its name.
hostName := name
ret, err := url.Parse(name)
if err == nil && len(ret.Host) > 0 {
hostName = ret.Host
}
// Extract the port number from the parsed server name.
checkHostName, chec... | go | {
"resource": ""
} |
q30485 | buildJobStatusHandler | train | func buildJobStatusHandler(ctx context.Context) (JobStatusHandler, error) {
jobStatus := JobStatusHandler{}
pfconfigdriver.PfconfigPool.AddStruct(ctx, &redisclient.Config)
var network string
if redisclient.Config.RedisArgs.Server[0] == '/' {
network = "unix"
} else {
network = "tcp"
}
jobStatus.redis = re... | go | {
"resource": ""
} |
q30486 | Http | train | func Http(ctx context.Context, w http.ResponseWriter) {
if r := recover(); r != nil {
outputPanic(ctx, r)
http.Error(w, httpErrorMsg, http.StatusInternalServerError)
}
} | go | {
"resource": ""
} |
q30487 | Standard | train | func Standard(ctx context.Context) {
if r := recover(); r != nil {
outputPanic(ctx, r)
}
} | go | {
"resource": ""
} |
q30488 | outputPanic | train | func outputPanic(ctx context.Context, recovered interface{}) {
msg := fmt.Sprintf("Recovered panic: %s.", recovered)
log.LoggerWContext(ctx).Error(msg)
fmt.Fprintln(os.Stderr, msg)
debug.PrintStack()
} | go | {
"resource": ""
} |
q30489 | hasStubEdns0 | train | func hasStubEdns0(m *dns.Msg) bool {
option := m.IsEdns0()
if option == nil {
return false
}
for _, o := range option.Option {
if o.Option() == ednsStubCode && len(o.(*dns.EDNS0_LOCAL).Data) == 1 &&
o.(*dns.EDNS0_LOCAL).Data[0] == 1 {
return true
}
}
return false
} | go | {
"resource": ""
} |
q30490 | addStubEdns0 | train | func addStubEdns0(m *dns.Msg) *dns.Msg {
option := m.IsEdns0()
// Add a custom EDNS0 option to the packet, so we can detect loops when 2 stubs are forwarding to each other.
if option != nil {
option.Option = append(option.Option, &dns.EDNS0_LOCAL{Code: ednsStubCode, Data: []byte{1}})
return m
}
m.Extra = appe... | go | {
"resource": ""
} |
q30491 | Wrap | train | func Wrap(m *lib.Message) lib.Dnstap {
t := lib.Dnstap_MESSAGE
return lib.Dnstap{
Type: &t,
Message: m,
}
} | go | {
"resource": ""
} |
q30492 | Marshal | train | func Marshal(m *lib.Message) (data []byte, err error) {
payload := Wrap(m)
data, err = proto.Marshal(&payload)
if err != nil {
err = fmt.Errorf("proto: %s", err)
return
}
return
} | go | {
"resource": ""
} |
q30493 | Dedup | train | func Dedup(m *dns.Msg) *dns.Msg {
// TODO(miek): expensive!
m.Answer = dns.Dedup(m.Answer, nil)
m.Ns = dns.Dedup(m.Ns, nil)
m.Extra = dns.Dedup(m.Extra, nil)
return m
} | go | {
"resource": ""
} |
q30494 | init | train | func init() {
flag.StringVar(&Port, serverType+".port", DefaultPort, "Default port")
caddy.RegisterServerType(serverType, caddy.ServerType{
Directives: func() []string { return directives },
DefaultInput: func() caddy.Input {
return caddy.CaddyfileInput{
Filepath: "Corefile",
Contents: []b... | go | {
"resource": ""
} |
q30495 | initChild | train | func (fw *PaloAlto) initChild(ctx context.Context) error {
// Set a default value for vsys if there is none
if fw.Vsys == "" {
log.LoggerWContext(ctx).Debug("Setting default value for vsys as it isn't defined")
fw.Vsys = "1"
}
return nil
} | go | {
"resource": ""
} |
q30496 | Start | train | func (fw *PaloAlto) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
if fw.Transport == "syslog" {
log.LoggerWContext(ctx).Info("Sending SSO to PaloAlto using syslog")
return fw.startSyslog(ctx, info, timeout)
} else {
log.LoggerWContext(ctx).Info("Sending SSO to PaloAlto using HT... | go | {
"resource": ""
} |
q30497 | getSyslog | train | func (fw *PaloAlto) getSyslog(ctx context.Context) (*syslog.Writer, error) {
writer, err := syslog.Dial("udp", fw.PfconfigHashNS+":514", syslog.LOG_ERR|syslog.LOG_LOCAL5, "pfsso")
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Error connecting to PaloAlto: %s", err))
return nil, err
}
return write... | go | {
"resource": ""
} |
q30498 | sendSyslog | train | func (fw *PaloAlto) sendSyslog(ctx context.Context, line string) error {
writer, err := fw.getSyslog(ctx)
if err != nil {
return err
}
err = writer.Err(line)
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Error sending message to PaloAlto: %s", err))
return err
}
return nil
} | go | {
"resource": ""
} |
q30499 | startSyslog | train | func (fw *PaloAlto) startSyslog(ctx context.Context, info map[string]string, timeout int) (bool, error) {
if err := fw.sendSyslog(ctx, fmt.Sprintf("Group <packetfence> User <%s> Address <%s> assigned to session", info["username"], info["ip"])); err != nil {
return false, err
} else {
return true, nil
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.