Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "c", "gracefulConn", ")", "Close", "(", ")", "error", "{", "err", ":=", "c", ".", "Conn", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// close can fail on http2 connections (as of Oct. 2015, before http2 in std lib)", "// so don't decrement count unless close succeeds", "c", ".", "connWg", ".", "Done", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "c", "s", "underlying", "connection", "while", "updating", "the", "wg", "count", "." ]

[ "func", "(", "c", "*", "Controller", ")", "OnRestart", "(", "fn", "func", "(", ")", "error", ")", "{", "c", ".", "instance", ".", "onRestart", "=", "append", "(", "c", ".", "instance", ".", "onRestart", ",", "fn", ")", "\n", "}" ]

[ "OnRestart", "adds", "fn", "to", "the", "list", "of", "callback", "functions", "to", "execute", "when", "the", "server", "is", "about", "to", "be", "restarted", "." ]

[ "func", "(", "c", "*", "Controller", ")", "OnFinalShutdown", "(", "fn", "func", "(", ")", "error", ")", "{", "c", ".", "instance", ".", "onFinalShutdown", "=", "append", "(", "c", ".", "instance", ".", "onFinalShutdown", ",", "fn", ")", "\n", "}" ]

[ "OnFinalShutdown", "adds", "fn", "to", "the", "list", "of", "callback", "functions", "to", "execute", "when", "the", "server", "is", "about", "to", "be", "shut", "down", "NOT", "as", "part", "of", "a", "restart", "." ]

[ "func", "(", "h", "*", "Hostsfile", ")", "parse", "(", "r", "io", ".", "Reader", ",", "override", "*", "hostsMap", ")", "*", "hostsMap", "{", "hmap", ":=", "newHostsMap", "(", ")", "\n\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "r", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Bytes", "(", ")", "\n", "if", "i", ":=", "bytes", ".", "Index", "(", "line", ",", "[", "]", "byte", "{", "'#'", "}", ")", ";", "i", ">=", "0", "{", "// Discard comments.", "line", "=", "line", "[", "0", ":", "i", "]", "\n", "}", "\n", "f", ":=", "bytes", ".", "Fields", "(", "line", ")", "\n", "if", "len", "(", "f", ")", "<", "2", "{", "continue", "\n", "}", "\n", "addr", ":=", "parseLiteralIP", "(", "string", "(", "f", "[", "0", "]", ")", ")", "\n", "if", "addr", "==", "nil", "{", "continue", "\n", "}", "\n", "ver", ":=", "ipVersion", "(", "string", "(", "f", "[", "0", "]", ")", ")", "\n", "for", "i", ":=", "1", ";", "i", "<", "len", "(", "f", ")", ";", "i", "++", "{", "name", ":=", "absDomainName", "(", "string", "(", "f", "[", "i", "]", ")", ")", "\n", "if", "plugin", ".", "Zones", "(", "h", ".", "Origins", ")", ".", "Matches", "(", "name", ")", "==", "\"", "\"", "{", "// name is not in Origins", "continue", "\n", "}", "\n", "switch", "ver", "{", "case", "4", ":", "hmap", ".", "byNameV4", "[", "name", "]", "=", "append", "(", "hmap", ".", "byNameV4", "[", "name", "]", ",", "addr", ")", "\n", "case", "6", ":", "hmap", ".", "byNameV6", "[", "name", "]", "=", "append", "(", "hmap", ".", "byNameV6", "[", "name", "]", ",", "addr", ")", "\n", "default", ":", "continue", "\n", "}", "\n", "hmap", ".", "byAddr", "[", "addr", ".", "String", "(", ")", "]", "=", "append", "(", "hmap", ".", "byAddr", "[", "addr", ".", "String", "(", ")", "]", ",", "name", ")", "\n", "}", "\n", "}", "\n\n", "if", "override", "==", "nil", "{", "return", "hmap", "\n", "}", "\n\n", "for", "name", ":=", "range", "override", ".", "byNameV4", "{", "hmap", ".", "byNameV4", "[", "name", "]", "=", "append", "(", "hmap", ".", "byNameV4", "[", "name", "]", ",", "override", ".", "byNameV4", "[", "name", "]", "...", ")", "\n", "}", "\n", "for", "name", ":=", "range", "override", ".", "byNameV4", "{", "hmap", ".", "byNameV6", "[", "name", "]", "=", "append", "(", "hmap", ".", "byNameV6", "[", "name", "]", ",", "override", ".", "byNameV6", "[", "name", "]", "...", ")", "\n", "}", "\n", "for", "addr", ":=", "range", "override", ".", "byAddr", "{", "hmap", ".", "byAddr", "[", "addr", "]", "=", "append", "(", "hmap", ".", "byAddr", "[", "addr", "]", ",", "override", ".", "byAddr", "[", "addr", "]", "...", ")", "\n", "}", "\n\n", "return", "hmap", "\n", "}" ]

[ "Parse", "reads", "the", "hostsfile", "and", "populates", "the", "byName", "and", "byAddr", "maps", "." ]

