Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "(", "WriterDeviceDateConflictRenamer", ")", "ConflictRenameHelper", "(", "t", "time", ".", "Time", ",", "user", ",", "device", ",", "original", "string", ")", "string", "{", "if", "device", "==", "\"", "\"", "{", "device", "=", "\"", "\"", "\n", "}", "\n", "base", ",", "ext", ":=", "splitExtension", "(", "original", ")", "\n", "date", ":=", "t", ".", "Format", "(", "\"", "\"", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "base", ",", "user", ",", "device", ",", "date", ",", "ext", ")", "\n", "}" ]

[ "ConflictRenameHelper", "is", "a", "helper", "for", "ConflictRename", "especially", "useful", "from", "tests", "." ]

[ "func", "splitExtension", "(", "path", "string", ")", "(", "string", ",", "string", ")", "{", "for", "i", ":=", "len", "(", "path", ")", "-", "1", ";", "i", ">", "0", ";", "i", "--", "{", "switch", "path", "[", "i", "]", "{", "case", "'.'", ":", "// Handle some multipart extensions", "if", "i", ">=", "4", "&&", "path", "[", "i", "-", "4", ":", "i", "]", "==", "\"", "\"", "{", "i", "-=", "4", "\n", "}", "\n", "// A leading dot is not an extension", "if", "i", "==", "0", "||", "path", "[", "i", "-", "1", "]", "==", "'/'", "||", "path", "[", "i", "-", "1", "]", "==", "'\\\\'", "{", "return", "path", ",", "\"", "\"", "\n", "}", "\n", "return", "path", "[", ":", "i", "]", ",", "path", "[", "i", ":", "]", "\n", "case", "'/'", ",", "'\\\\'", ",", "' '", ":", "return", "path", ",", "\"", "\"", "\n", "}", "\n", "}", "\n", "return", "path", ",", "\"", "\"", "\n", "}" ]

[ "splitExtension", "splits", "filename", "into", "a", "base", "name", "and", "the", "extension", "." ]

[ "func", "Preview", "(", "ctx", "context", ".", "Context", ",", "log", "utils", ".", "DebugLabeler", ",", "src", "ReadResetter", ",", "contentType", ",", "basename", "string", ",", "nvh", "types", ".", "NativeVideoHelper", ")", "(", "*", "PreviewRes", ",", "error", ")", "{", "switch", "contentType", "{", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "previewImage", "(", "ctx", ",", "log", ",", "src", ",", "basename", ",", "contentType", ")", "\n", "case", "\"", "\"", ":", "return", "previewGIF", "(", "ctx", ",", "log", ",", "src", ",", "basename", ")", "\n", "}", "\n", "if", "strings", ".", "HasPrefix", "(", "contentType", ",", "\"", "\"", ")", "{", "pre", ",", "err", ":=", "previewVideo", "(", "ctx", ",", "log", ",", "src", ",", "basename", ",", "nvh", ")", "\n", "if", "err", "==", "nil", "{", "log", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "basename", ",", "contentType", ")", "\n", "return", "pre", ",", "nil", "\n", "}", "\n", "log", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "basename", ",", "contentType", ",", "err", ")", "\n", "return", "previewVideoBlank", "(", "ctx", ",", "log", ",", "src", ",", "basename", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Preview", "creates", "preview", "assets", "from", "src", ".", "It", "returns", "an", "in", "-", "memory", "BufferSource", "and", "the", "content", "type", "of", "the", "preview", "asset", "." ]

[ "func", "previewVideoBlank", "(", "ctx", "context", ".", "Context", ",", "log", "utils", ".", "DebugLabeler", ",", "src", "io", ".", "Reader", ",", "basename", "string", ")", "(", "res", "*", "PreviewRes", ",", "err", "error", ")", "{", "const", "width", ",", "height", "=", "300", ",", "150", "\n", "img", ":=", "image", ".", "NewNRGBA", "(", "image", ".", "Rect", "(", "0", ",", "0", ",", "width", ",", "height", ")", ")", "\n", "for", "y", ":=", "0", ";", "y", "<", "height", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "width", ";", "x", "++", "{", "img", ".", "Set", "(", "x", ",", "y", ",", "color", ".", "NRGBA", "{", "R", ":", "0", ",", "G", ":", "0", ",", "B", ":", "0", ",", "A", ":", "255", ",", "}", ")", "\n", "}", "\n", "}", "\n", "var", "out", "bytes", ".", "Buffer", "\n", "if", "err", ":=", "png", ".", "Encode", "(", "&", "out", ",", "img", ")", ";", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "imagePreview", ",", "err", ":=", "previewImage", "(", "ctx", ",", "log", ",", "&", "out", ",", "basename", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "return", "&", "PreviewRes", "{", "Source", ":", "imagePreview", ".", "Source", ",", "ContentType", ":", "\"", "\"", ",", "BaseWidth", ":", "imagePreview", ".", "BaseWidth", ",", "BaseHeight", ":", "imagePreview", ".", "BaseHeight", ",", "BaseDurationMs", ":", "1", ",", "PreviewHeight", ":", "imagePreview", ".", "PreviewHeight", ",", "PreviewWidth", ":", "imagePreview", ".", "PreviewWidth", ",", "}", ",", "nil", "\n", "}" ]

[ "previewVideoBlank", "previews", "a", "video", "by", "inserting", "a", "black", "rectangle", "with", "a", "play", "button", "on", "it", "." ]

[ "func", "previewImage", "(", "ctx", "context", ".", "Context", ",", "log", "utils", ".", "DebugLabeler", ",", "src", "io", ".", "Reader", ",", "basename", ",", "contentType", "string", ")", "(", "res", "*", "PreviewRes", ",", "err", "error", ")", "{", "defer", "log", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "// images.Decode in camlistore correctly handles exif orientation information.", "log", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "img", ",", "_", ",", "err", ":=", "images", ".", "Decode", "(", "src", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "width", ",", "height", ":=", "previewDimensions", "(", "img", ".", "Bounds", "(", ")", ")", "\n\n", "log", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "img", ".", "Bounds", "(", ")", ")", "\n", "preview", ":=", "resize", ".", "Resize", "(", "width", ",", "height", ",", "img", ",", "resize", ".", "Bicubic", ")", "\n", "var", "buf", "bytes", ".", "Buffer", "\n\n", "var", "encodeContentType", "string", "\n", "switch", "contentType", "{", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "encodeContentType", "=", "\"", "\"", "\n", "if", "err", ":=", "png", ".", "Encode", "(", "&", "buf", ",", "preview", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "default", ":", "encodeContentType", "=", "\"", "\"", "\n", "if", "err", ":=", "jpeg", ".", "Encode", "(", "&", "buf", ",", "preview", ",", "&", "jpeg", ".", "Options", "{", "Quality", ":", "90", "}", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "&", "PreviewRes", "{", "Source", ":", "buf", ".", "Bytes", "(", ")", ",", "ContentType", ":", "encodeContentType", ",", "BaseWidth", ":", "img", ".", "Bounds", "(", ")", ".", "Dx", "(", ")", ",", "BaseHeight", ":", "img", ".", "Bounds", "(", ")", ".", "Dy", "(", ")", ",", "PreviewWidth", ":", "int", "(", "width", ")", ",", "PreviewHeight", ":", "int", "(", "height", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "previewImage", "will", "resize", "a", "single", "-", "frame", "image", "." ]

[ "func", "gifDuration", "(", "g", "*", "gif", ".", "GIF", ")", "int", "{", "var", "total", "int", "\n", "for", "_", ",", "d", ":=", "range", "g", ".", "Delay", "{", "total", "+=", "d", "\n", "}", "\n\n", "// total is in 100ths of a second, multiply by 10 to get milliseconds", "return", "total", "*", "10", "\n", "}" ]

[ "gifDuration", "returns", "the", "duration", "of", "one", "loop", "of", "an", "animated", "gif", "in", "milliseconds", "." ]

[ "func", "NewPGPKeyGen", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "keybase1", ".", "PGPKeyGenDefaultArg", ")", "*", "PGPKeyGen", "{", "return", "&", "PGPKeyGen", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "arg", ":", "arg", ",", "}", "\n", "}" ]

[ "NewPGPKeyGen", "creates", "a", "PGPKeyGen", "engine", "." ]

[ "func", "(", "d", "*", "IdentifyDispatch", ")", "NotifyTrackingSuccess", "(", "mctx", "MetaContext", ",", "target", "keybase1", ".", "UID", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "target", ")", "\n", "d", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "listener", ":=", "range", "d", ".", "listeners", "{", "select", "{", "case", "listener", "<-", "IdentifyDispatchMsg", "{", "Target", ":", "target", "}", ":", "default", ":", "}", "\n", "}", "\n", "}" ]

[ "NotifyTrackingSuccess", "notifies", "listeners", "that", "a", "target", "user", "has", "been", "found", "to", "satisfy", "tracking", ".", "This", "could", "be", "through", "-", "An", "identify", "call", "that", "heeded", "the", "active", "user", "s", "tracking", "of", "the", "target", ".", "-", "A", "user", "tracked", "or", "untracked", "the", "target", ".", "When", "the", "active", "user", "is", "the", "target", "all", "bets", "are", "off", "." ]

[ "func", "(", "d", "*", "IdentifyDispatch", ")", "Subscribe", "(", "mctx", "MetaContext", ")", "(", "unsubscribe", "func", "(", ")", ",", "recvCh", "<-", "chan", "IdentifyDispatchMsg", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "ch", ":=", "make", "(", "chan", "IdentifyDispatchMsg", ",", "10", ")", "\n", "d", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "Unlock", "(", ")", "\n", "d", ".", "listeners", "=", "append", "(", "d", ".", "listeners", ",", "ch", ")", "\n", "unsubscribe", "=", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "d", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "Unlock", "(", ")", "\n", "var", "listeners", "[", "]", "chan", "<-", "IdentifyDispatchMsg", "\n", "for", "_", ",", "ch2", ":=", "range", "d", ".", "listeners", "{", "if", "ch", "==", "ch2", "{", "continue", "\n", "}", "\n", "listeners", "=", "append", "(", "listeners", ",", "ch2", ")", "\n", "}", "\n", "d", ".", "listeners", "=", "listeners", "\n", "}", "\n", "return", "unsubscribe", ",", "ch", "\n", "}" ]

[ "Subscribe", "to", "notifications", ".", "unsubscribe", "releases", "resources", "associated", "with", "the", "subscription", "and", "should", "be", "called", "asap", "." ]

[ "func", "(", "d", "*", "IdentifyDispatch", ")", "OnLogout", "(", ")", "{", "d", ".", "Lock", "(", ")", "\n", "defer", "d", ".", "Unlock", "(", ")", "\n", "d", ".", "listeners", "=", "nil", "\n", "}" ]

[ "OnLogout", "drops", "all", "subscriptions", "." ]

[ "func", "findHardcoded", "(", "uid", "keybase1", ".", "UID", ")", "libkb", ".", "NormalizedUsername", "{", "findInit", "(", ")", "\n", "searchFor", ":=", "uid", ".", "ToBytes", "(", ")", "\n", "if", "len", "(", "searchFor", ")", "!=", "keybase1", ".", "UID_LEN", "{", "// wrong uid size", "return", "libkb", ".", "NormalizedUsername", "(", "\"", "\"", ")", "\n", "}", "\n", "l", ":=", "len", "(", "uids", ")", "/", "keybase1", ".", "UID_LEN", "\n", "uidAt", ":=", "func", "(", "i", "int", ")", "[", "]", "byte", "{", "start", ":=", "i", "*", "keybase1", ".", "UID_LEN", "\n", "return", "uids", "[", "start", ":", "start", "+", "keybase1", ".", "UID_LEN", "]", "\n", "}", "\n", "doCmp", ":=", "func", "(", "i", "int", ")", "int", "{", "return", "bytes", ".", "Compare", "(", "searchFor", ",", "uidAt", "(", "i", ")", ")", "\n", "}", "\n", "n", ":=", "sort", ".", "Search", "(", "l", ",", "func", "(", "i", "int", ")", "bool", "{", "return", "doCmp", "(", "i", ")", "<=", "0", "\n", "}", ")", "\n", "if", "n", "==", "l", "||", "doCmp", "(", "n", ")", "!=", "0", "{", "return", "libkb", ".", "NormalizedUsername", "(", "\"", "\"", ")", "\n", "}", "\n", "offset", ":=", "offsets", "[", "n", "]", "\n", "s", ":=", "string", "(", "usernames", "[", "offset", ":", "offset", "+", "uint32", "(", "lengths", "[", "n", "]", ")", "]", ")", "\n", "return", "libkb", ".", "NewNormalizedUsername", "(", "s", ")", "\n", "}" ]

[ "Returns", "empty", "name", "if", "not", "found" ]

[ "func", "(", "d", "*", "Service", ")", "writeServiceInfo", "(", ")", "error", "{", "_", ",", "err", ":=", "d", ".", "ensureRuntimeDir", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Write runtime info file", "rtInfo", ":=", "libkb", ".", "KeybaseServiceInfo", "(", "d", ".", "G", "(", ")", ")", "\n", "return", "rtInfo", ".", "WriteFile", "(", "d", ".", "G", "(", ")", ".", "Env", ".", "GetServiceInfoPath", "(", ")", ",", "d", ".", "G", "(", ")", ".", "Log", ")", "\n", "}" ]

[ "If", "the", "daemon", "is", "already", "running", "we", "need", "to", "be", "able", "to", "check", "what", "version", "it", "is", "in", "case", "the", "client", "has", "been", "updated", "." ]

[ "func", "(", "d", "*", "Service", ")", "ReleaseLock", "(", ")", "error", "{", "d", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "d", ".", "lockPid", ".", "Close", "(", ")", "\n", "}" ]

[ "ReleaseLock", "releases", "the", "locking", "pidfile", "by", "closing", "unlocking", "and", "deleting", "it", "." ]

[ "func", "(", "d", "*", "Service", ")", "GetExclusiveLock", "(", ")", "error", "{", "if", "err", ":=", "d", ".", "GetExclusiveLockWithoutAutoUnlock", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "d", ".", "G", "(", ")", ".", "PushShutdownHook", "(", "func", "(", ")", "error", "{", "return", "d", ".", "ReleaseLock", "(", ")", "\n", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "GetExclusiveLock", "grabs", "the", "exclusive", "lock", "over", "running", "keybase", "and", "then", "installs", "a", "shutdown", "hook", "to", "release", "the", "lock", "automatically", "on", "shutdown", "." ]

[ "func", "(", "d", "*", "Service", ")", "configurePath", "(", ")", "{", "defer", "d", ".", "G", "(", ")", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ")", "(", ")", "\n\n", "var", "newDirs", "string", "\n", "switch", "runtime", ".", "GOOS", "{", "case", "\"", "\"", ":", "newDirs", "=", "\"", "\"", "\n", "default", ":", "}", "\n", "if", "newDirs", "!=", "\"", "\"", "{", "mergeIntoPath", "(", "d", ".", "G", "(", ")", ",", "newDirs", ")", "\n", "}", "\n", "}" ]

[ "configurePath", "is", "a", "somewhat", "unfortunate", "hack", "but", "as", "it", "currently", "stands", "when", "the", "keybase", "service", "is", "run", "out", "of", "launchd", "its", "path", "is", "minimal", "and", "often", "can", "t", "find", "the", "GPG", "location", ".", "We", "have", "hacks", "around", "this", "for", "CLI", "operation", "in", "which", "the", "CLI", "forwards", "its", "path", "to", "the", "service", "and", "the", "service", "enlarges", "its", "path", "accordingly", ".", "In", "this", "way", "the", "service", "can", "get", "access", "to", "path", "additions", "inserted", "by", "the", "user", "s", "shell", "startup", "scripts", ".", "However", "the", "same", "mechanism", "doesn", "t", "apply", "to", "a", "GUI", "-", "driven", "workload", "since", "the", "Electron", "GUI", "like", "the", "Go", "service", "is", "launched", "from", "launchd", "and", "therefore", "has", "the", "wrong", "path", ".", "This", "function", "currently", "noops", "on", "all", "platforms", "aside", "from", "macOS", "but", "we", "can", "expand", "it", "later", "as", "needs", "be", "." ]

[ "func", "(", "d", "*", "Service", ")", "tryLogin", "(", "ctx", "context", ".", "Context", ")", "{", "tryLoginOnce", ".", "Do", "(", "func", "(", ")", "{", "eng", ":=", "engine", ".", "NewLoginOffline", "(", "d", ".", "G", "(", ")", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "d", ".", "G", "(", ")", ")", "\n", "if", "err", ":=", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Standalone mode quirk here. We call tryLogin when client is", "// launched in standalone to unlock the same keys that we would", "// have in service mode. But NewLoginProvisionedDevice engine", "// needs KbKeyrings and not every command sets it up. Ensure", "// Keyring is available.", "// TODO: We will be phasing out KbKeyrings usage flag, or even", "// usage flags entirely. Then this will not be needed because", "// Keyrings will always be loaded.", "if", "m", ".", "G", "(", ")", ".", "Keyrings", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "m", ".", "G", "(", ")", ".", "ConfigureKeyring", "(", ")", "\n", "}", "\n\n", "deng", ":=", "engine", ".", "NewLoginProvisionedDevice", "(", "d", ".", "G", "(", ")", ",", "\"", "\"", ")", "\n", "deng", ".", "SecretStoreOnly", "=", "true", "\n", "if", "err", ":=", "engine", ".", "RunEngine2", "(", "m", ",", "deng", ")", ";", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "tryLogin", "runs", "LoginOffline", "which", "will", "load", "the", "local", "session", "file", "and", "unlock", "the", "local", "device", "keys", "without", "making", "any", "network", "requests", ".", "If", "that", "fails", "for", "any", "reason", "LoginProvisionedDevice", "is", "used", "which", "should", "get", "around", "any", "issue", "where", "the", "session", ".", "json", "file", "is", "out", "of", "date", "or", "missing", "since", "the", "last", "time", "the", "service", "started", "." ]

[ "func", "(", "e", "ext", ")", "WriteExt", "(", "v", "interface", "{", "}", ")", "(", "buf", "[", "]", "byte", ")", "{", "buf", ",", "err", ":=", "e", ".", "codec", ".", "Encode", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", ")", "\n", "}", "\n", "return", "buf", "\n", "}" ]

