Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "b", "*", "BackgroundEphemeralPurger", ")", "loop", "(", "shutdownCh", "chan", "struct", "{", "}", ")", "{", "bgctx", ":=", "context", ".", "Background", "(", ")", "\n", "b", ".", "Debug", "(", "bgctx", ",", "\"", "\"", ",", "b", ".", "uid", ")", "\n\n", "for", "{", "select", "{", "case", "<-", "b", ".", "purgeTimer", ".", "C", ":", "b", ".", "Debug", "(", "bgctx", ",", "\"", "\"", ",", "b", ".", "uid", ")", "\n", "b", ".", "queuePurges", "(", "bgctx", ")", "\n", "case", "<-", "shutdownCh", ":", "b", ".", "Debug", "(", "bgctx", ",", "\"", "\"", ",", "b", ".", "uid", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "This", "runs", "when", "we", "are", "waiting", "to", "run", "a", "job", "but", "will", "shut", "itself", "down", "if", "we", "have", "no", "work", "." ]

[ "func", "(", "state", "*", "LockState", ")", "currLocked", "(", ")", "*", "exclusionState", "{", "stateCount", ":=", "len", "(", "state", ".", "exclusionStates", ")", "\n", "if", "stateCount", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "&", "state", ".", "exclusionStates", "[", "stateCount", "-", "1", "]", "\n", "}" ]

[ "currLocked", "returns", "the", "current", "exclusion", "state", "or", "nil", "if", "there", "is", "none", "." ]

[ "func", "(", "state", "*", "LockState", ")", "getExclusionType", "(", "level", "MutexLevel", ")", "exclusionType", "{", "state", ".", "exclusionStatesLock", ".", "lock", "(", ")", "\n", "defer", "state", ".", "exclusionStatesLock", ".", "unlock", "(", ")", "\n\n", "// Not worth it to do anything more complicated than a", "// brute-force search.", "for", "_", ",", "state", ":=", "range", "state", ".", "exclusionStates", "{", "if", "state", ".", "level", ">", "level", "{", "break", "\n", "}", "\n", "if", "state", ".", "level", "==", "level", "{", "return", "state", ".", "exclusionType", "\n", "}", "\n", "}", "\n\n", "return", "nonExclusion", "\n", "}" ]

[ "getExclusionType", "returns", "returns", "the", "exclusionType", "for", "the", "given", "MutexLevel", "or", "nonExclusion", "if", "there", "is", "none", "." ]

[ "func", "MakeLeveledMutex", "(", "level", "MutexLevel", ",", "locker", "sync", ".", "Locker", ")", "LeveledMutex", "{", "return", "LeveledMutex", "{", "level", ":", "level", ",", "locker", ":", "locker", ",", "}", "\n", "}" ]

[ "MakeLeveledMutex", "makes", "a", "mutex", "with", "the", "given", "level", "backed", "by", "the", "given", "locker", "." ]

[ "func", "(", "m", "LeveledMutex", ")", "Unlock", "(", "lockState", "*", "LockState", ")", "{", "err", ":=", "lockState", ".", "doUnlock", "(", "m", ".", "level", ",", "writeExclusion", ",", "m", ".", "locker", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "Unlock", "locks", "the", "associated", "locker", "." ]

[ "func", "MakeLeveledRWMutex", "(", "level", "MutexLevel", ",", "rwLocker", "rwLocker", ")", "LeveledRWMutex", "{", "return", "LeveledRWMutex", "{", "level", ":", "level", ",", "rwLocker", ":", "rwLocker", ",", "}", "\n", "}" ]

[ "MakeLeveledRWMutex", "makes", "a", "reader", "-", "writer", "mutex", "with", "the", "given", "level", "backed", "by", "the", "given", "rwLocker", "." ]

[ "func", "(", "rw", "LeveledRWMutex", ")", "Unlock", "(", "lockState", "*", "LockState", ")", "{", "err", ":=", "lockState", ".", "doUnlock", "(", "rw", ".", "level", ",", "writeExclusion", ",", "rw", ".", "rwLocker", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "Unlock", "unlocks", "the", "associated", "locker", "." ]

[ "func", "(", "rw", "LeveledRWMutex", ")", "RLock", "(", "lockState", "*", "LockState", ")", "{", "err", ":=", "lockState", ".", "doLock", "(", "rw", ".", "level", ",", "readExclusion", ",", "rw", ".", "rwLocker", ".", "RLocker", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "RLock", "locks", "the", "associated", "locker", "for", "reading", "." ]

[ "func", "(", "rw", "LeveledRWMutex", ")", "RUnlock", "(", "lockState", "*", "LockState", ")", "{", "err", ":=", "lockState", ".", "doUnlock", "(", "rw", ".", "level", ",", "readExclusion", ",", "rw", ".", "rwLocker", ".", "RLocker", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "RUnlock", "unlocks", "the", "associated", "locker", "for", "reading", "." ]

[ "func", "(", "rw", "LeveledRWMutex", ")", "AssertRLocked", "(", "lockState", "*", "LockState", ")", "{", "et", ":=", "lockState", ".", "getExclusionType", "(", "rw", ".", "level", ")", "\n", "if", "et", "!=", "readExclusion", "{", "panic", "(", "unexpectedExclusionTypeError", "{", "levelToString", ":", "lockState", ".", "levelToString", ",", "level", ":", "rw", ".", "level", ",", "expectedExclusionType", ":", "readExclusion", ",", "exclusionType", ":", "et", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "AssertRLocked", "does", "nothing", "if", "m", "is", "r", "-", "locked", "with", "respect", "to", "the", "given", "LockState", ".", "Otherwise", "it", "panics", "." ]

[ "func", "(", "rw", "LeveledRWMutex", ")", "AssertAnyLocked", "(", "lockState", "*", "LockState", ")", "{", "et", ":=", "lockState", ".", "getExclusionType", "(", "rw", ".", "level", ")", "\n", "if", "et", "==", "nonExclusion", "{", "panic", "(", "unexpectedNonExclusionError", "{", "levelToString", ":", "lockState", ".", "levelToString", ",", "level", ":", "rw", ".", "level", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "AssertAnyLocked", "does", "nothing", "if", "m", "is", "locked", "or", "r", "-", "locked", "with", "respect", "to", "the", "given", "LockState", ".", "Otherwise", "it", "panics", "." ]

[ "func", "NewFileData", "(", "file", "Path", ",", "chargedTo", "keybase1", ".", "UserOrTeamID", ",", "bsplit", "BlockSplitter", ",", "kmd", "libkey", ".", "KeyMetadata", ",", "getter", "FileBlockGetter", ",", "cacher", "dirtyBlockCacher", ",", "log", "logger", ".", "Logger", ",", "vlog", "*", "libkb", ".", "VDebugLog", ")", "*", "FileData", "{", "fd", ":=", "&", "FileData", "{", "getter", ":", "getter", ",", "}", "\n", "fd", ".", "tree", "=", "&", "blockTree", "{", "file", ":", "file", ",", "chargedTo", ":", "chargedTo", ",", "kmd", ":", "kmd", ",", "bsplit", ":", "bsplit", ",", "getter", ":", "fd", ".", "blockGetter", ",", "cacher", ":", "cacher", ",", "log", ":", "log", ",", "vlog", ":", "vlog", ",", "}", "\n", "return", "fd", "\n", "}" ]

[ "NewFileData", "makes", "a", "new", "file", "data", "object", "for", "the", "given", "file", "within", "the", "given", "kmd", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "Read", "(", "ctx", "context", ".", "Context", ",", "dest", "[", "]", "byte", ",", "startOff", "Int64Offset", ")", "(", "int64", ",", "error", ")", "{", "if", "len", "(", "dest", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "// If we have a large enough timeout add a temporary timeout that is", "// readTimeoutSmallerBy. Use that for reading so short reads get returned", "// upstream without triggering the global timeout.", "now", ":=", "time", ".", "Now", "(", ")", "\n", "deadline", ",", "haveTimeout", ":=", "ctx", ".", "Deadline", "(", ")", "\n", "if", "haveTimeout", "{", "rem", ":=", "deadline", ".", "Sub", "(", "now", ")", "-", "readTimeoutSmallerBy", "\n", "if", "rem", ">", "0", "{", "var", "cancel", "func", "(", ")", "\n", "ctx", ",", "cancel", "=", "context", ".", "WithTimeout", "(", "ctx", ",", "rem", ")", "\n", "defer", "cancel", "(", ")", "\n", "}", "\n", "}", "\n\n", "bytes", ",", "err", ":=", "fd", ".", "getByteSlicesInOffsetRange", "(", "ctx", ",", "startOff", ",", "startOff", "+", "Int64Offset", "(", "len", "(", "dest", ")", ")", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "currLen", ":=", "int64", "(", "0", ")", "\n", "for", "_", ",", "b", ":=", "range", "bytes", "{", "bLen", ":=", "int64", "(", "len", "(", "b", ")", ")", "\n", "copy", "(", "dest", "[", "currLen", ":", "currLen", "+", "bLen", "]", ",", "b", ")", "\n", "currLen", "+=", "bLen", "\n", "}", "\n", "return", "currLen", ",", "nil", "\n", "}" ]

[ "read", "fills", "the", "dest", "buffer", "with", "data", "from", "the", "file", "starting", "at", "startOff", ".", "Returns", "the", "number", "of", "bytes", "copied", ".", "If", "the", "read", "operation", "nears", "the", "deadline", "set", "in", "ctx", "it", "returns", "as", "big", "a", "prefix", "as", "possible", "before", "reaching", "the", "deadline", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "GetBytes", "(", "ctx", "context", ".", "Context", ",", "startOff", ",", "endOff", "Int64Offset", ")", "(", "data", "[", "]", "byte", ",", "err", "error", ")", "{", "bytes", ",", "err", ":=", "fd", ".", "getByteSlicesInOffsetRange", "(", "ctx", ",", "startOff", ",", "endOff", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "bufSize", ":=", "0", "\n", "for", "_", ",", "b", ":=", "range", "bytes", "{", "bufSize", "+=", "len", "(", "b", ")", "\n", "}", "\n", "data", "=", "make", "(", "[", "]", "byte", ",", "bufSize", ")", "\n", "currLen", ":=", "0", "\n", "for", "_", ",", "b", ":=", "range", "bytes", "{", "copy", "(", "data", "[", "currLen", ":", "currLen", "+", "len", "(", "b", ")", "]", ",", "b", ")", "\n", "currLen", "+=", "len", "(", "b", ")", "\n", "}", "\n\n", "return", "data", ",", "nil", "\n", "}" ]

[ "GetBytes", "returns", "a", "buffer", "containing", "data", "from", "the", "file", "in", "the", "half", "-", "inclusive", "range", "[", "startOff", "endOff", ")", ".", "If", "endOff", "==", "-", "1", "it", "returns", "data", "until", "the", "end", "of", "the", "file", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "GetFileBlockAtOffset", "(", "ctx", "context", ".", "Context", ",", "topBlock", "*", "FileBlock", ",", "off", "Int64Offset", ",", "rtype", "BlockReqType", ")", "(", "ptr", "BlockPointer", ",", "parentBlocks", "[", "]", "ParentBlockAndChildIndex", ",", "block", "*", "FileBlock", ",", "nextBlockStartOff", ",", "startOff", "Int64Offset", ",", "wasDirty", "bool", ",", "err", "error", ")", "{", "ptr", ",", "parentBlocks", ",", "b", ",", "nbso", ",", "so", ",", "wasDirty", ",", "err", ":=", "fd", ".", "tree", ".", "getBlockAtOffset", "(", "ctx", ",", "topBlock", ",", "off", ",", "rtype", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ZeroPtr", ",", "nil", ",", "nil", ",", "0", ",", "0", ",", "false", ",", "err", "\n", "}", "\n", "if", "b", "!=", "nil", "{", "block", "=", "b", ".", "(", "*", "FileBlock", ")", "\n", "}", "\n", "if", "nbso", "!=", "nil", "{", "nextBlockStartOff", "=", "nbso", ".", "(", "Int64Offset", ")", "\n", "}", "else", "{", "nextBlockStartOff", "=", "-", "1", "\n", "}", "\n", "if", "so", "!=", "nil", "{", "startOff", "=", "so", ".", "(", "Int64Offset", ")", "\n", "}", "\n", "return", "ptr", ",", "parentBlocks", ",", "block", ",", "nextBlockStartOff", ",", "startOff", ",", "wasDirty", ",", "nil", "\n", "}" ]

