Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "rfs", "*", "RootFS", ")", "Join", "(", "elem", "...", "string", ")", "string", "{", "return", "path", ".", "Clean", "(", "path", ".", "Join", "(", "elem", "...", ")", ")", "\n", "}" ]

[ "Join", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "ReadDir", "(", "p", "string", ")", "(", "fis", "[", "]", "os", ".", "FileInfo", ",", "err", "error", ")", "{", "if", "p", "==", "\"", "\"", "{", "p", "=", "\"", "\"", "\n", "}", "\n\n", "if", "p", "!=", "\"", "\"", "{", "return", "nil", ",", "os", ".", "ErrNotExist", "\n", "}", "\n\n", "now", ":=", "rfs", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n", "return", "[", "]", "os", ".", "FileInfo", "{", "&", "wrappedReadFileInfo", "{", "\"", "\"", ",", "0", ",", "now", ",", "true", "}", ",", "&", "wrappedReadFileInfo", "{", "\"", "\"", ",", "0", ",", "now", ",", "true", "}", ",", "&", "wrappedReadFileInfo", "{", "\"", "\"", ",", "0", ",", "now", ",", "true", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "ReadDir", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "Readlink", "(", "_", "string", ")", "(", "target", "string", ",", "err", "error", ")", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Readlink", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "Chroot", "(", "_", "string", ")", "(", "newFS", "billy", ".", "Filesystem", ",", "err", "error", ")", "{", "// Don't allow chroot'ing anywhere outside of the root FS since we", "// haven't yet implemented folderlist browsing.", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Chroot", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "Rename", "(", "_", ",", "_", "string", ")", "(", "err", "error", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Rename", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "MkdirAll", "(", "_", "string", ",", "_", "os", ".", "FileMode", ")", "(", "err", "error", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "MkdirAll", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "e", "*", "EKLib", ")", "GetTeamEK", "(", "mctx", "libkb", ".", "MetaContext", ",", "teamID", "keybase1", ".", "TeamID", ",", "generation", "keybase1", ".", "EkGeneration", ",", "contentCtime", "*", "gregor1", ".", "Time", ")", "(", "teamEK", "keybase1", ".", "TeamEk", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "teamEKBoxStorage", ":=", "mctx", ".", "G", "(", ")", ".", "GetTeamEKBoxStorage", "(", ")", "\n", "teamEK", ",", "err", "=", "teamEKBoxStorage", ".", "Get", "(", "mctx", ",", "teamID", ",", "generation", ",", "contentCtime", ")", "\n", "if", "err", "!=", "nil", "{", "switch", "err", ".", "(", "type", ")", "{", "case", "EphemeralKeyError", ":", "mctx", ".", "Debug", "(", "err", ".", "Error", "(", ")", ")", "\n", "// If we are unable to get the current max generation, try to kick", "// off creation of a new key.", "go", "func", "(", "mctx", "libkb", ".", "MetaContext", ")", "{", "maxGeneration", ",", "err", ":=", "teamEKBoxStorage", ".", "MaxGeneration", "(", "mctx", ",", "teamID", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "if", "generation", "==", "maxGeneration", "{", "_", ",", "created", ",", "cerr", ":=", "e", ".", "GetOrCreateLatestTeamEK", "(", "mctx", ",", "teamID", ")", "\n", "if", "cerr", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "cerr", ")", "\n", "}", "\n", "if", "e", ".", "backgroundCreationTestCh", "!=", "nil", "{", "e", ".", "backgroundCreationTestCh", "<-", "created", "\n", "}", "\n", "}", "\n", "}", "(", "libkb", ".", "NewMetaContextBackground", "(", "mctx", ".", "G", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n", "return", "teamEK", ",", "err", "\n", "}" ]

[ "Try", "to", "get", "the", "TeamEK", "for", "the", "given", "generation", ".", "If", "this", "fails", "and", "the", "generation", "is", "also", "the", "current", "maxGeneration", "create", "a", "new", "teamEK", "." ]

[ "func", "AutoInstall", "(", "context", "Context", ",", "binPath", "string", ",", "force", "bool", ",", "timeout", "time", ".", "Duration", ",", "log", "Log", ")", "(", "bool", ",", "error", ")", "{", "return", "false", ",", "nil", "\n", "}" ]

[ "AutoInstall", "is", "not", "supported", "on", "Windows" ]

[ "func", "InstallLogPath", "(", ")", "(", "string", ",", "error", ")", "{", "// Get the 3 newest keybase logs - sorting by name works because timestamp", "keybaseLogFiles", ",", "err", ":=", "filepath", ".", "Glob", "(", "os", ".", "ExpandEnv", "(", "filepath", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ")", ")", ")", "\n", "sort", ".", "Sort", "(", "sort", ".", "Reverse", "(", "sort", ".", "StringSlice", "(", "keybaseLogFiles", ")", ")", ")", "\n", "if", "len", "(", "keybaseLogFiles", ")", ">", "6", "{", "keybaseLogFiles", "=", "keybaseLogFiles", "[", ":", "6", "]", "\n", "}", "\n\n", "// Get the latest msi log - this is the clean install .msi log", "msiLogFiles", ",", "err", ":=", "filepath", ".", "Glob", "(", "os", ".", "ExpandEnv", "(", "filepath", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ")", ")", ")", "\n", "sort", ".", "Sort", "(", "sort", ".", "Reverse", "(", "sort", ".", "StringSlice", "(", "msiLogFiles", ")", ")", ")", "\n", "if", "len", "(", "msiLogFiles", ")", ">=", "1", "{", "keybaseLogFiles", "=", "append", "(", "keybaseLogFiles", ",", "msiLogFiles", "[", "0", "]", ")", "\n", "}", "\n\n", "// Get the 2 newest dokan logs - sorting by name works because timestamp", "dokanLogFiles", ",", "err", ":=", "filepath", ".", "Glob", "(", "os", ".", "ExpandEnv", "(", "filepath", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ")", ")", ")", "\n", "sort", ".", "Sort", "(", "sort", ".", "Reverse", "(", "sort", ".", "StringSlice", "(", "dokanLogFiles", ")", ")", ")", "\n", "if", "len", "(", "dokanLogFiles", ")", ">", "2", "{", "dokanLogFiles", "=", "dokanLogFiles", "[", ":", "2", "]", "\n", "}", "\n", "keybaseLogFiles", "=", "append", "(", "keybaseLogFiles", ",", "dokanLogFiles", "...", ")", "\n\n", "logName", ",", "logFile", ",", "err", ":=", "libkb", ".", "OpenTempFile", "(", "\"", "\"", ",", "\"", "\"", ",", "0", ")", "\n", "defer", "logFile", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "getVersionAndDrivers", "(", "logFile", ")", "\n\n", "if", "len", "(", "keybaseLogFiles", ")", "==", "0", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n", "for", "_", ",", "path", ":=", "range", "keybaseLogFiles", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ",", "path", ")", "\n\n", "// We have to parse the contents and write them because some files need to", "// be decoded from utf16", "s", ",", "err", ":=", "newScannerUTF16or8", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ",", "path", ",", "err", ")", "\n", "}", "else", "{", "scanner", ":=", "bufio", ".", "NewScanner", "(", "s", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "fmt", ".", "Fprintln", "(", "logFile", ",", "scanner", ".", "Text", "(", ")", ")", "// Println will add back the final '\\n'", "\n", "}", "\n", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ",", "path", ",", "err", ")", "\n", "}", "\n", "}", "\n", "fmt", ".", "Fprint", "(", "logFile", ",", "\"", "\\n", "\\n", "\"", ")", "\n", "}", "\n\n", "return", "logName", ",", "err", "\n", "}" ]

[ "InstallLogPath", "combines", "a", "handful", "of", "install", "logs", "in", "to", "one", "for", "server", "upload", ".", "Unfortunately", "Dokan", "can", "generate", "UTF16", "logs", "so", "we", "test", "each", "file", "and", "translate", "if", "necessary", "." ]

[ "func", "WatchdogLogPath", "(", "logGlobPath", "string", ")", "(", "string", ",", "error", ")", "{", "// Get the 5 newest watchdog logs - sorting by name works because timestamp", "watchdogLogFiles", ",", "err", ":=", "filepath", ".", "Glob", "(", "logGlobPath", ")", "\n", "sort", ".", "Sort", "(", "sort", ".", "Reverse", "(", "sort", ".", "StringSlice", "(", "watchdogLogFiles", ")", ")", ")", "\n", "if", "len", "(", "watchdogLogFiles", ")", ">", "5", "{", "watchdogLogFiles", "=", "watchdogLogFiles", "[", ":", "5", "]", "\n", "}", "\n\n", "logName", ",", "logFile", ",", "err", ":=", "libkb", ".", "OpenTempFile", "(", "\"", "\"", ",", "\"", "\"", ",", "0", ")", "\n", "defer", "logFile", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "watchdogLogFiles", ")", "==", "0", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n", "for", "_", ",", "path", ":=", "range", "watchdogLogFiles", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ",", "path", ")", "\n\n", "// append the files", "func", "(", ")", "{", "fd", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "defer", "fd", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "logFile", ",", "fd", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "logFile", ",", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n\n", "return", "logName", ",", "err", "\n", "}" ]

[ "WatchdogLogPath", "combines", "a", "handful", "of", "watchdog", "logs", "in", "to", "one", "for", "server", "upload", "." ]

[ "func", "addUnflushedPaths", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "VerifyingKey", ",", "codec", "kbfscodec", ".", "Codec", ",", "log", "logger", ".", "Logger", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "mdInfos", "[", "]", "unflushedPathMDInfo", ",", "cpp", "chainsPathPopulator", ",", "unflushedPaths", "unflushedPathsMap", ")", "error", "{", "// Make chains over the entire range to get the unflushed files.", "chains", ":=", "newCRChainsEmpty", "(", ")", "\n", "processedOne", ":=", "false", "\n", "for", "_", ",", "mdInfo", ":=", "range", "mdInfos", "{", "offline", ":=", "keybase1", ".", "OfflineAvailability_NONE", "\n", "if", "osg", "!=", "nil", "{", "offline", "=", "osg", ".", "OfflineAvailabilityForID", "(", "mdInfo", ".", "kmd", ".", "TlfID", "(", ")", ")", "\n", "}", "\n", "winfo", ":=", "newWriterInfo", "(", "uid", ",", "key", ",", "mdInfo", ".", "revision", ",", "offline", ")", "\n", "if", "_", ",", "ok", ":=", "unflushedPaths", "[", "mdInfo", ".", "revision", "]", ";", "ok", "{", "if", "processedOne", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "mdInfo", ".", "revision", ")", "\n", "}", "\n\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "mdInfo", ".", "revision", ")", "\n", "continue", "\n", "}", "\n", "unflushedPaths", "[", "mdInfo", ".", "revision", "]", "=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n\n", "processedOne", "=", "true", "\n", "err", ":=", "chains", ".", "addOps", "(", "codec", ",", "mdInfo", ".", "pmd", ",", "winfo", ",", "mdInfo", ".", "localTimestamp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "!", "processedOne", "{", "return", "nil", "\n", "}", "\n\n", "mostRecentMDInfo", ":=", "mdInfos", "[", "len", "(", "mdInfos", ")", "-", "1", "]", "\n", "chains", ".", "mostRecentChainMDInfo", "=", "mostRecentMDInfo", ".", "kmd", "\n\n", "// Does the last op already have a valid path in each chain? If", "// so, we don't need to bother populating the paths, which can", "// take a fair amount of CPU since the node cache isn't already", "// up-to-date with the current set of pointers (because the MDs", "// haven't been committed yet).", "populatePaths", ":=", "false", "\n", "for", "_", ",", "chain", ":=", "range", "chains", ".", "byOriginal", "{", "if", "len", "(", "chain", ".", "ops", ")", ">", "0", "&&", "!", "chain", ".", "ops", "[", "len", "(", "chain", ".", "ops", ")", "-", "1", "]", ".", "getFinalPath", "(", ")", ".", "IsValid", "(", ")", "{", "populatePaths", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "populatePaths", "{", "err", ":=", "cpp", ".", "populateChainPaths", "(", "ctx", ",", "log", ",", "chains", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "chain", ":=", "range", "chains", ".", "byOriginal", "{", "if", "len", "(", "chain", ".", "ops", ")", ">", "0", "{", "// Use the same final path from the chain for all ops.", "finalPath", ":=", "chain", ".", "ops", "[", "len", "(", "chain", ".", "ops", ")", "-", "1", "]", ".", "getFinalPath", "(", ")", ".", "CanonicalPathString", "(", ")", "\n", "for", "_", ",", "op", ":=", "range", "chain", ".", "ops", "{", "revPaths", ",", "ok", ":=", "unflushedPaths", "[", "op", ".", "getWriterInfo", "(", ")", ".", "revision", "]", "\n", "if", "!", "ok", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "op", ".", "getWriterInfo", "(", ")", ".", "revision", ")", ")", "\n", "}", "\n", "revPaths", "[", "finalPath", "]", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addUnflushedPaths", "populates", "the", "given", "unflushed", "paths", "object", ".", "The", "caller", "should", "NOT", "be", "holding", "any", "locks", "as", "it", "s", "possible", "that", "blocks", "will", "need", "to", "be", "fetched", "." ]

[ "func", "(", "upc", "*", "unflushedPathCache", ")", "prepUnflushedPaths", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "VerifyingKey", ",", "codec", "kbfscodec", ".", "Codec", ",", "log", "logger", ".", "Logger", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "mdInfo", "unflushedPathMDInfo", ")", "(", "unflushedPathsPerRevMap", ",", "error", ")", "{", "cpp", ":=", "func", "(", ")", "chainsPathPopulator", "{", "upc", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "upc", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "upc", ".", "chainsPopulator", "\n", "}", "(", ")", "\n\n", "// The unflushed paths haven't been initialized yet.", "if", "cpp", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "newUnflushedPaths", ":=", "make", "(", "unflushedPathsMap", ")", "\n", "mdInfos", ":=", "[", "]", "unflushedPathMDInfo", "{", "mdInfo", "}", "\n\n", "err", ":=", "addUnflushedPaths", "(", "ctx", ",", "uid", ",", "key", ",", "codec", ",", "log", ",", "osg", ",", "mdInfos", ",", "cpp", ",", "newUnflushedPaths", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "newUnflushedPaths", ")", ">", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "newUnflushedPaths", ")", ")", "\n", "}", "\n\n", "perRevMap", ",", "ok", ":=", "newUnflushedPaths", "[", "mdInfo", ".", "revision", "]", "\n", "if", "!", "ok", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "mdInfo", ".", "revision", ")", ")", "\n", "}", "\n\n", "return", "perRevMap", ",", "nil", "\n", "}" ]

[ "prepUnflushedPaths", "returns", "a", "set", "of", "paths", "that", "were", "updated", "in", "the", "given", "revision", "." ]

[ "func", "(", "upc", "*", "unflushedPathCache", ")", "appendToCache", "(", "mdInfo", "unflushedPathMDInfo", ",", "perRevMap", "unflushedPathsPerRevMap", ")", "bool", "{", "upc", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "upc", ".", "lock", ".", "Unlock", "(", ")", "\n", "switch", "upc", ".", "state", "{", "case", "upcUninitialized", ":", "// Nothing to do.", "case", "upcInitializing", ":", "// Append to queue for processing at the end of initialization.", "upc", ".", "queue", "=", "append", "(", "upc", ".", "queue", ",", "upcQueuedOp", "{", "op", ":", "upcOpAppend", ",", "info", ":", "mdInfo", ",", "rev", ":", "mdInfo", ".", "revision", ",", "}", ")", "\n", "case", "upcInitialized", ":", "if", "perRevMap", "==", "nil", "{", "// This was prepared before `upc.chainsPopulator` was set,", "// and needs to be done again.", "return", "false", "\n", "}", "\n", "// Update the cache with the prepared paths.", "upc", ".", "unflushedPaths", "[", "mdInfo", ".", "revision", "]", "=", "perRevMap", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "upc", ".", "state", ")", ")", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "appendToCache", "returns", "true", "when", "successful", "and", "false", "if", "it", "needs", "to", "be", "retried", "after", "the", "per", "-", "revision", "map", "is", "recomputed", "." ]

[ "func", "(", "upc", "*", "unflushedPathCache", ")", "reinitializeWithResolution", "(", "mdInfo", "unflushedPathMDInfo", ",", "perRevMap", "unflushedPathsPerRevMap", ",", "isLocalSquash", "bool", ")", "bool", "{", "upc", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "upc", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "if", "perRevMap", "==", "nil", "{", "switch", "upc", ".", "state", "{", "case", "upcInitialized", ":", "// Initialization started since the perRevMap was created,", "// so try again.", "return", "false", "\n", "case", "upcInitializing", ":", "// Save this reinit for later.", "upc", ".", "queue", "=", "append", "(", "upc", ".", "queue", ",", "upcQueuedOp", "{", "op", ":", "upcOpReinit", ",", "info", ":", "mdInfo", ",", "rev", ":", "mdInfo", ".", "revision", ",", "isLocalSquash", ":", "isLocalSquash", ",", "}", ")", "\n", "return", "true", "\n", "default", ":", "// We can't initialize with a nil revision map.", "return", "true", "\n", "}", "\n", "}", "\n\n", "if", "upc", ".", "unflushedPaths", "!=", "nil", "{", "reinitUpcCache", "(", "mdInfo", ".", "revision", ",", "upc", ".", "unflushedPaths", ",", "perRevMap", ",", "isLocalSquash", ")", "\n", "}", "else", "{", "upc", ".", "unflushedPaths", "=", "unflushedPathsMap", "{", "mdInfo", ".", "revision", ":", "perRevMap", "}", "\n", "}", "\n", "upc", ".", "queue", "=", "nil", "\n", "if", "upc", ".", "ready", "!=", "nil", "{", "close", "(", "upc", ".", "ready", ")", "\n", "upc", ".", "ready", "=", "nil", "\n", "}", "\n", "upc", ".", "state", "=", "upcInitialized", "\n", "return", "true", "\n", "}" ]

[ "reinitializeWithResolution", "returns", "true", "when", "successful", "and", "false", "if", "it", "needs", "to", "be", "retried", "after", "the", "per", "-", "revision", "map", "is", "recomputed", "." ]

[ "func", "NewS3Store", "(", "logger", "logger", ".", "Logger", ",", "env", "*", "libkb", ".", "Env", ",", "runtimeDir", "string", ")", "*", "S3Store", "{", "return", "&", "S3Store", "{", "DebugLabeler", ":", "utils", ".", "NewDebugLabeler", "(", "logger", ",", "\"", "\"", ",", "false", ")", ",", "s3c", ":", "&", "s3", ".", "AWS", "{", "}", ",", "stash", ":", "NewFileStash", "(", "runtimeDir", ")", ",", "env", ":", "env", ",", "}", "\n", "}" ]

[ "NewS3Store", "creates", "a", "standard", "Store", "that", "uses", "a", "real", "S3", "connection", "." ]

[ "func", "(", "a", "*", "S3Store", ")", "DownloadAsset", "(", "ctx", "context", ".", "Context", ",", "params", "chat1", ".", "S3Params", ",", "asset", "chat1", ".", "Asset", ",", "w", "io", ".", "Writer", ",", "signer", "s3", ".", "Signer", ",", "progress", "types", ".", "ProgressReporter", ")", "error", "{", "if", "asset", ".", "Key", "==", "nil", "||", "asset", ".", "VerifyKey", "==", "nil", "||", "asset", ".", "EncHash", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "asset", ")", "\n", "}", "\n", "body", ",", "err", ":=", "a", ".", "GetAssetReader", "(", "ctx", ",", "params", ",", "asset", ",", "signer", ")", "\n", "defer", "func", "(", ")", "{", "if", "body", "!=", "nil", "{", "body", ".", "Close", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "a", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "asset", ".", "Path", ")", "\n", "return", "a", ".", "DecryptAsset", "(", "ctx", ",", "w", ",", "body", ",", "asset", ",", "progress", ")", "\n", "}" ]

[ "DownloadAsset", "gets", "an", "object", "from", "S3", "as", "described", "in", "asset", "." ]

[ "func", "NewCmdRekey", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Subcommands", ":", "[", "]", "cli", ".", "Command", "{", "NewCmdRekeyStatus", "(", "cl", ",", "g", ")", ",", "NewCmdRekeyPaper", "(", "cl", ",", "g", ")", ",", "NewCmdRekeyTrigger", "(", "cl", ",", "g", ")", ",", "}", ",", "}", "\n", "}" ]

[ "These", "are", "the", "devel", "rekey", "commands" ]

[ "func", "NewTrackToken", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "TrackTokenArg", ")", "*", "TrackToken", "{", "if", "arg", ".", "Options", ".", "SigVersion", "==", "nil", "||", "libkb", ".", "SigVersion", "(", "*", "arg", ".", "Options", ".", "SigVersion", ")", "==", "libkb", ".", "KeybaseNullSigVersion", "{", "tmp", ":=", "keybase1", ".", "SigVersion", "(", "libkb", ".", "GetDefaultSigVersion", "(", "g", ")", ")", "\n", "arg", ".", "Options", ".", "SigVersion", "=", "&", "tmp", "\n", "}", "\n\n", "return", "&", "TrackToken", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewTrackToken", "creates", "a", "TrackToken", "engine", "." ]

[ "func", "NewCachedUPAKLoader", "(", "g", "*", "GlobalContext", ",", "f", "time", ".", "Duration", ")", "*", "CachedUPAKLoader", "{", "c", ",", "err", ":=", "lru", ".", "New", "(", "g", ".", "Env", ".", "GetUPAKCacheSize", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "g", ".", "Env", ".", "GetUPAKCacheSize", "(", ")", ")", ")", "\n", "}", "\n", "return", "&", "CachedUPAKLoader", "{", "Contextified", ":", "NewContextified", "(", "g", ")", ",", "Freshness", ":", "f", ",", "cache", ":", "c", ",", "noCache", ":", "false", ",", "}", "\n", "}" ]

[ "NewCachedUPAKLoader", "constructs", "a", "new", "CachedUPAKLoader" ]

[ "func", "NewUncachedUPAKLoader", "(", "g", "*", "GlobalContext", ")", "UPAKLoader", "{", "return", "&", "CachedUPAKLoader", "{", "Contextified", ":", "NewContextified", "(", "g", ")", ",", "Freshness", ":", "time", ".", "Duration", "(", "0", ")", ",", "noCache", ":", "true", ",", "}", "\n", "}" ]

[ "NewUncachedUPAKLoader", "creates", "a", "UPAK", "loader", "that", "doesn", "t", "do", "any", "caching", ".", "It", "uses", "the", "implementation", "of", "CachedUPAKLoader", "but", "disables", "all", "caching", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "Load", "(", "arg", "LoadUserArg", ")", "(", "*", "keybase1", ".", "UserPlusAllKeys", ",", "*", "User", ",", "error", ")", "{", "ret", ",", "user", ",", "err", ":=", "u", ".", "loadWithInfo", "(", "arg", ",", "nil", ",", "nil", ",", "true", ")", "\n\n", "// NOTE -- it's OK to return an error and a user, since certain code paths", "// want both (see note in loadWithInfo).", "var", "converted", "*", "keybase1", ".", "UserPlusAllKeys", "\n", "if", "ret", "!=", "nil", "{", "tmp", ":=", "keybase1", ".", "UPAKFromUPKV2AI", "(", "*", "ret", ")", "\n", "converted", "=", "&", "tmp", "\n", "}", "\n\n", "return", "converted", ",", "user", ",", "err", "\n", "}" ]

[ "Load", "a", "UserPlusKeysV2AllIncarnations", "from", "the", "local", "cache", "falls", "back", "to", "LoadUser", "and", "cache", "the", "user", ".", "Can", "only", "perform", "lookups", "by", "UID", ".", "Will", "return", "a", "non", "-", "nil", "UserPlusKeysV2AllIncarnations", "or", "a", "non", "-", "nil", "error", "but", "never", "both", "non", "-", "nil", "nor", "never", "both", "nil", ".", "If", "we", "had", "to", "do", "a", "full", "LoadUser", "as", "part", "of", "the", "request", "it", "s", "returned", "too", ".", "Convert", "to", "UserPlusAllKeys", "on", "the", "way", "out", "for", "backwards", "compatibility", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LoadV2", "(", "arg", "LoadUserArg", ")", "(", "*", "keybase1", ".", "UserPlusKeysV2AllIncarnations", ",", "*", "User", ",", "error", ")", "{", "m", ",", "tbs", ":=", "arg", ".", "m", ".", "WithTimeBuckets", "(", ")", "\n", "arg", ".", "m", "=", "m", "\n", "defer", "tbs", ".", "Record", "(", "\"", "\"", ")", "(", ")", "\n", "return", "u", ".", "loadWithInfo", "(", "arg", ",", "nil", ",", "nil", ",", "true", ")", "\n", "}" ]

[ "Load", "a", "UserPlusKeysV2AllIncarnations", "from", "the", "local", "cache", "falls", "back", "to", "LoadUser", "and", "cache", "the", "user", ".", "Can", "only", "perform", "lookups", "by", "UID", ".", "Will", "return", "a", "non", "-", "nil", "UserPlusKeysV2AllIncarnations", "or", "a", "non", "-", "nil", "error", "but", "never", "both", "non", "-", "nil", "nor", "never", "both", "nil", ".", "If", "we", "had", "to", "do", "a", "full", "LoadUser", "as", "part", "of", "the", "request", "it", "s", "returned", "too", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LoadKeyV2", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "kid", "keybase1", ".", "KID", ")", "(", "ret", "*", "keybase1", ".", "UserPlusKeysV2", ",", "upak", "*", "keybase1", ".", "UserPlusKeysV2AllIncarnations", ",", "key", "*", "keybase1", ".", "PublicKeyV2NaCl", ",", "err", "error", ")", "{", "ctx", "=", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "// Load key", "\n", "defer", "u", ".", "G", "(", ")", ".", "CVTraceTimed", "(", "ctx", ",", "VLog0", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "uid", ",", "kid", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "ctx", ",", "tbs", ":=", "u", ".", "G", "(", ")", ".", "CTimeBuckets", "(", "ctx", ")", "\n", "defer", "tbs", ".", "Record", "(", "\"", "\"", ")", "(", ")", "\n", "if", "uid", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "nil", ",", "nil", ",", "NoUIDError", "{", "}", "\n", "}", "\n\n", "argBase", ":=", "NewLoadUserArg", "(", "u", ".", "G", "(", ")", ")", ".", "WithUID", "(", "uid", ")", ".", "WithPublicKeyOptional", "(", ")", ".", "WithNetContext", "(", "ctx", ")", "\n\n", "// Make the retry mechanism increasingly aggressive. See CORE-8851.", "// It should be that a ForcePoll is good enough, but in some rare cases,", "// people have cached values for previous pre-reset user incarnations that", "// were incorrect. So clobber over that if it comes to it.", "attempts", ":=", "[", "]", "LoadUserArg", "{", "argBase", ",", "argBase", ".", "WithForcePoll", "(", "true", ")", ",", "argBase", ".", "WithForceReload", "(", ")", ",", "}", "\n\n", "for", "i", ",", "arg", ":=", "range", "attempts", "{", "if", "i", ">", "0", "{", "u", ".", "G", "(", ")", ".", "VDL", ".", "CLogf", "(", "ctx", ",", "VLog0", ",", "\"", "\"", ",", "arg", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "upak", ",", "_", ",", "err", ":=", "u", ".", "LoadV2", "(", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "if", "upak", "==", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ret", ",", "key", ":=", "upak", ".", "FindKID", "(", "kid", ")", "\n", "if", "key", "!=", "nil", "{", "u", ".", "G", "(", ")", ".", "VDL", ".", "CLogf", "(", "ctx", ",", "VLog1", ",", "\"", "\"", ",", "ret", ".", "Uid", ")", "\n", "return", "ret", ",", "upak", ",", "key", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "nil", ",", "nil", ",", "NotFoundError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}" ]

[ "LoadKeyV2", "looks", "through", "all", "incarnations", "for", "the", "user", "and", "returns", "the", "incarnation", "with", "the", "given", "KID", "as", "well", "as", "the", "Key", "data", "associated", "with", "that", "KID", ".", "It", "picks", "the", "latest", "such", "incarnation", "if", "there", "are", "multiple", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LoadDeviceKey", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "deviceID", "keybase1", ".", "DeviceID", ")", "(", "upakv1", "*", "keybase1", ".", "UserPlusAllKeys", ",", "deviceKey", "*", "keybase1", ".", "PublicKey", ",", "revoked", "*", "keybase1", ".", "RevokedKey", ",", "err", "error", ")", "{", "var", "info", "CachedUserLoadInfo", "\n", "larg", ":=", "NewLoadUserByUIDArg", "(", "ctx", ",", "u", ".", "G", "(", ")", ",", "uid", ")", "\n", "upakV2", ",", "_", ",", "err", ":=", "u", ".", "loadWithInfo", "(", "larg", ",", "&", "info", ",", "nil", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "upakV1", ":=", "keybase1", ".", "UPAKFromUPKV2AI", "(", "*", "upakV2", ")", "\n\n", "deviceKey", ",", "revoked", ",", "err", "=", "u", ".", "extractDeviceKey", "(", "upakV1", ",", "deviceID", ")", "\n", "if", "err", "==", "nil", "{", "// Early success, return", "return", "&", "upakV1", ",", "deviceKey", ",", "revoked", ",", "err", "\n", "}", "\n\n", "// Try again with a forced load in case the device is very new.", "larg", "=", "larg", ".", "WithForcePoll", "(", "true", ")", "\n", "upakV2", ",", "_", ",", "err", "=", "u", ".", "loadWithInfo", "(", "larg", ",", "nil", ",", "nil", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "upakV1", "=", "keybase1", ".", "UPAKFromUPKV2AI", "(", "*", "upakV2", ")", "\n\n", "deviceKey", ",", "revoked", ",", "err", "=", "u", ".", "extractDeviceKey", "(", "upakV1", ",", "deviceID", ")", "\n", "return", "&", "upakV1", ",", "deviceKey", ",", "revoked", ",", "err", "\n", "}" ]

[ "Load", "the", "PublicKey", "for", "a", "user", "s", "device", "from", "the", "local", "cache", "falling", "back", "to", "LoadUser", "and", "cache", "the", "user", ".", "If", "the", "user", "exists", "but", "the", "device", "doesn", "t", "will", "force", "a", "load", "in", "case", "the", "device", "is", "very", "new", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LoadUPAKWithDeviceID", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "deviceID", "keybase1", ".", "DeviceID", ")", "(", "*", "keybase1", ".", "UserPlusKeysV2AllIncarnations", ",", "error", ")", "{", "var", "info", "CachedUserLoadInfo", "\n", "larg", ":=", "NewLoadUserByUIDArg", "(", "ctx", ",", "u", ".", "G", "(", ")", ",", "uid", ")", ".", "WithPublicKeyOptional", "(", ")", "\n", "upakV2", ",", "_", ",", "err", ":=", "u", ".", "loadWithInfo", "(", "larg", ",", "&", "info", ",", "nil", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "device", ":=", "range", "upakV2", ".", "Current", ".", "DeviceKeys", "{", "if", "device", ".", "DeviceID", ".", "Eq", "(", "deviceID", ")", "{", "// Early success, return", "return", "upakV2", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Try again with a forced load in case the device is very new.", "larg", "=", "larg", ".", "WithForcePoll", "(", "true", ")", "\n", "upakV2", ",", "_", ",", "err", "=", "u", ".", "loadWithInfo", "(", "larg", ",", "nil", ",", "nil", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "upakV2", ",", "nil", "\n", "}" ]

[ "If", "the", "user", "exists", "but", "the", "device", "doesn", "t", "will", "force", "a", "load", "in", "case", "the", "device", "is", "very", "new", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LookupUsername", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ")", "(", "NormalizedUsername", ",", "error", ")", "{", "var", "empty", "NormalizedUsername", "\n", "uids", ":=", "[", "]", "keybase1", ".", "UID", "{", "uid", "}", "\n", "namePkgs", ",", "err", ":=", "u", ".", "G", "(", ")", ".", "UIDMapper", ".", "MapUIDsToUsernamePackages", "(", "ctx", ",", "u", ".", "G", "(", ")", ",", "uids", ",", "0", ",", "0", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "empty", ",", "err", "\n", "}", "\n", "if", "len", "(", "namePkgs", ")", "==", "0", "{", "return", "empty", ",", "UserNotFoundError", "{", "UID", ":", "uid", ",", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n\n", "if", "u", ".", "TestDeadlocker", "!=", "nil", "{", "u", ".", "TestDeadlocker", "(", ")", "\n", "}", "\n\n", "return", "namePkgs", "[", "0", "]", ".", "NormalizedUsername", ",", "nil", "\n", "}" ]

[ "LookupUsername", "uses", "the", "UIDMapper", "to", "find", "a", "username", "for", "uid", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LookupUsernameUPAK", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ")", "(", "NormalizedUsername", ",", "error", ")", "{", "var", "info", "CachedUserLoadInfo", "\n", "arg", ":=", "NewLoadUserByUIDArg", "(", "ctx", ",", "u", ".", "G", "(", ")", ",", "uid", ")", ".", "WithStaleOK", "(", "true", ")", ".", "WithPublicKeyOptional", "(", ")", "\n", "var", "ret", "NormalizedUsername", "\n", "_", ",", "_", ",", "err", ":=", "u", ".", "loadWithInfo", "(", "arg", ",", "&", "info", ",", "func", "(", "upak", "*", "keybase1", ".", "UserPlusKeysV2AllIncarnations", ")", "error", "{", "if", "upak", "==", "nil", "{", "return", "UserNotFoundError", "{", "UID", ":", "uid", ",", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n", "ret", "=", "NewNormalizedUsername", "(", "upak", ".", "Current", ".", "Username", ")", "\n", "return", "nil", "\n", "}", ",", "false", ")", "\n", "return", "ret", ",", "err", "\n", "}" ]

[ "LookupUsernameUPAK", "uses", "the", "upak", "loader", "to", "find", "a", "username", "for", "uid", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "LookupUID", "(", "ctx", "context", ".", "Context", ",", "un", "NormalizedUsername", ")", "(", "keybase1", ".", "UID", ",", "error", ")", "{", "m", ":=", "NewMetaContext", "(", "ctx", ",", "u", ".", "G", "(", ")", ")", "\n", "rres", ":=", "u", ".", "G", "(", ")", ".", "Resolver", ".", "Resolve", "(", "m", ",", "un", ".", "String", "(", ")", ")", "\n", "if", "err", ":=", "rres", ".", "GetError", "(", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "UID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n", "un2", ",", "err", ":=", "u", ".", "LookupUsername", "(", "ctx", ",", "rres", ".", "GetUID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "UID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n", "if", "!", "un", ".", "Eq", "(", "un2", ")", "{", "m", ".", "Warning", "(", "\"", "\"", ",", "rres", ".", "GetUID", "(", ")", ",", "un", ".", "String", "(", ")", ",", "un2", ".", "String", "(", ")", ")", "\n", "return", "keybase1", ".", "UID", "(", "\"", "\"", ")", ",", "NewBadUsernameError", "(", "un", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "rres", ".", "GetUID", "(", ")", ",", "nil", "\n", "}" ]

[ "LookupUID", "is", "a", "verified", "map", "of", "username", "-", ">", "UID", ".", "IT", "calls", "into", "the", "resolver", "which", "gives", "un", "untrusted", "UID", "but", "verifies", "with", "the", "UPAK", "loader", "that", "the", "mapping", "UID", "-", ">", "username", "is", "correct", "." ]

[ "func", "(", "u", "*", "CachedUPAKLoader", ")", "deleteV1UPAK", "(", "uid", "keybase1", ".", "UID", ")", "{", "err", ":=", "u", ".", "G", "(", ")", ".", "LocalDb", ".", "Delete", "(", "culDBKeyV1", "(", "uid", ")", ")", "\n", "if", "err", "!=", "nil", "{", "u", ".", "G", "(", ")", ".", "Log", ".", "Warning", "(", "\"", "\"", ",", "uid", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "v1", "UPAKs", "are", "all", "legacy", "and", "need", "to", "be", "gradually", "cleaned", "from", "cache", "." ]

[ "func", "(", "c", "UserClient", ")", "LoadUser", "(", "ctx", "context", ".", "Context", ",", "__arg", "LoadUserArg", ")", "(", "res", "User", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Load", "a", "user", "from", "the", "server", "." ]

[ "func", "(", "c", "UserClient", ")", "LoadUserPlusKeys", "(", "ctx", "context", ".", "Context", ",", "__arg", "LoadUserPlusKeysArg", ")", "(", "res", "UserPlusKeys", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Load", "a", "user", "+", "device", "keys", "from", "the", "server", "." ]

[ "func", "(", "c", "UserClient", ")", "LoadPublicKeys", "(", "ctx", "context", ".", "Context", ",", "__arg", "LoadPublicKeysArg", ")", "(", "res", "[", "]", "PublicKey", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Load", "public", "keys", "for", "a", "user", "." ]

[ "func", "(", "c", "UserClient", ")", "ListTracking", "(", "ctx", "context", ".", "Context", ",", "__arg", "ListTrackingArg", ")", "(", "res", "[", "]", "UserSummary", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "The", "list", "-", "tracking", "functions", "get", "verified", "data", "from", "the", "tracking", "statements", "in", "the", "user", "s", "sigchain", ".", "If", "assertion", "is", "empty", "it", "will", "use", "the", "current", "logged", "in", "user", "." ]

[ "func", "(", "c", "UserClient", ")", "GetUPAK", "(", "ctx", "context", ".", "Context", ",", "uid", "UID", ")", "(", "res", "UPAKVersioned", ",", "err", "error", ")", "{", "__arg", ":=", "GetUPAKArg", "{", "Uid", ":", "uid", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "getUPAK", "returns", "a", "UPAK", ".", "Used", "mainly", "for", "debugging", "." ]

[ "func", "(", "c", "UserClient", ")", "GetUPAKLite", "(", "ctx", "context", ".", "Context", ",", "uid", "UID", ")", "(", "res", "UPKLiteV1AllIncarnations", ",", "err", "error", ")", "{", "__arg", ":=", "GetUPAKLiteArg", "{", "Uid", ":", "uid", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "getUPAKLite", "returns", "a", "UPKLiteV1AllIncarnations", ".", "Used", "mainly", "for", "debugging", "." ]

[ "func", "(", "c", "UserClient", ")", "FindNextMerkleRootAfterReset", "(", "ctx", "context", ".", "Context", ",", "__arg", "FindNextMerkleRootAfterResetArg", ")", "(", "res", "NextMerkleRootRes", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "FindNextMerkleRootAfterReset", "finds", "the", "first", "Merkle", "root", "that", "contains", "the", "UID", "reset", "at", "resetSeqno", ".", "You", "should", "pass", "it", "prev", "which", "was", "the", "last", "known", "Merkle", "root", "at", "the", "time", "of", "the", "reset", ".", "Usually", "we", "ll", "just", "turn", "up", "the", "next", "Merkle", "root", "but", "not", "always", "." ]

[ "func", "(", "r", "*", "AutoClaimRunner", ")", "Kick", "(", "mctx", "libkb", ".", "MetaContext", ",", "trigger", "gregor", ".", "MsgID", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "trigger", ")", "\n", "var", "onced", "bool", "\n", "r", ".", "startOnce", ".", "Do", "(", "func", "(", ")", "{", "onced", "=", "true", "\n", "go", "r", ".", "loop", "(", "libkb", ".", "NewMetaContextBackground", "(", "mctx", ".", "G", "(", ")", ")", ",", "trigger", ")", "\n", "}", ")", "\n", "if", "!", "onced", "{", "select", "{", "case", "r", ".", "kickCh", "<-", "trigger", ":", "default", ":", "}", "\n", "}", "\n", "}" ]

[ "Kick", "the", "processor", "into", "gear", ".", "It", "will", "run", "until", "all", "relays", "in", "the", "queue", "are", "claimed", ".", "And", "then", "dismiss", "the", "gregor", "message", ".", "trigger", "is", "optional", "and", "is", "of", "the", "gregor", "message", "that", "caused", "the", "kick", "." ]

[ "func", "NewAccountReset", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "usernameOrEmail", "string", ")", "*", "AccountReset", "{", "return", "&", "AccountReset", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "usernameOrEmail", ":", "usernameOrEmail", ",", "}", "\n", "}" ]

[ "NewAccountReset", "creates", "a", "AccountReset", "engine", "." ]

[ "func", "(", "b", "*", "StdinSource", ")", "Close", "(", ")", "error", "{", "var", "err", "error", "\n", "if", "b", ".", "open", "{", "err", "=", "drain", "(", "os", ".", "Stdin", ")", "\n", "}", "\n", "b", ".", "open", "=", "false", "\n", "return", "err", "\n", "}" ]

[ "Close", "a", "source", "but", "consume", "all", "leftover", "input", "before", "so", "doing", "." ]

[ "func", "isValidFile", "(", "file", "*", "os", ".", "File", ")", "error", "{", "finfo", ",", "err", ":=", "file", ".", "Stat", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "mode", ":=", "finfo", ".", "Mode", "(", ")", ";", "mode", ".", "IsDir", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "isValidFile", "verifies", "the", "file", "in", "question", "is", "not", "actually", "a", "directory", "." ]

[ "func", "SetGlobalExternalKeyStore", "(", "s", "UnsafeExternalKeyStore", ")", "{", "externalKeyStoreMu", ".", "Lock", "(", ")", "\n", "defer", "externalKeyStoreMu", ".", "Unlock", "(", ")", "\n", "externalKeyStore", "=", "TypeSafeExternalKeyStoreProxy", "{", "s", "}", "\n", "externalKeyStoreInitialized", "=", "false", "\n", "}" ]

[ "SetGlobalExternalKeyStore", "is", "called", "by", "Android", "to", "register", "Android", "s", "KeyStore", "with", "Go" ]

[ "func", "(", "wmdV2", "*", "WriterMetadataV2", ")", "ToWriterMetadataV3", "(", ")", "WriterMetadataV3", "{", "var", "wmdV3", "WriterMetadataV3", "\n", "wmdV3", ".", "Writers", "=", "make", "(", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "len", "(", "wmdV2", ".", "Writers", ")", ")", "\n", "copy", "(", "wmdV3", ".", "Writers", ",", "wmdV2", ".", "Writers", ")", "\n\n", "wmdV3", ".", "UnresolvedWriters", "=", "make", "(", "[", "]", "keybase1", ".", "SocialAssertion", ",", "len", "(", "wmdV2", ".", "Extra", ".", "UnresolvedWriters", ")", ")", "\n", "copy", "(", "wmdV3", ".", "UnresolvedWriters", ",", "wmdV2", ".", "Extra", ".", "UnresolvedWriters", ")", "\n\n", "wmdV3", ".", "ID", "=", "wmdV2", ".", "ID", "\n", "wmdV3", ".", "BID", "=", "wmdV2", ".", "BID", "\n", "wmdV3", ".", "WFlags", "=", "wmdV2", ".", "WFlags", "\n", "wmdV3", ".", "DiskUsage", "=", "wmdV2", ".", "DiskUsage", "\n", "wmdV3", ".", "MDDiskUsage", "=", "wmdV2", ".", "MDDiskUsage", "\n", "wmdV3", ".", "RefBytes", "=", "wmdV2", ".", "RefBytes", "\n", "wmdV3", ".", "UnrefBytes", "=", "wmdV2", ".", "UnrefBytes", "\n", "wmdV3", ".", "MDRefBytes", "=", "wmdV2", ".", "MDRefBytes", "\n\n", "if", "wmdV2", ".", "ID", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "{", "wmdV3", ".", "LatestKeyGen", "=", "PublicKeyGen", "\n", "}", "else", "{", "wmdV3", ".", "LatestKeyGen", "=", "wmdV2", ".", "WKeys", ".", "LatestKeyGeneration", "(", ")", "\n", "}", "\n", "return", "wmdV3", "\n", "}" ]

[ "ToWriterMetadataV3", "converts", "the", "WriterMetadataV2", "to", "a", "WriterMetadataV3", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "KeyGenerationsToUpdate", "(", ")", "(", "KeyGen", ",", "KeyGen", ")", "{", "latest", ":=", "md", ".", "LatestKeyGeneration", "(", ")", "\n", "if", "latest", "<", "FirstValidKeyGen", "{", "return", "0", ",", "0", "\n", "}", "\n", "// We keep track of all known key generations.", "return", "FirstValidKeyGen", ",", "latest", "+", "1", "\n", "}" ]

[ "KeyGenerationsToUpdate", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "IsValidRekeyRequest", "(", "codec", "kbfscodec", ".", "Codec", ",", "prevBareMd", "RootMetadata", ",", "user", "keybase1", ".", "UID", ",", "_", ",", "_", "ExtraMetadata", ")", "(", "bool", ",", "error", ")", "{", "if", "!", "md", ".", "IsWriterMetadataCopiedSet", "(", ")", "{", "// Not a copy.", "return", "false", ",", "nil", "\n", "}", "\n", "prevMd", ",", "ok", ":=", "prevBareMd", ".", "(", "*", "RootMetadataV2", ")", "\n", "if", "!", "ok", "{", "// Not the same type so not a copy.", "return", "false", ",", "nil", "\n", "}", "\n", "writerEqual", ",", "err", ":=", "kbfscodec", ".", "Equal", "(", "codec", ",", "md", ".", "WriterMetadataV2", ",", "prevMd", ".", "WriterMetadataV2", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "writerEqual", "{", "// Copy mismatch.", "return", "false", ",", "nil", "\n", "}", "\n", "writerSigInfoEqual", ",", "err", ":=", "kbfscodec", ".", "Equal", "(", "codec", ",", "md", ".", "WriterMetadataSigInfo", ",", "prevMd", ".", "WriterMetadataSigInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "writerSigInfoEqual", "{", "// Signature/public key mismatch.", "return", "false", ",", "nil", "\n", "}", "\n", "onlyUserRKeysChanged", ",", "err", ":=", "md", ".", "haveOnlyUserRKeysChanged", "(", "codec", ",", "prevMd", ",", "user", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "onlyUserRKeysChanged", "{", "// Keys outside of this user's reader key set have changed.", "return", "false", ",", "nil", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "IsValidRekeyRequest", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "IsWriter", "(", "_", "context", ".", "Context", ",", "user", "keybase1", ".", "UID", ",", "deviceKey", "kbfscrypto", ".", "CryptPublicKey", ",", "_", "kbfscrypto", ".", "VerifyingKey", ",", "_", "TeamMembershipChecker", ",", "_", "ExtraMetadata", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "bool", ",", "error", ")", "{", "if", "md", ".", "ID", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "for", "_", ",", "w", ":=", "range", "md", ".", "Writers", "{", "if", "w", "==", "user", ".", "AsUserOrTeam", "(", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}", "\n", "return", "md", ".", "WKeys", ".", "IsWriter", "(", "user", ",", "deviceKey", ")", ",", "nil", "\n", "}" ]

[ "IsWriter", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "IsReader", "(", "_", "context", ".", "Context", ",", "user", "keybase1", ".", "UID", ",", "deviceKey", "kbfscrypto", ".", "CryptPublicKey", ",", "_", "TeamMembershipChecker", ",", "_", "ExtraMetadata", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "bool", ",", "error", ")", "{", "switch", "md", ".", "ID", ".", "Type", "(", ")", "{", "case", "tlf", ".", "Public", ":", "return", "true", ",", "nil", "\n", "case", "tlf", ".", "Private", ":", "return", "md", ".", "RKeys", ".", "IsReader", "(", "user", ",", "deviceKey", ")", ",", "nil", "\n", "case", "tlf", ".", "SingleTeam", ":", "// There are no read-only users of single-team TLFs.", "return", "false", ",", "nil", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "md", ".", "ID", ".", "Type", "(", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "IsReader", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "DeepCopy", "(", "codec", "kbfscodec", ".", "Codec", ")", "(", "MutableRootMetadata", ",", "error", ")", "{", "return", "md", ".", "deepCopy", "(", "codec", ")", "\n", "}" ]

[ "DeepCopy", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "MakeSuccessorCopy", "(", "codec", "kbfscodec", ".", "Codec", ",", "extra", "ExtraMetadata", ",", "latestMDVer", "MetadataVer", ",", "tlfCryptKeyGetter", "func", "(", ")", "(", "[", "]", "kbfscrypto", ".", "TLFCryptKey", ",", "error", ")", ",", "isReadableAndWriter", "bool", ")", "(", "MutableRootMetadata", ",", "ExtraMetadata", ",", "error", ")", "{", "if", "!", "isReadableAndWriter", "||", "(", "latestMDVer", "<", "SegregatedKeyBundlesVer", ")", "{", "// Continue with the current version. If we're just a reader,", "// or can't decrypt the MD, we have to continue with v2", "// because we can't just copy a v2 signature into a v3 MD", "// blindly.", "mdCopy", ",", "err", ":=", "md", ".", "makeSuccessorCopyV2", "(", "codec", ",", "isReadableAndWriter", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "mdCopy", ",", "nil", ",", "nil", "\n", "}", "\n\n", "// Upconvert to the new version.", "return", "md", ".", "makeSuccessorCopyV3", "(", "codec", ",", "tlfCryptKeyGetter", ")", "\n", "}" ]

[ "MakeSuccessorCopy", "implements", "the", "ImmutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "MakeBareTlfHandle", "(", "_", "ExtraMetadata", ")", "(", "tlf", ".", "Handle", ",", "error", ")", "{", "var", "writers", ",", "readers", "[", "]", "keybase1", ".", "UserOrTeamID", "\n", "if", "md", ".", "ID", ".", "Type", "(", ")", "==", "tlf", ".", "Private", "{", "if", "len", "(", "md", ".", "WKeys", ")", "==", "0", "{", "return", "tlf", ".", "Handle", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "md", ".", "RKeys", ")", "==", "0", "{", "return", "tlf", ".", "Handle", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "wkb", ":=", "md", ".", "WKeys", "[", "len", "(", "md", ".", "WKeys", ")", "-", "1", "]", "\n", "rkb", ":=", "md", ".", "RKeys", "[", "len", "(", "md", ".", "RKeys", ")", "-", "1", "]", "\n", "writers", "=", "make", "(", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "0", ",", "len", "(", "wkb", ".", "WKeys", ")", ")", "\n", "readers", "=", "make", "(", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "0", ",", "len", "(", "rkb", ".", "RKeys", ")", ")", "\n", "for", "w", ":=", "range", "wkb", ".", "WKeys", "{", "writers", "=", "append", "(", "writers", ",", "w", ".", "AsUserOrTeam", "(", ")", ")", "\n", "}", "\n", "for", "r", ":=", "range", "rkb", ".", "RKeys", "{", "// TODO: Return an error instead if r is", "// PublicUID. Maybe return an error if r is in", "// WKeys also. Or do all this in", "// MakeBareTlfHandle.", "if", "_", ",", "ok", ":=", "wkb", ".", "WKeys", "[", "r", "]", ";", "!", "ok", "&&", "r", "!=", "keybase1", ".", "PublicUID", "{", "readers", "=", "append", "(", "readers", ",", "r", ".", "AsUserOrTeam", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "writers", "=", "md", ".", "Writers", "\n", "if", "md", ".", "ID", ".", "Type", "(", ")", "==", "tlf", ".", "Public", "{", "readers", "=", "[", "]", "keybase1", ".", "UserOrTeamID", "{", "keybase1", ".", "PublicUID", ".", "AsUserOrTeam", "(", ")", "}", "\n", "}", "\n", "}", "\n\n", "return", "tlf", ".", "MakeHandle", "(", "writers", ",", "readers", ",", "md", ".", "Extra", ".", "UnresolvedWriters", ",", "md", ".", "UnresolvedReaders", ",", "md", ".", "TlfHandleExtensions", "(", ")", ")", "\n", "}" ]

[ "MakeBareTlfHandle", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "TlfHandleExtensions", "(", ")", "(", "extensions", "[", "]", "tlf", ".", "HandleExtension", ")", "{", "if", "md", ".", "ConflictInfo", "!=", "nil", "{", "extensions", "=", "append", "(", "extensions", ",", "*", "md", ".", "ConflictInfo", ")", "\n", "}", "\n", "if", "md", ".", "FinalizedInfo", "!=", "nil", "{", "extensions", "=", "append", "(", "extensions", ",", "*", "md", ".", "FinalizedInfo", ")", "\n", "}", "\n", "return", "extensions", "\n", "}" ]

[ "TlfHandleExtensions", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "PromoteReaders", "(", "readersToPromote", "map", "[", "keybase1", ".", "UID", "]", "bool", ",", "_", "ExtraMetadata", ")", "error", "{", "if", "md", ".", "TlfID", "(", ")", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "return", "InvalidNonPrivateTLFOperation", "{", "md", ".", "TlfID", "(", ")", ",", "\"", "\"", ",", "md", ".", "Version", "(", ")", "}", "\n", "}", "\n\n", "for", "i", ",", "rkb", ":=", "range", "md", ".", "RKeys", "{", "for", "reader", ":=", "range", "readersToPromote", "{", "dkim", ",", "ok", ":=", "rkb", ".", "RKeys", "[", "reader", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reader", ",", "FirstValidKeyGen", "+", "KeyGen", "(", "i", ")", ")", "\n", "}", "\n", "// TODO: This may be incorrect, since dkim may", "// contain negative EPubKey indices, and the", "// upconversion code assumes that writers will", "// only contain non-negative EPubKey indices.", "//", "// See KBFS-1719.", "md", ".", "WKeys", "[", "i", "]", ".", "WKeys", "[", "reader", "]", "=", "dkim", "\n", "delete", "(", "rkb", ".", "RKeys", ",", "reader", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PromoteReaders", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "RevokeRemovedDevices", "(", "updatedWriterKeys", ",", "updatedReaderKeys", "UserDevicePublicKeys", ",", "_", "ExtraMetadata", ")", "(", "ServerHalfRemovalInfo", ",", "error", ")", "{", "if", "md", ".", "TlfID", "(", ")", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "return", "nil", ",", "InvalidNonPrivateTLFOperation", "{", "md", ".", "TlfID", "(", ")", ",", "\"", "\"", ",", "md", ".", "Version", "(", ")", "}", "\n", "}", "\n\n", "var", "wRemovalInfo", "ServerHalfRemovalInfo", "\n", "for", "_", ",", "wkb", ":=", "range", "md", ".", "WKeys", "{", "removalInfo", ":=", "wkb", ".", "WKeys", ".", "RemoveDevicesNotIn", "(", "updatedWriterKeys", ")", "\n", "if", "wRemovalInfo", "==", "nil", "{", "wRemovalInfo", "=", "removalInfo", "\n", "}", "else", "{", "err", ":=", "wRemovalInfo", ".", "AddGeneration", "(", "removalInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "var", "rRemovalInfo", "ServerHalfRemovalInfo", "\n", "for", "_", ",", "rkb", ":=", "range", "md", ".", "RKeys", "{", "removalInfo", ":=", "rkb", ".", "RKeys", ".", "RemoveDevicesNotIn", "(", "updatedReaderKeys", ")", "\n", "if", "rRemovalInfo", "==", "nil", "{", "rRemovalInfo", "=", "removalInfo", "\n", "}", "else", "{", "err", ":=", "rRemovalInfo", ".", "AddGeneration", "(", "removalInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "wRemovalInfo", ".", "MergeUsers", "(", "rRemovalInfo", ")", "\n", "}" ]

[ "RevokeRemovedDevices", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "getTLFKeyBundles", "(", "keyGen", "KeyGen", ")", "(", "*", "TLFWriterKeyBundleV2", ",", "*", "TLFReaderKeyBundleV2", ",", "error", ")", "{", "if", "md", ".", "ID", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "return", "nil", ",", "nil", ",", "InvalidNonPrivateTLFOperation", "{", "md", ".", "ID", ",", "\"", "\"", ",", "md", ".", "Version", "(", ")", "}", "\n", "}", "\n\n", "if", "keyGen", "<", "FirstValidKeyGen", "{", "return", "nil", ",", "nil", ",", "InvalidKeyGenerationError", "{", "md", ".", "ID", ",", "keyGen", "}", "\n", "}", "\n", "i", ":=", "int", "(", "keyGen", "-", "FirstValidKeyGen", ")", "\n", "if", "i", ">=", "len", "(", "md", ".", "WKeys", ")", "||", "i", ">=", "len", "(", "md", ".", "RKeys", ")", "{", "return", "nil", ",", "nil", ",", "NewKeyGenerationError", "{", "md", ".", "ID", ",", "keyGen", "}", "\n", "}", "\n", "return", "&", "md", ".", "WKeys", "[", "i", "]", ",", "&", "md", ".", "RKeys", "[", "i", "]", ",", "nil", "\n", "}" ]

[ "getTLFKeyBundles", "returns", "the", "bundles", "for", "a", "given", "key", "generation", ".", "Note", "that", "it", "is", "legal", "a", "writer", "or", "a", "reader", "to", "have", "no", "keys", "in", "their", "bundle", "if", "they", "only", "have", "a", "Keybase", "username", "with", "no", "device", "keys", "yet", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "GetUserDevicePublicKeys", "(", "_", "ExtraMetadata", ")", "(", "writerDeviceKeys", ",", "readerDeviceKeys", "UserDevicePublicKeys", ",", "err", "error", ")", "{", "if", "md", ".", "TlfID", "(", ")", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "return", "nil", ",", "nil", ",", "InvalidNonPrivateTLFOperation", "{", "md", ".", "TlfID", "(", ")", ",", "\"", "\"", ",", "md", ".", "Version", "(", ")", "}", "\n", "}", "\n\n", "if", "len", "(", "md", ".", "WKeys", ")", "==", "0", "||", "len", "(", "md", ".", "RKeys", ")", "==", "0", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "wUDKIM", ":=", "md", ".", "WKeys", "[", "len", "(", "md", ".", "WKeys", ")", "-", "1", "]", "\n", "rUDKIM", ":=", "md", ".", "RKeys", "[", "len", "(", "md", ".", "RKeys", ")", "-", "1", "]", "\n\n", "return", "wUDKIM", ".", "WKeys", ".", "ToPublicKeys", "(", ")", ",", "rUDKIM", ".", "RKeys", ".", "ToPublicKeys", "(", ")", ",", "nil", "\n", "}" ]

[ "GetUserDevicePublicKeys", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "GetTLFCryptKeyParams", "(", "keyGen", "KeyGen", ",", "user", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ",", "_", "ExtraMetadata", ")", "(", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", ",", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ",", "bool", ",", "error", ")", "{", "wkb", ",", "rkb", ",", "err", ":=", "md", ".", "getTLFKeyBundles", "(", "keyGen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFEphemeralPublicKey", "{", "}", ",", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", "{", "}", ",", "false", ",", "err", "\n", "}", "\n\n", "dkim", ":=", "wkb", ".", "WKeys", "[", "user", "]", "\n", "if", "dkim", "==", "nil", "{", "dkim", "=", "rkb", ".", "RKeys", "[", "user", "]", "\n", "if", "dkim", "==", "nil", "{", "return", "kbfscrypto", ".", "TLFEphemeralPublicKey", "{", "}", ",", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", "{", "}", ",", "false", ",", "nil", "\n", "}", "\n", "}", "\n", "info", ",", "ok", ":=", "dkim", "[", "key", ".", "KID", "(", ")", "]", "\n", "if", "!", "ok", "{", "return", "kbfscrypto", ".", "TLFEphemeralPublicKey", "{", "}", ",", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", "{", "}", ",", "false", ",", "nil", "\n", "}", "\n\n", "_", ",", "_", ",", "ePubKey", ",", "err", ":=", "GetEphemeralPublicKeyInfoV2", "(", "info", ",", "*", "wkb", ",", "*", "rkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFEphemeralPublicKey", "{", "}", ",", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", "{", "}", ",", "false", ",", "err", "\n", "}", "\n\n", "return", "ePubKey", ",", "info", ".", "ClientHalf", ",", "info", ".", "ServerHalfID", ",", "true", ",", "nil", "\n", "}" ]

[ "GetTLFCryptKeyParams", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "IsValidAndSigned", "(", "_", "context", ".", "Context", ",", "codec", "kbfscodec", ".", "Codec", ",", "_", "TeamMembershipChecker", ",", "extra", "ExtraMetadata", ",", "_", "kbfscrypto", ".", "VerifyingKey", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "error", "{", "// Optimization -- if the WriterMetadata signature is nil, it", "// will fail verification.", "if", "md", ".", "WriterMetadataSigInfo", ".", "IsNil", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "md", ".", "IsFinal", "(", ")", "{", "if", "md", ".", "Revision", "<", "RevisionInitial", "+", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "Revision", ")", "\n", "}", "\n\n", "if", "md", ".", "Revision", "==", "(", "RevisionInitial", "+", "1", ")", "{", "if", "md", ".", "PrevRoot", "!=", "(", "ID", "{", "}", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "PrevRoot", ")", "\n", "}", "\n", "}", "else", "{", "if", "md", ".", "PrevRoot", "==", "(", "ID", "{", "}", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "if", "md", ".", "Revision", "<", "RevisionInitial", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "Revision", ")", "\n", "}", "\n\n", "if", "md", ".", "Revision", "==", "RevisionInitial", "{", "if", "md", ".", "PrevRoot", "!=", "(", "ID", "{", "}", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "PrevRoot", ")", "\n", "}", "\n", "}", "else", "{", "if", "md", ".", "PrevRoot", "==", "(", "ID", "{", "}", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "md", ".", "SerializedPrivateMetadata", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "(", "md", ".", "MergedStatus", "(", ")", "==", "Merged", ")", "!=", "(", "md", ".", "BID", "(", ")", "==", "NullBranchID", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "BID", "(", ")", ",", "md", ".", "MergedStatus", "(", ")", ")", "\n", "}", "\n\n", "handle", ",", "err", ":=", "md", ".", "MakeBareTlfHandle", "(", "extra", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Make sure the last writer is valid. TODO(KBFS-2185): for a", "// team TLF, check that the writer is part of the team.", "writer", ":=", "md", ".", "LastModifyingWriter", "(", ")", "\n", "if", "!", "handle", ".", "IsWriter", "(", "writer", ".", "AsUserOrTeam", "(", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "writer", ")", "\n", "}", "\n\n", "// Make sure the last modifier is valid.", "user", ":=", "md", ".", "LastModifyingUser", "\n", "if", "!", "handle", ".", "IsReader", "(", "user", ".", "AsUserOrTeam", "(", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "user", ")", "\n", "}", "\n\n", "// Verify signature. We have to re-marshal the WriterMetadata,", "// since it's embedded.", "buf", ",", "err", ":=", "codec", ".", "Encode", "(", "md", ".", "WriterMetadataV2", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "kbfscrypto", ".", "Verify", "(", "buf", ",", "md", ".", "WriterMetadataSigInfo", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "IsValidAndSigned", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "IsLastModifiedBy", "(", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "VerifyingKey", ")", "error", "{", "// Verify the user and device are the writer.", "writer", ":=", "md", ".", "LastModifyingWriter", "(", ")", "\n", "if", "!", "md", ".", "IsWriterMetadataCopiedSet", "(", ")", "{", "if", "writer", "!=", "uid", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "writer", ",", "uid", ")", "\n", "}", "\n", "if", "md", ".", "WriterMetadataSigInfo", ".", "VerifyingKey", "!=", "key", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "md", ".", "WriterMetadataSigInfo", ".", "VerifyingKey", ",", "key", ")", "\n", "}", "\n", "}", "\n\n", "// Verify the user and device are the last modifier.", "user", ":=", "md", ".", "GetLastModifyingUser", "(", ")", "\n", "if", "user", "!=", "uid", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "user", ",", "uid", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "IsLastModifiedBy", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "GetSerializedWriterMetadata", "(", "codec", "kbfscodec", ".", "Codec", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "codec", ".", "Encode", "(", "md", ".", "WriterMetadataV2", ")", "\n", "}" ]

[ "GetSerializedWriterMetadata", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "SetLastModifyingWriter", "(", "user", "keybase1", ".", "UID", ")", "{", "md", ".", "WriterMetadataV2", ".", "LastModifyingWriter", "=", "user", "\n", "}" ]

[ "SetLastModifyingWriter", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "SetUnresolvedWriters", "(", "writers", "[", "]", "keybase1", ".", "SocialAssertion", ")", "{", "md", ".", "Extra", ".", "UnresolvedWriters", "=", "writers", "\n", "}" ]

[ "SetUnresolvedWriters", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "ClearForV4Migration", "(", ")", "{", "md", ".", "WKeys", "=", "nil", "\n", "md", ".", "RKeys", "=", "nil", "\n", "md", ".", "Extra", ".", "UnresolvedWriters", "=", "nil", "\n", "md", ".", "UnresolvedReaders", "=", "nil", "\n", "}" ]

[ "ClearForV4Migration", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "Version", "(", ")", "MetadataVer", "{", "// Only folders with unresolved assertions or conflict info get the", "// new version.", "if", "len", "(", "md", ".", "Extra", ".", "UnresolvedWriters", ")", ">", "0", "||", "len", "(", "md", ".", "UnresolvedReaders", ")", ">", "0", "||", "md", ".", "ConflictInfo", "!=", "nil", "||", "md", ".", "FinalizedInfo", "!=", "nil", "{", "return", "InitialExtraMetadataVer", "\n", "}", "\n", "// Let other types of MD objects use the older version since they", "// are still compatible with older clients.", "return", "PreExtraMetadataVer", "\n", "}" ]

[ "Version", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "GetCurrentTLFPublicKey", "(", "_", "ExtraMetadata", ")", "(", "kbfscrypto", ".", "TLFPublicKey", ",", "error", ")", "{", "if", "len", "(", "md", ".", "WKeys", ")", "==", "0", "{", "return", "kbfscrypto", ".", "TLFPublicKey", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "md", ".", "WKeys", "[", "len", "(", "md", ".", "WKeys", ")", "-", "1", "]", ".", "TLFPublicKey", ",", "nil", "\n", "}" ]

[ "GetCurrentTLFPublicKey", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "GetUnresolvedParticipants", "(", ")", "[", "]", "keybase1", ".", "SocialAssertion", "{", "writers", ":=", "md", ".", "WriterMetadataV2", ".", "Extra", ".", "UnresolvedWriters", "\n", "readers", ":=", "md", ".", "UnresolvedReaders", "\n", "users", ":=", "make", "(", "[", "]", "keybase1", ".", "SocialAssertion", ",", "0", ",", "len", "(", "writers", ")", "+", "len", "(", "readers", ")", ")", "\n", "users", "=", "append", "(", "users", ",", "writers", "...", ")", "\n", "users", "=", "append", "(", "users", ",", "readers", "...", ")", "\n", "return", "users", "\n", "}" ]

[ "GetUnresolvedParticipants", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "AddKeyGeneration", "(", "codec", "kbfscodec", ".", "Codec", ",", "extra", "ExtraMetadata", ",", "updatedWriterKeys", ",", "updatedReaderKeys", "UserDevicePublicKeys", ",", "ePubKey", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "ePrivKey", "kbfscrypto", ".", "TLFEphemeralPrivateKey", ",", "pubKey", "kbfscrypto", ".", "TLFPublicKey", ",", "currCryptKey", ",", "nextCryptKey", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "nextExtra", "ExtraMetadata", ",", "serverHalves", "UserDeviceKeyServerHalves", ",", "err", "error", ")", "{", "if", "md", ".", "TlfID", "(", ")", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "return", "nil", ",", "nil", ",", "InvalidNonPrivateTLFOperation", "{", "md", ".", "TlfID", "(", ")", ",", "\"", "\"", ",", "md", ".", "Version", "(", ")", "}", "\n", "}", "\n\n", "if", "len", "(", "updatedWriterKeys", ")", "==", "0", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "currCryptKey", "!=", "(", "kbfscrypto", ".", "TLFCryptKey", "{", "}", ")", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "md", ".", "WKeys", ")", "!=", "len", "(", "md", ".", "RKeys", ")", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "md", ".", "WKeys", ")", ",", "len", "(", "md", ".", "RKeys", ")", ")", "\n", "}", "\n\n", "if", "len", "(", "md", ".", "WKeys", ")", ">", "0", "{", "existingWriterKeys", ":=", "md", ".", "WKeys", "[", "len", "(", "md", ".", "WKeys", ")", "-", "1", "]", ".", "WKeys", ".", "ToPublicKeys", "(", ")", "\n", "if", "!", "existingWriterKeys", ".", "Equals", "(", "updatedWriterKeys", ")", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "existingWriterKeys", ",", "updatedWriterKeys", ")", "\n", "}", "\n\n", "existingReaderKeys", ":=", "md", ".", "RKeys", "[", "len", "(", "md", ".", "RKeys", ")", "-", "1", "]", ".", "RKeys", ".", "ToPublicKeys", "(", ")", "\n", "if", "!", "existingReaderKeys", ".", "Equals", "(", "updatedReaderKeys", ")", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "existingReaderKeys", ",", "updatedReaderKeys", ")", "\n", "}", "\n", "}", "\n\n", "newWriterKeys", ":=", "TLFWriterKeyBundleV2", "{", "WKeys", ":", "make", "(", "UserDeviceKeyInfoMapV2", ")", ",", "TLFPublicKey", ":", "pubKey", ",", "}", "\n", "md", ".", "WKeys", "=", "append", "(", "md", ".", "WKeys", ",", "newWriterKeys", ")", "\n\n", "newReaderKeys", ":=", "TLFReaderKeyBundleV2", "{", "RKeys", ":", "make", "(", "UserDeviceKeyInfoMapV2", ")", ",", "}", "\n", "md", ".", "RKeys", "=", "append", "(", "md", ".", "RKeys", ",", "newReaderKeys", ")", "\n\n", "serverHalves", ",", "err", "=", "md", ".", "updateKeyGeneration", "(", "md", ".", "LatestKeyGeneration", "(", ")", ",", "updatedWriterKeys", ",", "updatedReaderKeys", ",", "ePubKey", ",", "ePrivKey", ",", "nextCryptKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "nil", ",", "serverHalves", ",", "nil", "\n", "}" ]

[ "AddKeyGeneration", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "UpdateKeyBundles", "(", "codec", "kbfscodec", ".", "Codec", ",", "_", "ExtraMetadata", ",", "updatedWriterKeys", ",", "updatedReaderKeys", "UserDevicePublicKeys", ",", "ePubKey", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "ePrivKey", "kbfscrypto", ".", "TLFEphemeralPrivateKey", ",", "tlfCryptKeys", "[", "]", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "[", "]", "UserDeviceKeyServerHalves", ",", "error", ")", "{", "if", "md", ".", "TlfID", "(", ")", ".", "Type", "(", ")", "!=", "tlf", ".", "Private", "{", "return", "nil", ",", "InvalidNonPrivateTLFOperation", "{", "md", ".", "TlfID", "(", ")", ",", "\"", "\"", ",", "md", ".", "Version", "(", ")", "}", "\n", "}", "\n\n", "expectedTLFCryptKeyCount", ":=", "int", "(", "md", ".", "LatestKeyGeneration", "(", ")", "-", "FirstValidKeyGen", "+", "1", ")", "\n", "if", "len", "(", "tlfCryptKeys", ")", "!=", "expectedTLFCryptKeyCount", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "expectedTLFCryptKeyCount", ",", "len", "(", "tlfCryptKeys", ")", ")", "\n", "}", "\n\n", "serverHalves", ":=", "make", "(", "[", "]", "UserDeviceKeyServerHalves", ",", "len", "(", "tlfCryptKeys", ")", ")", "\n", "if", "len", "(", "updatedWriterKeys", ")", "==", "0", "{", "// Reader rekey case.", "for", "keyGen", ":=", "FirstValidKeyGen", ";", "keyGen", "<=", "md", ".", "LatestKeyGeneration", "(", ")", ";", "keyGen", "++", "{", "serverHalvesGen", ",", "err", ":=", "md", ".", "updateKeyGenerationForReaderRekey", "(", "codec", ",", "keyGen", ",", "updatedReaderKeys", ",", "ePubKey", ",", "ePrivKey", ",", "tlfCryptKeys", "[", "keyGen", "-", "FirstValidKeyGen", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "serverHalves", "[", "keyGen", "-", "FirstValidKeyGen", "]", "=", "serverHalvesGen", "\n", "}", "\n\n", "return", "serverHalves", ",", "nil", "\n", "}", "\n\n", "// Usual rekey case.", "for", "keyGen", ":=", "FirstValidKeyGen", ";", "keyGen", "<=", "md", ".", "LatestKeyGeneration", "(", ")", ";", "keyGen", "++", "{", "serverHalvesGen", ",", "err", ":=", "md", ".", "updateKeyGeneration", "(", "keyGen", ",", "updatedWriterKeys", ",", "updatedReaderKeys", ",", "ePubKey", ",", "ePrivKey", ",", "tlfCryptKeys", "[", "keyGen", "-", "FirstValidKeyGen", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "serverHalves", "[", "keyGen", "-", "FirstValidKeyGen", "]", "=", "serverHalvesGen", "\n", "}", "\n", "return", "serverHalves", ",", "nil", "\n\n", "}" ]

[ "UpdateKeyBundles", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "FinalizeRekey", "(", "_", "kbfscodec", ".", "Codec", ",", "_", "ExtraMetadata", ")", "error", "{", "// Nothing to do.", "return", "nil", "\n", "}" ]

[ "FinalizeRekey", "implements", "the", "MutableRootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "md", "*", "RootMetadataV2", ")", "GetHistoricTLFCryptKey", "(", "_", "kbfscodec", ".", "Codec", ",", "_", "KeyGen", ",", "_", "kbfscrypto", ".", "TLFCryptKey", ",", "_", "ExtraMetadata", ")", "(", "kbfscrypto", ".", "TLFCryptKey", ",", "error", ")", "{", "return", "kbfscrypto", ".", "TLFCryptKey", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetHistoricTLFCryptKey", "implements", "the", "RootMetadata", "interface", "for", "RootMetadataV2", "." ]

[ "func", "(", "sc", "SigChain", ")", "GetExpectedNextHighSkip", "(", "mctx", "MetaContext", ",", "uid", "keybase1", ".", "UID", ")", "(", "HighSkip", ",", "error", ")", "{", "if", "sc", ".", "localChainNextHighSkipOverride", "!=", "nil", "{", "return", "*", "sc", ".", "localChainNextHighSkipOverride", ",", "nil", "\n", "}", "\n", "if", "len", "(", "sc", ".", "chainLinks", ")", "==", "0", "{", "return", "NewInitialHighSkip", "(", ")", ",", "nil", "\n", "}", "\n", "return", "sc", ".", "GetLastLink", "(", ")", ".", "ExpectedNextHighSkip", "(", "mctx", ",", "uid", ")", "\n", "}" ]

[ "GetExpectedNextHighSkip", "returns", "the", "HighSkip", "expected", "for", "a", "new", "link", "to", "be", "added", "to", "the", "chain", ".", "It", "can", "only", "be", "called", "after", "VerifyChain", "is", "completed", "." ]

[ "func", "(", "sc", "*", "SigChain", ")", "GetCurrentSubchain", "(", "m", "MetaContext", ",", "eldest", "keybase1", ".", "KID", ")", "(", "ChainLinks", ",", "error", ")", "{", "return", "cropToRightmostSubchain", "(", "m", ",", "sc", ".", "chainLinks", ",", "eldest", ",", "sc", ".", "uid", ")", "\n", "}" ]

[ "GetCurrentSubchain", "takes", "the", "given", "sigchain", "and", "walks", "backward", "until", "it", "finds", "the", "start", "of", "the", "current", "subchain", "returning", "all", "the", "links", "in", "the", "subchain", ".", "See", "isSubchainStart", "for", "the", "details", "of", "the", "logic", "here", "." ]

[ "func", "cropToRightmostSubchain", "(", "m", "MetaContext", ",", "links", "[", "]", "*", "ChainLink", ",", "eldest", "keybase1", ".", "KID", ",", "uid", "keybase1", ".", "UID", ")", "(", "ChainLinks", ",", "error", ")", "{", "// Check for a totally empty chain (that is, a totally new account).", "if", "len", "(", "links", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "// Confirm that the last link is not stubbed. This would prevent us from", "// reading the eldest_kid, so the server should never do it.", "lastLink", ":=", "links", "[", "len", "(", "links", ")", "-", "1", "]", "\n", "if", "lastLink", ".", "IsStubbed", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// Check whether the eldest KID doesn't match the latest link. That means", "// the account has just been reset, and so as with a new account, there is", "// no current subchain.", "if", "!", "lastLink", ".", "ToEldestKID", "(", ")", ".", "Equal", "(", "eldest", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "// The usual case: The eldest kid we're looking for matches the latest", "// link, and we need to loop backwards through every pair of links we have.", "// If we find a subchain start, return that subslice of links.", "for", "i", ":=", "len", "(", "links", ")", "-", "1", ";", "i", ">", "0", ";", "i", "--", "{", "curr", ":=", "links", "[", "i", "]", "\n", "prev", ":=", "links", "[", "i", "-", "1", "]", "\n", "isStart", ",", "err", ":=", "isSubchainStart", "(", "m", ",", "curr", ",", "prev", ",", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "isStart", "{", "return", "links", "[", "i", ":", "]", ",", "nil", "\n", "}", "\n", "}", "\n", "// If we didn't find a start anywhere in the middle of the chain, then this", "// user has no resets, and we'll return the whole chain. Sanity check that", "// we actually loaded everything back to seqno 1. (Anything else would be", "// some kind of bug in chain loading.)", "if", "links", "[", "0", "]", ".", "GetSeqno", "(", ")", "!=", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// In this last case, we're returning the whole chain.", "return", "links", ",", "nil", "\n", "}" ]

[ "cropToRightmostSubchain", "takes", "the", "given", "set", "of", "chain", "links", "and", "then", "limits", "the", "tail", "of", "the", "chain", "to", "just", "those", "that", "correspond", "to", "the", "eldest", "key", "given", "by", "eldest", "." ]

[ "func", "(", "sc", "*", "SigChain", ")", "Dump", "(", "w", "io", ".", "Writer", ")", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n", "for", "i", ",", "l", ":=", "range", "sc", ".", "chainLinks", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "i", ",", "l", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "sc", ".", "GetLastKnownSeqno", "(", ")", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ",", "sc", ".", "GetLastKnownID", "(", ")", ")", "\n", "}" ]

[ "Dump", "prints", "the", "sigchain", "to", "the", "writer", "arg", "." ]

[ "func", "(", "sc", "*", "SigChain", ")", "GetLinkFromSigIDQuery", "(", "query", "string", ")", "*", "ChainLink", "{", "for", "_", ",", "link", ":=", "range", "sc", ".", "chainLinks", "{", "if", "link", ".", "GetSigID", "(", ")", ".", "Match", "(", "query", ",", "false", ")", "{", "return", "link", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetLinkFromSigIDQuery", "will", "return", "true", "if", "it", "finds", "a", "ChainLink", "with", "a", "SigID", "that", "starts", "with", "query", "." ]

[ "func", "(", "l", "*", "SigChainLoader", ")", "Store", "(", ")", "(", "err", "error", ")", "{", "err", "=", "l", ".", "StoreTail", "(", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "l", ".", "chain", ".", "Store", "(", "l", ".", "M", "(", ")", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Store", "a", "SigChain", "to", "local", "storage", "as", "a", "result", "of", "having", "loaded", "it", ".", "We", "eagerly", "write", "loaded", "chain", "links", "to", "storage", "if", "they", "verify", "properly", "." ]

[ "func", "MakeHandle", "(", "writers", ",", "readers", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "unresolvedWriters", ",", "unresolvedReaders", "[", "]", "keybase1", ".", "SocialAssertion", ",", "extensions", "[", "]", "HandleExtension", ")", "(", "Handle", ",", "error", ")", "{", "if", "len", "(", "writers", ")", "==", "0", "{", "return", "Handle", "{", "}", ",", "errNoWriters", "\n", "}", "\n\n", "if", "writers", "[", "0", "]", ".", "IsTeamOrSubteam", "(", ")", "{", "// Right now we only support single-team private TLFs.", "if", "len", "(", "writers", ")", ">", "1", "||", "len", "(", "unresolvedWriters", ")", "!=", "0", "{", "return", "Handle", "{", "}", ",", "errInvalidWriter", "\n", "}", "else", "if", "len", "(", "readers", ")", "!=", "0", "||", "len", "(", "unresolvedReaders", ")", "!=", "0", "{", "return", "Handle", "{", "}", ",", "errInvalidReader", "\n", "}", "\n", "}", "\n\n", "for", "i", ",", "w", ":=", "range", "writers", "{", "if", "w", "==", "keybase1", ".", "PUBLIC_UID", "{", "return", "Handle", "{", "}", ",", "errInvalidWriter", "\n", "}", "else", "if", "i", ">", "0", "&&", "w", ".", "IsTeamOrSubteam", "(", ")", "{", "return", "Handle", "{", "}", ",", "errInvalidWriter", "\n", "}", "\n", "}", "\n\n", "// If we have more than one reader, none of them should be the", "// public UID. And no readers should be a team.", "checkPublic", ":=", "(", "len", "(", "readers", ")", "+", "len", "(", "unresolvedReaders", ")", ")", ">", "1", "\n", "for", "_", ",", "r", ":=", "range", "readers", "{", "if", "checkPublic", "&&", "r", "==", "keybase1", ".", "PUBLIC_UID", "{", "return", "Handle", "{", "}", ",", "errInvalidReader", "\n", "}", "else", "if", "r", ".", "IsTeamOrSubteam", "(", ")", "{", "return", "Handle", "{", "}", ",", "errInvalidReader", "\n", "}", "\n", "}", "\n\n", "// TODO: Check for overlap between readers and writers, and", "// for duplicates.", "writersCopy", ":=", "make", "(", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "len", "(", "writers", ")", ")", "\n", "copy", "(", "writersCopy", ",", "writers", ")", "\n", "sort", ".", "Sort", "(", "UIDList", "(", "writersCopy", ")", ")", "\n\n", "var", "readersCopy", "[", "]", "keybase1", ".", "UserOrTeamID", "\n", "if", "len", "(", "readers", ")", ">", "0", "{", "readersCopy", "=", "make", "(", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "len", "(", "readers", ")", ")", "\n", "copy", "(", "readersCopy", ",", "readers", ")", "\n", "sort", ".", "Sort", "(", "UIDList", "(", "readersCopy", ")", ")", "\n", "}", "\n\n", "var", "unresolvedWritersCopy", "[", "]", "keybase1", ".", "SocialAssertion", "\n", "if", "len", "(", "unresolvedWriters", ")", ">", "0", "{", "unresolvedWritersCopy", "=", "make", "(", "[", "]", "keybase1", ".", "SocialAssertion", ",", "len", "(", "unresolvedWriters", ")", ")", "\n", "copy", "(", "unresolvedWritersCopy", ",", "unresolvedWriters", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "unresolvedWritersCopy", ")", ")", "\n", "}", "\n\n", "var", "unresolvedReadersCopy", "[", "]", "keybase1", ".", "SocialAssertion", "\n", "if", "len", "(", "unresolvedReaders", ")", ">", "0", "{", "unresolvedReadersCopy", "=", "make", "(", "[", "]", "keybase1", ".", "SocialAssertion", ",", "len", "(", "unresolvedReaders", ")", ")", "\n", "copy", "(", "unresolvedReadersCopy", ",", "unresolvedReaders", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "unresolvedReadersCopy", ")", ")", "\n", "}", "\n\n", "conflictInfo", ",", "finalizedInfo", ":=", "HandleExtensionList", "(", "extensions", ")", ".", "Splat", "(", ")", "\n\n", "return", "Handle", "{", "Writers", ":", "writersCopy", ",", "Readers", ":", "readersCopy", ",", "UnresolvedWriters", ":", "unresolvedWritersCopy", ",", "UnresolvedReaders", ":", "unresolvedReadersCopy", ",", "ConflictInfo", ":", "conflictInfo", ",", "FinalizedInfo", ":", "finalizedInfo", ",", "sorted", ":", "true", ",", "}", ",", "nil", "\n", "}" ]

[ "MakeHandle", "creates", "a", "Handle", "from", "the", "given", "list", "of", "readers", "and", "writers", ".", "If", "the", "given", "reader", "list", "contains", "just", "keybase1", ".", "PUBLIC_UID", "then", "the", "returned", "handle", "will", "be", "for", "a", "public", "folder", ".", "Otherwise", "it", "will", "be", "private", ".", "PUBLIC_UID", "shouldn", "t", "be", "in", "any", "list", "in", "any", "other", "case", "." ]

[ "func", "(", "h", "Handle", ")", "Type", "(", ")", "Type", "{", "if", "len", "(", "h", ".", "Readers", ")", "==", "1", "&&", "h", ".", "Readers", "[", "0", "]", ".", "Equal", "(", "keybase1", ".", "PublicUID", ".", "AsUserOrTeam", "(", ")", ")", "{", "return", "Public", "\n", "}", "else", "if", "len", "(", "h", ".", "Writers", ")", "==", "1", "&&", "h", ".", "Writers", "[", "0", "]", ".", "IsTeamOrSubteam", "(", ")", "{", "return", "SingleTeam", "\n", "}", "\n", "return", "Private", "\n", "}" ]

[ "Type", "returns", "the", "type", "of", "TLF", "this", "Handle", "represents", "." ]

[ "func", "(", "h", "Handle", ")", "TypeForKeying", "(", ")", "KeyingType", "{", "if", "h", ".", "IsBackedByTeam", "(", ")", "{", "return", "TeamKeying", "\n", "}", "\n", "return", "h", ".", "Type", "(", ")", ".", "ToKeyingType", "(", ")", "\n", "}" ]

[ "TypeForKeying", "returns", "the", "keying", "type", "for", "the", "handle", "h", "." ]

[ "func", "(", "h", "Handle", ")", "IsWriter", "(", "user", "keybase1", ".", "UserOrTeamID", ")", "bool", "{", "if", "h", ".", "TypeForKeying", "(", ")", "==", "TeamKeying", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "h", ".", "findUserInList", "(", "user", ",", "h", ".", "Writers", ")", "\n", "}" ]

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

[ "func", "(", "h", "Handle", ")", "IsReader", "(", "user", "keybase1", ".", "UserOrTeamID", ")", "bool", "{", "if", "h", ".", "TypeForKeying", "(", ")", "==", "TeamKeying", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "h", ".", "TypeForKeying", "(", ")", "==", "PublicKeying", "||", "h", ".", "findUserInList", "(", "user", ",", "h", ".", "Readers", ")", "||", "h", ".", "IsWriter", "(", "user", ")", "\n", "}" ]

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

[ "func", "(", "h", "Handle", ")", "ResolvedUsers", "(", ")", "[", "]", "keybase1", ".", "UserOrTeamID", "{", "var", "resolvedUsers", "[", "]", "keybase1", ".", "UserOrTeamID", "\n", "resolvedUsers", "=", "append", "(", "resolvedUsers", ",", "h", ".", "Writers", "...", ")", "\n", "if", "h", ".", "TypeForKeying", "(", ")", "==", "PrivateKeying", "{", "resolvedUsers", "=", "append", "(", "resolvedUsers", ",", "h", ".", "Readers", "...", ")", "\n", "}", "\n", "return", "resolvedUsers", "\n", "}" ]

[ "ResolvedUsers", "returns", "the", "concatenation", "of", "h", ".", "Writers", "and", "h", ".", "Readers", "except", "if", "the", "handle", "is", "public", "the", "returned", "list", "won", "t", "contain", "PUBLIC_UID", "." ]

[ "func", "(", "h", "Handle", ")", "HasUnresolvedUsers", "(", ")", "bool", "{", "return", "len", "(", "h", ".", "UnresolvedWriters", ")", ">", "0", "||", "len", "(", "h", ".", "UnresolvedReaders", ")", ">", "0", "\n", "}" ]

[ "HasUnresolvedUsers", "returns", "true", "if", "this", "handle", "has", "any", "unresolved", "writers", "or", "readers", "." ]

[ "func", "(", "h", "Handle", ")", "UnresolvedUsers", "(", ")", "[", "]", "keybase1", ".", "SocialAssertion", "{", "var", "unresolvedUsers", "[", "]", "keybase1", ".", "SocialAssertion", "\n", "unresolvedUsers", "=", "append", "(", "unresolvedUsers", ",", "h", ".", "UnresolvedWriters", "...", ")", "\n", "unresolvedUsers", "=", "append", "(", "unresolvedUsers", ",", "h", ".", "UnresolvedReaders", "...", ")", "\n", "return", "unresolvedUsers", "\n", "}" ]

[ "UnresolvedUsers", "returns", "the", "concatenation", "of", "h", ".", "UnresolvedWriters", "and", "h", ".", "UnresolvedReaders", "." ]

[ "func", "(", "h", "Handle", ")", "ResolveAssertions", "(", "assertions", "map", "[", "keybase1", ".", "SocialAssertion", "]", "keybase1", ".", "UID", ")", "Handle", "{", "if", "len", "(", "assertions", ")", "==", "0", "||", "(", "len", "(", "h", ".", "UnresolvedWriters", ")", "==", "0", "&&", "len", "(", "h", ".", "UnresolvedReaders", ")", "==", "0", ")", "||", "h", ".", "IsFinal", "(", ")", "{", "return", "h", "\n", "}", "\n", "var", "resolvedWriters", ",", "resolvedReaders", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "bool", "\n", "resolvedWriters", ",", "h", ".", "UnresolvedWriters", "=", "resolveAssertions", "(", "assertions", ",", "h", ".", "UnresolvedWriters", ",", "h", ".", "Writers", ")", "\n", "resolvedReaders", ",", "h", ".", "UnresolvedReaders", "=", "resolveAssertions", "(", "assertions", ",", "h", ".", "UnresolvedReaders", ",", "h", ".", "Readers", ")", "\n", "h", ".", "Writers", "=", "uidSetToSlice", "(", "resolvedWriters", ")", "\n", "for", "_", ",", "u", ":=", "range", "h", ".", "Writers", "{", "delete", "(", "resolvedReaders", ",", "u", ")", "\n", "}", "\n", "h", ".", "Readers", "=", "uidSetToSlice", "(", "resolvedReaders", ")", "\n", "sort", ".", "Sort", "(", "UIDList", "(", "h", ".", "Writers", ")", ")", "\n", "sort", ".", "Sort", "(", "UIDList", "(", "h", ".", "Readers", ")", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "h", ".", "UnresolvedWriters", ")", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "h", ".", "UnresolvedReaders", ")", ")", "\n", "h", ".", "sorted", "=", "true", "\n", "return", "h", "\n", "}" ]

[ "ResolveAssertions", "creates", "a", "new", "Handle", "given", "an", "existing", "one", "with", "while", "resolving", "the", "passed", "assertions", "." ]

[ "func", "(", "h", "Handle", ")", "Extensions", "(", ")", "(", "extensions", "[", "]", "HandleExtension", ")", "{", "if", "h", ".", "ConflictInfo", "!=", "nil", "{", "extensions", "=", "append", "(", "extensions", ",", "*", "h", ".", "ConflictInfo", ")", "\n", "}", "\n", "if", "h", ".", "FinalizedInfo", "!=", "nil", "{", "extensions", "=", "append", "(", "extensions", ",", "*", "h", ".", "FinalizedInfo", ")", "\n", "}", "\n", "return", "extensions", "\n", "}" ]

[ "Extensions", "returns", "a", "list", "of", "extensions", "for", "the", "given", "handle", "." ]

[ "func", "(", "h", "*", "Handle", ")", "DeepEqual", "(", "other", "Handle", ")", "bool", "{", "if", "len", "(", "h", ".", "Writers", ")", "!=", "len", "(", "other", ".", "Writers", ")", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "h", ".", "UnresolvedWriters", ")", "!=", "len", "(", "other", ".", "UnresolvedWriters", ")", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "h", ".", "Readers", ")", "!=", "len", "(", "other", ".", "Readers", ")", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "h", ".", "UnresolvedReaders", ")", "!=", "len", "(", "other", ".", "UnresolvedReaders", ")", "{", "return", "false", "\n", "}", "\n\n", "if", "!", "h", ".", "sorted", "{", "sort", ".", "Sort", "(", "UIDList", "(", "h", ".", "Writers", ")", ")", "\n", "sort", ".", "Sort", "(", "UIDList", "(", "h", ".", "Readers", ")", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "h", ".", "UnresolvedWriters", ")", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "h", ".", "UnresolvedReaders", ")", ")", "\n", "h", ".", "sorted", "=", "true", "\n", "}", "\n", "if", "!", "other", ".", "sorted", "{", "sort", ".", "Sort", "(", "UIDList", "(", "other", ".", "Writers", ")", ")", "\n", "sort", ".", "Sort", "(", "UIDList", "(", "other", ".", "Readers", ")", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "other", ".", "UnresolvedWriters", ")", ")", "\n", "sort", ".", "Sort", "(", "SocialAssertionList", "(", "other", ".", "UnresolvedReaders", ")", ")", "\n", "}", "\n\n", "for", "i", ",", "v", ":=", "range", "h", ".", "Writers", "{", "if", "other", ".", "Writers", "[", "i", "]", "!=", "v", "{", "return", "false", "\n", "}", "\n", "}", "\n", "for", "i", ",", "v", ":=", "range", "h", ".", "UnresolvedWriters", "{", "if", "other", ".", "UnresolvedWriters", "[", "i", "]", "!=", "v", "{", "return", "false", "\n", "}", "\n", "}", "\n", "for", "i", ",", "v", ":=", "range", "h", ".", "Readers", "{", "if", "other", ".", "Readers", "[", "i", "]", "!=", "v", "{", "return", "false", "\n", "}", "\n", "}", "\n", "for", "i", ",", "v", ":=", "range", "h", ".", "UnresolvedReaders", "{", "if", "other", ".", "UnresolvedReaders", "[", "i", "]", "!=", "v", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "h", ".", "IsConflict", "(", ")", "!=", "other", ".", "IsConflict", "(", ")", "{", "return", "false", "\n", "}", "\n", "if", "h", ".", "IsFinal", "(", ")", "!=", "other", ".", "IsFinal", "(", ")", "{", "return", "false", "\n", "}", "\n", "if", "h", ".", "ConflictInfo", "!=", "nil", "&&", "h", ".", "ConflictInfo", ".", "String", "(", ")", "!=", "other", ".", "ConflictInfo", ".", "String", "(", ")", "{", "return", "false", "\n", "}", "\n", "if", "h", ".", "FinalizedInfo", "!=", "nil", "&&", "h", ".", "FinalizedInfo", ".", "String", "(", ")", "!=", "other", ".", "FinalizedInfo", ".", "String", "(", ")", "{", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "DeepEqual", "returns", "true", "if", "the", "handle", "is", "equal", "to", "another", "handle", ".", "This", "can", "mutate", "the", "Handle", "in", "that", "it", "might", "sort", "its", "Writers", "Readers", "UnresolvedWriters", "and", "UnresolvedReaders", "." ]

[ "func", "checkUIDEquality", "(", "a", ",", "b", "[", "]", "keybase1", ".", "UserOrTeamID", ")", "bool", "{", "aMap", ":=", "make", "(", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "bool", ")", "\n", "for", "_", ",", "u", ":=", "range", "a", "{", "aMap", "[", "u", "]", "=", "true", "\n", "}", "\n", "for", "_", ",", "u", ":=", "range", "b", "{", "if", "!", "aMap", "[", "u", "]", "{", "return", "false", "\n", "}", "\n", "delete", "(", "aMap", ",", "u", ")", "\n", "}", "\n", "return", "len", "(", "aMap", ")", "==", "0", "\n", "}" ]

[ "checkUIDEquality", "returns", "true", "if", "a", "and", "b", "contain", "the", "same", "IDs", "regardless", "of", "order", ".", "However", "if", "a", "contains", "duplicates", "this", "function", "may", "return", "an", "incorrect", "value", "." ]

[ "func", "(", "h", "*", "Handle", ")", "ResolvedUsersEqual", "(", "writers", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "readers", "[", "]", "keybase1", ".", "UserOrTeamID", ")", "bool", "{", "return", "checkUIDEquality", "(", "h", ".", "Writers", ",", "writers", ")", "&&", "checkUIDEquality", "(", "h", ".", "Readers", ",", "readers", ")", "\n", "}" ]

[ "ResolvedUsersEqual", "checks", "whether", "the", "resolved", "users", "of", "this", "TLF", "matches", "the", "provided", "lists", "of", "writers", "and", "readers", "." ]

[ "func", "commonTime", "(", "ctx", "context", ".", "Context", ",", "mdserver", "libkbfs", ".", "MDServer", ",", "clock", "libkbfs", ".", "Clock", ",", "log", "logger", ".", "Logger", ")", "time", ".", "Time", "{", "offset", ",", "haveOffset", ":=", "mdserver", ".", "OffsetFromServerTime", "(", ")", "\n", "if", "!", "haveOffset", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ")", "\n", "return", "clock", ".", "Now", "(", ")", "\n", "}", "\n", "return", "clock", ".", "Now", "(", ")", ".", "Add", "(", "-", "offset", ")", "\n", "}" ]

[ "commonTime", "computes", "the", "current", "time", "according", "to", "our", "estimate", "of", "the", "mdserver", "s", "time", ".", "It", "s", "a", "very", "crude", "way", "of", "normalizing", "the", "local", "clock", "." ]

[ "func", "canDoWork", "(", "ctx", "context", ".", "Context", ",", "mdserver", "libkbfs", ".", "MDServer", ",", "clock", "libkbfs", ".", "Clock", ",", "fs", "*", "libfs", ".", "FS", ",", "workingFileName", "string", ",", "workLimit", "time", ".", "Duration", ",", "log", "logger", ".", "Logger", ")", "(", "bool", ",", "error", ")", "{", "fi", ",", "err", ":=", "fs", ".", "Stat", "(", "workingFileName", ")", "\n", "currCommonTime", ":=", "commonTime", "(", "ctx", ",", "mdserver", ",", "clock", ",", "log", ")", "\n", "switch", "{", "case", "os", ".", "IsNotExist", "(", "err", ")", ":", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "workingFileName", ")", "\n", "f", ",", "err", ":=", "fs", ".", "Create", "(", "workingFileName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "err", "=", "f", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "case", "err", "!=", "nil", ":", "return", "false", ",", "err", "\n", "default", ":", "// err == nil", "modCommonTime", ":=", "fi", ".", "ModTime", "(", ")", "\n", "if", "modCommonTime", ".", "Add", "(", "workTimeLimit", ")", ".", "After", "(", "currCommonTime", ")", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "modCommonTime", ",", "currCommonTime", ",", "workTimeLimit", ")", "\n", "// The other GC is still running within the time", "// limit.", "return", "false", ",", "nil", "\n", "}", "\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "modCommonTime", ",", "currCommonTime", ",", "workTimeLimit", ")", "\n", "}", "\n\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "currCommonTime", ")", "\n", "err", "=", "fs", ".", "Chtimes", "(", "workingFileName", ",", "time", ".", "Time", "{", "}", ",", "currCommonTime", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "canDoWork", "creates", "a", "file", "that", "marks", "the", "start", "of", "some", "long", "-", "term", "work", "by", "this", "node", ".", "It", "should", "be", "called", "while", "a", "lock", "is", "taken", "on", "the", "server", ".", "It", "returns", "true", "if", "the", "caller", "should", "start", "doing", "the", "work", "." ]

[ "func", "NewFS", "(", "config", "libkbfs", ".", "Config", ",", "log", "logger", ".", "Logger", ")", "keybase1", ".", "FsInterface", "{", "return", "&", "fs", "{", "config", ":", "config", ",", "log", ":", "log", "}", "\n", "}" ]

[ "NewFS", "returns", "a", "new", "FS", "protocol", "implementation" ]

[ "func", "(", "f", "*", "fs", ")", "List", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "ListArg", ")", "(", "keybase1", ".", "ListResult", ",", "error", ")", "{", "f", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Path", ")", "\n\n", "kbfsPath", ",", "err", ":=", "NewPath", "(", "arg", ".", "Path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "ListResult", "{", "}", ",", "err", "\n", "}", "\n\n", "var", "result", "keybase1", ".", "ListResult", "\n", "switch", "kbfsPath", ".", "PathType", "{", "case", "RootPathType", ":", "result", ",", "err", "=", "f", ".", "root", "(", "ctx", ")", "\n", "case", "KeybasePathType", ":", "result", ",", "err", "=", "f", ".", "keybase", "(", "ctx", ")", "\n", "case", "KeybaseChildPathType", ":", "result", ",", "err", "=", "f", ".", "favorites", "(", "ctx", ",", "kbfsPath", ")", "\n", "default", ":", "result", ",", "err", "=", "f", ".", "tlf", "(", "ctx", ",", "kbfsPath", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "f", ".", "log", ".", "CErrorf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Path", ",", "err", ")", "\n", "}", "\n", "return", "result", ",", "err", "\n", "}" ]

[ "List", "implements", "keybase1", ".", "FsInterface" ]

[ "func", "PrimeSecretStore", "(", "mctx", "MetaContext", ",", "ss", "SecretStoreAll", ")", "(", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// Generate test username and test secret", "testUsername", ",", "err", ":=", "RandString", "(", "\"", "\"", ",", "5", ")", "\n", "// RandString returns base32 encoded random bytes, make it look like a", "// Keybase username. This is not required, though.", "testUsername", "=", "strings", ".", "ToLower", "(", "strings", ".", "Replace", "(", "testUsername", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "randBytes", ",", "err", ":=", "RandBytes", "(", "LKSecLen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "testUsername", ",", "randBytes", ")", "\n", "testNormUsername", ":=", "NormalizedUsername", "(", "testUsername", ")", "\n", "var", "secretF", "[", "LKSecLen", "]", "byte", "\n", "copy", "(", "secretF", "[", ":", "]", ",", "randBytes", "[", ":", "]", ")", "\n", "testSecret", ":=", "LKSecFullSecret", "{", "f", ":", "&", "secretF", "}", "\n\n", "defer", "func", "(", ")", "{", "err2", ":=", "ss", ".", "ClearSecret", "(", "mctx", ",", "testNormUsername", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err2", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err2", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "err2", "\n", "}", "else", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "// Try to fetch first, we should get an error back.", "_", ",", "err", "=", "ss", ".", "RetrieveSecret", "(", "mctx", ",", "testNormUsername", ")", "\n", "if", "err", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Put secret in secret store through `SecretStore` interface.", "err", "=", "ss", ".", "StoreSecret", "(", "mctx", ",", "testNormUsername", ",", "testSecret", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Recreate test store with same username, try to retrieve secret.", "retrSecret", ",", "err", ":=", "ss", ".", "RetrieveSecret", "(", "mctx", ",", "testNormUsername", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "retrSecret", ".", "f", ")", "\n", "if", "!", "retrSecret", ".", "Equal", "(", "testSecret", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "PrimeSecretStore", "runs", "a", "test", "with", "current", "platform", "s", "secret", "store", "trying", "to", "store", "retrieve", "and", "then", "delete", "a", "secret", "with", "an", "arbitrary", "name", ".", "This", "should", "be", "done", "before", "provisioning", "or", "logging", "in" ]

[ "func", "(", "f", "*", "FS", ")", "SetFuseConn", "(", "fuse", "*", "fs", ".", "Server", ",", "conn", "*", "fuse", ".", "Conn", ")", "{", "f", ".", "fuse", "=", "fuse", "\n", "f", ".", "conn", "=", "conn", "\n", "}" ]

[ "SetFuseConn", "sets", "fuse", "connection", "for", "this", "FS", "." ]

[ "func", "(", "f", "*", "FS", ")", "LaunchNotificationProcessor", "(", "ctx", "context", ".", "Context", ")", "{", "f", ".", "notifications", ".", "LaunchProcessor", "(", "ctx", ")", "\n", "}" ]

[ "LaunchNotificationProcessor", "launches", "the", "notification", "processor", "." ]

[ "func", "(", "f", "*", "FS", ")", "WithContext", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "id", ",", "errRandomReqID", ":=", "libkbfs", ".", "MakeRandomRequestID", "(", ")", "\n", "if", "errRandomReqID", "!=", "nil", "{", "f", ".", "log", ".", "Errorf", "(", "\"", "\"", ",", "errRandomReqID", ")", "\n", "}", "\n\n", "// context.WithDeadline uses clock from `time` package, so we are not using", "// f.config.Clock() here", "start", ":=", "time", ".", "Now", "(", ")", "\n", "ctx", ",", "err", ":=", "libcontext", ".", "NewContextWithCancellationDelayer", "(", "libcontext", ".", "NewContextReplayable", "(", "ctx", ",", "func", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "libfs", ".", "CtxAppIDKey", ",", "f", ")", "\n", "logTags", ":=", "make", "(", "logger", ".", "CtxLogTags", ")", "\n", "logTags", "[", "CtxIDKey", "]", "=", "CtxOpID", "\n", "ctx", "=", "logger", ".", "NewContextWithLogTags", "(", "ctx", ",", "logTags", ")", "\n\n", "if", "errRandomReqID", "==", "nil", "{", "// Add a unique ID to this context, identifying a particular", "// request.", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "CtxIDKey", ",", "id", ")", "\n", "}", "\n\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "// Timeout operations before they hit the osxfuse time limit,", "// so we don't hose the entire mount (Fixed in OSXFUSE 3.2.0).", "// The timeout is 60 seconds, but it looks like sometimes it", "// tries multiple attempts within that 60 seconds, so let's go", "// a little under 60/3 to be safe.", "//", "// It should be safe to ignore the CancelFunc here because our", "// parent context will be canceled by the FUSE serve loop.", "ctx", ",", "_", "=", "context", ".", "WithDeadline", "(", "ctx", ",", "start", ".", "Add", "(", "19", "*", "time", ".", "Second", ")", ")", "\n", "}", "\n\n", "return", "ctx", "\n\n", "}", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// this should never happen", "\n", "}", "\n\n", "return", "ctx", "\n", "}" ]

[ "WithContext", "adds", "app", "-", "and", "request", "-", "specific", "values", "to", "the", "context", ".", "libkbfs", ".", "NewContextWithCancellationDelayer", "is", "called", "before", "returning", "the", "context", "to", "ensure", "the", "cancellation", "is", "controllable", ".", "It", "is", "called", "by", "FUSE", "for", "normal", "runs", "but", "may", "be", "called", "explicitly", "in", "other", "settings", "such", "as", "tests", "." ]

[ "func", "(", "f", "*", "FS", ")", "Serve", "(", "ctx", "context", ".", "Context", ")", "error", "{", "srv", ":=", "fs", ".", "New", "(", "f", ".", "conn", ",", "&", "fs", ".", "Config", "{", "WithContext", ":", "func", "(", "ctx", "context", ".", "Context", ",", "_", "fuse", ".", "Request", ")", "context", ".", "Context", "{", "return", "f", ".", "WithContext", "(", "ctx", ")", "\n", "}", ",", "}", ")", "\n", "f", ".", "fuse", "=", "srv", "\n\n", "f", ".", "notifications", ".", "LaunchProcessor", "(", "ctx", ")", "\n", "f", ".", "remoteStatus", ".", "Init", "(", "ctx", ",", "f", ".", "log", ",", "f", ".", "config", ",", "f", ")", "\n", "// Blocks forever, unless an interrupt signal is received", "// (handled by libkbfs.Init).", "return", "srv", ".", "Serve", "(", "f", ")", "\n", "}" ]

[ "Serve", "FS", ".", "Will", "block", "." ]

[ "func", "(", "f", "*", "FS", ")", "Statfs", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "StatfsRequest", ",", "resp", "*", "fuse", ".", "StatfsResponse", ")", "error", "{", "*", "resp", "=", "fuse", ".", "StatfsResponse", "{", "Bsize", ":", "fuseBlockSize", ",", "Namelen", ":", "^", "uint32", "(", "0", ")", ",", "Frsize", ":", "fuseBlockSize", ",", "}", "\n\n", "if", "f", ".", "remoteStatus", ".", "ExtraFileName", "(", ")", "!=", "\"", "\"", "{", "f", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "session", ",", "err", ":=", "idutil", ".", "GetCurrentSessionIfPossible", "(", "ctx", ",", "f", ".", "config", ".", "KBPKI", "(", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "session", "==", "(", "idutil", ".", "SessionInfo", "{", "}", ")", "{", "// If user is not logged in, don't bother getting quota info. Otherwise", "// reading a public TLF while logged out can fail on macOS.", "return", "nil", "\n", "}", "\n", "_", ",", "usageBytes", ",", "_", ",", "limitBytes", ",", "err", ":=", "f", ".", "quotaUsage", ".", "Get", "(", "ctx", ",", "quotaUsageStaleTolerance", "/", "2", ",", "quotaUsageStaleTolerance", ")", "\n", "if", "err", "!=", "nil", "{", "f", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "total", ":=", "getNumBlocksFromSize", "(", "uint64", "(", "limitBytes", ")", ")", "\n", "used", ":=", "getNumBlocksFromSize", "(", "uint64", "(", "usageBytes", ")", ")", "\n", "resp", ".", "Blocks", "=", "total", "\n", "resp", ".", "Bavail", "=", "total", "-", "used", "\n", "resp", ".", "Bfree", "=", "total", "-", "used", "\n\n", "return", "nil", "\n", "}" ]

[ "Statfs", "implements", "the", "fs", ".", "FSStatfser", "interface", "for", "FS", "." ]

[ "func", "(", "r", "*", "Root", ")", "Lookup", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "LookupRequest", ",", "resp", "*", "fuse", ".", "LookupResponse", ")", "(", "_", "fs", ".", "Node", ",", "err", "error", ")", "{", "r", ".", "log", "(", ")", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "req", ".", "Name", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "r", ".", "private", ".", "fs", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "ReadMode", ",", "err", ")", "}", "(", ")", "\n\n", "specialNode", ":=", "handleNonTLFSpecialFile", "(", "req", ".", "Name", ",", "r", ".", "private", ".", "fs", ",", "&", "resp", ".", "EntryValid", ")", "\n", "if", "specialNode", "!=", "nil", "{", "return", "specialNode", ",", "nil", "\n", "}", "\n\n", "platformNode", ",", "err", ":=", "r", ".", "platformLookup", "(", "ctx", ",", "req", ",", "resp", ")", "\n", "if", "platformNode", "!=", "nil", "||", "err", "!=", "nil", "{", "return", "platformNode", ",", "err", "\n", "}", "\n\n", "switch", "req", ".", "Name", "{", "case", "PrivateName", ":", "return", "r", ".", "private", ",", "nil", "\n", "case", "PublicName", ":", "return", "r", ".", "public", ",", "nil", "\n", "}", "\n\n", "if", "req", ".", "Name", "==", "TeamName", "{", "return", "r", ".", "team", ",", "nil", "\n", "}", "\n\n", "// Don't want to pop up errors on special OS files.", "if", "strings", ".", "HasPrefix", "(", "req", ".", "Name", ",", "\"", "\"", ")", "{", "return", "nil", ",", "fuse", ".", "ENOENT", "\n", "}", "\n\n", "return", "nil", ",", "libkbfs", ".", "NoSuchFolderListError", "{", "Name", ":", "req", ".", "Name", ",", "PrivName", ":", "PrivateName", ",", "PubName", ":", "PublicName", ",", "}", "\n", "}" ]

[ "Lookup", "implements", "the", "fs", ".", "NodeRequestLookuper", "interface", "for", "Root", "." ]

[ "func", "(", "r", "*", "Root", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "CreateRequest", ",", "resp", "*", "fuse", ".", "CreateResponse", ")", "(", "_", "fs", ".", "Node", ",", "_", "fs", ".", "Handle", ",", "err", "error", ")", "{", "r", ".", "log", "(", ")", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "r", ".", "private", ".", "fs", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "err", ")", "}", "(", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "req", ".", "Name", ",", "\"", "\"", ")", "{", "// Quietly ignore writes to special macOS files, without", "// triggering a notification.", "return", "nil", ",", "nil", ",", "syscall", ".", "ENOENT", "\n", "}", "\n", "return", "nil", ",", "nil", ",", "libkbfs", ".", "NewWriteUnsupportedError", "(", "tlfhandle", ".", "BuildCanonicalPath", "(", "r", ".", "PathType", "(", ")", ",", "req", ".", "Name", ")", ")", "\n", "}" ]

[ "Create", "implements", "the", "fs", ".", "NodeCreater", "interface", "for", "Root", "." ]

[ "func", "(", "r", "*", "Root", ")", "Mkdir", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "MkdirRequest", ")", "(", "_", "fs", ".", "Node", ",", "err", "error", ")", "{", "r", ".", "log", "(", ")", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "r", ".", "private", ".", "fs", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "err", ")", "}", "(", ")", "\n", "return", "nil", ",", "libkbfs", ".", "NewWriteUnsupportedError", "(", "tlfhandle", ".", "BuildCanonicalPath", "(", "r", ".", "PathType", "(", ")", ",", "req", ".", "Name", ")", ")", "\n", "}" ]

[ "Mkdir", "implements", "the", "fs", ".", "NodeMkdirer", "interface", "for", "Root", "." ]