[ "func", "(", "h", "*", "Hostsfile", ")", "LookupStaticAddr", "(", "addr", "string", ")", "[", "]", "string", "{", "h", ".", "RLock", "(", ")", "\n", "defer", "h", ".", "RUnlock", "(", ")", "\n", "addr", "=", "parseLiteralIP", "(", "addr", ")", ".", "String", "(", ")", "\n", "if", "addr", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "if", "len", "(", "h", ".", "hmap", ".", "byAddr", ")", "!=", "0", "{", "if", "hosts", ",", "ok", ":=", "h", ".", "hmap", ".", "byAddr", "[", "addr", "]", ";", "ok", "{", "hostsCp", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "hosts", ")", ")", "\n", "copy", "(", "hostsCp", ",", "hosts", ")", "\n", "return", "hostsCp", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LookupStaticAddr", "looks", "up", "the", "hosts", "for", "the", "given", "address", "from", "the", "hosts", "file", "." ]

[ "func", "key", "(", "m", "*", "dns", ".", "Msg", ",", "t", "response", ".", "Type", ",", "do", "bool", ")", "int", "{", "// We don't store truncated responses.", "if", "m", ".", "Truncated", "{", "return", "-", "1", "\n", "}", "\n", "// Nor errors or Meta or Update", "if", "t", "==", "response", ".", "OtherError", "||", "t", "==", "response", ".", "Meta", "||", "t", "==", "response", ".", "Update", "{", "return", "-", "1", "\n", "}", "\n\n", "return", "int", "(", "hash", "(", "m", ".", "Question", "[", "0", "]", ".", "Name", ",", "m", ".", "Question", "[", "0", "]", ".", "Qtype", ",", "do", ")", ")", "\n", "}" ]

[ "Return", "key", "under", "which", "we", "store", "the", "item", "-", "1", "will", "be", "returned", "if", "we", "don", "t", "store", "the", "message", ".", "Currently", "we", "do", "not", "cache", "Truncated", "errors", "zone", "transfers", "or", "dynamic", "update", "messages", "." ]

[ "func", "registerCallback", "(", "c", "*", "caddy", ".", "Controller", ",", "registerFunc", "func", "(", "func", "(", ")", "error", ")", ")", "error", "{", "var", "funcs", "[", "]", "func", "(", ")", "error", "\n\n", "for", "c", ".", "Next", "(", ")", "{", "args", ":=", "c", ".", "RemainingArgs", "(", ")", "\n", "if", "len", "(", "args", ")", "==", "0", "{", "return", "c", ".", "ArgErr", "(", ")", "\n", "}", "\n\n", "nonblock", ":=", "false", "\n", "if", "len", "(", "args", ")", ">", "1", "&&", "args", "[", "len", "(", "args", ")", "-", "1", "]", "==", "\"", "\"", "{", "// Run command in background; non-blocking", "nonblock", "=", "true", "\n", "args", "=", "args", "[", ":", "len", "(", "args", ")", "-", "1", "]", "\n", "}", "\n\n", "command", ",", "args", ",", "err", ":=", "caddy", ".", "SplitCommandAndArgs", "(", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "Err", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "fn", ":=", "func", "(", ")", "error", "{", "cmd", ":=", "exec", ".", "Command", "(", "command", ",", "args", "...", ")", "\n", "cmd", ".", "Stdin", "=", "os", ".", "Stdin", "\n", "cmd", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n", "if", "nonblock", "{", "log", ".", "Printf", "(", "\"", "\\\"", "\\\"", "\"", ",", "command", ",", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "return", "cmd", ".", "Start", "(", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\\\"", "\\\"", "\"", ",", "command", ",", "strings", ".", "Join", "(", "args", ",", "\"", "\"", ")", ")", "\n", "return", "cmd", ".", "Run", "(", ")", "\n", "}", "\n\n", "funcs", "=", "append", "(", "funcs", ",", "fn", ")", "\n", "}", "\n\n", "return", "c", ".", "OncePerServerBlock", "(", "func", "(", ")", "error", "{", "for", "_", ",", "fn", ":=", "range", "funcs", "{", "registerFunc", "(", "fn", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "registerCallback", "registers", "a", "callback", "function", "to", "execute", "by", "using", "c", "to", "parse", "the", "directive", ".", "It", "registers", "the", "callback", "to", "be", "executed", "using", "registerFunc", "." ]

[ "func", "(", "b", "*", "Builder", ")", "AddrMsg", "(", "a", "net", ".", "Addr", ",", "m", "*", "dns", ".", "Msg", ")", "(", "err", "error", ")", "{", "err", "=", "b", ".", "RemoteAddr", "(", "a", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "return", "b", ".", "Msg", "(", "m", ")", "\n", "}" ]

[ "AddrMsg", "parses", "the", "info", "of", "net", ".", "Addr", "and", "dns", ".", "Msg", "." ]

[ "func", "(", "b", "*", "Builder", ")", "Msg", "(", "m", "*", "dns", ".", "Msg", ")", "(", "err", "error", ")", "{", "if", "b", ".", "Full", "{", "err", "=", "b", ".", "Pack", "(", "m", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Msg", "parses", "the", "info", "of", "dns", ".", "Msg", "." ]

[ "func", "(", "d", "*", "Data", ")", "HostPort", "(", "addr", "string", ")", "error", "{", "ip", ",", "port", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "p", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "port", ",", "10", ",", "32", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "d", ".", "Port", "=", "uint32", "(", "p", ")", "\n\n", "if", "ip", ":=", "net", ".", "ParseIP", "(", "ip", ")", ";", "ip", "!=", "nil", "{", "d", ".", "Address", "=", "[", "]", "byte", "(", "ip", ")", "\n", "if", "ip", ":=", "ip", ".", "To4", "(", ")", ";", "ip", "!=", "nil", "{", "d", ".", "SocketFam", "=", "tap", ".", "SocketFamily_INET", "\n", "}", "else", "{", "d", ".", "SocketFam", "=", "tap", ".", "SocketFamily_INET6", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "HostPort", "decodes", "into", "Data", "any", "string", "returned", "by", "dnsutil", ".", "ParseHostPortOrFile", "." ]

[ "func", "(", "d", "*", "Data", ")", "RemoteAddr", "(", "remote", "net", ".", "Addr", ")", "error", "{", "switch", "addr", ":=", "remote", ".", "(", "type", ")", "{", "case", "*", "net", ".", "TCPAddr", ":", "d", ".", "Address", "=", "addr", ".", "IP", "\n", "d", ".", "Port", "=", "uint32", "(", "addr", ".", "Port", ")", "\n", "d", ".", "SocketProto", "=", "tap", ".", "SocketProtocol_TCP", "\n", "case", "*", "net", ".", "UDPAddr", ":", "d", ".", "Address", "=", "addr", ".", "IP", "\n", "d", ".", "Port", "=", "uint32", "(", "addr", ".", "Port", ")", "\n", "d", ".", "SocketProto", "=", "tap", ".", "SocketProtocol_UDP", "\n", "default", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "a", ":=", "net", ".", "IP", "(", "d", ".", "Address", ")", ";", "a", ".", "To4", "(", ")", "!=", "nil", "{", "d", ".", "SocketFam", "=", "tap", ".", "SocketFamily_INET", "\n", "}", "else", "{", "d", ".", "SocketFam", "=", "tap", ".", "SocketFamily_INET6", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "RemoteAddr", "parses", "the", "information", "about", "the", "remote", "address", "into", "Data", "." ]

[ "func", "(", "d", "*", "Data", ")", "Pack", "(", "m", "*", "dns", ".", "Msg", ")", "error", "{", "packed", ",", "err", ":=", "m", ".", "Pack", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "d", ".", "Packed", "=", "packed", "\n", "return", "nil", "\n", "}" ]

[ "Pack", "encodes", "the", "DNS", "message", "into", "Data", "." ]

[ "func", "newUpstream", "(", "hosts", "[", "]", "string", ",", "old", "*", "staticUpstream", ")", "Upstream", "{", "upstream", ":=", "&", "staticUpstream", "{", "from", ":", "old", ".", "from", ",", "HealthCheck", ":", "healthcheck", ".", "HealthCheck", "{", "FailTimeout", ":", "5", "*", "time", ".", "Second", ",", "MaxFails", ":", "3", ",", "}", ",", "ex", ":", "old", ".", "ex", ",", "IgnoredSubDomains", ":", "old", ".", "IgnoredSubDomains", ",", "}", "\n\n", "upstream", ".", "Hosts", "=", "make", "(", "[", "]", "*", "healthcheck", ".", "UpstreamHost", ",", "len", "(", "hosts", ")", ")", "\n", "for", "i", ",", "host", ":=", "range", "hosts", "{", "uh", ":=", "&", "healthcheck", ".", "UpstreamHost", "{", "Name", ":", "host", ",", "Conns", ":", "0", ",", "Fails", ":", "0", ",", "FailTimeout", ":", "upstream", ".", "FailTimeout", ",", "CheckDown", ":", "checkDownFunc", "(", "upstream", ")", ",", "}", "\n", "upstream", ".", "Hosts", "[", "i", "]", "=", "uh", "\n", "}", "\n", "return", "upstream", "\n", "}" ]

[ "newUpstream", "returns", "an", "upstream", "initialized", "with", "hosts", "." ]

[ "func", "replaceEnvReferences", "(", "s", ",", "refStart", ",", "refEnd", "string", ")", "string", "{", "index", ":=", "strings", ".", "Index", "(", "s", ",", "refStart", ")", "\n", "for", "index", "!=", "-", "1", "{", "endIndex", ":=", "strings", ".", "Index", "(", "s", ",", "refEnd", ")", "\n", "if", "endIndex", "!=", "-", "1", "{", "ref", ":=", "s", "[", "index", ":", "endIndex", "+", "len", "(", "refEnd", ")", "]", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "ref", ",", "os", ".", "Getenv", "(", "ref", "[", "len", "(", "refStart", ")", ":", "len", "(", "ref", ")", "-", "len", "(", "refEnd", ")", "]", ")", ",", "-", "1", ")", "\n", "}", "else", "{", "return", "s", "\n", "}", "\n", "index", "=", "strings", ".", "Index", "(", "s", ",", "refStart", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "replaceEnvReferences", "performs", "the", "actual", "replacement", "of", "env", "variables", "in", "s", "given", "the", "placeholder", "start", "and", "placeholder", "end", "strings", "." ]

[ "func", "redirPlaintextHost", "(", "cfg", "*", "SiteConfig", ")", "*", "SiteConfig", "{", "redirPort", ":=", "cfg", ".", "Addr", ".", "Port", "\n", "if", "redirPort", "==", "\"", "\"", "{", "// default port is redundant", "redirPort", "=", "\"", "\"", "\n", "}", "\n", "redirMiddleware", ":=", "func", "(", "next", "Handler", ")", "Handler", "{", "return", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "(", "int", ",", "error", ")", "{", "toURL", ":=", "\"", "\"", "+", "r", ".", "Host", "\n", "if", "redirPort", "!=", "\"", "\"", "{", "toURL", "+=", "\"", "\"", "+", "redirPort", "\n", "}", "\n", "toURL", "+=", "r", ".", "URL", ".", "RequestURI", "(", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "http", ".", "Redirect", "(", "w", ",", "r", ",", "toURL", ",", "http", ".", "StatusMovedPermanently", ")", "\n", "return", "0", ",", "nil", "\n", "}", ")", "\n", "}", "\n", "host", ":=", "cfg", ".", "Addr", ".", "Host", "\n", "port", ":=", "\"", "\"", "\n", "addr", ":=", "net", ".", "JoinHostPort", "(", "host", ",", "port", ")", "\n", "return", "&", "SiteConfig", "{", "Addr", ":", "Address", "{", "Original", ":", "addr", ",", "Host", ":", "host", ",", "Port", ":", "port", "}", ",", "ListenHost", ":", "cfg", ".", "ListenHost", ",", "middleware", ":", "[", "]", "Middleware", "{", "redirMiddleware", "}", ",", "TLS", ":", "&", "caddytls", ".", "Config", "{", "AltHTTPPort", ":", "cfg", ".", "TLS", ".", "AltHTTPPort", "}", ",", "}", "\n", "}" ]

[ "redirPlaintextHost", "returns", "a", "new", "plaintext", "HTTP", "configuration", "for", "a", "virtualHost", "that", "simply", "redirects", "to", "cfg", "which", "is", "assumed", "to", "be", "the", "HTTPS", "configuration", ".", "The", "returned", "configuration", "is", "set", "to", "listen", "on", "port", "80", ".", "The", "TLS", "field", "of", "cfg", "must", "not", "be", "nil", "." ]

[ "func", "Report", "(", "req", "request", ".", "Request", ",", "zone", ",", "rcode", "string", ",", "size", "int", ",", "start", "time", ".", "Time", ")", "{", "// Proto and Family.", "net", ":=", "req", ".", "Proto", "(", ")", "\n", "fam", ":=", "\"", "\"", "\n", "if", "req", ".", "Family", "(", ")", "==", "2", "{", "fam", "=", "\"", "\"", "\n", "}", "\n\n", "typ", ":=", "req", ".", "QType", "(", ")", "\n\n", "RequestCount", ".", "WithLabelValues", "(", "zone", ",", "net", ",", "fam", ")", ".", "Inc", "(", ")", "\n", "RequestDuration", ".", "WithLabelValues", "(", "zone", ")", ".", "Observe", "(", "float64", "(", "time", ".", "Since", "(", "start", ")", "/", "time", ".", "Millisecond", ")", ")", "\n\n", "if", "req", ".", "Do", "(", ")", "{", "RequestDo", ".", "WithLabelValues", "(", "zone", ")", ".", "Inc", "(", ")", "\n", "}", "\n\n", "if", "_", ",", "known", ":=", "monitorType", "[", "typ", "]", ";", "known", "{", "RequestType", ".", "WithLabelValues", "(", "zone", ",", "dns", ".", "Type", "(", "typ", ")", ".", "String", "(", ")", ")", ".", "Inc", "(", ")", "\n", "}", "else", "{", "RequestType", ".", "WithLabelValues", "(", "zone", ",", "other", ")", ".", "Inc", "(", ")", "\n", "}", "\n\n", "ResponseSize", ".", "WithLabelValues", "(", "zone", ",", "net", ")", ".", "Observe", "(", "float64", "(", "size", ")", ")", "\n", "RequestSize", ".", "WithLabelValues", "(", "zone", ",", "net", ")", ".", "Observe", "(", "float64", "(", "req", ".", "Len", "(", ")", ")", ")", "\n\n", "ResponseRcode", ".", "WithLabelValues", "(", "zone", ",", "rcode", ")", ".", "Inc", "(", ")", "\n", "}" ]

[ "Report", "reports", "the", "metrics", "data", "associcated", "with", "request", "." ]

[ "func", "setup", "(", "c", "*", "caddy", ".", "Controller", ")", "error", "{", "ctx", ":=", "log", ".", "LoggerNewContext", "(", "context", ".", "Background", "(", ")", ")", "\n\n", "apiAAA", ",", "err", ":=", "buildApiAAAHandler", "(", "ctx", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "httpserver", ".", "GetConfig", "(", "c", ")", ".", "AddMiddleware", "(", "func", "(", "next", "httpserver", ".", "Handler", ")", "httpserver", ".", "Handler", "{", "apiAAA", ".", "Next", "=", "next", "\n", "return", "apiAAA", "\n", "}", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Setup", "the", "api", "-", "aaa", "middleware", "Also", "loads", "the", "pfconfig", "resources", "and", "registers", "them", "in", "the", "pool" ]

[ "func", "buildApiAAAHandler", "(", "ctx", "context", ".", "Context", ")", "(", "ApiAAAHandler", ",", "error", ")", "{", "apiAAA", ":=", "ApiAAAHandler", "{", "}", "\n\n", "pfconfigdriver", ".", "PfconfigPool", ".", "AddStruct", "(", "ctx", ",", "&", "pfconfigdriver", ".", "Config", ".", "PfConf", ".", "Webservices", ")", "\n", "pfconfigdriver", ".", "PfconfigPool", ".", "AddStruct", "(", "ctx", ",", "&", "pfconfigdriver", ".", "Config", ".", "UnifiedApiSystemUser", ")", "\n", "pfconfigdriver", ".", "PfconfigPool", ".", "AddStruct", "(", "ctx", ",", "&", "pfconfigdriver", ".", "Config", ".", "AdminRoles", ")", "\n\n", "tokenBackend", ":=", "aaa", ".", "NewMemTokenBackend", "(", "15", "*", "time", ".", "Minute", ",", "12", "*", "time", ".", "Hour", ")", "\n", "apiAAA", ".", "authentication", "=", "aaa", ".", "NewTokenAuthenticationMiddleware", "(", "tokenBackend", ")", "\n\n", "// Backend for the system Unified API user", "if", "pfconfigdriver", ".", "Config", ".", "UnifiedApiSystemUser", ".", "User", "!=", "\"", "\"", "{", "apiAAA", ".", "systemBackend", "=", "aaa", ".", "NewMemAuthenticationBackend", "(", "map", "[", "string", "]", "string", "{", "}", ",", "map", "[", "string", "]", "bool", "{", "\"", "\"", ":", "true", "}", ",", ")", "\n", "apiAAA", ".", "systemBackend", ".", "SetUser", "(", "pfconfigdriver", ".", "Config", ".", "UnifiedApiSystemUser", ".", "User", ",", "pfconfigdriver", ".", "Config", ".", "UnifiedApiSystemUser", ".", "Pass", ")", "\n", "apiAAA", ".", "authentication", ".", "AddAuthenticationBackend", "(", "apiAAA", ".", "systemBackend", ")", "\n", "}", "\n\n", "// Backend for the pf.conf webservices user", "apiAAA", ".", "webservicesBackend", "=", "aaa", ".", "NewMemAuthenticationBackend", "(", "map", "[", "string", "]", "string", "{", "}", ",", "map", "[", "string", "]", "bool", "{", "\"", "\"", ":", "true", "}", ",", ")", "\n", "apiAAA", ".", "authentication", ".", "AddAuthenticationBackend", "(", "apiAAA", ".", "webservicesBackend", ")", "\n\n", "if", "pfconfigdriver", ".", "Config", ".", "PfConf", ".", "Webservices", ".", "User", "!=", "\"", "\"", "{", "apiAAA", ".", "webservicesBackend", ".", "SetUser", "(", "pfconfigdriver", ".", "Config", ".", "PfConf", ".", "Webservices", ".", "User", ",", "pfconfigdriver", ".", "Config", ".", "PfConf", ".", "Webservices", ".", "Pass", ")", "\n", "}", "\n\n", "url", ",", "err", ":=", "url", ".", "Parse", "(", "\"", "\"", ")", "\n", "sharedutils", ".", "CheckError", "(", "err", ")", "\n", "apiAAA", ".", "authentication", ".", "AddAuthenticationBackend", "(", "aaa", ".", "NewPfAuthenticationBackend", "(", "ctx", ",", "url", ",", "false", ")", ")", "\n\n", "apiAAA", ".", "authorization", "=", "aaa", ".", "NewTokenAuthorizationMiddleware", "(", "tokenBackend", ")", "\n\n", "router", ":=", "httprouter", ".", "New", "(", ")", "\n", "router", ".", "POST", "(", "\"", "\"", ",", "apiAAA", ".", "handleLogin", ")", "\n", "router", ".", "GET", "(", "\"", "\"", ",", "apiAAA", ".", "handleTokenInfo", ")", "\n\n", "apiAAA", ".", "router", "=", "router", "\n\n", "return", "apiAAA", ",", "nil", "\n", "}" ]

[ "Build", "the", "ApiAAAHandler", "which", "will", "initialize", "the", "cache", "and", "instantiate", "the", "router", "along", "with", "its", "routes" ]

[ "func", "(", "h", "ApiAAAHandler", ")", "handleLogin", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ",", "p", "httprouter", ".", "Params", ")", "{", "ctx", ":=", "r", ".", "Context", "(", ")", "\n", "defer", "statsd", ".", "NewStatsDTiming", "(", "ctx", ")", ".", "Send", "(", "\"", "\"", ")", "\n\n", "var", "loginParams", "struct", "{", "Username", "string", "\n", "Password", "string", "\n", "}", "\n\n", "err", ":=", "json", ".", "NewDecoder", "(", "r", ".", "Body", ")", ".", "Decode", "(", "&", "loginParams", ")", "\n\n", "if", "err", "!=", "nil", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", "\n", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "msg", ")", "\n", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprint", "(", "err", ")", ",", "http", ".", "StatusBadRequest", ")", "\n", "return", "\n", "}", "\n\n", "auth", ",", "token", ",", "err", ":=", "h", ".", "authentication", ".", "Login", "(", "ctx", ",", "loginParams", ".", "Username", ",", "loginParams", ".", "Password", ")", "\n\n", "if", "auth", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "res", ",", "_", ":=", "json", ".", "Marshal", "(", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "token", ",", "}", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "string", "(", "res", ")", ")", "\n", "}", "else", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusUnauthorized", ")", "\n", "res", ",", "_", ":=", "json", ".", "Marshal", "(", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "err", ".", "Error", "(", ")", ",", "}", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "string", "(", "res", ")", ")", "\n", "}", "\n", "}" ]

[ "Handle", "an", "API", "login" ]

[ "func", "(", "h", "ApiAAAHandler", ")", "handleTokenInfo", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ",", "p", "httprouter", ".", "Params", ")", "{", "ctx", ":=", "r", ".", "Context", "(", ")", "\n", "defer", "statsd", ".", "NewStatsDTiming", "(", "ctx", ")", ".", "Send", "(", "\"", "\"", ")", "\n\n", "info", ",", "expiration", ":=", "h", ".", "authorization", ".", "GetTokenInfoFromBearerRequest", "(", "ctx", ",", "r", ")", "\n\n", "if", "info", "!=", "nil", "{", "// We'll want to render the roles as an array, not as a map", "prettyInfo", ":=", "PrettyTokenInfo", "{", "AdminActions", ":", "make", "(", "[", "]", "string", ",", "len", "(", "info", ".", "AdminActions", "(", ")", ")", ")", ",", "AdminRoles", ":", "make", "(", "[", "]", "string", ",", "len", "(", "info", ".", "AdminRoles", ")", ")", ",", "TenantId", ":", "info", ".", "TenantId", ",", "Username", ":", "info", ".", "Username", ",", "ExpiresAt", ":", "expiration", ",", "}", "\n\n", "i", ":=", "0", "\n", "for", "r", ",", "_", ":=", "range", "info", ".", "AdminActions", "(", ")", "{", "prettyInfo", ".", "AdminActions", "[", "i", "]", "=", "r", "\n", "i", "++", "\n", "}", "\n\n", "i", "=", "0", "\n", "for", "r", ",", "_", ":=", "range", "info", ".", "AdminRoles", "{", "prettyInfo", ".", "AdminRoles", "[", "i", "]", "=", "r", "\n", "i", "++", "\n", "}", "\n\n", "w", ".", "WriteHeader", "(", "http", ".", "StatusOK", ")", "\n", "res", ",", "_", ":=", "json", ".", "Marshal", "(", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "prettyInfo", ",", "}", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "string", "(", "res", ")", ")", "\n", "}", "else", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusNotFound", ")", "\n", "res", ",", "_", ":=", "json", ".", "Marshal", "(", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "\"", "\"", ",", "}", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "string", "(", "res", ")", ")", "\n", "}", "\n", "}" ]

[ "Handle", "getting", "the", "token", "info" ]

[ "func", "NewServergRPC", "(", "addr", "string", ",", "group", "[", "]", "*", "Config", ")", "(", "*", "ServergRPC", ",", "error", ")", "{", "s", ",", "err", ":=", "NewServer", "(", "addr", ",", "group", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "gs", ":=", "&", "ServergRPC", "{", "Server", ":", "s", "}", "\n", "return", "gs", ",", "nil", "\n", "}" ]

[ "NewServergRPC", "returns", "a", "new", "CoreDNS", "GRPC", "server", "and", "compiles", "all", "plugin", "in", "to", "it", "." ]

[ "func", "(", "s", "*", "ServergRPC", ")", "Query", "(", "ctx", "context", ".", "Context", ",", "in", "*", "pb", ".", "DnsPacket", ")", "(", "*", "pb", ".", "DnsPacket", ",", "error", ")", "{", "msg", ":=", "new", "(", "dns", ".", "Msg", ")", "\n", "err", ":=", "msg", ".", "Unpack", "(", "in", ".", "Msg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "p", ",", "ok", ":=", "peer", ".", "FromContext", "(", "ctx", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "a", ",", "ok", ":=", "p", ".", "Addr", ".", "(", "*", "net", ".", "TCPAddr", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "Addr", ")", "\n", "}", "\n\n", "r", ":=", "&", "net", ".", "IPAddr", "{", "IP", ":", "a", ".", "IP", "}", "\n", "w", ":=", "&", "gRPCresponse", "{", "localAddr", ":", "s", ".", "listenAddr", ",", "remoteAddr", ":", "r", ",", "Msg", ":", "msg", "}", "\n\n", "s", ".", "ServeDNS", "(", "ctx", ",", "w", ",", "msg", ")", "\n\n", "packed", ",", "err", ":=", "w", ".", "Msg", ".", "Pack", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pb", ".", "DnsPacket", "{", "Msg", ":", "packed", "}", ",", "nil", "\n", "}" ]

[ "Query", "is", "the", "main", "entry", "-", "point", "into", "the", "gRPC", "server", ".", "From", "here", "we", "call", "ServeDNS", "like", "any", "normal", "server", ".", "We", "use", "a", "custom", "responseWriter", "to", "pick", "up", "the", "bytes", "we", "need", "to", "write", "back", "to", "the", "client", "as", "a", "protobuf", "." ]

[ "func", "DefaultErrorFunc", "(", "w", "dns", ".", "ResponseWriter", ",", "r", "*", "dns", ".", "Msg", ",", "rc", "int", ")", "{", "state", ":=", "request", ".", "Request", "{", "W", ":", "w", ",", "Req", ":", "r", "}", "\n\n", "answer", ":=", "new", "(", "dns", ".", "Msg", ")", "\n", "answer", ".", "SetRcode", "(", "r", ",", "rc", ")", "\n\n", "state", ".", "SizeAndDo", "(", "answer", ")", "\n\n", "vars", ".", "Report", "(", "state", ",", "vars", ".", "Dropped", ",", "rcode", ".", "ToString", "(", "rc", ")", ",", "answer", ".", "Len", "(", ")", ",", "time", ".", "Now", "(", ")", ")", "\n\n", "w", ".", "WriteMsg", "(", "answer", ")", "\n", "}" ]

[ "DefaultErrorFunc", "responds", "to", "an", "DNS", "request", "with", "an", "error", "." ]

[ "func", "(", "z", "*", "Zone", ")", "Reload", "(", ")", "error", "{", "if", "z", ".", "NoReload", "{", "return", "nil", "\n", "}", "\n\n", "tick", ":=", "time", ".", "NewTicker", "(", "TickTime", ")", "\n\n", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "<-", "tick", ".", "C", ":", "reader", ",", "err", ":=", "os", ".", "Open", "(", "z", ".", "file", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "z", ".", "origin", ",", "z", ".", "file", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "serial", ":=", "z", ".", "SOASerialIfDefined", "(", ")", "\n", "zone", ",", "err", ":=", "Parse", "(", "reader", ",", "z", ".", "origin", ",", "z", ".", "file", ",", "serial", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "serialErr", ")", ";", "!", "ok", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "z", ".", "origin", ",", "err", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "// copy elements we need", "z", ".", "reloadMu", ".", "Lock", "(", ")", "\n", "z", ".", "Apex", "=", "zone", ".", "Apex", "\n", "z", ".", "Tree", "=", "zone", ".", "Tree", "\n", "z", ".", "reloadMu", ".", "Unlock", "(", ")", "\n\n", "log", ".", "Printf", "(", "\"", "\"", ",", "z", ".", "origin", ",", "z", ".", "file", ",", "z", ".", "Apex", ".", "SOA", ".", "Serial", ")", "\n", "z", ".", "Notify", "(", ")", "\n\n", "case", "<-", "z", ".", "ReloadShutdown", ":", "tick", ".", "Stop", "(", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Reload", "reloads", "a", "zone", "when", "it", "is", "changed", "on", "disk", ".", "If", "z", ".", "NoRoload", "is", "true", "no", "reloading", "will", "be", "done", "." ]

[ "func", "NewStaticUpstreams", "(", "c", "caddyfile", ".", "Dispenser", ")", "(", "[", "]", "Upstream", ",", "error", ")", "{", "var", "upstreams", "[", "]", "Upstream", "\n", "for", "c", ".", "Next", "(", ")", "{", "upstream", ":=", "&", "staticUpstream", "{", "from", ":", "\"", "\"", ",", "upstreamHeaders", ":", "make", "(", "http", ".", "Header", ")", ",", "downstreamHeaders", ":", "make", "(", "http", ".", "Header", ")", ",", "Hosts", ":", "nil", ",", "Policy", ":", "&", "Random", "{", "}", ",", "MaxFails", ":", "1", ",", "TryInterval", ":", "250", "*", "time", ".", "Millisecond", ",", "MaxConns", ":", "0", ",", "KeepAlive", ":", "http", ".", "DefaultMaxIdleConnsPerHost", ",", "Timeout", ":", "30", "*", "time", ".", "Second", ",", "}", "\n\n", "if", "!", "c", ".", "Args", "(", "&", "upstream", ".", "from", ")", "{", "return", "upstreams", ",", "c", ".", "ArgErr", "(", ")", "\n", "}", "\n\n", "var", "to", "[", "]", "string", "\n", "for", "_", ",", "t", ":=", "range", "c", ".", "RemainingArgs", "(", ")", "{", "parsed", ",", "err", ":=", "parseUpstream", "(", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "upstreams", ",", "err", "\n", "}", "\n", "to", "=", "append", "(", "to", ",", "parsed", "...", ")", "\n", "}", "\n\n", "for", "c", ".", "NextBlock", "(", ")", "{", "switch", "c", ".", "Val", "(", ")", "{", "case", "\"", "\"", ":", "if", "!", "c", ".", "NextArg", "(", ")", "{", "return", "upstreams", ",", "c", ".", "ArgErr", "(", ")", "\n", "}", "\n", "parsed", ",", "err", ":=", "parseUpstream", "(", "c", ".", "Val", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "upstreams", ",", "err", "\n", "}", "\n", "to", "=", "append", "(", "to", ",", "parsed", "...", ")", "\n", "default", ":", "if", "err", ":=", "parseBlock", "(", "&", "c", ",", "upstream", ")", ";", "err", "!=", "nil", "{", "return", "upstreams", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "to", ")", "==", "0", "{", "return", "upstreams", ",", "c", ".", "ArgErr", "(", ")", "\n", "}", "\n\n", "upstream", ".", "Hosts", "=", "make", "(", "[", "]", "*", "UpstreamHost", ",", "len", "(", "to", ")", ")", "\n", "for", "i", ",", "host", ":=", "range", "to", "{", "uh", ",", "err", ":=", "upstream", ".", "NewHost", "(", "host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "upstreams", ",", "err", "\n", "}", "\n", "upstream", ".", "Hosts", "[", "i", "]", "=", "uh", "\n", "}", "\n\n", "if", "upstream", ".", "HealthCheck", ".", "Path", "!=", "\"", "\"", "{", "upstream", ".", "HealthCheck", ".", "Client", "=", "http", ".", "Client", "{", "Timeout", ":", "upstream", ".", "HealthCheck", ".", "Timeout", ",", "}", "\n", "go", "upstream", ".", "HealthCheckWorker", "(", "nil", ")", "\n", "}", "\n", "upstreams", "=", "append", "(", "upstreams", ",", "upstream", ")", "\n", "}", "\n", "return", "upstreams", ",", "nil", "\n", "}" ]

