Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "save", "(", "filename", ",", "passphrase", "string", ",", "data", "map", "[", "string", "]", "string", ")", "error", "{", "buf", ",", "err", ":=", "seal", "(", "data", ",", "passphrase", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "ioutil", ".", "WriteFile", "(", "filename", ",", "buf", ",", "0600", ")", "\n", "}" ]

[ "save", "will", "try", "to", "marshal", "seal", "and", "write", "to", "disk" ]

[ "func", "seal", "(", "data", "map", "[", "string", "]", "string", ",", "passphrase", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "jstr", ",", "err", ":=", "json", ".", "Marshal", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "nonce", "[", "nonceLength", "]", "byte", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "crypto_rand", ".", "Reader", ",", "nonce", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "salt", ":=", "make", "(", "[", "]", "byte", ",", "saltLength", ")", "\n", "if", "_", ",", "err", ":=", "crypto_rand", ".", "Read", "(", "salt", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "secretKey", ":=", "deriveKey", "(", "passphrase", ",", "salt", ")", "\n", "prefix", ":=", "append", "(", "salt", ",", "nonce", "[", ":", "]", "...", ")", "\n", "return", "secretbox", ".", "Seal", "(", "prefix", ",", "jstr", ",", "&", "nonce", ",", "&", "secretKey", ")", ",", "nil", "\n", "}" ]

[ "seal", "will", "try", "to", "marshal", "and", "seal", "the", "given", "data" ]