[ "WriteExt", "implements", "the", "codec", ".", "Ext", "interface", "for", "ext", "." ]

[ "func", "(", "e", "ext", ")", "ReadExt", "(", "v", "interface", "{", "}", ",", "buf", "[", "]", "byte", ")", "{", "err", ":=", "e", ".", "codec", ".", "Decode", "(", "buf", ",", "v", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", ")", "\n", "}", "\n", "}" ]

[ "ReadExt", "implements", "the", "codec", ".", "Ext", "interface", "for", "ext", "." ]

[ "func", "(", "es", "extSlice", ")", "WriteExt", "(", "v", "interface", "{", "}", ")", "(", "buf", "[", "]", "byte", ")", "{", "val", ":=", "reflect", ".", "ValueOf", "(", "v", ")", "\n", "if", "val", ".", "Kind", "(", ")", "!=", "reflect", ".", "Slice", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ".", "Kind", "(", ")", ")", ")", "\n", "}", "\n\n", "ifaceArray", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "val", ".", "Len", "(", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "val", ".", "Len", "(", ")", ";", "i", "++", "{", "ifaceArray", "[", "i", "]", "=", "val", ".", "Index", "(", "i", ")", ".", "Interface", "(", ")", "\n", "}", "\n\n", "buf", ",", "err", ":=", "es", ".", "codec", ".", "Encode", "(", "ifaceArray", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", ")", "\n", "}", "\n", "return", "buf", "\n", "}" ]

[ "WriteExt", "implements", "the", "codec", ".", "Ext", "interface", "for", "extSlice", "." ]