[ "NewStaticUpstreams", "parses", "the", "configuration", "input", "and", "sets", "up", "static", "upstreams", "for", "the", "proxy", "middleware", "." ]

[ "func", "(", "pf", "*", "pfdns", ")", "WebservicesInit", "(", ")", "error", "{", "var", "ctx", "=", "context", ".", "Background", "(", ")", "\n", "var", "webservices", "pfconfigdriver", ".", "PfConfWebservices", "\n", "webservices", ".", "PfconfigNS", "=", "\"", "\"", "\n", "webservices", ".", "PfconfigMethod", "=", "\"", "\"", "\n", "webservices", ".", "PfconfigHashNS", "=", "\"", "\"", "\n\n", "pfconfigdriver", ".", "FetchDecodeSocket", "(", "ctx", ",", "&", "webservices", ")", "\n", "pf", ".", "Webservices", "=", "webservices", "\n", "return", "nil", "\n\n", "}" ]

[ "WebservicesInit", "read", "pfconfig", "webservices", "configuration" ]

[ "func", "(", "pf", "*", "pfdns", ")", "addDetectionMechanismsToList", "(", "ctx", "context", ".", "Context", ",", "r", "string", ")", "error", "{", "rgx", ",", "err", ":=", "regexp", ".", "Compile", "(", "r", ")", "\n", "if", "err", "==", "nil", "{", "pf", ".", "mutex", ".", "Lock", "(", ")", "\n", "pf", ".", "detectionMechanisms", "=", "append", "(", "pf", ".", "detectionMechanisms", ",", "rgx", ")", "\n", "pf", ".", "mutex", ".", "Unlock", "(", ")", "\n", "}", "else", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "addDetectionMechanismsToList", "add", "all", "detection", "mechanisms", "in", "a", "list" ]

[ "func", "newUser", "(", "email", "string", ")", "(", "User", ",", "error", ")", "{", "user", ":=", "User", "{", "Email", ":", "email", "}", "\n", "privateKey", ",", "err", ":=", "ecdsa", ".", "GenerateKey", "(", "elliptic", ".", "P384", "(", ")", ",", "rand", ".", "Reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "user", ",", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "user", ".", "key", "=", "privateKey", "\n", "return", "user", ",", "nil", "\n", "}" ]

[ "newUser", "creates", "a", "new", "User", "for", "the", "given", "email", "address", "with", "a", "new", "private", "key", ".", "This", "function", "does", "NOT", "save", "the", "user", "to", "disk", "or", "register", "it", "via", "ACME", ".", "If", "you", "want", "to", "use", "a", "user", "account", "that", "might", "already", "exist", "call", "getUser", "instead", ".", "It", "does", "NOT", "prompt", "the", "user", "." ]

[ "func", "getUser", "(", "storage", "Storage", ",", "email", "string", ")", "(", "User", ",", "error", ")", "{", "var", "user", "User", "\n\n", "// open user reg", "userData", ",", "err", ":=", "storage", ".", "LoadUser", "(", "email", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "ErrNotExist", ")", ";", "ok", "{", "// create a new user", "return", "newUser", "(", "email", ")", "\n", "}", "\n", "return", "user", ",", "err", "\n", "}", "\n\n", "// load user information", "err", "=", "json", ".", "Unmarshal", "(", "userData", ".", "Reg", ",", "&", "user", ")", "\n", "if", "err", "!=", "nil", "{", "return", "user", ",", "err", "\n", "}", "\n\n", "// load their private key", "user", ".", "key", ",", "err", "=", "loadPrivateKey", "(", "userData", ".", "Key", ")", "\n", "return", "user", ",", "err", "\n", "}" ]

[ "getUser", "loads", "the", "user", "with", "the", "given", "email", "from", "disk", "using", "the", "provided", "storage", ".", "If", "the", "user", "does", "not", "exist", "it", "will", "create", "a", "new", "one", "but", "it", "does", "NOT", "save", "new", "users", "to", "the", "disk", "or", "register", "them", "via", "ACME", ".", "It", "does", "NOT", "prompt", "the", "user", "." ]

[ "func", "saveUser", "(", "storage", "Storage", ",", "user", "User", ")", "error", "{", "// Save the private key and registration", "userData", ":=", "new", "(", "UserData", ")", "\n", "var", "err", "error", "\n", "userData", ".", "Key", ",", "err", "=", "savePrivateKey", "(", "user", ".", "key", ")", "\n", "if", "err", "==", "nil", "{", "userData", ".", "Reg", ",", "err", "=", "json", ".", "MarshalIndent", "(", "&", "user", ",", "\"", "\"", ",", "\"", "\\t", "\"", ")", "\n", "}", "\n", "if", "err", "==", "nil", "{", "err", "=", "storage", ".", "StoreUser", "(", "user", ".", "Email", ",", "userData", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "saveUser", "persists", "a", "user", "s", "key", "and", "account", "registration", "to", "the", "file", "system", ".", "It", "does", "NOT", "register", "the", "user", "via", "ACME", "or", "prompt", "the", "user", ".", "You", "must", "also", "pass", "in", "the", "storage", "wherein", "the", "user", "should", "be", "saved", ".", "It", "should", "be", "the", "storage", "for", "the", "CA", "with", "which", "user", "has", "an", "account", "." ]

[ "func", "promptUserAgreement", "(", "agreementURL", "string", ",", "changed", "bool", ")", "bool", "{", "if", "changed", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\\n", "\"", ",", "agreementURL", ")", "\n", "fmt", ".", "Print", "(", "\"", "\"", ")", "\n", "}", "else", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\\n", "\"", ",", "agreementURL", ")", "\n", "fmt", ".", "Print", "(", "\"", "\"", ")", "\n", "}", "\n\n", "reader", ":=", "bufio", ".", "NewReader", "(", "stdin", ")", "\n", "answer", ",", "err", ":=", "reader", ".", "ReadString", "(", "'\\n'", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "answer", "=", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "answer", ")", ")", "\n\n", "return", "answer", "==", "\"", "\"", "||", "answer", "==", "\"", "\"", "\n", "}" ]

[ "promptUserAgreement", "prompts", "the", "user", "to", "agree", "to", "the", "agreement", "at", "agreementURL", "via", "stdin", ".", "If", "the", "agreement", "has", "changed", "then", "pass", "true", "as", "the", "second", "argument", ".", "If", "this", "is", "the", "user", "s", "first", "time", "agreeing", "pass", "false", ".", "It", "returns", "whether", "the", "user", "agreed", "or", "not", "." ]

[ "func", "NewSocket", "(", "path", "string", ")", "(", "s", "*", "Socket", ",", "err", "error", ")", "{", "s", "=", "&", "Socket", "{", "path", ":", "path", "}", "\n", "if", "err", "=", "openSocket", "(", "s", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "s", ".", "err", "=", "err", "\n", "return", "\n", "}", "\n", "return", "\n", "}" ]

[ "NewSocket", "will", "always", "return", "a", "new", "Socket", ".", "err", "if", "nothing", "is", "listening", "to", "it", "it", "will", "attempt", "to", "reconnect", "on", "the", "next", "Write", "." ]

[ "func", "(", "s", "*", "Socket", ")", "Close", "(", ")", "error", "{", "if", "s", ".", "err", "!=", "nil", "{", "// nothing to close", "return", "nil", "\n", "}", "\n\n", "defer", "s", ".", "conn", ".", "Close", "(", ")", "\n\n", "if", "err", ":=", "s", ".", "enc", ".", "Flush", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "s", ".", "enc", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "the", "socket", "and", "flush", "the", "remaining", "frames", "." ]

[ "func", "DialTimeout", "(", "network", "string", ",", "address", "string", ",", "timeout", "time", ".", "Duration", ")", "(", "fcgi", "*", "FCGIClient", ",", "err", "error", ")", "{", "conn", ",", "err", ":=", "net", ".", "DialTimeout", "(", "network", ",", "address", ",", "timeout", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "fcgi", "=", "&", "FCGIClient", "{", "conn", ":", "conn", ",", "keepAlive", ":", "false", ",", "reqID", ":", "1", "}", "\n\n", "return", "fcgi", ",", "nil", "\n", "}" ]

[ "DialTimeout", "connects", "to", "the", "fcgi", "responder", "at", "the", "specified", "network", "address", "using", "default", "net", ".", "Dialer", ".", "See", "func", "net", ".", "Dial", "for", "a", "description", "of", "the", "network", "and", "address", "parameters", "." ]

[ "func", "(", "rh", "*", "RequestHistory", ")", "UuidIndex", "(", "uuid", "string", ")", "int", "{", "rh", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "rh", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "rh", ".", "uuidIndexNoLock", "(", "uuid", ")", "\n", "}" ]

[ "Returns", "the", "index", "at", "which", "to", "find", "the", "request", "for", "the", "UUID", "Returns", "-", "1", "if", "the", "UUID", "is", "unknown" ]

[ "func", "connectDB", "(", "configDatabase", "pfconfigdriver", ".", "PfConfDatabase", ")", "{", "db", ",", "err", ":=", "db", ".", "DbFromConfig", "(", "ctx", ")", "\n", "sharedutils", ".", "CheckError", "(", "err", ")", "\n", "MySQLdatabase", "=", "db", "\n", "}" ]

[ "connectDB", "connect", "to", "the", "database" ]

[ "func", "initiaLease", "(", "dhcpHandler", "*", "DHCPHandler", ",", "ConfNet", "pfconfigdriver", ".", "RessourseNetworkConf", ")", "{", "// Need to calculate the end ip because of the ip per role feature", "now", ":=", "time", ".", "Now", "(", ")", "\n", "endip", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "dhcpHandler", ".", "start", ".", "To4", "(", ")", ")", "+", "uint32", "(", "dhcpHandler", ".", "leaseRange", ")", "-", "uint32", "(", "1", ")", "\n", "a", ":=", "make", "(", "[", "]", "byte", ",", "4", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "a", ",", "endip", ")", "\n", "ipend", ":=", "net", ".", "IPv4", "(", "a", "[", "0", "]", ",", "a", "[", "1", "]", ",", "a", "[", "2", "]", ",", "a", "[", "3", "]", ")", "\n\n", "rows", ",", "err", ":=", "MySQLdatabase", ".", "Query", "(", "\"", "\"", ",", "dhcpHandler", ".", "start", ".", "String", "(", ")", ",", "ipend", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "defer", "rows", ".", "Close", "(", ")", "\n", "var", "(", "ipstr", "string", "\n", "mac", "string", "\n", "end_time", "time", ".", "Time", "\n", "start_time", "time", ".", "Time", "\n", "reservedIP", "[", "]", "net", ".", "IP", "\n", "found", "bool", "\n", ")", "\n", "found", "=", "false", "\n", "excludeIP", ":=", "ExcludeIP", "(", "dhcpHandler", ",", "ConfNet", ".", "IpReserved", ")", "\n", "dhcpHandler", ".", "ipAssigned", ",", "reservedIP", "=", "AssignIP", "(", "dhcpHandler", ",", "ConfNet", ".", "IpAssigned", ")", "\n", "dhcpHandler", ".", "ipReserved", "=", "ConfNet", ".", "IpReserved", "\n\n", "for", "rows", ".", "Next", "(", ")", "{", "err", ":=", "rows", ".", "Scan", "(", "&", "ipstr", ",", "&", "mac", ",", "&", "end_time", ",", "&", "start_time", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "for", "_", ",", "ans", ":=", "range", "append", "(", "excludeIP", ",", "reservedIP", "...", ")", "{", "if", "net", ".", "ParseIP", "(", "ipstr", ")", ".", "Equal", "(", "ans", ")", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "found", "==", "false", "{", "// Calculate the leasetime from the date in the database", "var", "leaseDuration", "time", ".", "Duration", "\n", "if", "end_time", ".", "IsZero", "(", ")", "{", "leaseDuration", "=", "dhcpHandler", ".", "leaseDuration", "\n", "}", "else", "{", "leaseDuration", "=", "end_time", ".", "Sub", "(", "now", ")", "\n", "}", "\n", "ip", ":=", "net", ".", "ParseIP", "(", "ipstr", ")", "\n\n", "// Calculate the position for the roaring bitmap", "position", ":=", "uint32", "(", "binary", ".", "BigEndian", ".", "Uint32", "(", "ip", ".", "To4", "(", ")", ")", ")", "-", "uint32", "(", "binary", ".", "BigEndian", ".", "Uint32", "(", "dhcpHandler", ".", "start", ".", "To4", "(", ")", ")", ")", "\n", "// Remove the position in the roaming bitmap", "dhcpHandler", ".", "available", ".", "ReserveIPIndex", "(", "uint64", "(", "position", ")", ",", "mac", ")", "\n", "// Add the mac in the cache", "dhcpHandler", ".", "hwcache", ".", "Set", "(", "mac", ",", "int", "(", "position", ")", ",", "leaseDuration", ")", "\n", "GlobalIpCache", ".", "Set", "(", "ipstr", ",", "mac", ",", "leaseDuration", ")", "\n", "GlobalMacCache", ".", "Set", "(", "mac", ",", "ipstr", ",", "leaseDuration", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "initiaLease", "fetch", "the", "database", "to", "remove", "already", "assigned", "ip", "addresses" ]

