Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "cache", "*", "DiskBlockCacheLocal", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "{", "// Wait for the cache to either finish starting or error.", "select", "{", "case", "<-", "cache", ".", "startedCh", ":", "case", "<-", "cache", ".", "startErrCh", ":", "return", "\n", "}", "\n", "cache", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "cache", ".", "lock", ".", "Unlock", "(", ")", "\n", "// shutdownCh has to be checked under lock, otherwise we can race.", "select", "{", "case", "<-", "cache", ".", "shutdownCh", ":", "cache", ".", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ")", "\n", "default", ":", "}", "\n", "close", "(", "cache", ".", "shutdownCh", ")", "\n", "if", "cache", ".", "blockDb", "==", "nil", "{", "return", "\n", "}", "\n", "cache", ".", "closer", "(", ")", "\n", "cache", ".", "blockDb", "=", "nil", "\n", "cache", ".", "metaDb", "=", "nil", "\n", "cache", ".", "tlfDb", "=", "nil", "\n", "if", "cache", ".", "useLimiter", "(", ")", "{", "cache", ".", "config", ".", "DiskLimiter", "(", ")", ".", "onSimpleByteTrackerDisable", "(", "ctx", ",", "cache", ".", "cacheType", ",", "int64", "(", "cache", ".", "getCurrBytes", "(", ")", ")", ")", "\n", "}", "\n", "cache", ".", "hitMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "missMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "putMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "updateMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "evictCountMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "evictSizeMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "deleteCountMeter", ".", "Shutdown", "(", ")", "\n", "cache", ".", "deleteSizeMeter", ".", "Shutdown", "(", ")", "\n", "}" ]

[ "Shutdown", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheLocal", "." ]

[ "func", "ParseSeitanTokenFromPaste", "(", "token", "string", ")", "(", "string", ",", "bool", ")", "{", "// If the person pasted the whole seitan SMS message in, then let's parse out the token", "if", "strings", ".", "Contains", "(", "token", ",", "\"", "\"", ")", "{", "m", ":=", "tokenPasteRegexp", ".", "FindStringSubmatch", "(", "token", ")", "\n", "if", "len", "(", "m", ")", "==", "1", "{", "return", "strings", ".", "Split", "(", "m", "[", "0", "]", ",", "\"", "\"", ")", "[", "1", "]", ",", "true", "\n", "}", "\n", "return", "token", ",", "true", "\n", "}", "\n", "if", "IsSeitany", "(", "token", ")", "{", "return", "token", ",", "true", "\n", "}", "\n", "return", "token", ",", "false", "\n", "}" ]

[ "Returns", "the", "string", "that", "might", "be", "the", "token", "and", "whether", "the", "content", "looked", "like", "a", "token", "paste", "." ]

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

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

[ "func", "DumpExtraMetadata", "(", "codec", "kbfscodec", ".", "Codec", ",", "extra", "ExtraMetadata", ")", "(", "string", ",", "error", ")", "{", "var", "s", "string", "\n", "switch", "extra", ":=", "extra", ".", "(", "type", ")", "{", "case", "*", "ExtraMetadataV3", ":", "serializedWKB", ",", "err", ":=", "codec", ".", "Encode", "(", "extra", ".", "GetWriterKeyBundle", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "serializedRKB", ",", "err", ":=", "codec", ".", "Encode", "(", "extra", ".", "GetReaderKeyBundle", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "s", "=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\"", ",", "len", "(", "serializedWKB", ")", ",", "len", "(", "serializedRKB", ")", ")", "\n", "}", "\n\n", "s", "+=", "DumpConfig", "(", ")", ".", "Sdump", "(", "extra", ")", "\n", "return", "s", ",", "nil", "\n", "}" ]

[ "DumpExtraMetadata", "returns", "a", "detailed", "dump", "of", "the", "given", "ExtraMetadata", "s", "contents", "." ]

[ "func", "verifyMemberRoleInTeam", "(", "ctx", "context", ".", "Context", ",", "userID", "keybase1", ".", "UID", ",", "expectedRole", "keybase1", ".", "TeamRole", ",", "team", "*", "Team", ")", "(", "res", "keybase1", ".", "UserVersion", ",", "err", "error", ")", "{", "if", "expectedRole", "==", "keybase1", ".", "TeamRole_NONE", "{", "return", "res", ",", "nil", "\n", "}", "\n\n", "memberUV", ",", "err", ":=", "team", ".", "chain", "(", ")", ".", "GetLatestUVWithUID", "(", "userID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "role", ",", "err", ":=", "team", ".", "chain", "(", ")", ".", "GetUserRole", "(", "memberUV", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "if", "role", "!=", "expectedRole", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "expectedRole", ",", "role", ")", "\n", "}", "\n", "return", "memberUV", ",", "nil", "\n", "}" ]

[ "verifyMemberRoleInTeam", "checks", "if", "role", "give", "in", "MemberInfo", "matches", "what", "team", "chain", "says", ".", "Nothing", "is", "checked", "when", "MemberInfo", "s", "role", "is", "NONE", "in", "this", "context", "it", "means", "that", "user", "has", "implied", "membership", "in", "the", "team", "and", "no", "role", "given", "in", "sigchain", "." ]

[ "func", "IDFromString", "(", "idStr", "string", ")", "(", "ID", ",", "error", ")", "{", "h", ",", "err", ":=", "kbfshash", ".", "HashFromString", "(", "idStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "return", "ID", "{", "h", "}", ",", "nil", "\n", "}" ]

[ "IDFromString", "creates", "a", "ID", "from", "the", "given", "string", ".", "If", "the", "returned", "error", "is", "nil", "the", "returned", "ID", "is", "valid", "." ]

[ "func", "IDFromBytes", "(", "idBytes", "[", "]", "byte", ")", "(", "ID", ",", "error", ")", "{", "h", ",", "err", ":=", "kbfshash", ".", "HashFromBytes", "(", "idBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "return", "ID", "{", "h", "}", ",", "nil", "\n", "}" ]

[ "IDFromBytes", "creates", "a", "ID", "from", "the", "given", "bytes", ".", "If", "the", "returned", "error", "is", "nil", "the", "returned", "ID", "is", "valid", "." ]

[ "func", "(", "id", "ID", ")", "MarshalBinary", "(", ")", "(", "data", "[", "]", "byte", ",", "err", "error", ")", "{", "return", "id", ".", "h", ".", "MarshalBinary", "(", ")", "\n", "}" ]

[ "MarshalBinary", "implements", "the", "encoding", ".", "BinaryMarshaler", "interface", "for", "ID", ".", "Returns", "an", "error", "if", "the", "ID", "is", "invalid", "and", "not", "the", "zero", "ID", "." ]

[ "func", "(", "id", "*", "ID", ")", "UnmarshalBinary", "(", "data", "[", "]", "byte", ")", "error", "{", "return", "id", ".", "h", ".", "UnmarshalBinary", "(", "data", ")", "\n", "}" ]

[ "UnmarshalBinary", "implements", "the", "encoding", ".", "BinaryUnmarshaler", "interface", "for", "ID", ".", "Returns", "an", "error", "if", "the", "given", "byte", "array", "is", "non", "-", "empty", "and", "the", "ID", "is", "invalid", "." ]

[ "func", "MakeTemporaryID", "(", ")", "(", "ID", ",", "error", ")", "{", "var", "dh", "kbfshash", ".", "RawDefaultHash", "\n", "err", ":=", "kbfscrypto", ".", "RandRead", "(", "dh", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "h", ",", "err", ":=", "kbfshash", ".", "HashFromRaw", "(", "kbfshash", ".", "DefaultHashType", ",", "dh", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "return", "ID", "{", "h", "}", ",", "nil", "\n", "}" ]

[ "MakeTemporaryID", "generates", "a", "temporary", "block", "ID", "using", "a", "CSPRNG", ".", "This", "is", "used", "for", "indirect", "blocks", "before", "they", "re", "committed", "to", "the", "server", "." ]

[ "func", "MakePermanentID", "(", "encodedEncryptedData", "[", "]", "byte", ",", "encryptionVer", "kbfscrypto", ".", "EncryptionVer", ")", "(", "ID", ",", "error", ")", "{", "h", ",", "err", ":=", "kbfshash", ".", "DoHash", "(", "encodedEncryptedData", ",", "encryptionVer", ".", "ToHashType", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n", "return", "ID", "{", "h", "}", ",", "nil", "\n", "}" ]

[ "MakePermanentID", "computes", "the", "permanent", "ID", "of", "a", "block", "given", "its", "encoded", "and", "encrypted", "contents", "." ]

[ "func", "VerifyID", "(", "encodedEncryptedData", "[", "]", "byte", ",", "id", "ID", ")", "error", "{", "return", "id", ".", "h", ".", "Verify", "(", "encodedEncryptedData", ")", "\n", "}" ]

[ "VerifyID", "verifies", "that", "the", "given", "block", "ID", "is", "the", "permanent", "block", "ID", "for", "the", "given", "encoded", "and", "encrypted", "data", "." ]

[ "func", "FakeID", "(", "b", "byte", ")", "ID", "{", "dh", ":=", "kbfshash", ".", "RawDefaultHash", "{", "b", "}", "\n", "h", ",", "err", ":=", "kbfshash", ".", "HashFromRaw", "(", "kbfshash", ".", "DefaultHashType", ",", "dh", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "ID", "{", "h", "}", "\n", "}" ]

[ "FakeID", "returns", "an", "ID", "derived", "from", "the", "given", "byte", "suitable", "for", "testing", "." ]

[ "func", "FakeIDAdd", "(", "id", "ID", ",", "b", "byte", ")", "ID", "{", "return", "FakeID", "(", "id", ".", "h", ".", "Bytes", "(", ")", "[", "1", "]", "+", "b", ")", "\n", "}" ]

[ "FakeIDAdd", "returns", "an", "ID", "derived", "from", "the", "given", "ID", "and", "the", "given", "byte", "suitable", "for", "testing", "." ]

[ "func", "(", "t", "TeamSigChainState", ")", "GetUserRoleAtSeqno", "(", "user", "keybase1", ".", "UserVersion", ",", "seqno", "keybase1", ".", "Seqno", ")", "(", "keybase1", ".", "TeamRole", ",", "error", ")", "{", "role", ":=", "keybase1", ".", "TeamRole_NONE", "\n", "if", "seqno", "<=", "0", "{", "return", "role", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "seqno", ")", "\n", "}", "\n", "for", "_", ",", "point", ":=", "range", "t", ".", "inner", ".", "UserLog", "[", "user", "]", "{", "if", "point", ".", "SigMeta", ".", "SigChainLocation", ".", "Seqno", ">", "seqno", "{", "return", "role", ",", "nil", "\n", "}", "\n", "role", "=", "point", ".", "Role", "\n", "}", "\n", "return", "role", ",", "nil", "\n", "}" ]

