Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "a", "*", "Agent", ")", "connectedTo", "(", "proxy", "services", ".", "Server", ")", "bool", "{", "principals", ":=", "a", ".", "getPrincipals", "(", ")", "\n", "proxyID", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "proxy", ".", "GetName", "(", ")", ",", "a", ".", "ClusterName", ")", "\n", "if", "_", ",", "ok", ":=", "principals", "[", "proxyID", "]", ";", "ok", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "connectedTo", "returns", "true", "if", "connected", "services", ".", "Server", "passed", "in", "." ]

[ "func", "(", "a", "*", "Agent", ")", "connectedToRightProxy", "(", ")", "bool", "{", "for", "_", ",", "proxy", ":=", "range", "a", ".", "DiscoverProxies", "{", "if", "a", ".", "connectedTo", "(", "proxy", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "connectedToRightProxy", "returns", "true", "if", "it", "connected", "to", "a", "proxy", "in", "the", "discover", "list", "." ]

[ "func", "(", "a", "*", "Agent", ")", "run", "(", ")", "{", "defer", "a", ".", "setState", "(", "agentStateDisconnected", ")", "\n\n", "if", "len", "(", "a", ".", "DiscoverProxies", ")", "!=", "0", "{", "a", ".", "setStateAndPrincipals", "(", "agentStateDiscovering", ",", "nil", ")", "\n", "}", "else", "{", "a", ".", "setStateAndPrincipals", "(", "agentStateConnecting", ",", "nil", ")", "\n", "}", "\n\n", "// Try and connect to remote cluster.", "conn", ",", "err", ":=", "a", ".", "connect", "(", ")", "\n", "if", "err", "!=", "nil", "||", "conn", "==", "nil", "{", "a", ".", "Warningf", "(", "\"", "\"", ",", "err", ",", "conn", ")", "\n", "return", "\n", "}", "\n\n", "// Successfully connected to remote cluster.", "a", ".", "Infof", "(", "\"", "\"", ",", "conn", ".", "RemoteAddr", "(", ")", ")", "\n", "if", "len", "(", "a", ".", "DiscoverProxies", ")", "!=", "0", "{", "// If not connected to a proxy in the discover list (which means we", "// connected to a proxy we already have a connection to), try again.", "if", "!", "a", ".", "connectedToRightProxy", "(", ")", "{", "a", ".", "Debugf", "(", "\"", "\"", ",", "a", ".", "getPrincipalsList", "(", ")", ",", "Proxies", "(", "a", ".", "DiscoverProxies", ")", ")", "\n\n", "conn", ".", "Close", "(", ")", "\n", "return", "\n", "}", "\n", "a", ".", "setState", "(", "agentStateDiscovered", ")", "\n", "}", "else", "{", "a", ".", "setState", "(", "agentStateConnected", ")", "\n", "}", "\n\n", "// Notify waiters that the agent has connected.", "if", "a", ".", "EventsC", "!=", "nil", "{", "select", "{", "case", "a", ".", "EventsC", "<-", "ConnectedEvent", ":", "case", "<-", "a", ".", "ctx", ".", "Done", "(", ")", ":", "a", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "default", ":", "}", "\n", "}", "\n\n", "// A connection has been established start processing requests. Note that", "// this function blocks while the connection is up. It will unblock when", "// the connection is closed either due to intermittent connectivity issues", "// or permanent loss of a proxy.", "err", "=", "a", ".", "processRequests", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "a", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "}" ]

[ "run", "is", "the", "main", "agent", "loop", ".", "It", "tries", "to", "establish", "a", "connection", "to", "the", "remote", "proxy", "and", "then", "process", "requests", "that", "come", "over", "the", "tunnel", ".", "Once", "run", "connects", "to", "a", "proxy", "it", "starts", "processing", "requests", "from", "the", "proxy", "via", "SSH", "channels", "opened", "by", "the", "remote", "Proxy", ".", "Agent", "sends", "periodic", "heartbeats", "back", "to", "the", "Proxy", "and", "that", "is", "how", "Proxy", "determines", "disconnects", "." ]