[ "func", "ExcludeIP", "(", "dhcpHandler", "*", "DHCPHandler", ",", "ipRange", "string", ")", "[", "]", "net", ".", "IP", "{", "excludeIPs", ",", "_", ":=", "IPsFromRange", "(", "ipRange", ")", "\n\n", "for", "_", ",", "excludeIP", ":=", "range", "excludeIPs", "{", "if", "excludeIP", "!=", "nil", "{", "// Calculate the position for the dhcp pool", "position", ":=", "uint32", "(", "binary", ".", "BigEndian", ".", "Uint32", "(", "excludeIP", ".", "To4", "(", ")", ")", ")", "-", "uint32", "(", "binary", ".", "BigEndian", ".", "Uint32", "(", "dhcpHandler", ".", "start", ".", "To4", "(", ")", ")", ")", "\n\n", "dhcpHandler", ".", "available", ".", "ReserveIPIndex", "(", "uint64", "(", "position", ")", ",", "FakeMac", ")", "\n", "}", "\n", "}", "\n", "return", "excludeIPs", "\n", "}" ]

[ "ExcludeIP", "remove", "IP", "from", "the", "pool" ]

[ "func", "AssignIP", "(", "dhcpHandler", "*", "DHCPHandler", ",", "ipRange", "string", ")", "(", "map", "[", "string", "]", "uint32", ",", "[", "]", "net", ".", "IP", ")", "{", "couple", ":=", "make", "(", "map", "[", "string", "]", "uint32", ")", "\n", "var", "iplist", "[", "]", "net", ".", "IP", "\n", "if", "ipRange", "!=", "\"", "\"", "{", "rgx", ",", "_", ":=", "regexp", ".", "Compile", "(", "\"", "\"", ")", "\n", "ipRangeArray", ":=", "strings", ".", "Split", "(", "ipRange", ",", "\"", "\"", ")", "\n", "if", "len", "(", "ipRangeArray", ")", ">=", "1", "{", "for", "_", ",", "rangeip", ":=", "range", "ipRangeArray", "{", "result", ":=", "rgx", ".", "FindStringSubmatch", "(", "rangeip", ")", "\n", "position", ":=", "uint32", "(", "binary", ".", "BigEndian", ".", "Uint32", "(", "net", ".", "ParseIP", "(", "result", "[", "2", "]", ")", ".", "To4", "(", ")", ")", ")", "-", "uint32", "(", "binary", ".", "BigEndian", ".", "Uint32", "(", "dhcpHandler", ".", "start", ".", "To4", "(", ")", ")", ")", "\n", "// Remove the position in the roaming bitmap", "dhcpHandler", ".", "available", ".", "ReserveIPIndex", "(", "uint64", "(", "position", ")", ",", "result", "[", "1", "]", ")", "\n", "couple", "[", "result", "[", "1", "]", "]", "=", "position", "\n", "iplist", "=", "append", "(", "iplist", ",", "net", ".", "ParseIP", "(", "result", "[", "2", "]", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "couple", ",", "iplist", "\n", "}" ]

[ "Assign", "static", "IP", "address", "to", "a", "mac", "address", "and", "remove", "it", "from", "the", "pool" ]

[ "func", "(", "cg", "configGroup", ")", "GetCertificate", "(", "clientHello", "*", "tls", ".", "ClientHelloInfo", ")", "(", "*", "tls", ".", "Certificate", ",", "error", ")", "{", "cert", ",", "err", ":=", "cg", ".", "getCertDuringHandshake", "(", "strings", ".", "ToLower", "(", "clientHello", ".", "ServerName", ")", ",", "true", ",", "true", ")", "\n", "return", "&", "cert", ".", "Certificate", ",", "err", "\n", "}" ]

[ "GetCertificate", "gets", "a", "certificate", "to", "satisfy", "clientHello", ".", "In", "getting", "the", "certificate", "it", "abides", "the", "rules", "and", "settings", "defined", "in", "the", "Config", "that", "matches", "clientHello", ".", "ServerName", ".", "It", "first", "checks", "the", "in", "-", "memory", "cache", "then", "if", "the", "config", "enables", "OnDemand", "it", "accesses", "disk", "then", "accesses", "the", "network", "if", "it", "must", "obtain", "a", "new", "certificate", "via", "ACME", ".", "This", "method", "is", "safe", "for", "use", "as", "a", "tls", ".", "Config", ".", "GetCertificate", "callback", "." ]

[ "func", "(", "cg", "configGroup", ")", "checkLimitsForObtainingNewCerts", "(", "name", "string", ",", "cfg", "*", "Config", ")", "error", "{", "// User can set hard limit for number of certs for the process to issue", "if", "cfg", ".", "OnDemandState", ".", "MaxObtain", ">", "0", "&&", "atomic", ".", "LoadInt32", "(", "&", "cfg", ".", "OnDemandState", ".", "ObtainedCount", ")", ">=", "cfg", ".", "OnDemandState", ".", "MaxObtain", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "cfg", ".", "OnDemandState", ".", "MaxObtain", ")", "\n", "}", "\n\n", "// Make sure name hasn't failed a challenge recently", "failedIssuanceMu", ".", "RLock", "(", ")", "\n", "when", ",", "ok", ":=", "failedIssuance", "[", "name", "]", "\n", "failedIssuanceMu", ".", "RUnlock", "(", ")", "\n", "if", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "when", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "// Make sure, if we've issued a few certificates already, that we haven't", "// issued any recently", "lastIssueTimeMu", ".", "Lock", "(", ")", "\n", "since", ":=", "time", ".", "Since", "(", "lastIssueTime", ")", "\n", "lastIssueTimeMu", ".", "Unlock", "(", ")", "\n", "if", "atomic", ".", "LoadInt32", "(", "&", "cfg", ".", "OnDemandState", ".", "ObtainedCount", ")", ">=", "10", "&&", "since", "<", "10", "*", "time", ".", "Minute", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "since", ")", "\n", "}", "\n\n", "// 👍Good to go", "return", "nil", "\n", "}" ]

[ "checkLimitsForObtainingNewCerts", "checks", "to", "see", "if", "name", "can", "be", "issued", "right", "now", "according", "to", "mitigating", "factors", "we", "keep", "track", "of", "and", "preferences", "the", "user", "has", "set", ".", "If", "a", "non", "-", "nil", "error", "is", "returned", "do", "not", "issue", "a", "new", "certificate", "for", "name", "." ]

[ "func", "(", "cg", "configGroup", ")", "obtainOnDemandCertificate", "(", "name", "string", ",", "cfg", "*", "Config", ")", "(", "Certificate", ",", "error", ")", "{", "// We must protect this process from happening concurrently, so synchronize.", "obtainCertWaitChansMu", ".", "Lock", "(", ")", "\n", "wait", ",", "ok", ":=", "obtainCertWaitChans", "[", "name", "]", "\n", "if", "ok", "{", "// lucky us -- another goroutine is already obtaining the certificate.", "// wait for it to finish obtaining the cert and then we'll use it.", "obtainCertWaitChansMu", ".", "Unlock", "(", ")", "\n", "<-", "wait", "\n", "return", "cg", ".", "getCertDuringHandshake", "(", "name", ",", "true", ",", "false", ")", "\n", "}", "\n\n", "// looks like it's up to us to do all the work and obtain the cert.", "// make a chan others can wait on if needed", "wait", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "obtainCertWaitChans", "[", "name", "]", "=", "wait", "\n", "obtainCertWaitChansMu", ".", "Unlock", "(", ")", "\n\n", "// do the obtain", "log", ".", "Printf", "(", "\"", "\"", ",", "name", ")", "\n", "err", ":=", "cfg", ".", "ObtainCert", "(", "name", ",", "false", ")", "\n\n", "// immediately unblock anyone waiting for it; doing this in", "// a defer would risk deadlock because of the recursive call", "// to getCertDuringHandshake below when we return!", "obtainCertWaitChansMu", ".", "Lock", "(", ")", "\n", "close", "(", "wait", ")", "\n", "delete", "(", "obtainCertWaitChans", ",", "name", ")", "\n", "obtainCertWaitChansMu", ".", "Unlock", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "// Failed to solve challenge, so don't allow another on-demand", "// issue for this name to be attempted for a little while.", "failedIssuanceMu", ".", "Lock", "(", ")", "\n", "failedIssuance", "[", "name", "]", "=", "time", ".", "Now", "(", ")", "\n", "go", "func", "(", "name", "string", ")", "{", "time", ".", "Sleep", "(", "5", "*", "time", ".", "Minute", ")", "\n", "failedIssuanceMu", ".", "Lock", "(", ")", "\n", "delete", "(", "failedIssuance", ",", "name", ")", "\n", "failedIssuanceMu", ".", "Unlock", "(", ")", "\n", "}", "(", "name", ")", "\n", "failedIssuanceMu", ".", "Unlock", "(", ")", "\n", "return", "Certificate", "{", "}", ",", "err", "\n", "}", "\n\n", "// Success - update counters and stuff", "atomic", ".", "AddInt32", "(", "&", "cfg", ".", "OnDemandState", ".", "ObtainedCount", ",", "1", ")", "\n", "lastIssueTimeMu", ".", "Lock", "(", ")", "\n", "lastIssueTime", "=", "time", ".", "Now", "(", ")", "\n", "lastIssueTimeMu", ".", "Unlock", "(", ")", "\n\n", "// certificate is already on disk; now just start over to load it and serve it", "return", "cg", ".", "getCertDuringHandshake", "(", "name", ",", "true", ",", "false", ")", "\n", "}" ]

[ "obtainOnDemandCertificate", "obtains", "a", "certificate", "for", "name", "for", "the", "given", "name", ".", "If", "another", "goroutine", "has", "already", "started", "obtaining", "a", "cert", "for", "name", "it", "will", "wait", "and", "use", "what", "the", "other", "goroutine", "obtained", ".", "This", "function", "is", "safe", "for", "use", "by", "multiple", "concurrent", "goroutines", "." ]

[ "func", "(", "cg", "configGroup", ")", "handshakeMaintenance", "(", "name", "string", ",", "cert", "Certificate", ")", "(", "Certificate", ",", "error", ")", "{", "// Check cert expiration", "timeLeft", ":=", "cert", ".", "NotAfter", ".", "Sub", "(", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ")", "\n", "if", "timeLeft", "<", "RenewDurationBefore", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "cert", ".", "Names", ",", "timeLeft", ")", "\n", "return", "cg", ".", "renewDynamicCertificate", "(", "name", ",", "cert", ".", "Config", ")", "\n", "}", "\n\n", "// Check OCSP staple validity", "if", "cert", ".", "OCSP", "!=", "nil", "{", "refreshTime", ":=", "cert", ".", "OCSP", ".", "ThisUpdate", ".", "Add", "(", "cert", ".", "OCSP", ".", "NextUpdate", ".", "Sub", "(", "cert", ".", "OCSP", ".", "ThisUpdate", ")", "/", "2", ")", "\n", "if", "time", ".", "Now", "(", ")", ".", "After", "(", "refreshTime", ")", "{", "err", ":=", "stapleOCSP", "(", "&", "cert", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "// An error with OCSP stapling is not the end of the world, and in fact, is", "// quite common considering not all certs have issuer URLs that support it.", "log", ".", "Printf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "certCacheMu", ".", "Lock", "(", ")", "\n", "certCache", "[", "name", "]", "=", "cert", "\n", "certCacheMu", ".", "Unlock", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "cert", ",", "nil", "\n", "}" ]

[ "handshakeMaintenance", "performs", "a", "check", "on", "cert", "for", "expiration", "and", "OCSP", "validity", ".", "This", "function", "is", "safe", "for", "use", "by", "multiple", "concurrent", "goroutines", "." ]

[ "func", "(", "cg", "configGroup", ")", "renewDynamicCertificate", "(", "name", "string", ",", "cfg", "*", "Config", ")", "(", "Certificate", ",", "error", ")", "{", "obtainCertWaitChansMu", ".", "Lock", "(", ")", "\n", "wait", ",", "ok", ":=", "obtainCertWaitChans", "[", "name", "]", "\n", "if", "ok", "{", "// lucky us -- another goroutine is already renewing the certificate.", "// wait for it to finish, then we'll use the new one.", "obtainCertWaitChansMu", ".", "Unlock", "(", ")", "\n", "<-", "wait", "\n", "return", "cg", ".", "getCertDuringHandshake", "(", "name", ",", "true", ",", "false", ")", "\n", "}", "\n\n", "// looks like it's up to us to do all the work and renew the cert", "wait", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "obtainCertWaitChans", "[", "name", "]", "=", "wait", "\n", "obtainCertWaitChansMu", ".", "Unlock", "(", ")", "\n\n", "// do the renew", "log", ".", "Printf", "(", "\"", "\"", ",", "name", ")", "\n", "err", ":=", "cfg", ".", "RenewCert", "(", "name", ",", "false", ")", "\n\n", "// immediately unblock anyone waiting for it; doing this in", "// a defer would risk deadlock because of the recursive call", "// to getCertDuringHandshake below when we return!", "obtainCertWaitChansMu", ".", "Lock", "(", ")", "\n", "close", "(", "wait", ")", "\n", "delete", "(", "obtainCertWaitChans", ",", "name", ")", "\n", "obtainCertWaitChansMu", ".", "Unlock", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "Certificate", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "cg", ".", "getCertDuringHandshake", "(", "name", ",", "true", ",", "false", ")", "\n", "}" ]

[ "renewDynamicCertificate", "renews", "the", "certificate", "for", "name", "using", "cfg", ".", "It", "returns", "the", "certificate", "to", "use", "and", "an", "error", "if", "any", ".", "currentCert", "may", "be", "returned", "even", "if", "an", "error", "occurs", "since", "we", "perform", "renewals", "before", "they", "expire", "and", "it", "may", "still", "be", "usable", ".", "name", "should", "already", "be", "lower", "-", "cased", "before", "calling", "this", "function", ".", "This", "function", "is", "safe", "for", "use", "by", "multiple", "concurrent", "goroutines", "." ]

[ "func", "NewRawClient", "(", "ifi", "*", "net", ".", "Interface", ")", "(", "*", "RawClient", ",", "error", ")", "{", "// Open raw socket to send Wake-on-LAN magic packets", "var", "cfg", "raw", ".", "Config", "\n\n", "p", ",", "err", ":=", "raw", ".", "ListenPacket", "(", "ifi", ",", "0x0806", ",", "&", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "RawClient", "{", "ifi", ":", "ifi", ",", "p", ":", "p", ",", "}", ",", "nil", "\n", "}" ]

[ "NewRawClient", "creates", "a", "new", "RawClient", "using", "the", "specified", "network", "interface", ".", "Note", "that", "raw", "sockets", "typically", "require", "elevated", "user", "privileges", "such", "as", "the", "root", "user", "on", "Linux", "or", "the", "SET_CAP_RAW", "capability", ".", "For", "this", "reason", "it", "is", "typically", "recommended", "to", "use", "the", "regular", "Client", "type", "instead", "which", "operates", "over", "UDP", "." ]