[ "GetFileBlockAtOffset", "returns", "the", "leaf", "file", "block", "responsible", "for", "the", "given", "offset", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "Ready", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bcache", "BlockCache", ",", "dirtyBcache", "IsDirtyProvider", ",", "rp", "ReadyProvider", ",", "bps", "BlockPutState", ",", "topBlock", "*", "FileBlock", ",", "df", "*", "DirtyFile", ")", "(", "map", "[", "BlockInfo", "]", "BlockPointer", ",", "error", ")", "{", "return", "fd", ".", "tree", ".", "ready", "(", "ctx", ",", "id", ",", "bcache", ",", "dirtyBcache", ",", "rp", ",", "bps", ",", "topBlock", ",", "func", "(", "ptr", "BlockPointer", ")", "func", "(", ")", "error", "{", "if", "df", "!=", "nil", "{", "return", "func", "(", ")", "error", "{", "return", "df", ".", "setBlockSynced", "(", "ptr", ")", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "Ready", "readies", "if", "given", "an", "indirect", "top", "-", "block", "all", "the", "dirty", "child", "blocks", "and", "updates", "their", "block", "IDs", "in", "their", "parent", "block", "s", "list", "of", "indirect", "pointers", ".", "It", "returns", "a", "map", "pointing", "from", "the", "new", "block", "info", "from", "any", "readied", "block", "to", "its", "corresponding", "old", "block", "pointer", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "GetIndirectFileBlockInfosWithTopBlock", "(", "ctx", "context", ".", "Context", ",", "topBlock", "*", "FileBlock", ")", "(", "[", "]", "BlockInfo", ",", "error", ")", "{", "return", "fd", ".", "tree", ".", "getIndirectBlockInfosWithTopBlock", "(", "ctx", ",", "topBlock", ")", "\n", "}" ]

[ "GetIndirectFileBlockInfosWithTopBlock", "returns", "the", "block", "infos", "contained", "in", "all", "the", "indirect", "blocks", "in", "this", "file", "tree", "given", "an", "already", "-", "fetched", "top", "block", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "GetIndirectFileBlockInfos", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "BlockInfo", ",", "error", ")", "{", "return", "fd", ".", "tree", ".", "getIndirectBlockInfos", "(", "ctx", ")", "\n", "}" ]

[ "GetIndirectFileBlockInfos", "returns", "the", "block", "infos", "contained", "in", "all", "the", "indirect", "blocks", "in", "this", "file", "tree", "." ]

[ "func", "(", "fd", "*", "FileData", ")", "FindIPtrsAndClearSize", "(", "ctx", "context", ".", "Context", ",", "topBlock", "*", "FileBlock", ",", "ptrs", "map", "[", "BlockPointer", "]", "bool", ")", "(", "found", "map", "[", "BlockPointer", "]", "bool", ",", "err", "error", ")", "{", "if", "!", "topBlock", ".", "IsInd", "||", "len", "(", "ptrs", ")", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "pfr", ",", "err", ":=", "fd", ".", "tree", ".", "getIndirectBlocksForOffsetRange", "(", "ctx", ",", "topBlock", ",", "Int64Offset", "(", "0", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "found", "=", "make", "(", "map", "[", "BlockPointer", "]", "bool", ")", "\n\n", "// Search all paths for the given block pointer, clear its encoded", "// size, and dirty all its parents up to the root.", "infoSeen", ":=", "make", "(", "map", "[", "BlockPointer", "]", "bool", ")", "\n", "for", "_", ",", "Path", ":=", "range", "pfr", "{", "parentPtr", ":=", "fd", ".", "rootBlockPointer", "(", ")", "\n", "for", "level", ",", "pb", ":=", "range", "Path", "{", "if", "infoSeen", "[", "parentPtr", "]", "{", "parentPtr", "=", "pb", ".", "childBlockPtr", "(", ")", "\n", "continue", "\n", "}", "\n", "infoSeen", "[", "parentPtr", "]", "=", "true", "\n\n", "for", "i", ",", "iptr", ":=", "range", "pb", ".", "pblock", ".", "(", "*", "FileBlock", ")", ".", "IPtrs", "{", "if", "ptrs", "[", "iptr", ".", "BlockPointer", "]", "{", "// Mark this pointer, and all parent blocks, as dirty.", "parentPtr", ":=", "fd", ".", "rootBlockPointer", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<=", "level", ";", "i", "++", "{", "// Get a writeable copy for each block.", "pblock", ",", "_", ",", "err", ":=", "fd", ".", "getter", "(", "ctx", ",", "fd", ".", "tree", ".", "kmd", ",", "parentPtr", ",", "fd", ".", "tree", ".", "file", ",", "BlockWrite", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "Path", "[", "i", "]", ".", "pblock", "=", "pblock", "\n", "parentPtr", "=", "Path", "[", "i", "]", ".", "childBlockPtr", "(", ")", "\n", "}", "\n", "// Because we only check each parent once, the", "// `path` we're using here will be the one with a", "// childIndex of 0. But, that's not necessarily", "// the one that matches the pointer that needs to", "// be dirty. So make a new path and set the", "// childIndex to the correct pointer instead.", "newPath", ":=", "make", "(", "[", "]", "ParentBlockAndChildIndex", ",", "level", "+", "1", ")", "\n", "copy", "(", "newPath", ",", "Path", "[", ":", "level", "+", "1", "]", ")", "\n", "newPath", "[", "level", "]", ".", "childIndex", "=", "i", "\n", "_", ",", "_", ",", "err", "=", "fd", ".", "tree", ".", "markParentsDirty", "(", "ctx", ",", "newPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "found", "[", "iptr", ".", "BlockPointer", "]", "=", "true", "\n", "if", "len", "(", "found", ")", "==", "len", "(", "ptrs", ")", "{", "return", "found", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "parentPtr", "=", "pb", ".", "childBlockPtr", "(", ")", "\n", "}", "\n", "}", "\n", "return", "found", ",", "nil", "\n", "}" ]

[ "FindIPtrsAndClearSize", "looks", "for", "the", "given", "set", "of", "indirect", "pointers", "and", "returns", "whether", "they", "could", "be", "found", ".", "As", "a", "side", "effect", "it", "also", "clears", "the", "encoded", "size", "for", "those", "indirect", "pointers", "." ]

[ "func", "(", "rwg", "*", "RepeatedWaitGroup", ")", "Add", "(", "delta", "int", ")", "{", "rwg", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "rwg", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "rwg", ".", "isIdleCh", "==", "nil", "{", "rwg", ".", "isIdleCh", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "}", "\n", "if", "rwg", ".", "num", "+", "delta", "<", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "rwg", ".", "num", "+=", "delta", "\n", "if", "rwg", ".", "num", "==", "0", "{", "close", "(", "rwg", ".", "isIdleCh", ")", "\n", "rwg", ".", "isIdleCh", "=", "nil", "\n", "}", "\n", "}" ]

[ "Add", "indicates", "that", "a", "number", "of", "tasks", "have", "begun", "." ]

[ "func", "(", "rwg", "*", "RepeatedWaitGroup", ")", "Wait", "(", "ctx", "context", ".", "Context", ")", "error", "{", "isIdleCh", ":=", "func", "(", ")", "chan", "struct", "{", "}", "{", "rwg", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "rwg", ".", "lock", ".", "Unlock", "(", ")", "\n", "return", "rwg", ".", "isIdleCh", "\n", "}", "(", ")", "\n\n", "if", "isIdleCh", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "select", "{", "case", "<-", "isIdleCh", ":", "return", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "Wait", "blocks", "until", "either", "the", "underlying", "task", "count", "goes", "to", "0", "or", "the", "given", "context", "is", "canceled", "." ]

[ "func", "(", "rwg", "*", "RepeatedWaitGroup", ")", "WaitUnlessPaused", "(", "ctx", "context", ".", "Context", ")", "(", "bool", ",", "error", ")", "{", "paused", ",", "isIdleCh", ",", "pauseCh", ":=", "func", "(", ")", "(", "bool", ",", "chan", "struct", "{", "}", ",", "chan", "struct", "{", "}", ")", "{", "rwg", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "rwg", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "!", "rwg", ".", "paused", "&&", "rwg", ".", "pauseCh", "==", "nil", "{", "rwg", ".", "pauseCh", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "}", "\n", "return", "rwg", ".", "paused", ",", "rwg", ".", "isIdleCh", ",", "rwg", ".", "pauseCh", "\n", "}", "(", ")", "\n\n", "if", "isIdleCh", "==", "nil", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "if", "paused", "{", "return", "true", ",", "nil", "\n", "}", "\n\n", "select", "{", "case", "<-", "isIdleCh", ":", "return", "false", ",", "nil", "\n", "case", "<-", "pauseCh", ":", "return", "true", ",", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "false", ",", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}" ]

[ "WaitUnlessPaused", "works", "like", "Wait", "except", "it", "can", "return", "early", "if", "the", "wait", "group", "is", "paused", ".", "It", "returns", "whether", "it", "was", "paused", "with", "outstanding", "work", "still", "left", "in", "the", "group", "." ]

[ "func", "(", "rwg", "*", "RepeatedWaitGroup", ")", "Pause", "(", ")", "{", "rwg", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "rwg", ".", "lock", ".", "Unlock", "(", ")", "\n", "rwg", ".", "paused", "=", "true", "\n", "if", "rwg", ".", "pauseCh", "!=", "nil", "{", "close", "(", "rwg", ".", "pauseCh", ")", "\n", "rwg", ".", "pauseCh", "=", "nil", "\n", "}", "\n", "}" ]

[ "Pause", "causes", "any", "current", "or", "future", "callers", "of", "WaitUnlessPaused", "to", "return", "immediately", "." ]

[ "func", "(", "rwg", "*", "RepeatedWaitGroup", ")", "Resume", "(", ")", "{", "rwg", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "rwg", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "rwg", ".", "pauseCh", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "rwg", ".", "paused", "=", "false", "\n", "}" ]

[ "Resume", "unpauses", "the", "wait", "group", "allowing", "future", "callers", "of", "WaitUnlessPaused", "to", "wait", "until", "all", "the", "outstanding", "work", "is", "completed", "." ]

[ "func", "NewTemplate", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "Template", "{", "return", "&", "Template", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewTemplate", "creates", "a", "Template", "engine", "." ]

[ "func", "PadBlock", "(", "block", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "totalLen", ":=", "powerOfTwoEqualOrGreater", "(", "len", "(", "block", ")", ")", "\n\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "padPrefixSize", "+", "totalLen", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "buf", ",", "uint32", "(", "len", "(", "block", ")", ")", ")", "\n\n", "copy", "(", "buf", "[", "padPrefixSize", ":", "]", ",", "block", ")", "\n", "return", "buf", ",", "nil", "\n", "}" ]

[ "PadBlock", "adds", "zero", "padding", "to", "an", "encoded", "block", "." ]

[ "func", "DepadBlock", "(", "paddedBlock", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "totalLen", ":=", "len", "(", "paddedBlock", ")", "\n", "if", "totalLen", "<", "padPrefixSize", "{", "return", "nil", ",", "errors", ".", "WithStack", "(", "io", ".", "ErrUnexpectedEOF", ")", "\n", "}", "\n\n", "blockLen", ":=", "binary", ".", "LittleEndian", ".", "Uint32", "(", "paddedBlock", ")", "\n", "blockEndPos", ":=", "int", "(", "blockLen", "+", "padPrefixSize", ")", "\n\n", "if", "totalLen", "<", "blockEndPos", "{", "return", "nil", ",", "errors", ".", "WithStack", "(", "PaddedBlockReadError", "{", "ActualLen", ":", "totalLen", ",", "ExpectedLen", ":", "blockEndPos", ",", "}", ")", "\n", "}", "\n", "return", "paddedBlock", "[", "padPrefixSize", ":", "blockEndPos", "]", ",", "nil", "\n", "}" ]

[ "DepadBlock", "extracts", "the", "actual", "block", "data", "from", "a", "padded", "block", "." ]

[ "func", "(", "p", "*", "CmdProve", ")", "ParseArgv", "(", "ctx", "*", "cli", ".", "Context", ")", "error", "{", "nargs", ":=", "len", "(", "ctx", ".", "Args", "(", ")", ")", "\n", "p", ".", "arg", ".", "Force", "=", "ctx", ".", "Bool", "(", "\"", "\"", ")", "\n", "p", ".", "listServices", "=", "ctx", ".", "Bool", "(", "\"", "\"", ")", "\n", "p", ".", "output", "=", "ctx", ".", "String", "(", "\"", "\"", ")", "\n\n", "if", "p", ".", "listServices", "{", "return", "nil", "\n", "}", "\n\n", "if", "nargs", ">", "2", "||", "nargs", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "p", ".", "arg", ".", "Service", "=", "ctx", ".", "Args", "(", ")", "[", "0", "]", "\n", "if", "nargs", "==", "2", "{", "p", ".", "arg", ".", "Username", "=", "ctx", ".", "Args", "(", ")", "[", "1", "]", "\n", "}", "\n\n", "if", "libkb", ".", "RemoteServiceTypes", "[", "p", ".", "arg", ".", "Service", "]", "==", "keybase1", ".", "ProofType_ROOTER", "{", "p", ".", "arg", ".", "Auto", "=", "ctx", ".", "Bool", "(", "\"", "\"", ")", "\n", "if", "p", ".", "arg", ".", "Auto", "&&", "len", "(", "p", ".", "arg", ".", "Username", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ParseArgv", "parses", "arguments", "for", "the", "prove", "command", "." ]

[ "func", "NewCmdProve", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "cmd", ":=", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Description", ":", "\"", "\"", ",", "Flags", ":", "[", "]", "cli", ".", "Flag", "{", "cli", ".", "StringFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "cli", ".", "BoolFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "cli", ".", "BoolFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "}", ",", "Action", ":", "func", "(", "c", "*", "cli", ".", "Context", ")", "{", "cl", ".", "ChooseCommand", "(", "&", "CmdProve", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", "}", ",", "\"", "\"", ",", "c", ")", "\n", "}", ",", "}", "\n", "cmd", ".", "Flags", "=", "append", "(", "cmd", ".", "Flags", ",", "restrictedProveFlags", "...", ")", "\n", "return", "cmd", "\n", "}" ]

[ "NewCmdProve", "makes", "a", "new", "prove", "command", "from", "the", "given", "CLI", "parameters", "." ]

[ "func", "NewCmdProveRooterRunner", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "username", "string", ")", "*", "CmdProve", "{", "return", "&", "CmdProve", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "arg", ":", "keybase1", ".", "StartProofArg", "{", "Service", ":", "\"", "\"", ",", "Username", ":", "username", ",", "Auto", ":", "true", ",", "}", ",", "}", "\n", "}" ]

[ "NewCmdProveRooterRunner", "creates", "a", "CmdProve", "for", "proving", "rooter", "in", "tests", "." ]

[ "func", "(", "p", "*", "CmdProve", ")", "GetUsage", "(", ")", "libkb", ".", "Usage", "{", "return", "libkb", ".", "Usage", "{", "Config", ":", "true", ",", "API", ":", "true", ",", "KbKeyring", ":", "true", ",", "}", "\n", "}" ]

[ "GetUsage", "specifics", "the", "library", "features", "that", "the", "prove", "command", "needs", "." ]

[ "func", "(", "et", "HandleExtensionType", ")", "String", "(", "username", "kbname", ".", "NormalizedUsername", ")", "string", "{", "switch", "et", "{", "case", "HandleExtensionConflict", ":", "return", "handleExtensionConflictString", "\n", "case", "HandleExtensionFinalized", ":", "if", "len", "(", "username", ")", "!=", "0", "{", "username", "+=", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "handleExtensionFinalizedString", ",", "username", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "String", "implements", "the", "fmt", ".", "Stringer", "interface", "for", "HandleExtensionType" ]

[ "func", "parseHandleExtensionString", "(", "s", "string", ")", "(", "HandleExtensionType", ",", "kbname", ".", "NormalizedUsername", ")", "{", "if", "handleExtensionConflictString", "==", "s", "{", "return", "HandleExtensionConflict", ",", "\"", "\"", "\n", "}", "\n", "m", ":=", "handleExtensionFinalizedRegex", ".", "FindStringSubmatch", "(", "s", ")", "\n", "if", "len", "(", "m", ")", "<", "2", "{", "return", "HandleExtensionUnknown", ",", "\"", "\"", "\n", "}", "\n", "return", "HandleExtensionFinalized", ",", "kbname", ".", "NewNormalizedUsername", "(", "m", "[", "1", "]", ")", "\n", "}" ]

[ "parseHandleExtensionString", "parses", "an", "extension", "type", "and", "optional", "username", "from", "a", "string", "." ]

[ "func", "NewHandleExtension", "(", "extType", "HandleExtensionType", ",", "num", "uint16", ",", "un", "kbname", ".", "NormalizedUsername", ",", "now", "time", ".", "Time", ")", "(", "*", "HandleExtension", ",", "error", ")", "{", "return", "newHandleExtension", "(", "extType", ",", "num", ",", "un", ",", "now", ")", "\n", "}" ]

[ "NewHandleExtension", "returns", "a", "new", "HandleExtension", "struct", "populated", "with", "the", "date", "from", "the", "given", "time", "and", "conflict", "number", "." ]

[ "func", "newHandleExtension", "(", "extType", "HandleExtensionType", ",", "num", "uint16", ",", "un", "kbname", ".", "NormalizedUsername", ",", "now", "time", ".", "Time", ")", "(", "*", "HandleExtension", ",", "error", ")", "{", "if", "num", "==", "0", "{", "return", "nil", ",", "errHandleExtensionInvalidNumber", "\n", "}", "\n", "// mask out everything but the date", "date", ":=", "now", ".", "UTC", "(", ")", ".", "Format", "(", "handleExtensionDateFormat", ")", "\n", "now", ",", "err", ":=", "time", ".", "Parse", "(", "handleExtensionDateFormat", ",", "date", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "HandleExtension", "{", "Date", ":", "now", ".", "UTC", "(", ")", ".", "Unix", "(", ")", ",", "Number", ":", "num", ",", "Type", ":", "extType", ",", "Username", ":", "un", ",", "}", ",", "nil", "\n", "}" ]

[ "Helper", "to", "instantiate", "a", "HandleExtension", "object", "." ]

[ "func", "parseHandleExtension", "(", "fields", "[", "]", "string", ")", "(", "*", "HandleExtension", ",", "error", ")", "{", "if", "len", "(", "fields", ")", "!=", "4", "{", "return", "nil", ",", "errHandleExtensionInvalidString", "\n", "}", "\n", "extType", ",", "un", ":=", "parseHandleExtensionString", "(", "fields", "[", "1", "]", ")", "\n", "if", "extType", "==", "HandleExtensionUnknown", "{", "return", "nil", ",", "errHandleExtensionInvalidString", "\n", "}", "\n", "date", ",", "err", ":=", "time", ".", "Parse", "(", "handleExtensionDateFormat", ",", "fields", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "num", "uint64", "=", "1", "\n", "if", "len", "(", "fields", "[", "3", "]", ")", "!=", "0", "{", "num", ",", "err", "=", "strconv", ".", "ParseUint", "(", "fields", "[", "3", "]", ",", "10", ",", "16", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "num", "<", "1", "{", "return", "nil", ",", "errHandleExtensionInvalidNumber", "\n", "}", "\n", "}", "\n", "return", "&", "HandleExtension", "{", "Date", ":", "date", ".", "UTC", "(", ")", ".", "Unix", "(", ")", ",", "Number", ":", "uint16", "(", "num", ")", ",", "Type", ":", "extType", ",", "Username", ":", "un", ",", "}", ",", "nil", "\n", "}" ]

[ "parseHandleExtension", "parses", "a", "HandleExtension", "array", "of", "string", "fields", "." ]

[ "func", "ParseHandleExtensionSuffix", "(", "s", "string", ")", "(", "[", "]", "HandleExtension", ",", "error", ")", "{", "exts", ":=", "handleExtensionRegex", ".", "FindAllStringSubmatch", "(", "s", ",", "2", ")", "\n", "if", "len", "(", "exts", ")", "<", "1", "||", "len", "(", "exts", ")", ">", "2", "{", "return", "nil", ",", "errHandleExtensionInvalidString", "\n", "}", "\n", "extMap", ":=", "make", "(", "map", "[", "HandleExtensionType", "]", "bool", ")", "\n", "var", "extensions", "[", "]", "HandleExtension", "\n", "for", "_", ",", "e", ":=", "range", "exts", "{", "ext", ",", "err", ":=", "parseHandleExtension", "(", "e", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "extMap", "[", "ext", ".", "Type", "]", "{", "// No duplicate extension types in the same suffix.", "return", "nil", ",", "errHandleExtensionInvalidString", "\n", "}", "\n", "extMap", "[", "ext", ".", "Type", "]", "=", "true", "\n", "extensions", "=", "append", "(", "extensions", ",", "*", "ext", ")", "\n", "}", "\n", "return", "extensions", ",", "nil", "\n", "}" ]

[ "ParseHandleExtensionSuffix", "parses", "a", "TLF", "handle", "extension", "suffix", "string", "." ]

[ "func", "newHandleExtensionSuffix", "(", "extensions", "[", "]", "HandleExtension", ",", "isBackedByTeam", "bool", ")", "string", "{", "var", "suffix", "string", "\n", "for", "_", ",", "extension", ":=", "range", "extensions", "{", "suffix", "+=", "HandleExtensionSep", "\n", "suffix", "+=", "extension", ".", "string", "(", "isBackedByTeam", ")", "\n", "}", "\n", "return", "suffix", "\n", "}" ]

[ "newHandleExtensionSuffix", "creates", "a", "suffix", "string", "given", "a", "set", "of", "extensions", "." ]

[ "func", "(", "t", "*", "delhTracker", ")", "setDeletedUpto", "(", "ctx", "context", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ",", "uid", "gregor1", ".", "UID", ",", "msgid", "chat1", ".", "MessageID", ")", "Error", "{", "entry", ",", "err", ":=", "t", ".", "getEntry", "(", "ctx", ",", "convID", ",", "uid", ")", "\n", "switch", "err", ".", "(", "type", ")", "{", "case", "nil", ":", "case", "MissError", ":", "default", ":", "return", "err", "\n", "}", "\n", "entry", ".", "MaxDeleteHistoryUpto", "=", "msgid", "\n", "entry", ".", "MinDeletableMessage", "=", "msgid", "\n", "return", "t", ".", "setEntry", "(", "ctx", ",", "convID", ",", "uid", ",", "entry", ")", "\n", "}" ]

[ "Set", "both", "values", "to", "msgid" ]

[ "func", "(", "f", "*", "UpdatesFile", ")", "Write", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "WriteRequest", ",", "resp", "*", "fuse", ".", "WriteResponse", ")", "(", "err", "error", ")", "{", "f", ".", "folder", ".", "fs", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "f", ".", "enable", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "f", ".", "folder", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "err", ")", "}", "(", ")", "\n", "if", "len", "(", "req", ".", "Data", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "f", ".", "folder", ".", "updateMu", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "folder", ".", "updateMu", ".", "Unlock", "(", ")", "\n", "if", "f", ".", "enable", "{", "if", "f", ".", "folder", ".", "updateChan", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "err", "=", "libkbfs", ".", "RestartCRForTesting", "(", "libcontext", ".", "BackgroundContextWithCancellationDelayer", "(", ")", ",", "f", ".", "folder", ".", "fs", ".", "config", ",", "f", ".", "folder", ".", "getFolderBranch", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "f", ".", "folder", ".", "updateChan", "<-", "struct", "{", "}", "{", "}", "\n", "close", "(", "f", ".", "folder", ".", "updateChan", ")", "\n", "f", ".", "folder", ".", "updateChan", "=", "nil", "\n", "}", "else", "{", "if", "f", ".", "folder", ".", "updateChan", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "f", ".", "folder", ".", "updateChan", ",", "err", "=", "libkbfs", ".", "DisableUpdatesForTesting", "(", "f", ".", "folder", ".", "fs", ".", "config", ",", "f", ".", "folder", ".", "getFolderBranch", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "libkbfs", ".", "DisableCRForTesting", "(", "f", ".", "folder", ".", "fs", ".", "config", ",", "f", ".", "folder", ".", "getFolderBranch", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "resp", ".", "Size", "=", "len", "(", "req", ".", "Data", ")", "\n", "return", "nil", "\n", "}" ]

[ "Write", "implements", "the", "fs", ".", "HandleWriter", "interface", "for", "UpdatesFile", "." ]

[ "func", "ExtensionForceGC", "(", ")", "{", "var", "m", "runtime", ".", "MemStats", "\n", "runtime", ".", "ReadMemStats", "(", "&", "m", ")", "\n\n", "// Free up gc memory first", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "m", ".", "Alloc", ",", "m", ".", "Sys", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "debug", ".", "FreeOSMemory", "(", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "runtime", ".", "ReadMemStats", "(", "&", "m", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "m", ".", "Alloc", ",", "m", ".", "Sys", ")", "\n\n", "if", "!", "ExtensionIsInited", "(", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "return", "\n", "}", "\n\n", "// Free all caches, and run gc again to clear out anything", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "kbCtx", ".", "FlushCaches", "(", ")", "\n", "if", "_", ",", "ok", ":=", "kbCtx", ".", "LocalChatDb", ".", "GetEngine", "(", ")", ".", "(", "*", "libkb", ".", "MemDb", ")", ";", "ok", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "kbCtx", ".", "LocalChatDb", ".", "Nuke", "(", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "kbCtx", ".", "LocalDb", ".", "GetEngine", "(", ")", ".", "(", "*", "libkb", ".", "MemDb", ")", ";", "ok", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "kbCtx", ".", "LocalDb", ".", "Nuke", "(", ")", "\n", "}", "\n", "debug", ".", "FreeOSMemory", "(", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "runtime", ".", "ReadMemStats", "(", "&", "m", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "m", ".", "Alloc", ",", "m", ".", "Sys", ")", "\n", "}" ]

[ "ExtensionForceGC", "Forces", "a", "gc" ]

[ "func", "NewIdentify2Cache", "(", "maxAge", "time", ".", "Duration", ")", "*", "Identify2Cache", "{", "res", ":=", "&", "Identify2Cache", "{", "cache", ":", "ramcache", ".", "New", "(", ")", ",", "}", "\n", "res", ".", "cache", ".", "MaxAge", "=", "maxAge", "\n", "res", ".", "cache", ".", "TTL", "=", "maxAge", "\n", "return", "res", "\n", "}" ]

[ "NewIdentify2Cache", "creates", "a", "Identify2Cache", "and", "sets", "the", "object", "max", "age", "to", "maxAge", ".", "Once", "a", "user", "is", "inserted", "after", "maxAge", "duration", "passes", "the", "user", "will", "be", "removed", "from", "the", "cache", "." ]

[ "func", "(", "c", "*", "Identify2Cache", ")", "Get", "(", "uid", "keybase1", ".", "UID", ",", "gctf", "GetCheckTimeFunc", ",", "gcdf", "GetCacheDurationFunc", ",", "breaksOK", "bool", ")", "(", "*", "keybase1", ".", "Identify2ResUPK2", ",", "error", ")", "{", "v", ",", "err", ":=", "c", ".", "cache", ".", "Get", "(", "string", "(", "uid", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "ramcache", ".", "ErrNotFound", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "up", ",", "ok", ":=", "v", ".", "(", "*", "keybase1", ".", "Identify2ResUPK2", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n\n", "if", "gctf", "!=", "nil", "{", "then", ":=", "gctf", "(", "*", "up", ")", "\n", "if", "then", "==", "0", "{", "return", "nil", ",", "IdentifyTimeoutError", "{", "}", "\n", "}", "\n", "if", "up", ".", "TrackBreaks", "!=", "nil", "&&", "!", "breaksOK", "{", "return", "nil", ",", "TrackBrokenError", "{", "}", "\n", "}", "\n\n", "thenTime", ":=", "keybase1", ".", "FromTime", "(", "then", ")", "\n", "timeout", ":=", "gcdf", "(", "*", "up", ")", "\n", "if", "time", ".", "Since", "(", "thenTime", ")", ">", "timeout", "{", "return", "nil", ",", "IdentifyTimeoutError", "{", "}", "\n", "}", "\n", "}", "\n\n", "return", "up", ",", "nil", "\n", "}" ]

[ "Get", "returns", "a", "user", "object", ".", "If", "none", "exists", "for", "uid", "it", "will", "return", "nil", "." ]

[ "func", "(", "c", "*", "Identify2Cache", ")", "Insert", "(", "up", "*", "keybase1", ".", "Identify2ResUPK2", ")", "error", "{", "tmp", ":=", "*", "up", "\n", "copy", ":=", "&", "tmp", "\n", "copy", ".", "Upk", ".", "Uvv", ".", "CachedAt", "=", "keybase1", ".", "ToTime", "(", "time", ".", "Now", "(", ")", ")", "\n", "return", "c", ".", "cache", ".", "Set", "(", "string", "(", "up", ".", "Upk", ".", "GetUID", "(", ")", ")", ",", "copy", ")", "\n", "}" ]

[ "Insert", "adds", "a", "user", "to", "the", "cache", "keyed", "on", "UID", "." ]

[ "func", "NewBlockSplitterSimple", "(", "desiredBlockSize", "int64", ",", "blockChangeEmbedMaxSize", "uint64", ",", "codec", "kbfscodec", ".", "Codec", ")", "(", "*", "BlockSplitterSimple", ",", "error", ")", "{", "// If the desired block size is exactly a power of 2, subtract one", "// from it to account for the padding we will do, which rounds up", "// when the encoded size is exactly a power of 2.", "if", "desiredBlockSize", "&", "(", "desiredBlockSize", "-", "1", ")", "==", "0", "{", "desiredBlockSize", "--", "\n", "}", "\n\n", "// Make a FileBlock of the expected size to see what the encoded", "// overhead is.", "block", ":=", "NewFileBlock", "(", ")", ".", "(", "*", "FileBlock", ")", "\n", "fullData", ":=", "make", "(", "[", "]", "byte", ",", "desiredBlockSize", ")", "\n", "// Fill in the block with varying data to make sure not to trigger", "// any encoding optimizations.", "for", "i", ":=", "range", "fullData", "{", "fullData", "[", "i", "]", "=", "byte", "(", "i", ")", "\n", "}", "\n\n", "maxSize", ":=", "desiredBlockSize", "\n", "var", "encodedLen", "int64", "\n", "// Iterate until we find the right size (up to a maximum number of", "// attempts), because the overhead is not constant across", "// different Contents lengths (probably due to variable length", "// encoding of the buffer size).", "for", "i", ":=", "0", ";", "i", "<", "10", ";", "i", "++", "{", "block", ".", "Contents", "=", "fullData", "[", ":", "maxSize", "]", "\n", "encodedBlock", ",", "err", ":=", "codec", ".", "Encode", "(", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "encodedLen", "=", "int64", "(", "len", "(", "encodedBlock", ")", ")", "\n", "if", "encodedLen", ">=", "2", "*", "desiredBlockSize", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "encodedLen", ",", "desiredBlockSize", ")", "\n", "}", "\n\n", "if", "encodedLen", "==", "desiredBlockSize", "{", "break", "\n", "}", "\n\n", "maxSize", "+=", "(", "desiredBlockSize", "-", "encodedLen", ")", "\n", "}", "\n\n", "if", "encodedLen", "!=", "desiredBlockSize", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "desiredBlockSize", ")", "\n", "}", "\n\n", "// Trial and error shows that this magic 75% constant maximizes", "// the number of realistic indirect pointers you can fit into the", "// default block size. TODO: calculate this number more exactly", "// during initialization for a given `maxSize`.", "maxPtrs", ":=", "int", "(", ".75", "*", "float64", "(", "maxSize", "/", "int64", "(", "BPSize", ")", ")", ")", "\n", "if", "maxPtrs", "<", "2", "{", "maxPtrs", "=", "2", "\n", "}", "\n\n", "maxDirEntriesPerBlock", ",", "err", ":=", "getMaxDirEntriesPerBlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "BlockSplitterSimple", "{", "maxSize", ":", "maxSize", ",", "maxPtrsPerBlock", ":", "maxPtrs", ",", "blockChangeEmbedMaxSize", ":", "blockChangeEmbedMaxSize", ",", "maxDirEntriesPerBlock", ":", "maxDirEntriesPerBlock", ",", "}", ",", "nil", "\n", "}" ]

[ "NewBlockSplitterSimple", "creates", "a", "new", "BlockSplittleSimple", "and", "adjusts", "the", "max", "size", "to", "try", "to", "match", "the", "desired", "size", "for", "file", "blocks", "given", "the", "overhead", "of", "encoding", "a", "file", "block", "and", "the", "round", "-", "up", "padding", "we", "do", "." ]

[ "func", "NewBlockSplitterSimpleExact", "(", "maxSize", "int64", ",", "maxPtrsPerBlock", "int", ",", "blockChangeEmbedMaxSize", "uint64", ")", "(", "*", "BlockSplitterSimple", ",", "error", ")", "{", "maxDirEntriesPerBlock", ",", "err", ":=", "getMaxDirEntriesPerBlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "BlockSplitterSimple", "{", "maxSize", ":", "maxSize", ",", "maxPtrsPerBlock", ":", "maxPtrsPerBlock", ",", "blockChangeEmbedMaxSize", ":", "blockChangeEmbedMaxSize", ",", "maxDirEntriesPerBlock", ":", "maxDirEntriesPerBlock", ",", "}", ",", "nil", "\n", "}" ]

[ "NewBlockSplitterSimpleExact", "returns", "a", "BlockSplitterSimple", "with", "the", "max", "block", "size", "set", "to", "an", "exact", "value", "." ]

[ "func", "(", "b", "*", "BlockSplitterSimple", ")", "SetMaxDirEntriesByBlockSize", "(", "codec", "kbfscodec", ".", "Codec", ")", "error", "{", "dirEnv", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "len", "(", "dirEnv", ")", ">", "0", "{", "// Don't override the environment variable.", "return", "nil", "\n", "}", "\n\n", "block", ":=", "NewDirBlock", "(", ")", ".", "(", "*", "DirBlock", ")", "\n", "bigName", ":=", "strings", ".", "Repeat", "(", "\"", "\"", ",", "MaxNameBytesDefault", ")", "\n", "// Make \"typical\" DirEntry, though the max dir entry is a bit", "// bigger than this (can contain a variable-length symlink path,", "// for example).", "de", ":=", "DirEntry", "{", "BlockInfo", ":", "BlockInfo", "{", "BlockPointer", ":", "BlockPointer", "{", "DirectType", ":", "DirectBlock", ",", "}", ",", "}", ",", "EntryInfo", ":", "EntryInfo", "{", "PrevRevisions", ":", "PrevRevisions", "{", "{", "Revision", ":", "0", ",", "Count", ":", "0", "}", ",", "{", "Revision", ":", "1", ",", "Count", ":", "1", "}", ",", "{", "Revision", ":", "2", ",", "Count", ":", "2", "}", ",", "{", "Revision", ":", "3", ",", "Count", ":", "3", "}", ",", "{", "Revision", ":", "4", ",", "Count", ":", "4", "}", ",", "}", ",", "}", ",", "}", "\n", "block", ".", "Children", "[", "bigName", "]", "=", "de", "\n", "encodedBlock", ",", "err", ":=", "codec", ".", "Encode", "(", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "oneEntrySize", ":=", "int64", "(", "len", "(", "encodedBlock", ")", ")", "\n", "b", ".", "maxDirEntriesPerBlock", "=", "int", "(", "b", ".", "maxSize", "/", "oneEntrySize", ")", "\n", "if", "b", ".", "maxDirEntriesPerBlock", "==", "0", "{", "b", ".", "maxDirEntriesPerBlock", "=", "1", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetMaxDirEntriesByBlockSize", "sets", "the", "maximum", "number", "of", "directory", "entries", "per", "directory", "block", "based", "on", "the", "maximum", "block", "size", ".", "If", "the", "KEYBASE_BSPLIT_MAX_DIR_ENTRIES", "is", "set", "this", "function", "does", "nothing", "." ]

[ "func", "(", "b", "*", "BlockSplitterSimple", ")", "CopyUntilSplit", "(", "block", "*", "FileBlock", ",", "lastBlock", "bool", ",", "data", "[", "]", "byte", ",", "off", "int64", ")", "int64", "{", "n", ":=", "int64", "(", "len", "(", "data", ")", ")", "\n", "currLen", ":=", "int64", "(", "len", "(", "block", ".", "Contents", ")", ")", "\n", "// lastBlock is irrelevant since we only copy fixed sizes", "toCopy", ":=", "n", "\n", "if", "currLen", "<", "(", "off", "+", "n", ")", "{", "moreNeeded", ":=", "(", "n", "+", "off", ")", "-", "currLen", "\n", "// Reduce the number of additional bytes if it will take this block", "// over maxSize.", "if", "moreNeeded", "+", "currLen", ">", "b", ".", "maxSize", "{", "moreNeeded", "=", "b", ".", "maxSize", "-", "currLen", "\n", "if", "moreNeeded", "<", "0", "{", "// If it is already over maxSize w/o any added bytes,", "// just give up.", "return", "0", "\n", "}", "\n", "// only copy to the end of the block", "toCopy", "=", "b", ".", "maxSize", "-", "off", "\n", "}", "\n\n", "if", "moreNeeded", ">", "0", "{", "block", ".", "Contents", "=", "append", "(", "block", ".", "Contents", ",", "make", "(", "[", "]", "byte", ",", "moreNeeded", ")", "...", ")", "\n", "}", "\n", "}", "\n\n", "// we may have filled out the block above, but we still can't copy anything", "if", "off", ">", "int64", "(", "len", "(", "block", ".", "Contents", ")", ")", "{", "return", "0", "\n", "}", "\n\n", "copy", "(", "block", ".", "Contents", "[", "off", ":", "off", "+", "toCopy", "]", ",", "data", "[", ":", "toCopy", "]", ")", "\n", "return", "toCopy", "\n", "}" ]

[ "CopyUntilSplit", "implements", "the", "BlockSplitter", "interface", "for", "BlockSplitterSimple", "." ]

[ "func", "(", "b", "*", "BlockSplitterSimple", ")", "SplitDirIfNeeded", "(", "block", "*", "DirBlock", ")", "(", "[", "]", "*", "DirBlock", ",", "*", "StringOffset", ")", "{", "if", "block", ".", "IsIndirect", "(", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "b", ".", "maxDirEntriesPerBlock", "==", "0", "||", "len", "(", "block", ".", "Children", ")", "<=", "b", ".", "maxDirEntriesPerBlock", "{", "return", "[", "]", "*", "DirBlock", "{", "block", "}", ",", "nil", "\n", "}", "\n\n", "// Sort the entries and split them down the middle.", "names", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "block", ".", "Children", ")", ")", "\n", "for", "name", ":=", "range", "block", ".", "Children", "{", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n\n", "sort", ".", "Strings", "(", "names", ")", "\n", "// Delete the second half of the names from the original block,", "// and add to the new block.", "newBlock", ":=", "NewDirBlock", "(", ")", ".", "(", "*", "DirBlock", ")", "\n", "startOff", ":=", "int", "(", "len", "(", "names", ")", "/", "2", ")", "\n", "for", "_", ",", "name", ":=", "range", "names", "[", "int", "(", "len", "(", "names", ")", "/", "2", ")", ":", "]", "{", "newBlock", ".", "Children", "[", "name", "]", "=", "block", ".", "Children", "[", "name", "]", "\n", "delete", "(", "block", ".", "Children", ",", "name", ")", "\n", "}", "\n", "newOffset", ":=", "StringOffset", "(", "names", "[", "startOff", "]", ")", "\n", "return", "[", "]", "*", "DirBlock", "{", "block", ",", "newBlock", "}", ",", "&", "newOffset", "\n", "}" ]

[ "SplitDirIfNeeded", "implements", "the", "BlockSplitter", "interface", "for", "BlockSplitterSimple", "." ]

[ "func", "(", "l", "logf", ")", "Debugf", "(", "s", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "log", ".", "Debug", "(", "s", ",", "args", "...", ")", "\n", "}" ]

[ "Debugf", "forwards", "to", "Logger", ".", "Debug" ]

[ "func", "(", "l", "logf", ")", "Infof", "(", "s", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "log", ".", "Info", "(", "s", ",", "args", "...", ")", "\n", "}" ]

[ "Infof", "forwards", "to", "Logger", ".", "Info" ]

[ "func", "(", "l", "logf", ")", "Warningf", "(", "s", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "log", ".", "Warning", "(", "s", ",", "args", "...", ")", "\n", "}" ]

[ "Warningf", "forwards", "to", "Logger", ".", "Warning" ]

[ "func", "(", "l", "logf", ")", "Errorf", "(", "s", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "log", ".", "Errorf", "(", "s", ",", "args", "...", ")", "\n", "}" ]

[ "Errorf", "forwards", "to", "Logger", ".", "Errorf" ]

[ "func", "AddPerUserKeyServerArg", "(", "serverArg", "JSONPayload", ",", "generation", "keybase1", ".", "PerUserKeyGeneration", ",", "pukBoxes", "[", "]", "keybase1", ".", "PerUserKeyBox", ",", "pukPrev", "*", "PerUserKeyPrev", ")", "{", "section", ":=", "make", "(", "JSONPayload", ")", "\n", "section", "[", "\"", "\"", "]", "=", "pukBoxes", "\n", "section", "[", "\"", "\"", "]", "=", "generation", "\n", "if", "pukPrev", "!=", "nil", "{", "section", "[", "\"", "\"", "]", "=", "*", "pukPrev", "\n", "}", "\n", "serverArg", "[", "\"", "\"", "]", "=", "section", "\n", "}" ]

[ "Make", "the", "per_user_key", "section", "of", "an", "API", "arg", ".", "Requires", "one", "or", "more", "pukBoxes", "pukPrev", "is", "optional", ".", "Modifies", "serverArg", "." ]

[ "func", "AddUserEKReBoxServerArg", "(", "serverArg", "JSONPayload", ",", "arg", "*", "keybase1", ".", "UserEkReboxArg", ")", "{", "if", "arg", "==", "nil", "{", "return", "\n", "}", "\n", "serverArg", "[", "\"", "\"", "]", "=", "map", "[", "string", "]", "string", "{", "string", "(", "arg", ".", "DeviceID", ")", ":", "arg", ".", "DeviceEkStatementSig", "}", "\n", "serverArg", "[", "\"", "\"", "]", "=", "arg", ".", "UserEkBoxMetadata", "\n", "}" ]

[ "Make", "the", "user_ek_rebox", "and", "device_eks", "section", "of", "an", "API", "arg", ".", "Modifies", "serverArg", "unless", "arg", "is", "nil", "." ]

[ "func", "(", "h", "*", "ScanProofsHandler", ")", "ScanProofs", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "ScanProofsArg", ")", "error", "{", "uis", ":=", "libkb", ".", "UIs", "{", "LogUI", ":", "h", ".", "getLogUI", "(", "arg", ".", "SessionID", ")", ",", "SessionID", ":", "arg", ".", "SessionID", ",", "}", "\n", "eng", ":=", "engine", ".", "NewScanProofsEngine", "(", "arg", ".", "Infile", ",", "arg", ".", "Indices", ",", "arg", ".", "Sigid", ",", "arg", ".", "Ratelimit", ",", "arg", ".", "Cachefile", ",", "arg", ".", "Ignorefile", ",", "h", ".", "G", "(", ")", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "h", ".", "G", "(", ")", ")", ".", "WithUIs", "(", "uis", ")", "\n", "return", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", "\n", "}" ]

[ "ScanProofs", "creates", "a", "ScanProofsEngine", "and", "runs", "it", "." ]

[ "func", "New", "(", "signer", "Signer", ",", "region", "Region", ",", "client", "...", "*", "http", ".", "Client", ")", "*", "S3", "{", "var", "httpclient", "*", "http", ".", "Client", "\n\n", "if", "len", "(", "client", ")", ">", "0", "{", "httpclient", "=", "client", "[", "0", "]", "\n", "}", "\n\n", "return", "&", "S3", "{", "Signer", ":", "signer", ",", "Region", ":", "region", ",", "AttemptStrategy", ":", "DefaultAttemptStrategy", ",", "client", ":", "httpclient", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "S3", ".", "Optional", "client", "argument", "allows", "for", "custom", "http", ".", "clients", "to", "be", "used", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "GetReader", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "(", "rc", "io", ".", "ReadCloser", ",", "err", "error", ")", "{", "resp", ",", "err", ":=", "b", ".", "GetResponse", "(", "ctx", ",", "path", ")", "\n", "if", "resp", "!=", "nil", "{", "return", "resp", ".", "Body", ",", "err", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}" ]

[ "GetReader", "retrieves", "an", "object", "from", "an", "S3", "bucket", "returning", "the", "body", "of", "the", "HTTP", "response", ".", "It", "is", "the", "caller", "s", "responsibility", "to", "call", "Close", "on", "rc", "when", "finished", "reading", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "GetReaderWithRange", "(", "ctx", "context", ".", "Context", ",", "path", "string", ",", "begin", ",", "end", "int64", ")", "(", "rc", "io", ".", "ReadCloser", ",", "err", "error", ")", "{", "header", ":=", "make", "(", "http", ".", "Header", ")", "\n", "header", ".", "Add", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "begin", ",", "end", "-", "1", ")", ")", "\n", "resp", ",", "err", ":=", "b", ".", "GetResponseWithHeaders", "(", "ctx", ",", "path", ",", "header", ")", "\n", "if", "resp", "!=", "nil", "{", "return", "resp", ".", "Body", ",", "err", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}" ]

[ "GetReaderWithRange", "retrieves", "an", "object", "from", "an", "S3", "bucket", "using", "the", "specified", "range", "returning", "the", "body", "of", "the", "HTTP", "response", ".", "It", "is", "the", "caller", "s", "responsibility", "to", "call", "Close", "on", "rc", "when", "finished", "reading", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "GetResponse", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "(", "resp", "*", "http", ".", "Response", ",", "err", "error", ")", "{", "return", "b", ".", "GetResponseWithHeaders", "(", "ctx", ",", "path", ",", "make", "(", "http", ".", "Header", ")", ")", "\n", "}" ]

[ "GetResponse", "retrieves", "an", "object", "from", "an", "S3", "bucket", "returning", "the", "HTTP", "response", ".", "It", "is", "the", "caller", "s", "responsibility", "to", "call", "Close", "on", "rc", "when", "finished", "reading" ]

[ "func", "(", "b", "*", "Bucket", ")", "GetResponseWithHeaders", "(", "ctx", "context", ".", "Context", ",", "path", "string", ",", "headers", "map", "[", "string", "]", "[", "]", "string", ")", "(", "resp", "*", "http", ".", "Response", ",", "err", "error", ")", "{", "req", ":=", "&", "request", "{", "bucket", ":", "b", ".", "Name", ",", "path", ":", "path", ",", "headers", ":", "headers", ",", "}", "\n", "err", "=", "b", ".", "S3", ".", "prepare", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "attempt", ":=", "b", ".", "S3", ".", "AttemptStrategy", ".", "Start", "(", ")", ";", "attempt", ".", "Next", "(", ")", ";", "{", "resp", ",", "err", ":=", "b", ".", "S3", ".", "run", "(", "ctx", ",", "req", ",", "nil", ")", "\n", "if", "shouldRetry", "(", "err", ")", "&&", "attempt", ".", "HasNext", "(", ")", "{", "continue", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "resp", ",", "nil", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetReaderWithHeaders", "retrieves", "an", "object", "from", "an", "S3", "bucket", "Accepts", "custom", "headers", "to", "be", "sent", "as", "the", "second", "parameter", "returning", "the", "body", "of", "the", "HTTP", "response", ".", "It", "is", "the", "caller", "s", "responsibility", "to", "call", "Close", "on", "rc", "when", "finished", "reading" ]

[ "func", "(", "b", "*", "Bucket", ")", "Exists", "(", "path", "string", ")", "(", "exists", "bool", ",", "err", "error", ")", "{", "req", ":=", "&", "request", "{", "method", ":", "\"", "\"", ",", "bucket", ":", "b", ".", "Name", ",", "path", ":", "path", ",", "}", "\n", "err", "=", "b", ".", "S3", ".", "prepare", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "for", "attempt", ":=", "b", ".", "S3", ".", "AttemptStrategy", ".", "Start", "(", ")", ";", "attempt", ".", "Next", "(", ")", ";", "{", "resp", ",", "err", ":=", "b", ".", "S3", ".", "run", "(", "context", ".", "Background", "(", ")", ",", "req", ",", "nil", ")", "\n\n", "if", "shouldRetry", "(", "err", ")", "&&", "attempt", ".", "HasNext", "(", ")", "{", "continue", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "// We can treat a 403 or 404 as non existence", "if", "e", ",", "ok", ":=", "err", ".", "(", "*", "Error", ")", ";", "ok", "&&", "(", "e", ".", "StatusCode", "==", "403", "||", "e", ".", "StatusCode", "==", "404", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "resp", ".", "StatusCode", "/", "100", "==", "2", "{", "exists", "=", "true", "\n", "}", "\n", "return", "exists", ",", "err", "\n", "}", "\n", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "Exists", "checks", "whether", "or", "not", "an", "object", "exists", "on", "an", "S3", "bucket", "using", "a", "HEAD", "request", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "PutCopy", "(", "path", "string", ",", "perm", "ACL", ",", "options", "CopyOptions", ",", "source", "string", ")", "(", "result", "*", "CopyObjectResult", ",", "err", "error", ")", "{", "headers", ":=", "map", "[", "string", "]", "[", "]", "string", "{", "\"", "\"", ":", "{", "string", "(", "perm", ")", "}", ",", "\"", "\"", ":", "{", "source", "}", ",", "}", "\n", "options", ".", "addHeaders", "(", "headers", ")", "\n", "req", ":=", "&", "request", "{", "method", ":", "\"", "\"", ",", "bucket", ":", "b", ".", "Name", ",", "path", ":", "path", ",", "headers", ":", "headers", ",", "}", "\n", "result", "=", "&", "CopyObjectResult", "{", "}", "\n", "for", "attempt", ":=", "b", ".", "S3", ".", "AttemptStrategy", ".", "Start", "(", ")", ";", "attempt", ".", "Next", "(", ")", ";", "{", "err", "=", "b", ".", "S3", ".", "query", "(", "context", ".", "Background", "(", ")", ",", "req", ",", "result", ")", "\n", "if", "!", "shouldRetry", "(", "err", ")", "{", "break", "\n", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "PutCopy", "puts", "a", "copy", "of", "an", "object", "given", "by", "the", "key", "path", "into", "bucket", "b", "using", "b", ".", "Path", "as", "the", "target", "key" ]

[ "func", "(", "b", "*", "Bucket", ")", "PutReader", "(", "ctx", "context", ".", "Context", ",", "path", "string", ",", "r", "io", ".", "Reader", ",", "length", "int64", ",", "contType", "string", ",", "perm", "ACL", ",", "options", "Options", ")", "error", "{", "headers", ":=", "map", "[", "string", "]", "[", "]", "string", "{", "\"", "\"", ":", "{", "strconv", ".", "FormatInt", "(", "length", ",", "10", ")", "}", ",", "\"", "\"", ":", "{", "contType", "}", ",", "\"", "\"", ":", "{", "string", "(", "perm", ")", "}", ",", "}", "\n", "options", ".", "addHeaders", "(", "headers", ")", "\n", "req", ":=", "&", "request", "{", "method", ":", "\"", "\"", ",", "bucket", ":", "b", ".", "Name", ",", "path", ":", "path", ",", "headers", ":", "headers", ",", "payload", ":", "r", ",", "}", "\n", "return", "b", ".", "S3", ".", "query", "(", "ctx", ",", "req", ",", "nil", ")", "\n", "}" ]

[ "PutReader", "inserts", "an", "object", "into", "the", "S3", "bucket", "by", "consuming", "data", "from", "r", "until", "EOF", "." ]

[ "func", "(", "b", "*", "Bucket", ")", "GetBucketContents", "(", ")", "(", "*", "map", "[", "string", "]", "Key", ",", "error", ")", "{", "bucketContents", ":=", "map", "[", "string", "]", "Key", "{", "}", "\n", "prefix", ":=", "\"", "\"", "\n", "pathSeparator", ":=", "\"", "\"", "\n", "marker", ":=", "\"", "\"", "\n", "for", "{", "contents", ",", "err", ":=", "b", ".", "List", "(", "prefix", ",", "pathSeparator", ",", "marker", ",", "1000", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "bucketContents", ",", "err", "\n", "}", "\n", "for", "_", ",", "key", ":=", "range", "contents", ".", "Contents", "{", "bucketContents", "[", "key", ".", "Key", "]", "=", "key", "\n", "}", "\n", "if", "contents", ".", "IsTruncated", "{", "marker", "=", "contents", ".", "NextMarker", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n\n", "return", "&", "bucketContents", ",", "nil", "\n", "}" ]

[ "Returns", "a", "mapping", "of", "all", "key", "names", "in", "this", "bucket", "to", "Key", "objects" ]

[ "func", "(", "s3", "*", "S3", ")", "prepare", "(", "req", "*", "request", ")", "error", "{", "var", "signpath", "=", "req", ".", "path", "\n\n", "if", "!", "req", ".", "prepared", "{", "req", ".", "prepared", "=", "true", "\n", "if", "req", ".", "method", "==", "\"", "\"", "{", "req", ".", "method", "=", "\"", "\"", "\n", "}", "\n", "// Copy so they can be mutated without affecting on retries.", "params", ":=", "make", "(", "url", ".", "Values", ")", "\n", "headers", ":=", "make", "(", "http", ".", "Header", ")", "\n", "for", "k", ",", "v", ":=", "range", "req", ".", "params", "{", "params", "[", "k", "]", "=", "v", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "req", ".", "headers", "{", "headers", "[", "k", "]", "=", "v", "\n", "}", "\n", "req", ".", "params", "=", "params", "\n", "req", ".", "headers", "=", "headers", "\n", "if", "!", "strings", ".", "HasPrefix", "(", "req", ".", "path", ",", "\"", "\"", ")", "{", "req", ".", "path", "=", "\"", "\"", "+", "req", ".", "path", "\n", "}", "\n", "signpath", "=", "req", ".", "path", "\n", "if", "req", ".", "bucket", "!=", "\"", "\"", "{", "req", ".", "baseurl", "=", "s3", ".", "Region", ".", "S3BucketEndpoint", "\n", "if", "req", ".", "baseurl", "==", "\"", "\"", "{", "// Use the path method to address the bucket.", "req", ".", "baseurl", "=", "s3", ".", "Region", ".", "S3Endpoint", "\n", "req", ".", "path", "=", "\"", "\"", "+", "req", ".", "bucket", "+", "req", ".", "path", "\n", "}", "else", "{", "// Just in case, prevent injection.", "if", "strings", ".", "IndexAny", "(", "req", ".", "bucket", ",", "\"", "\"", ")", ">=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "req", ".", "bucket", ")", "\n", "}", "\n", "req", ".", "baseurl", "=", "strings", ".", "Replace", "(", "req", ".", "baseurl", ",", "\"", "\"", ",", "req", ".", "bucket", ",", "-", "1", ")", "\n", "}", "\n", "signpath", "=", "\"", "\"", "+", "req", ".", "bucket", "+", "signpath", "\n", "}", "\n", "}", "\n\n", "// Always sign again as it's not clear how far the", "// server has handled a previous attempt.", "u", ",", "err", ":=", "url", ".", "Parse", "(", "req", ".", "baseurl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "req", ".", "baseurl", ",", "err", ")", "\n", "}", "\n", "reqSignpathSpaceFix", ":=", "(", "&", "url", ".", "URL", "{", "Path", ":", "signpath", "}", ")", ".", "String", "(", ")", "\n", "req", ".", "headers", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "u", ".", "Host", "}", "\n", "req", ".", "headers", "[", "\"", "\"", "]", "=", "[", "]", "string", "{", "time", ".", "Now", "(", ")", ".", "In", "(", "time", ".", "UTC", ")", ".", "Format", "(", "time", ".", "RFC1123", ")", "}", "\n", "return", "s3", ".", "sign", "(", "req", ".", "method", ",", "reqSignpathSpaceFix", ",", "req", ".", "params", ",", "req", ".", "headers", ")", "\n", "}" ]

[ "prepare", "sets", "up", "req", "to", "be", "delivered", "to", "S3", "." ]

[ "func", "(", "fi", "*", "FileInfo", ")", "getRequestorToken", "(", ")", "(", "syscall", ".", "Token", ",", "error", ")", "{", "hdl", ":=", "syscall", ".", "Handle", "(", "C", ".", "kbfsLibdokan_OpenRequestorToken", "(", "fi", ".", "ptr", ")", ")", "\n", "var", "err", "error", "\n", "if", "hdl", "==", "syscall", ".", "InvalidHandle", "{", "// Tokens are value types, so returning nil is impossible,", "// returning an InvalidHandle is the best way.", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "syscall", ".", "Token", "(", "hdl", ")", ",", "err", "\n", "}" ]

[ "getRequestorToken", "returns", "the", "syscall", ".", "Token", "associated", "with", "the", "requestor", "of", "this", "file", "system", "operation", ".", "Remember", "to", "call", "Close", "on", "the", "Token", "." ]

[ "func", "(", "fi", "*", "FileInfo", ")", "isRequestorUserSidEqualTo", "(", "sid", "*", "winacl", ".", "SID", ")", "bool", "{", "tok", ",", "err", ":=", "fi", ".", "getRequestorToken", "(", ")", "\n", "if", "err", "!=", "nil", "{", "debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "defer", "tok", ".", "Close", "(", ")", "\n", "tokUser", ",", "err", ":=", "tok", ".", "GetTokenUser", "(", ")", "\n", "if", "err", "!=", "nil", "{", "debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "res", ",", "_", ",", "_", ":=", "syscall", ".", "Syscall", "(", "procEqualSid", ".", "Addr", "(", ")", ",", "2", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "sid", ")", ")", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "tokUser", ".", "User", ".", "Sid", ")", ")", ",", "0", ")", "\n", "if", "isDebug", "{", "u1", ",", "_", ":=", "(", "*", "syscall", ".", "SID", ")", "(", "sid", ")", ".", "String", "(", ")", "\n", "u2", ",", "_", ":=", "tokUser", ".", "User", ".", "Sid", ".", "String", "(", ")", "\n", "debugf", "(", "\"", "\\n", "\"", ",", "u1", ",", "u2", ",", "res", ")", "\n", "}", "\n", "runtime", ".", "KeepAlive", "(", "sid", ")", "\n", "runtime", ".", "KeepAlive", "(", "tokUser", ".", "User", ".", "Sid", ")", "\n", "return", "res", "!=", "0", "\n", "}" ]

[ "isRequestorUserSidEqualTo", "returns", "true", "if", "the", "sid", "passed", "as", "the", "argument", "is", "equal", "to", "the", "sid", "of", "the", "user", "associated", "with", "the", "filesystem", "request", "." ]

[ "func", "unmount", "(", "path", "string", ")", "error", "{", "debug", "(", "\"", "\"", ")", "\n", "res", ":=", "C", ".", "kbfsLibdokan_RemoveMountPoint", "(", "(", "*", "C", ".", "WCHAR", ")", "(", "stringToUtf16Ptr", "(", "path", ")", ")", ")", "\n", "if", "res", "==", "C", ".", "FALSE", "{", "debug", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "unmount", "a", "drive", "mounted", "by", "dokan", "." ]

[ "func", "stringToUtf16Buffer", "(", "s", "string", ",", "ptr", "C", ".", "LPWSTR", ",", "blenUcs2", "C", ".", "DWORD", ")", "bool", "{", "return", "stringToUtf16BufferPtr", "(", "s", ",", "unsafe", ".", "Pointer", "(", "ptr", ")", ",", "blenUcs2", ")", "\n", "}" ]

[ "stringToUtf16Buffer", "pokes", "a", "string", "into", "a", "Windows", "wide", "string", "buffer", ".", "On", "overflow", "does", "not", "poke", "anything", "and", "returns", "false", "." ]

[ "func", "stringToUtf16Ptr", "(", "s", "string", ")", "unsafe", ".", "Pointer", "{", "tmp", ":=", "utf16", ".", "Encode", "(", "[", "]", "rune", "(", "s", "+", "\"", "\\000", "\"", ")", ")", "\n", "return", "unsafe", ".", "Pointer", "(", "&", "tmp", "[", "0", "]", ")", "\n", "}" ]

[ "stringToUtf16Ptr", "return", "a", "pointer", "to", "the", "string", "as", "utf16", "with", "zero", "termination", "." ]

[ "func", "StringToRunMode", "(", "s", "string", ")", "(", "RunMode", ",", "error", ")", "{", "switch", "s", "{", "case", "string", "(", "DevelRunMode", ")", ":", "return", "DevelRunMode", ",", "nil", "\n", "case", "string", "(", "ProductionRunMode", ")", ":", "return", "ProductionRunMode", ",", "nil", "\n", "case", "string", "(", "StagingRunMode", ")", ":", "return", "StagingRunMode", ",", "nil", "\n", "case", "\"", "\"", ":", "return", "NoRunMode", ",", "nil", "\n", "default", ":", "return", "NoRunMode", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "}" ]

[ "StringToRunMode", "turns", "a", "string", "into", "a", "run", "-", "mode" ]

[ "func", "(", "c", "*", "CmdListTrackers", ")", "ParseArgv", "(", "ctx", "*", "cli", ".", "Context", ")", "error", "{", "if", "len", "(", "ctx", ".", "Args", "(", ")", ")", "==", "1", "{", "c", ".", "assertion", "=", "ctx", ".", "Args", "(", ")", "[", "0", "]", "\n", "}", "\n\n", "c", ".", "verbose", "=", "ctx", ".", "Bool", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "ParseArgv", "parses", "the", "command", "args", "." ]

[ "func", "(", "c", "*", "CmdListTrackers", ")", "GetUsage", "(", ")", "libkb", ".", "Usage", "{", "return", "libkb", ".", "Usage", "{", "Config", ":", "true", ",", "API", ":", "true", ",", "}", "\n", "}" ]

[ "GetUsage", "says", "what", "this", "command", "needs", "to", "operate", "." ]

[ "func", "LockedLocalSecretKey", "(", "m", "MetaContext", ",", "ska", "SecretKeyArg", ")", "(", "*", "SKB", ",", "error", ")", "{", "var", "ret", "*", "SKB", "\n", "me", ":=", "ska", ".", "Me", "\n\n", "keyring", ",", "err", ":=", "m", ".", "Keyring", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "keyring", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "NoKeyringsError", "{", "}", "\n", "}", "\n\n", "ckf", ":=", "me", ".", "GetComputedKeyFamily", "(", ")", "\n", "if", "ckf", "==", "nil", "{", "m", ".", "Warning", "(", "\"", "\"", ",", "me", ".", "name", ")", "\n", "return", "nil", ",", "KeyFamilyError", "{", "Msg", ":", "\"", "\"", "+", "me", ".", "name", "}", "\n", "}", "\n\n", "if", "(", "ska", ".", "KeyType", "==", "DeviceSigningKeyType", ")", "||", "(", "ska", ".", "KeyType", "==", "DeviceEncryptionKeyType", ")", "{", "key", ",", "err", ":=", "getDeviceKey", "(", "m", ",", "ckf", ",", "ska", ".", "KeyType", ",", "me", ".", "GetNormalizedName", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "key", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "NoKeyError", "{", "Msg", ":", "\"", "\"", "}", "\n", "}", "\n\n", "kid", ":=", "key", ".", "GetKID", "(", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ",", "kid", ")", "\n", "ret", "=", "keyring", ".", "LookupByKid", "(", "kid", ")", "\n", "if", "ret", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "kid", ")", "\n", "}", "\n", "}", "else", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "blocks", ":=", "keyring", ".", "SearchWithComputedKeyFamily", "(", "ckf", ",", "ska", ")", "\n", "if", "len", "(", "blocks", ")", ">", "0", "{", "ret", "=", "blocks", "[", "0", "]", "\n", "}", "\n", "}", "\n\n", "if", "ret", "!=", "nil", "{", "ret", ".", "SetUID", "(", "me", ".", "GetUID", "(", ")", ")", "\n", "}", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "LockedLocalSecretKey", "looks", "in", "the", "local", "keyring", "to", "find", "a", "key", "for", "the", "given", "user", ".", "Returns", "non", "-", "nil", "if", "one", "was", "found", "and", "nil", "otherwise", "." ]

[ "func", "(", "k", "*", "Keyrings", ")", "GetSecretKeyLocked", "(", "m", "MetaContext", ",", "ska", "SecretKeyArg", ")", "(", "ret", "*", "SKB", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "if", "ska", ".", "Me", "==", "nil", "{", "if", "ska", ".", "Me", ",", "err", "=", "LoadMe", "(", "NewLoadUserArg", "(", "k", ".", "G", "(", ")", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "ret", ",", "err", "=", "LockedLocalSecretKey", "(", "m", ",", "ska", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "ret", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "ret", ",", "nil", "\n", "}", "\n\n", "var", "pub", "GenericKey", "\n\n", "if", "ska", ".", "KeyType", "!=", "PGPKeyType", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "err", "=", "NoSecretKeyError", "{", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "ret", ",", "err", "=", "ska", ".", "Me", ".", "SyncedSecretKey", "(", "m", ")", ";", "err", "!=", "nil", "{", "m", ".", "Warning", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "if", "ret", "==", "nil", "{", "err", "=", "NoSecretKeyError", "{", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "pub", ",", "err", "=", "ret", ".", "GetPubKey", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "!", "KeyMatchesQuery", "(", "pub", ",", "ska", ".", "KeyQuery", ",", "ska", ".", "ExactMatch", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "ska", ".", "KeyQuery", ")", "\n", "err", "=", "NoSecretKeyError", "{", "}", "\n", "return", "nil", ",", "err", "\n\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "GetSecretKeyLocked", "gets", "a", "secret", "key", "for", "the", "current", "user", "by", "first", "looking", "for", "keys", "synced", "from", "the", "server", "and", "if", "that", "fails", "tries", "those", "in", "the", "local", "Keyring", "that", "are", "also", "active", "for", "the", "user", ".", "In", "any", "case", "the", "key", "will", "be", "locked", "." ]

[ "func", "NewSharedKeybaseConnection", "(", "kbCtx", "Context", ",", "config", "Config", ",", "handler", "rpc", ".", "ConnectionHandler", ")", "*", "rpc", ".", "Connection", "{", "transport", ":=", "&", "SharedKeybaseTransport", "{", "kbCtx", ":", "kbCtx", "}", "\n", "constBackoff", ":=", "backoff", ".", "NewConstantBackOff", "(", "RPCReconnectInterval", ")", "\n", "opts", ":=", "rpc", ".", "ConnectionOpts", "{", "WrapErrorFunc", ":", "libkb", ".", "WrapError", ",", "TagsFunc", ":", "libkb", ".", "LogTagsFromContext", ",", "ReconnectBackoff", ":", "func", "(", ")", "backoff", ".", "BackOff", "{", "return", "constBackoff", "}", ",", "}", "\n", "return", "rpc", ".", "NewConnectionWithTransport", "(", "handler", ",", "transport", ",", "libkb", ".", "ErrorUnwrapper", "{", "}", ",", "logger", ".", "LogOutputWithDepthAdder", "{", "Logger", ":", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "}", ",", "opts", ")", "\n", "}" ]

[ "NewSharedKeybaseConnection", "returns", "a", "connection", "that", "tries", "to", "connect", "to", "the", "local", "keybase", "daemon", "." ]

[ "func", "(", "kt", "*", "SharedKeybaseTransport", ")", "Dial", "(", "ctx", "context", ".", "Context", ")", "(", "rpc", ".", "Transporter", ",", "error", ")", "{", "_", ",", "transport", ",", "_", ",", "err", ":=", "kt", ".", "kbCtx", ".", "GetSocket", "(", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "kt", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "kt", ".", "mutex", ".", "Unlock", "(", ")", "\n", "kt", ".", "stagedTransport", "=", "transport", "\n", "return", "transport", ",", "nil", "\n", "}" ]

[ "Dial", "is", "an", "implementation", "of", "the", "ConnectionTransport", "interface", "." ]

[ "func", "(", "kt", "*", "SharedKeybaseTransport", ")", "IsConnected", "(", ")", "bool", "{", "kt", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "kt", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "kt", ".", "transport", "!=", "nil", "&&", "kt", ".", "transport", ".", "IsConnected", "(", ")", "\n", "}" ]

[ "IsConnected", "is", "an", "implementation", "of", "the", "ConnectionTransport", "interface", "." ]

[ "func", "(", "kt", "*", "SharedKeybaseTransport", ")", "Finalize", "(", ")", "{", "kt", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "kt", ".", "mutex", ".", "Unlock", "(", ")", "\n", "kt", ".", "transport", "=", "kt", ".", "stagedTransport", "\n", "kt", ".", "stagedTransport", "=", "nil", "\n", "}" ]

[ "Finalize", "is", "an", "implementation", "of", "the", "ConnectionTransport", "interface", "." ]

[ "func", "NewMDOpsStandard", "(", "config", "Config", ")", "*", "MDOpsStandard", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "return", "&", "MDOpsStandard", "{", "config", ":", "config", ",", "log", ":", "log", ",", "vlog", ":", "config", ".", "MakeVLogger", "(", "log", ")", ",", "leafChainsValidated", ":", "make", "(", "map", "[", "tlf", ".", "ID", "]", "map", "[", "kbfsmd", ".", "Revision", "]", "kbfsmd", ".", "Revision", ")", ",", "}", "\n", "}" ]

[ "NewMDOpsStandard", "returns", "a", "new", "MDOpsStandard" ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "convertVerifyingKeyError", "(", "ctx", "context", ".", "Context", ",", "rmds", "*", "RootMetadataSigned", ",", "handle", "*", "tlfhandle", ".", "Handle", ",", "err", "error", ")", "error", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "VerifyingKeyNotFoundError", ")", ";", "!", "ok", "{", "return", "err", "\n", "}", "\n\n", "tlf", ":=", "handle", ".", "GetCanonicalPath", "(", ")", "\n", "writer", ",", "nameErr", ":=", "md", ".", "config", ".", "KBPKI", "(", ")", ".", "GetNormalizedUsername", "(", "ctx", ",", "rmds", ".", "MD", ".", "LastModifyingWriter", "(", ")", ".", "AsUserOrTeam", "(", ")", ",", "md", ".", "config", ".", "OfflineAvailabilityForPath", "(", "tlf", ")", ")", "\n", "if", "nameErr", "!=", "nil", "{", "writer", "=", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", "+", "rmds", ".", "MD", ".", "LastModifyingWriter", "(", ")", ".", "String", "(", ")", ")", "\n", "}", "\n", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "rmds", ".", "MD", ".", "TlfID", "(", ")", ",", "err", ")", "\n", "return", "UnverifiableTlfUpdateError", "{", "tlf", ",", "writer", ",", "err", "}", "\n", "}" ]

[ "convertVerifyingKeyError", "gives", "a", "better", "error", "when", "the", "TLF", "was", "signed", "by", "a", "key", "that", "is", "no", "longer", "associated", "with", "the", "last", "writer", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "startOfValidatedChainForLeaf", "(", "tlfID", "tlf", ".", "ID", ",", "leafRev", "kbfsmd", ".", "Revision", ")", "kbfsmd", ".", "Revision", "{", "md", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "md", ".", "lock", ".", "Unlock", "(", ")", "\n", "revs", ",", "ok", ":=", "md", ".", "leafChainsValidated", "[", "tlfID", "]", "\n", "if", "!", "ok", "{", "return", "leafRev", "\n", "}", "\n", "min", ",", "ok", ":=", "revs", "[", "leafRev", "]", "\n", "if", "!", "ok", "{", "return", "leafRev", "\n", "}", "\n", "return", "min", "\n", "}" ]

[ "startOfValidatedChainForLeaf", "returns", "the", "earliest", "revision", "in", "the", "chain", "leading", "up", "to", "leafRev", "that", "s", "been", "validated", "so", "far", ".", "If", "no", "validations", "have", "occurred", "yet", "it", "returns", "leafRev", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "GetIDForHandle", "(", "ctx", "context", ".", "Context", ",", "handle", "*", "tlfhandle", ".", "Handle", ")", "(", "id", "tlf", ".", "ID", ",", "err", "error", ")", "{", "mdcache", ":=", "md", ".", "config", ".", "MDCache", "(", ")", "\n", "id", ",", "err", "=", "mdcache", ".", "GetIDForHandle", "(", "handle", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "NoSuchTlfIDError", ":", "// Do the server-based lookup below.", "case", "nil", ":", "return", "id", ",", "nil", "\n", "default", ":", "return", "tlf", ".", "NullID", ",", "err", "\n", "}", "\n", "id", ",", "_", ",", "err", "=", "md", ".", "getForHandle", "(", "ctx", ",", "handle", ",", "kbfsmd", ".", "Merged", ",", "nil", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "kbfsmd", ".", "ServerErrorClassicTLFDoesNotExist", ":", "// The server thinks we should create an implicit team for this TLF.", "return", "tlf", ".", "NullID", ",", "nil", "\n", "case", "nil", ":", "default", ":", "return", "tlf", ".", "NullID", ",", "err", "\n", "}", "\n", "err", "=", "mdcache", ".", "PutIDForHandle", "(", "handle", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "tlf", ".", "NullID", ",", "err", "\n", "}", "\n", "return", "id", ",", "nil", "\n", "}" ]

[ "GetIDForHandle", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "GetForTLF", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "return", "md", ".", "getForTLF", "(", "ctx", ",", "id", ",", "kbfsmd", ".", "NullBranchID", ",", "kbfsmd", ".", "Merged", ",", "lockBeforeGet", ")", "\n", "}" ]

[ "GetForTLF", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "GetForTLFByTime", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "serverTime", "time", ".", "Time", ")", "(", "irmd", "ImmutableRootMetadata", ",", "err", "error", ")", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "serverTime", ")", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "serverTime", ",", "irmd", ".", "Revision", "(", ")", ")", "\n", "}", "else", "{", "md", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "serverTime", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "mdserv", ",", "err", ":=", "md", ".", "mdserver", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n", "rmds", ",", "err", ":=", "mdserv", ".", "GetForTLFByTime", "(", "ctx", ",", "id", ",", "serverTime", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "md", ".", "processSignedMD", "(", "ctx", ",", "id", ",", "kbfsmd", ".", "NullBranchID", ",", "rmds", ")", "\n", "}" ]

[ "GetForTLFByTime", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "GetUnmergedForTLF", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "return", "md", ".", "getForTLF", "(", "ctx", ",", "id", ",", "bid", ",", "kbfsmd", ".", "Unmerged", ",", "nil", ")", "\n", "}" ]

[ "GetUnmergedForTLF", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "GetRange", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "start", ",", "stop", "kbfsmd", ".", "Revision", ",", "lockBeforeGet", "*", "keybase1", ".", "LockID", ")", "(", "[", "]", "ImmutableRootMetadata", ",", "error", ")", "{", "return", "md", ".", "getRange", "(", "ctx", ",", "id", ",", "kbfsmd", ".", "NullBranchID", ",", "kbfsmd", ".", "Merged", ",", "start", ",", "stop", ",", "lockBeforeGet", ")", "\n", "}" ]

[ "GetRange", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "GetUnmergedRange", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ",", "start", ",", "stop", "kbfsmd", ".", "Revision", ")", "(", "[", "]", "ImmutableRootMetadata", ",", "error", ")", "{", "return", "md", ".", "getRange", "(", "ctx", ",", "id", ",", "bid", ",", "kbfsmd", ".", "Unmerged", ",", "start", ",", "stop", ",", "nil", ")", "\n", "}" ]

[ "GetUnmergedRange", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "Put", "(", "ctx", "context", ".", "Context", ",", "rmd", "*", "RootMetadata", ",", "verifyingKey", "kbfscrypto", ".", "VerifyingKey", ",", "lockContext", "*", "keybase1", ".", "LockContext", ",", "priority", "keybase1", ".", "MDPriority", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "if", "rmd", ".", "MergedStatus", "(", ")", "==", "kbfsmd", ".", "Unmerged", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "UnexpectedUnmergedPutError", "{", "}", "\n", "}", "\n", "return", "md", ".", "put", "(", "ctx", ",", "rmd", ",", "verifyingKey", ",", "lockContext", ",", "priority", ")", "\n", "}" ]

[ "Put", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "PutUnmerged", "(", "ctx", "context", ".", "Context", ",", "rmd", "*", "RootMetadata", ",", "verifyingKey", "kbfscrypto", ".", "VerifyingKey", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "rmd", ".", "SetUnmerged", "(", ")", "\n", "if", "rmd", ".", "BID", "(", ")", "==", "kbfsmd", ".", "NullBranchID", "{", "// new branch ID", "bid", ",", "err", ":=", "md", ".", "config", ".", "Crypto", "(", ")", ".", "MakeRandomBranchID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n", "rmd", ".", "SetBranchID", "(", "bid", ")", "\n", "}", "\n", "return", "md", ".", "put", "(", "ctx", ",", "rmd", ",", "verifyingKey", ",", "nil", ",", "keybase1", ".", "MDPriorityNormal", ")", "\n", "}" ]

[ "PutUnmerged", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "PruneBranch", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ")", "error", "{", "mdserv", ",", "err", ":=", "md", ".", "mdserver", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "mdserv", ".", "PruneBranch", "(", "ctx", ",", "id", ",", "bid", ")", "\n", "}" ]

[ "PruneBranch", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "(", "md", "*", "MDOpsStandard", ")", "ResolveBranch", "(", "ctx", "context", ".", "Context", ",", "id", "tlf", ".", "ID", ",", "bid", "kbfsmd", ".", "BranchID", ",", "_", "[", "]", "kbfsblock", ".", "ID", ",", "rmd", "*", "RootMetadata", ",", "verifyingKey", "kbfscrypto", ".", "VerifyingKey", ")", "(", "ImmutableRootMetadata", ",", "error", ")", "{", "// Put the MD first.", "irmd", ",", "err", ":=", "md", ".", "Put", "(", "ctx", ",", "rmd", ",", "verifyingKey", ",", "nil", ",", "keybase1", ".", "MDPriorityNormal", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "// Prune the branch ia the journal, if there is one. If the", "// client fails before this is completed, we'll need to check for", "// resolutions on the next restart (see KBFS-798).", "err", "=", "md", ".", "PruneBranch", "(", "ctx", ",", "id", ",", "bid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ImmutableRootMetadata", "{", "}", ",", "err", "\n", "}", "\n", "return", "irmd", ",", "nil", "\n", "}" ]

[ "ResolveBranch", "implements", "the", "MDOps", "interface", "for", "MDOpsStandard", "." ]

[ "func", "OutputSignatureSuccess", "(", "m", "libkb", ".", "MetaContext", ",", "fingerprint", "libkb", ".", "PGPFingerprint", ",", "owner", "*", "libkb", ".", "User", ",", "signatureTime", "time", ".", "Time", ")", "error", "{", "arg", ":=", "keybase1", ".", "OutputSignatureSuccessArg", "{", "Fingerprint", ":", "fingerprint", ".", "String", "(", ")", ",", "Username", ":", "owner", ".", "GetName", "(", ")", ",", "SignedAt", ":", "keybase1", ".", "TimeFromSeconds", "(", "signatureTime", ".", "Unix", "(", ")", ")", ",", "}", "\n", "return", "m", ".", "UIs", "(", ")", ".", "PgpUI", ".", "OutputSignatureSuccess", "(", "m", ".", "Ctx", "(", ")", ",", "arg", ")", "\n", "}" ]

[ "OutputSignatureSuccess", "prints", "the", "details", "of", "a", "successful", "verification", "." ]

[ "func", "OutputSignatureSuccessNonKeybase", "(", "m", "libkb", ".", "MetaContext", ",", "keyID", "uint64", ",", "signatureTime", "time", ".", "Time", ")", "error", "{", "arg", ":=", "keybase1", ".", "OutputSignatureSuccessNonKeybaseArg", "{", "KeyID", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "keyID", ")", ",", "SignedAt", ":", "keybase1", ".", "TimeFromSeconds", "(", "signatureTime", ".", "Unix", "(", ")", ")", ",", "}", "\n", "return", "m", ".", "UIs", "(", ")", ".", "PgpUI", ".", "OutputSignatureSuccessNonKeybase", "(", "m", ".", "Ctx", "(", ")", ",", "arg", ")", "\n", "}" ]

[ "OutputSignatureSuccessNonKeybase", "prints", "the", "details", "of", "successful", "signature", "verification", "when", "signing", "key", "is", "not", "known", "to", "keybase", "." ]

[ "func", "NewWalletUpkeepBackground", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "args", "*", "WalletUpkeepBackgroundArgs", ")", "*", "WalletUpkeepBackground", "{", "task", ":=", "NewBackgroundTask", "(", "g", ",", "&", "BackgroundTaskArgs", "{", "Name", ":", "\"", "\"", ",", "F", ":", "WalletUpkeepBackgroundRound", ",", "Settings", ":", "WalletUpkeepBackgroundSettings", ",", "testingMetaCh", ":", "args", ".", "testingMetaCh", ",", "testingRoundResCh", ":", "args", ".", "testingRoundResCh", ",", "}", ")", "\n", "return", "&", "WalletUpkeepBackground", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "args", ":", "args", ",", "// Install the task early so that Shutdown can be called before RunEngine.", "task", ":", "task", ",", "}", "\n", "}" ]

[ "NewWalletUpkeepBackground", "creates", "a", "WalletUpkeepBackground", "engine", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "UnboxThread", "(", "ctx", "context", ".", "Context", ",", "boxed", "chat1", ".", "ThreadViewBoxed", ",", "conv", "types", ".", "UnboxConversationInfo", ")", "(", "thread", "chat1", ".", "ThreadView", ",", "err", "error", ")", "{", "thread", "=", "chat1", ".", "ThreadView", "{", "Pagination", ":", "boxed", ".", "Pagination", ",", "}", "\n\n", "if", "thread", ".", "Messages", ",", "err", "=", "b", ".", "UnboxMessages", "(", "ctx", ",", "boxed", ".", "Messages", ",", "conv", ")", ";", "err", "!=", "nil", "{", "return", "chat1", ".", "ThreadView", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "thread", ",", "nil", "\n", "}" ]

[ "unboxThread", "transforms", "a", "chat1", ".", "ThreadViewBoxed", "to", "a", "keybase1", ".", "ThreadView", "." ]

[ "func", "dummySigningKey", "(", ")", "libkb", ".", "NaclSigningKeyPair", "{", "dummySigningKeyOnce", ".", "Do", "(", "func", "(", ")", "{", "var", "allZeroSecretKey", "[", "libkb", ".", "NaclSigningKeySecretSize", "]", "byte", "\n", "dummyKeypair", ",", "err", ":=", "libkb", ".", "MakeNaclSigningKeyPairFromSecret", "(", "allZeroSecretKey", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "dummySigningKeyPtr", "=", "&", "dummyKeypair", "\n", "}", ")", "\n", "return", "*", "dummySigningKeyPtr", "\n", "}" ]

[ "We", "use", "this", "constant", "key", "when", "we", "already", "have", "pairwiseMACs", "providing", "authentication", ".", "Creating", "a", "keypair", "requires", "a", "curve", "multiply", "so", "we", "cache", "it", "here", "in", "case", "someone", "uses", "it", "in", "a", "tight", "loop", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "BoxMessage", "(", "ctx", "context", ".", "Context", ",", "msg", "chat1", ".", "MessagePlaintext", ",", "membersType", "chat1", ".", "ConversationMembersType", ",", "signingKeyPair", "libkb", ".", "NaclSigningKeyPair", ",", "info", "*", "types", ".", "BoxerEncryptionInfo", ")", "(", "res", "chat1", ".", "MessageBoxed", ",", "err", "error", ")", "{", "defer", "b", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "tlfName", ":=", "msg", ".", "ClientHeader", ".", "TlfName", "\n", "if", "len", "(", "tlfName", ")", "==", "0", "{", "return", "res", ",", "NewBoxingError", "(", "\"", "\"", ",", "true", ")", "\n", "}", "\n", "version", ",", "err", ":=", "b", ".", "GetBoxedVersion", "(", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "if", "err", "=", "b", ".", "attachMerkleRoot", "(", "ctx", ",", "&", "msg", ",", "version", ")", ";", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "if", "info", "==", "nil", "{", "info", "=", "new", "(", "types", ".", "BoxerEncryptionInfo", ")", "\n", "if", "*", "info", ",", "err", "=", "b", ".", "GetEncryptionInfo", "(", "ctx", ",", "&", "msg", ",", "membersType", ",", "signingKeyPair", ")", ";", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "if", "len", "(", "msg", ".", "ClientHeader", ".", "TlfName", ")", "==", "0", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "tlfName", ",", "msg", ".", "ClientHeader", ".", "TlfName", ")", "\n", "return", "res", ",", "NewBoxingError", "(", "msg", ",", "true", ")", "\n", "}", "\n", "}", "\n", "boxed", ",", "err", ":=", "b", ".", "box", "(", "ctx", ",", "msg", ",", "info", ".", "Key", ",", "info", ".", "EphemeralSeed", ",", "info", ".", "SigningKeyPair", ",", "info", ".", "Version", ",", "info", ".", "PairwiseMACRecipients", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "NewBoxingError", "(", "err", ".", "Error", "(", ")", ",", "true", ")", "\n", "}", "\n", "return", "boxed", ",", "nil", "\n", "}" ]

[ "BoxMessage", "encrypts", "a", "keybase1", ".", "MessagePlaintext", "into", "a", "chat1", ".", "MessageBoxed", ".", "It", "finds", "the", "most", "recent", "key", "for", "the", "TLF", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "attachMerkleRoot", "(", "ctx", "context", ".", "Context", ",", "msg", "*", "chat1", ".", "MessagePlaintext", ",", "version", "chat1", ".", "MessageBoxedVersion", ")", "error", "{", "switch", "version", "{", "case", "chat1", ".", "MessageBoxedVersion_V1", ":", "if", "msg", ".", "ClientHeader", ".", "MerkleRoot", "!=", "nil", "{", "return", "NewBoxingError", "(", "\"", "\"", ",", "true", ")", "\n", "}", "\n", "case", "chat1", ".", "MessageBoxedVersion_V2", ",", "chat1", ".", "MessageBoxedVersion_V3", ",", "chat1", ".", "MessageBoxedVersion_V4", ":", "merkleRoot", ",", "err", ":=", "b", ".", "latestMerkleRoot", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NewBoxingError", "(", "err", ".", "Error", "(", ")", ",", "false", ")", "\n", "}", "\n", "msg", ".", "ClientHeader", ".", "MerkleRoot", "=", "merkleRoot", "\n", "if", "msg", ".", "ClientHeader", ".", "MerkleRoot", "==", "nil", "{", "return", "NewBoxingError", "(", "\"", "\"", ",", "false", ")", "\n", "}", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "version", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Attach", "a", "merkle", "root", "to", "the", "message", "to", "send", ".", "Modifies", "msg", ".", "For", "MessageBoxedV1", "makes", "sure", "there", "is", "no", "MR", ".", "For", "MessageBoxedV2", "attaches", "a", "MR", "that", "is", "no", "more", "out", "of", "date", "than", "ChatBoxerMerkleFreshness", "." ]