[ "func", "(", "es", "extSlice", ")", "ReadExt", "(", "v", "interface", "{", "}", ",", "buf", "[", "]", "byte", ")", "{", "// ReadExt actually receives a pointer to the list", "val", ":=", "reflect", ".", "ValueOf", "(", "v", ")", "\n", "if", "val", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ".", "Kind", "(", ")", ")", ")", "\n", "}", "\n\n", "val", "=", "val", ".", "Elem", "(", ")", "\n", "if", "val", ".", "Kind", "(", ")", "!=", "reflect", ".", "Slice", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ".", "Kind", "(", ")", ")", ")", "\n", "}", "\n\n", "var", "ifaceArray", "[", "]", "interface", "{", "}", "\n", "err", ":=", "es", ".", "codec", ".", "Decode", "(", "buf", ",", "&", "ifaceArray", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", ")", "\n", "}", "\n\n", "if", "len", "(", "ifaceArray", ")", ">", "0", "{", "val", ".", "Set", "(", "reflect", ".", "MakeSlice", "(", "val", ".", "Type", "(", ")", ",", "len", "(", "ifaceArray", ")", ",", "len", "(", "ifaceArray", ")", ")", ")", "\n", "}", "\n\n", "for", "i", ",", "v", ":=", "range", "ifaceArray", "{", "if", "es", ".", "typer", "!=", "nil", "{", "val", ".", "Index", "(", "i", ")", ".", "Set", "(", "es", ".", "typer", "(", "v", ")", ")", "\n", "}", "else", "{", "val", ".", "Index", "(", "i", ")", ".", "Set", "(", "reflect", ".", "ValueOf", "(", "v", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReadExt", "implements", "the", "codec", ".", "Ext", "interface", "for", "extSlice", "." ]

[ "func", "newCodecMsgpackHelper", "(", "handleUnknownFields", "bool", ")", "*", "CodecMsgpack", "{", "handle", ":=", "codec", ".", "MsgpackHandle", "{", "}", "\n", "handle", ".", "Canonical", "=", "true", "\n", "handle", ".", "WriteExt", "=", "true", "\n", "handle", ".", "DecodeUnknownFields", "=", "handleUnknownFields", "\n", "handle", ".", "EncodeUnknownFields", "=", "handleUnknownFields", "\n\n", "// save a codec that doesn't write extensions, so that we can just", "// call Encode/Decode when we want to (de)serialize extension", "// types.", "handleNoExt", ":=", "handle", "\n", "handleNoExt", ".", "WriteExt", "=", "false", "\n", "ExtCodec", ":=", "&", "CodecMsgpack", "{", "&", "handleNoExt", ",", "nil", "}", "\n", "return", "&", "CodecMsgpack", "{", "&", "handle", ",", "ExtCodec", "}", "\n", "}" ]

[ "newCodecMsgpackHelper", "constructs", "a", "new", "CodecMsgpack", "that", "may", "or", "may", "not", "handle", "unknown", "fields", "." ]

[ "func", "(", "c", "*", "CodecMsgpack", ")", "Decode", "(", "buf", "[", "]", "byte", ",", "obj", "interface", "{", "}", ")", "error", "{", "err", ":=", "codec", ".", "NewDecoderBytes", "(", "buf", ",", "c", ".", "h", ")", ".", "Decode", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Decode", "implements", "the", "Codec", "interface", "for", "CodecMsgpack" ]

[ "func", "(", "c", "*", "CodecMsgpack", ")", "Encode", "(", "obj", "interface", "{", "}", ")", "(", "buf", "[", "]", "byte", ",", "err", "error", ")", "{", "err", "=", "codec", ".", "NewEncoderBytes", "(", "&", "buf", ",", "c", ".", "h", ")", ".", "Encode", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "buf", ",", "nil", "\n", "}" ]

[ "Encode", "implements", "the", "Codec", "interface", "for", "CodecMsgpack" ]

[ "func", "(", "c", "*", "CodecMsgpack", ")", "RegisterType", "(", "rt", "reflect", ".", "Type", ",", "code", "ExtCode", ")", "{", "c", ".", "h", ".", "(", "*", "codec", ".", "MsgpackHandle", ")", ".", "SetExt", "(", "rt", ",", "uint64", "(", "code", ")", ",", "ext", "{", "c", ".", "ExtCodec", "}", ")", "\n", "}" ]

[ "RegisterType", "implements", "the", "Codec", "interface", "for", "CodecMsgpack" ]

[ "func", "(", "c", "*", "CodecMsgpack", ")", "RegisterIfaceSliceType", "(", "rt", "reflect", ".", "Type", ",", "code", "ExtCode", ",", "typer", "func", "(", "interface", "{", "}", ")", "reflect", ".", "Value", ")", "{", "c", ".", "h", ".", "(", "*", "codec", ".", "MsgpackHandle", ")", ".", "SetExt", "(", "rt", ",", "uint64", "(", "code", ")", ",", "extSlice", "{", "c", ",", "typer", "}", ")", "\n", "}" ]

[ "RegisterIfaceSliceType", "implements", "the", "Codec", "interface", "for", "CodecMsgpack" ]

[ "func", "SaferDLLLoading", "(", ")", "error", "{", "kernel32", ",", "err", ":=", "syscall", ".", "LoadDLL", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "procSetDllDirectoryW", ",", "err", ":=", "kernel32", ".", "FindProc", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "var", "zero", "uint16", "\n", "r1", ",", "_", ",", "e1", ":=", "syscall", ".", "Syscall", "(", "procSetDllDirectoryW", ".", "Addr", "(", ")", ",", "1", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "zero", ")", ")", ",", "0", ",", "0", ")", "\n\n", "procSetDefaultDllDirectories", ",", "err", ":=", "kernel32", ".", "FindProc", "(", "\"", "\"", ")", "\n", "if", "err", "==", "nil", "&&", "procSetDefaultDllDirectories", ".", "Addr", "(", ")", "!=", "0", "{", "r1", ",", "_", ",", "e1", "=", "syscall", ".", "Syscall", "(", "procSetDefaultDllDirectories", ".", "Addr", "(", ")", ",", "1", ",", "loadLibrarySearchSystem32", ",", "0", ",", "0", ")", "\n", "if", "r1", "==", "0", "{", "return", "e1", "\n", "}", "\n", "}", "else", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SaferDLLLoading", "sets", "DLL", "load", "path", "to", "be", "safer", "." ]

[ "func", "NewFile", "(", "filename", "string", ",", "data", "[", "]", "byte", ",", "perm", "os", ".", "FileMode", ")", "File", "{", "return", "File", "{", "filename", ",", "data", ",", "perm", "}", "\n", "}" ]

[ "NewFile", "returns", "a", "File" ]

[ "func", "NewKBFSService", "(", "kbCtx", "Context", ",", "config", "kbfsServiceConfig", ")", "(", "*", "KBFSService", ",", "error", ")", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "// Check to see if we're receiving a socket from systemd. If not, create", "// one and bind to it.", "listener", ",", "err", ":=", "systemd", ".", "GetListenerFromEnvironment", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "listener", "!=", "nil", "{", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "else", "{", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "listener", ",", "err", "=", "kbCtx", ".", "BindToKBFSSocket", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "k", ":=", "&", "KBFSService", "{", "config", ":", "config", ",", "log", ":", "log", ",", "kbCtx", ":", "kbCtx", ",", "}", "\n", "k", ".", "Run", "(", "listener", ")", "\n", "return", "k", ",", "nil", "\n", "}" ]

[ "NewKBFSService", "creates", "a", "new", "KBFSService", "." ]

[ "func", "(", "k", "*", "KBFSService", ")", "registerProtocols", "(", "srv", "*", "rpc", ".", "Server", ",", "xp", "rpc", ".", "Transporter", ")", "error", "{", "// TODO: fill in with actual protocols.", "protocols", ":=", "[", "]", "rpc", ".", "Protocol", "{", "kbgitkbfs", ".", "DiskBlockCacheProtocol", "(", "NewDiskBlockCacheService", "(", "k", ".", "config", ")", ")", ",", "}", "\n", "for", "_", ",", "proto", ":=", "range", "protocols", "{", "if", "err", ":=", "srv", ".", "Register", "(", "proto", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "registerProtocols", "registers", "protocols", "for", "this", "KBFSService", "." ]

[ "func", "(", "k", "*", "KBFSService", ")", "handle", "(", "c", "net", ".", "Conn", ")", "{", "xp", ":=", "rpc", ".", "NewTransport", "(", "c", ",", "k", ".", "kbCtx", ".", "NewRPCLogFactory", "(", ")", ",", "libkb", ".", "WrapError", ",", "rpc", ".", "DefaultMaxFrameLength", ")", "\n\n", "server", ":=", "rpc", ".", "NewServer", "(", "xp", ",", "libkb", ".", "WrapError", ")", "\n\n", "err", ":=", "k", ".", "registerProtocols", "(", "server", ",", "xp", ")", "\n\n", "if", "err", "!=", "nil", "{", "k", ".", "log", ".", "Warning", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// Run the server, then wait for it or this KBFSService to finish.", "serverCh", ":=", "server", ".", "Run", "(", ")", "\n", "go", "func", "(", ")", "{", "select", "{", "case", "<-", "k", ".", "stopCh", ":", "case", "<-", "serverCh", ":", "}", "\n", "// Close is idempotent, so always close when we're done.", "c", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "<-", "serverCh", "\n\n", "// err is always non-nil.", "err", "=", "server", ".", "Err", "(", ")", "\n", "if", "err", "!=", "io", ".", "EOF", "{", "k", ".", "log", ".", "Warning", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "k", ".", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "handle", "creates", "a", "server", "on", "an", "established", "connection", "." ]

[ "func", "(", "k", "*", "KBFSService", ")", "listenLoop", "(", "l", "net", ".", "Listener", ")", "error", "{", "go", "func", "(", ")", "{", "<-", "k", ".", "stopCh", "\n", "l", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "defer", "l", ".", "Close", "(", ")", "\n", "for", "{", "c", ",", "err", ":=", "l", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "libkb", ".", "IsSocketClosedError", "(", "err", ")", "{", "err", "=", "nil", "\n", "}", "\n\n", "k", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "go", "k", ".", "handle", "(", "c", ")", "\n", "}", "\n", "}" ]

[ "listenLoop", "listens", "on", "a", "passed", "-", "in", "listener", "and", "calls", "handle", "for", "any", "connection", "that", "is", "established", "on", "the", "listener", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "SetCurrentUID", "(", "uid", "keybase1", ".", "UID", ")", "{", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "// TODO: Send out notifications.", "dl", ".", "currentUID", "=", "uid", "\n", "}" ]

[ "SetCurrentUID", "sets", "the", "current", "UID", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "Resolve", "(", "ctx", "context", ".", "Context", ",", "assertion", "string", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "kbname", ".", "NormalizedUsername", ",", "keybase1", ".", "UserOrTeamID", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "id", ",", "err", ":=", "dl", ".", "assertionToIDLocked", "(", "ctx", ",", "assertion", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "if", "id", ".", "IsUser", "(", ")", "{", "u", ",", "err", ":=", "dl", ".", "localUsers", ".", "getLocalUser", "(", "id", ".", "AsUserOrBust", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n", "return", "u", ".", "Name", ",", "id", ",", "nil", "\n", "}", "\n\n", "// Otherwise it's a team", "ti", ",", "err", ":=", "dl", ".", "localTeams", ".", "getLocalTeam", "(", "id", ".", "AsTeamOrBust", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n\n", "_", ",", "ok", ":=", "dl", ".", "localImplicitTeams", "[", "id", ".", "AsTeamOrBust", "(", ")", "]", "\n", "if", "ok", "{", "// An implicit team exists, so Resolve shouldn't work. The", "// caller should use `ResolveImplicitTeamByID` instead.", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n\n", "return", "ti", ".", "Name", ",", "id", ",", "nil", "\n", "}" ]

[ "Resolve", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "Identify", "(", "ctx", "context", ".", "Context", ",", "assertion", ",", "_", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "kbname", ".", "NormalizedUsername", ",", "keybase1", ".", "UserOrTeamID", ",", "error", ")", "{", "// The local daemon doesn't need to distinguish resolves from", "// identifies.", "return", "dl", ".", "Resolve", "(", "ctx", ",", "assertion", ",", "offline", ")", "\n", "}" ]

[ "Identify", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "NormalizeSocialAssertion", "(", "ctx", "context", ".", "Context", ",", "assertion", "string", ")", "(", "keybase1", ".", "SocialAssertion", ",", "error", ")", "{", "socialAssertion", ",", "isSocialAssertion", ":=", "externals", ".", "NormalizeSocialAssertionStatic", "(", "assertion", ")", "\n", "if", "!", "isSocialAssertion", "{", "return", "keybase1", ".", "SocialAssertion", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "socialAssertion", ",", "nil", "\n", "}" ]

[ "NormalizeSocialAssertion", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "ResolveImplicitTeamByID", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "name", "string", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "info", ",", "ok", ":=", "dl", ".", "localImplicitTeams", "[", "teamID", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "NoSuchTeamError", "{", "teamID", ".", "String", "(", ")", "}", "\n", "}", "\n", "return", "info", ".", "Name", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "ResolveImplicitTeamByID", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "LoadUserPlusKeys", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "_", "keybase1", ".", "KID", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "UserInfo", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "u", ",", "err", ":=", "dl", ".", "localUsers", ".", "getLocalUser", "(", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "var", "infoCopy", "UserInfo", "\n", "if", "err", ":=", "kbfscodec", ".", "Update", "(", "dl", ".", "codec", ",", "&", "infoCopy", ",", "u", ".", "UserInfo", ")", ";", "err", "!=", "nil", "{", "return", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n", "return", "infoCopy", ",", "nil", "\n", "}" ]

[ "LoadUserPlusKeys", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "LoadTeamPlusKeys", "(", "ctx", "context", ".", "Context", ",", "tid", "keybase1", ".", "TeamID", ",", "_", "tlf", ".", "Type", ",", "_", "kbfsmd", ".", "KeyGen", ",", "_", "keybase1", ".", "UserVersion", ",", "_", "kbfscrypto", ".", "VerifyingKey", ",", "_", "keybase1", ".", "TeamRole", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "TeamInfo", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "TeamInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "t", ",", "err", ":=", "dl", ".", "localTeams", ".", "getLocalTeam", "(", "tid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TeamInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "// Copy the info since it contains a map that might be mutated.", "var", "infoCopy", "TeamInfo", "\n", "if", "err", ":=", "kbfscodec", ".", "Update", "(", "dl", ".", "codec", ",", "&", "infoCopy", ",", "t", ")", ";", "err", "!=", "nil", "{", "return", "TeamInfo", "{", "}", ",", "err", "\n", "}", "\n", "return", "infoCopy", ",", "nil", "\n", "}" ]

[ "LoadTeamPlusKeys", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "CreateTeamTLF", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "tlfID", "tlf", ".", "ID", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// TODO: add check to make sure the private/public suffix of the", "// team ID matches that of the tlf ID.", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "iteamInfo", ",", "isImplicit", ":=", "dl", ".", "localImplicitTeams", "[", "teamID", "]", "\n", "if", "isImplicit", "{", "iteamInfo", ".", "TlfID", "=", "tlfID", "\n", "dl", ".", "localImplicitTeams", "[", "teamID", "]", "=", "iteamInfo", "\n", "}", "\n", "_", ",", "isRegularTeam", ":=", "dl", ".", "localTeams", "[", "teamID", "]", "\n", "if", "!", "isImplicit", "&&", "!", "isRegularTeam", "{", "return", "NoSuchTeamError", "{", "teamID", ".", "String", "(", ")", "}", "\n", "}", "\n", "dl", ".", "localTeamSettings", "[", "teamID", "]", "=", "keybase1", ".", "KBFSTeamSettings", "{", "TlfID", ":", "keybase1", ".", "TLFID", "(", "tlfID", ".", "String", "(", ")", ")", "}", "\n", "return", "nil", "\n", "}" ]

[ "CreateTeamTLF", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "GetTeamSettings", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "settings", "keybase1", ".", "KBFSTeamSettings", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "KBFSTeamSettings", "{", "}", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "dl", ".", "localTeamSettings", "[", "teamID", "]", ",", "nil", "\n", "}" ]

[ "GetTeamSettings", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "GetCurrentMerkleRoot", "(", "ctx", "context", ".", "Context", ")", "(", "keybase1", ".", "MerkleRootV2", ",", "time", ".", "Time", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "MerkleRootV2", "{", "}", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "dl", ".", "merkleRoot", ",", "dl", ".", "merkleTime", ",", "nil", "\n", "}" ]

[ "GetCurrentMerkleRoot", "implements", "the", "MerkleRootGetter", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "VerifyMerkleRoot", "(", "_", "context", ".", "Context", ",", "_", "keybase1", ".", "MerkleRootV2", ",", "_", "keybase1", ".", "KBFSRoot", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "VerifyMerkleRoot", "implements", "the", "MerkleRootGetter", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "SetCurrentMerkleRoot", "(", "root", "keybase1", ".", "MerkleRootV2", ",", "rootTime", "time", ".", "Time", ")", "{", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "dl", ".", "merkleRoot", "=", "root", "\n", "dl", ".", "merkleTime", "=", "rootTime", "\n", "}" ]

[ "SetCurrentMerkleRoot", "is", "a", "helper", "function", "useful", "for", "tests", "to", "set", "the", "current", "Merkle", "root", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "CurrentSession", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "SessionInfo", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "SessionInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "u", ",", "err", ":=", "dl", ".", "localUsers", ".", "getLocalUser", "(", "dl", ".", "currentUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "SessionInfo", "{", "}", ",", "err", "\n", "}", "\n", "return", "SessionInfo", "{", "Name", ":", "u", ".", "Name", ",", "UID", ":", "u", ".", "UID", ",", "CryptPublicKey", ":", "u", ".", "GetCurrentCryptPublicKey", "(", ")", ",", "VerifyingKey", ":", "u", ".", "GetCurrentVerifyingKey", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "CurrentSession", "implements", "the", "KeybaseService", "interface", "for", "DaemonLocal", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "GetLocalUser", "(", "uid", "keybase1", ".", "UID", ")", "(", "LocalUser", ",", "error", ")", "{", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "dl", ".", "localUsers", ".", "getLocalUser", "(", "uid", ")", "\n", "}" ]

[ "GetLocalUser", "returns", "the", "LocalUser", "object", "for", "the", "given", "UID", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "SetLocalUser", "(", "uid", "keybase1", ".", "UID", ",", "user", "LocalUser", ")", "{", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "dl", ".", "localUsers", "[", "uid", "]", "=", "user", "\n", "}" ]

[ "SetLocalUser", "sets", "the", "LocalUser", "object", "for", "the", "given", "UID", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "GetIDForAssertion", "(", "assertion", "string", ")", "(", "keybase1", ".", "UserOrTeamID", ",", "bool", ")", "{", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "id", ",", "ok", ":=", "dl", ".", "asserts", "[", "assertion", "]", "\n", "return", "id", ",", "ok", "\n", "}" ]

[ "GetIDForAssertion", "returns", "the", "UID", "associated", "with", "the", "given", "assertion", "." ]

[ "func", "(", "dl", "*", "DaemonLocal", ")", "GetLocalUsers", "(", ")", "(", "res", "[", "]", "LocalUser", ")", "{", "dl", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "dl", ".", "lock", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "u", ":=", "range", "dl", ".", "localUsers", "{", "res", "=", "append", "(", "res", ",", "u", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "GetLocalUsers", "returns", "all", "of", "the", "users", "tracked", "by", "this", "daemon", "." ]

[ "func", "NewDaemonLocal", "(", "currentUID", "keybase1", ".", "UID", ",", "users", "[", "]", "LocalUser", ",", "teams", "[", "]", "TeamInfo", ",", "codec", "kbfscodec", ".", "Codec", ")", "*", "DaemonLocal", "{", "localUserMap", ":=", "make", "(", "localUserMap", ")", "\n", "asserts", ":=", "make", "(", "map", "[", "string", "]", "keybase1", ".", "UserOrTeamID", ")", "\n", "for", "_", ",", "u", ":=", "range", "users", "{", "localUserMap", "[", "u", ".", "UID", "]", "=", "u", "\n", "for", "_", ",", "a", ":=", "range", "u", ".", "Asserts", "{", "asserts", "[", "a", "]", "=", "u", ".", "UID", ".", "AsUserOrTeam", "(", ")", "\n", "}", "\n", "asserts", "[", "string", "(", "u", ".", "Name", ")", "]", "=", "u", ".", "UID", ".", "AsUserOrTeam", "(", ")", "\n", "}", "\n", "dl", ":=", "&", "DaemonLocal", "{", "codec", ":", "codec", ",", "localUsers", ":", "localUserMap", ",", "localTeams", ":", "make", "(", "localTeamMap", ")", ",", "localTeamSettings", ":", "make", "(", "localTeamSettingsMap", ")", ",", "localImplicitTeams", ":", "make", "(", "localImplicitTeamMap", ")", ",", "asserts", ":", "asserts", ",", "implicitAsserts", ":", "make", "(", "map", "[", "string", "]", "keybase1", ".", "TeamID", ")", ",", "currentUID", ":", "currentUID", ",", "// TODO: let test fill in valid merkle root.", "}", "\n", "dl", ".", "AddTeamsForTest", "(", "teams", ")", "\n", "return", "dl", "\n", "}" ]

[ "NewDaemonLocal", "constructs", "a", "new", "DaemonLocal", "initialized", "to", "contain", "the", "given", "users", "and", "teams", "." ]

[ "func", "NewHandle", "(", "ty", "tlf", ".", "Type", ",", "resolvedWriters", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", ",", "unresolvedWriters", ",", "unresolvedReaders", "[", "]", "keybase1", ".", "SocialAssertion", ",", "name", "tlf", ".", "CanonicalName", ",", "tlfID", "tlf", ".", "ID", ")", "*", "Handle", "{", "return", "&", "Handle", "{", "tlfType", ":", "ty", ",", "resolvedWriters", ":", "resolvedWriters", ",", "unresolvedWriters", ":", "unresolvedWriters", ",", "unresolvedReaders", ":", "unresolvedReaders", ",", "name", ":", "name", ",", "tlfID", ":", "tlfID", ",", "}", "\n", "}" ]

[ "NewHandle", "returns", "a", "simple", "new", "Handle", "based", "on", "the", "given", "fields", ".", "This", "is", "probably", "most", "useful", "for", "testing", "." ]

[ "func", "(", "h", "Handle", ")", "IsWriter", "(", "user", "keybase1", ".", "UID", ")", "bool", "{", "// TODO(KBFS-2185) relax this?", "if", "h", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "_", ",", "ok", ":=", "h", ".", "resolvedWriters", "[", "user", ".", "AsUserOrTeam", "(", ")", "]", "\n", "return", "ok", "\n", "}" ]

[ "IsWriter", "returns", "whether", "or", "not", "the", "given", "user", "is", "a", "writer", "for", "the", "top", "-", "level", "folder", "represented", "by", "this", "TlfHandle", "." ]

[ "func", "(", "h", "Handle", ")", "IsReader", "(", "user", "keybase1", ".", "UID", ")", "bool", "{", "// TODO(KBFS-2185) relax this?", "if", "h", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "h", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "PublicKeying", "||", "h", ".", "IsWriter", "(", "user", ")", "{", "return", "true", "\n", "}", "\n", "_", ",", "ok", ":=", "h", ".", "resolvedReaders", "[", "user", ".", "AsUserOrTeam", "(", ")", "]", "\n", "return", "ok", "\n", "}" ]

[ "IsReader", "returns", "whether", "or", "not", "the", "given", "user", "is", "a", "reader", "for", "the", "top", "-", "level", "folder", "represented", "by", "this", "TlfHandle", "." ]

[ "func", "(", "h", "Handle", ")", "ResolvedUsersMap", "(", ")", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", "{", "m", ":=", "make", "(", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", ",", "len", "(", "h", ".", "resolvedReaders", ")", "+", "len", "(", "h", ".", "resolvedWriters", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "h", ".", "resolvedReaders", "{", "m", "[", "k", "]", "=", "v", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "h", ".", "resolvedWriters", "{", "m", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "m", "\n", "}" ]

[ "ResolvedUsersMap", "returns", "a", "map", "of", "resolved", "users", "from", "uid", "to", "usernames", "." ]

[ "func", "(", "h", "Handle", ")", "ResolvedWriters", "(", ")", "[", "]", "keybase1", ".", "UserOrTeamID", "{", "writers", ":=", "h", ".", "unsortedResolvedWriters", "(", ")", "\n", "sort", ".", "Sort", "(", "tlf", ".", "UIDList", "(", "writers", ")", ")", "\n", "return", "writers", "\n", "}" ]

[ "ResolvedWriters", "returns", "the", "handle", "s", "resolved", "writer", "IDs", "in", "sorted", "order", "." ]

[ "func", "(", "h", "Handle", ")", "ResolvedReaders", "(", ")", "[", "]", "keybase1", ".", "UserOrTeamID", "{", "readers", ":=", "h", ".", "unsortedResolvedReaders", "(", ")", "\n", "sort", ".", "Sort", "(", "tlf", ".", "UIDList", "(", "readers", ")", ")", "\n", "return", "readers", "\n", "}" ]

[ "ResolvedReaders", "returns", "the", "handle", "s", "resolved", "reader", "IDs", "in", "sorted", "order", ".", "If", "the", "handle", "is", "public", "nil", "will", "be", "returned", "." ]

[ "func", "(", "h", "Handle", ")", "UnresolvedWriters", "(", ")", "[", "]", "keybase1", ".", "SocialAssertion", "{", "if", "len", "(", "h", ".", "unresolvedWriters", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "unresolvedWriters", ":=", "make", "(", "[", "]", "keybase1", ".", "SocialAssertion", ",", "len", "(", "h", ".", "unresolvedWriters", ")", ")", "\n", "copy", "(", "unresolvedWriters", ",", "h", ".", "unresolvedWriters", ")", "\n", "return", "unresolvedWriters", "\n", "}" ]

[ "UnresolvedWriters", "returns", "the", "handle", "s", "unresolved", "writers", "in", "sorted", "order", "." ]

[ "func", "(", "h", "Handle", ")", "UnresolvedReaders", "(", ")", "[", "]", "keybase1", ".", "SocialAssertion", "{", "if", "len", "(", "h", ".", "unresolvedReaders", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "unresolvedReaders", ":=", "make", "(", "[", "]", "keybase1", ".", "SocialAssertion", ",", "len", "(", "h", ".", "unresolvedReaders", ")", ")", "\n", "copy", "(", "unresolvedReaders", ",", "h", ".", "unresolvedReaders", ")", "\n", "return", "unresolvedReaders", "\n", "}" ]

[ "UnresolvedReaders", "returns", "the", "handle", "s", "unresolved", "readers", "in", "sorted", "order", ".", "If", "the", "handle", "is", "public", "nil", "will", "be", "returned", "." ]

[ "func", "(", "h", "Handle", ")", "ConflictInfo", "(", ")", "*", "tlf", ".", "HandleExtension", "{", "if", "h", ".", "conflictInfo", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "conflictInfoCopy", ":=", "*", "h", ".", "conflictInfo", "\n", "return", "&", "conflictInfoCopy", "\n", "}" ]

[ "ConflictInfo", "returns", "the", "handle", "s", "conflict", "info", "if", "any", "." ]

[ "func", "(", "h", "Handle", ")", "FinalizedInfo", "(", ")", "*", "tlf", ".", "HandleExtension", "{", "if", "h", ".", "finalizedInfo", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "finalizedInfoCopy", ":=", "*", "h", ".", "finalizedInfo", "\n", "return", "&", "finalizedInfoCopy", "\n", "}" ]

[ "FinalizedInfo", "returns", "the", "handle", "s", "finalized", "info", "if", "any", "." ]

[ "func", "(", "h", "*", "Handle", ")", "SetResolvedWriter", "(", "id", "keybase1", ".", "UserOrTeamID", ",", "name", "kbname", ".", "NormalizedUsername", ")", "{", "h", ".", "resolvedWriters", "[", "id", "]", "=", "name", "\n", "}" ]

[ "SetResolvedWriter", "resolves", "the", "given", "id", "to", "the", "given", "name", ".", "Useful", "for", "testing", "." ]

[ "func", "(", "h", "Handle", ")", "EqualsIgnoreName", "(", "codec", "kbfscodec", ".", "Codec", ",", "other", "Handle", ")", "(", "bool", ",", "error", ")", "{", "if", "h", ".", "tlfType", "!=", "other", ".", "tlfType", "{", "return", "false", ",", "nil", "\n", "}", "\n", "if", "h", ".", "tlfID", "!=", "other", ".", "tlfID", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "if", "!", "reflect", ".", "DeepEqual", "(", "h", ".", "resolvedWriters", ",", "other", ".", "resolvedWriters", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "if", "!", "reflect", ".", "DeepEqual", "(", "h", ".", "resolvedReaders", ",", "other", ".", "resolvedReaders", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "if", "!", "reflect", ".", "DeepEqual", "(", "h", ".", "unresolvedWriters", ",", "other", ".", "unresolvedWriters", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "if", "!", "reflect", ".", "DeepEqual", "(", "h", ".", "unresolvedReaders", ",", "other", ".", "unresolvedReaders", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "eq", ",", "err", ":=", "kbfscodec", ".", "Equal", "(", "codec", ",", "h", ".", "conflictInfo", ",", "other", ".", "conflictInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "eq", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "eq", ",", "err", "=", "kbfscodec", ".", "Equal", "(", "codec", ",", "h", ".", "finalizedInfo", ",", "other", ".", "finalizedInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "eq", ",", "nil", "\n", "}" ]

[ "EqualsIgnoreName", "returns", "whether", "h", "and", "other", "contain", "the", "same", "info", "ignoring", "the", "name", "." ]

[ "func", "(", "h", "Handle", ")", "Equals", "(", "codec", "kbfscodec", ".", "Codec", ",", "other", "Handle", ")", "(", "bool", ",", "error", ")", "{", "eq", ",", "err", ":=", "h", ".", "EqualsIgnoreName", "(", "codec", ",", "other", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "eq", "&&", "h", ".", "name", "!=", "other", ".", "name", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "return", "eq", ",", "nil", "\n", "}" ]

[ "Equals", "returns", "whether", "h", "and", "other", "contain", "the", "same", "info", "." ]

[ "func", "(", "h", "Handle", ")", "ToBareHandle", "(", ")", "(", "tlf", ".", "Handle", ",", "error", ")", "{", "var", "readers", "[", "]", "keybase1", ".", "UserOrTeamID", "\n", "switch", "h", ".", "TypeForKeying", "(", ")", "{", "case", "tlf", ".", "PublicKeying", ":", "readers", "=", "[", "]", "keybase1", ".", "UserOrTeamID", "{", "keybase1", ".", "UserOrTeamID", "(", "keybase1", ".", "PUBLIC_UID", ")", "}", "\n", "case", "tlf", ".", "TeamKeying", ":", "// Leave readers blank.", "default", ":", "readers", "=", "h", ".", "unsortedResolvedReaders", "(", ")", "\n", "}", "\n", "return", "tlf", ".", "MakeHandle", "(", "h", ".", "unsortedResolvedWriters", "(", ")", ",", "readers", ",", "h", ".", "unresolvedWriters", ",", "h", ".", "unresolvedReaders", ",", "h", ".", "Extensions", "(", ")", ")", "\n", "}" ]

[ "ToBareHandle", "returns", "a", "tlf", ".", "Handle", "corresponding", "to", "this", "handle", "." ]

[ "func", "(", "h", "Handle", ")", "ToBareHandleOrBust", "(", ")", "tlf", ".", "Handle", "{", "bh", ",", "err", ":=", "h", ".", "ToBareHandle", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "bh", "\n", "}" ]

[ "ToBareHandleOrBust", "returns", "a", "tlf", ".", "Handle", "corresponding", "to", "this", "handle", "and", "panics", "if", "there", "s", "an", "error", ".", "Used", "by", "tests", "." ]

[ "func", "(", "h", "Handle", ")", "DeepCopy", "(", ")", "*", "Handle", "{", "hCopy", ":=", "Handle", "{", "tlfType", ":", "h", ".", "tlfType", ",", "name", ":", "h", ".", "name", ",", "unresolvedWriters", ":", "h", ".", "UnresolvedWriters", "(", ")", ",", "unresolvedReaders", ":", "h", ".", "UnresolvedReaders", "(", ")", ",", "conflictInfo", ":", "h", ".", "ConflictInfo", "(", ")", ",", "finalizedInfo", ":", "h", ".", "FinalizedInfo", "(", ")", ",", "tlfID", ":", "h", ".", "tlfID", ",", "}", "\n\n", "hCopy", ".", "resolvedWriters", "=", "make", "(", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", ",", "len", "(", "h", ".", "resolvedWriters", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "h", ".", "resolvedWriters", "{", "hCopy", ".", "resolvedWriters", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "hCopy", ".", "resolvedReaders", "=", "make", "(", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", ",", "len", "(", "h", ".", "resolvedReaders", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "h", ".", "resolvedReaders", "{", "hCopy", ".", "resolvedReaders", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "return", "&", "hCopy", "\n", "}" ]

[ "DeepCopy", "makes", "a", "deep", "copy", "of", "this", "Handle", "." ]

[ "func", "(", "h", "*", "Handle", ")", "GetCanonicalName", "(", ")", "tlf", ".", "CanonicalName", "{", "if", "h", ".", "name", "==", "\"", "\"", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ")", ")", "\n", "}", "\n\n", "return", "h", ".", "name", "\n", "}" ]

[ "GetCanonicalName", "returns", "the", "canonical", "name", "of", "this", "TLF", "." ]

[ "func", "(", "h", "*", "Handle", ")", "ToFavorite", "(", ")", "favorites", ".", "Folder", "{", "return", "favorites", ".", "Folder", "{", "Name", ":", "string", "(", "h", ".", "GetCanonicalName", "(", ")", ")", ",", "Type", ":", "h", ".", "Type", "(", ")", ",", "}", "\n", "}" ]

[ "ToFavorite", "converts", "a", "TlfHandle", "into", "a", "Favorite", "suitable", "for", "Favorites", "calls", "." ]

[ "func", "(", "h", "*", "Handle", ")", "FavoriteData", "(", ")", "favorites", ".", "Data", "{", "fd", ":=", "favorites", ".", "Data", "{", "Name", ":", "string", "(", "h", ".", "GetCanonicalName", "(", ")", ")", ",", "FolderType", ":", "h", ".", "Type", "(", ")", ".", "FolderType", "(", ")", ",", "Private", ":", "h", ".", "Type", "(", ")", "!=", "tlf", ".", "Public", ",", "ResetMembers", ":", "[", "]", "keybase1", ".", "User", "{", "}", ",", "}", "\n", "if", "h", ".", "IsBackedByTeam", "(", ")", "{", "teamID", ":=", "h", ".", "FirstResolvedWriter", "(", ")", ".", "AsTeamOrBust", "(", ")", "\n", "fd", ".", "TeamID", "=", "&", "teamID", "\n", "}", "\n", "return", "fd", "\n", "}" ]

[ "FavoriteData", "converts", "a", "TlfHandle", "into", "FavoriteData", "suitable", "for", "Favorites", "calls", "." ]

[ "func", "(", "h", "*", "Handle", ")", "ToFavToAdd", "(", "created", "bool", ")", "favorites", ".", "ToAdd", "{", "return", "favorites", ".", "ToAdd", "{", "Folder", ":", "h", ".", "ToFavorite", "(", ")", ",", "Data", ":", "h", ".", "FavoriteData", "(", ")", ",", "Created", ":", "created", ",", "}", "\n", "}" ]

[ "ToFavToAdd", "converts", "a", "TlfHandle", "into", "a", "Favorite", "to", "be", "added", "and", "sets", "internal", "state", "about", "whether", "the", "corresponding", "folder", "was", "just", "created", "or", "not", "." ]

[ "func", "CheckHandleOffline", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "t", "tlf", ".", "Type", ")", "error", "{", "_", ",", "_", ",", "_", ",", "err", ":=", "idutil", ".", "SplitAndNormalizeTLFName", "(", "name", ",", "t", ")", "\n", "return", "err", "\n", "}" ]

[ "CheckHandleOffline", "does", "light", "checks", "whether", "a", "TLF", "handle", "looks", "ok", "it", "avoids", "all", "network", "calls", "." ]

[ "func", "(", "h", "Handle", ")", "GetPreferredFormat", "(", "username", "kbname", ".", "NormalizedUsername", ")", "tlf", ".", "PreferredName", "{", "s", ",", "err", ":=", "tlf", ".", "CanonicalToPreferredName", "(", "username", ",", "h", ".", "GetCanonicalName", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "GetPreferredFormat", "returns", "a", "TLF", "name", "formatted", "with", "the", "username", "given", "as", "the", "parameter", "first", ".", "This", "calls", "tlf", ".", "CanonicalToPreferredName", "with", "the", "canonical", "tlf", "name", "which", "will", "be", "reordered", "into", "the", "preferred", "format", ".", "An", "empty", "username", "is", "allowed", "here", "and", "results", "in", "the", "canonical", "ordering", "." ]

[ "func", "IsSeitany", "(", "s", "string", ")", "bool", "{", "return", "len", "(", "s", ")", ">", "seitanEncodedIKeyV2PlusOffset", "&&", "strings", ".", "IndexByte", "(", "s", ",", "'+'", ")", ">", "1", "\n", "}" ]

[ "IsSeitany", "is", "a", "very", "conservative", "check", "of", "whether", "a", "given", "string", "looks", "like", "a", "Seitan", "token", ".", "We", "want", "to", "err", "on", "the", "side", "of", "considering", "strings", "Seitan", "tokens", "since", "we", "don", "t", "mistakenly", "want", "to", "send", "botched", "Seitan", "tokens", "to", "the", "server", "." ]

[ "func", "ParseIKeyV2FromString", "(", "token", "string", ")", "(", "ikey", "SeitanIKeyV2", ",", "err", "error", ")", "{", "if", "len", "(", "token", ")", "!=", "SeitanEncodedIKeyLength", "{", "return", "ikey", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "SeitanEncodedIKeyLength", ",", "len", "(", "token", ")", ")", "\n", "}", "\n", "if", "token", "[", "seitanEncodedIKeyV2PlusOffset", "]", "!=", "'+'", "{", "return", "ikey", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "seitanEncodedIKeyV2PlusOffset", "+", "1", ")", "\n", "}", "\n\n", "return", "SeitanIKeyV2", "(", "strings", ".", "ToLower", "(", "token", ")", ")", ",", "nil", "\n", "}" ]

[ "ParseIKeyV2FromString", "safely", "creates", "SeitanIKey", "value", "from", "plaintext", "string", ".", "Only", "format", "is", "checked", "-", "any", "18", "-", "character", "token", "with", "+", "character", "at", "position", "6", "can", "be", "Invite", "Key", ".", "Alphabet", "is", "not", "checked", "as", "it", "is", "only", "a", "hint", "for", "token", "generation", "and", "it", "can", "change", "over", "time", "but", "we", "assume", "that", "token", "length", "stays", "the", "same", "." ]

[ "func", "findKeybaseBinary", "(", "name", "string", ")", "(", "string", ",", "error", ")", "{", "// Is it near the kbnm binary?", "binPath", ",", "err", ":=", "utils", ".", "BinPath", "(", ")", "\n", "if", "err", "==", "nil", "{", "path", ":=", "filepath", ".", "Join", "(", "filepath", ".", "Dir", "(", "binPath", ")", ",", "name", ")", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "path", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Is it in our PATH?", "path", ",", "err", ":=", "exec", ".", "LookPath", "(", "name", ")", "\n", "if", "err", "==", "nil", "{", "return", "path", ",", "nil", "\n", "}", "\n\n", "// Last ditch effort!", "path", "=", "guessKeybasePath", "(", "name", ")", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "path", ",", "nil", "\n", "}", "\n\n", "return", "\"", "\"", ",", "errKeybaseNotFound", "\n", "}" ]

[ "findKeybaseBinary", "returns", "the", "path", "to", "a", "Keybase", "binary", "if", "it", "finds", "it", "." ]

[ "func", "(", "k", "*", "PGPKeyBundle", ")", "StripRevocations", "(", ")", "(", "strippedKey", "*", "PGPKeyBundle", ")", "{", "strippedKey", "=", "nil", "\n", "if", "k", ".", "ArmoredPublicKey", "!=", "\"", "\"", "{", "// Re-read the key because we want to return a copy, that does", "// not reference PGPKeyBundle `k` anywhere.", "strippedKey", ",", "_", ",", "_", "=", "ReadOneKeyFromString", "(", "k", ".", "ArmoredPublicKey", ")", "\n", "}", "\n\n", "if", "strippedKey", "==", "nil", "{", "// Either Armored key was not saved or ReadOneKeyFromString", "// failed. Do old behavior here - we won't have a proper copy", "// of the key (there is a lot of pointers in the key structs),", "// but at least we won't have to bail out completely.", "entityCopy", ":=", "*", "k", ".", "Entity", "\n", "strippedKey", "=", "&", "PGPKeyBundle", "{", "Entity", ":", "&", "entityCopy", "}", "\n", "}", "\n\n", "strippedKey", ".", "Revocations", "=", "nil", "\n\n", "oldSubkeys", ":=", "strippedKey", ".", "Subkeys", "\n", "strippedKey", ".", "Subkeys", "=", "nil", "\n", "for", "_", ",", "subkey", ":=", "range", "oldSubkeys", "{", "// Skip revoked subkeys", "if", "subkey", ".", "Sig", ".", "SigType", "==", "packet", ".", "SigTypeSubkeyBinding", "&&", "subkey", ".", "Revocation", "==", "nil", "{", "strippedKey", ".", "Subkeys", "=", "append", "(", "strippedKey", ".", "Subkeys", ",", "subkey", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "StripRevocations", "returns", "a", "copy", "of", "the", "key", "with", "revocations", "removed" ]

[ "func", "firstPrivateKey", "(", "s", "string", ")", "(", "string", ",", "error", ")", "{", "scanner", ":=", "bufio", ".", "NewScanner", "(", "strings", ".", "NewReader", "(", "s", ")", ")", "\n", "var", "lines", "[", "]", "string", "\n", "looking", ":=", "true", "\n", "complete", ":=", "false", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "if", "looking", "&&", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "{", "looking", "=", "false", "\n\n", "}", "\n", "if", "looking", "{", "continue", "\n", "}", "\n", "lines", "=", "append", "(", "lines", ",", "line", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "{", "complete", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "looking", "{", "// never found a private key block", "return", "\"", "\"", ",", "NoSecretKeyError", "{", "}", "\n", "}", "\n", "if", "!", "complete", "{", "// string ended without the end tag", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "lines", ",", "\"", "\\n", "\"", ")", ",", "nil", "\n", "}" ]

[ "firstPrivateKey", "scans", "s", "for", "a", "private", "key", "block", "." ]

[ "func", "ReadPrivateKeyFromString", "(", "s", "string", ")", "(", "*", "PGPKeyBundle", ",", "*", "Warnings", ",", "error", ")", "{", "priv", ",", "err", ":=", "firstPrivateKey", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "&", "Warnings", "{", "}", ",", "err", "\n", "}", "\n", "return", "ReadOneKeyFromString", "(", "priv", ")", "\n", "}" ]

[ "ReadPrivateKeyFromString", "finds", "the", "first", "private", "key", "block", "in", "s", "and", "decodes", "it", "into", "a", "PGPKeyBundle", ".", "It", "is", "useful", "in", "the", "case", "where", "s", "contains", "multiple", "key", "blocks", "and", "you", "want", "the", "private", "key", "block", ".", "For", "example", "the", "result", "of", "gpg", "export", "." ]

[ "func", "(", "k", "*", "PGPKeyBundle", ")", "FindKeybaseUsername", "(", "un", "string", ")", "bool", "{", "rxx", ":=", "regexp", ".", "MustCompile", "(", "\"", "\"", "+", "un", "+", "\"", "\"", ")", "\n\n", "for", "_", ",", "id", ":=", "range", "k", ".", "Identities", "{", "if", "rxx", ".", "MatchString", "(", "id", ".", "Name", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "XXX", "for", "now", "this", "is", "OK", "but", "probably", "we", "need", "a", "PGP", "uid", "parser", "as", "in", "pgp", "-", "utils" ]

[ "func", "FindPGPPrivateKey", "(", "k", "*", "PGPKeyBundle", ")", "bool", "{", "if", "k", ".", "PrivateKey", ".", "PrivateKey", "!=", "nil", "{", "return", "true", "\n", "}", "\n\n", "for", "_", ",", "subKey", ":=", "range", "k", ".", "Subkeys", "{", "if", "subKey", ".", "PrivateKey", "!=", "nil", "&&", "subKey", ".", "PrivateKey", ".", "PrivateKey", "!=", "nil", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "FindPGPPrivateKey", "checks", "if", "supposed", "secret", "key", "PGPKeyBundle", "contains", "any", "valid", "PrivateKey", "entities", ".", "Sometimes", "primary", "private", "key", "is", "stoopped", "out", "but", "there", "are", "subkeys", "with", "secret", "keys", "." ]

[ "func", "(", "k", "*", "PGPKeyBundle", ")", "CheckIdentity", "(", "kbid", "Identity", ")", "(", "match", "bool", ",", "ctime", "int64", ",", "etime", "int64", ")", "{", "ctime", ",", "etime", "=", "-", "1", ",", "-", "1", "\n", "for", "_", ",", "pgpIdentity", ":=", "range", "k", ".", "Identities", "{", "if", "Cicmp", "(", "pgpIdentity", ".", "UserId", ".", "Email", ",", "kbid", ".", "Email", ")", "{", "match", "=", "true", "\n", "ctime", "=", "pgpIdentity", ".", "SelfSignature", ".", "CreationTime", ".", "Unix", "(", ")", "\n", "// This is a special case in OpenPGP, so we used KeyLifetimeSecs", "lifeSeconds", ":=", "pgpIdentity", ".", "SelfSignature", ".", "KeyLifetimeSecs", "\n", "if", "lifeSeconds", "==", "nil", "{", "// No expiration time is OK, it just means it never expires.", "etime", "=", "0", "\n", "}", "else", "{", "etime", "=", "ctime", "+", "int64", "(", "*", "lifeSeconds", ")", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "CheckIdentity", "finds", "the", "foo_user" ]

[ "func", "(", "k", "*", "PGPKeyBundle", ")", "DecryptFromString", "(", "ciphertext", "string", ")", "(", "msg", "[", "]", "byte", ",", "sender", "keybase1", ".", "KID", ",", "err", "error", ")", "{", "err", "=", "KeyCannotDecryptError", "{", "}", "\n", "return", "\n", "}" ]

[ "DecryptFromString", "fails", "for", "this", "type", "of", "key", "since", "we", "haven", "t", "implemented", "it", "yet" ]

[ "func", "NewTrackHandler", "(", "xp", "rpc", ".", "Transporter", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "TrackHandler", "{", "return", "&", "TrackHandler", "{", "BaseHandler", ":", "NewBaseHandler", "(", "g", ",", "xp", ")", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewTrackHandler", "creates", "a", "TrackHandler", "for", "the", "xp", "transport", "." ]

[ "func", "(", "h", "*", "TrackHandler", ")", "Track", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "TrackArg", ")", "(", "keybase1", ".", "ConfirmResult", ",", "error", ")", "{", "earg", ":=", "engine", ".", "TrackEngineArg", "{", "UserAssertion", ":", "arg", ".", "UserAssertion", ",", "Options", ":", "arg", ".", "Options", ",", "ForceRemoteCheck", ":", "arg", ".", "ForceRemoteCheck", ",", "}", "\n", "uis", ":=", "libkb", ".", "UIs", "{", "IdentifyUI", ":", "h", ".", "NewRemoteIdentifyUI", "(", "arg", ".", "SessionID", ",", "h", ".", "G", "(", ")", ")", ",", "SecretUI", ":", "h", ".", "getSecretUI", "(", "arg", ".", "SessionID", ",", "h", ".", "G", "(", ")", ")", ",", "SessionID", ":", "arg", ".", "SessionID", ",", "}", "\n", "eng", ":=", "engine", ".", "NewTrackEngine", "(", "h", ".", "G", "(", ")", ",", "&", "earg", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "h", ".", "G", "(", ")", ")", ".", "WithUIs", "(", "uis", ")", "\n", "err", ":=", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", "\n", "res", ":=", "eng", ".", "ConfirmResult", "(", ")", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "Track", "creates", "a", "TrackEngine", "and", "runs", "it", "." ]

[ "func", "(", "h", "*", "TrackHandler", ")", "Untrack", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "UntrackArg", ")", "error", "{", "earg", ":=", "engine", ".", "UntrackEngineArg", "{", "Username", ":", "libkb", ".", "NewNormalizedUsername", "(", "arg", ".", "Username", ")", ",", "}", "\n", "uis", ":=", "libkb", ".", "UIs", "{", "SecretUI", ":", "h", ".", "getSecretUI", "(", "arg", ".", "SessionID", ",", "h", ".", "G", "(", ")", ")", ",", "SessionID", ":", "arg", ".", "SessionID", ",", "}", "\n", "eng", ":=", "engine", ".", "NewUntrackEngine", "(", "h", ".", "G", "(", ")", ",", "&", "earg", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "h", ".", "G", "(", ")", ")", ".", "WithUIs", "(", "uis", ")", "\n", "return", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", "\n", "}" ]

[ "Untrack", "creates", "an", "UntrackEngine", "and", "runs", "it", "." ]

[ "func", "NewSaltpackSign", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "SaltpackSignArg", ")", "*", "SaltpackSign", "{", "return", "&", "SaltpackSign", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewSaltpackSign", "creates", "a", "SaltpackSign", "engine", "." ]

[ "func", "(", "c", "RemindClient", ")", "GetReminders", "(", "ctx", "context", ".", "Context", ",", "maxReminders", "int", ")", "(", "res", "ReminderSet", ",", "err", "error", ")", "{", "__arg", ":=", "GetRemindersArg", "{", "MaxReminders", ":", "maxReminders", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "getReminders", "gets", "the", "reminders", "waiting", "to", "be", "sent", "out", "as", "a", "batch", ".", "Get", "at", "most", "maxReminders", "back", "." ]

[ "func", "(", "c", "RemindClient", ")", "DeleteReminders", "(", "ctx", "context", ".", "Context", ",", "reminderIDs", "[", "]", "ReminderID", ")", "(", "err", "error", ")", "{", "__arg", ":=", "DeleteRemindersArg", "{", "ReminderIDs", ":", "reminderIDs", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "deleteReminders", "deletes", "all", "of", "the", "reminders", "by", "ReminderID" ]

[ "func", "(", "r", "*", "rekeyMaster", ")", "sendRekeyEvent", "(", "e", "keybase1", ".", "RekeyEvent", ")", "(", "err", "error", ")", "{", "defer", "r", ".", "G", "(", ")", ".", "Trace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "if", "e", ".", "InterruptType", "==", "int", "(", "RekeyInterruptSync", ")", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "var", "ui", "*", "RekeyUI", "\n", "ui", ",", "err", "=", "r", ".", "getUI", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "ui", "==", "nil", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "err", "=", "ui", ".", "RekeySendEvent", "(", "context", ".", "Background", "(", ")", ",", "keybase1", ".", "RekeySendEventArg", "{", "Event", ":", "e", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "sendRekeyEvent", "sends", "notification", "of", "a", "rekey", "event", "to", "the", "UI", ".", "It", "s", "largely", "used", "for", "testing", "." ]

[ "func", "(", "r", "*", "rekeyMaster", ")", "currentDeviceSolvesProblemSet", "(", "me", "*", "libkb", ".", "User", ",", "ps", "keybase1", ".", "ProblemSet", ")", "(", "ret", "bool", ")", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\\n", "\"", ",", "ret", ")", "\n", "}", "(", ")", "\n\n", "var", "paperKey", "libkb", ".", "GenericKey", "\n", "deviceKey", ",", "err", ":=", "me", ".", "GetDeviceSubkey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Info", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "ret", "\n", "}", "\n\n", "m", ":=", "libkb", ".", "NewMetaContextBackground", "(", "r", ".", "G", "(", ")", ")", "\n", "if", "d", ":=", "m", ".", "ActiveDevice", "(", ")", ".", "ProvisioningKey", "(", "m", ")", ";", "d", "!=", "nil", "{", "paperKey", "=", "d", ".", "EncryptionKey", "(", ")", "\n", "}", "\n\n", "// We can continue though, so no need to error out", "if", "paperKey", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "deviceKey", "!=", "nil", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "deviceKey", ".", "GetKID", "(", ")", ")", "\n", "}", "\n", "if", "paperKey", "!=", "nil", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "paperKey", ".", "GetKID", "(", ")", ")", "\n", "}", "\n\n", "for", "_", ",", "tlf", ":=", "range", "ps", ".", "Tlfs", "{", "if", "!", "keysSolveProblemTLF", "(", "[", "]", "libkb", ".", "GenericKey", "{", "deviceKey", ",", "paperKey", "}", ",", "tlf", ")", "{", "r", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\\n", "\"", ",", "tlf", ".", "Tlf", ".", "Name", ",", "tlf", ".", "Tlf", ".", "Id", ")", "\n", "return", "ret", "\n", "}", "\n", "}", "\n", "ret", "=", "true", "\n", "return", "ret", "\n", "}" ]

[ "currentDeviceSolvesProblemSet", "returns", "true", "if", "the", "current", "device", "can", "fix", "all", "of", "the", "folders", "in", "the", "ProblemSet", "." ]

[ "func", "(", "d", "*", "Delegator", ")", "Run", "(", "m", "MetaContext", ")", "(", "err", "error", ")", "{", "var", "jw", "*", "jsonw", ".", "Wrapper", "\n", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "if", "err", "=", "d", ".", "CheckArgs", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "d", ".", "MerkleRoot", "=", "m", ".", "G", "(", ")", ".", "MerkleClient", ".", "LastRoot", "(", ")", "\n\n", "// We'll need to generate two proofs, so set the Ctime", "// so that we get the same time both times", "d", ".", "Ctime", "=", "m", ".", "G", "(", ")", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "Unix", "(", ")", "\n\n", "// For a sibkey signature, we first sign the blob with the", "// sibkey, and then embed that signature for the delegating key", "if", "d", ".", "DelegationType", "==", "DelegationTypeSibkey", "{", "if", "jw", ",", "err", "=", "KeyProof", "(", "m", ",", "*", "d", ")", ";", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "d", ".", "RevSig", ",", "_", ",", "_", ",", "err", "=", "SignJSON", "(", "jw", ",", "d", ".", "NewKey", ")", ";", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "m", ".", "G", "(", ")", ".", "LocalDb", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "proof", ",", "err", ":=", "KeyProof2", "(", "m", ",", "*", "d", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "d", ".", "SignAndPost", "(", "m", ",", "proof", ")", "\n", "}" ]

[ "Run", "the", "Delegator", "performing", "all", "necessary", "internal", "operations", ".", "Return", "err", "on", "failure", "and", "nil", "on", "success", "." ]

[ "func", "(", "id", "ID", ")", "MarshalText", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "bytes", ",", "err", ":=", "id", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "[", "]", "byte", "(", "hex", ".", "EncodeToString", "(", "bytes", ")", ")", ",", "nil", "\n", "}" ]

[ "MarshalText", "implements", "the", "encoding", ".", "TextMarshaler", "interface", "for", "ID", "." ]

[ "func", "NewKeybaseDaemonRPC", "(", "config", "Config", ",", "kbCtx", "Context", ",", "log", "logger", ".", "Logger", ",", "debug", "bool", ",", "additionalProtocols", "[", "]", "rpc", ".", "Protocol", ")", "*", "KeybaseDaemonRPC", "{", "k", ":=", "newKeybaseDaemonRPC", "(", "config", ",", "kbCtx", ",", "log", ")", "\n", "k", ".", "config", "=", "config", "\n", "k", ".", "daemonLog", "=", "logger", ".", "New", "(", "\"", "\"", ")", "\n", "if", "debug", "{", "k", ".", "daemonLog", ".", "Configure", "(", "\"", "\"", ",", "true", ",", "\"", "\"", ")", "\n", "}", "\n", "conn", ":=", "NewSharedKeybaseConnection", "(", "kbCtx", ",", "config", ",", "k", ")", "\n", "k", ".", "fillClients", "(", "conn", ".", "GetClient", "(", ")", ")", "\n", "k", ".", "shutdownFn", "=", "conn", ".", "Shutdown", "\n\n", "if", "config", ".", "Mode", "(", ")", ".", "ServiceKeepaliveEnabled", "(", ")", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "k", ".", "keepAliveCancel", "=", "cancel", "\n", "go", "k", ".", "keepAliveLoop", "(", "ctx", ")", "\n", "}", "\n", "k", ".", "notifyService", "=", "newNotifyServiceHandler", "(", "config", ",", "log", ")", "\n\n", "k", ".", "addKBFSProtocols", "(", ")", "\n", "k", ".", "AddProtocols", "(", "additionalProtocols", ")", "\n\n", "return", "k", "\n", "}" ]

[ "NewKeybaseDaemonRPC", "makes", "a", "new", "KeybaseDaemonRPC", "that", "makes", "RPC", "calls", "using", "the", "socket", "of", "the", "given", "Keybase", "context", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonRPC", ")", "AddProtocols", "(", "protocols", "[", "]", "rpc", ".", "Protocol", ")", "{", "if", "protocols", "==", "nil", "{", "return", "\n", "}", "\n\n", "k", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "k", ".", "protocols", "!=", "nil", "{", "k", ".", "protocols", "=", "append", "(", "k", ".", "protocols", ",", "protocols", "...", ")", "\n", "}", "else", "{", "k", ".", "protocols", "=", "protocols", "\n", "}", "\n\n", "// If we are already connected, register these protocols.", "if", "k", ".", "server", "!=", "nil", "{", "for", "_", ",", "p", ":=", "range", "protocols", "{", "k", ".", "registerProtocol", "(", "k", ".", "server", ",", "p", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "AddProtocols", "adds", "protocols", "that", "are", "registered", "on", "server", "connect" ]

[ "func", "(", "k", "*", "KeybaseDaemonRPC", ")", "Shutdown", "(", ")", "{", "if", "k", ".", "shutdownFn", "!=", "nil", "{", "k", ".", "shutdownFn", "(", ")", "\n", "}", "\n", "if", "k", ".", "keepAliveCancel", "!=", "nil", "{", "k", ".", "keepAliveCancel", "(", ")", "\n", "}", "\n", "k", ".", "log", ".", "Warning", "(", "\"", "\"", ")", "\n\n", "}" ]

[ "Shutdown", "implements", "the", "KeybaseService", "interface", "for", "KeybaseDaemonRPC", "." ]

[ "func", "newNotifyServiceHandler", "(", "config", "Config", ",", "log", "logger", ".", "Logger", ")", "keybase1", ".", "NotifyServiceInterface", "{", "s", ":=", "&", "notifyServiceHandler", "{", "config", ":", "config", ",", "log", ":", "log", "}", "\n", "return", "s", "\n", "}" ]

[ "newNotifyServiceHandler", "makes", "a", "new", "NotifyServiceHandler" ]

[ "func", "(", "k", "*", "KeybaseDaemonRPC", ")", "FavoritesChanged", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ")", "error", "{", "k", ".", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "RefreshCachedFavorites", "(", "ctx", ")", "\n", "return", "nil", "\n", "}" ]

[ "FavoritesChanged", "implements", "keybase1", ".", "NotifyFavoritesClient" ]

[ "func", "(", "bt", "*", "backpressureTracker", ")", "updateSemaphoreMax", "(", ")", "{", "newMax", ":=", "int64", "(", "bt", ".", "currLimit", "(", ")", ")", "\n", "delta", ":=", "newMax", "-", "bt", ".", "semaphoreMax", "\n", "// These operations are adjusting the *maximum* value of", "// bt.semaphore.", "if", "delta", ">", "0", "{", "bt", ".", "semaphore", ".", "Release", "(", "delta", ")", "\n", "}", "else", "if", "delta", "<", "0", "{", "bt", ".", "semaphore", ".", "ForceAcquire", "(", "-", "delta", ")", "\n", "}", "\n", "bt", ".", "semaphoreMax", "=", "newMax", "\n", "}" ]

[ "updateSemaphoreMax", "must", "be", "called", "whenever", "bt", ".", "used", "or", "bt", ".", "free", "changes", "." ]

[ "func", "newBackpressureDiskLimiter", "(", "log", "logger", ".", "Logger", ",", "params", "backpressureDiskLimiterParams", ")", "(", "*", "backpressureDiskLimiter", ",", "error", ")", "{", "freeBytes", ",", "freeFiles", ",", "err", ":=", "params", ".", "freeBytesAndFilesFn", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "journalTracker", ",", "err", ":=", "newJournalTracker", "(", "params", ".", "minThreshold", ",", "params", ".", "maxThreshold", ",", "params", ".", "quotaMinThreshold", ",", "params", ".", "quotaMaxThreshold", ",", "params", ".", "journalFrac", ",", "params", ".", "byteLimit", ",", "params", ".", "fileLimit", ",", "freeBytes", ",", "freeFiles", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// byteLimit must be scaled by the proportion of the limit", "// that the disk cache should consume. Add 0.5 for rounding.", "diskCacheByteLimit", ":=", "int64", "(", "(", "float64", "(", "params", ".", "byteLimit", ")", "*", "params", ".", "diskCacheFrac", ")", "+", "0.5", ")", "\n", "syncCacheByteLimit", ":=", "int64", "(", "(", "float64", "(", "params", ".", "byteLimit", ")", "*", "params", ".", "syncCacheFrac", ")", "+", "0.5", ")", "\n", "overallByteTracker", ",", "err", ":=", "newBackpressureTracker", "(", "1.0", ",", "1.0", ",", "1.0", ",", "params", ".", "byteLimit", ",", "freeBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "diskCacheByteTracker", ",", "err", ":=", "newBackpressureTracker", "(", "1.0", ",", "1.0", ",", "params", ".", "diskCacheFrac", ",", "diskCacheByteLimit", ",", "freeBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "syncCacheByteTracker", ",", "err", ":=", "newBackpressureTracker", "(", "1.0", ",", "1.0", ",", "params", ".", "diskCacheFrac", ",", "syncCacheByteLimit", ",", "freeBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "bdl", ":=", "&", "backpressureDiskLimiter", "{", "log", ":", "log", ",", "maxDelay", ":", "params", ".", "maxDelay", ",", "delayFn", ":", "params", ".", "delayFn", ",", "freeBytesAndFilesFn", ":", "params", ".", "freeBytesAndFilesFn", ",", "quotaFn", ":", "params", ".", "quotaFn", ",", "lock", ":", "sync", ".", "RWMutex", "{", "}", ",", "overallByteTracker", ":", "overallByteTracker", ",", "journalTracker", ":", "journalTracker", ",", "diskCacheByteTracker", ":", "diskCacheByteTracker", ",", "syncCacheByteTracker", ":", "syncCacheByteTracker", ",", "}", "\n", "return", "bdl", ",", "nil", "\n", "}" ]

[ "newBackpressureDiskLimiter", "constructs", "a", "new", "backpressureDiskLimiter", "with", "the", "given", "params", "." ]

[ "func", "defaultDoDelay", "(", "ctx", "context", ".", "Context", ",", "delay", "time", ".", "Duration", ")", "error", "{", "if", "delay", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "timer", ":=", "time", ".", "NewTimer", "(", "delay", ")", "\n", "select", "{", "case", "<-", "timer", ".", "C", ":", "return", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "timer", ".", "Stop", "(", ")", "\n", "return", "errors", ".", "WithStack", "(", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "defaultDoDelay", "uses", "a", "timer", "to", "delay", "by", "the", "given", "duration", "." ]

[ "func", "CreateWalletGated", "(", "mctx", "libkb", ".", "MetaContext", ")", "(", "res", "CreateWalletGatedResult", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "defer", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "res", ",", "err", "!=", "nil", ")", "\n", "}", "(", ")", "\n", "res", ",", "err", "=", "createWalletGatedHelper", "(", "mctx", ")", "\n", "if", "err", "==", "nil", "&&", "res", ".", "ErrorCreating", "!=", "nil", "{", "// An error was encountered while creating the wallet.", "// This could have been the result of losing a race against other threads.", "// When multiple threads create a wallet only one will succeed.", "// In that case we _do_ have a wallet now even though this thread failed,", "// so run again for an accurate reply.", "return", "createWalletGatedHelper", "(", "mctx", ")", "\n", "}", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "CreateWalletGated", "may", "create", "a", "wallet", "for", "the", "user", ".", "Taking", "into", "account", "settings", "from", "the", "server", ".", "It", "should", "be", "speedy", "to", "call", "repeatedly", "_if_", "the", "user", "gets", "a", "wallet", "." ]