[ "func", "(", "c", "*", "RawClient", ")", "sendDHCP", "(", "target", "net", ".", "HardwareAddr", ",", "dhcp", "[", "]", "byte", ",", "dstIP", "net", ".", "IP", ",", "srcIP", "net", ".", "IP", ")", "error", "{", "proto", ":=", "17", "\n\n", "udpsrc", ":=", "uint", "(", "67", ")", "\n", "udpdst", ":=", "uint", "(", "68", ")", "\n\n", "udp", ":=", "udphdr", "{", "src", ":", "uint16", "(", "udpsrc", ")", ",", "dst", ":", "uint16", "(", "udpdst", ")", ",", "}", "\n\n", "udplen", ":=", "8", "+", "len", "(", "dhcp", ")", "\n\n", "ip", ":=", "iphdr", "{", "vhl", ":", "0x45", ",", "tos", ":", "0", ",", "id", ":", "0x0000", ",", "// the kernel overwrites id if it is zero", "off", ":", "0", ",", "ttl", ":", "128", ",", "proto", ":", "uint8", "(", "proto", ")", ",", "}", "\n", "copy", "(", "ip", ".", "src", "[", ":", "]", ",", "srcIP", ".", "To4", "(", ")", ")", "\n", "copy", "(", "ip", ".", "dst", "[", ":", "]", ",", "dstIP", ".", "To4", "(", ")", ")", "\n\n", "udp", ".", "ulen", "=", "uint16", "(", "udplen", ")", "\n", "udp", ".", "checksum", "(", "&", "ip", ",", "dhcp", ")", "\n\n", "totalLen", ":=", "20", "+", "udplen", "\n\n", "ip", ".", "iplen", "=", "uint16", "(", "totalLen", ")", "\n", "ip", ".", "checksum", "(", ")", "\n\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "[", "]", "byte", "{", "}", ")", "\n", "err", ":=", "binary", ".", "Write", "(", "buf", ",", "binary", ".", "BigEndian", ",", "&", "udp", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "udpHeader", ":=", "buf", ".", "Bytes", "(", ")", "\n", "dataWithHeader", ":=", "append", "(", "udpHeader", ",", "dhcp", "...", ")", "\n\n", "buff", ":=", "bytes", ".", "NewBuffer", "(", "[", "]", "byte", "{", "}", ")", "\n", "err", "=", "binary", ".", "Write", "(", "buff", ",", "binary", ".", "BigEndian", ",", "&", "ip", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "ipHeader", ":=", "buff", ".", "Bytes", "(", ")", "\n", "packet", ":=", "append", "(", "ipHeader", ",", "dataWithHeader", "...", ")", "\n\n", "// Create Ethernet frame", "f", ":=", "&", "ethernet", ".", "Frame", "{", "Destination", ":", "target", ",", "Source", ":", "c", ".", "ifi", ".", "HardwareAddr", ",", "EtherType", ":", "ethernet", ".", "EtherTypeIPv4", ",", "Payload", ":", "packet", ",", "}", "\n", "fb", ",", "err", ":=", "f", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Send packet to target", "_", ",", "err", "=", "c", ".", "p", ".", "WriteTo", "(", "fb", ",", "&", "raw", ".", "Addr", "{", "HardwareAddr", ":", "target", ",", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "sendDHCP", "create", "a", "udp", "packet", "and", "stores", "it", "in", "an", "Ethernet", "frame", "and", "sends", "the", "frame", "over", "a", "raw", "socket", "to", "attempt", "to", "wake", "a", "machine", "." ]

[ "func", "setupEdns0Opt", "(", "r", "*", "dns", ".", "Msg", ")", "*", "dns", ".", "OPT", "{", "o", ":=", "r", ".", "IsEdns0", "(", ")", "\n", "if", "o", "==", "nil", "{", "r", ".", "SetEdns0", "(", "4096", ",", "true", ")", "\n", "o", "=", "r", ".", "IsEdns0", "(", ")", "\n", "}", "\n", "return", "o", "\n", "}" ]

[ "setupEdns0Opt", "will", "retrieve", "the", "EDNS0", "OPT", "or", "create", "it", "if", "it", "does", "not", "exist" ]

[ "func", "(", "rule", "*", "edns0LocalRule", ")", "Rewrite", "(", "w", "dns", ".", "ResponseWriter", ",", "r", "*", "dns", ".", "Msg", ")", "Result", "{", "result", ":=", "RewriteIgnored", "\n", "o", ":=", "setupEdns0Opt", "(", "r", ")", "\n", "found", ":=", "false", "\n", "for", "_", ",", "s", ":=", "range", "o", ".", "Option", "{", "switch", "e", ":=", "s", ".", "(", "type", ")", "{", "case", "*", "dns", ".", "EDNS0_LOCAL", ":", "if", "rule", ".", "code", "==", "e", ".", "Code", "{", "if", "rule", ".", "action", "==", "Replace", "||", "rule", ".", "action", "==", "Set", "{", "e", ".", "Data", "=", "rule", ".", "data", "\n", "result", "=", "RewriteDone", "\n", "}", "\n", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// add option if not found", "if", "!", "found", "&&", "(", "rule", ".", "action", "==", "Append", "||", "rule", ".", "action", "==", "Set", ")", "{", "o", ".", "SetDo", "(", ")", "\n", "var", "opt", "dns", ".", "EDNS0_LOCAL", "\n", "opt", ".", "Code", "=", "rule", ".", "code", "\n", "opt", ".", "Data", "=", "rule", ".", "data", "\n", "o", ".", "Option", "=", "append", "(", "o", ".", "Option", ",", "&", "opt", ")", "\n", "result", "=", "RewriteDone", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "Rewrite", "will", "alter", "the", "request", "EDNS0", "local", "options" ]

[ "func", "newEdns0Rule", "(", "mode", "string", ",", "args", "...", "string", ")", "(", "Rule", ",", "error", ")", "{", "if", "len", "(", "args", ")", "<", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ruleType", ":=", "strings", ".", "ToLower", "(", "args", "[", "0", "]", ")", "\n", "action", ":=", "strings", ".", "ToLower", "(", "args", "[", "1", "]", ")", "\n", "switch", "action", "{", "case", "Append", ":", "case", "Replace", ":", "case", "Set", ":", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "action", ")", "\n", "}", "\n\n", "switch", "ruleType", "{", "case", "\"", "\"", ":", "if", "len", "(", "args", ")", "!=", "4", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "//Check for variable option", "if", "strings", ".", "HasPrefix", "(", "args", "[", "3", "]", ",", "\"", "\"", ")", "&&", "strings", ".", "HasSuffix", "(", "args", "[", "3", "]", ",", "\"", "\"", ")", "{", "return", "newEdns0VariableRule", "(", "mode", ",", "action", ",", "args", "[", "2", "]", ",", "args", "[", "3", "]", ")", "\n", "}", "\n", "return", "newEdns0LocalRule", "(", "mode", ",", "action", ",", "args", "[", "2", "]", ",", "args", "[", "3", "]", ")", "\n", "case", "\"", "\"", ":", "if", "len", "(", "args", ")", "!=", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "edns0NsidRule", "{", "mode", ":", "mode", ",", "action", ":", "action", "}", ",", "nil", "\n", "case", "\"", "\"", ":", "if", "len", "(", "args", ")", "!=", "4", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "newEdns0SubnetRule", "(", "mode", ",", "action", ",", "args", "[", "2", "]", ",", "args", "[", "3", "]", ")", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ruleType", ")", "\n", "}", "\n", "}" ]

[ "newEdns0Rule", "creates", "an", "EDNS0", "rule", "of", "the", "appropriate", "type", "based", "on", "the", "args" ]

[ "func", "newEdns0VariableRule", "(", "mode", ",", "action", ",", "code", ",", "variable", "string", ")", "(", "*", "edns0VariableRule", ",", "error", ")", "{", "c", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "code", ",", "0", ",", "16", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "//Validate", "if", "!", "isValidVariable", "(", "variable", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "variable", ")", "\n", "}", "\n", "return", "&", "edns0VariableRule", "{", "mode", ":", "mode", ",", "action", ":", "action", ",", "code", ":", "uint16", "(", "c", ")", ",", "variable", ":", "variable", "}", ",", "nil", "\n", "}" ]

[ "newEdns0VariableRule", "creates", "an", "EDNS0", "rule", "that", "handles", "variable", "substitution" ]

[ "func", "(", "rule", "*", "edns0VariableRule", ")", "ruleData", "(", "w", "dns", ".", "ResponseWriter", ",", "r", "*", "dns", ".", "Msg", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "req", ":=", "request", ".", "Request", "{", "W", ":", "w", ",", "Req", ":", "r", "}", "\n", "switch", "rule", ".", "variable", "{", "case", "queryName", ":", "//Query name is written as ascii string", "return", "[", "]", "byte", "(", "req", ".", "QName", "(", ")", ")", ",", "nil", "\n\n", "case", "queryType", ":", "return", "rule", ".", "uint16ToWire", "(", "req", ".", "QType", "(", ")", ")", ",", "nil", "\n\n", "case", "clientIP", ":", "return", "rule", ".", "ipToWire", "(", "req", ".", "Family", "(", ")", ",", "req", ".", "IP", "(", ")", ")", "\n\n", "case", "clientPort", ":", "return", "rule", ".", "portToWire", "(", "req", ".", "Port", "(", ")", ")", "\n\n", "case", "protocol", ":", "// Proto is written as ascii string", "return", "[", "]", "byte", "(", "req", ".", "Proto", "(", ")", ")", ",", "nil", "\n\n", "case", "serverIP", ":", "ip", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "w", ".", "LocalAddr", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "ip", "=", "w", ".", "RemoteAddr", "(", ")", ".", "String", "(", ")", "\n", "}", "\n", "return", "rule", ".", "ipToWire", "(", "rule", ".", "family", "(", "w", ".", "RemoteAddr", "(", ")", ")", ",", "ip", ")", "\n\n", "case", "serverPort", ":", "_", ",", "port", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "w", ".", "LocalAddr", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "port", "=", "\"", "\"", "\n", "}", "\n", "return", "rule", ".", "portToWire", "(", "port", ")", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rule", ".", "variable", ")", "\n", "}" ]

[ "ruleData", "returns", "the", "data", "specified", "by", "the", "variable" ]