[ "Get", "the", "user", "s", "role", "right", "after", "link", "at", "seqno", "was", "processed", "." ]

[ "func", "findRoleDowngrade", "(", "points", "[", "]", "keybase1", ".", "UserLogPoint", ",", "role", "keybase1", ".", "TeamRole", ")", "*", "keybase1", ".", "SignatureMetadata", "{", "for", "_", ",", "p", ":=", "range", "points", "{", "if", "!", "p", ".", "Role", ".", "IsOrAbove", "(", "role", ")", "{", "return", "&", "p", ".", "SigMeta", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Find", "a", "point", "where", "the", "role", "is", "taken", "away", "." ]

[ "func", "(", "t", "TeamSigChainState", ")", "AssertWasRoleOrAboveAt", "(", "uv", "keybase1", ".", "UserVersion", ",", "role", "keybase1", ".", "TeamRole", ",", "scl", "keybase1", ".", "SigChainLocation", ")", "(", "err", "error", ")", "{", "mkErr", ":=", "func", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "error", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "format", ",", "args", "...", ")", "\n", "if", "role", ".", "IsOrAbove", "(", "keybase1", ".", "TeamRole_ADMIN", ")", "{", "return", "NewAdminPermissionError", "(", "t", ".", "GetID", "(", ")", ",", "uv", ",", "msg", ")", "\n", "}", "\n", "return", "NewPermissionError", "(", "t", ".", "GetID", "(", ")", ",", "uv", ",", "msg", ")", "\n", "}", "\n", "if", "scl", ".", "Seqno", "<", "keybase1", ".", "Seqno", "(", "0", ")", "{", "return", "mkErr", "(", "\"", "\"", ",", "scl", ".", "Seqno", ")", "\n", "}", "\n", "points", ":=", "t", ".", "inner", ".", "UserLog", "[", "uv", "]", "\n", "for", "i", ":=", "len", "(", "points", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "point", ":=", "points", "[", "i", "]", "\n", "if", "err", ":=", "point", ".", "SigMeta", ".", "SigChainLocation", ".", "Comparable", "(", "scl", ")", ";", "err", "!=", "nil", "{", "return", "mkErr", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "if", "point", ".", "SigMeta", ".", "SigChainLocation", ".", "LessThanOrEqualTo", "(", "scl", ")", "&&", "point", ".", "Role", ".", "IsOrAbove", "(", "role", ")", "{", "// OK great, we found a point with the role in the log that's less than or equal to the given one.", "// But now we reverse and go forward, and check that it wasn't revoked or downgraded.", "// If so, that's a problem!", "if", "right", ":=", "findRoleDowngrade", "(", "points", "[", "(", "i", "+", "1", ")", ":", "]", ",", "role", ")", ";", "right", "!=", "nil", "&&", "right", ".", "SigChainLocation", ".", "LessThanOrEqualTo", "(", "scl", ")", "{", "return", "mkErr", "(", "\"", "\"", ",", "role", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "mkErr", "(", "\"", "\"", ",", "role", ")", "\n", "}" ]

[ "AssertWasRoleOrAboveAt", "asserts", "that", "user", "uv", "had", "role", "or", "above", "on", "the", "team", "just", "after", "the", "given", "SigChainLocation", "scl", ".", "We", "start", "at", "the", "point", "given", "go", "backwards", "until", "we", "find", "a", "promotion", "then", "go", "forwards", "to", "make", "sure", "there", "wasn", "t", "a", "demotion", "before", "the", "specified", "time", ".", "If", "there", "was", "return", "a", "PermissionError", ".", "If", "no", "adminship", "was", "found", "at", "all", "return", "a", "PermissionError", "." ]

[ "func", "(", "t", "TeamSigChainState", ")", "IsLinkFilled", "(", "seqno", "keybase1", ".", "Seqno", ")", "bool", "{", "if", "seqno", ">", "t", ".", "inner", ".", "LastSeqno", "{", "return", "false", "\n", "}", "\n", "if", "seqno", "<", "0", "{", "return", "false", "\n", "}", "\n", "return", "!", "t", ".", "inner", ".", "StubbedLinks", "[", "seqno", "]", "\n", "}" ]

[ "Whether", "the", "link", "has", "been", "processed", "and", "is", "not", "stubbed", "." ]

[ "func", "(", "t", "*", "TeamSigChainState", ")", "inform", "(", "u", "keybase1", ".", "UserVersion", ",", "role", "keybase1", ".", "TeamRole", ",", "sigMeta", "keybase1", ".", "SignatureMetadata", ")", "{", "currentRole", ":=", "t", ".", "getUserRole", "(", "u", ")", "\n", "if", "currentRole", "==", "role", "{", "// no change in role, now new checkpoint needed", "return", "\n", "}", "\n", "t", ".", "inner", ".", "UserLog", "[", "u", "]", "=", "append", "(", "t", ".", "inner", ".", "UserLog", "[", "u", "]", ",", "keybase1", ".", "UserLogPoint", "{", "Role", ":", "role", ",", "SigMeta", ":", "sigMeta", ",", "}", ")", "\n", "}" ]

[ "Inform", "the", "UserLog", "of", "a", "user", "s", "role", ".", "Mutates", "the", "UserLog", ".", "Must", "be", "called", "with", "seqno", "s", "and", "events", "in", "correct", "order", ".", "Idempotent", "if", "called", "correctly", "." ]

[ "func", "(", "t", "*", "TeamSigChainState", ")", "ListSubteams", "(", ")", "(", "res", "[", "]", "keybase1", ".", "TeamIDAndName", ")", "{", "type", "Entry", "struct", "{", "ID", "keybase1", ".", "TeamID", "\n", "Name", "keybase1", ".", "TeamName", "\n", "// Seqno of the last cached rename of this team", "Seqno", "keybase1", ".", "Seqno", "\n", "}", "\n", "// Use a map to deduplicate names. If there is a subteam name", "// collision, take the one with the latest (parent) seqno", "// modifying its name.", "// A collision could occur if you were removed from a team", "// and miss its renaming or deletion to stubbing.", "resMap", ":=", "make", "(", "map", "[", "string", "]", "/*TeamName*/", "Entry", ")", "\n", "for", "subteamID", ",", "points", ":=", "range", "t", ".", "inner", ".", "SubteamLog", "{", "if", "len", "(", "points", ")", "==", "0", "{", "// this should never happen", "continue", "\n", "}", "\n", "lastPoint", ":=", "points", "[", "len", "(", "points", ")", "-", "1", "]", "\n", "if", "lastPoint", ".", "Name", ".", "IsNil", "(", ")", "{", "// the subteam has been deleted", "continue", "\n", "}", "\n", "entry", ":=", "Entry", "{", "ID", ":", "subteamID", ",", "Name", ":", "lastPoint", ".", "Name", ",", "Seqno", ":", "lastPoint", ".", "Seqno", ",", "}", "\n", "existing", ",", "ok", ":=", "resMap", "[", "entry", ".", "Name", ".", "String", "(", ")", "]", "\n", "replace", ":=", "!", "ok", "||", "(", "entry", ".", "Seqno", ">=", "existing", ".", "Seqno", ")", "\n", "if", "replace", "{", "resMap", "[", "entry", ".", "Name", ".", "String", "(", ")", "]", "=", "entry", "\n", "}", "\n", "}", "\n", "for", "_", ",", "entry", ":=", "range", "resMap", "{", "res", "=", "append", "(", "res", ",", "keybase1", ".", "TeamIDAndName", "{", "Id", ":", "entry", ".", "ID", ",", "Name", ":", "entry", ".", "Name", ",", "}", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "Only", "call", "this", "on", "a", "Team", "that", "has", "been", "loaded", "with", "NeedAdmin", ".", "Otherwise", "you", "might", "get", "incoherent", "answers", "due", "to", "links", "that", "were", "stubbed", "over", "the", "life", "of", "the", "cached", "object", ".", "For", "subteams", "that", "you", "were", "removed", "from", "this", "list", "may", "still", "include", "them", "because", "your", "removal", "was", "stubbed", ".", "The", "list", "will", "not", "contain", "duplicate", "names", ".", "Since", "this", "should", "only", "be", "called", "when", "you", "are", "an", "admin", "none", "of", "that", "should", "really", "come", "up", "but", "it", "s", "here", "just", "to", "be", "less", "fragile", "." ]

[ "func", "(", "t", "*", "TeamSigChainState", ")", "SubteamRenameOccurred", "(", "subteamID", "keybase1", ".", "TeamID", ",", "newName", "keybase1", ".", "TeamName", ",", "seqno", "keybase1", ".", "Seqno", ")", "error", "{", "points", ":=", "t", ".", "inner", ".", "SubteamLog", "[", "subteamID", "]", "\n", "if", "len", "(", "points", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "subteamID", ")", "\n", "}", "\n", "for", "_", ",", "point", ":=", "range", "points", "{", "if", "point", ".", "Seqno", "==", "seqno", "{", "if", "point", ".", "Name", ".", "LastPart", "(", ")", ".", "Eq", "(", "newName", ".", "LastPart", "(", ")", ")", "{", "// found it!", "return", "nil", "\n", "}", "\n", "}", "\n", "if", "point", ".", "Seqno", ">", "seqno", "{", "break", "\n", "}", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "subteamID", ",", "newName", ",", "seqno", ")", "\n", "}" ]

[ "Check", "that", "a", "subteam", "rename", "occurred", "just", "so", ".", "That", "the", "subteam", "subteamID", "got", "a", "new", "name", "newName", "at", "exactly", "seqno", "in", "this", "the", "parent", "chain", ".", "Note", "this", "only", "checks", "against", "the", "last", "part", "of", "newName", "because", "mid", "-", "team", "renames", "are", "such", "a", "pain", ".", "This", "is", "currently", "linear", "in", "the", "number", "of", "times", "that", "subteam", "has", "been", "renamed", ".", "It", "should", "be", "easy", "to", "add", "an", "index", "if", "need", "be", "." ]

[ "func", "InflateLink", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "reader", "keybase1", ".", "UserVersion", ",", "state", "TeamSigChainState", ",", "link", "*", "ChainLinkUnpacked", ",", "signer", "SignerX", ")", "(", "res", "TeamSigChainState", ",", "err", "error", ")", "{", "if", "link", ".", "isStubbed", "(", ")", "{", "return", "TeamSigChainState", "{", "}", ",", "NewStubbedError", "(", "link", ")", "\n", "}", "\n", "if", "link", ".", "Seqno", "(", ")", ">", "state", ".", "GetLatestSeqno", "(", ")", "{", "return", "TeamSigChainState", "{", "}", ",", "NewInflateErrorWithNote", "(", "link", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "link", ".", "Seqno", "(", ")", ",", "state", ".", "GetLatestSeqno", "(", ")", ")", ")", "\n", "}", "\n\n", "// Check the that the link id matches our stubbed record.", "seenLinkID", ",", "err", ":=", "state", ".", "GetLibkbLinkIDBySeqno", "(", "link", ".", "Seqno", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TeamSigChainState", "{", "}", ",", "err", "\n", "}", "\n", "if", "!", "seenLinkID", ".", "Eq", "(", "link", ".", "LinkID", "(", ")", ")", "{", "return", "TeamSigChainState", "{", "}", ",", "NewInflateErrorWithNote", "(", "link", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "link", ".", "LinkID", "(", ")", ".", "String", "(", ")", ",", "seenLinkID", ".", "String", "(", ")", ")", ")", "\n", "}", "\n\n", "// Check that the link has not already been inflated.", "if", "_", ",", "ok", ":=", "state", ".", "inner", ".", "StubbedLinks", "[", "link", ".", "Seqno", "(", ")", "]", ";", "!", "ok", "{", "return", "TeamSigChainState", "{", "}", ",", "NewInflateErrorWithNote", "(", "link", ",", "\"", "\"", ")", "\n", "}", "\n\n", "t", ":=", "&", "teamSigchainPlayer", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "reader", ":", "reader", ",", "}", "\n", "iRes", ",", "err", ":=", "t", ".", "addInnerLink", "(", "&", "state", ",", "link", ",", "signer", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TeamSigChainState", "{", "}", ",", "err", "\n", "}", "\n\n", "delete", "(", "iRes", ".", "newState", ".", "inner", ".", "StubbedLinks", ",", "link", ".", "Seqno", "(", ")", ")", "\n\n", "return", "iRes", ".", "newState", ",", "nil", "\n\n", "}" ]