[ "func", "(", "a", "*", "Agent", ")", "processRequests", "(", "conn", "*", "ssh", ".", "Client", ")", "error", "{", "defer", "conn", ".", "Close", "(", ")", "\n", "ticker", ":=", "time", ".", "NewTicker", "(", "defaults", ".", "ReverseTunnelAgentHeartbeatPeriod", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n\n", "hb", ",", "reqC", ",", "err", ":=", "conn", ".", "OpenChannel", "(", "chanHeartbeat", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "newTransportC", ":=", "conn", ".", "HandleChannelOpen", "(", "chanTransport", ")", "\n", "newDiscoveryC", ":=", "conn", ".", "HandleChannelOpen", "(", "chanDiscovery", ")", "\n\n", "// send first ping right away, then start a ping timer:", "hb", ".", "SendRequest", "(", "\"", "\"", ",", "false", ",", "nil", ")", "\n\n", "for", "{", "select", "{", "// need to exit:", "case", "<-", "a", ".", "ctx", ".", "Done", "(", ")", ":", "return", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", "\n", "// time to ping:", "case", "<-", "ticker", ".", "C", ":", "bytes", ",", "_", ":=", "a", ".", "Clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "MarshalText", "(", ")", "\n", "_", ",", "err", ":=", "hb", ".", "SendRequest", "(", "\"", "\"", ",", "false", ",", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "a", ".", "Error", "(", "err", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "a", ".", "Debugf", "(", "\"", "\"", ",", "conn", ".", "RemoteAddr", "(", ")", ")", "\n", "// ssh channel closed:", "case", "req", ":=", "<-", "reqC", ":", "if", "req", "==", "nil", "{", "return", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "// new transport request:", "case", "nch", ":=", "<-", "newTransportC", ":", "if", "nch", "==", "nil", "{", "continue", "\n", "}", "\n", "a", ".", "Debugf", "(", "\"", "\"", ",", "nch", ".", "ChannelType", "(", ")", ")", "\n", "ch", ",", "req", ",", "err", ":=", "nch", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "a", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "go", "proxyTransport", "(", "&", "transportParams", "{", "log", ":", "a", ".", "Entry", ",", "closeContext", ":", "a", ".", "ctx", ",", "authClient", ":", "a", ".", "Client", ",", "kubeDialAddr", ":", "a", ".", "KubeDialAddr", ",", "channel", ":", "ch", ",", "requestCh", ":", "req", ",", "sconn", ":", "conn", ".", "Conn", ",", "server", ":", "a", ".", "Server", ",", "component", ":", "teleport", ".", "ComponentReverseTunnelAgent", ",", "}", ")", "\n", "// new discovery request", "case", "nch", ":=", "<-", "newDiscoveryC", ":", "if", "nch", "==", "nil", "{", "continue", "\n", "}", "\n", "a", ".", "Debugf", "(", "\"", "\"", ",", "nch", ".", "ChannelType", "(", ")", ")", "\n", "ch", ",", "req", ",", "err", ":=", "nch", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "a", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "go", "a", ".", "handleDiscovery", "(", "ch", ",", "req", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "processRequests", "is", "a", "blocking", "function", "which", "runs", "in", "a", "loop", "sending", "heartbeats", "to", "the", "given", "SSH", "connection", "and", "processes", "inbound", "requests", "from", "the", "remote", "proxy" ]

[ "func", "NewLinear", "(", "cfg", "LinearConfig", ")", "(", "*", "Linear", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "closedChan", ":=", "make", "(", "chan", "time", ".", "Time", ")", "\n", "close", "(", "closedChan", ")", "\n", "return", "&", "Linear", "{", "LinearConfig", ":", "cfg", ",", "closedChan", ":", "closedChan", "}", ",", "nil", "\n", "}" ]

[ "NewLinear", "returns", "a", "new", "instance", "of", "linear", "retry" ]

[ "func", "(", "r", "*", "Linear", ")", "Duration", "(", ")", "time", ".", "Duration", "{", "a", ":=", "r", ".", "First", "+", "time", ".", "Duration", "(", "r", ".", "attempt", ")", "*", "r", ".", "Step", "\n", "if", "a", "<", "0", "{", "return", "0", "\n", "}", "\n", "if", "a", "<=", "r", ".", "Max", "{", "return", "a", "\n", "}", "\n", "return", "r", ".", "Max", "\n", "}" ]

[ "Duration", "returns", "retry", "duration", "based", "on", "state" ]

[ "func", "(", "r", "*", "Linear", ")", "After", "(", ")", "<-", "chan", "time", ".", "Time", "{", "if", "r", ".", "Duration", "(", ")", "==", "0", "{", "return", "r", ".", "closedChan", "\n", "}", "\n", "return", "time", ".", "After", "(", "r", ".", "Duration", "(", ")", ")", "\n", "}" ]

[ "After", "returns", "channel", "that", "fires", "with", "timeout", "defined", "in", "Duration", "method", "as", "a", "special", "case", "if", "Duration", "is", "0", "returns", "a", "closed", "channel" ]

[ "func", "(", "r", "*", "Linear", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "attempt", ",", "r", ".", "Duration", "(", ")", ")", "\n", "}" ]

[ "String", "returns", "user", "-", "friendly", "representation", "of", "the", "LinearPeriod" ]

[ "func", "getLoginShell", "(", "username", "string", ")", "(", "string", ",", "error", ")", "{", "// See if the username is valid.", "_", ",", "err", ":=", "user", ".", "Lookup", "(", "username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Based on stdlib user/lookup_unix.go packages which does not return", "// user shell: https://golang.org/src/os/user/lookup_unix.go", "var", "pwd", "C", ".", "struct_passwd", "\n", "var", "result", "*", "C", ".", "struct_passwd", "\n\n", "bufSize", ":=", "C", ".", "sysconf", "(", "C", ".", "_SC_GETPW_R_SIZE_MAX", ")", "\n", "if", "bufSize", "==", "-", "1", "{", "bufSize", "=", "1024", "\n", "}", "\n", "if", "bufSize", "<=", "0", "||", "bufSize", ">", "1", "<<", "20", "{", "return", "\"", "\"", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "bufSize", ")", "\n", "}", "\n", "buf", ":=", "C", ".", "malloc", "(", "C", ".", "size_t", "(", "bufSize", ")", ")", "\n", "defer", "C", ".", "free", "(", "buf", ")", "\n", "var", "rv", "C", ".", "int", "\n", "nameC", ":=", "C", ".", "CString", "(", "username", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "nameC", ")", ")", "\n", "rv", "=", "C", ".", "mygetpwnam_r", "(", "nameC", ",", "&", "pwd", ",", "(", "*", "C", ".", "char", ")", "(", "buf", ")", ",", "C", ".", "size_t", "(", "bufSize", ")", ",", "&", "result", ")", "\n", "if", "rv", "!=", "0", "||", "result", "==", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "username", ",", "syscall", ".", "Errno", "(", "rv", ")", ")", "\n", "return", "\"", "\"", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n\n", "// If no shell was found, return trace.NotFound to allow the caller to set", "// the default shell.", "shellCmd", ":=", "strings", ".", "TrimSpace", "(", "C", ".", "GoString", "(", "pwd", ".", "pw_shell", ")", ")", "\n", "if", "len", "(", "shellCmd", ")", "==", "0", "{", "return", "\"", "\"", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "username", ")", "\n", "}", "\n\n", "return", "shellCmd", ",", "nil", "\n", "}" ]

[ "getLoginShell", "determines", "the", "login", "shell", "for", "a", "given", "username" ]

[ "func", "AuthorizedKeyFingerprint", "(", "publicKey", "[", "]", "byte", ")", "(", "string", ",", "error", ")", "{", "key", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "ssh", ".", "ParseAuthorizedKey", "(", "publicKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "Fingerprint", "(", "key", ")", ",", "nil", "\n", "}" ]

[ "AuthorizedKeyFingerprint", "returns", "fingerprint", "from", "public", "key", "in", "authorized", "key", "format" ]

[ "func", "PrivateKeyFingerprint", "(", "keyBytes", "[", "]", "byte", ")", "(", "string", ",", "error", ")", "{", "signer", ",", "err", ":=", "ssh", ".", "ParsePrivateKey", "(", "keyBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "Fingerprint", "(", "signer", ".", "PublicKey", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "PrivateKeyFingerprint", "returns", "fingerprint", "of", "the", "public", "key", "extracted", "from", "the", "PEM", "encoded", "private", "key" ]

[ "func", "NewHMACAnonymizer", "(", "key", "string", ")", "(", "*", "hmacAnonymizer", ",", "error", ")", "{", "if", "strings", ".", "TrimSpace", "(", "key", ")", "==", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "hmacAnonymizer", "{", "key", ":", "key", ",", "}", ",", "nil", "\n", "}" ]

[ "NewHMACAnonymizer", "returns", "a", "new", "HMAC", "-", "based", "anonymizer" ]

[ "func", "(", "a", "*", "hmacAnonymizer", ")", "Anonymize", "(", "data", "[", "]", "byte", ")", "string", "{", "h", ":=", "hmac", ".", "New", "(", "sha256", ".", "New", ",", "[", "]", "byte", "(", "a", ".", "key", ")", ")", "\n", "h", ".", "Write", "(", "data", ")", "\n", "return", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "h", ".", "Sum", "(", "nil", ")", ")", "\n", "}" ]

[ "Anonymize", "anonymizes", "the", "provided", "data", "using", "HMAC" ]

[ "func", "UnmarshalWithSchema", "(", "schemaDefinition", "string", ",", "object", "interface", "{", "}", ",", "data", "[", "]", "byte", ")", "error", "{", "schema", ",", "err", ":=", "jsonschema", ".", "New", "(", "[", "]", "byte", "(", "schemaDefinition", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "jsonData", ",", "err", ":=", "ToJSON", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "raw", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "jsonData", ",", "&", "raw", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// schema will check format and set defaults", "processed", ",", "err", ":=", "schema", ".", "ProcessObject", "(", "raw", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// since ProcessObject works with unstructured data, the", "// data needs to be re-interpreted in structured form", "bytes", ",", "err", ":=", "json", ".", "Marshal", "(", "processed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "bytes", ",", "object", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalWithSchema", "processes", "YAML", "or", "JSON", "encoded", "object", "with", "JSON", "schema", "sets", "defaults", "and", "unmarshals", "resulting", "object", "into", "given", "struct" ]

[ "func", "NewSessionArchive", "(", "dataDir", ",", "serverID", ",", "namespace", "string", ",", "sessionID", "session", ".", "ID", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "index", ",", "err", ":=", "readSessionIndex", "(", "dataDir", ",", "[", "]", "string", "{", "serverID", "}", ",", "namespace", ",", "sessionID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// io.Pipe allows to generate the archive part by part", "// without writing to disk or generating it in memory", "// at the pace which reader is ready to consume it", "reader", ",", "writer", ":=", "io", ".", "Pipe", "(", ")", "\n", "tarball", ":=", "tar", ".", "NewWriter", "(", "writer", ")", "\n", "go", "func", "(", ")", "{", "if", "err", ":=", "writeSessionArchive", "(", "index", ",", "tarball", ",", "writer", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "trace", ".", "DebugReport", "(", "err", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "reader", ",", "nil", "\n", "}" ]

[ "NewSessionArchive", "returns", "generated", "tar", "archive", "with", "all", "components" ]

[ "func", "ParseSigningKeyStorePEM", "(", "keyPEM", ",", "certPEM", "string", ")", "(", "*", "SigningKeyStore", ",", "error", ")", "{", "_", ",", "err", ":=", "ParseCertificatePEM", "(", "[", "]", "byte", "(", "certPEM", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "key", ",", "err", ":=", "ParsePrivateKeyPEM", "(", "[", "]", "byte", "(", "keyPEM", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "rsaKey", ",", "ok", ":=", "key", ".", "(", "*", "rsa", ".", "PrivateKey", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "key", ")", "\n", "}", "\n", "certASN", ",", "_", ":=", "pem", ".", "Decode", "(", "[", "]", "byte", "(", "certPEM", ")", ")", "\n", "if", "certASN", "==", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "SigningKeyStore", "{", "privateKey", ":", "rsaKey", ",", "cert", ":", "certASN", ".", "Bytes", "}", ",", "nil", "\n", "}" ]

[ "ParseSigningKeyStore", "parses", "signing", "key", "store", "from", "PEM", "encoded", "key", "pair" ]

[ "func", "ParseCertificateRequestPEM", "(", "bytes", "[", "]", "byte", ")", "(", "*", "x509", ".", "CertificateRequest", ",", "error", ")", "{", "block", ",", "_", ":=", "pem", ".", "Decode", "(", "bytes", ")", "\n", "if", "block", "==", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "csr", ",", "err", ":=", "x509", ".", "ParseCertificateRequest", "(", "block", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "csr", ",", "nil", "\n", "}" ]

[ "ParseCertificateRequestPEM", "parses", "PEM", "-", "encoded", "certificate", "signing", "request" ]

[ "func", "ParseCertificatePEM", "(", "bytes", "[", "]", "byte", ")", "(", "*", "x509", ".", "Certificate", ",", "error", ")", "{", "block", ",", "_", ":=", "pem", ".", "Decode", "(", "bytes", ")", "\n", "if", "block", "==", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "block", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "cert", ",", "nil", "\n", "}" ]

[ "ParseCertificatePEM", "parses", "PEM", "-", "encoded", "certificate" ]

[ "func", "ParsePrivateKeyPEM", "(", "bytes", "[", "]", "byte", ")", "(", "crypto", ".", "Signer", ",", "error", ")", "{", "block", ",", "_", ":=", "pem", ".", "Decode", "(", "bytes", ")", "\n", "if", "block", "==", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ParsePrivateKeyDER", "(", "block", ".", "Bytes", ")", "\n", "}" ]

[ "ParsePrivateKeyPEM", "parses", "PEM", "-", "encoded", "private", "key" ]

[ "func", "ParsePrivateKeyDER", "(", "der", "[", "]", "byte", ")", "(", "crypto", ".", "Signer", ",", "error", ")", "{", "generalKey", ",", "err", ":=", "x509", ".", "ParsePKCS8PrivateKey", "(", "der", ")", "\n", "if", "err", "!=", "nil", "{", "generalKey", ",", "err", "=", "x509", ".", "ParsePKCS1PrivateKey", "(", "der", ")", "\n", "if", "err", "!=", "nil", "{", "generalKey", ",", "err", "=", "x509", ".", "ParseECPrivateKey", "(", "der", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "switch", "generalKey", ".", "(", "type", ")", "{", "case", "*", "rsa", ".", "PrivateKey", ":", "return", "generalKey", ".", "(", "*", "rsa", ".", "PrivateKey", ")", ",", "nil", "\n", "case", "*", "ecdsa", ".", "PrivateKey", ":", "return", "generalKey", ".", "(", "*", "ecdsa", ".", "PrivateKey", ")", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}" ]

[ "ParsePrivateKeyDER", "parses", "unencrypted", "DER", "-", "encoded", "private", "key" ]

[ "func", "ReadCertificateChain", "(", "certificateChainBytes", "[", "]", "byte", ")", "(", "[", "]", "*", "x509", ".", "Certificate", ",", "error", ")", "{", "// build the certificate chain next", "var", "certificateBlock", "*", "pem", ".", "Block", "\n", "var", "remainingBytes", "[", "]", "byte", "=", "bytes", ".", "TrimSpace", "(", "certificateChainBytes", ")", "\n", "var", "certificateChain", "[", "]", "[", "]", "byte", "\n\n", "for", "{", "certificateBlock", ",", "remainingBytes", "=", "pem", ".", "Decode", "(", "remainingBytes", ")", "\n", "if", "certificateBlock", "==", "nil", "||", "certificateBlock", ".", "Type", "!=", "pemBlockCertificate", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "certificateChain", "=", "append", "(", "certificateChain", ",", "certificateBlock", ".", "Bytes", ")", "\n\n", "if", "len", "(", "remainingBytes", ")", "==", "0", "{", "break", "\n", "}", "\n", "}", "\n\n", "// build a concatenated certificate chain", "var", "buf", "bytes", ".", "Buffer", "\n", "for", "_", ",", "cc", ":=", "range", "certificateChain", "{", "_", ",", "err", ":=", "buf", ".", "Write", "(", "cc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// parse the chain and get a slice of x509.Certificates.", "x509Chain", ",", "err", ":=", "x509", ".", "ParseCertificates", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "x509Chain", ",", "nil", "\n", "}" ]

[ "ReadCertificateChain", "parses", "PEM", "encoded", "bytes", "that", "can", "contain", "one", "or", "multiple", "certificates", "and", "returns", "a", "slice", "of", "x509", ".", "Certificate", "." ]

[ "func", "NewLoadBalancer", "(", "ctx", "context", ".", "Context", ",", "frontend", "NetAddr", ",", "backends", "...", "NetAddr", ")", "(", "*", "LoadBalancer", ",", "error", ")", "{", "if", "ctx", "==", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "waitCtx", ",", "waitCancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "return", "&", "LoadBalancer", "{", "frontend", ":", "frontend", ",", "ctx", ":", "ctx", ",", "backends", ":", "backends", ",", "currentIndex", ":", "-", "1", ",", "waitCtx", ":", "waitCtx", ",", "waitCancel", ":", "waitCancel", ",", "Entry", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "\"", "\"", ",", "trace", ".", "ComponentFields", ":", "log", ".", "Fields", "{", "\"", "\"", ":", "frontend", ".", "String", "(", ")", ",", "}", ",", "}", ")", ",", "connections", ":", "make", "(", "map", "[", "NetAddr", "]", "map", "[", "int64", "]", "net", ".", "Conn", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewLoadBalancer", "returns", "new", "load", "balancer", "listening", "on", "frontend", "and", "redirecting", "requests", "to", "backends", "using", "round", "robin", "algo" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "trackConnection", "(", "backend", "NetAddr", ",", "conn", "net", ".", "Conn", ")", "int64", "{", "l", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "Unlock", "(", ")", "\n", "l", ".", "connID", "+=", "1", "\n", "tracker", ",", "ok", ":=", "l", ".", "connections", "[", "backend", "]", "\n", "if", "!", "ok", "{", "tracker", "=", "make", "(", "map", "[", "int64", "]", "net", ".", "Conn", ")", "\n", "l", ".", "connections", "[", "backend", "]", "=", "tracker", "\n", "}", "\n", "tracker", "[", "l", ".", "connID", "]", "=", "conn", "\n", "return", "l", ".", "connID", "\n", "}" ]

[ "trackeConnection", "adds", "connection", "to", "the", "connection", "tracker" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "untrackConnection", "(", "backend", "NetAddr", ",", "id", "int64", ")", "{", "l", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "Unlock", "(", ")", "\n", "tracker", ",", "ok", ":=", "l", ".", "connections", "[", "backend", "]", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n", "delete", "(", "tracker", ",", "id", ")", "\n", "}" ]

[ "untrackConnection", "removes", "connection", "from", "connection", "tracker" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "dropConnections", "(", "backend", "NetAddr", ")", "{", "tracker", ":=", "l", ".", "connections", "[", "backend", "]", "\n", "for", "_", ",", "conn", ":=", "range", "tracker", "{", "conn", ".", "Close", "(", ")", "\n", "}", "\n", "delete", "(", "l", ".", "connections", ",", "backend", ")", "\n", "}" ]

[ "dropConnections", "drops", "connections", "associated", "with", "backend" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "AddBackend", "(", "b", "NetAddr", ")", "{", "l", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "Unlock", "(", ")", "\n", "l", ".", "backends", "=", "append", "(", "l", ".", "backends", ",", "b", ")", "\n", "l", ".", "Debugf", "(", "\"", "\"", ",", "l", ".", "backends", ")", "\n", "}" ]

[ "AddBackend", "adds", "backend" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "RemoveBackend", "(", "b", "NetAddr", ")", "{", "l", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "Unlock", "(", ")", "\n", "l", ".", "currentIndex", "=", "-", "1", "\n", "for", "i", ":=", "range", "l", ".", "backends", "{", "if", "l", ".", "backends", "[", "i", "]", ".", "Equals", "(", "b", ")", "{", "l", ".", "backends", "=", "append", "(", "l", ".", "backends", "[", ":", "i", "]", ",", "l", ".", "backends", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "l", ".", "dropConnections", "(", "b", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "RemoveBackend", "removes", "backend" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "ListenAndServe", "(", ")", "error", "{", "if", "err", ":=", "l", ".", "Listen", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "l", ".", "Serve", "(", ")", "\n", "}" ]

[ "ListenAndServe", "starts", "listening", "socket", "and", "serves", "connections", "on", "it" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "Listen", "(", ")", "error", "{", "var", "err", "error", "\n", "l", ".", "listener", ",", "err", "=", "net", ".", "Listen", "(", "l", ".", "frontend", ".", "AddrNetwork", ",", "l", ".", "frontend", ".", "Addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "l", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "Listen", "creates", "a", "listener", "on", "the", "frontend", "addr" ]

[ "func", "(", "l", "*", "LoadBalancer", ")", "Serve", "(", ")", "error", "{", "defer", "l", ".", "waitCancel", "(", ")", "\n", "backoffTimer", ":=", "time", ".", "NewTicker", "(", "5", "*", "time", ".", "Second", ")", "\n", "defer", "backoffTimer", ".", "Stop", "(", ")", "\n", "for", "{", "conn", ",", "err", ":=", "l", ".", "listener", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "l", ".", "isClosed", "(", ")", "{", "return", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "select", "{", "case", "<-", "backoffTimer", ".", "C", ":", "l", ".", "Debugf", "(", "\"", "\"", ")", "\n", "case", "<-", "l", ".", "ctx", ".", "Done", "(", ")", ":", "return", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "go", "l", ".", "forwardConnection", "(", "conn", ")", "\n", "}", "\n", "}" ]

[ "Serve", "starts", "accepting", "connections" ]

[ "func", "NewDiskSessionLogger", "(", "cfg", "DiskSessionLoggerConfig", ")", "(", "*", "DiskSessionLogger", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "err", "error", "\n\n", "sessionDir", ":=", "filepath", ".", "Join", "(", "cfg", ".", "DataDir", ",", "cfg", ".", "ServerID", ",", "SessionLogsDir", ",", "cfg", ".", "Namespace", ")", "\n", "indexFile", ",", "err", ":=", "os", ".", "OpenFile", "(", "filepath", ".", "Join", "(", "sessionDir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cfg", ".", "SessionID", ".", "String", "(", ")", ")", ")", ",", "os", ".", "O_WRONLY", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_APPEND", ",", "0640", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "sessionLogger", ":=", "&", "DiskSessionLogger", "{", "DiskSessionLoggerConfig", ":", "cfg", ",", "Entry", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "ComponentAuditLog", ",", "trace", ".", "ComponentFields", ":", "log", ".", "Fields", "{", "\"", "\"", ":", "cfg", ".", "SessionID", ",", "}", ",", "}", ")", ",", "sessionDir", ":", "sessionDir", ",", "indexFile", ":", "indexFile", ",", "lastEventIndex", ":", "-", "1", ",", "lastChunkIndex", ":", "-", "1", ",", "}", "\n", "return", "sessionLogger", ",", "nil", "\n", "}" ]

[ "NewDiskSessionLogger", "creates", "new", "disk", "based", "session", "logger" ]

[ "func", "(", "sl", "*", "DiskSessionLogger", ")", "Finalize", "(", ")", "error", "{", "sl", ".", "Lock", "(", ")", "\n", "defer", "sl", ".", "Unlock", "(", ")", "\n\n", "return", "sl", ".", "finalize", "(", ")", "\n", "}" ]

[ "Finalize", "is", "called", "by", "the", "session", "when", "it", "s", "closing", ".", "This", "is", "where", "we", "re", "releasing", "audit", "resources", "associated", "with", "the", "session" ]

[ "func", "(", "sl", "*", "DiskSessionLogger", ")", "flush", "(", ")", "error", "{", "var", "err", ",", "err2", "error", "\n\n", "if", "sl", ".", "RecordSessions", "&&", "sl", ".", "chunksFile", "!=", "nil", "{", "err", "=", "sl", ".", "chunksFile", ".", "Flush", "(", ")", "\n", "}", "\n", "if", "sl", ".", "eventsFile", "!=", "nil", "{", "err2", "=", "sl", ".", "eventsFile", ".", "Flush", "(", ")", "\n", "}", "\n", "return", "trace", ".", "NewAggregate", "(", "err", ",", "err2", ")", "\n", "}" ]

[ "flush", "is", "used", "to", "flush", "gzip", "frames", "to", "file", "otherwise", "some", "attempts", "to", "read", "the", "file", "could", "fail" ]

[ "func", "eventsFileName", "(", "dataDir", "string", ",", "sessionID", "session", ".", "ID", ",", "eventIndex", "int64", ")", "string", "{", "return", "filepath", ".", "Join", "(", "dataDir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sessionID", ".", "String", "(", ")", ",", "eventIndex", ")", ")", "\n", "}" ]

[ "eventsFileName", "consists", "of", "session", "id", "and", "the", "first", "global", "event", "index", "recorded", "there" ]

[ "func", "chunksFileName", "(", "dataDir", "string", ",", "sessionID", "session", ".", "ID", ",", "offset", "int64", ")", "string", "{", "return", "filepath", ".", "Join", "(", "dataDir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sessionID", ".", "String", "(", ")", ",", "offset", ")", ")", "\n", "}" ]

[ "chunksFileName", "consists", "of", "session", "id", "and", "the", "first", "global", "offset", "recorded" ]

[ "func", "(", "sl", "*", "DiskSessionLogger", ")", "PostSessionSlice", "(", "slice", "SessionSlice", ")", "error", "{", "sl", ".", "Lock", "(", ")", "\n", "defer", "sl", ".", "Unlock", "(", ")", "\n\n", "for", "i", ":=", "range", "slice", ".", "Chunks", "{", "_", ",", "err", ":=", "sl", ".", "writeChunk", "(", "slice", ".", "SessionID", ",", "slice", ".", "Chunks", "[", "i", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "sl", ".", "flush", "(", ")", "\n", "}" ]

[ "PostSessionSlice", "takes", "series", "of", "events", "associated", "with", "the", "session", "and", "writes", "them", "to", "events", "files", "and", "data", "file", "for", "future", "replays" ]

[ "func", "EventFromChunk", "(", "sessionID", "string", ",", "chunk", "*", "SessionChunk", ")", "(", "EventFields", ",", "error", ")", "{", "var", "fields", "EventFields", "\n", "eventStart", ":=", "time", ".", "Unix", "(", "0", ",", "chunk", ".", "Time", ")", ".", "In", "(", "time", ".", "UTC", ")", ".", "Round", "(", "time", ".", "Millisecond", ")", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "chunk", ".", "Data", ",", "&", "fields", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "fields", "[", "SessionEventID", "]", "=", "sessionID", "\n", "fields", "[", "EventIndex", "]", "=", "chunk", ".", "EventIndex", "\n", "fields", "[", "EventTime", "]", "=", "eventStart", "\n", "fields", "[", "EventType", "]", "=", "chunk", ".", "EventType", "\n", "if", "fields", "[", "EventID", "]", "==", "\"", "\"", "{", "fields", "[", "EventID", "]", "=", "uuid", ".", "New", "(", ")", "\n", "}", "\n", "return", "fields", ",", "nil", "\n", "}" ]

[ "EventFromChunk", "returns", "event", "converted", "from", "session", "chunk" ]

[ "func", "(", "f", "*", "gzipWriter", ")", "Close", "(", ")", "error", "{", "var", "errors", "[", "]", "error", "\n", "if", "f", ".", "Writer", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "f", ".", "Writer", ".", "Close", "(", ")", ")", "\n", "f", ".", "Writer", ".", "Reset", "(", "ioutil", ".", "Discard", ")", "\n", "writerPool", ".", "Put", "(", "f", ".", "Writer", ")", "\n", "f", ".", "Writer", "=", "nil", "\n", "}", "\n", "if", "f", ".", "file", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "f", ".", "file", ".", "Close", "(", ")", ")", "\n", "f", ".", "file", "=", "nil", "\n", "}", "\n", "return", "trace", ".", "NewAggregate", "(", "errors", "...", ")", "\n", "}" ]

[ "Close", "closes", "gzip", "writer", "and", "file" ]

[ "func", "(", "f", "*", "gzipReader", ")", "Close", "(", ")", "error", "{", "var", "errors", "[", "]", "error", "\n", "if", "f", ".", "ReadCloser", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "f", ".", "ReadCloser", ".", "Close", "(", ")", ")", "\n", "f", ".", "ReadCloser", "=", "nil", "\n", "}", "\n", "if", "f", ".", "file", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "f", ".", "file", ".", "Close", "(", ")", ")", "\n", "f", ".", "file", "=", "nil", "\n", "}", "\n", "return", "trace", ".", "NewAggregate", "(", "errors", "...", ")", "\n", "}" ]

[ "Close", "closes", "file", "and", "gzip", "writer" ]

[ "func", "(", "h", "HeartbeatMode", ")", "String", "(", ")", "string", "{", "switch", "h", "{", "case", "HeartbeatModeNode", ":", "return", "\"", "\"", "\n", "case", "HeartbeatModeProxy", ":", "return", "\"", "\"", "\n", "case", "HeartbeatModeAuth", ":", "return", "\"", "\"", "\n", "default", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int", "(", "h", ")", ")", "\n", "}", "\n", "}" ]

[ "String", "returns", "user", "-", "friendly", "representation", "of", "the", "mode" ]

[ "func", "NewHeartbeat", "(", "cfg", "HeartbeatConfig", ")", "(", "*", "Heartbeat", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "cfg", ".", "Context", ")", "\n", "h", ":=", "&", "Heartbeat", "{", "cancelCtx", ":", "ctx", ",", "cancel", ":", "cancel", ",", "HeartbeatConfig", ":", "cfg", ",", "Entry", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "Component", "(", "cfg", ".", "Component", ",", "\"", "\"", ")", ",", "}", ")", ",", "checkTicker", ":", "time", ".", "NewTicker", "(", "cfg", ".", "CheckPeriod", ")", ",", "announceC", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "sendC", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "}", "\n", "h", ".", "Debugf", "(", "\"", "\"", ",", "cfg", ".", "Mode", ",", "cfg", ".", "KeepAlivePeriod", ",", "cfg", ".", "AnnouncePeriod", ",", "cfg", ".", "CheckPeriod", ")", "\n", "return", "h", ",", "nil", "\n", "}" ]

[ "NewHeartbeat", "returns", "a", "new", "instance", "of", "heartbeat" ]

[ "func", "(", "h", "*", "Heartbeat", ")", "Run", "(", ")", "error", "{", "defer", "func", "(", ")", "{", "h", ".", "reset", "(", "HeartbeatStateInit", ")", "\n", "h", ".", "checkTicker", ".", "Stop", "(", ")", "\n", "}", "(", ")", "\n", "for", "{", "if", "err", ":=", "h", ".", "fetchAndAnnounce", "(", ")", ";", "err", "!=", "nil", "{", "h", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "select", "{", "case", "<-", "h", ".", "checkTicker", ".", "C", ":", "case", "<-", "h", ".", "sendC", ":", "h", ".", "Debugf", "(", "\"", "\"", ")", "\n", "case", "<-", "h", ".", "cancelCtx", ".", "Done", "(", ")", ":", "h", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "Run", "periodically", "calls", "to", "announce", "presence", "should", "be", "called", "explicitly", "in", "a", "separate", "goroutine" ]

[ "func", "(", "h", "*", "Heartbeat", ")", "reset", "(", "state", "KeepAliveState", ")", "{", "h", ".", "setState", "(", "state", ")", "\n", "h", ".", "nextAnnounce", "=", "time", ".", "Time", "{", "}", "\n", "h", ".", "nextKeepAlive", "=", "time", ".", "Time", "{", "}", "\n", "h", ".", "keepAlive", "=", "nil", "\n", "if", "h", ".", "keepAliver", "!=", "nil", "{", "if", "err", ":=", "h", ".", "keepAliver", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "h", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "h", ".", "keepAliver", "=", "nil", "\n", "}", "\n", "}" ]

[ "reset", "resets", "keep", "alive", "state", "and", "sends", "the", "state", "back", "to", "the", "initial", "state", "of", "sending", "full", "update" ]

[ "func", "(", "h", "*", "Heartbeat", ")", "fetch", "(", ")", "error", "{", "// failed to fetch server info?", "// reset to init state regardless of the current state", "server", ",", "err", ":=", "h", ".", "GetServerInfo", "(", ")", "\n", "if", "err", "!=", "nil", "{", "h", ".", "reset", "(", "HeartbeatStateInit", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "switch", "h", ".", "state", "{", "// in case of successfull state fetch, move to announce from init", "case", "HeartbeatStateInit", ":", "h", ".", "current", "=", "server", "\n", "h", ".", "reset", "(", "HeartbeatStateAnnounce", ")", "\n", "return", "nil", "\n", "// nothing to do in announce state", "case", "HeartbeatStateAnnounce", ":", "return", "nil", "\n", "case", "HeartbeatStateAnnounceWait", ":", "// time to announce", "if", "h", ".", "Clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "After", "(", "h", ".", "nextAnnounce", ")", "{", "h", ".", "current", "=", "server", "\n", "h", ".", "reset", "(", "HeartbeatStateAnnounce", ")", "\n", "return", "nil", "\n", "}", "\n", "result", ":=", "services", ".", "CompareServers", "(", "h", ".", "current", ",", "server", ")", "\n", "// server update happened, time to announce", "if", "result", "==", "services", ".", "Different", "{", "h", ".", "current", "=", "server", "\n", "h", ".", "reset", "(", "HeartbeatStateAnnounce", ")", "\n", "}", "\n", "return", "nil", "\n", "// nothing to do in keep alive state", "case", "HeartbeatStateKeepAlive", ":", "return", "nil", "\n", "// Stay in keep alive state in case", "// if there are no changes", "case", "HeartbeatStateKeepAliveWait", ":", "// time to send a new keep alive", "if", "h", ".", "Clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "After", "(", "h", ".", "nextKeepAlive", ")", "{", "h", ".", "setState", "(", "HeartbeatStateKeepAlive", ")", "\n", "return", "nil", "\n", "}", "\n", "result", ":=", "services", ".", "CompareServers", "(", "h", ".", "current", ",", "server", ")", "\n", "// server update happened, move to announce", "if", "result", "==", "services", ".", "Different", "{", "h", ".", "current", "=", "server", "\n", "h", ".", "reset", "(", "HeartbeatStateAnnounce", ")", "\n", "}", "\n", "return", "nil", "\n", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "h", ".", "state", ")", "\n", "}", "\n", "}" ]

[ "fetch", "if", "succeeded", "updates", "or", "sets", "current", "server", "to", "the", "last", "received", "server" ]

[ "func", "(", "h", "*", "Heartbeat", ")", "fetchAndAnnounce", "(", ")", "error", "{", "if", "err", ":=", "h", ".", "fetch", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "h", ".", "announce", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "fetchAndAnnounce", "fetches", "data", "about", "server", "and", "announces", "it", "to", "the", "server" ]

[ "func", "(", "h", "*", "Heartbeat", ")", "ForceSend", "(", "timeout", "time", ".", "Duration", ")", "error", "{", "timeoutC", ":=", "time", ".", "After", "(", "timeout", ")", "\n", "select", "{", "case", "h", ".", "sendC", "<-", "struct", "{", "}", "{", "}", ":", "case", "<-", "timeoutC", ":", "return", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "select", "{", "case", "<-", "h", ".", "announceC", ":", "return", "nil", "\n", "case", "<-", "timeoutC", ":", "return", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "ForceSend", "forces", "send", "cycle", "used", "in", "tests", "returns", "nil", "in", "case", "of", "success", "error", "otherwise" ]

[ "func", "(", "b", "*", "Log", ")", "deleteAllItems", "(", ")", "error", "{", "out", ",", "err", ":=", "b", ".", "svc", ".", "Scan", "(", "&", "dynamodb", ".", "ScanInput", "{", "TableName", ":", "aws", ".", "String", "(", "b", ".", "Tablename", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "requests", "[", "]", "*", "dynamodb", ".", "WriteRequest", "\n", "for", "_", ",", "item", ":=", "range", "out", ".", "Items", "{", "requests", "=", "append", "(", "requests", ",", "&", "dynamodb", ".", "WriteRequest", "{", "DeleteRequest", ":", "&", "dynamodb", ".", "DeleteRequest", "{", "Key", ":", "map", "[", "string", "]", "*", "dynamodb", ".", "AttributeValue", "{", "keySessionID", ":", "item", "[", "keySessionID", "]", ",", "keyEventIndex", ":", "item", "[", "keyEventIndex", "]", ",", "}", ",", "}", ",", "}", ")", "\n", "}", "\n", "if", "len", "(", "requests", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "req", ",", "_", ":=", "b", ".", "svc", ".", "BatchWriteItemRequest", "(", "&", "dynamodb", ".", "BatchWriteItemInput", "{", "RequestItems", ":", "map", "[", "string", "]", "[", "]", "*", "dynamodb", ".", "WriteRequest", "{", "b", ".", "Tablename", ":", "requests", ",", "}", ",", "}", ")", "\n", "err", "=", "req", ".", "Send", "(", ")", "\n", "err", "=", "convertError", "(", "err", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "deleteAllItems", "deletes", "all", "items", "from", "the", "database", "used", "in", "tests" ]

[ "func", "NewEventsService", "(", "b", "backend", ".", "Backend", ")", "*", "EventsService", "{", "return", "&", "EventsService", "{", "Entry", ":", "logrus", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "trace", ".", "Component", ":", "\"", "\"", "}", ")", ",", "backend", ":", "b", ",", "}", "\n", "}" ]

[ "NewEventsService", "returns", "new", "events", "service", "instance" ]

[ "func", "base", "(", "key", "[", "]", "byte", ",", "offset", "int", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "parts", ":=", "bytes", ".", "Split", "(", "key", ",", "[", "]", "byte", "{", "backend", ".", "Separator", "}", ")", "\n", "if", "len", "(", "parts", ")", "<", "offset", "+", "1", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "string", "(", "key", ")", ")", "\n", "}", "\n", "return", "parts", "[", "len", "(", "parts", ")", "-", "offset", "-", "1", "]", ",", "nil", "\n", "}" ]

[ "base", "returns", "last", "element", "delimited", "by", "separator", "index", "is", "is", "an", "index", "of", "the", "key", "part", "to", "get", "counting", "from", "the", "end" ]

[ "func", "baseTwoKeys", "(", "key", "[", "]", "byte", ")", "(", "string", ",", "string", ",", "error", ")", "{", "parts", ":=", "bytes", ".", "Split", "(", "key", ",", "[", "]", "byte", "{", "backend", ".", "Separator", "}", ")", "\n", "if", "len", "(", "parts", ")", "<", "2", "{", "return", "\"", "\"", ",", "\"", "\"", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "string", "(", "key", ")", ")", "\n", "}", "\n", "return", "string", "(", "parts", "[", "len", "(", "parts", ")", "-", "2", "]", ")", ",", "string", "(", "parts", "[", "len", "(", "parts", ")", "-", "1", "]", ")", ",", "nil", "\n", "}" ]

[ "baseTwoKeys", "returns", "two", "last", "keys" ]

[ "func", "NewWrapper", "(", "writer", "AccessPoint", ",", "cache", "ReadAccessPoint", ")", "AccessPoint", "{", "return", "&", "Wrapper", "{", "Write", ":", "writer", ",", "ReadAccessPoint", ":", "cache", ",", "}", "\n", "}" ]

[ "NewWrapper", "returns", "new", "access", "point", "wrapper" ]

[ "func", "(", "w", "*", "Wrapper", ")", "UpsertNode", "(", "s", "services", ".", "Server", ")", "(", "*", "services", ".", "KeepAlive", ",", "error", ")", "{", "return", "w", ".", "Write", ".", "UpsertNode", "(", "s", ")", "\n", "}" ]

[ "UpsertNode", "is", "part", "of", "auth", ".", "AccessPoint", "implementation" ]

[ "func", "(", "w", "*", "Wrapper", ")", "UpsertAuthServer", "(", "s", "services", ".", "Server", ")", "error", "{", "return", "w", ".", "Write", ".", "UpsertAuthServer", "(", "s", ")", "\n", "}" ]

[ "UpsertAuthServer", "is", "part", "of", "auth", ".", "AccessPoint", "implementation" ]

[ "func", "(", "w", "*", "Wrapper", ")", "UpsertProxy", "(", "s", "services", ".", "Server", ")", "error", "{", "return", "w", ".", "Write", ".", "UpsertProxy", "(", "s", ")", "\n", "}" ]

[ "UpsertProxy", "is", "part", "of", "auth", ".", "AccessPoint", "implementation" ]

[ "func", "(", "w", "*", "Wrapper", ")", "UpsertTunnelConnection", "(", "conn", "services", ".", "TunnelConnection", ")", "error", "{", "return", "w", ".", "Write", ".", "UpsertTunnelConnection", "(", "conn", ")", "\n", "}" ]

[ "UpsertTunnelConnection", "is", "a", "part", "of", "auth", ".", "AccessPoint", "implementation" ]

[ "func", "(", "w", "*", "Wrapper", ")", "DeleteTunnelConnection", "(", "clusterName", ",", "connName", "string", ")", "error", "{", "return", "w", ".", "Write", ".", "DeleteTunnelConnection", "(", "clusterName", ",", "connName", ")", "\n", "}" ]

[ "DeleteTunnelConnection", "is", "a", "part", "of", "auth", ".", "AccessPoint", "implementation" ]

[ "func", "SetShutdownPollPeriod", "(", "period", "time", ".", "Duration", ")", "ServerOption", "{", "return", "func", "(", "s", "*", "Server", ")", "error", "{", "s", ".", "shutdownPollPeriod", "=", "period", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "SetShutdownPollPeriod", "sets", "a", "polling", "period", "for", "graceful", "shutdowns", "of", "SSH", "servers" ]

[ "func", "(", "s", "*", "Server", ")", "Wait", "(", "ctx", "context", ".", "Context", ")", "{", "select", "{", "case", "<-", "s", ".", "closeContext", ".", "Done", "(", ")", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "}", "\n", "}" ]

[ "Wait", "waits", "until", "server", "stops", "serving", "new", "connections", "on", "the", "listener", "socket" ]

[ "func", "(", "s", "*", "Server", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "error", "{", "// close listener to stop receiving new connections", "err", ":=", "s", ".", "Close", "(", ")", "\n", "s", ".", "Wait", "(", "ctx", ")", "\n", "activeConnections", ":=", "s", ".", "trackConnections", "(", "0", ")", "\n", "if", "activeConnections", "==", "0", "{", "return", "err", "\n", "}", "\n", "s", ".", "Infof", "(", "\"", "\"", ",", "activeConnections", ")", "\n", "lastReport", ":=", "time", ".", "Time", "{", "}", "\n", "ticker", ":=", "time", ".", "NewTicker", "(", "s", ".", "shutdownPollPeriod", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "activeConnections", "=", "s", ".", "trackConnections", "(", "0", ")", "\n", "if", "activeConnections", "==", "0", "{", "return", "err", "\n", "}", "\n", "if", "time", ".", "Now", "(", ")", ".", "Sub", "(", "lastReport", ")", ">", "10", "*", "s", ".", "shutdownPollPeriod", "{", "s", ".", "Infof", "(", "\"", "\"", ",", "activeConnections", ")", "\n", "lastReport", "=", "time", ".", "Now", "(", ")", "\n", "}", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "s", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "trace", ".", "ConnectionProblem", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Shutdown", "initiates", "graceful", "shutdown", "-", "waiting", "until", "all", "active", "connections", "will", "get", "closed" ]

[ "func", "validateHostSigner", "(", "signer", "ssh", ".", "Signer", ")", "error", "{", "cert", ",", "ok", ":=", "signer", ".", "PublicKey", "(", ")", ".", "(", "*", "ssh", ".", "Certificate", ")", "\n", "if", "!", "ok", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "cert", ".", "ValidPrincipals", ")", "==", "0", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "certChecker", ":=", "utils", ".", "CertChecker", "{", "}", "\n", "err", ":=", "certChecker", ".", "CheckCert", "(", "cert", ".", "ValidPrincipals", "[", "0", "]", ",", "cert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "validateHostSigner", "make", "sure", "the", "signer", "is", "a", "valid", "certificate", "." ]

[ "func", "KeysEqual", "(", "ak", ",", "bk", "ssh", ".", "PublicKey", ")", "bool", "{", "a", ":=", "ssh", ".", "Marshal", "(", "ak", ")", "\n", "b", ":=", "ssh", ".", "Marshal", "(", "bk", ")", "\n", "return", "(", "len", "(", "a", ")", "==", "len", "(", "b", ")", "&&", "subtle", ".", "ConstantTimeCompare", "(", "a", ",", "b", ")", "==", "1", ")", "\n", "}" ]

[ "KeysEqual", "is", "constant", "time", "compare", "of", "the", "keys", "to", "avoid", "timing", "attacks" ]

[ "func", "(", "w", "*", "Watch", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "w", ".", "Name", ",", "string", "(", "bytes", ".", "Join", "(", "w", ".", "Prefixes", ",", "[", "]", "byte", "(", "\"", "\"", ")", ")", ")", ")", "\n", "}" ]

[ "String", "returns", "a", "user", "-", "friendly", "description", "of", "the", "watcher" ]

[ "func", "(", "p", "Params", ")", "GetString", "(", "key", "string", ")", "string", "{", "v", ",", "ok", ":=", "p", "[", "key", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", "\n", "}", "\n", "s", ",", "_", ":=", "v", ".", "(", "string", ")", "\n", "return", "s", "\n", "}" ]

[ "GetString", "returns", "a", "string", "value", "stored", "in", "Params", "map", "or", "an", "empty", "string", "if", "nothing", "is", "found" ]

[ "func", "RangeEnd", "(", "key", "[", "]", "byte", ")", "[", "]", "byte", "{", "end", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "key", ")", ")", "\n", "copy", "(", "end", ",", "key", ")", "\n", "for", "i", ":=", "len", "(", "end", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "if", "end", "[", "i", "]", "<", "0xff", "{", "end", "[", "i", "]", "=", "end", "[", "i", "]", "+", "1", "\n", "end", "=", "end", "[", ":", "i", "+", "1", "]", "\n", "return", "end", "\n", "}", "\n", "}", "\n", "// next key does not exist (e.g., 0xffff);", "return", "noEnd", "\n", "}" ]

[ "RangeEnd", "returns", "end", "of", "the", "range", "for", "given", "key" ]

[ "func", "TTL", "(", "clock", "clockwork", ".", "Clock", ",", "expires", "time", ".", "Time", ")", "time", ".", "Duration", "{", "ttl", ":=", "expires", ".", "Sub", "(", "clock", ".", "Now", "(", ")", ")", "\n", "if", "ttl", "<", "time", ".", "Second", "{", "return", "time", ".", "Second", "\n", "}", "\n", "return", "ttl", "\n", "}" ]

[ "TTL", "returns", "TTL", "in", "duration", "units", "rounds", "up", "to", "one", "second" ]

[ "func", "EarliestExpiry", "(", "times", "...", "time", ".", "Time", ")", "time", ".", "Time", "{", "if", "len", "(", "times", ")", "==", "0", "{", "return", "time", ".", "Time", "{", "}", "\n", "}", "\n", "sort", ".", "Sort", "(", "earliest", "(", "times", ")", ")", "\n", "return", "times", "[", "0", "]", "\n", "}" ]

[ "EarliestExpiry", "returns", "first", "of", "the", "otherwise", "returns", "empty" ]

[ "func", "Expiry", "(", "clock", "clockwork", ".", "Clock", ",", "ttl", "time", ".", "Duration", ")", "time", ".", "Time", "{", "if", "ttl", "==", "0", "{", "return", "time", ".", "Time", "{", "}", "\n", "}", "\n", "return", "clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Add", "(", "ttl", ")", "\n", "}" ]

[ "Expiry", "converts", "ttl", "to", "expiry", "time", "if", "ttl", "is", "0", "returns", "empty", "time" ]

[ "func", "Dial", "(", "socket", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "conn", ",", "err", ":=", "net", ".", "Dial", "(", "\"", "\"", ",", "socket", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "Dial", "creates", "net", ".", "Conn", "to", "a", "SSH", "agent", "listening", "on", "a", "Unix", "socket", "." ]

[ "func", "NewAuthPreference", "(", "spec", "AuthPreferenceSpecV2", ")", "(", "AuthPreference", ",", "error", ")", "{", "return", "&", "AuthPreferenceV2", "{", "Kind", ":", "KindClusterAuthPreference", ",", "Version", ":", "V2", ",", "Metadata", ":", "Metadata", "{", "Name", ":", "MetaNameClusterAuthPreference", ",", "Namespace", ":", "defaults", ".", "Namespace", ",", "}", ",", "Spec", ":", "spec", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAuthPreference", "is", "a", "convenience", "method", "to", "to", "create", "AuthPreferenceV2", "." ]

[ "func", "(", "c", "*", "AuthPreferenceV2", ")", "GetU2F", "(", ")", "(", "*", "U2F", ",", "error", ")", "{", "if", "c", ".", "Spec", ".", "U2F", "==", "nil", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "c", ".", "Spec", ".", "U2F", ",", "nil", "\n", "}" ]

[ "GetU2F", "gets", "the", "U2F", "configuration", "settings", "." ]

[ "func", "(", "c", "*", "AuthPreferenceV2", ")", "CheckAndSetDefaults", "(", ")", "error", "{", "// if nothing is passed in, set defaults", "if", "c", ".", "Spec", ".", "Type", "==", "\"", "\"", "{", "c", ".", "Spec", ".", "Type", "=", "teleport", ".", "Local", "\n", "}", "\n", "if", "c", ".", "Spec", ".", "SecondFactor", "==", "\"", "\"", "{", "c", ".", "Spec", ".", "SecondFactor", "=", "teleport", ".", "OTP", "\n", "}", "\n\n", "// make sure type makes sense", "switch", "c", ".", "Spec", ".", "Type", "{", "case", "teleport", ".", "Local", ",", "teleport", ".", "OIDC", ",", "teleport", ".", "SAML", ",", "teleport", ".", "Github", ":", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "c", ".", "Spec", ".", "Type", ")", "\n", "}", "\n\n", "// make sure second factor makes sense", "switch", "c", ".", "Spec", ".", "SecondFactor", "{", "case", "teleport", ".", "OFF", ",", "teleport", ".", "OTP", ",", "teleport", ".", "U2F", ":", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "c", ".", "Spec", ".", "SecondFactor", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "verifies", "the", "constraints", "for", "AuthPreference", "." ]

[ "func", "(", "c", "*", "AuthPreferenceV2", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Spec", ".", "Type", ",", "c", ".", "Spec", ".", "SecondFactor", ")", "\n", "}" ]

[ "String", "represents", "a", "human", "readable", "version", "of", "authentication", "settings", "." ]

[ "func", "GetAuthPreferenceSchema", "(", "extensionSchema", "string", ")", "string", "{", "var", "authPreferenceSchema", "string", "\n", "if", "authPreferenceSchema", "==", "\"", "\"", "{", "authPreferenceSchema", "=", "fmt", ".", "Sprintf", "(", "AuthPreferenceSpecSchemaTemplate", ",", "\"", "\"", ")", "\n", "}", "else", "{", "authPreferenceSchema", "=", "fmt", ".", "Sprintf", "(", "AuthPreferenceSpecSchemaTemplate", ",", "\"", "\"", "+", "extensionSchema", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "V2SchemaTemplate", ",", "MetadataSchema", ",", "authPreferenceSchema", ",", "DefaultDefinitions", ")", "\n", "}" ]

[ "GetAuthPreferenceSchema", "returns", "the", "schema", "with", "optionally", "injected", "schema", "for", "extensions", "." ]

[ "func", "(", "t", "*", "proxySubsys", ")", "proxyToSite", "(", "ctx", "*", "srv", ".", "ServerContext", ",", "site", "reversetunnel", ".", "RemoteSite", ",", "remoteAddr", "net", ".", "Addr", ",", "ch", "ssh", ".", "Channel", ")", "error", "{", "conn", ",", "err", ":=", "site", ".", "DialAuthServer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "t", ".", "log", ".", "Infof", "(", "\"", "\"", ",", "conn", ".", "RemoteAddr", "(", ")", ")", "\n\n", "go", "func", "(", ")", "{", "var", "err", "error", "\n", "defer", "func", "(", ")", "{", "t", ".", "close", "(", "err", ")", "\n", "}", "(", ")", "\n", "defer", "ch", ".", "Close", "(", ")", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "ch", ",", "conn", ")", "\n", "}", "(", ")", "\n", "go", "func", "(", ")", "{", "var", "err", "error", "\n", "defer", "func", "(", ")", "{", "t", ".", "close", "(", "err", ")", "\n", "}", "(", ")", "\n", "defer", "conn", ".", "Close", "(", ")", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "conn", ",", "srv", ".", "NewTrackingReader", "(", "ctx", ",", "ch", ")", ")", "\n\n", "}", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "proxyToSite", "establishes", "a", "proxy", "connection", "from", "the", "connected", "SSH", "client", "to", "the", "auth", "server", "of", "the", "requested", "remote", "site" ]

[ "func", "ListenTLS", "(", "address", "string", ",", "certFile", ",", "keyFile", "string", ",", "cipherSuites", "[", "]", "uint16", ")", "(", "net", ".", "Listener", ",", "error", ")", "{", "tlsConfig", ",", "err", ":=", "CreateTLSConfiguration", "(", "certFile", ",", "keyFile", ",", "cipherSuites", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "tls", ".", "Listen", "(", "\"", "\"", ",", "address", ",", "tlsConfig", ")", "\n", "}" ]

[ "ListenTLS", "sets", "up", "TLS", "listener", "for", "the", "http", "handler", "starts", "listening", "on", "a", "TCP", "socket", "and", "returns", "the", "socket", "which", "is", "ready", "to", "be", "used", "for", "http", ".", "Serve" ]

[ "func", "TLSConfig", "(", "cipherSuites", "[", "]", "uint16", ")", "*", "tls", ".", "Config", "{", "config", ":=", "&", "tls", ".", "Config", "{", "}", "\n\n", "// If ciphers suites were passed in, use them. Otherwise use the the", "// Go defaults.", "if", "len", "(", "cipherSuites", ")", ">", "0", "{", "config", ".", "CipherSuites", "=", "cipherSuites", "\n", "}", "\n\n", "// Pick the servers preferred ciphersuite, not the clients.", "config", ".", "PreferServerCipherSuites", "=", "true", "\n\n", "config", ".", "MinVersion", "=", "tls", ".", "VersionTLS12", "\n", "config", ".", "SessionTicketsDisabled", "=", "false", "\n", "config", ".", "ClientSessionCache", "=", "tls", ".", "NewLRUClientSessionCache", "(", "DefaultLRUCapacity", ")", "\n", "return", "config", "\n", "}" ]

[ "TLSConfig", "returns", "default", "TLS", "configuration", "strong", "defaults", "." ]

[ "func", "CreateTLSConfiguration", "(", "certFile", ",", "keyFile", "string", ",", "cipherSuites", "[", "]", "uint16", ")", "(", "*", "tls", ".", "Config", ",", "error", ")", "{", "config", ":=", "TLSConfig", "(", "cipherSuites", ")", "\n\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "certFile", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "certFile", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "keyFile", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "certFile", ")", "\n", "}", "\n\n", "cert", ",", "err", ":=", "tls", ".", "LoadX509KeyPair", "(", "certFile", ",", "keyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "config", ".", "Certificates", "=", "[", "]", "tls", ".", "Certificate", "{", "cert", "}", "\n\n", "return", "config", ",", "nil", "\n", "}" ]

[ "CreateTLSConfiguration", "sets", "up", "default", "TLS", "configuration" ]

[ "func", "GenerateSelfSignedCert", "(", "hostNames", "[", "]", "string", ")", "(", "*", "TLSCredentials", ",", "error", ")", "{", "priv", ",", "err", ":=", "rsa", ".", "GenerateKey", "(", "rand", ".", "Reader", ",", "teleport", ".", "RSAKeySize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "notBefore", ":=", "time", ".", "Now", "(", ")", "\n", "notAfter", ":=", "notBefore", ".", "Add", "(", "time", ".", "Hour", "*", "24", "*", "365", "*", "10", ")", "// 10 years", "\n\n", "serialNumberLimit", ":=", "new", "(", "big", ".", "Int", ")", ".", "Lsh", "(", "big", ".", "NewInt", "(", "1", ")", ",", "128", ")", "\n", "serialNumber", ",", "err", ":=", "rand", ".", "Int", "(", "rand", ".", "Reader", ",", "serialNumberLimit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "entity", ":=", "pkix", ".", "Name", "{", "CommonName", ":", "\"", "\"", ",", "Country", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "Organization", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", "\n\n", "template", ":=", "x509", ".", "Certificate", "{", "SerialNumber", ":", "serialNumber", ",", "Issuer", ":", "entity", ",", "Subject", ":", "entity", ",", "NotBefore", ":", "notBefore", ",", "NotAfter", ":", "notAfter", ",", "KeyUsage", ":", "x509", ".", "KeyUsageKeyEncipherment", "|", "x509", ".", "KeyUsageDigitalSignature", "|", "x509", ".", "KeyUsageCertSign", ",", "BasicConstraintsValid", ":", "true", ",", "IsCA", ":", "true", ",", "}", "\n\n", "// collect IP addresses localhost resolves to and add them to the cert. template:", "template", ".", "DNSNames", "=", "append", "(", "hostNames", ",", "\"", "\"", ")", "\n", "ips", ",", "_", ":=", "net", ".", "LookupIP", "(", "\"", "\"", ")", "\n", "if", "ips", "!=", "nil", "{", "template", ".", "IPAddresses", "=", "ips", "\n", "}", "\n", "derBytes", ",", "err", ":=", "x509", ".", "CreateCertificate", "(", "rand", ".", "Reader", ",", "&", "template", ",", "&", "template", ",", "&", "priv", ".", "PublicKey", ",", "priv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "publicKeyBytes", ",", "err", ":=", "x509", ".", "MarshalPKIXPublicKey", "(", "priv", ".", "Public", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", "err", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "TLSCredentials", "{", "PublicKey", ":", "pem", ".", "EncodeToMemory", "(", "&", "pem", ".", "Block", "{", "Type", ":", "\"", "\"", ",", "Bytes", ":", "publicKeyBytes", "}", ")", ",", "PrivateKey", ":", "pem", ".", "EncodeToMemory", "(", "&", "pem", ".", "Block", "{", "Type", ":", "\"", "\"", ",", "Bytes", ":", "x509", ".", "MarshalPKCS1PrivateKey", "(", "priv", ")", "}", ")", ",", "Cert", ":", "pem", ".", "EncodeToMemory", "(", "&", "pem", ".", "Block", "{", "Type", ":", "\"", "\"", ",", "Bytes", ":", "derBytes", "}", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "GenerateSelfSignedCert", "generates", "a", "self", "signed", "certificate", "that", "is", "valid", "for", "given", "domain", "names", "and", "ips", "returns", "PEM", "-", "encoded", "bytes", "with", "key", "and", "cert" ]

[ "func", "CipherSuiteMapping", "(", "cipherSuites", "[", "]", "string", ")", "(", "[", "]", "uint16", ",", "error", ")", "{", "out", ":=", "make", "(", "[", "]", "uint16", ",", "0", ",", "len", "(", "cipherSuites", ")", ")", "\n\n", "for", "_", ",", "cs", ":=", "range", "cipherSuites", "{", "c", ",", "ok", ":=", "cipherSuiteMapping", "[", "cs", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "cs", ")", "\n", "}", "\n\n", "out", "=", "append", "(", "out", ",", "c", ")", "\n", "}", "\n\n", "return", "out", ",", "nil", "\n", "}" ]

[ "CipherSuiteMapping", "transforms", "Teleport", "formatted", "cipher", "suites", "strings", "into", "uint16", "IDs", "." ]

[ "func", "NewTerminal", "(", "ctx", "*", "ServerContext", ")", "(", "Terminal", ",", "error", ")", "{", "// It doesn't matter what mode the cluster is in, if this is a Teleport node", "// return a local terminal.", "if", "ctx", ".", "srv", ".", "Component", "(", ")", "==", "teleport", ".", "ComponentNode", "{", "return", "newLocalTerminal", "(", "ctx", ")", "\n", "}", "\n\n", "// If this is not a Teleport node, find out what mode the cluster is in and", "// return the correct terminal.", "if", "ctx", ".", "ClusterConfig", ".", "GetSessionRecording", "(", ")", "==", "services", ".", "RecordAtProxy", "{", "return", "newRemoteTerminal", "(", "ctx", ")", "\n", "}", "\n", "return", "newLocalTerminal", "(", "ctx", ")", "\n", "}" ]

[ "NewTerminal", "returns", "a", "new", "terminal", ".", "Terminal", "can", "be", "local", "or", "remote", "depending", "on", "cluster", "configuration", "." ]

[ "func", "newLocalTerminal", "(", "ctx", "*", "ServerContext", ")", "(", "*", "terminal", ",", "error", ")", "{", "var", "err", "error", "\n\n", "t", ":=", "&", "terminal", "{", "log", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "ComponentLocalTerm", ",", "}", ")", ",", "ctx", ":", "ctx", ",", "}", "\n\n", "// Open PTY and corresponding TTY.", "t", ".", "pty", ",", "t", ".", "tty", ",", "err", "=", "pty", ".", "Open", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Set the TTY owner. Failure is not fatal, for example Teleport is running", "// on a read-only filesystem, but logging is useful for diagnostic purposes.", "err", "=", "t", ".", "setOwner", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debugf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "t", ",", "nil", "\n", "}" ]

[ "NewLocalTerminal", "creates", "and", "returns", "a", "local", "PTY", "." ]

[ "func", "(", "t", "*", "terminal", ")", "Run", "(", ")", "error", "{", "defer", "t", ".", "closeTTY", "(", ")", "\n\n", "cmd", ",", "err", ":=", "prepareInteractiveCommand", "(", "t", ".", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "t", ".", "cmd", "=", "cmd", "\n\n", "cmd", ".", "Stdout", "=", "t", ".", "tty", "\n", "cmd", ".", "Stdin", "=", "t", ".", "tty", "\n", "cmd", ".", "Stderr", "=", "t", ".", "tty", "\n", "cmd", ".", "SysProcAttr", ".", "Setctty", "=", "true", "\n", "cmd", ".", "SysProcAttr", ".", "Setsid", "=", "true", "\n\n", "err", "=", "cmd", ".", "Start", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Run", "will", "run", "the", "terminal", "." ]

[ "func", "(", "t", "*", "terminal", ")", "Wait", "(", ")", "(", "*", "ExecResult", ",", "error", ")", "{", "err", ":=", "t", ".", "cmd", ".", "Wait", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "exitErr", ",", "ok", ":=", "err", ".", "(", "*", "exec", ".", "ExitError", ")", ";", "ok", "{", "status", ":=", "exitErr", ".", "Sys", "(", ")", ".", "(", "syscall", ".", "WaitStatus", ")", "\n", "return", "&", "ExecResult", "{", "Code", ":", "status", ".", "ExitStatus", "(", ")", ",", "Command", ":", "t", ".", "cmd", ".", "Path", "}", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "status", ",", "ok", ":=", "t", ".", "cmd", ".", "ProcessState", ".", "Sys", "(", ")", ".", "(", "syscall", ".", "WaitStatus", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "Errorf", "(", "\"", "\"", ",", "t", ".", "cmd", ".", "ProcessState", ".", "Sys", "(", ")", ",", "t", ".", "cmd", ".", "ProcessState", ".", "Sys", "(", ")", ")", "\n", "}", "\n\n", "return", "&", "ExecResult", "{", "Code", ":", "status", ".", "ExitStatus", "(", ")", ",", "Command", ":", "t", ".", "cmd", ".", "Path", ",", "}", ",", "nil", "\n", "}" ]

[ "Wait", "will", "block", "until", "the", "terminal", "is", "complete", "." ]

[ "func", "(", "t", "*", "terminal", ")", "Kill", "(", ")", "error", "{", "if", "t", ".", "cmd", ".", "Process", "!=", "nil", "{", "if", "err", ":=", "t", ".", "cmd", ".", "Process", ".", "Kill", "(", ")", ";", "err", "!=", "nil", "{", "if", "err", ".", "Error", "(", ")", "!=", "\"", "\"", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Kill", "will", "force", "kill", "the", "terminal", "." ]

[ "func", "(", "t", "*", "terminal", ")", "Close", "(", ")", "error", "{", "var", "err", "error", "\n", "// note, pty is closed in the copying goroutine,", "// not here to avoid data races", "if", "t", ".", "tty", "!=", "nil", "{", "if", "e", ":=", "t", ".", "tty", ".", "Close", "(", ")", ";", "e", "!=", "nil", "{", "err", "=", "e", "\n", "}", "\n", "}", "\n", "go", "t", ".", "closePTY", "(", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "Close", "will", "free", "resources", "associated", "with", "the", "terminal", "." ]

[ "func", "(", "t", "*", "terminal", ")", "GetWinSize", "(", ")", "(", "*", "term", ".", "Winsize", ",", "error", ")", "{", "t", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "t", ".", "pty", "==", "nil", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "ws", ",", "err", ":=", "term", ".", "GetWinsize", "(", "t", ".", "pty", ".", "Fd", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "ws", ",", "nil", "\n", "}" ]

[ "GetWinSize", "returns", "the", "window", "size", "of", "the", "terminal", "." ]

[ "func", "(", "t", "*", "terminal", ")", "SetWinSize", "(", "params", "rsession", ".", "TerminalParams", ")", "error", "{", "t", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "t", ".", "pty", "==", "nil", "{", "return", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "term", ".", "SetWinsize", "(", "t", ".", "pty", ".", "Fd", "(", ")", ",", "params", ".", "Winsize", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "t", ".", "params", "=", "params", "\n", "return", "nil", "\n", "}" ]

[ "SetWinSize", "sets", "the", "window", "size", "of", "the", "terminal", "." ]

[ "func", "(", "t", "*", "terminal", ")", "GetTerminalParams", "(", ")", "rsession", ".", "TerminalParams", "{", "t", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "t", ".", "params", "\n", "}" ]

[ "GetTerminalParams", "is", "a", "fast", "call", "to", "get", "cached", "terminal", "parameters", "and", "avoid", "extra", "system", "call", "." ]

[ "func", "(", "t", "*", "terminal", ")", "SetTermType", "(", "term", "string", ")", "{", "if", "term", "==", "\"", "\"", "{", "term", "=", "defaultTerm", "\n", "}", "\n", "t", ".", "termType", "=", "term", "\n", "}" ]

[ "SetTermType", "sets", "the", "terminal", "type", "from", "req", "-", "pty", "request", "." ]

[ "func", "(", "t", "*", "terminal", ")", "setOwner", "(", ")", "error", "{", "uid", ",", "gid", ",", "mode", ",", "err", ":=", "getOwner", "(", "t", ".", "ctx", ".", "Identity", ".", "Login", ",", "user", ".", "Lookup", ",", "user", ".", "LookupGroup", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "os", ".", "Chown", "(", "t", ".", "tty", ".", "Name", "(", ")", ",", "uid", ",", "gid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "os", ".", "Chmod", "(", "t", ".", "tty", ".", "Name", "(", ")", ",", "mode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "t", ".", "tty", ".", "Name", "(", ")", ",", "uid", ",", "gid", ",", "mode", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "setOwner", "changes", "the", "owner", "and", "mode", "of", "the", "TTY", "." ]

[ "func", "(", "t", "*", "remoteTerminal", ")", "prepareRemoteSession", "(", "session", "*", "ssh", ".", "Session", ",", "ctx", "*", "ServerContext", ")", "{", "envs", ":=", "map", "[", "string", "]", "string", "{", "teleport", ".", "SSHTeleportUser", ":", "ctx", ".", "Identity", ".", "TeleportUser", ",", "teleport", ".", "SSHSessionWebproxyAddr", ":", "ctx", ".", "ProxyPublicAddress", "(", ")", ",", "teleport", ".", "SSHTeleportHostUUID", ":", "ctx", ".", "srv", ".", "ID", "(", ")", ",", "teleport", ".", "SSHTeleportClusterName", ":", "ctx", ".", "ClusterName", ",", "teleport", ".", "SSHSessionID", ":", "string", "(", "ctx", ".", "session", ".", "id", ")", ",", "}", "\n\n", "for", "k", ",", "v", ":=", "range", "envs", "{", "if", "err", ":=", "session", ".", "Setenv", "(", "k", ",", "v", ")", ";", "err", "!=", "nil", "{", "t", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "k", ",", "v", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "prepareRemoteSession", "prepares", "the", "more", "session", "for", "execution", "." ]

[ "func", "NewAuthServer", "(", "cfg", "*", "InitConfig", ",", "opts", "...", "AuthServerOption", ")", "(", "*", "AuthServer", ",", "error", ")", "{", "if", "cfg", ".", "Trust", "==", "nil", "{", "cfg", ".", "Trust", "=", "local", ".", "NewCAService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "Presence", "==", "nil", "{", "cfg", ".", "Presence", "=", "local", ".", "NewPresenceService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "Provisioner", "==", "nil", "{", "cfg", ".", "Provisioner", "=", "local", ".", "NewProvisioningService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "Identity", "==", "nil", "{", "cfg", ".", "Identity", "=", "local", ".", "NewIdentityService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "Access", "==", "nil", "{", "cfg", ".", "Access", "=", "local", ".", "NewAccessService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "ClusterConfiguration", "==", "nil", "{", "cfg", ".", "ClusterConfiguration", "=", "local", ".", "NewClusterConfigurationService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "Events", "==", "nil", "{", "cfg", ".", "Events", "=", "local", ".", "NewEventsService", "(", "cfg", ".", "Backend", ")", "\n", "}", "\n", "if", "cfg", ".", "AuditLog", "==", "nil", "{", "cfg", ".", "AuditLog", "=", "events", ".", "NewDiscardAuditLog", "(", ")", "\n", "}", "\n\n", "limiter", ",", "err", ":=", "limiter", ".", "NewConnectionsLimiter", "(", "limiter", ".", "LimiterConfig", "{", "MaxConnections", ":", "defaults", ".", "LimiterMaxConcurrentSignatures", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "closeCtx", ",", "cancelFunc", ":=", "context", ".", "WithCancel", "(", "context", ".", "TODO", "(", ")", ")", "\n", "as", ":=", "AuthServer", "{", "bk", ":", "cfg", ".", "Backend", ",", "limiter", ":", "limiter", ",", "Authority", ":", "cfg", ".", "Authority", ",", "AuthServiceName", ":", "cfg", ".", "AuthServiceName", ",", "oidcClients", ":", "make", "(", "map", "[", "string", "]", "*", "oidcClient", ")", ",", "samlProviders", ":", "make", "(", "map", "[", "string", "]", "*", "samlProvider", ")", ",", "githubClients", ":", "make", "(", "map", "[", "string", "]", "*", "githubClient", ")", ",", "cancelFunc", ":", "cancelFunc", ",", "closeCtx", ":", "closeCtx", ",", "AuthServices", ":", "AuthServices", "{", "Trust", ":", "cfg", ".", "Trust", ",", "Presence", ":", "cfg", ".", "Presence", ",", "Provisioner", ":", "cfg", ".", "Provisioner", ",", "Identity", ":", "cfg", ".", "Identity", ",", "Access", ":", "cfg", ".", "Access", ",", "ClusterConfiguration", ":", "cfg", ".", "ClusterConfiguration", ",", "IAuditLog", ":", "cfg", ".", "AuditLog", ",", "Events", ":", "cfg", ".", "Events", ",", "}", ",", "}", "\n", "for", "_", ",", "o", ":=", "range", "opts", "{", "o", "(", "&", "as", ")", "\n", "}", "\n", "if", "as", ".", "clock", "==", "nil", "{", "as", ".", "clock", "=", "clockwork", ".", "NewRealClock", "(", ")", "\n", "}", "\n\n", "return", "&", "as", ",", "nil", "\n", "}" ]

[ "NewAuthServer", "creates", "and", "configures", "a", "new", "AuthServer", "instance" ]

[ "func", "(", "a", "*", "AuthServer", ")", "SetCache", "(", "clt", "AuthCache", ")", "{", "a", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "lock", ".", "Unlock", "(", ")", "\n", "a", ".", "cache", "=", "clt", "\n", "}" ]

[ "SetCache", "sets", "cache", "used", "by", "auth", "server" ]

[ "func", "(", "a", "*", "AuthServer", ")", "GetCache", "(", ")", "AuthCache", "{", "a", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "a", ".", "lock", ".", "RUnlock", "(", ")", "\n", "if", "a", ".", "cache", "==", "nil", "{", "return", "&", "a", ".", "AuthServices", "\n", "}", "\n", "return", "a", ".", "cache", "\n", "}" ]

[ "GetCache", "returns", "cache", "used", "by", "auth", "server" ]

[ "func", "(", "a", "*", "AuthServer", ")", "runPeriodicOperations", "(", ")", "{", "// run periodic functions with a semi-random period", "// to avoid contention on the database in case if there are multiple", "// auth servers running - so they don't compete trying", "// to update the same resources.", "r", ":=", "rand", ".", "New", "(", "rand", ".", "NewSource", "(", "a", ".", "GetClock", "(", ")", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", ")", "\n", "period", ":=", "defaults", ".", "HighResPollingPeriod", "+", "time", ".", "Duration", "(", "r", ".", "Intn", "(", "int", "(", "defaults", ".", "HighResPollingPeriod", "/", "time", ".", "Second", ")", ")", ")", "*", "time", ".", "Second", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "period", ")", "\n", "ticker", ":=", "time", ".", "NewTicker", "(", "period", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "a", ".", "closeCtx", ".", "Done", "(", ")", ":", "return", "\n", "case", "<-", "ticker", ".", "C", ":", "err", ":=", "a", ".", "autoRotateCertAuthorities", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsCompareFailed", "(", "err", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "runPeriodicOperations", "runs", "some", "periodic", "bookkeeping", "operations", "performed", "by", "auth", "server" ]

[ "func", "(", "a", "*", "AuthServer", ")", "SetClock", "(", "clock", "clockwork", ".", "Clock", ")", "{", "a", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "lock", ".", "Unlock", "(", ")", "\n", "a", ".", "clock", "=", "clock", "\n", "}" ]

[ "SetClock", "sets", "clock", "used", "in", "tests" ]

[ "func", "(", "a", "*", "AuthServer", ")", "GetClusterConfig", "(", "opts", "...", "services", ".", "MarshalOption", ")", "(", "services", ".", "ClusterConfig", ",", "error", ")", "{", "return", "a", ".", "GetCache", "(", ")", ".", "GetClusterConfig", "(", "opts", "...", ")", "\n", "}" ]

[ "GetClusterConfig", "gets", "ClusterConfig", "from", "the", "backend", "." ]

[ "func", "(", "a", "*", "AuthServer", ")", "GetClusterName", "(", "opts", "...", "services", ".", "MarshalOption", ")", "(", "services", ".", "ClusterName", ",", "error", ")", "{", "return", "a", ".", "GetCache", "(", ")", ".", "GetClusterName", "(", "opts", "...", ")", "\n", "}" ]

[ "GetClusterName", "returns", "the", "domain", "name", "that", "identifies", "this", "authority", "server", ".", "Also", "known", "as", "cluster", "name" ]

[ "func", "(", "a", "*", "AuthServer", ")", "GetDomainName", "(", ")", "(", "string", ",", "error", ")", "{", "clusterName", ",", "err", ":=", "a", ".", "GetClusterName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "clusterName", ".", "GetClusterName", "(", ")", ",", "nil", "\n", "}" ]

[ "GetDomainName", "returns", "the", "domain", "name", "that", "identifies", "this", "authority", "server", ".", "Also", "known", "as", "cluster", "name" ]

[ "func", "(", "a", "*", "AuthServer", ")", "GenerateUserCerts", "(", "key", "[", "]", "byte", ",", "username", "string", ",", "ttl", "time", ".", "Duration", ",", "compatibility", "string", ")", "(", "[", "]", "byte", ",", "[", "]", "byte", ",", "error", ")", "{", "user", ",", "err", ":=", "a", ".", "Identity", ".", "GetUser", "(", "username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "checker", ",", "err", ":=", "services", ".", "FetchRoles", "(", "user", ".", "GetRoles", "(", ")", ",", "a", ".", "Access", ",", "user", ".", "GetTraits", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "certs", ",", "err", ":=", "a", ".", "generateUserCert", "(", "certRequest", "{", "user", ":", "user", ",", "roles", ":", "checker", ",", "ttl", ":", "ttl", ",", "compatibility", ":", "compatibility", ",", "publicKey", ":", "key", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "certs", ".", "ssh", ",", "certs", ".", "tls", ",", "nil", "\n", "}" ]

[ "GenerateUserCerts", "is", "used", "to", "generate", "user", "certificate", "used", "internally", "for", "tests" ]