[ "func", "(", "rule", "*", "edns0SubnetRule", ")", "fillEcsData", "(", "w", "dns", ".", "ResponseWriter", ",", "r", "*", "dns", ".", "Msg", ",", "ecs", "*", "dns", ".", "EDNS0_SUBNET", ")", "error", "{", "req", ":=", "request", ".", "Request", "{", "W", ":", "w", ",", "Req", ":", "r", "}", "\n", "family", ":=", "req", ".", "Family", "(", ")", "\n", "if", "(", "family", "!=", "1", ")", "&&", "(", "family", "!=", "2", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ecs", ".", "Family", "=", "uint16", "(", "family", ")", "\n", "ecs", ".", "SourceScope", "=", "0", "\n\n", "ipAddr", ":=", "req", ".", "IP", "(", ")", "\n", "switch", "family", "{", "case", "1", ":", "ipv4Mask", ":=", "net", ".", "CIDRMask", "(", "int", "(", "rule", ".", "v4BitMaskLen", ")", ",", "32", ")", "\n", "ipv4Addr", ":=", "net", ".", "ParseIP", "(", "ipAddr", ")", "\n", "ecs", ".", "SourceNetmask", "=", "rule", ".", "v4BitMaskLen", "\n", "ecs", ".", "Address", "=", "ipv4Addr", ".", "Mask", "(", "ipv4Mask", ")", ".", "To4", "(", ")", "\n", "case", "2", ":", "ipv6Mask", ":=", "net", ".", "CIDRMask", "(", "int", "(", "rule", ".", "v6BitMaskLen", ")", ",", "128", ")", "\n", "ipv6Addr", ":=", "net", ".", "ParseIP", "(", "ipAddr", ")", "\n", "ecs", ".", "SourceNetmask", "=", "rule", ".", "v6BitMaskLen", "\n", "ecs", ".", "Address", "=", "ipv6Addr", ".", "Mask", "(", "ipv6Mask", ")", ".", "To16", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "fillEcsData", "sets", "the", "subnet", "data", "into", "the", "ecs", "option" ]

[ "func", "(", "rule", "*", "edns0SubnetRule", ")", "Rewrite", "(", "w", "dns", ".", "ResponseWriter", ",", "r", "*", "dns", ".", "Msg", ")", "Result", "{", "result", ":=", "RewriteIgnored", "\n", "o", ":=", "setupEdns0Opt", "(", "r", ")", "\n", "found", ":=", "false", "\n", "for", "_", ",", "s", ":=", "range", "o", ".", "Option", "{", "switch", "e", ":=", "s", ".", "(", "type", ")", "{", "case", "*", "dns", ".", "EDNS0_SUBNET", ":", "if", "rule", ".", "action", "==", "Replace", "||", "rule", ".", "action", "==", "Set", "{", "if", "rule", ".", "fillEcsData", "(", "w", ",", "r", ",", "e", ")", "==", "nil", "{", "result", "=", "RewriteDone", "\n", "}", "\n", "}", "\n", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "// add option if not found", "if", "!", "found", "&&", "(", "rule", ".", "action", "==", "Append", "||", "rule", ".", "action", "==", "Set", ")", "{", "o", ".", "SetDo", "(", ")", "\n", "opt", ":=", "dns", ".", "EDNS0_SUBNET", "{", "Code", ":", "dns", ".", "EDNS0SUBNET", "}", "\n", "if", "rule", ".", "fillEcsData", "(", "w", ",", "r", ",", "&", "opt", ")", "==", "nil", "{", "o", ".", "Option", "=", "append", "(", "o", ".", "Option", ",", "&", "opt", ")", "\n", "result", "=", "RewriteDone", "\n", "}", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "Rewrite", "will", "alter", "the", "request", "EDNS0", "subnet", "option" ]

[ "func", "setup", "(", "c", "*", "caddy", ".", "Controller", ")", "error", "{", "ctx", ":=", "log", ".", "LoggerNewContext", "(", "context", ".", "Background", "(", ")", ")", "\n\n", "pfsso", ",", "err", ":=", "buildPfssoHandler", "(", "ctx", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Declare all pfconfig resources that will be necessary", "pfconfigdriver", ".", "PfconfigPool", ".", "AddRefreshable", "(", "ctx", ",", "&", "firewallsso", ".", "Firewalls", ")", "\n", "pfconfigdriver", ".", "PfconfigPool", ".", "AddStruct", "(", "ctx", ",", "&", "pfconfigdriver", ".", "Config", ".", "Interfaces", ".", "ManagementNetwork", ")", "\n\n", "httpserver", ".", "GetConfig", "(", "c", ")", ".", "AddMiddleware", "(", "func", "(", "next", "httpserver", ".", "Handler", ")", "httpserver", ".", "Handler", "{", "pfsso", ".", "Next", "=", "next", "\n", "return", "pfsso", "\n", "}", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Setup", "the", "pfsso", "middleware", "Also", "loads", "the", "pfconfig", "resources", "and", "registers", "them", "in", "the", "pool" ]

[ "func", "buildPfssoHandler", "(", "ctx", "context", ".", "Context", ")", "(", "PfssoHandler", ",", "error", ")", "{", "pfsso", ":=", "PfssoHandler", "{", "}", "\n\n", "pfsso", ".", "updateCache", "=", "cache", ".", "New", "(", "1", "*", "time", ".", "Hour", ",", "30", "*", "time", ".", "Second", ")", "\n\n", "router", ":=", "httprouter", ".", "New", "(", ")", "\n", "router", ".", "POST", "(", "\"", "\"", ",", "pfsso", ".", "handleUpdate", ")", "\n", "router", ".", "POST", "(", "\"", "\"", ",", "pfsso", ".", "handleStart", ")", "\n", "router", ".", "POST", "(", "\"", "\"", ",", "pfsso", ".", "handleStop", ")", "\n\n", "pfsso", ".", "router", "=", "router", "\n\n", "return", "pfsso", ",", "nil", "\n", "}" ]

[ "Build", "the", "PfssoHandler", "which", "will", "initialize", "the", "cache", "and", "instantiate", "the", "router", "along", "with", "its", "routes" ]

[ "func", "(", "h", "PfssoHandler", ")", "validateInfo", "(", "ctx", "context", ".", "Context", ",", "info", "map", "[", "string", "]", "string", ")", "error", "{", "required", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "for", "_", ",", "k", ":=", "range", "required", "{", "if", "_", ",", "ok", ":=", "info", "[", "k", "]", ";", "!", "ok", "{", "return", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ")", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "that", "all", "the", "required", "fields", "are", "there", "in", "the", "request" ]

[ "func", "(", "h", "PfssoHandler", ")", "spawnSso", "(", "ctx", "context", ".", "Context", ",", "firewall", "firewallsso", ".", "FirewallSSOInt", ",", "info", "map", "[", "string", "]", "string", ",", "f", "func", "(", "info", "map", "[", "string", "]", "string", ")", "(", "bool", ",", "error", ")", ")", "{", "// Perform a copy of the information hash before spawning the goroutine", "infoCopy", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "for", "k", ",", "v", ":=", "range", "info", "{", "infoCopy", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "go", "func", "(", ")", "{", "defer", "panichandler", ".", "Standard", "(", "ctx", ")", "\n", "sent", ",", "err", ":=", "f", "(", "infoCopy", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "PfconfigHashNS", ",", "err", ")", ")", "\n", "}", "\n\n", "if", "sent", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Debug", "(", "\"", "\"", "+", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "PfconfigHashNS", ")", "\n", "}", "else", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Debug", "(", "\"", "\"", "+", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "PfconfigHashNS", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "Spawn", "an", "async", "SSO", "request", "for", "a", "specific", "firewall" ]

[ "func", "(", "h", "PfssoHandler", ")", "addInfoToContext", "(", "ctx", "context", ".", "Context", ",", "info", "map", "[", "string", "]", "string", ")", "context", ".", "Context", "{", "return", "log", ".", "AddToLogContext", "(", "ctx", ",", "\"", "\"", ",", "info", "[", "\"", "\"", "]", ",", "\"", "\"", ",", "info", "[", "\"", "\"", "]", ",", "\"", "\"", ",", "info", "[", "\"", "\"", "]", ",", "\"", "\"", ",", "info", "[", "\"", "\"", "]", ")", "\n", "}" ]

[ "Add", "the", "info", "in", "the", "request", "to", "the", "log", "context" ]

[ "func", "(", "h", "PfssoHandler", ")", "handleUpdate", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ",", "p", "httprouter", ".", "Params", ")", "{", "ctx", ":=", "r", ".", "Context", "(", ")", "\n", "defer", "statsd", ".", "NewStatsDTiming", "(", "ctx", ")", ".", "Send", "(", "\"", "\"", ")", "\n\n", "info", ",", "timeout", ",", "err", ":=", "h", ".", "parseSsoRequest", "(", "ctx", ",", "r", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprint", "(", "err", ")", ",", "http", ".", "StatusBadRequest", ")", "\n", "return", "\n", "}", "\n\n", "ctx", "=", "h", ".", "addInfoToContext", "(", "ctx", ",", "info", ")", "\n\n", "var", "shouldStart", "bool", "\n", "for", "_", ",", "firewall", ":=", "range", "firewallsso", ".", "Firewalls", ".", "Structs", "{", "cacheKey", ":=", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "PfconfigHashNS", "+", "\"", "\"", "+", "info", "[", "\"", "\"", "]", "+", "\"", "\"", "+", "info", "[", "\"", "\"", "]", "+", "\"", "\"", "+", "info", "[", "\"", "\"", "]", "\n", "// Check whether or not this firewall has cache updates", "// Then check if an entry in the cache exists", "// If it does exist, we don't send a Start", "// Otherwise, we add an entry in the cache", "// Note that this has a race condition between the cache.Get and the cache.Set but it is acceptable since worst case will be that 2 SSO will be sent if both requests came in at that same nanosecond", "if", "firewall", ".", "ShouldCacheUpdates", "(", "ctx", ")", "{", "if", "_", ",", "found", ":=", "h", ".", "updateCache", ".", "Get", "(", "cacheKey", ")", ";", "!", "found", "{", "var", "cacheTimeout", "int", "\n", "if", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "GetCacheTimeout", "(", "ctx", ")", "!=", "0", "{", "cacheTimeout", "=", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "GetCacheTimeout", "(", "ctx", ")", "\n", "}", "else", "if", "timeout", "!=", "0", "{", "cacheTimeout", "=", "timeout", "/", "2", "\n", "}", "else", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "cacheTimeout", "!=", "0", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Debug", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cacheTimeout", ")", ")", "\n", "h", ".", "updateCache", ".", "Set", "(", "cacheKey", ",", "1", ",", "time", ".", "Duration", "(", "cacheTimeout", ")", "*", "time", ".", "Second", ")", "\n", "}", "\n\n", "shouldStart", "=", "true", "\n", "}", "\n", "}", "else", "{", "shouldStart", "=", "true", "\n", "}", "\n\n", "if", "shouldStart", "{", "//Creating a shallow copy here so the anonymous function has the right reference", "firewall", ":=", "firewall", "\n", "h", ".", "spawnSso", "(", "ctx", ",", "firewall", ",", "info", ",", "func", "(", "info", "map", "[", "string", "]", "string", ")", "(", "bool", ",", "error", ")", "{", "return", "firewallsso", ".", "ExecuteStart", "(", "ctx", ",", "firewall", ",", "info", ",", "timeout", ")", "\n", "}", ")", "\n", "}", "else", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "}", "\n\n", "w", ".", "WriteHeader", "(", "http", ".", "StatusAccepted", ")", "\n", "}" ]

[ "Handle", "an", "update", "action", "for", "pfsso", "If", "the", "firewall", "has", "cached", "updates", "enabled", "it", "will", "handle", "it", "here", "The", "cache", "is", "in", "-", "memory", "so", "that", "means", "that", "a", "restart", "of", "the", "process", "will", "clear", "the", "cached", "updates", "cache" ]

[ "func", "(", "h", "PfssoHandler", ")", "handleStop", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ",", "p", "httprouter", ".", "Params", ")", "{", "ctx", ":=", "r", ".", "Context", "(", ")", "\n", "defer", "statsd", ".", "NewStatsDTiming", "(", "ctx", ")", ".", "Send", "(", "\"", "\"", ")", "\n\n", "info", ",", "_", ",", "err", ":=", "h", ".", "parseSsoRequest", "(", "ctx", ",", "r", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "http", ".", "Error", "(", "w", ",", "fmt", ".", "Sprint", "(", "err", ")", ",", "http", ".", "StatusBadRequest", ")", "\n", "return", "\n", "}", "\n\n", "ctx", "=", "h", ".", "addInfoToContext", "(", "ctx", ",", "info", ")", "\n\n", "for", "_", ",", "firewall", ":=", "range", "firewallsso", ".", "Firewalls", ".", "Structs", "{", "//Creating a shallow copy here so the anonymous function has the right reference", "firewall", ":=", "firewall", "\n", "h", ".", "spawnSso", "(", "ctx", ",", "firewall", ",", "info", ",", "func", "(", "info", "map", "[", "string", "]", "string", ")", "(", "bool", ",", "error", ")", "{", "return", "firewallsso", ".", "ExecuteStop", "(", "ctx", ",", "firewall", ",", "info", ")", "\n", "}", ")", "\n", "}", "\n\n", "w", ".", "WriteHeader", "(", "http", ".", "StatusAccepted", ")", "\n", "}" ]

[ "Handle", "an", "SSO", "stop" ]

[ "func", "a", "(", "zone", "string", ",", "ips", "[", "]", "net", ".", "IP", ")", "[", "]", "dns", ".", "RR", "{", "answers", ":=", "[", "]", "dns", ".", "RR", "{", "}", "\n", "for", "_", ",", "ip", ":=", "range", "ips", "{", "r", ":=", "new", "(", "dns", ".", "A", ")", "\n", "r", ".", "Hdr", "=", "dns", ".", "RR_Header", "{", "Name", ":", "zone", ",", "Rrtype", ":", "dns", ".", "TypeA", ",", "Class", ":", "dns", ".", "ClassINET", ",", "Ttl", ":", "3600", "}", "\n", "r", ".", "A", "=", "ip", "\n", "answers", "=", "append", "(", "answers", ",", "r", ")", "\n", "}", "\n", "return", "answers", "\n", "}" ]

[ "a", "takes", "a", "slice", "of", "net", ".", "IPs", "and", "returns", "a", "slice", "of", "A", "RRs", "." ]

[ "func", "NewFileStorage", "(", "caURL", "*", "url", ".", "URL", ")", "(", "Storage", ",", "error", ")", "{", "return", "&", "FileStorage", "{", "Path", ":", "filepath", ".", "Join", "(", "storageBasePath", ",", "caURL", ".", "Host", ")", ",", "nameLocks", ":", "make", "(", "map", "[", "string", "]", "*", "sync", ".", "WaitGroup", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewFileStorage", "is", "a", "StorageConstructor", "function", "that", "creates", "a", "new", "Storage", "instance", "backed", "by", "the", "local", "disk", ".", "The", "resulting", "Storage", "instance", "is", "guaranteed", "to", "be", "non", "-", "nil", "if", "there", "is", "no", "error", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "site", "(", "domain", "string", ")", "string", "{", "domain", "=", "strings", ".", "ToLower", "(", "domain", ")", "\n", "return", "filepath", ".", "Join", "(", "s", ".", "sites", "(", ")", ",", "domain", ")", "\n", "}" ]

[ "site", "returns", "the", "path", "to", "the", "folder", "containing", "assets", "for", "domain", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "user", "(", "email", "string", ")", "string", "{", "if", "email", "==", "\"", "\"", "{", "email", "=", "emptyEmail", "\n", "}", "\n", "email", "=", "strings", ".", "ToLower", "(", "email", ")", "\n", "return", "filepath", ".", "Join", "(", "s", ".", "users", "(", ")", ",", "email", ")", "\n", "}" ]

[ "user", "gets", "the", "account", "folder", "for", "the", "user", "with", "email" ]

[ "func", "emailUsername", "(", "email", "string", ")", "string", "{", "at", ":=", "strings", ".", "Index", "(", "email", ",", "\"", "\"", ")", "\n", "if", "at", "==", "-", "1", "{", "return", "email", "\n", "}", "else", "if", "at", "==", "0", "{", "return", "email", "[", "1", ":", "]", "\n", "}", "\n", "return", "email", "[", ":", "at", "]", "\n", "}" ]

[ "emailUsername", "returns", "the", "username", "portion", "of", "an", "email", "address", "(", "part", "before" ]

[ "func", "(", "s", "*", "FileStorage", ")", "userRegFile", "(", "email", "string", ")", "string", "{", "if", "email", "==", "\"", "\"", "{", "email", "=", "emptyEmail", "\n", "}", "\n", "email", "=", "strings", ".", "ToLower", "(", "email", ")", "\n", "fileName", ":=", "emailUsername", "(", "email", ")", "\n", "if", "fileName", "==", "\"", "\"", "{", "fileName", "=", "\"", "\"", "\n", "}", "\n", "return", "filepath", ".", "Join", "(", "s", ".", "user", "(", "email", ")", ",", "fileName", "+", "\"", "\"", ")", "\n", "}" ]

[ "userRegFile", "gets", "the", "path", "to", "the", "registration", "file", "for", "the", "user", "with", "the", "given", "email", "address", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "readFile", "(", "file", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "file", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "ErrNotExist", "(", "err", ")", "\n", "}", "\n", "return", "b", ",", "err", "\n", "}" ]

[ "readFile", "abstracts", "a", "simple", "ioutil", ".", "ReadFile", "making", "sure", "to", "return", "an", "ErrNotExist", "instance", "when", "the", "file", "is", "not", "found", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "SiteExists", "(", "domain", "string", ")", "(", "bool", ",", "error", ")", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "s", ".", "siteCertFile", "(", "domain", ")", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "false", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "os", ".", "Stat", "(", "s", ".", "siteKeyFile", "(", "domain", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "SiteExists", "implements", "Storage", ".", "SiteExists", "by", "checking", "for", "the", "presence", "of", "cert", "and", "key", "files", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "LoadSite", "(", "domain", "string", ")", "(", "*", "SiteData", ",", "error", ")", "{", "var", "err", "error", "\n", "siteData", ":=", "new", "(", "SiteData", ")", "\n", "siteData", ".", "Cert", ",", "err", "=", "s", ".", "readFile", "(", "s", ".", "siteCertFile", "(", "domain", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "siteData", ".", "Key", ",", "err", "=", "s", ".", "readFile", "(", "s", ".", "siteKeyFile", "(", "domain", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "siteData", ".", "Meta", ",", "err", "=", "s", ".", "readFile", "(", "s", ".", "siteMetaFile", "(", "domain", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "siteData", ",", "nil", "\n", "}" ]

[ "LoadSite", "implements", "Storage", ".", "LoadSite", "by", "loading", "it", "from", "disk", ".", "If", "it", "is", "not", "present", "an", "instance", "of", "ErrNotExist", "is", "returned", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "StoreSite", "(", "domain", "string", ",", "data", "*", "SiteData", ")", "error", "{", "err", ":=", "os", ".", "MkdirAll", "(", "s", ".", "site", "(", "domain", ")", ",", "0700", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "s", ".", "siteCertFile", "(", "domain", ")", ",", "data", ".", "Cert", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "s", ".", "siteKeyFile", "(", "domain", ")", ",", "data", ".", "Key", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "s", ".", "siteMetaFile", "(", "domain", ")", ",", "data", ".", "Meta", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "StoreSite", "implements", "Storage", ".", "StoreSite", "by", "writing", "it", "to", "disk", ".", "The", "base", "directories", "needed", "for", "the", "file", "are", "automatically", "created", "as", "needed", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "DeleteSite", "(", "domain", "string", ")", "error", "{", "err", ":=", "os", ".", "Remove", "(", "s", ".", "siteCertFile", "(", "domain", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "ErrNotExist", "(", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteSite", "implements", "Storage", ".", "DeleteSite", "by", "deleting", "just", "the", "cert", "from", "disk", ".", "If", "it", "is", "not", "present", "an", "instance", "of", "ErrNotExist", "is", "returned", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "LoadUser", "(", "email", "string", ")", "(", "*", "UserData", ",", "error", ")", "{", "var", "err", "error", "\n", "userData", ":=", "new", "(", "UserData", ")", "\n", "userData", ".", "Reg", ",", "err", "=", "s", ".", "readFile", "(", "s", ".", "userRegFile", "(", "email", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "userData", ".", "Key", ",", "err", "=", "s", ".", "readFile", "(", "s", ".", "userKeyFile", "(", "email", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "userData", ",", "nil", "\n", "}" ]

[ "LoadUser", "implements", "Storage", ".", "LoadUser", "by", "loading", "it", "from", "disk", ".", "If", "it", "is", "not", "present", "an", "instance", "of", "ErrNotExist", "is", "returned", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "StoreUser", "(", "email", "string", ",", "data", "*", "UserData", ")", "error", "{", "err", ":=", "os", ".", "MkdirAll", "(", "s", ".", "user", "(", "email", ")", ",", "0700", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "s", ".", "userRegFile", "(", "email", ")", ",", "data", ".", "Reg", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "s", ".", "userKeyFile", "(", "email", ")", ",", "data", ".", "Key", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "StoreUser", "implements", "Storage", ".", "StoreUser", "by", "writing", "it", "to", "disk", ".", "The", "base", "directories", "needed", "for", "the", "file", "are", "automatically", "created", "as", "needed", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "TryLock", "(", "name", "string", ")", "(", "Waiter", ",", "error", ")", "{", "s", ".", "nameLocksMu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "nameLocksMu", ".", "Unlock", "(", ")", "\n", "wg", ",", "ok", ":=", "s", ".", "nameLocks", "[", "name", "]", "\n", "if", "ok", "{", "// lock already obtained, let caller wait on it", "return", "wg", ",", "nil", "\n", "}", "\n", "// caller gets lock", "wg", "=", "new", "(", "sync", ".", "WaitGroup", ")", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "s", ".", "nameLocks", "[", "name", "]", "=", "wg", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "TryLock", "attempts", "to", "get", "a", "lock", "for", "name", "otherwise", "it", "returns", "a", "Waiter", "value", "to", "wait", "until", "the", "other", "process", "is", "finished", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "Unlock", "(", "name", "string", ")", "error", "{", "s", ".", "nameLocksMu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "nameLocksMu", ".", "Unlock", "(", ")", "\n", "wg", ",", "ok", ":=", "s", ".", "nameLocks", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "wg", ".", "Done", "(", ")", "\n", "delete", "(", "s", ".", "nameLocks", ",", "name", ")", "\n", "return", "nil", "\n", "}" ]

[ "Unlock", "unlocks", "name", "." ]

[ "func", "(", "s", "*", "FileStorage", ")", "MostRecentUserEmail", "(", ")", "string", "{", "userDirs", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "s", ".", "users", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "var", "mostRecent", "os", ".", "FileInfo", "\n", "for", "_", ",", "dir", ":=", "range", "userDirs", "{", "if", "!", "dir", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n", "if", "mostRecent", "==", "nil", "||", "dir", ".", "ModTime", "(", ")", ".", "After", "(", "mostRecent", ".", "ModTime", "(", ")", ")", "{", "mostRecent", "=", "dir", "\n", "}", "\n", "}", "\n", "if", "mostRecent", "!=", "nil", "{", "return", "mostRecent", ".", "Name", "(", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "MostRecentUserEmail", "implements", "Storage", ".", "MostRecentUserEmail", "by", "finding", "the", "most", "recently", "written", "sub", "directory", "in", "the", "users", "directory", ".", "It", "is", "named", "after", "the", "email", "address", ".", "This", "corresponds", "to", "the", "most", "recent", "call", "to", "StoreUser", "." ]

[ "func", "setup", "(", "c", "*", "caddy", ".", "Controller", ")", "error", "{", "ctx", ":=", "log", ".", "LoggerNewContext", "(", "context", ".", "Background", "(", ")", ")", "\n\n", "pfconfigdriver", ".", "PfconfigPool", ".", "AddStruct", "(", "ctx", ",", "&", "pfconfigdriver", ".", "Config", ".", "Cluster", ".", "HostsIp", ")", "\n\n", "pfipset", ",", "err", ":=", "buildPfipsetHandler", "(", "ctx", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "httpserver", ".", "GetConfig", "(", "c", ")", ".", "AddMiddleware", "(", "func", "(", "next", "httpserver", ".", "Handler", ")", "httpserver", ".", "Handler", "{", "pfipset", ".", "Next", "=", "next", "\n", "return", "pfipset", "\n", "}", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Setup", "the", "pfipset", "middleware", "Also", "loads", "the", "pfconfig", "resources", "and", "registers", "them", "in", "the", "pool" ]

[ "func", "resourceExists", "(", "root", ",", "path", "string", ")", "bool", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "root", "+", "path", ")", "\n", "// technically we should use os.IsNotExist(err)", "// but we don't handle any other kinds of errors anyway", "return", "err", "==", "nil", "\n", "}" ]

[ "resourceExists", "returns", "true", "if", "the", "file", "specified", "at", "root", "+", "path", "exists", ";", "false", "otherwise", "." ]

[ "func", "(", "f", "*", "FirewallsContainer", ")", "Refresh", "(", "ctx", "context", ".", "Context", ")", "{", "reload", ":=", "false", "\n\n", "f", ".", "ids", ".", "PfconfigNS", "=", "\"", "\"", "\n\n", "// If ids changed, we want to reload", "if", "!", "pfconfigdriver", ".", "IsValid", "(", "ctx", ",", "&", "f", ".", "ids", ")", "{", "reload", "=", "true", "\n", "}", "\n\n", "pfconfigdriver", ".", "FetchDecodeSocketCache", "(", "ctx", ",", "&", "f", ".", "ids", ")", "\n\n", "fssoFactory", ":=", "NewFactory", "(", "ctx", ")", "\n\n", "if", "f", ".", "Structs", "!=", "nil", "{", "for", "_", ",", "firewallId", ":=", "range", "f", ".", "ids", ".", "Keys", "{", "firewall", ",", "ok", ":=", "f", ".", "Structs", "[", "firewallId", "]", "\n\n", "if", "!", "ok", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "reload", "=", "true", "\n", "break", "\n", "}", "\n\n", "if", "!", "pfconfigdriver", ".", "IsValid", "(", "ctx", ",", "firewall", ")", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Info", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "firewallId", ")", ")", "\n", "reload", "=", "true", "\n", "}", "\n", "}", "\n", "}", "else", "{", "reload", "=", "true", "\n", "}", "\n\n", "if", "reload", "{", "newFirewalls", ":=", "make", "(", "map", "[", "string", "]", "FirewallSSOInt", ")", "\n\n", "for", "_", ",", "firewallId", ":=", "range", "f", ".", "ids", ".", "Keys", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Info", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "firewallId", ")", ")", "\n\n", "firewall", ",", "err", ":=", "fssoFactory", ".", "Instantiate", "(", "ctx", ",", "firewallId", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "firewallId", ",", "err", ")", ")", "\n", "}", "else", "{", "newFirewalls", "[", "firewall", ".", "GetFirewallSSO", "(", "ctx", ")", ".", "PfconfigHashNS", "]", "=", "firewall", "\n", "}", "\n", "}", "\n", "f", ".", "Structs", "=", "newFirewalls", "\n", "}", "\n", "}" ]

[ "Refresh", "the", "FirewallsContainer", "struct", "Will", "first", "check", "if", "the", "IDs", "have", "changed", "in", "pfconfig", "and", "reload", "if", "they", "did", "Then", "it", "will", "check", "if", "all", "the", "IDs", "in", "pfconfig", "are", "loaded", "and", "valid", "and", "reload", "otherwise" ]

[ "func", "getPfconfigSocketPath", "(", ")", "string", "{", "if", "pfconfigSocketPathCache", "!=", "\"", "\"", "{", "// Do nothing, cache is populated, will be returned below", "}", "else", "if", "sharedutils", ".", "EnvOrDefault", "(", "\"", "\"", ",", "\"", "\"", ")", "==", "\"", "\"", "{", "pfconfigSocketPathCache", "=", "pfconfigSocketPath", "\n", "}", "else", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "pfconfigSocketPathCache", "=", "pfconfigTestSocketPath", "\n", "}", "\n", "return", "pfconfigSocketPathCache", "\n", "}" ]

[ "Get", "the", "pfconfig", "socket", "path", "depending", "on", "whether", "or", "not", "we", "re", "in", "testing", "Since", "the", "environment", "is", "not", "bound", "to", "change", "at", "runtime", "the", "socket", "path", "is", "computed", "once", "and", "cached", "in", "pfconfigSocketPathCache", "If", "the", "socket", "should", "be", "re", "-", "computed", "empty", "out", "pfconfigSocketPathCache", "and", "run", "this", "function" ]

[ "func", "(", "q", "*", "Query", ")", "GetPayload", "(", ")", "string", "{", "j", ",", "err", ":=", "json", ".", "Marshal", "(", "struct", "{", "Encoding", "string", "`json:\"encoding\"`", "\n", "Method", "string", "`json:\"method\"`", "\n", "NS", "string", "`json:\"key\"`", "\n", "}", "{", "Encoding", ":", "q", ".", "encoding", ",", "Method", ":", "q", ".", "method", ",", "NS", ":", "q", ".", "ns", ",", "}", ")", "\n", "sharedutils", ".", "CheckError", "(", "err", ")", "\n", "return", "string", "(", "j", ")", "+", "\"", "\\n", "\"", "\n", "}" ]

[ "Get", "the", "payload", "to", "send", "to", "pfconfig", "based", "on", "the", "Query", "attributes", "Also", "sets", "the", "payload", "attribute", "at", "the", "same", "time" ]

[ "func", "(", "q", "*", "Query", ")", "GetIdentifier", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "q", ".", "method", ",", "q", ".", "ns", ")", "\n", "}" ]

[ "Get", "a", "string", "identifier", "of", "the", "query" ]

[ "func", "connectSocket", "(", "ctx", "context", ".", "Context", ")", "net", ".", "Conn", "{", "timeoutChan", ":=", "time", ".", "After", "(", "SocketTimeout", ")", "\n\n", "var", "c", "net", ".", "Conn", "\n", "err", ":=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "for", "err", "!=", "nil", "{", "select", "{", "case", "<-", "timeoutChan", ":", "panic", "(", "\"", "\"", ")", "\n", "default", ":", "// We try to connect to the pfconfig socket", "// If we fail, we will wait a second before leaving this scope", "// Otherwise, we continue and the for loop will detect the connection is valid since err will be nil", "c", ",", "err", "=", "net", ".", "Dial", "(", "\"", "\"", ",", "getPfconfigSocketPath", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "LoggerWContext", "(", "ctx", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "time", ".", "Sleep", "(", "1", "*", "time", ".", "Second", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "c", "\n", "}" ]

[ "Connect", "to", "the", "pfconfig", "socket", "If", "it", "fails", "to", "connect", "it", "will", "try", "it", "every", "second", "up", "to", "the", "time", "defined", "in", "SocketTimeout", "After", "SocketTimeout", "is", "reached", "this", "will", "panic" ]

[ "func", "FetchSocket", "(", "ctx", "context", ".", "Context", ",", "payload", "string", ")", "[", "]", "byte", "{", "c", ":=", "connectSocket", "(", "ctx", ")", "\n\n", "// Send our query in the socket", "fmt", ".", "Fprintf", "(", "c", ",", "payload", ")", "\n\n", "var", "buf", "bytes", ".", "Buffer", "\n", "buf", ".", "ReadFrom", "(", "c", ")", "\n\n", "// First 4 bytes are a little-endian representing the length of the payload", "var", "length", "uint32", "\n", "binary", ".", "Read", "(", "&", "buf", ",", "binary", ".", "LittleEndian", ",", "&", "length", ")", "\n\n", "// Read the response given the length provided by pfconfig", "response", ":=", "make", "(", "[", "]", "byte", ",", "length", ")", "\n", "buf", ".", "Read", "(", "response", ")", "\n\n", "// Validate the response has the length that was declared by pfconfig", "if", "uint32", "(", "len", "(", "response", ")", ")", "!=", "length", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "length", ",", "len", "(", "response", ")", ")", ")", "\n", "}", "\n", "c", ".", "Close", "(", ")", "\n", "return", "response", "\n", "}" ]

[ "Fetch", "data", "from", "the", "pfconfig", "socket", "for", "a", "string", "payload", "Returns", "the", "bytes", "received", "from", "the", "socket" ]

[ "func", "metadataFromField", "(", "ctx", "context", ".", "Context", ",", "param", "interface", "{", "}", ",", "fieldName", "string", ")", "string", "{", "var", "ov", "reflect", ".", "Value", "\n\n", "ov", "=", "reflect", ".", "ValueOf", "(", "param", ")", "\n", "for", "ov", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "||", "ov", ".", "Kind", "(", ")", "==", "reflect", ".", "Interface", "{", "ov", "=", "ov", ".", "Elem", "(", ")", "\n", "}", "\n\n", "// We check if the field was set to a value as this will overide the value in the tag", "// At the same time, we check if the field exists and early exit with the empty string if it doesn't", "field", ":=", "reflect", ".", "Value", "(", "ov", ".", "FieldByName", "(", "fieldName", ")", ")", "\n", "if", "!", "field", ".", "IsValid", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n\n", "userVal", ":=", "field", ".", "Interface", "(", ")", "\n", "if", "userVal", "!=", "\"", "\"", "{", "return", "userVal", ".", "(", "string", ")", "\n", "}", "\n\n", "ot", ":=", "ov", ".", "Type", "(", ")", "\n", "if", "field", ",", "ok", ":=", "ot", ".", "FieldByName", "(", "fieldName", ")", ";", "ok", "{", "// The val tag defines the «default» value the metadata field should have", "// If the val tag has a value of \"-\", then a user value was expected and this will panic", "val", ":=", "field", ".", "Tag", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "val", "!=", "\"", "\"", "{", "return", "val", "\n", "}", "else", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ",", "ot", ".", "String", "(", ")", ")", ")", "\n", "}", "\n", "}", "else", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fieldName", ",", "ot", ".", "String", "(", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "Lookup", "the", "pfconfig", "metadata", "for", "a", "specific", "field", "If", "there", "is", "a", "non", "-", "zero", "value", "in", "the", "field", "it", "will", "be", "taken", "Otherwise", "it", "will", "take", "the", "value", "in", "the", "val", "tag", "of", "the", "field" ]

[ "func", "decodeInterface", "(", "ctx", "context", ".", "Context", ",", "encoding", "string", ",", "b", "[", "]", "byte", ",", "o", "interface", "{", "}", ")", "{", "switch", "encoding", "{", "case", "\"", "\"", ":", "decodeJsonInterface", "(", "ctx", ",", "b", ",", "o", ")", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "encoding", ")", ")", "\n", "}", "\n", "}" ]

[ "Decode", "the", "struct", "from", "bytes", "given", "an", "encoding", "For", "now", "only", "JSON", "is", "supported" ]

[ "func", "decodeJsonInterface", "(", "ctx", "context", ".", "Context", ",", "b", "[", "]", "byte", ",", "o", "interface", "{", "}", ")", "{", "decoder", ":=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "b", ")", ")", "\n", "for", "{", "if", "err", ":=", "decoder", ".", "Decode", "(", "&", "o", ")", ";", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "else", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Decode", "an", "array", "of", "bytes", "representing", "a", "json", "string", "into", "interface", "Panics", "if", "there", "is", "an", "error", "decoding", "the", "JSON", "data" ]

[ "func", "FetchDecodeSocketCache", "(", "ctx", "context", ".", "Context", ",", "o", "PfconfigObject", ")", "(", "bool", ",", "error", ")", "{", "query", ":=", "createQuery", "(", "ctx", ",", "o", ")", "\n", "ctx", "=", "log", ".", "AddToLogContext", "(", "ctx", ",", "\"", "\"", ",", "query", ".", "GetIdentifier", "(", ")", ")", "\n\n", "// If the resource is still valid and is already loaded", "if", "IsValid", "(", "ctx", ",", "o", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "err", ":=", "FetchDecodeSocket", "(", "ctx", ",", "o", ")", "\n", "return", "true", ",", "err", "\n", "}" ]

[ "Fetch", "and", "decode", "from", "the", "socket", "but", "only", "if", "the", "PfconfigObject", "is", "not", "valid", "anymore" ]

[ "func", "FetchKeys", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "keys", ":=", "PfconfigKeys", "{", "PfconfigNS", ":", "name", "}", "\n", "err", ":=", "FetchDecodeSocket", "(", "ctx", ",", "&", "keys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "keys", ".", "Keys", ",", "nil", "\n", "}" ]

[ "Fetch", "the", "keys", "of", "a", "namespace" ]

[ "func", "FetchDecodeSocket", "(", "ctx", "context", ".", "Context", ",", "o", "PfconfigObject", ")", "error", "{", "ptrT", ":=", "reflect", ".", "TypeOf", "(", "o", ")", "\n", "new", ":=", "reflect", ".", "New", "(", "ptrT", ".", "Elem", "(", ")", ")", "\n", "newo", ":=", "new", ".", "Interface", "(", ")", ".", "(", "PfconfigObject", ")", "\n\n", "transferMetadata", "(", "ctx", ",", "&", "o", ",", "&", "newo", ")", "\n\n", "reflect", ".", "ValueOf", "(", "o", ")", ".", "Elem", "(", ")", ".", "Set", "(", "reflect", ".", "ValueOf", "(", "newo", ")", ".", "Elem", "(", ")", ")", "\n\n", "query", ":=", "createQuery", "(", "ctx", ",", "o", ")", "\n\n", "jsonResponse", ":=", "FetchSocket", "(", "ctx", ",", "query", ".", "GetPayload", "(", ")", ")", "\n\n", "if", "query", ".", "method", "==", "\"", "\"", "{", "if", "cs", ",", "ok", ":=", "o", ".", "(", "PfconfigKeysInt", ")", ";", "ok", "{", "decodeInterface", "(", "ctx", ",", "query", ".", "encoding", ",", "jsonResponse", ",", "cs", ".", "GetKeys", "(", ")", ")", "\n", "}", "else", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "if", "metadataFromField", "(", "ctx", ",", "o", ",", "\"", "\"", ")", "==", "\"", "\"", "||", "metadataFromField", "(", "ctx", ",", "o", ",", "\"", "\"", ")", "==", "\"", "\"", "{", "decodeInterface", "(", "ctx", ",", "query", ".", "encoding", ",", "jsonResponse", ",", "&", "o", ")", "\n", "}", "else", "{", "receiver", ":=", "&", "PfconfigElementResponse", "{", "}", "\n", "decodeInterface", "(", "ctx", ",", "query", ".", "encoding", ",", "jsonResponse", ",", "receiver", ")", "\n", "if", "receiver", ".", "Element", "!=", "nil", "{", "b", ",", "_", ":=", "receiver", ".", "Element", ".", "MarshalJSON", "(", ")", "\n", "decodeInterface", "(", "ctx", ",", "query", ".", "encoding", ",", "b", ",", "&", "o", ")", "\n", "}", "else", "{", "return", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "jsonResponse", ")", ")", "\n", "}", "\n", "}", "\n\n", "o", ".", "SetLoadedAt", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Fetch", "and", "decode", "a", "namespace", "from", "pfconfig", "given", "a", "pfconfig", "compatible", "struct", "This", "will", "fetch", "the", "json", "representation", "from", "pfconfig", "and", "decode", "it", "into", "o", "o", "must", "be", "a", "pointer", "to", "the", "struct", "as", "this", "should", "be", "used", "by", "reference" ]

[ "func", "AAAA", "(", "b", "ServiceBackend", ",", "zone", "string", ",", "state", "request", ".", "Request", ",", "previousRecords", "[", "]", "dns", ".", "RR", ",", "opt", "Options", ")", "(", "records", "[", "]", "dns", ".", "RR", ",", "err", "error", ")", "{", "services", ",", "err", ":=", "b", ".", "Services", "(", "state", ",", "false", ",", "opt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "serv", ":=", "range", "services", "{", "what", ",", "ip", ":=", "serv", ".", "HostType", "(", ")", "\n\n", "switch", "what", "{", "case", "dns", ".", "TypeCNAME", ":", "// Try to resolve as CNAME if it's not an IP, but only if we don't create loops.", "if", "Name", "(", "state", ".", "Name", "(", ")", ")", ".", "Matches", "(", "dns", ".", "Fqdn", "(", "serv", ".", "Host", ")", ")", "{", "// x CNAME x is a direct loop, don't add those", "continue", "\n", "}", "\n\n", "newRecord", ":=", "serv", ".", "NewCNAME", "(", "state", ".", "QName", "(", ")", ",", "serv", ".", "Host", ")", "\n", "if", "len", "(", "previousRecords", ")", ">", "7", "{", "// don't add it, and just continue", "continue", "\n", "}", "\n", "if", "dnsutil", ".", "DuplicateCNAME", "(", "newRecord", ",", "previousRecords", ")", "{", "continue", "\n", "}", "\n\n", "state1", ":=", "state", ".", "NewWithQuestion", "(", "serv", ".", "Host", ",", "state", ".", "QType", "(", ")", ")", "\n", "nextRecords", ",", "err", ":=", "AAAA", "(", "b", ",", "zone", ",", "state1", ",", "append", "(", "previousRecords", ",", "newRecord", ")", ",", "opt", ")", "\n\n", "if", "err", "==", "nil", "{", "// Not only have we found something we should add the CNAME and the IP addresses.", "if", "len", "(", "nextRecords", ")", ">", "0", "{", "records", "=", "append", "(", "records", ",", "newRecord", ")", "\n", "records", "=", "append", "(", "records", ",", "nextRecords", "...", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "// This means we can not complete the CNAME, try to look else where.", "target", ":=", "newRecord", ".", "Target", "\n", "if", "dns", ".", "IsSubDomain", "(", "zone", ",", "target", ")", "{", "// We should already have found it", "continue", "\n", "}", "\n", "m1", ",", "e1", ":=", "b", ".", "Lookup", "(", "state", ",", "target", ",", "state", ".", "QType", "(", ")", ")", "\n", "if", "e1", "!=", "nil", "{", "continue", "\n", "}", "\n", "// Len(m1.Answer) > 0 here is well?", "records", "=", "append", "(", "records", ",", "newRecord", ")", "\n", "records", "=", "append", "(", "records", ",", "m1", ".", "Answer", "...", ")", "\n", "continue", "\n", "// both here again", "case", "dns", ".", "TypeA", ":", "// nada?", "case", "dns", ".", "TypeAAAA", ":", "records", "=", "append", "(", "records", ",", "serv", ".", "NewAAAA", "(", "state", ".", "QName", "(", ")", ",", "ip", ")", ")", "\n", "}", "\n", "}", "\n", "return", "records", ",", "nil", "\n", "}" ]

[ "AAAA", "returns", "AAAA", "records", "from", "Backend", "or", "an", "error", "." ]

[ "func", "MX", "(", "b", "ServiceBackend", ",", "zone", "string", ",", "state", "request", ".", "Request", ",", "opt", "Options", ")", "(", "records", ",", "extra", "[", "]", "dns", ".", "RR", ",", "err", "error", ")", "{", "services", ",", "err", ":=", "b", ".", "Services", "(", "state", ",", "false", ",", "opt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "lookup", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "for", "_", ",", "serv", ":=", "range", "services", "{", "if", "!", "serv", ".", "Mail", "{", "continue", "\n", "}", "\n", "what", ",", "ip", ":=", "serv", ".", "HostType", "(", ")", "\n", "switch", "what", "{", "case", "dns", ".", "TypeCNAME", ":", "mx", ":=", "serv", ".", "NewMX", "(", "state", ".", "QName", "(", ")", ")", "\n", "records", "=", "append", "(", "records", ",", "mx", ")", "\n", "if", "_", ",", "ok", ":=", "lookup", "[", "mx", ".", "Mx", "]", ";", "ok", "{", "break", "\n", "}", "\n\n", "lookup", "[", "mx", ".", "Mx", "]", "=", "true", "\n\n", "if", "!", "dns", ".", "IsSubDomain", "(", "zone", ",", "mx", ".", "Mx", ")", "{", "m1", ",", "e1", ":=", "b", ".", "Lookup", "(", "state", ",", "mx", ".", "Mx", ",", "dns", ".", "TypeA", ")", "\n", "if", "e1", "==", "nil", "{", "extra", "=", "append", "(", "extra", ",", "m1", ".", "Answer", "...", ")", "\n", "}", "\n\n", "m1", ",", "e1", "=", "b", ".", "Lookup", "(", "state", ",", "mx", ".", "Mx", ",", "dns", ".", "TypeAAAA", ")", "\n", "if", "e1", "==", "nil", "{", "// If we have seen CNAME's we *assume* that they are already added.", "for", "_", ",", "a", ":=", "range", "m1", ".", "Answer", "{", "if", "_", ",", "ok", ":=", "a", ".", "(", "*", "dns", ".", "CNAME", ")", ";", "!", "ok", "{", "extra", "=", "append", "(", "extra", ",", "a", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "break", "\n", "}", "\n", "// Internal name", "state1", ":=", "state", ".", "NewWithQuestion", "(", "mx", ".", "Mx", ",", "dns", ".", "TypeA", ")", "\n", "addr", ",", "e1", ":=", "A", "(", "b", ",", "zone", ",", "state1", ",", "nil", ",", "opt", ")", "\n", "if", "e1", "==", "nil", "{", "extra", "=", "append", "(", "extra", ",", "addr", "...", ")", "\n", "}", "\n", "// e.AAAA as well", "case", "dns", ".", "TypeA", ",", "dns", ".", "TypeAAAA", ":", "serv", ".", "Host", "=", "msg", ".", "Domain", "(", "serv", ".", "Key", ")", "\n", "records", "=", "append", "(", "records", ",", "serv", ".", "NewMX", "(", "state", ".", "QName", "(", ")", ")", ")", "\n", "extra", "=", "append", "(", "extra", ",", "newAddress", "(", "serv", ",", "serv", ".", "Host", ",", "ip", ",", "what", ")", ")", "\n", "}", "\n", "}", "\n", "return", "records", ",", "extra", ",", "nil", "\n", "}" ]

[ "MX", "returns", "MX", "records", "from", "the", "Backend", ".", "If", "the", "Target", "is", "not", "a", "name", "but", "an", "IP", "address", "a", "name", "is", "created", "on", "the", "fly", "." ]

[ "func", "CNAME", "(", "b", "ServiceBackend", ",", "zone", "string", ",", "state", "request", ".", "Request", ",", "opt", "Options", ")", "(", "records", "[", "]", "dns", ".", "RR", ",", "err", "error", ")", "{", "services", ",", "err", ":=", "b", ".", "Services", "(", "state", ",", "true", ",", "opt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "services", ")", ">", "0", "{", "serv", ":=", "services", "[", "0", "]", "\n", "if", "ip", ":=", "net", ".", "ParseIP", "(", "serv", ".", "Host", ")", ";", "ip", "==", "nil", "{", "records", "=", "append", "(", "records", ",", "serv", ".", "NewCNAME", "(", "state", ".", "QName", "(", ")", ",", "serv", ".", "Host", ")", ")", "\n", "}", "\n", "}", "\n", "return", "records", ",", "nil", "\n", "}" ]

[ "CNAME", "returns", "CNAME", "records", "from", "the", "backend", "or", "an", "error", "." ]

[ "func", "BackendError", "(", "b", "ServiceBackend", ",", "zone", "string", ",", "rcode", "int", ",", "state", "request", ".", "Request", ",", "err", "error", ",", "opt", "Options", ")", "(", "int", ",", "error", ")", "{", "m", ":=", "new", "(", "dns", ".", "Msg", ")", "\n", "m", ".", "SetRcode", "(", "state", ".", "Req", ",", "rcode", ")", "\n", "m", ".", "Authoritative", ",", "m", ".", "RecursionAvailable", ",", "m", ".", "Compress", "=", "true", ",", "true", ",", "true", "\n", "m", ".", "Ns", ",", "_", "=", "SOA", "(", "b", ",", "zone", ",", "state", ",", "opt", ")", "\n\n", "state", ".", "SizeAndDo", "(", "m", ")", "\n", "state", ".", "W", ".", "WriteMsg", "(", "m", ")", "\n", "// Return success as the rcode to signal we have written to the client.", "return", "dns", ".", "RcodeSuccess", ",", "err", "\n", "}" ]

[ "BackendError", "writes", "an", "error", "response", "to", "the", "client", "." ]

[ "func", "(", "network", "*", "network", ")", "hostnameToIP", "(", "rname", "string", ")", "net", ".", "IP", "{", "var", "matchedIP", "net", ".", "IP", "\n\n", "match", ":=", "network", ".", "RegexMatchIP", ".", "FindStringSubmatch", "(", "rname", ")", "\n", "if", "len", "(", "match", ")", "!=", "2", "{", "return", "nil", "\n", "}", "\n\n", "if", "network", ".", "IPnet", ".", "IP", ".", "To4", "(", ")", "!=", "nil", "{", "matchedIP", "=", "net", ".", "ParseIP", "(", "match", "[", "1", "]", ")", "\n", "}", "else", "{", "// TODO: can probably just allocate a []byte and use that.", "var", "buf", "bytes", ".", "Buffer", "\n", "// convert back to an valid ipv6 string with colons", "for", "i", ":=", "0", ";", "i", "<", "8", "*", "4", ";", "i", "+=", "4", "{", "buf", ".", "WriteString", "(", "match", "[", "1", "]", "[", "i", ":", "i", "+", "4", "]", ")", "\n", "if", "i", "<", "28", "{", "buf", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "matchedIP", "=", "net", ".", "ParseIP", "(", "buf", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "// No valid ip or it does not belong to this network", "if", "matchedIP", "==", "nil", "||", "!", "network", ".", "IPnet", ".", "Contains", "(", "matchedIP", ")", "{", "return", "nil", "\n", "}", "\n\n", "return", "matchedIP", "\n", "}" ]

[ "hostnameToIP", "converts", "the", "hostname", "back", "to", "an", "ip", "based", "on", "the", "template", "returns", "nil", "if", "there", "is", "no", "IP", "found", "." ]

[ "func", "(", "network", "*", "network", ")", "ipToHostname", "(", "ip", "net", ".", "IP", ")", "(", "name", "string", ")", "{", "if", "ipv4", ":=", "ip", ".", "To4", "(", ")", ";", "ipv4", "!=", "nil", "{", "// replace . to -", "name", "=", "ipv4", ".", "String", "(", ")", "\n", "}", "else", "{", "// assume v6", "// ensure zeros are present in string", "buf", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "ip", ")", "*", "4", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "ip", ")", ";", "i", "++", "{", "v", ":=", "ip", "[", "i", "]", "\n", "buf", "=", "append", "(", "buf", ",", "hexDigit", "[", "v", ">>", "4", "]", ")", "\n", "buf", "=", "append", "(", "buf", ",", "hexDigit", "[", "v", "&", "0xF", "]", ")", "\n", "}", "\n", "name", "=", "string", "(", "buf", ")", "\n", "}", "\n", "// inject the converted ip into the fqdn template", "return", "strings", ".", "Replace", "(", "network", ".", "Template", ",", "templateNameIP", ",", "name", ",", "1", ")", "\n", "}" ]

[ "ipToHostname", "converts", "an", "IP", "to", "an", "DNS", "compatible", "hostname", "and", "injects", "it", "into", "the", "template", ".", "domain", "." ]

[ "func", "(", "h", "*", "health", ")", "Ok", "(", ")", "bool", "{", "h", ".", "RLock", "(", ")", "\n", "defer", "h", ".", "RUnlock", "(", ")", "\n", "return", "h", ".", "ok", "\n", "}" ]

[ "Ok", "returns", "the", "global", "health", "status", "of", "all", "plugin", "configured", "in", "this", "server", "." ]

[ "func", "(", "h", "*", "health", ")", "SetOk", "(", "ok", "bool", ")", "{", "h", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "Unlock", "(", ")", "\n", "h", ".", "ok", "=", "ok", "\n", "}" ]

[ "SetOk", "sets", "the", "global", "health", "status", "of", "all", "plugin", "configured", "in", "this", "server", "." ]

[ "func", "(", "h", "*", "health", ")", "poll", "(", ")", "{", "for", "_", ",", "m", ":=", "range", "h", ".", "h", "{", "if", "!", "m", ".", "Health", "(", ")", "{", "h", ".", "SetOk", "(", "false", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "h", ".", "SetOk", "(", "true", ")", "\n", "}" ]

[ "poll", "polls", "all", "healthers", "and", "sets", "the", "global", "state", "." ]

[ "func", "NewLookupWithOption", "(", "hosts", "[", "]", "string", ",", "opts", "Options", ")", "Proxy", "{", "p", ":=", "Proxy", "{", "Next", ":", "nil", "}", "\n\n", "// TODO(miek): this needs to be unified with upstream.go's NewStaticUpstreams, caddy uses NewHost", "// we should copy/make something similar.", "upstream", ":=", "&", "staticUpstream", "{", "from", ":", "\"", "\"", ",", "HealthCheck", ":", "healthcheck", ".", "HealthCheck", "{", "FailTimeout", ":", "5", "*", "time", ".", "Second", ",", "MaxFails", ":", "3", ",", "}", ",", "ex", ":", "newDNSExWithOption", "(", "opts", ")", ",", "}", "\n", "upstream", ".", "Hosts", "=", "make", "(", "[", "]", "*", "healthcheck", ".", "UpstreamHost", ",", "len", "(", "hosts", ")", ")", "\n\n", "for", "i", ",", "host", ":=", "range", "hosts", "{", "uh", ":=", "&", "healthcheck", ".", "UpstreamHost", "{", "Name", ":", "host", ",", "FailTimeout", ":", "upstream", ".", "FailTimeout", ",", "CheckDown", ":", "checkDownFunc", "(", "upstream", ")", ",", "}", "\n\n", "upstream", ".", "Hosts", "[", "i", "]", "=", "uh", "\n", "}", "\n", "p", ".", "Upstreams", "=", "&", "[", "]", "Upstream", "{", "upstream", "}", "\n", "return", "p", "\n", "}" ]

[ "NewLookupWithOption", "process", "creates", "a", "simple", "round", "robin", "forward", "with", "potentially", "forced", "proto", "for", "upstream", "." ]