[ "InflateLink", "adds", "the", "full", "inner", "link", "for", "a", "link", "that", "has", "already", "been", "added", "in", "stubbed", "form", ".", "state", "is", "moved", "into", "this", "function", ".", "There", "must", "exist", "no", "live", "references", "into", "it", "from", "now", "on", "." ]

[ "func", "(", "t", "*", "teamSigchainPlayer", ")", "appendChainLinkHelper", "(", "ctx", "context", ".", "Context", ",", "prevState", "*", "TeamSigChainState", ",", "link", "*", "ChainLinkUnpacked", ",", "signer", "*", "SignerX", ")", "(", "res", "TeamSigChainState", ",", "err", "error", ")", "{", "err", "=", "t", ".", "checkOuterLink", "(", "ctx", ",", "prevState", ",", "link", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "var", "newState", "*", "TeamSigChainState", "\n", "if", "link", ".", "isStubbed", "(", ")", "{", "if", "prevState", "==", "nil", "{", "return", "res", ",", "NewStubbedErrorWithNote", "(", "link", ",", "\"", "\"", ")", "\n", "}", "\n", "newState2", ":=", "prevState", ".", "DeepCopy", "(", ")", "\n", "newState", "=", "&", "newState2", "\n", "}", "else", "{", "if", "signer", "==", "nil", "||", "!", "signer", ".", "signer", ".", "Uid", ".", "Exists", "(", ")", "{", "return", "res", ",", "NewInvalidLink", "(", "link", ",", "\"", "\"", ")", "\n", "}", "\n", "iRes", ",", "err", ":=", "t", ".", "addInnerLink", "(", "prevState", ",", "link", ",", "*", "signer", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "newState", "=", "&", "iRes", ".", "newState", "\n", "}", "\n\n", "newState", ".", "inner", ".", "LastSeqno", "=", "link", ".", "Seqno", "(", ")", "\n", "newState", ".", "inner", ".", "LastLinkID", "=", "link", ".", "LinkID", "(", ")", ".", "Export", "(", ")", "\n", "newState", ".", "inner", ".", "LinkIDs", "[", "link", ".", "Seqno", "(", ")", "]", "=", "link", ".", "LinkID", "(", ")", ".", "Export", "(", ")", "\n\n", "if", "link", ".", "isStubbed", "(", ")", "{", "newState", ".", "inner", ".", "StubbedLinks", "[", "link", ".", "Seqno", "(", ")", "]", "=", "true", "\n", "}", "\n\n", "// Store the head merkle sequence to the DB, for use in the audit mechanism.", "// For the purposes of testing, we disable this feature, so we can check", "// the lazy-repopulation scheme for old stored teams (without a full cache bust).", "if", "link", ".", "Seqno", "(", ")", "==", "keybase1", ".", "Seqno", "(", "1", ")", "&&", "!", "link", ".", "isStubbed", "(", ")", "&&", "!", "t", ".", "G", "(", ")", ".", "Env", ".", "Test", ".", "TeamNoHeadMerkleStore", "{", "tmp", ":=", "link", ".", "inner", ".", "Body", ".", "MerkleRoot", ".", "ToMerkleRootV2", "(", ")", "\n", "newState", ".", "inner", ".", "HeadMerkle", "=", "&", "tmp", "\n", "}", "\n\n", "if", "!", "link", ".", "isStubbed", "(", ")", "&&", "newState", ".", "inner", ".", "MerkleRoots", "!=", "nil", "{", "newState", ".", "inner", ".", "MerkleRoots", "[", "link", ".", "Seqno", "(", ")", "]", "=", "link", ".", "inner", ".", "Body", ".", "MerkleRoot", ".", "ToMerkleRootV2", "(", ")", "\n", "}", "\n\n", "return", "*", "newState", ",", "nil", "\n", "}" ]

[ "Add", "a", "chain", "link", "to", "the", "end", ".", "prevState", "is", "moved", "into", "this", "function", ".", "There", "must", "exist", "no", "live", "references", "into", "it", "from", "now", "on", ".", "signer", "may", "be", "nil", "iff", "link", "is", "stubbed", ".", "If", "prevState", "is", "nil", "this", "is", "the", "first", "chain", "link", "." ]