[ "func", "AskForPrivateKey", "(", "ctx", "context", ".", "Context", ",", "crypto", "backend", ".", "Crypto", ",", "name", ",", "prompt", "string", ")", "(", "string", ",", "error", ")", "{", "if", "!", "ctxutil", ".", "IsInteractive", "(", "ctx", ")", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "crypto", "==", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "kl", ",", "err", ":=", "crypto", ".", "ListPrivateKeyIDs", "(", "gpg", ".", "WithAlwaysTrust", "(", "ctx", ",", "false", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "len", "(", "kl", ")", "<", "1", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "maxTries", ";", "i", "++", "{", "if", "!", "ctxutil", ".", "IsTerminal", "(", "ctx", ")", "{", "return", "kl", "[", "0", "]", ",", "nil", "\n", "}", "\n", "// check for context cancelation", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "}", "\n\n", "fmt", ".", "Fprintln", "(", "Stdout", ",", "prompt", ")", "\n", "for", "i", ",", "k", ":=", "range", "kl", "{", "fmt", ".", "Fprintf", "(", "Stdout", ",", "\"", "\\n", "\"", ",", "i", ",", "crypto", ".", "Name", "(", ")", ",", "crypto", ".", "FormatKey", "(", "ctx", ",", "k", ")", ")", "\n", "}", "\n", "iv", ",", "err", ":=", "termio", ".", "AskForInt", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "kl", ")", "-", "1", ")", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", ".", "Error", "(", ")", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "continue", "\n", "}", "\n", "if", "iv", ">=", "0", "&&", "iv", "<", "len", "(", "kl", ")", "{", "return", "kl", "[", "iv", "]", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "AskForPrivateKey", "promts", "the", "user", "to", "select", "from", "a", "list", "of", "private", "keys" ]

[ "func", "NewSecring", "(", ")", "*", "Secring", "{", "return", "&", "Secring", "{", "data", ":", "&", "xcpb", ".", "Secring", "{", "PrivateKeys", ":", "make", "(", "[", "]", "*", "xcpb", ".", "PrivateKey", ",", "0", ",", "10", ")", ",", "}", ",", "}", "\n", "}" ]

[ "NewSecring", "initializes", "and", "a", "new", "secring" ]

[ "func", "LoadSecring", "(", "file", "string", ")", "(", "*", "Secring", ",", "error", ")", "{", "pr", ":=", "NewSecring", "(", ")", "\n", "pr", ".", "File", "=", "file", "\n\n", "buf", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "file", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "pr", ",", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "buf", ",", "pr", ".", "data", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "pr", ",", "nil", "\n", "}" ]

[ "LoadSecring", "loads", "an", "existing", "secring", "from", "disk", ".", "If", "the", "file", "is", "not", "found", "an", "empty", "keyring", "is", "returned" ]

[ "func", "(", "p", "*", "Secring", ")", "Contains", "(", "fp", "string", ")", "bool", "{", "p", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "pk", ":=", "range", "p", ".", "data", ".", "PrivateKeys", "{", "if", "pk", ".", "PublicKey", ".", "Fingerprint", "==", "fp", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Contains", "returns", "true", "if", "the", "given", "key", "is", "found", "in", "the", "keyring" ]

[ "func", "(", "p", "*", "Secring", ")", "KeyIDs", "(", ")", "[", "]", "string", "{", "p", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Unlock", "(", ")", "\n\n", "ids", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "p", ".", "data", ".", "PrivateKeys", ")", ")", "\n", "for", "_", ",", "pk", ":=", "range", "p", ".", "data", ".", "PrivateKeys", "{", "ids", "=", "append", "(", "ids", ",", "pk", ".", "PublicKey", ".", "Fingerprint", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "ids", ")", "\n", "return", "ids", "\n", "}" ]

[ "KeyIDs", "returns", "a", "list", "of", "key", "IDs" ]

[ "func", "(", "p", "*", "Secring", ")", "Export", "(", "id", "string", ",", "withPrivate", "bool", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "p", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Unlock", "(", ")", "\n\n", "xpk", ":=", "p", ".", "fetch", "(", "id", ")", "\n", "if", "xpk", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "withPrivate", "{", "return", "proto", ".", "Marshal", "(", "xpk", ")", "\n", "}", "\n", "return", "proto", ".", "Marshal", "(", "xpk", ".", "PublicKey", ")", "\n", "}" ]

[ "Export", "marshals", "a", "single", "private", "key" ]

[ "func", "(", "p", "*", "Secring", ")", "Import", "(", "buf", "[", "]", "byte", ")", "error", "{", "pk", ":=", "&", "xcpb", ".", "PrivateKey", "{", "}", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "buf", ",", "pk", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "p", ".", "insert", "(", "pk", ")", "\n", "return", "nil", "\n", "}" ]

[ "Import", "unmarshals", "and", "imports", "a", "previously", "exported", "key" ]

[ "func", "(", "p", "*", "Secring", ")", "Set", "(", "pk", "*", "PrivateKey", ")", "error", "{", "if", "!", "pk", ".", "Encrypted", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "p", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Unlock", "(", ")", "\n\n", "p", ".", "insert", "(", "secKRToPB", "(", "pk", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "inserts", "a", "single", "key" ]

[ "func", "(", "p", "*", "Secring", ")", "Remove", "(", "id", "string", ")", "error", "{", "p", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Unlock", "(", ")", "\n\n", "match", ":=", "-", "1", "\n", "for", "i", ",", "pk", ":=", "range", "p", ".", "data", ".", "PrivateKeys", "{", "if", "pk", ".", "PublicKey", ".", "Fingerprint", "==", "id", "{", "match", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "match", "<", "0", "||", "match", ">", "len", "(", "p", ".", "data", ".", "PrivateKeys", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "p", ".", "data", ".", "PrivateKeys", "=", "append", "(", "p", ".", "data", ".", "PrivateKeys", "[", ":", "match", "]", ",", "p", ".", "data", ".", "PrivateKeys", "[", "match", "+", "1", ":", "]", "...", ")", "\n", "return", "nil", "\n", "}" ]

[ "Remove", "deletes", "the", "given", "key" ]

[ "func", "(", "s", "*", "Action", ")", "Sync", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "store", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "return", "s", ".", "sync", "(", "ctx", ",", "c", ",", "store", ")", "\n", "}" ]

[ "Sync", "all", "stores", "with", "their", "remotes" ]

[ "func", "Open", "(", "path", ",", "gpg", "string", ")", "(", "*", "Git", ",", "error", ")", "{", "if", "!", "fsutil", ".", "IsDir", "(", "filepath", ".", "Join", "(", "path", ",", "\"", "\"", ")", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "Git", "{", "path", ":", "path", ",", "}", ",", "nil", "\n", "}" ]

[ "Open", "creates", "a", "new", "git", "cli", "based", "git", "backend" ]

[ "func", "Clone", "(", "ctx", "context", ".", "Context", ",", "repo", ",", "path", "string", ")", "(", "*", "Git", ",", "error", ")", "{", "g", ":=", "&", "Git", "{", "path", ":", "filepath", ".", "Dir", "(", "path", ")", ",", "}", "\n", "if", "err", ":=", "g", ".", "Cmd", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "repo", ",", "path", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "g", ".", "path", "=", "path", "\n", "return", "g", ",", "nil", "\n", "}" ]

[ "Clone", "clones", "an", "existing", "git", "repo", "and", "returns", "a", "new", "cli", "based", "git", "backend", "configured", "for", "this", "clone", "repo" ]

[ "func", "Init", "(", "ctx", "context", ".", "Context", ",", "path", ",", "userName", ",", "userEmail", "string", ")", "(", "*", "Git", ",", "error", ")", "{", "g", ":=", "&", "Git", "{", "path", ":", "path", ",", "}", "\n", "// the git repo may be empty (i.e. no branches, cloned from a fresh remote)", "// or already initialized. Only run git init if the folder is completely empty", "if", "!", "g", ".", "IsInitialized", "(", ")", "{", "if", "err", ":=", "g", ".", "Cmd", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "out", ".", "Red", "(", "ctx", ",", "\"", "\"", ",", "g", ".", "path", ")", "\n", "}", "\n\n", "if", "!", "ctxutil", ".", "IsGitInit", "(", "ctx", ")", "{", "return", "g", ",", "nil", "\n", "}", "\n\n", "// initialize the local git config", "if", "err", ":=", "g", ".", "InitConfig", "(", "ctx", ",", "userName", ",", "userEmail", ")", ";", "err", "!=", "nil", "{", "return", "g", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "out", ".", "Red", "(", "ctx", ",", "\"", "\"", ",", "g", ".", "path", ")", "\n\n", "// add current content of the store", "if", "err", ":=", "g", ".", "Add", "(", "ctx", ",", "g", ".", "path", ")", ";", "err", "!=", "nil", "{", "return", "g", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "g", ".", "path", ")", "\n", "}", "\n\n", "// commit if there is something to commit", "if", "!", "g", ".", "HasStagedChanges", "(", "ctx", ")", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "g", ",", "nil", "\n", "}", "\n\n", "if", "err", ":=", "g", ".", "Commit", "(", "ctx", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "g", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "g", ",", "nil", "\n", "}" ]

[ "Init", "initializes", "this", "store", "s", "git", "repo" ]

[ "func", "(", "g", "*", "Git", ")", "Cmd", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "args", "...", "string", ")", "error", "{", "stdout", ",", "stderr", ",", "err", ":=", "g", ".", "captureCmd", "(", "ctx", ",", "name", ",", "args", "...", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\\n", "\\n", "\"", ",", "string", "(", "stdout", ")", ",", "string", "(", "stderr", ")", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Cmd", "runs", "an", "git", "command" ]

[ "func", "(", "g", "*", "Git", ")", "Version", "(", "ctx", "context", ".", "Context", ")", "semver", ".", "Version", "{", "v", ":=", "semver", ".", "Version", "{", "}", "\n\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmdout", ",", "err", ":=", "cmd", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "v", "\n", "}", "\n\n", "svStr", ":=", "strings", ".", "TrimPrefix", "(", "string", "(", "cmdout", ")", ",", "\"", "\"", ")", "\n", "if", "p", ":=", "strings", ".", "Fields", "(", "svStr", ")", ";", "len", "(", "p", ")", ">", "0", "{", "svStr", "=", "p", "[", "0", "]", "\n", "}", "\n\n", "sv", ",", "err", ":=", "semver", ".", "ParseTolerant", "(", "svStr", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "svStr", ",", "err", ")", "\n", "return", "v", "\n", "}", "\n", "return", "sv", "\n", "}" ]

[ "Version", "returns", "the", "git", "version", "as", "major", "minor", "and", "patch", "level" ]

[ "func", "(", "g", "*", "Git", ")", "Add", "(", "ctx", "context", ".", "Context", ",", "files", "...", "string", ")", "error", "{", "if", "!", "g", ".", "IsInitialized", "(", ")", "{", "return", "store", ".", "ErrGitNotInit", "\n", "}", "\n\n", "for", "i", ":=", "range", "files", "{", "files", "[", "i", "]", "=", "strings", ".", "TrimPrefix", "(", "files", "[", "i", "]", ",", "g", ".", "path", "+", "\"", "\"", ")", "\n", "}", "\n\n", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "args", "=", "append", "(", "args", ",", "files", "...", ")", "\n\n", "return", "g", ".", "Cmd", "(", "ctx", ",", "\"", "\"", ",", "args", "...", ")", "\n", "}" ]

[ "Add", "adds", "the", "listed", "files", "to", "the", "git", "index" ]

[ "func", "(", "g", "*", "Git", ")", "HasStagedChanges", "(", "ctx", "context", ".", "Context", ")", "bool", "{", "if", "err", ":=", "g", ".", "Cmd", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HasStagedChanges", "returns", "true", "if", "there", "are", "any", "staged", "changes", "which", "can", "be", "committed" ]

[ "func", "(", "g", "*", "Git", ")", "Commit", "(", "ctx", "context", ".", "Context", ",", "msg", "string", ")", "error", "{", "if", "!", "g", ".", "IsInitialized", "(", ")", "{", "return", "store", ".", "ErrGitNotInit", "\n", "}", "\n\n", "if", "!", "g", ".", "HasStagedChanges", "(", "ctx", ")", "{", "return", "store", ".", "ErrGitNothingToCommit", "\n", "}", "\n\n", "return", "g", ".", "Cmd", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "msg", ")", "\n", "}" ]

[ "Commit", "creates", "a", "new", "git", "commit", "with", "the", "given", "commit", "message" ]

[ "func", "(", "g", "*", "Git", ")", "Push", "(", "ctx", "context", ".", "Context", ",", "remote", ",", "branch", "string", ")", "error", "{", "return", "g", ".", "PushPull", "(", "ctx", ",", "\"", "\"", ",", "remote", ",", "branch", ")", "\n", "}" ]

[ "Push", "pushes", "to", "the", "git", "remote" ]

[ "func", "(", "s", "*", "Store", ")", "exportPublicKey", "(", "ctx", "context", ".", "Context", ",", "r", "string", ")", "(", "string", ",", "error", ")", "{", "filename", ":=", "filepath", ".", "Join", "(", "keyDir", ",", "r", ")", "\n\n", "// do not overwrite existing keys", "if", "s", ".", "storage", ".", "Exists", "(", "ctx", ",", "filename", ")", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "pk", ",", "err", ":=", "s", ".", "crypto", ".", "ExportPublicKey", "(", "ctx", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// ECC keys are at least 700 byte, RSA should be a lot bigger", "if", "len", "(", "pk", ")", "<", "32", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "storage", ".", "Set", "(", "ctx", ",", "filename", ",", "pk", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "filename", ",", "nil", "\n", "}" ]

[ "export", "an", "ASCII", "armored", "public", "key" ]

[ "func", "(", "s", "*", "Store", ")", "importPublicKey", "(", "ctx", "context", ".", "Context", ",", "r", "string", ")", "error", "{", "for", "_", ",", "kd", ":=", "range", "[", "]", "string", "{", "keyDir", ",", "oldKeyDir", "}", "{", "filename", ":=", "filepath", ".", "Join", "(", "kd", ",", "r", ")", "\n", "if", "!", "s", ".", "storage", ".", "Exists", "(", "ctx", ",", "filename", ")", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "r", ",", "filename", ")", "\n", "continue", "\n", "}", "\n", "pk", ",", "err", ":=", "s", ".", "storage", ".", "Get", "(", "ctx", ",", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "s", ".", "crypto", ".", "ImportPublicKey", "(", "ctx", ",", "pk", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "import", "an", "public", "key", "into", "the", "default", "keyring" ]

[ "func", "(", "s", "*", "Action", ")", "List", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "filter", ":=", "c", ".", "Args", "(", ")", ".", "First", "(", ")", "\n", "flat", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "stripPrefix", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "limit", ":=", "c", ".", "Int", "(", "\"", "\"", ")", "\n", "folders", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "// we only support listing folders in flat mode currently", "if", "folders", "{", "flat", "=", "true", "\n", "}", "\n\n", "ctx", "=", "s", ".", "Store", ".", "WithConfig", "(", "ctx", ",", "filter", ")", "\n\n", "l", ",", "err", ":=", "s", ".", "Store", ".", "Tree", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitList", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "filter", "==", "\"", "\"", "{", "return", "s", ".", "listAll", "(", "ctx", ",", "l", ",", "limit", ",", "flat", ",", "folders", ")", "\n", "}", "\n", "return", "s", ".", "listFiltered", "(", "ctx", ",", "l", ",", "limit", ",", "flat", ",", "folders", ",", "stripPrefix", ",", "filter", ")", "\n", "}" ]

[ "List", "all", "secrets", "as", "a", "tree", ".", "If", "the", "filter", "argument", "is", "non", "-", "empty", "display", "only", "those", "that", "have", "this", "prefix" ]

[ "func", "redirectPager", "(", "ctx", "context", ".", "Context", ",", "subtree", "tree", ".", "Tree", ")", "(", "io", ".", "Writer", ",", "*", "bytes", ".", "Buffer", ")", "{", "if", "ctxutil", ".", "IsNoPager", "(", "ctx", ")", "{", "return", "stdout", ",", "nil", "\n", "}", "\n", "rows", ",", "_", ":=", "termutil", ".", "GetTermsize", "(", ")", "\n", "if", "rows", "<=", "0", "{", "return", "stdout", ",", "nil", "\n", "}", "\n", "if", "subtree", "==", "nil", "||", "subtree", ".", "Len", "(", ")", "<", "rows", "{", "return", "stdout", ",", "nil", "\n", "}", "\n", "color", ".", "NoColor", "=", "true", "\n", "buf", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "return", "buf", ",", "buf", "\n", "}" ]

[ "redirectPager", "returns", "a", "redirected", "io", ".", "Writer", "if", "the", "output", "would", "exceed", "the", "terminal", "size" ]

[ "func", "(", "s", "*", "Action", ")", "listAll", "(", "ctx", "context", ".", "Context", ",", "l", "tree", ".", "Tree", ",", "limit", "int", ",", "flat", ",", "folders", "bool", ")", "error", "{", "if", "flat", "{", "listOver", ":=", "l", ".", "List", "\n", "if", "folders", "{", "listOver", "=", "l", ".", "ListFolders", "\n", "}", "\n", "for", "_", ",", "e", ":=", "range", "listOver", "(", "limit", ")", "{", "fmt", ".", "Fprintln", "(", "stdout", ",", "e", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// we may need to redirect stdout for the pager support", "so", ",", "buf", ":=", "redirectPager", "(", "ctx", ",", "l", ")", "\n\n", "fmt", ".", "Fprintln", "(", "so", ",", "l", ".", "Format", "(", "limit", ")", ")", "\n", "if", "buf", "!=", "nil", "{", "if", "err", ":=", "s", ".", "pager", "(", "ctx", ",", "buf", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "listAll", "will", "unconditionally", "list", "all", "entries", "used", "if", "no", "filter", "is", "given" ]

[ "func", "(", "s", "*", "Action", ")", "pager", "(", "ctx", "context", ".", "Context", ",", "buf", "io", ".", "Reader", ")", "error", "{", "pager", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "pager", "==", "\"", "\"", "{", "fmt", ".", "Fprintln", "(", "stdout", ",", "buf", ")", "\n", "return", "nil", "\n", "}", "\n\n", "args", ",", "err", ":=", "shellquote", ".", "Split", "(", "pager", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "args", "[", "0", "]", ",", "args", "[", "1", ":", "]", "...", ")", "\n", "cmd", ".", "Stdin", "=", "buf", "\n", "cmd", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n\n", "return", "cmd", ".", "Run", "(", ")", "\n", "}" ]

[ "pager", "invokes", "the", "default", "pager", "with", "the", "given", "content" ]

[ "func", "GetTermsize", "(", ")", "(", "int", ",", "int", ")", "{", "ts", ":=", "termSize", "{", "}", "\n", "ret", ",", "_", ",", "_", ":=", "syscall", ".", "Syscall", "(", "syscall", ".", "SYS_IOCTL", ",", "uintptr", "(", "syscall", ".", "Stdin", ")", ",", "uintptr", "(", "syscall", ".", "TIOCGWINSZ", ")", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "ts", ")", ")", ",", ")", "\n", "if", "int", "(", "ret", ")", "==", "-", "1", "{", "return", "-", "1", ",", "-", "1", "\n", "}", "\n", "return", "int", "(", "ts", ".", "Rows", ")", ",", "int", "(", "ts", ".", "Cols", ")", "\n", "}" ]

[ "GetTermsize", "returns", "the", "size", "of", "the", "current", "terminal" ]

[ "func", "CryptoBackends", "(", ")", "[", "]", "string", "{", "bes", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "cryptoNameToBackendMap", ")", ")", "\n", "for", "k", ":=", "range", "cryptoNameToBackendMap", "{", "bes", "=", "append", "(", "bes", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "bes", ")", "\n", "return", "bes", "\n", "}" ]

[ "CryptoBackends", "returns", "the", "list", "of", "registered", "crypto", "backends", "." ]

[ "func", "RCSBackends", "(", ")", "[", "]", "string", "{", "bes", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "rcsNameToBackendMap", ")", ")", "\n", "for", "k", ":=", "range", "rcsNameToBackendMap", "{", "bes", "=", "append", "(", "bes", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "bes", ")", "\n", "return", "bes", "\n", "}" ]

[ "RCSBackends", "returns", "the", "list", "of", "registered", "RCS", "backends", "." ]

[ "func", "StorageBackends", "(", ")", "[", "]", "string", "{", "bes", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "storageNameToBackendMap", ")", ")", "\n", "for", "k", ":=", "range", "storageNameToBackendMap", "{", "bes", "=", "append", "(", "bes", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "bes", ")", "\n", "return", "bes", "\n", "}" ]

[ "StorageBackends", "returns", "the", "list", "of", "registered", "storage", "backends", "." ]

[ "func", "(", "r", "*", "Store", ")", "Copy", "(", "ctx", "context", ".", "Context", ",", "from", ",", "to", "string", ")", "error", "{", "return", "r", ".", "move", "(", "ctx", ",", "from", ",", "to", ",", "false", ")", "\n", "}" ]

[ "Copy", "will", "copy", "one", "entry", "to", "another", "location", ".", "Multi", "-", "store", "copies", "are", "supported", ".", "Each", "entry", "has", "to", "be", "decoded", "and", "encoded", "for", "the", "destination", "to", "make", "sure", "it", "s", "encrypted", "for", "the", "right", "set", "of", "recipients", "." ]

[ "func", "(", "r", "*", "Store", ")", "Move", "(", "ctx", "context", ".", "Context", ",", "from", ",", "to", "string", ")", "error", "{", "return", "r", ".", "move", "(", "ctx", ",", "from", ",", "to", ",", "true", ")", "\n", "}" ]

[ "Move", "will", "move", "one", "entry", "from", "one", "location", "to", "another", ".", "Cross", "-", "store", "moves", "are", "supported", ".", "Moving", "an", "entry", "will", "decode", "it", "from", "the", "old", "location", "encode", "it", "for", "the", "destination", "store", "with", "the", "right", "set", "of", "recipients", "and", "remove", "it", "from", "the", "old", "location", "afterwards", "." ]

[ "func", "(", "s", "*", "Store", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "path", ":=", "filepath", ".", "Join", "(", "s", ".", "path", ",", "filepath", ".", "Clean", "(", "name", ")", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "name", ",", "path", ")", "\n", "return", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "}" ]

[ "Get", "retrieves", "the", "named", "content" ]

[ "func", "(", "s", "*", "Store", ")", "Set", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "value", "[", "]", "byte", ")", "error", "{", "filename", ":=", "filepath", ".", "Join", "(", "s", ".", "path", ",", "filepath", ".", "Clean", "(", "name", ")", ")", "\n", "filedir", ":=", "filepath", ".", "Dir", "(", "filename", ")", "\n", "if", "!", "fsutil", ".", "IsDir", "(", "filedir", ")", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "filedir", ",", "0700", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "name", ",", "filepath", ".", "Join", "(", "s", ".", "path", ",", "name", ")", ")", "\n", "return", "ioutil", ".", "WriteFile", "(", "filepath", ".", "Join", "(", "s", ".", "path", ",", "name", ")", ",", "value", ",", "0644", ")", "\n", "}" ]

[ "Set", "writes", "the", "given", "content" ]

[ "func", "(", "s", "*", "Store", ")", "Delete", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "error", "{", "path", ":=", "filepath", ".", "Join", "(", "s", ".", "path", ",", "filepath", ".", "Clean", "(", "name", ")", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "name", ",", "path", ")", "\n\n", "if", "err", ":=", "os", ".", "Remove", "(", "path", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "s", ".", "removeEmptyParentDirectories", "(", "path", ")", "\n", "}" ]

[ "Delete", "removes", "the", "named", "entity" ]

[ "func", "(", "s", "*", "Store", ")", "removeEmptyParentDirectories", "(", "path", "string", ")", "error", "{", "parent", ":=", "filepath", ".", "Dir", "(", "path", ")", "\n\n", "if", "relpath", ",", "err", ":=", "filepath", ".", "Rel", "(", "s", ".", "path", ",", "parent", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "strings", ".", "HasPrefix", "(", "relpath", ",", "\"", "\"", ")", "{", "return", "nil", "\n", "}", "\n\n", "err", ":=", "os", ".", "Remove", "(", "parent", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "return", "s", ".", "removeEmptyParentDirectories", "(", "parent", ")", "\n", "case", "err", ".", "(", "*", "os", ".", "PathError", ")", ".", "Err", "==", "syscall", ".", "ENOTEMPTY", ":", "// ignore when directory is non-empty", "return", "nil", "\n", "default", ":", "return", "err", "\n", "}", "\n", "}" ]

[ "Deletes", "all", "empty", "parent", "directories", "up", "to", "the", "store", "root" ]

[ "func", "(", "s", "*", "Store", ")", "Exists", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "bool", "{", "path", ":=", "filepath", ".", "Join", "(", "s", ".", "path", ",", "filepath", ".", "Clean", "(", "name", ")", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "name", ",", "path", ")", "\n", "return", "fsutil", ".", "IsFile", "(", "path", ")", "\n", "}" ]

[ "Exists", "checks", "if", "the", "named", "entity", "exists" ]

[ "func", "(", "s", "*", "Store", ")", "List", "(", "ctx", "context", ".", "Context", ",", "prefix", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "prefix", "=", "strings", ".", "TrimPrefix", "(", "prefix", ",", "\"", "\"", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "prefix", ")", "\n", "files", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "100", ")", "\n", "if", "err", ":=", "filepath", ".", "Walk", "(", "s", ".", "path", ",", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "&&", "strings", ".", "HasPrefix", "(", "info", ".", "Name", "(", ")", ",", "\"", "\"", ")", "&&", "path", "!=", "s", ".", "path", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "nil", "\n", "}", "\n", "if", "path", "==", "s", ".", "path", "{", "return", "nil", "\n", "}", "\n", "name", ":=", "strings", ".", "TrimPrefix", "(", "path", ",", "s", ".", "path", "+", "string", "(", "filepath", ".", "Separator", ")", ")", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "name", ",", "prefix", ")", "{", "return", "nil", "\n", "}", "\n", "files", "=", "append", "(", "files", ",", "name", ")", "\n", "return", "nil", "\n", "}", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "sort", ".", "Strings", "(", "files", ")", "\n", "return", "files", ",", "nil", "\n", "}" ]

[ "List", "returns", "a", "list", "of", "all", "entities" ]

[ "func", "(", "s", "*", "Store", ")", "IsDir", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "bool", "{", "path", ":=", "filepath", ".", "Join", "(", "s", ".", "path", ",", "filepath", ".", "Clean", "(", "name", ")", ")", "\n", "isDir", ":=", "fsutil", ".", "IsDir", "(", "path", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "name", ",", "path", ",", "isDir", ")", "\n", "return", "isDir", "\n", "}" ]

[ "IsDir", "returns", "true", "if", "the", "named", "entity", "is", "a", "directory" ]

[ "func", "(", "s", "*", "Store", ")", "Prune", "(", "ctx", "context", ".", "Context", ",", "prefix", "string", ")", "error", "{", "path", ":=", "filepath", ".", "Join", "(", "s", ".", "path", ",", "filepath", ".", "Clean", "(", "prefix", ")", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "prefix", ",", "path", ")", "\n", "return", "os", ".", "RemoveAll", "(", "path", ")", "\n", "}" ]

[ "Prune", "removes", "a", "named", "directory" ]

[ "func", "New", "(", "dir", "string", ")", "*", "Agent", "{", "a", ":=", "&", "Agent", "{", "socket", ":", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "cache", ":", "&", "cache", "{", "ttl", ":", "time", ".", "Hour", ",", "maxTTL", ":", "24", "*", "time", ".", "Hour", ",", "}", ",", "pinentry", ":", "func", "(", ")", "(", "piner", ",", "error", ")", "{", "return", "pinentry", ".", "New", "(", ")", "\n", "}", ",", "}", "\n", "mux", ":=", "http", ".", "NewServeMux", "(", ")", "\n", "mux", ".", "HandleFunc", "(", "\"", "\"", ",", "a", ".", "servePing", ")", "\n", "mux", ".", "HandleFunc", "(", "\"", "\"", ",", "a", ".", "servePassphrase", ")", "\n", "mux", ".", "HandleFunc", "(", "\"", "\"", ",", "a", ".", "serveRemove", ")", "\n", "mux", ".", "HandleFunc", "(", "\"", "\"", ",", "a", ".", "servePurge", ")", "\n", "a", ".", "server", "=", "&", "http", ".", "Server", "{", "Handler", ":", "mux", ",", "}", "\n", "return", "a", "\n", "}" ]

[ "New", "creates", "a", "new", "agent" ]

[ "func", "(", "a", "*", "Agent", ")", "ListenAndServe", "(", "ctx", "context", ".", "Context", ")", "error", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "a", ".", "socket", ")", "\n", "lis", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "a", ".", "socket", ")", "\n", "if", "err", "==", "nil", "{", "return", "a", ".", "server", ".", "Serve", "(", "lis", ")", "\n", "}", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "a", ".", "socket", ",", "err", ")", "\n", "if", "err", ":=", "client", ".", "New", "(", "filepath", ".", "Dir", "(", "a", ".", "socket", ")", ")", ".", "Ping", "(", "ctx", ")", ";", "err", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "os", ".", "Remove", "(", "a", ".", "socket", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "a", ".", "socket", ",", "err", ")", "\n", "}", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "a", ".", "socket", ")", "\n", "lis", ",", "err", "=", "net", ".", "Listen", "(", "\"", "\"", ",", "a", ".", "socket", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "a", ".", "socket", ",", "err", ")", "\n", "}", "\n", "return", "a", ".", "server", ".", "Serve", "(", "lis", ")", "\n", "}" ]

[ "ListenAndServe", "starts", "listening", "and", "blocks" ]

[ "func", "lookupAuthStyle", "(", "tokenURL", "string", ")", "(", "style", "AuthStyle", ",", "ok", "bool", ")", "{", "authStyleCache", ".", "Lock", "(", ")", "\n", "defer", "authStyleCache", ".", "Unlock", "(", ")", "\n", "style", ",", "ok", "=", "authStyleCache", ".", "m", "[", "tokenURL", "]", "\n", "return", "\n", "}" ]

[ "lookupAuthStyle", "reports", "which", "auth", "style", "we", "last", "used", "with", "tokenURL", "when", "calling", "RetrieveToken", "and", "whether", "we", "have", "ever", "done", "so", "." ]

[ "func", "setAuthStyle", "(", "tokenURL", "string", ",", "v", "AuthStyle", ")", "{", "authStyleCache", ".", "Lock", "(", ")", "\n", "defer", "authStyleCache", ".", "Unlock", "(", ")", "\n", "if", "authStyleCache", ".", "m", "==", "nil", "{", "authStyleCache", ".", "m", "=", "make", "(", "map", "[", "string", "]", "AuthStyle", ")", "\n", "}", "\n", "authStyleCache", ".", "m", "[", "tokenURL", "]", "=", "v", "\n", "}" ]

[ "setAuthStyle", "adds", "an", "entry", "to", "authStyleCache", "documented", "above", "." ]

[ "func", "ServerEndpoint", "(", "host", "string", ")", "oauth2", ".", "Endpoint", "{", "return", "oauth2", ".", "Endpoint", "{", "AuthURL", ":", "\"", "\"", "+", "host", "+", "\"", "\"", ",", "TokenURL", ":", "\"", "\"", "+", "host", "+", "\"", "\"", ",", "}", "\n", "}" ]

[ "ServerEndpoint", "returns", "a", "new", "oauth2", ".", "Endpoint", "for", "a", "HipChat", "Server", "instance", "running", "on", "the", "given", "domain", "or", "host", "." ]

[ "func", "(", "c", "*", "Config", ")", "Token", "(", "ctx", "context", ".", "Context", ")", "(", "*", "oauth2", ".", "Token", ",", "error", ")", "{", "return", "c", ".", "TokenSource", "(", "ctx", ")", ".", "Token", "(", ")", "\n", "}" ]

[ "Token", "uses", "client", "credentials", "to", "retrieve", "a", "token", ".", "The", "provided", "context", "optionally", "controls", "which", "HTTP", "client", "is", "used", ".", "See", "the", "oauth2", ".", "HTTPClient", "variable", "." ]

[ "func", "EncodeWithSigner", "(", "header", "*", "Header", ",", "c", "*", "ClaimSet", ",", "sg", "Signer", ")", "(", "string", ",", "error", ")", "{", "head", ",", "err", ":=", "header", ".", "encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "cs", ",", "err", ":=", "c", ".", "encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "ss", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "head", ",", "cs", ")", "\n", "sig", ",", "err", ":=", "sg", "(", "[", "]", "byte", "(", "ss", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ss", ",", "base64", ".", "RawURLEncoding", ".", "EncodeToString", "(", "sig", ")", ")", ",", "nil", "\n", "}" ]

[ "EncodeWithSigner", "encodes", "a", "header", "and", "claim", "set", "with", "the", "provided", "signer", "." ]

[ "func", "Verify", "(", "token", "string", ",", "key", "*", "rsa", ".", "PublicKey", ")", "error", "{", "parts", ":=", "strings", ".", "Split", "(", "token", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "!=", "3", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "signedContent", ":=", "parts", "[", "0", "]", "+", "\"", "\"", "+", "parts", "[", "1", "]", "\n", "signatureString", ",", "err", ":=", "base64", ".", "RawURLEncoding", ".", "DecodeString", "(", "parts", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "h", ":=", "sha256", ".", "New", "(", ")", "\n", "h", ".", "Write", "(", "[", "]", "byte", "(", "signedContent", ")", ")", "\n", "return", "rsa", ".", "VerifyPKCS1v15", "(", "key", ",", "crypto", ".", "SHA256", ",", "h", ".", "Sum", "(", "nil", ")", ",", "[", "]", "byte", "(", "signatureString", ")", ")", "\n", "}" ]

[ "Verify", "tests", "whether", "the", "provided", "JWT", "token", "s", "signature", "was", "produced", "by", "the", "private", "key", "associated", "with", "the", "supplied", "public", "key", "." ]

[ "func", "sign", "(", "key", "string", ",", "claims", "*", "ClaimSet", ")", "(", "string", ",", "error", ")", "{", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "defaultHeader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "header", ":=", "base64", ".", "RawURLEncoding", ".", "EncodeToString", "(", "b", ")", "\n\n", "jsonClaims", ",", "err", ":=", "json", ".", "Marshal", "(", "claims", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "encodedClaims", ":=", "strings", ".", "TrimRight", "(", "base64", ".", "URLEncoding", ".", "EncodeToString", "(", "jsonClaims", ")", ",", "\"", "\"", ")", "\n\n", "ss", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "header", ",", "encodedClaims", ")", "\n\n", "mac", ":=", "hmac", ".", "New", "(", "sha256", ".", "New", ",", "[", "]", "byte", "(", "key", ")", ")", "\n", "mac", ".", "Write", "(", "[", "]", "byte", "(", "ss", ")", ")", "\n", "signature", ":=", "mac", ".", "Sum", "(", "nil", ")", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ss", ",", "base64", ".", "RawURLEncoding", ".", "EncodeToString", "(", "signature", ")", ")", ",", "nil", "\n", "}" ]

[ "Sign", "the", "claim", "set", "with", "the", "shared", "secret", "Result", "to", "be", "sent", "as", "assertion" ]

[ "func", "(", "n", "*", "Net", ")", "activeListeners", "(", ")", "(", "[", "]", "net", ".", "Listener", ",", "error", ")", "{", "n", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "n", ".", "mutex", ".", "Unlock", "(", ")", "\n", "ls", ":=", "make", "(", "[", "]", "net", ".", "Listener", ",", "len", "(", "n", ".", "active", ")", ")", "\n", "copy", "(", "ls", ",", "n", ".", "active", ")", "\n", "return", "ls", ",", "nil", "\n", "}" ]

[ "activeListeners", "returns", "a", "snapshot", "copy", "of", "the", "active", "listeners", "." ]

[ "func", "(", "n", "*", "Net", ")", "StartProcess", "(", ")", "(", "int", ",", "error", ")", "{", "listeners", ",", "err", ":=", "n", ".", "activeListeners", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// Extract the fds from the listeners.", "files", ":=", "make", "(", "[", "]", "*", "os", ".", "File", ",", "len", "(", "listeners", ")", ")", "\n", "for", "i", ",", "l", ":=", "range", "listeners", "{", "files", "[", "i", "]", ",", "err", "=", "l", ".", "(", "filer", ")", ".", "File", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "defer", "files", "[", "i", "]", ".", "Close", "(", ")", "\n", "}", "\n\n", "// Use the original binary location. This works with symlinks such that if", "// the file it points to has been changed we will use the updated symlink.", "argv0", ",", "err", ":=", "exec", ".", "LookPath", "(", "os", ".", "Args", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// Pass on the environment and replace the old count key with the new one.", "var", "env", "[", "]", "string", "\n", "for", "_", ",", "v", ":=", "range", "os", ".", "Environ", "(", ")", "{", "if", "!", "strings", ".", "HasPrefix", "(", "v", ",", "envCountKeyPrefix", ")", "{", "env", "=", "append", "(", "env", ",", "v", ")", "\n", "}", "\n", "}", "\n", "env", "=", "append", "(", "env", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "envCountKeyPrefix", ",", "len", "(", "listeners", ")", ")", ")", "\n\n", "allFiles", ":=", "append", "(", "[", "]", "*", "os", ".", "File", "{", "os", ".", "Stdin", ",", "os", ".", "Stdout", ",", "os", ".", "Stderr", "}", ",", "files", "...", ")", "\n", "process", ",", "err", ":=", "os", ".", "StartProcess", "(", "argv0", ",", "os", ".", "Args", ",", "&", "os", ".", "ProcAttr", "{", "Dir", ":", "originalWD", ",", "Env", ":", "env", ",", "Files", ":", "allFiles", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "process", ".", "Pid", ",", "nil", "\n", "}" ]

[ "StartProcess", "starts", "a", "new", "process", "passing", "it", "the", "active", "listeners", ".", "It", "doesn", "t", "fork", "but", "starts", "a", "new", "process", "using", "the", "same", "environment", "and", "arguments", "as", "when", "it", "was", "originally", "started", ".", "This", "allows", "for", "a", "newly", "deployed", "binary", "to", "be", "started", ".", "It", "returns", "the", "pid", "of", "the", "newly", "started", "process", "when", "successful", "." ]

[ "func", "ServeWithOptions", "(", "servers", "[", "]", "*", "http", ".", "Server", ",", "options", "...", "option", ")", "error", "{", "a", ":=", "newApp", "(", "servers", ")", "\n", "for", "_", ",", "opt", ":=", "range", "options", "{", "opt", "(", "a", ")", "\n", "}", "\n", "return", "a", ".", "run", "(", ")", "\n", "}" ]

[ "ServeWithOptions", "does", "the", "same", "as", "Serve", "but", "takes", "a", "set", "of", "options", "to", "configure", "the", "app", "struct", "." ]

[ "func", "pprintAddr", "(", "listeners", "[", "]", "net", ".", "Listener", ")", "[", "]", "byte", "{", "var", "out", "bytes", ".", "Buffer", "\n", "for", "i", ",", "l", ":=", "range", "listeners", "{", "if", "i", "!=", "0", "{", "fmt", ".", "Fprint", "(", "&", "out", ",", "\"", "\"", ")", "\n", "}", "\n", "fmt", ".", "Fprint", "(", "&", "out", ",", "l", ".", "Addr", "(", ")", ")", "\n", "}", "\n", "return", "out", ".", "Bytes", "(", ")", "\n", "}" ]

[ "Used", "for", "pretty", "printing", "addresses", "." ]

[ "func", "(", "f", "*", "FreeList", ")", "freeNode", "(", "n", "*", "node", ")", "(", "out", "bool", ")", "{", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "len", "(", "f", ".", "freelist", ")", "<", "cap", "(", "f", ".", "freelist", ")", "{", "f", ".", "freelist", "=", "append", "(", "f", ".", "freelist", ",", "n", ")", "\n", "out", "=", "true", "\n", "}", "\n", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "\n", "}" ]

[ "freeNode", "adds", "the", "given", "node", "to", "the", "list", "returning", "true", "if", "it", "was", "added", "and", "false", "if", "it", "was", "discarded", "." ]

[ "func", "NewWithFreeList", "(", "degree", "int", ",", "f", "*", "FreeList", ")", "*", "BTree", "{", "if", "degree", "<=", "1", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "BTree", "{", "degree", ":", "degree", ",", "cow", ":", "&", "copyOnWriteContext", "{", "freelist", ":", "f", "}", ",", "}", "\n", "}" ]

[ "NewWithFreeList", "creates", "a", "new", "B", "-", "Tree", "that", "uses", "the", "given", "node", "free", "list", "." ]

[ "func", "(", "s", "*", "items", ")", "truncate", "(", "index", "int", ")", "{", "var", "toClear", "items", "\n", "*", "s", ",", "toClear", "=", "(", "*", "s", ")", "[", ":", "index", "]", ",", "(", "*", "s", ")", "[", "index", ":", "]", "\n", "for", "len", "(", "toClear", ")", ">", "0", "{", "toClear", "=", "toClear", "[", "copy", "(", "toClear", ",", "nilItems", ")", ":", "]", "\n", "}", "\n", "}" ]

[ "truncate", "truncates", "this", "instance", "at", "index", "so", "that", "it", "contains", "only", "the", "first", "index", "items", ".", "index", "must", "be", "less", "than", "or", "equal", "to", "length", "." ]

[ "func", "(", "s", "items", ")", "find", "(", "item", "Item", ")", "(", "index", "int", ",", "found", "bool", ")", "{", "i", ":=", "sort", ".", "Search", "(", "len", "(", "s", ")", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "item", ".", "Less", "(", "s", "[", "i", "]", ")", "\n", "}", ")", "\n", "if", "i", ">", "0", "&&", "!", "s", "[", "i", "-", "1", "]", ".", "Less", "(", "item", ")", "{", "return", "i", "-", "1", ",", "true", "\n", "}", "\n", "return", "i", ",", "false", "\n", "}" ]

[ "find", "returns", "the", "index", "where", "the", "given", "item", "should", "be", "inserted", "into", "this", "list", ".", "found", "is", "true", "if", "the", "item", "already", "exists", "in", "the", "list", "at", "the", "given", "index", "." ]

[ "func", "(", "s", "*", "children", ")", "truncate", "(", "index", "int", ")", "{", "var", "toClear", "children", "\n", "*", "s", ",", "toClear", "=", "(", "*", "s", ")", "[", ":", "index", "]", ",", "(", "*", "s", ")", "[", "index", ":", "]", "\n", "for", "len", "(", "toClear", ")", ">", "0", "{", "toClear", "=", "toClear", "[", "copy", "(", "toClear", ",", "nilChildren", ")", ":", "]", "\n", "}", "\n", "}" ]

[ "truncate", "truncates", "this", "instance", "at", "index", "so", "that", "it", "contains", "only", "the", "first", "index", "children", ".", "index", "must", "be", "less", "than", "or", "equal", "to", "length", "." ]

[ "func", "(", "n", "*", "node", ")", "maybeSplitChild", "(", "i", ",", "maxItems", "int", ")", "bool", "{", "if", "len", "(", "n", ".", "children", "[", "i", "]", ".", "items", ")", "<", "maxItems", "{", "return", "false", "\n", "}", "\n", "first", ":=", "n", ".", "mutableChild", "(", "i", ")", "\n", "item", ",", "second", ":=", "first", ".", "split", "(", "maxItems", "/", "2", ")", "\n", "n", ".", "items", ".", "insertAt", "(", "i", ",", "item", ")", "\n", "n", ".", "children", ".", "insertAt", "(", "i", "+", "1", ",", "second", ")", "\n", "return", "true", "\n", "}" ]

[ "maybeSplitChild", "checks", "if", "a", "child", "should", "be", "split", "and", "if", "so", "splits", "it", ".", "Returns", "whether", "or", "not", "a", "split", "occurred", "." ]

[ "func", "(", "n", "*", "node", ")", "get", "(", "key", "Item", ")", "Item", "{", "i", ",", "found", ":=", "n", ".", "items", ".", "find", "(", "key", ")", "\n", "if", "found", "{", "return", "n", ".", "items", "[", "i", "]", "\n", "}", "else", "if", "len", "(", "n", ".", "children", ")", ">", "0", "{", "return", "n", ".", "children", "[", "i", "]", ".", "get", "(", "key", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "get", "finds", "the", "given", "key", "in", "the", "subtree", "and", "returns", "it", "." ]

[ "func", "min", "(", "n", "*", "node", ")", "Item", "{", "if", "n", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "len", "(", "n", ".", "children", ")", ">", "0", "{", "n", "=", "n", ".", "children", "[", "0", "]", "\n", "}", "\n", "if", "len", "(", "n", ".", "items", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "n", ".", "items", "[", "0", "]", "\n", "}" ]

[ "min", "returns", "the", "first", "item", "in", "the", "subtree", "." ]

[ "func", "max", "(", "n", "*", "node", ")", "Item", "{", "if", "n", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "len", "(", "n", ".", "children", ")", ">", "0", "{", "n", "=", "n", ".", "children", "[", "len", "(", "n", ".", "children", ")", "-", "1", "]", "\n", "}", "\n", "if", "len", "(", "n", ".", "items", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "n", ".", "items", "[", "len", "(", "n", ".", "items", ")", "-", "1", "]", "\n", "}" ]

[ "max", "returns", "the", "last", "item", "in", "the", "subtree", "." ]

[ "func", "(", "n", "*", "node", ")", "remove", "(", "item", "Item", ",", "minItems", "int", ",", "typ", "toRemove", ")", "Item", "{", "var", "i", "int", "\n", "var", "found", "bool", "\n", "switch", "typ", "{", "case", "removeMax", ":", "if", "len", "(", "n", ".", "children", ")", "==", "0", "{", "return", "n", ".", "items", ".", "pop", "(", ")", "\n", "}", "\n", "i", "=", "len", "(", "n", ".", "items", ")", "\n", "case", "removeMin", ":", "if", "len", "(", "n", ".", "children", ")", "==", "0", "{", "return", "n", ".", "items", ".", "removeAt", "(", "0", ")", "\n", "}", "\n", "i", "=", "0", "\n", "case", "removeItem", ":", "i", ",", "found", "=", "n", ".", "items", ".", "find", "(", "item", ")", "\n", "if", "len", "(", "n", ".", "children", ")", "==", "0", "{", "if", "found", "{", "return", "n", ".", "items", ".", "removeAt", "(", "i", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "// If we get to here, we have children.", "if", "len", "(", "n", ".", "children", "[", "i", "]", ".", "items", ")", "<=", "minItems", "{", "return", "n", ".", "growChildAndRemove", "(", "i", ",", "item", ",", "minItems", ",", "typ", ")", "\n", "}", "\n", "child", ":=", "n", ".", "mutableChild", "(", "i", ")", "\n", "// Either we had enough items to begin with, or we've done some", "// merging/stealing, because we've got enough now and we're ready to return", "// stuff.", "if", "found", "{", "// The item exists at index 'i', and the child we've selected can give us a", "// predecessor, since if we've gotten here it's got > minItems items in it.", "out", ":=", "n", ".", "items", "[", "i", "]", "\n", "// We use our special-case 'remove' call with typ=maxItem to pull the", "// predecessor of item i (the rightmost leaf of our immediate left child)", "// and set it into where we pulled the item from.", "n", ".", "items", "[", "i", "]", "=", "child", ".", "remove", "(", "nil", ",", "minItems", ",", "removeMax", ")", "\n", "return", "out", "\n", "}", "\n", "// Final recursive call. Once we're here, we know that the item isn't in this", "// node and that the child is big enough to remove from.", "return", "child", ".", "remove", "(", "item", ",", "minItems", ",", "typ", ")", "\n", "}" ]

[ "remove", "removes", "an", "item", "from", "the", "subtree", "rooted", "at", "this", "node", "." ]

[ "func", "(", "t", "*", "BTree", ")", "Delete", "(", "item", "Item", ")", "Item", "{", "return", "t", ".", "deleteItem", "(", "item", ",", "removeItem", ")", "\n", "}" ]

[ "Delete", "removes", "an", "item", "equal", "to", "the", "passed", "in", "item", "from", "the", "tree", "returning", "it", ".", "If", "no", "such", "item", "exists", "returns", "nil", "." ]

[ "func", "(", "t", "*", "BTree", ")", "AscendRange", "(", "greaterOrEqual", ",", "lessThan", "Item", ",", "iterator", "ItemIterator", ")", "{", "if", "t", ".", "root", "==", "nil", "{", "return", "\n", "}", "\n", "t", ".", "root", ".", "iterate", "(", "ascend", ",", "greaterOrEqual", ",", "lessThan", ",", "true", ",", "false", ",", "iterator", ")", "\n", "}" ]

[ "AscendRange", "calls", "the", "iterator", "for", "every", "value", "in", "the", "tree", "within", "the", "range", "[", "greaterOrEqual", "lessThan", ")", "until", "iterator", "returns", "false", "." ]

[ "func", "(", "t", "*", "BTree", ")", "AscendLessThan", "(", "pivot", "Item", ",", "iterator", "ItemIterator", ")", "{", "if", "t", ".", "root", "==", "nil", "{", "return", "\n", "}", "\n", "t", ".", "root", ".", "iterate", "(", "ascend", ",", "nil", ",", "pivot", ",", "false", ",", "false", ",", "iterator", ")", "\n", "}" ]

[ "AscendLessThan", "calls", "the", "iterator", "for", "every", "value", "in", "the", "tree", "within", "the", "range", "[", "first", "pivot", ")", "until", "iterator", "returns", "false", "." ]

[ "func", "(", "t", "*", "BTree", ")", "DescendRange", "(", "lessOrEqual", ",", "greaterThan", "Item", ",", "iterator", "ItemIterator", ")", "{", "if", "t", ".", "root", "==", "nil", "{", "return", "\n", "}", "\n", "t", ".", "root", ".", "iterate", "(", "descend", ",", "lessOrEqual", ",", "greaterThan", ",", "true", ",", "false", ",", "iterator", ")", "\n", "}" ]

[ "DescendRange", "calls", "the", "iterator", "for", "every", "value", "in", "the", "tree", "within", "the", "range", "[", "lessOrEqual", "greaterThan", ")", "until", "iterator", "returns", "false", "." ]

[ "func", "(", "t", "*", "BTree", ")", "DescendGreaterThan", "(", "pivot", "Item", ",", "iterator", "ItemIterator", ")", "{", "if", "t", ".", "root", "==", "nil", "{", "return", "\n", "}", "\n", "t", ".", "root", ".", "iterate", "(", "descend", ",", "nil", ",", "pivot", ",", "false", ",", "false", ",", "iterator", ")", "\n", "}" ]

[ "DescendGreaterThan", "calls", "the", "iterator", "for", "every", "value", "in", "the", "tree", "within", "the", "range", "(", "pivot", "last", "]", "until", "iterator", "returns", "false", "." ]

[ "func", "(", "t", "*", "BTree", ")", "Get", "(", "key", "Item", ")", "Item", "{", "if", "t", ".", "root", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "t", ".", "root", ".", "get", "(", "key", ")", "\n", "}" ]

[ "Get", "looks", "for", "the", "key", "item", "in", "the", "tree", "returning", "it", ".", "It", "returns", "nil", "if", "unable", "to", "find", "that", "item", "." ]

[ "func", "(", "t", "*", "BTree", ")", "Has", "(", "key", "Item", ")", "bool", "{", "return", "t", ".", "Get", "(", "key", ")", "!=", "nil", "\n", "}" ]

[ "Has", "returns", "true", "if", "the", "given", "key", "is", "in", "the", "tree", "." ]

[ "func", "(", "n", "*", "node", ")", "reset", "(", "c", "*", "copyOnWriteContext", ")", "bool", "{", "for", "_", ",", "child", ":=", "range", "n", ".", "children", "{", "if", "!", "child", ".", "reset", "(", "c", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "c", ".", "freeNode", "(", "n", ")", "!=", "ftFreelistFull", "\n", "}" ]

[ "reset", "returns", "a", "subtree", "to", "the", "freelist", ".", "It", "breaks", "out", "immediately", "if", "the", "freelist", "is", "full", "since", "the", "only", "benefit", "of", "iterating", "is", "to", "fill", "that", "freelist", "up", ".", "Returns", "true", "if", "parent", "reset", "call", "should", "continue", "." ]

[ "func", "(", "ip", "*", "IP", ")", "Scan", "(", "value", "interface", "{", "}", ")", "(", "err", "error", ")", "{", "switch", "v", ":=", "value", ".", "(", "type", ")", "{", "case", "[", "]", "byte", ":", "if", "len", "(", "v", ")", "==", "4", "||", "len", "(", "v", ")", "==", "16", "{", "*", "ip", "=", "IP", "(", "v", ")", "\n", "}", "else", "{", "err", "=", "errInvalidScanValue", "\n", "}", "\n", "case", "string", ":", "if", "len", "(", "v", ")", "==", "4", "||", "len", "(", "v", ")", "==", "16", "{", "*", "ip", "=", "IP", "(", "[", "]", "byte", "(", "v", ")", ")", "\n", "}", "else", "{", "err", "=", "errInvalidScanValue", "\n", "}", "\n", "default", ":", "err", "=", "errInvalidScanType", "\n", "}", "\n", "return", "\n", "}" ]

[ "Scan", "implements", "the", "driver", ".", "Valuer", "interface", "json", "field", "interface" ]

[ "func", "hashLen17to32", "(", "s", "[", "]", "byte", ",", "length", "uint32", ")", "uint64", "{", "var", "a", "=", "fetch64", "(", "s", ")", "*", "k1", "\n", "var", "b", "=", "fetch64", "(", "s", "[", "8", ":", "]", ")", "\n", "var", "c", "=", "fetch64", "(", "s", "[", "length", "-", "8", ":", "]", ")", "*", "k2", "\n", "var", "d", "=", "fetch64", "(", "s", "[", "length", "-", "16", ":", "]", ")", "*", "k0", "\n\n", "return", "hashLen16", "(", "rotate64", "(", "a", "-", "b", ",", "43", ")", "+", "rotate64", "(", "c", ",", "30", ")", "+", "d", ",", "a", "+", "rotate64", "(", "b", "^", "k3", ",", "20", ")", "-", "c", "+", "uint64", "(", "length", ")", ")", "\n", "}" ]

[ "This", "probably", "works", "well", "for", "16", "-", "byte", "strings", "as", "well", "but", "it", "may", "be", "overkill" ]

[ "func", "NewCompressWriter", "(", "w", "io", ".", "Writer", ")", "*", "compressWriter", "{", "p", ":=", "&", "compressWriter", "{", "writer", ":", "w", "}", "\n", "p", ".", "data", "=", "make", "(", "[", "]", "byte", ",", "BlockMaxSize", ",", "BlockMaxSize", ")", "\n\n", "zlen", ":=", "lz4", ".", "CompressBound", "(", "BlockMaxSize", ")", "+", "HeaderSize", "\n", "p", ".", "zdata", "=", "make", "(", "[", "]", "byte", ",", "zlen", ",", "zlen", ")", "\n", "return", "p", "\n", "}" ]

[ "NewCompressWriter", "wrap", "the", "io", ".", "Writer" ]

[ "func", "xtob", "(", "x1", ",", "x2", "byte", ")", "(", "byte", ",", "bool", ")", "{", "b1", ":=", "xvalues", "[", "x1", "]", "\n", "b2", ":=", "xvalues", "[", "x2", "]", "\n", "return", "(", "b1", "<<", "4", ")", "|", "b2", ",", "b1", "!=", "255", "&&", "b2", "!=", "255", "\n", "}" ]

[ "xtob", "converts", "hex", "characters", "x1", "and", "x2", "into", "a", "byte", "." ]

[ "func", "newMatcher", "(", "needle", "string", ")", "*", "wordMatcher", "{", "return", "&", "wordMatcher", "{", "word", ":", "[", "]", "rune", "(", "strings", ".", "ToUpper", "(", "needle", ")", ")", ",", "position", ":", "0", "}", "\n", "}" ]

[ "newMatcher", "returns", "matcher", "for", "word", "needle" ]

[ "func", "NewCompressReader", "(", "r", "io", ".", "Reader", ")", "*", "compressReader", "{", "p", ":=", "&", "compressReader", "{", "reader", ":", "r", ",", "header", ":", "make", "(", "[", "]", "byte", ",", "HeaderSize", ")", ",", "}", "\n", "p", ".", "data", "=", "make", "(", "[", "]", "byte", ",", "BlockMaxSize", ",", "BlockMaxSize", ")", "\n\n", "zlen", ":=", "lz4", ".", "CompressBound", "(", "BlockMaxSize", ")", "+", "HeaderSize", "\n", "p", ".", "zdata", "=", "make", "(", "[", "]", "byte", ",", "zlen", ",", "zlen", ")", "\n\n", "p", ".", "pos", "=", "len", "(", "p", ".", "data", ")", "\n", "return", "p", "\n", "}" ]

[ "NewCompressReader", "wrap", "the", "io", ".", "Reader" ]

[ "func", "RegisterTLSConfig", "(", "key", "string", ",", "config", "*", "tls", ".", "Config", ")", "error", "{", "tlsConfigLock", ".", "Lock", "(", ")", "\n", "if", "tlsConfigRegistry", "==", "nil", "{", "tlsConfigRegistry", "=", "make", "(", "map", "[", "string", "]", "*", "tls", ".", "Config", ")", "\n", "}", "\n\n", "tlsConfigRegistry", "[", "key", "]", "=", "config", "\n", "tlsConfigLock", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "RegisterTLSConfig", "registers", "a", "custom", "tls", ".", "Config", "to", "be", "used", "with", "sql", ".", "Open", "." ]

[ "func", "acceptConnection", "(", "listener", "net", ".", "Listener", ",", "listen", "chan", "<-", "net", ".", "Conn", ")", "{", "for", "{", "conn", ",", "err", ":=", "listener", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "listen", "<-", "conn", "\n", "}", "\n", "}" ]

[ "Accept", "a", "client", "connection", "and", "collect", "it", "in", "a", "channel" ]

[ "func", "(", "bsd", "*", "bsdRecord", ")", "isEnabled", "(", ")", "(", "bool", ",", "error", ")", "{", "rcConf", ",", "err", ":=", "os", ".", "Open", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "err", "\n", "}", "\n", "defer", "rcConf", ".", "Close", "(", ")", "\n", "rcData", ",", "_", ":=", "ioutil", ".", "ReadAll", "(", "rcConf", ")", "\n", "r", ",", "_", ":=", "regexp", ".", "Compile", "(", "`.*`", "+", "bsd", ".", "name", "+", "`_enable=\"YES\".*`", ")", "\n", "v", ":=", "string", "(", "r", ".", "Find", "(", "rcData", ")", ")", "\n", "var", "chrFound", ",", "sharpFound", "bool", "\n", "for", "_", ",", "c", ":=", "range", "v", "{", "if", "c", "==", "'#'", "&&", "!", "chrFound", "{", "sharpFound", "=", "true", "\n", "break", "\n", "}", "else", "if", "!", "sharpFound", "&&", "c", "!=", "' '", "{", "chrFound", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "chrFound", ",", "nil", "\n", "}" ]

[ "Is", "a", "service", "is", "enabled" ]

[ "func", "(", "darwin", "*", "darwinRecord", ")", "checkRunning", "(", ")", "(", "string", ",", "bool", ")", "{", "output", ",", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "darwin", ".", "name", ")", ".", "Output", "(", ")", "\n", "if", "err", "==", "nil", "{", "if", "matched", ",", "err", ":=", "regexp", ".", "MatchString", "(", "darwin", ".", "name", ",", "string", "(", "output", ")", ")", ";", "err", "==", "nil", "&&", "matched", "{", "reg", ":=", "regexp", ".", "MustCompile", "(", "\"", "\\\"", "\"", ")", "\n", "data", ":=", "reg", ".", "FindStringSubmatch", "(", "string", "(", "output", ")", ")", "\n", "if", "len", "(", "data", ")", ">", "1", "{", "return", "\"", "\"", "+", "data", "[", "1", "]", "+", "\"", "\"", ",", "true", "\n", "}", "\n", "return", "\"", "\"", ",", "true", "\n", "}", "\n", "}", "\n\n", "return", "\"", "\"", ",", "false", "\n", "}" ]

[ "Check", "service", "is", "running" ]

[ "func", "execPath", "(", ")", "(", "string", ",", "error", ")", "{", "var", "n", "uint32", "\n", "b", ":=", "make", "(", "[", "]", "uint16", ",", "syscall", ".", "MAX_PATH", ")", "\n", "size", ":=", "uint32", "(", "len", "(", "b", ")", ")", "\n\n", "r0", ",", "_", ",", "e1", ":=", "syscall", ".", "MustLoadDLL", "(", "\"", "\"", ",", ")", ".", "MustFindProc", "(", "\"", "\"", ",", ")", ".", "Call", "(", "0", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "b", "[", "0", "]", ")", ")", ",", "uintptr", "(", "size", ")", ")", "\n", "n", "=", "uint32", "(", "r0", ")", "\n", "if", "n", "==", "0", "{", "return", "\"", "\"", ",", "e1", "\n", "}", "\n", "return", "string", "(", "utf16", ".", "Decode", "(", "b", "[", "0", ":", "n", "]", ")", ")", ",", "nil", "\n", "}" ]

[ "Get", "executable", "path" ]

[ "func", "getWindowsError", "(", "inputError", "error", ")", "error", "{", "if", "exiterr", ",", "ok", ":=", "inputError", ".", "(", "*", "exec", ".", "ExitError", ")", ";", "ok", "{", "if", "status", ",", "ok", ":=", "exiterr", ".", "Sys", "(", ")", ".", "(", "syscall", ".", "WaitStatus", ")", ";", "ok", "{", "if", "sysErr", ",", "ok", ":=", "WinErrCode", "[", "status", ".", "ExitStatus", "(", ")", "]", ";", "ok", "{", "return", "errors", ".", "New", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\"", ",", "sysErr", ".", "Title", ",", "sysErr", ".", "Description", ",", "sysErr", ".", "Action", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "inputError", "\n", "}" ]

[ "Get", "windows", "error" ]

[ "func", "getWindowsServiceStateFromUint32", "(", "state", "svc", ".", "State", ")", "string", "{", "switch", "state", "{", "case", "svc", ".", "Stopped", ":", "return", "\"", "\"", "\n", "case", "svc", ".", "StartPending", ":", "return", "\"", "\"", "\n", "case", "svc", ".", "StopPending", ":", "return", "\"", "\"", "\n", "case", "svc", ".", "Running", ":", "return", "\"", "\"", "\n", "case", "svc", ".", "ContinuePending", ":", "return", "\"", "\"", "\n", "case", "svc", ".", "PausePending", ":", "return", "\"", "\"", "\n", "case", "svc", ".", "Paused", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "Get", "windows", "service", "state" ]

[ "func", "executablePath", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "if", "path", ",", "err", ":=", "exec", ".", "LookPath", "(", "name", ")", ";", "err", "==", "nil", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "err", "==", "nil", "{", "return", "path", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "os", ".", "Executable", "(", ")", "\n", "}" ]

[ "Lookup", "path", "for", "executable", "file" ]

[ "func", "checkPrivileges", "(", ")", "(", "bool", ",", "error", ")", "{", "if", "output", ",", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Output", "(", ")", ";", "err", "==", "nil", "{", "if", "gid", ",", "parseErr", ":=", "strconv", ".", "ParseUint", "(", "strings", ".", "TrimSpace", "(", "string", "(", "output", ")", ")", ",", "10", ",", "32", ")", ";", "parseErr", "==", "nil", "{", "if", "gid", "==", "0", "{", "return", "true", ",", "nil", "\n", "}", "\n", "return", "false", ",", "ErrRootPrivileges", "\n", "}", "\n", "}", "\n", "return", "false", ",", "ErrUnsupportedSystem", "\n", "}" ]

[ "Check", "root", "rights", "to", "use", "system", "service" ]

[ "func", "NewShellProgramFuncWithEnv", "(", "name", "string", ",", "env", "*", "map", "[", "string", "]", "string", ")", "ProgramFunc", "{", "return", "func", "(", "args", "...", "string", ")", "Program", "{", "return", "&", "Shell", "{", "cmd", ":", "createProgramCmdRedirectErr", "(", "name", ",", "args", ",", "env", ")", "}", "\n", "}", "\n", "}" ]

[ "NewShellProgramFuncWithEnv", "creates", "programs", "that", "are", "executed", "in", "a", "Shell", "with", "environment", "variables" ]

[ "func", "(", "s", "*", "Shell", ")", "Input", "(", "in", "io", ".", "Reader", ")", "{", "s", ".", "cmd", ".", "Stdin", "=", "in", "\n", "}" ]

[ "Input", "sets", "the", "input", "to", "send", "to", "a", "remote", "credentials", "helper", "." ]

[ "func", "isValidCredsMessage", "(", "msg", "string", ")", "error", "{", "if", "credentials", ".", "IsCredentialsMissingServerURLMessage", "(", "msg", ")", "{", "return", "credentials", ".", "NewErrCredentialsMissingServerURL", "(", ")", "\n", "}", "\n\n", "if", "credentials", ".", "IsCredentialsMissingUsernameMessage", "(", "msg", ")", "{", "return", "credentials", ".", "NewErrCredentialsMissingUsername", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "isValidCredsMessage", "checks", "if", "msg", "contains", "invalid", "credentials", "error", "message", ".", "It", "returns", "whether", "the", "logs", "are", "free", "of", "invalid", "credentials", "errors", "and", "the", "error", "if", "it", "isn", "t", ".", "error", "values", "can", "be", "errCredentialsMissingServerURL", "or", "errCredentialsMissingUsername", "." ]

[ "func", "Store", "(", "program", "ProgramFunc", ",", "creds", "*", "credentials", ".", "Credentials", ")", "error", "{", "cmd", ":=", "program", "(", "\"", "\"", ")", "\n\n", "buffer", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "if", "err", ":=", "json", ".", "NewEncoder", "(", "buffer", ")", ".", "Encode", "(", "creds", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "cmd", ".", "Input", "(", "buffer", ")", "\n\n", "out", ",", "err", ":=", "cmd", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ":=", "strings", ".", "TrimSpace", "(", "string", "(", "out", ")", ")", "\n\n", "if", "isValidErr", ":=", "isValidCredsMessage", "(", "t", ")", ";", "isValidErr", "!=", "nil", "{", "err", "=", "isValidErr", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "t", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Store", "uses", "an", "external", "program", "to", "save", "credentials", "." ]

[ "func", "Get", "(", "program", "ProgramFunc", ",", "serverURL", "string", ")", "(", "*", "credentials", ".", "Credentials", ",", "error", ")", "{", "cmd", ":=", "program", "(", "\"", "\"", ")", "\n", "cmd", ".", "Input", "(", "strings", ".", "NewReader", "(", "serverURL", ")", ")", "\n\n", "out", ",", "err", ":=", "cmd", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ":=", "strings", ".", "TrimSpace", "(", "string", "(", "out", ")", ")", "\n\n", "if", "credentials", ".", "IsErrCredentialsNotFoundMessage", "(", "t", ")", "{", "return", "nil", ",", "credentials", ".", "NewErrCredentialsNotFound", "(", ")", "\n", "}", "\n\n", "if", "isValidErr", ":=", "isValidCredsMessage", "(", "t", ")", ";", "isValidErr", "!=", "nil", "{", "err", "=", "isValidErr", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "t", ")", "\n", "}", "\n\n", "resp", ":=", "&", "credentials", ".", "Credentials", "{", "ServerURL", ":", "serverURL", ",", "}", "\n\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "out", ")", ")", ".", "Decode", "(", "resp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "Get", "executes", "an", "external", "program", "to", "get", "the", "credentials", "from", "a", "native", "store", "." ]

[ "func", "Erase", "(", "program", "ProgramFunc", ",", "serverURL", "string", ")", "error", "{", "cmd", ":=", "program", "(", "\"", "\"", ")", "\n", "cmd", ".", "Input", "(", "strings", ".", "NewReader", "(", "serverURL", ")", ")", "\n", "out", ",", "err", ":=", "cmd", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ":=", "strings", ".", "TrimSpace", "(", "string", "(", "out", ")", ")", "\n\n", "if", "isValidErr", ":=", "isValidCredsMessage", "(", "t", ")", ";", "isValidErr", "!=", "nil", "{", "err", "=", "isValidErr", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "t", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Erase", "executes", "a", "program", "to", "remove", "the", "server", "credentials", "from", "the", "native", "store", "." ]

[ "func", "List", "(", "program", "ProgramFunc", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "cmd", ":=", "program", "(", "\"", "\"", ")", "\n", "cmd", ".", "Input", "(", "strings", ".", "NewReader", "(", "\"", "\"", ")", ")", "\n", "out", ",", "err", ":=", "cmd", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "t", ":=", "strings", ".", "TrimSpace", "(", "string", "(", "out", ")", ")", "\n\n", "if", "isValidErr", ":=", "isValidCredsMessage", "(", "t", ")", ";", "isValidErr", "!=", "nil", "{", "err", "=", "isValidErr", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "t", ")", "\n", "}", "\n\n", "var", "resp", "map", "[", "string", "]", "string", "\n", "if", "err", "=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "out", ")", ")", ".", "Decode", "(", "&", "resp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "List", "executes", "a", "program", "to", "list", "server", "credentials", "in", "the", "native", "store", "." ]

[ "func", "(", "h", "Osxkeychain", ")", "Delete", "(", "serverURL", "string", ")", "error", "{", "s", ",", "err", ":=", "splitServer", "(", "serverURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "freeServer", "(", "s", ")", "\n\n", "errMsg", ":=", "C", ".", "keychain_delete", "(", "s", ")", "\n", "if", "errMsg", "!=", "nil", "{", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "errMsg", ")", ")", "\n", "return", "errors", ".", "New", "(", "C", ".", "GoString", "(", "errMsg", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Delete", "removes", "credentials", "from", "the", "keychain", "." ]

[ "func", "(", "h", "Osxkeychain", ")", "List", "(", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "credsLabelC", ":=", "C", ".", "CString", "(", "credentials", ".", "CredsLabel", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "credsLabelC", ")", ")", "\n\n", "var", "pathsC", "*", "*", "C", ".", "char", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "pathsC", ")", ")", "\n", "var", "acctsC", "*", "*", "C", ".", "char", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "acctsC", ")", ")", "\n", "var", "listLenC", "C", ".", "uint", "\n", "errMsg", ":=", "C", ".", "keychain_list", "(", "credsLabelC", ",", "&", "pathsC", ",", "&", "acctsC", ",", "&", "listLenC", ")", "\n", "if", "errMsg", "!=", "nil", "{", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "errMsg", ")", ")", "\n", "goMsg", ":=", "C", ".", "GoString", "(", "errMsg", ")", "\n", "if", "goMsg", "==", "errCredentialsNotFound", "{", "return", "make", "(", "map", "[", "string", "]", "string", ")", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "New", "(", "goMsg", ")", "\n", "}", "\n\n", "defer", "C", ".", "freeListData", "(", "&", "pathsC", ",", "listLenC", ")", "\n", "defer", "C", ".", "freeListData", "(", "&", "acctsC", ",", "listLenC", ")", "\n\n", "var", "listLen", "int", "\n", "listLen", "=", "int", "(", "listLenC", ")", "\n", "pathTmp", ":=", "(", "*", "[", "1", "<<", "30", "]", "*", "C", ".", "char", ")", "(", "unsafe", ".", "Pointer", "(", "pathsC", ")", ")", "[", ":", "listLen", ":", "listLen", "]", "\n", "acctTmp", ":=", "(", "*", "[", "1", "<<", "30", "]", "*", "C", ".", "char", ")", "(", "unsafe", ".", "Pointer", "(", "acctsC", ")", ")", "[", ":", "listLen", ":", "listLen", "]", "\n", "//taking the array of c strings into go while ignoring all the stuff irrelevant to credentials-helper", "resp", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "listLen", ";", "i", "++", "{", "if", "C", ".", "GoString", "(", "pathTmp", "[", "i", "]", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "resp", "[", "C", ".", "GoString", "(", "pathTmp", "[", "i", "]", ")", "]", "=", "C", ".", "GoString", "(", "acctTmp", "[", "i", "]", ")", "\n", "}", "\n", "return", "resp", ",", "nil", "\n", "}" ]

[ "List", "returns", "the", "stored", "URLs", "and", "corresponding", "usernames", "." ]

[ "func", "(", "c", "*", "Credentials", ")", "isValid", "(", ")", "(", "bool", ",", "error", ")", "{", "if", "len", "(", "c", ".", "ServerURL", ")", "==", "0", "{", "return", "false", ",", "NewErrCredentialsMissingServerURL", "(", ")", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "Username", ")", "==", "0", "{", "return", "false", ",", "NewErrCredentialsMissingUsername", "(", ")", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "isValid", "checks", "the", "integrity", "of", "Credentials", "object", "such", "that", "no", "credentials", "lack", "a", "server", "URL", "or", "a", "username", ".", "It", "returns", "whether", "the", "credentials", "are", "valid", "and", "the", "error", "if", "it", "isn", "t", ".", "error", "values", "can", "be", "errCredentialsMissingServerURL", "or", "errCredentialsMissingUsername" ]

[ "func", "HandleCommand", "(", "helper", "Helper", ",", "key", "string", ",", "in", "io", ".", "Reader", ",", "out", "io", ".", "Writer", ")", "error", "{", "switch", "key", "{", "case", "\"", "\"", ":", "return", "Store", "(", "helper", ",", "in", ")", "\n", "case", "\"", "\"", ":", "return", "Get", "(", "helper", ",", "in", ",", "out", ")", "\n", "case", "\"", "\"", ":", "return", "Erase", "(", "helper", ",", "in", ")", "\n", "case", "\"", "\"", ":", "return", "List", "(", "helper", ",", "out", ")", "\n", "case", "\"", "\"", ":", "return", "PrintVersion", "(", "out", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "key", ")", "\n", "}" ]

[ "HandleCommand", "uses", "a", "helper", "and", "a", "key", "to", "run", "a", "credential", "action", "." ]

[ "func", "Store", "(", "helper", "Helper", ",", "reader", "io", ".", "Reader", ")", "error", "{", "scanner", ":=", "bufio", ".", "NewScanner", "(", "reader", ")", "\n\n", "buffer", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "buffer", ".", "Write", "(", "scanner", ".", "Bytes", "(", ")", ")", "\n", "}", "\n\n", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "err", "\n", "}", "\n\n", "var", "creds", "Credentials", "\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "buffer", ")", ".", "Decode", "(", "&", "creds", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "ok", ",", "err", ":=", "creds", ".", "isValid", "(", ")", ";", "!", "ok", "{", "return", "err", "\n", "}", "\n\n", "return", "helper", ".", "Add", "(", "&", "creds", ")", "\n", "}" ]

[ "Store", "uses", "a", "helper", "and", "an", "input", "reader", "to", "save", "credentials", ".", "The", "reader", "must", "contain", "the", "JSON", "serialization", "of", "a", "Credentials", "struct", "." ]

[ "func", "Get", "(", "helper", "Helper", ",", "reader", "io", ".", "Reader", ",", "writer", "io", ".", "Writer", ")", "error", "{", "scanner", ":=", "bufio", ".", "NewScanner", "(", "reader", ")", "\n\n", "buffer", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "buffer", ".", "Write", "(", "scanner", ".", "Bytes", "(", ")", ")", "\n", "}", "\n\n", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "err", "\n", "}", "\n\n", "serverURL", ":=", "strings", ".", "TrimSpace", "(", "buffer", ".", "String", "(", ")", ")", "\n", "if", "len", "(", "serverURL", ")", "==", "0", "{", "return", "NewErrCredentialsMissingServerURL", "(", ")", "\n", "}", "\n\n", "username", ",", "secret", ",", "err", ":=", "helper", ".", "Get", "(", "serverURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "resp", ":=", "Credentials", "{", "ServerURL", ":", "serverURL", ",", "Username", ":", "username", ",", "Secret", ":", "secret", ",", "}", "\n\n", "buffer", ".", "Reset", "(", ")", "\n", "if", "err", ":=", "json", ".", "NewEncoder", "(", "buffer", ")", ".", "Encode", "(", "resp", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "fmt", ".", "Fprint", "(", "writer", ",", "buffer", ".", "String", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Get", "retrieves", "the", "credentials", "for", "a", "given", "server", "url", ".", "The", "reader", "must", "contain", "the", "server", "URL", "to", "search", ".", "The", "writer", "is", "used", "to", "write", "the", "JSON", "serialization", "of", "the", "credentials", "." ]