[ "func", "(", "t", "*", "teamSigchainPlayer", ")", "roleUpdatesDemoteOwners", "(", "prev", "*", "TeamSigChainState", ",", "roleUpdates", "map", "[", "keybase1", ".", "TeamRole", "]", "[", "]", "keybase1", ".", "UserVersion", ")", "bool", "{", "// It is OK to readmit an owner if the owner reset and is coming in at a lower permission", "// level. So check that case here.", "readmittingResetUser", ":=", "func", "(", "uv", "keybase1", ".", "UserVersion", ")", "bool", "{", "for", "toRole", ",", "uvs", ":=", "range", "roleUpdates", "{", "if", "toRole", "==", "keybase1", ".", "TeamRole_NONE", "{", "continue", "\n", "}", "\n", "for", "_", ",", "newUV", ":=", "range", "uvs", "{", "if", "newUV", ".", "Uid", ".", "Equal", "(", "uv", ".", "Uid", ")", "&&", "newUV", ".", "EldestSeqno", ">", "uv", ".", "EldestSeqno", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n\n", "for", "toRole", ",", "uvs", ":=", "range", "roleUpdates", "{", "if", "toRole", "==", "keybase1", ".", "TeamRole_OWNER", "{", "continue", "\n", "}", "\n", "for", "_", ",", "uv", ":=", "range", "uvs", "{", "fromRole", ",", "err", ":=", "prev", ".", "GetUserRole", "(", "uv", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "// ignore error, user not in team", "\n", "}", "\n", "if", "toRole", "==", "keybase1", ".", "TeamRole_NONE", "&&", "fromRole", "==", "keybase1", ".", "TeamRole_OWNER", "&&", "readmittingResetUser", "(", "uv", ")", "{", "continue", "\n", "}", "\n", "if", "fromRole", "==", "keybase1", ".", "TeamRole_OWNER", "{", "// This is an intent to demote an owner.", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Whether", "the", "roleUpdates", "would", "demote", "any", "current", "owner", "to", "a", "lesser", "role", "." ]

[ "func", "(", "t", "*", "teamSigchainPlayer", ")", "updateMembership", "(", "stateToUpdate", "*", "TeamSigChainState", ",", "roleUpdates", "chainRoleUpdates", ",", "sigMeta", "keybase1", ".", "SignatureMetadata", ")", "{", "for", "role", ",", "uvs", ":=", "range", "roleUpdates", "{", "for", "_", ",", "uv", ":=", "range", "uvs", "{", "stateToUpdate", ".", "inform", "(", "uv", ",", "role", ",", "sigMeta", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Update", "userLog", "with", "the", "membership", "in", "roleUpdates", ".", "The", "NONE", "list", "removes", "users", ".", "The", "other", "lists", "add", "users", "." ]

[ "func", "(", "t", "*", "teamSigchainPlayer", ")", "assertSubteamName", "(", "parent", "*", "TeamSigChainState", ",", "parentSeqno", "keybase1", ".", "Seqno", ",", "subteamNameStr", "string", ")", "(", "keybase1", ".", "TeamName", ",", "error", ")", "{", "// Ideally, we would assert the team name is a direct child of this team's name.", "// But the middle parts of the names might be out of date.", "// Instead assert:", "// - The root team name is same.", "// - The subteam is 1 level deeper.", "// - The last part of the parent team's name matched", "// at the parent-seqno that this subteam name was mentioned.", "// (If the subteam is a.b.c.d then c should match)", "// The reason this is pegged at seqno instead of simply the latest parent name is", "// hard to explain, see TestRenameInflateSubteamAfterRenameParent.", "subteamName", ",", "err", ":=", "keybase1", ".", "TeamNameFromString", "(", "subteamNameStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "subteamName", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "subteamNameStr", ",", "err", ")", "\n", "}", "\n\n", "if", "!", "parent", ".", "inner", ".", "RootAncestor", ".", "Eq", "(", "subteamName", ".", "RootAncestorName", "(", ")", ")", "{", "return", "subteamName", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "subteamName", ".", "RootAncestorName", "(", ")", ",", "parent", ".", "inner", ".", "RootAncestor", ")", "\n", "}", "\n\n", "expectedDepth", ":=", "parent", ".", "inner", ".", "NameDepth", "+", "1", "\n", "if", "subteamName", ".", "Depth", "(", ")", "!=", "expectedDepth", "{", "return", "subteamName", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "subteamName", ".", "Depth", "(", ")", ",", "expectedDepth", ")", "\n", "}", "\n\n", "// The last part of the parent name at parentSeqno.", "var", "parentLastPart", "keybase1", ".", "TeamNamePart", "\n", "for", "_", ",", "point", ":=", "range", "parent", ".", "inner", ".", "NameLog", "{", "if", "point", ".", "Seqno", ">", "parentSeqno", "{", "break", "\n", "}", "\n", "parentLastPart", "=", "point", ".", "LastPart", "\n", "}", "\n\n", "subteamSecondToLastPart", ":=", "subteamName", ".", "Parts", "[", "len", "(", "subteamName", ".", "Parts", ")", "-", "2", "]", "\n", "if", "!", "subteamSecondToLastPart", ".", "Eq", "(", "parentLastPart", ")", "{", "return", "subteamName", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "subteamSecondToLastPart", ",", "parentLastPart", ")", "\n", "}", "\n\n", "return", "subteamName", ",", "nil", "\n", "}" ]

[ "Check", "that", "the", "subteam", "name", "is", "valid", "and", "kind", "of", "is", "a", "child", "of", "this", "chain", ".", "Returns", "the", "parsed", "subteam", "name", "." ]

[ "func", "NewUserKeyAPIer", "(", "log", "logger", ".", "Logger", ",", "api", "libkb", ".", "API", ")", "UserKeyAPIer", "{", "return", "&", "userKeyAPI", "{", "log", ":", "log", ",", "api", ":", "api", "}", "\n", "}" ]

[ "NewUserKeyAPIer", "returns", "a", "UserKeyAPIer", "implementation", "." ]

[ "func", "NewOnDemandStorer", "(", "s", "storage", ".", "Storer", ")", "(", "*", "OnDemandStorer", ",", "error", ")", "{", "// Track a small number of recent in-memory objects, to improve", "// performance without impacting memory too much.", "//", "// LRU is very helpful here because of the way delta compression", "// works. It first sorts the objects by type and descending size,", "// and then compares each object to a sliding window of previous", "// objects to find a good match. By default in git, the sliding", "// window for compression is 10, and it's good to have a", "// slightly larger cache size than that to avoid thrashing.", "//", "// To avoid memory pressure, it might be nice to additionally", "// consider capping the total size of this cache (e.g., with", "// github.com/keybase/cache). However, since the set in use is", "// based on the sliding window, it seems like that should be the", "// limiting factor. Eventually we might hit some repo where", "// there's a set of large objects that can overrun memory, but at", "// the limit that could be any two objects, and then the", "// compression algorithm in go-git is worthless. So for now,", "// let's just limit by number of entries, and add size-limits", "// later if needed.", "recentCache", ",", "err", ":=", "lru", ".", "New", "(", "25", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "OnDemandStorer", "{", "s", ",", "recentCache", "}", ",", "nil", "\n", "}" ]

[ "NewOnDemandStorer", "constructs", "an", "on", "-", "demand", "storage", "layer", "on", "top", "of", "an", "existing", "Storer", "." ]

[ "func", "(", "ods", "*", "OnDemandStorer", ")", "EncodedObject", "(", "ot", "plumbing", ".", "ObjectType", ",", "hash", "plumbing", ".", "Hash", ")", "(", "plumbing", ".", "EncodedObject", ",", "error", ")", "{", "o", ":=", "&", "onDemandObject", "{", "s", ":", "ods", ".", "Storer", ",", "hash", ":", "hash", ",", "objType", ":", "ot", ",", "size", ":", "-", "1", ",", "recentCache", ":", "ods", ".", "recentCache", ",", "}", "\n", "// If the object is missing, we need to return an error for that", "// here. But don't read all the object data from disk by calling", "// `Storer.EncodedObject()` or `o.cache()`. Instead use a", "// KBFS-specific `HasEncodedObject()` method that just tells us", "// whether or not the object exists.", "err", ":=", "ods", ".", "Storer", ".", "HasEncodedObject", "(", "hash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "o", ",", "nil", "\n", "}" ]

[ "EncodedObject", "implements", "the", "storage", ".", "Storer", "interface", "for", "OnDemandStorer", "." ]

[ "func", "(", "ods", "*", "OnDemandStorer", ")", "DeltaObject", "(", "ot", "plumbing", ".", "ObjectType", ",", "hash", "plumbing", ".", "Hash", ")", "(", "plumbing", ".", "EncodedObject", ",", "error", ")", "{", "edos", ",", "ok", ":=", "ods", ".", "Storer", ".", "(", "storer", ".", "DeltaObjectStorer", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "o", ":=", "&", "onDemandDeltaObject", "{", "s", ":", "edos", ",", "hash", ":", "hash", ",", "objType", ":", "ot", ",", "size", ":", "-", "1", ",", "recentCache", ":", "ods", ".", "recentCache", ",", "}", "\n", "// Need to see if this is a delta object, which means reading all", "// the data.", "_", ",", "err", ":=", "o", ".", "cache", "(", ")", "\n", "_", ",", "notDelta", ":=", "err", ".", "(", "notDeltaError", ")", "\n", "if", "notDelta", "{", "return", "ods", ".", "EncodedObject", "(", "ot", ",", "hash", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "o", ",", "nil", "\n", "}" ]

[ "DeltaObject", "implements", "the", "storer", ".", "DeltaObjectStorer", "interface", "for", "OnDemandStorer", "." ]

[ "func", "(", "s", "*", "SimpleTimer", ")", "Start", "(", ")", "{", "if", "s", ".", "start", "==", "nil", "{", "tmp", ":=", "time", ".", "Now", "(", ")", "\n", "s", ".", "start", "=", "&", "tmp", "\n", "}", "\n", "}" ]

[ "Start", "the", "timer", "running", "if", "it", "s", "not", "already", "started", "." ]

[ "func", "(", "s", "*", "SimpleTimer", ")", "Stop", "(", ")", "time", ".", "Duration", "{", "if", "s", ".", "start", "!=", "nil", "{", "s", ".", "total", "+=", "time", ".", "Since", "(", "*", "s", ".", "start", ")", "\n", "}", "else", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", ".", "GetTotal", "(", ")", "\n", "}" ]

[ "Stop", "the", "timer", ";", "panic", "if", "it", "hasn", "t", "been", "previously", "started", ".", "Return", "the", "total", "duration", "spent", "in", "the", "timer", "." ]

[ "func", "(", "r", "*", "ReportingTimerReal", ")", "Report", "(", "prefix", "string", ")", "{", "dur", ":=", "r", ".", "Stop", "(", ")", "\n", "r", ".", "Reset", "(", ")", "\n", "r", ".", "G", "(", ")", ".", "Log", ".", "Info", "(", "\"", "\"", ",", "prefix", ",", "dur", "/", "time", ".", "Millisecond", ")", "\n", "}" ]

[ "Report", "stops", "and", "resets", "the", "timer", "then", "logs", "to", "Info", "what", "the", "duration", "was", "." ]

[ "func", "NewTimerSet", "(", "g", "*", "GlobalContext", ")", "*", "TimerSet", "{", "s", ":=", "g", ".", "Env", ".", "GetTimers", "(", ")", "\n", "sel", ":=", "TimerNone", "\n", "for", "_", ",", "c", ":=", "range", "s", "{", "switch", "c", "{", "case", "'a'", ":", "sel", "|=", "TimerAPI", "\n", "case", "'x'", ":", "sel", "|=", "TimerXAPI", "\n", "case", "'r'", ":", "sel", "|=", "TimerRPC", "\n\n", "}", "\n", "}", "\n", "return", "&", "TimerSet", "{", "sel", ":", "sel", ",", "Contextified", ":", "Contextified", "{", "g", "}", "}", "\n", "}" ]

[ "NewTimerSet", "looks", "into", "the", "given", "context", "for", "configuration", "information", "about", "how", "to", "set", "up", "timers", ".", "It", "then", "returns", "the", "corresponding", "TimerSet", "." ]

[ "func", "(", "s", "TimerSet", ")", "Start", "(", "sel", "TimerSelector", ")", "ReportingTimer", "{", "var", "ret", "ReportingTimer", "\n", "if", "s", ".", "sel", "&", "sel", "==", "sel", "{", "tmp", ":=", "NewReportingTimerReal", "(", "s", ".", "Contextified", ")", "\n", "tmp", ".", "Start", "(", ")", "\n", "ret", "=", "tmp", "\n", "}", "else", "{", "ret", "=", "ReportingTimerDummy", "{", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Start", "allocates", "and", "starts", "a", "new", "timer", "if", "the", "passed", "TimerSelector", "is", "currently", "enabled", ".", "Otherwise", "it", "just", "returns", "a", "Dummy", "timer", "." ]

[ "func", "(", "t", "SigchainV2Type", ")", "IsSupportedTeamType", "(", ")", "bool", "{", "switch", "t", "{", "case", "SigchainV2TypeTeamRoot", ",", "SigchainV2TypeTeamNewSubteam", ",", "SigchainV2TypeTeamChangeMembership", ",", "SigchainV2TypeTeamRotateKey", ",", "SigchainV2TypeTeamLeave", ",", "SigchainV2TypeTeamSubteamHead", ",", "SigchainV2TypeTeamRenameSubteam", ",", "SigchainV2TypeTeamInvite", ",", "SigchainV2TypeTeamRenameUpPointer", ",", "SigchainV2TypeTeamDeleteRoot", ",", "SigchainV2TypeTeamDeleteSubteam", ",", "SigchainV2TypeTeamDeleteUpPointer", ",", "SigchainV2TypeTeamKBFSSettings", ",", "SigchainV2TypeTeamSettings", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "Whether", "a", "type", "is", "for", "team", "sigchains", ".", "Also", "the", "list", "of", "which", "types", "are", "supported", "by", "this", "client", "." ]

[ "func", "(", "t", "SigchainV2Type", ")", "TeamAllowStub", "(", "role", "keybase1", ".", "TeamRole", ")", "bool", "{", "if", "role", ".", "IsAdminOrAbove", "(", ")", "{", "// Links cannot be stubbed for owners and admins", "return", "false", "\n", "}", "\n", "switch", "t", "{", "case", "SigchainV2TypeTeamNewSubteam", ",", "SigchainV2TypeTeamRenameSubteam", ",", "SigchainV2TypeTeamDeleteSubteam", ",", "SigchainV2TypeTeamInvite", ":", "return", "true", "\n", "default", ":", "// Disallow stubbing of other known links.", "// Allow stubbing of unknown link types for forward compatibility.", "return", "!", "t", ".", "IsSupportedTeamType", "(", ")", "\n", "}", "\n", "}" ]

[ "Whether", "the", "type", "can", "be", "stubbed", "for", "a", "team", "member", "with", "role" ]

[ "func", "(", "a", "*", "MobileAppState", ")", "NextUpdate", "(", "lastState", "*", "keybase1", ".", "MobileAppState", ")", "chan", "keybase1", ".", "MobileAppState", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n", "ch", ":=", "make", "(", "chan", "keybase1", ".", "MobileAppState", ",", "1", ")", "\n", "if", "lastState", "!=", "nil", "&&", "*", "lastState", "!=", "a", ".", "state", "{", "ch", "<-", "a", ".", "state", "\n", "}", "else", "{", "a", ".", "updateChs", "=", "append", "(", "a", ".", "updateChs", ",", "ch", ")", "\n", "}", "\n", "return", "ch", "\n", "}" ]

[ "NextUpdate", "returns", "a", "channel", "that", "triggers", "when", "the", "app", "state", "changes" ]

[ "func", "(", "a", "*", "MobileAppState", ")", "Update", "(", "state", "keybase1", ".", "MobileAppState", ")", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n", "defer", "a", ".", "G", "(", ")", ".", "Trace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "state", ")", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ")", "(", ")", "\n", "if", "a", ".", "state", "!=", "state", "{", "a", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "state", ",", "a", ".", "state", ")", "\n", "a", ".", "state", "=", "state", "\n", "for", "_", ",", "ch", ":=", "range", "a", ".", "updateChs", "{", "ch", "<-", "state", "\n", "}", "\n", "a", ".", "updateChs", "=", "nil", "\n\n", "// cancel RPCs if we go into the background", "switch", "a", ".", "state", "{", "case", "keybase1", ".", "MobileAppState_BACKGROUND", ":", "a", ".", "G", "(", ")", ".", "RPCCanceler", ".", "CancelLiveContexts", "(", "RPCCancelerReasonBackground", ")", "\n", "}", "\n", "}", "else", "{", "a", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "state", ",", "a", ".", "state", ")", "\n", "}", "\n", "}" ]

[ "Update", "updates", "the", "current", "app", "state", "and", "notifies", "any", "waiting", "calls", "from", "NextUpdate" ]

[ "func", "(", "a", "*", "MobileAppState", ")", "State", "(", ")", "keybase1", ".", "MobileAppState", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n", "return", "a", ".", "state", "\n", "}" ]

[ "State", "returns", "the", "current", "app", "state" ]

[ "func", "NewBlockOpsConstrained", "(", "delegate", "BlockOps", ",", "bwKBps", "int", ")", "*", "BlockOpsConstrained", "{", "return", "&", "BlockOpsConstrained", "{", "BlockOps", ":", "delegate", ",", "bwKBps", ":", "bwKBps", ",", "}", "\n", "}" ]

[ "NewBlockOpsConstrained", "constructs", "a", "new", "BlockOpsConstrained", "." ]

[ "func", "BinPath", "(", ")", "(", "string", ",", "error", ")", "{", "exePath", ",", "err", ":=", "os", ".", "Executable", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "filepath", ".", "EvalSymlinks", "(", "exePath", ")", "\n", "}" ]

[ "BinPath", "returns", "path", "to", "the", "keybase", "executable", ".", "If", "the", "executable", "path", "is", "a", "symlink", "the", "target", "path", "is", "returned", "." ]

[ "func", "(", "b", "*", "Browser", ")", "Open", "(", "filename", "string", ")", "(", "f", "billy", ".", "File", ",", "err", "error", ")", "{", "if", "b", ".", "tree", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "defer", "translateGitError", "(", "&", "err", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "maxSymlinkLevels", ";", "i", "++", "{", "fi", ",", "err", ":=", "b", ".", "Lstat", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Check if this is a submodule.", "if", "sfi", ",", "ok", ":=", "fi", ".", "(", "*", "submoduleFileInfo", ")", ";", "ok", "{", "return", "sfi", ".", "sf", ",", "nil", "\n", "}", "\n\n", "// If it's not a symlink, we can return right away.", "if", "fi", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "==", "0", "{", "f", ",", "err", ":=", "b", ".", "tree", ".", "File", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "newBrowserFile", "(", "f", ")", "\n", "}", "\n\n", "filename", ",", "err", "=", "b", ".", "followSymlink", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Open", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "Browser", "." ]

[ "func", "(", "b", "*", "Browser", ")", "OpenFile", "(", "filename", "string", ",", "flag", "int", ",", "_", "os", ".", "FileMode", ")", "(", "f", "billy", ".", "File", ",", "err", "error", ")", "{", "if", "b", ".", "tree", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "flag", "&", "os", ".", "O_CREATE", "!=", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "b", ".", "Open", "(", "filename", ")", "\n", "}" ]

[ "OpenFile", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "Browser", "." ]

[ "func", "(", "b", "*", "Browser", ")", "Lstat", "(", "filename", "string", ")", "(", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "{", "if", "b", ".", "tree", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "strings", ".", "HasPrefix", "(", "filename", ",", "AutogitCommitPrefix", ")", "{", "commit", ":=", "strings", ".", "TrimPrefix", "(", "filename", ",", "AutogitCommitPrefix", ")", "\n", "hash", ":=", "plumbing", ".", "NewHash", "(", "commit", ")", "\n", "f", ",", "err", ":=", "b", ".", "getCommitFile", "(", "context", ".", "Background", "(", ")", ",", "hash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "f", ".", "GetInfo", "(", ")", ",", "nil", "\n", "}", "\n\n", "cachePath", ":=", "path", ".", "Join", "(", "b", ".", "root", ",", "filename", ")", "\n", "if", "fi", ",", "ok", ":=", "b", ".", "sharedCache", ".", "getFileInfo", "(", "b", ".", "commitHash", ",", "cachePath", ")", ";", "ok", "{", "return", "fi", ",", "nil", "\n", "}", "\n", "defer", "translateGitError", "(", "&", "err", ")", "\n", "entry", ",", "err", ":=", "b", ".", "tree", ".", "FindEntry", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "WithStack", "(", "err", ")", "\n", "}", "\n\n", "size", ",", "err", ":=", "b", ".", "tree", ".", "Size", "(", "filename", ")", "\n", "switch", "errors", ".", "Cause", "(", "err", ")", "{", "case", "nil", ":", "// Git doesn't keep track of the mtime of individual files", "// anywhere, so just use the timestamp from the commit.", "fi", "=", "&", "browserFileInfo", "{", "entry", ",", "size", ",", "b", ".", "mtime", "}", "\n", "case", "plumbing", ".", "ErrObjectNotFound", ":", "// This is likely a git submodule.", "sf", ":=", "newSubmoduleFile", "(", "entry", ".", "Hash", ",", "filename", ",", "b", ".", "mtime", ")", "\n", "fi", "=", "sf", ".", "GetInfo", "(", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "WithStack", "(", "err", ")", "\n", "}", "\n\n", "b", ".", "sharedCache", ".", "setFileInfo", "(", "b", ".", "commitHash", ",", "cachePath", ",", "fi", ")", "\n", "return", "fi", ",", "nil", "\n", "}" ]

[ "Lstat", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "Browser", "." ]

[ "func", "(", "b", "*", "Browser", ")", "Stat", "(", "filename", "string", ")", "(", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "{", "defer", "translateGitError", "(", "&", "err", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "maxSymlinkLevels", ";", "i", "++", "{", "fi", ",", "err", ":=", "b", ".", "Lstat", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// If it's not a symlink, we can return right away.", "if", "fi", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "==", "0", "{", "return", "fi", ",", "nil", "\n", "}", "\n\n", "filename", ",", "err", "=", "b", ".", "followSymlink", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Stat", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "Browser", "." ]

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

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

[ "func", "(", "b", "*", "Browser", ")", "ReadDir", "(", "p", "string", ")", "(", "fis", "[", "]", "os", ".", "FileInfo", ",", "err", "error", ")", "{", "if", "p", "==", "\"", "\"", "{", "p", "=", "\"", "\"", "\n", "}", "\n\n", "if", "b", ".", "tree", "==", "nil", "{", "if", "p", "==", "\"", "\"", "{", "// Branch with no commits.", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cachePath", ":=", "path", ".", "Join", "(", "b", ".", "root", ",", "p", ")", "\n\n", "if", "fis", ",", "ok", ":=", "b", ".", "sharedCache", ".", "getChildrenFileInfos", "(", "b", ".", "commitHash", ",", "cachePath", ")", ";", "ok", "{", "return", "fis", ",", "nil", "\n", "}", "\n\n", "defer", "translateGitError", "(", "&", "err", ")", "\n", "var", "dirTree", "*", "object", ".", "Tree", "\n", "if", "p", "==", "\"", "\"", "{", "dirTree", "=", "b", ".", "tree", "\n", "}", "else", "{", "dirTree", ",", "err", "=", "b", ".", "tree", ".", "Tree", "(", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "childrenPathsToCache", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "dirTree", ".", "Entries", ")", ")", "\n", "for", "_", ",", "e", ":=", "range", "dirTree", ".", "Entries", "{", "fi", ",", "err", ":=", "b", ".", "Lstat", "(", "path", ".", "Join", "(", "p", ",", "e", ".", "Name", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "fis", "=", "append", "(", "fis", ",", "fi", ")", "\n", "childrenPathsToCache", "=", "append", "(", "childrenPathsToCache", ",", "path", ".", "Join", "(", "cachePath", ",", "e", ".", "Name", ")", ")", "\n", "}", "\n", "b", ".", "sharedCache", ".", "setChildrenPaths", "(", "b", ".", "commitHash", ",", "cachePath", ",", "childrenPathsToCache", ")", "\n\n", "return", "fis", ",", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "Browser", ")", "Readlink", "(", "link", "string", ")", "(", "target", "string", ",", "err", "error", ")", "{", "defer", "translateGitError", "(", "&", "err", ")", "\n", "fi", ",", "err", ":=", "b", ".", "Lstat", "(", "link", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "// If it's not a symlink, error right away.", "if", "fi", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "b", ".", "readLink", "(", "link", ")", "\n", "}" ]

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

[ "func", "(", "b", "*", "Browser", ")", "Chroot", "(", "p", "string", ")", "(", "newFS", "billy", ".", "Filesystem", ",", "err", "error", ")", "{", "if", "b", ".", "tree", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "defer", "translateGitError", "(", "&", "err", ")", "\n", "newTree", ",", "err", ":=", "b", ".", "tree", ".", "Tree", "(", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "Browser", "{", "tree", ":", "newTree", ",", "root", ":", "b", ".", "Join", "(", "b", ".", "root", ",", "p", ")", ",", "mtime", ":", "b", ".", "mtime", ",", "commitHash", ":", "b", ".", "commitHash", ",", "sharedCache", ":", "b", ".", "sharedCache", ",", "}", ",", "nil", "\n", "}" ]

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

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

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

[ "func", "(", "b", "*", "Browser", ")", "Symlink", "(", "_", ",", "_", "string", ")", "(", "err", "error", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Symlink", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "Browser", "." ]

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

[ "NewLoginWithPaperKey", "creates", "a", "LoginWithPaperKey", "engine", ".", "Uses", "the", "paperkey", "to", "log", "in", "and", "unlock", "LKS", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "FavoriteDelete", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "error", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "k", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lock", ".", "Unlock", "(", ")", "\n", "session", ",", "err", ":=", "k", ".", "CurrentSession", "(", "ctx", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "k", ".", "favoriteStore", ".", "FavoriteDelete", "(", "session", ".", "UID", ",", "folder", ")", "\n", "}" ]

[ "FavoriteDelete", "implements", "KeybaseDaemon", "for", "KeybaseDaemonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "FavoriteList", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "keybase1", ".", "FavoritesResult", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "FavoritesResult", "{", "}", ",", "err", "\n", "}", "\n\n", "k", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "session", ",", "err", ":=", "k", ".", "CurrentSession", "(", "ctx", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "FavoritesResult", "{", "}", ",", "err", "\n", "}", "\n\n", "// This is only used for testing, so it's okay to only have favorites here.", "favs", ",", "err", ":=", "k", ".", "favoriteStore", ".", "FavoriteList", "(", "session", ".", "UID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "FavoritesResult", "{", "}", ",", "err", "\n", "}", "\n", "return", "keybase1", ".", "FavoritesResult", "{", "FavoriteFolders", ":", "favs", ",", "IgnoredFolders", ":", "[", "]", "keybase1", ".", "Folder", "{", "}", ",", "NewFolders", ":", "[", "]", "keybase1", ".", "Folder", "{", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "FavoriteList", "implements", "KeybaseDaemon", "for", "KeybaseDaemonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "EncryptFavorites", "(", "ctx", "context", ".", "Context", ",", "dataToEncrypt", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "nil", ",", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "EncryptFavorites", "implements", "KeybaseService", "for", "KeybaseDaemonLocal" ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "DecryptFavorites", "(", "ctx", "context", ".", "Context", ",", "dataToDecrypt", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "nil", ",", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "DecryptFavorites", "implements", "KeybaseService", "for", "KeybaseDaemonLocal" ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "NotifyOnlineStatusChanged", "(", "ctx", "context", ".", "Context", ",", "online", "bool", ")", "error", "{", "return", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "NotifyOnlineStatusChanged", "implements", "KeybaseDaemon", "for", "KeybaseDeamonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "Notify", "(", "ctx", "context", ".", "Context", ",", "notification", "*", "keybase1", ".", "FSNotification", ")", "error", "{", "return", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "Notify", "implements", "KeybaseDaemon", "for", "KeybaseDeamonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "NotifyPathUpdated", "(", "ctx", "context", ".", "Context", ",", "_", "string", ")", "error", "{", "return", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "NotifyPathUpdated", "implements", "KeybaseDaemon", "for", "KeybaseDeamonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "NotifySyncStatus", "(", "ctx", "context", ".", "Context", ",", "_", "*", "keybase1", ".", "FSPathSyncStatus", ")", "error", "{", "return", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "NotifySyncStatus", "implements", "KeybaseDaemon", "for", "KeybaseDeamonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "NotifyOverallSyncStatus", "(", "ctx", "context", ".", "Context", ",", "_", "keybase1", ".", "FolderSyncStatus", ")", "error", "{", "return", "checkContext", "(", "ctx", ")", "\n", "}" ]

[ "NotifyOverallSyncStatus", "implements", "KeybaseDaemon", "for", "KeybaseDeamonLocal", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonLocal", ")", "PutGitMetadata", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ",", "repoID", "keybase1", ".", "RepoID", ",", "metadata", "keybase1", ".", "GitLocalMetadata", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "PutGitMetadata", "implements", "the", "KeybaseService", "interface", "for", "KeybaseDaemonLocal", "." ]

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

[ "FindNextMerkleRootAfterTeamRemoval", "finds", "the", "first", "Merkle", "root", "that", "contains", "the", "user", "being", "removed", "from", "the", "team", "at", "that", "given", "seqno", "in", "the", "team", "s", "chain", ".", "You", "should", "pass", "in", "a", "previous", "Merkle", "root", "as", "a", "starting", "point", "for", "the", "binary", "search", "." ]

[ "func", "(", "c", "TeamsClient", ")", "ProfileTeamLoad", "(", "ctx", "context", ".", "Context", ",", "arg", "LoadTeamArg", ")", "(", "res", "ProfileTeamLoadRes", ",", "err", "error", ")", "{", "__arg", ":=", "ProfileTeamLoadArg", "{", "Arg", ":", "arg", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "ProfileTeamLoad", "loads", "a", "team", "and", "then", "throws", "it", "on", "the", "ground", "for", "the", "purposes", "of", "profiling", "the", "team", "load", "machinery", "." ]

[ "func", "(", "c", "TeamsClient", ")", "GetTeamID", "(", "ctx", "context", ".", "Context", ",", "teamName", "string", ")", "(", "res", "TeamID", ",", "err", "error", ")", "{", "__arg", ":=", "GetTeamIDArg", "{", "TeamName", ":", "teamName", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Gets", "a", "TeamID", "from", "a", "team", "name", "string", ".", "Returns", "an", "error", "if", "the", "current", "user", "can", "t", "read", "the", "team", "." ]

[ "func", "(", "c", "FsClient", ")", "List", "(", "ctx", "context", ".", "Context", ",", "__arg", "ListArg", ")", "(", "res", "ListResult", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "List", "files", "in", "a", "path", ".", "Implemented", "by", "KBFS", "service", "." ]

[ "func", "(", "b", "*", "blockServerRemoteClientHandler", ")", "resetAuth", "(", "ctx", "context", ".", "Context", ",", "c", "keybase1", ".", "BlockInterface", ")", "(", "err", "error", ")", "{", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "ctxBServerResetKey", ",", "b", ".", "name", ")", "\n\n", "defer", "func", "(", ")", "{", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n\n", "session", ",", "err", ":=", "b", ".", "csg", ".", "GetCurrentSession", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "b", ".", "name", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// request a challenge", "challenge", ",", "err", ":=", "c", ".", "GetSessionChallenge", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// get a new signature", "signature", ",", "err", ":=", "b", ".", "authToken", ".", "Sign", "(", "ctx", ",", "session", ".", "Name", ",", "session", ".", "UID", ",", "session", ".", "VerifyingKey", ",", "challenge", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "c", ".", "AuthenticateSession", "(", "ctx", ",", "signature", ")", "\n", "}" ]

[ "resetAuth", "is", "called", "to", "reset", "the", "authorization", "on", "a", "BlockServer", "connection", "." ]

[ "func", "NewBlockServerRemote", "(", "config", "blockServerRemoteConfig", ",", "blkSrvRemote", "rpc", ".", "Remote", ",", "rpcLogFactory", "rpc", ".", "LogFactory", ")", "*", "BlockServerRemote", "{", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "deferLog", ":=", "log", ".", "CloneWithAddedDepth", "(", "1", ")", "\n", "bs", ":=", "&", "BlockServerRemote", "{", "config", ":", "config", ",", "log", ":", "traceLogger", "{", "log", "}", ",", "deferLog", ":", "traceLogger", "{", "deferLog", "}", ",", "blkSrvRemote", ":", "blkSrvRemote", ",", "}", "\n", "// Use two separate auth clients -- one for writes and one for", "// reads. This allows small reads to avoid getting trapped behind", "// large asynchronous writes. TODO: use some real network QoS to", "// achieve better prioritization within the actual network.", "bs", ".", "putConn", "=", "newBlockServerRemoteClientHandler", "(", "\"", "\"", ",", "log", ",", "config", ".", "Signer", "(", ")", ",", "config", ".", "CurrentSessionGetter", "(", ")", ",", "blkSrvRemote", ",", "rpcLogFactory", ")", "\n", "bs", ".", "getConn", "=", "newBlockServerRemoteClientHandler", "(", "\"", "\"", ",", "log", ",", "config", ".", "Signer", "(", ")", ",", "config", ".", "CurrentSessionGetter", "(", ")", ",", "blkSrvRemote", ",", "rpcLogFactory", ")", "\n\n", "bs", ".", "shutdownFn", "=", "func", "(", ")", "{", "bs", ".", "putConn", ".", "shutdown", "(", ")", "\n", "bs", ".", "getConn", ".", "shutdown", "(", ")", "\n", "}", "\n", "return", "bs", "\n", "}" ]

[ "NewBlockServerRemote", "constructs", "a", "new", "BlockServerRemote", "for", "the", "given", "address", "." ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "cacheType", "DiskBlockCacheType", ")", "(", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "var", "res", "keybase1", ".", "GetBlockRes", "\n", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ")", "\n\n", "// Once the block has been retrieved, cache it.", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "deferLog", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "len", "(", "buf", ")", ",", "err", ")", "\n", "}", "else", "{", "// But don't cache it if it's archived data.", "if", "res", ".", "Status", "==", "keybase1", ".", "BlockStatus_ARCHIVED", "{", "return", "\n", "}", "\n\n", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "len", "(", "buf", ")", ")", "\n", "dbc", ":=", "b", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "!=", "nil", "{", "// This used to be called in a goroutine to prevent blocking", "// the `Get`. But we need this cached synchronously so prefetch", "// operations can work correctly.", "dbc", ".", "Put", "(", "ctx", ",", "tlfID", ",", "id", ",", "buf", ",", "serverHalf", ",", "cacheType", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "arg", ":=", "kbfsblock", ".", "MakeGetBlockArg", "(", "tlfID", ",", "id", ",", "context", ")", "\n", "res", ",", "err", "=", "b", ".", "getConn", ".", "getClient", "(", ")", ".", "GetBlock", "(", "ctx", ",", "arg", ")", "\n", "return", "kbfsblock", ".", "ParseGetBlockRes", "(", "res", ",", "err", ")", "\n", "}" ]

[ "Get", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote", "." ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "GetEncodedSize", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ")", "(", "size", "uint32", ",", "status", "keybase1", ".", "BlockStatus", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ")", "\n", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "deferLog", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "err", ")", "\n", "}", "else", "{", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "size", ",", "status", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "arg", ":=", "kbfsblock", ".", "MakeGetBlockArg", "(", "tlfID", ",", "id", ",", "context", ")", "\n", "arg", ".", "SizeOnly", "=", "true", "\n", "res", ",", "err", ":=", "b", ".", "getConn", ".", "getClient", "(", ")", ".", "GetBlock", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "nil", "\n", "}", "\n", "return", "uint32", "(", "res", ".", "Size", ")", ",", "res", ".", "Status", ",", "nil", "\n", "}" ]

[ "GetEncodedSize", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote", "." ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "Put", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "bContext", "kbfsblock", ".", "Context", ",", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "cacheType", "DiskBlockCacheType", ")", "(", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "dbc", ":=", "b", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "!=", "nil", "{", "dbc", ".", "Put", "(", "ctx", ",", "tlfID", ",", "id", ",", "buf", ",", "serverHalf", ",", "cacheType", ")", "\n", "}", "\n", "size", ":=", "len", "(", "buf", ")", "\n", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ")", "\n", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "deferLog", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "bContext", ",", "size", ",", "err", ")", "\n", "}", "else", "{", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "bContext", ",", "size", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "arg", ":=", "kbfsblock", ".", "MakePutBlockArg", "(", "tlfID", ",", "id", ",", "bContext", ",", "buf", ",", "serverHalf", ")", "\n", "// Handle OverQuota errors at the caller", "return", "b", ".", "putConn", ".", "getClient", "(", ")", ".", "PutBlock", "(", "ctx", ",", "arg", ")", "\n", "}" ]

[ "Put", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote", "." ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "AddBlockReference", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ")", "(", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ")", "\n", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "deferLog", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "err", ")", "\n", "}", "else", "{", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "arg", ":=", "kbfsblock", ".", "MakeAddReferenceArg", "(", "tlfID", ",", "id", ",", "context", ")", "\n", "// Handle OverQuota errors at the caller", "return", "b", ".", "putConn", ".", "getClient", "(", ")", ".", "AddReference", "(", "ctx", ",", "arg", ")", "\n", "}" ]

[ "AddBlockReference", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote" ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "RemoveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "// TODO: Define a more compact printout of contexts.", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "contexts", ")", "\n", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "contexts", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "deferLog", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "contexts", ")", ",", "err", ")", "\n", "}", "else", "{", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "contexts", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "doneRefs", ",", "err", ":=", "kbfsblock", ".", "BatchDowngradeReferences", "(", "ctx", ",", "b", ".", "log", ",", "tlfID", ",", "contexts", ",", "false", ",", "b", ".", "putConn", ".", "getClient", "(", ")", ")", "\n", "return", "kbfsblock", ".", "GetLiveCounts", "(", "doneRefs", ")", ",", "err", "\n", "}" ]

[ "RemoveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote" ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "ArchiveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "contexts", ")", "\n", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "contexts", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "b", ".", "deferLog", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "contexts", ")", ",", "err", ")", "\n", "}", "else", "{", "b", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "contexts", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "_", ",", "err", "=", "kbfsblock", ".", "BatchDowngradeReferences", "(", "ctx", ",", "b", ".", "log", ",", "tlfID", ",", "contexts", ",", "true", ",", "b", ".", "putConn", ".", "getClient", "(", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "ArchiveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote" ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "GetLiveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", ",", "err", "error", ")", "{", "return", "kbfsblock", ".", "GetReferenceCount", "(", "ctx", ",", "tlfID", ",", "contexts", ",", "keybase1", ".", "BlockStatus_LIVE", ",", "b", ".", "getConn", ".", "getClient", "(", ")", ")", "\n", "}" ]

[ "GetLiveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote", "." ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "IsUnflushed", "(", "_", "context", ".", "Context", ",", "_", "tlf", ".", "ID", ",", "_", "kbfsblock", ".", "ID", ")", "(", "bool", ",", "error", ")", "{", "return", "false", ",", "nil", "\n", "}" ]

[ "IsUnflushed", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote", "." ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "GetUserQuotaInfo", "(", "ctx", "context", ".", "Context", ")", "(", "info", "*", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "ctx", "=", "rpc", ".", "WithFireNow", "(", "ctx", ")", "\n", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "b", ".", "log", ".", "LazyTrace", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "(", ")", "\n", "res", ",", "err", ":=", "b", ".", "getConn", ".", "getClient", "(", ")", ".", "GetUserQuotaInfo", "(", "ctx", ")", "\n", "return", "kbfsblock", ".", "ParseGetQuotaInfoRes", "(", "b", ".", "config", ".", "Codec", "(", ")", ",", "res", ",", "err", ")", "\n", "}" ]

[ "GetUserQuotaInfo", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote" ]

[ "func", "(", "b", "*", "BlockServerRemote", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "{", "if", "b", ".", "shutdownFn", "!=", "nil", "{", "b", ".", "shutdownFn", "(", ")", "\n", "}", "\n", "b", ".", "getConn", ".", "shutdown", "(", ")", "\n", "b", ".", "putConn", ".", "shutdown", "(", ")", "\n", "}" ]

[ "Shutdown", "implements", "the", "BlockServer", "interface", "for", "BlockServerRemote", "." ]

[ "func", "NewPGPDecrypt", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "PGPDecryptArg", ")", "*", "PGPDecrypt", "{", "return", "&", "PGPDecrypt", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPGPDecrypt", "creates", "a", "PGPDecrypt", "engine", "." ]

[ "func", "MakeID", "(", "codec", "kbfscodec", ".", "Codec", ",", "md", "RootMetadata", ")", "(", "ID", ",", "error", ")", "{", "// Make sure that the serialized metadata is set; otherwise we", "// won't get the right ID.", "if", "md", ".", "GetSerializedPrivateMetadata", "(", ")", "==", "nil", "{", "return", "ID", "{", "}", ",", "errors", ".", "WithStack", "(", "MissingDataError", "{", "md", ".", "TlfID", "(", ")", "}", ")", "\n", "}", "\n\n", "buf", ",", "err", ":=", "codec", ".", "Encode", "(", "md", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n\n", "h", ",", "err", ":=", "kbfshash", ".", "DefaultHash", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ID", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "ID", "{", "h", "}", ",", "nil", "\n", "}" ]

[ "MakeID", "creates", "a", "new", "ID", "from", "the", "given", "RootMetadata", "object", "." ]

[ "func", "AutoInstall", "(", "context", "Context", ",", "_", "string", ",", "_", "bool", ",", "timeout", "time", ".", "Duration", ",", "log", "Log", ")", "(", "newProc", "bool", ",", "err", "error", ")", "{", "err", "=", "os", ".", "MkdirAll", "(", "context", ".", "GetConfigDir", "(", ")", ",", "0755", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "err", "=", "ToggleAutostart", "(", "context", ",", "true", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "// Ignore if we couldn't write to autostart", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "AutoInstall", "installs", "auto", "start", "on", "unix" ]

[ "func", "KBFSBinPath", "(", "runMode", "libkb", ".", "RunMode", ",", "binPath", "string", ")", "(", "string", ",", "error", ")", "{", "return", "kbfsBinPathDefault", "(", "runMode", ",", "binPath", ")", "\n", "}" ]

[ "KBFSBinPath", "returns", "the", "path", "to", "the", "KBFS", "executable" ]

[ "func", "NewPGPEncrypt", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "PGPEncryptArg", ")", "*", "PGPEncrypt", "{", "return", "&", "PGPEncrypt", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPGPEncrypt", "creates", "a", "PGPEncrypt", "engine", "." ]

[ "func", "(", "k", "*", "keyset", ")", "Add", "(", "bundle", "*", "libkb", ".", "PGPKeyBundle", ")", "{", "kid", ":=", "bundle", ".", "GetKID", "(", ")", "\n", "if", "_", ",", "ok", ":=", "k", ".", "keys", "[", "kid", "]", ";", "ok", "{", "return", "\n", "}", "\n", "k", ".", "keys", "[", "kid", "]", "=", "bundle", "\n", "k", ".", "index", "=", "append", "(", "k", ".", "index", ",", "kid", ")", "\n", "}" ]

[ "Add", "adds", "bundle", "to", "the", "keyset", ".", "If", "a", "key", "already", "exists", "it", "will", "be", "ignored", "." ]

[ "func", "(", "k", "*", "keyset", ")", "Sorted", "(", ")", "[", "]", "*", "libkb", ".", "PGPKeyBundle", "{", "var", "sorted", "[", "]", "*", "libkb", ".", "PGPKeyBundle", "\n", "for", "_", ",", "kid", ":=", "range", "k", ".", "index", "{", "sorted", "=", "append", "(", "sorted", ",", "k", ".", "keys", "[", "kid", "]", ")", "\n", "}", "\n", "return", "sorted", "\n", "}" ]

[ "Sorted", "returns", "the", "unique", "keys", "in", "insertion", "order", "." ]

[ "func", "(", "s", "*", "Session", ")", "Invalidate", "(", ")", "{", "s", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "s", ".", "valid", "=", "false", "\n", "s", ".", "mtime", "=", "time", ".", "Time", "{", "}", "\n", "s", ".", "token", "=", "\"", "\"", "\n", "s", ".", "csrf", "=", "\"", "\"", "\n", "s", ".", "checked", "=", "false", "\n", "}" ]

[ "Invalidate", "marks", "the", "session", "as", "invalid", "and", "posts", "a", "logout", "notification", "." ]

[ "func", "MakeNaclSigningKeyPairFromSecret", "(", "secret", "[", "NaclSigningKeySecretSize", "]", "byte", ")", "(", "NaclSigningKeyPair", ",", "error", ")", "{", "r", ":=", "bytes", ".", "NewReader", "(", "secret", "[", ":", "]", ")", "\n\n", "kp", ",", "err", ":=", "makeNaclSigningKeyPair", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NaclSigningKeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "r", ".", "Len", "(", ")", ">", "0", "{", "return", "NaclSigningKeyPair", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ".", "Len", "(", ")", ")", "\n", "}", "\n\n", "return", "kp", ",", "err", "\n", "}" ]

[ "MakeNaclSigningKeyPairFromSecret", "makes", "a", "signing", "key", "pair", "given", "a", "secret", ".", "Of", "course", "the", "security", "of", "depends", "entirely", "on", "the", "randomness", "of", "the", "bytes", "in", "the", "secret", "." ]

[ "func", "MakeNaclDHKeyPairFromSecret", "(", "secret", "[", "NaclDHKeySecretSize", "]", "byte", ")", "(", "NaclDHKeyPair", ",", "error", ")", "{", "r", ":=", "bytes", ".", "NewReader", "(", "secret", "[", ":", "]", ")", "\n\n", "kp", ",", "err", ":=", "makeNaclDHKeyPair", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NaclDHKeyPair", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "r", ".", "Len", "(", ")", ">", "0", "{", "return", "NaclDHKeyPair", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ".", "Len", "(", ")", ")", "\n", "}", "\n\n", "return", "kp", ",", "err", "\n", "}" ]

[ "MakeNaclDHKeyPairFromSecret", "makes", "a", "DH", "key", "pair", "given", "a", "secret", ".", "Of", "course", "the", "security", "of", "depends", "entirely", "on", "the", "randomness", "of", "the", "bytes", "in", "the", "secret", "." ]

[ "func", "(", "k", "NaclSigningKeyPair", ")", "EncryptToString", "(", "plaintext", "[", "]", "byte", ",", "sender", "GenericKey", ")", "(", "ciphertext", "string", ",", "err", "error", ")", "{", "err", "=", "KeyCannotEncryptError", "{", "}", "\n", "return", "\n", "}" ]

[ "EncryptToString", "fails", "for", "this", "type", "of", "key", "." ]

[ "func", "(", "k", "NaclDHKeyPair", ")", "Encrypt", "(", "msg", "[", "]", "byte", ",", "sender", "*", "NaclDHKeyPair", ")", "(", "*", "NaclEncryptionInfo", ",", "error", ")", "{", "if", "sender", "==", "nil", "{", "if", "tmp", ",", "err", ":=", "GenerateNaclDHKeyPair", "(", ")", ";", "err", "==", "nil", "{", "sender", "=", "&", "tmp", "\n", "}", "else", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "if", "sender", ".", "Private", "==", "nil", "{", "return", "nil", ",", "NoSecretKeyError", "{", "}", "\n", "}", "\n\n", "var", "nonce", "[", "NaclDHNonceSize", "]", "byte", "\n", "if", "nRead", ",", "err", ":=", "rand", ".", "Read", "(", "nonce", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "nRead", "!=", "NaclDHNonceSize", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "nRead", ")", "\n", "}", "\n\n", "var", "ctext", "[", "]", "byte", "\n", "ctext", "=", "box", ".", "Seal", "(", "ctext", ",", "msg", ",", "&", "nonce", ",", "(", "(", "*", "[", "32", "]", "byte", ")", "(", "&", "k", ".", "Public", ")", ")", ",", "(", "(", "*", "[", "32", "]", "byte", ")", "(", "sender", ".", "Private", ")", ")", ")", "\n", "ret", ":=", "&", "NaclEncryptionInfo", "{", "Ciphertext", ":", "ctext", ",", "EncryptionType", ":", "kbcrypto", ".", "KIDNaclDH", ",", "Nonce", ":", "nonce", "[", ":", "]", ",", "Receiver", ":", "k", ".", "GetKID", "(", ")", ".", "ToBytes", "(", ")", ",", "Sender", ":", "sender", ".", "GetKID", "(", ")", ".", "ToBytes", "(", ")", ",", "}", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "Encrypt", "a", "message", "to", "the", "key", "k", "from", "the", "given", "sender", ".", "If", "sender", "is", "nil", "an", "ephemeral", "keypair", "will", "be", "invented" ]

[ "func", "(", "k", "NaclDHKeyPair", ")", "EncryptToString", "(", "plaintext", "[", "]", "byte", ",", "sender", "GenericKey", ")", "(", "string", ",", "error", ")", "{", "var", "senderDh", "*", "NaclDHKeyPair", "\n", "if", "sender", "!=", "nil", "{", "var", "ok", "bool", "\n", "if", "senderDh", ",", "ok", "=", "sender", ".", "(", "*", "NaclDHKeyPair", ")", ";", "!", "ok", "{", "return", "\"", "\"", ",", "NoSecretKeyError", "{", "}", "\n", "}", "\n", "}", "\n\n", "info", ",", "err", ":=", "k", ".", "Encrypt", "(", "plaintext", ",", "senderDh", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "kbcrypto", ".", "EncodePacketToArmoredString", "(", "info", ")", "\n", "}" ]

[ "EncryptToString", "encrypts", "the", "plaintext", "using", "DiffieHelman", ";", "the", "this", "object", "is", "the", "receiver", "and", "the", "passed", "sender", "is", "optional", ".", "If", "not", "provided", "we", "ll", "make", "up", "an", "ephemeral", "key", "." ]

[ "func", "(", "k", "NaclDHKeyPair", ")", "DecryptFromString", "(", "ciphertext", "string", ")", "(", "msg", "[", "]", "byte", ",", "sender", "keybase1", ".", "KID", ",", "err", "error", ")", "{", "var", "nei", "NaclEncryptionInfo", "\n\n", "if", "nei", ",", "err", "=", "DecodeArmoredNaclEncryptionInfoPacket", "(", "ciphertext", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "return", "k", ".", "Decrypt", "(", "&", "nei", ")", "\n", "}" ]

[ "DecryptFromString", "decrypts", "the", "output", "of", "EncryptToString", "above", "and", "returns", "the", "kbcrypto", ".", "KID", "of", "the", "other", "end", "." ]

[ "func", "(", "c", "LoginUiClient", ")", "DisplayResetProgress", "(", "ctx", "context", ".", "Context", ",", "__arg", "DisplayResetProgressArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "In", "some", "flows", "the", "user", "will", "get" ]

[ "func", "(", "lp", "PDPKALoginPackage", ")", "PopulateArgs", "(", "h", "*", "HTTPArgs", ")", "{", "h", ".", "Add", "(", "\"", "\"", ",", "S", "{", "string", "(", "lp", ".", "pdpka4", ")", "}", ")", "\n", "h", ".", "Add", "(", "\"", "\"", ",", "S", "{", "string", "(", "lp", ".", "pdpka5", ")", "}", ")", "\n", "}" ]

[ "PopulateArgs", "populates", "the", "given", "HTTP", "args", "with", "parameters", "in", "this", "PDPKA", "package", ".", "Right", "now", "that", "includes", "v4", "and", "v5", "of", "the", "PDPKA", "login", "system", "." ]

[ "func", "(", "j", "*", "mdIDJournal", ")", "move", "(", "newDir", "string", ")", "(", "oldDir", "string", ",", "err", "error", ")", "{", "return", "j", ".", "j", ".", "move", "(", "newDir", ")", "\n", "}" ]

[ "Note", "that", "since", "diskJournal", ".", "move", "takes", "a", "pointer", "receiver", "so", "must", "this", "." ]

[ "func", "UninstallKBNM", "(", ")", "error", "{", "u", ",", "err", ":=", "CurrentUser", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "app", ":=", "hostmanifest", ".", "App", "{", "Name", ":", "kbnmAppName", ",", "}", "\n\n", "for", "_", ",", "whitelist", ":=", "range", "hostmanifest", ".", "KnownInstallers", "(", ")", "{", "if", "err", ":=", "whitelist", ".", "Uninstall", "(", "u", ",", "app", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "UninstallKBNM", "removes", "NativeMessaging", "whitelisting", "for", "KBNM", "." ]

[ "func", "InstallKBNM", "(", "path", "string", ")", "error", "{", "u", ",", "err", ":=", "CurrentUser", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// If we're installing in an overlay, we need to strip it as a prefix from", "// the path we detect.", "overlay", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "overlay", "!=", "\"", "\"", "{", "// This is a bit arcane because filepath.HasPrefix deprecated due to", "// being broken, but what it does is it attempts to map path as", "// relative to overlay. If it succeeds and they're both absolute paths", "// (which means the relative path won't start with \"../\"), then make", "// path an absolute path with the overlay removed", "// filepath.Rel takes care of normalizing paths which is an advantage", "// over direct string comparisons which would be simpler.", "rel", ",", "err", ":=", "filepath", ".", "Rel", "(", "overlay", ",", "path", ")", "\n", "if", "err", "==", "nil", "&&", "!", "strings", ".", "HasPrefix", "(", "rel", ",", "\"", "\"", ")", "{", "path", "=", "\"", "\"", "+", "rel", "\n", "}", "\n", "}", "\n\n", "app", ":=", "hostmanifest", ".", "App", "{", "Name", ":", "kbnmAppName", ",", "Description", ":", "\"", "\"", ",", "Path", ":", "path", ",", "Type", ":", "\"", "\"", ",", "}", "\n\n", "var", "manifest", "hostmanifest", ".", "AppManifest", "\n", "for", "browser", ",", "whitelist", ":=", "range", "hostmanifest", ".", "KnownInstallers", "(", ")", "{", "switch", "browser", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "manifest", "=", "hostmanifest", ".", "ChromeApp", "{", "App", ":", "app", ",", "AllowedOrigins", ":", "[", "]", "string", "{", "// Production public version in the store", "\"", "\"", ",", "// Hard-coded key from the repo version", "\"", "\"", ",", "// Keybase-internal version", "\"", "\"", ",", "}", ",", "}", "\n", "case", "\"", "\"", ":", "manifest", "=", "hostmanifest", ".", "FirefoxApp", "{", "App", ":", "app", ",", "AllowedExtensions", ":", "[", "]", "string", "{", "\"", "\"", ",", "}", ",", "}", "\n", "}", "\n\n", "if", "err", ":=", "whitelist", ".", "Install", "(", "u", ",", "manifest", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "InstallKBNM", "writes", "NativeMessaging", "whitelisting", "for", "KBNM", "." ]

[ "func", "(", "g", "*", "GlobalContext", ")", "ResetSocket", "(", "clearError", "bool", ")", "(", "net", ".", "Conn", ",", "rpc", ".", "Transporter", ",", "bool", ",", "error", ")", "{", "g", ".", "SocketWrapper", "=", "nil", "\n", "return", "g", ".", "GetSocket", "(", "clearError", ")", "\n", "}" ]

[ "ResetSocket", "clears", "and", "returns", "a", "new", "socket" ]

[ "func", "NewWalletState", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "r", "remote", ".", "Remoter", ")", "*", "WalletState", "{", "ws", ":=", "&", "WalletState", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "Remoter", ":", "r", ",", "accounts", ":", "make", "(", "map", "[", "stellar1", ".", "AccountID", "]", "*", "AccountState", ")", ",", "rates", ":", "make", "(", "map", "[", "string", "]", "rateEntry", ")", ",", "refreshGroup", ":", "&", "singleflight", ".", "Group", "{", "}", ",", "refreshReqs", ":", "make", "(", "chan", "stellar1", ".", "AccountID", ",", "100", ")", ",", "rateGroup", ":", "&", "singleflight", ".", "Group", "{", "}", ",", "options", ":", "NewOptions", "(", ")", ",", "}", "\n\n", "g", ".", "PushShutdownHook", "(", "ws", ".", "Shutdown", ")", "\n\n", "go", "ws", ".", "backgroundRefresh", "(", ")", "\n\n", "return", "ws", "\n", "}" ]

[ "NewWalletState", "creates", "a", "wallet", "state", "with", "a", "remoter", "that", "will", "be", "used", "for", "any", "network", "calls", "." ]