Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "(", "dbcr", "*", "DiskBlockCacheRemote", ")", "DeleteUnmarked", "(", "_", "context", ".", "Context", ",", "_", "tlf", ".", "ID", ",", "_", "string", ",", "_", "DiskBlockCacheType", ")", "error", "{", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "DeleteUnmarked", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheRemote", "." ]

[ "func", "(", "dbcr", "*", "DiskBlockCacheRemote", ")", "AddHomeTLF", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ")", "error", "{", "// Let the local cache care about home TLFs.", "return", "nil", "\n", "}" ]

[ "AddHomeTLF", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheRemote", "." ]

[ "func", "(", "dbcr", "*", "DiskBlockCacheRemote", ")", "GetTlfSize", "(", "_", "context", ".", "Context", ",", "_", "tlf", ".", "ID", ",", "_", "DiskBlockCacheType", ")", "(", "uint64", ",", "error", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetTlfSize", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheRemote", "." ]

[ "func", "(", "dbcr", "*", "DiskBlockCacheRemote", ")", "GetTlfIDs", "(", "_", "context", ".", "Context", ",", "_", "DiskBlockCacheType", ")", "(", "[", "]", "tlf", ".", "ID", ",", "error", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "GetTlfIDs", "implements", "the", "DiskBlockCache", "interface", "for", "DiskBlockCacheRemote", "." ]

[ "func", "formatUniqueRepoID", "(", "teamID", "keybase1", ".", "TeamID", ",", "repoID", "keybase1", ".", "RepoID", ")", "string", "{", "return", "string", "(", "teamID", ")", "+", "\"", "\"", "+", "string", "(", "repoID", ")", "\n", "}" ]

[ "The", "GUI", "needs", "a", "way", "to", "refer", "to", "repos" ]

[ "func", "folderFromTeamID", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "teamID", "keybase1", ".", "TeamID", ",", "isImplicit", "bool", ")", "(", "keybase1", ".", "Folder", ",", "error", ")", "{", "if", "isImplicit", "{", "return", "folderFromTeamIDImplicit", "(", "ctx", ",", "g", ",", "teamID", ")", "\n", "}", "\n", "return", "folderFromTeamIDNamed", "(", "ctx", ",", "g", ",", "teamID", ")", "\n", "}" ]

[ "Implicit", "teams", "need", "to", "be", "converted", "back", "into", "the", "folder", "that", "matches", "their", "display", "name", ".", "Regular", "teams", "become", "a", "regular", "team", "folder", "." ]

[ "func", "folderFromTeamIDImplicit", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "keybase1", ".", "Folder", ",", "error", ")", "{", "team", ",", "err", ":=", "teams", ".", "Load", "(", "ctx", ",", "g", ",", "keybase1", ".", "LoadTeamArg", "{", "ID", ":", "teamID", ",", "Public", ":", "teamID", ".", "IsPublic", "(", ")", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "Folder", "{", "}", ",", "err", "\n", "}", "\n", "if", "!", "team", ".", "IsImplicit", "(", ")", "{", "return", "keybase1", ".", "Folder", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "teamID", ")", "\n", "}", "\n\n", "// TODO: This function doesn't currently support conflict info.", "name", ",", "err", ":=", "team", ".", "ImplicitTeamDisplayNameString", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "keybase1", ".", "Folder", "{", "}", ",", "err", "\n", "}", "\n", "var", "folderType", "keybase1", ".", "FolderType", "\n", "if", "team", ".", "IsPublic", "(", ")", "{", "folderType", "=", "keybase1", ".", "FolderType_PUBLIC", "\n", "}", "else", "{", "folderType", "=", "keybase1", ".", "FolderType_PRIVATE", "\n", "}", "\n", "return", "keybase1", ".", "Folder", "{", "Name", ":", "name", ",", "FolderType", ":", "folderType", ",", "Private", ":", "!", "team", ".", "IsPublic", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "folderFromTeamIDImplicit", "converts", "from", "a", "teamID", "for", "implicit", "teams" ]

[ "func", "getMetadataInner", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "folder", "*", "keybase1", ".", "Folder", ")", "(", "[", "]", "keybase1", ".", "GitRepoResult", ",", "error", ")", "{", "mctx", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "g", ")", "\n", "teamer", ":=", "NewTeamer", "(", "g", ")", "\n\n", "apiArg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "Args", ":", "libkb", ".", "HTTPArgs", "{", "}", ",", "// a limit parameter exists, default 100, and we don't currently set it", "}", "\n\n", "// The team_id parameter is optional. Add it in if the caller supplied it.", "if", "folder", "!=", "nil", "{", "teamIDVis", ",", "err", ":=", "teamer", ".", "LookupOrCreate", "(", "ctx", ",", "*", "folder", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "apiArg", ".", "Args", "[", "\"", "\"", "]", "=", "libkb", ".", "S", "{", "Val", ":", "string", "(", "teamIDVis", ".", "TeamID", ")", "}", "\n", "}", "\n", "var", "serverResponse", "ServerResponse", "\n", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetAPI", "(", ")", ".", "GetDecode", "(", "mctx", ",", "apiArg", ",", "&", "serverResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Unbox the repos in parallel", "repoCh", ":=", "make", "(", "chan", "ServerResponseRepo", ")", "\n", "eg", ",", "ctx", ":=", "errgroup", ".", "WithContext", "(", "ctx", ")", "\n", "eg", ".", "Go", "(", "func", "(", ")", "error", "{", "defer", "close", "(", "repoCh", ")", "\n", "for", "_", ",", "responseRepo", ":=", "range", "serverResponse", ".", "Repos", "{", "select", "{", "case", "repoCh", "<-", "responseRepo", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n\n", "// Initializing the results list to non-nil means that we end up seeing", "// \"[]\" instead of \"null\" in the final JSON output on the CLI, which is", "// preferable.", "resultList", ":=", "[", "]", "keybase1", ".", "GitRepoResult", "{", "}", "\n", "var", "resLock", "sync", ".", "Mutex", "\n", "var", "firstErr", "error", "\n", "var", "anySuccess", "bool", "\n", "numUnboxThreads", ":=", "2", "\n", "for", "i", ":=", "0", ";", "i", "<", "numUnboxThreads", ";", "i", "++", "{", "eg", ".", "Go", "(", "func", "(", ")", "error", "{", "for", "responseRepo", ":=", "range", "repoCh", "{", "info", ",", "skip", ",", "err", ":=", "getMetadataInnerSingle", "(", "ctx", ",", "g", ",", "folder", ",", "responseRepo", ")", "\n\n", "resLock", ".", "Lock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "firstErr", "==", "nil", "{", "firstErr", "=", "err", "\n", "}", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "responseRepo", ".", "TeamID", ",", "responseRepo", ".", "RepoID", ",", "err", ")", "\n", "resultList", "=", "append", "(", "resultList", ",", "keybase1", ".", "NewGitRepoResultWithErr", "(", "err", ".", "Error", "(", ")", ")", ")", "\n", "}", "else", "{", "if", "!", "skip", "{", "anySuccess", "=", "true", "\n", "resultList", "=", "append", "(", "resultList", ",", "keybase1", ".", "NewGitRepoResultWithOk", "(", "*", "info", ")", ")", "\n", "}", "\n", "}", "\n", "resLock", ".", "Unlock", "(", ")", "\n\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}", "\n", "if", "err", ":=", "eg", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "return", "resultList", ",", "err", "\n", "}", "\n", "sort", ".", "Sort", "(", "ByRepoMtime", "(", "resultList", ")", ")", "\n\n", "// If there were no repos, return ok", "// If all repos failed, return the first error (something is probably wrong that's not repo-specific)", "// If no repos failed, return ok", "if", "len", "(", "resultList", ")", "==", "0", "{", "return", "resultList", ",", "nil", "\n", "}", "\n", "if", "!", "anySuccess", "{", "return", "resultList", ",", "firstErr", "\n", "}", "\n", "return", "resultList", ",", "nil", "\n", "}" ]

[ "If", "folder", "is", "nil", "get", "for", "all", "folders", "." ]

[ "func", "(", "g", "*", "GpgCLI", ")", "CanExec", "(", ")", "(", "bool", ",", "error", ")", "{", "err", ":=", "g", ".", "Configure", "(", ")", "\n", "if", "IsExecError", "(", "err", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "true", ",", "nil", "\n", "}" ]

[ "CanExec", "returns", "true", "if", "a", "gpg", "executable", "exists", "." ]

[ "func", "(", "m", "*", "MinTerm", ")", "getReadWriter", "(", ")", "io", ".", "ReadWriter", "{", "return", "WindowsReadWriter", "{", "r", ":", "m", ".", "termIn", ",", "w", ":", "logger", ".", "OutputWriterFromFile", "(", "m", ".", "termOut", ")", "}", "\n", "}" ]

[ "Use", "a", "Windows", "output", "writer", "to", "eat", "control", "codes", "that", "look", "ugly", "on", "legacy", "terminals", ".", "As", "a", "bonus", "we", "can", "do", "color", "prompts", "this", "way", "." ]

[ "func", "(", "s", "*", "PerUserKeySeed", ")", "derivePrevKey", "(", ")", "(", "res", "NaclSecretBoxKey", ",", "err", "error", ")", "{", "return", "s", ".", "DeriveSymmetricKey", "(", "DeriveReasonPUKPrev", ")", "\n", "}" ]

[ "derivePrevKey", "derives", "the", "symmetric", "key", "used", "to", "secretbox", "the", "previous", "generation", "seed", "." ]

[ "func", "openPerUserKeyPrev", "(", "sbox", "PerUserKeyPrev", ",", "symmetricKey", "NaclSecretBoxKey", ")", "(", "PerUserKeySeed", ",", "error", ")", "{", "var", "res", "PerUserKeySeed", "\n\n", "// decode b64", "msgpacked", ",", "err", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "string", "(", "sbox", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// decode msgpack", "mh", ":=", "codec", ".", "MsgpackHandle", "{", "WriteExt", ":", "true", "}", "\n", "dec", ":=", "codec", ".", "NewDecoderBytes", "(", "msgpacked", ",", "&", "mh", ")", "\n", "var", "parts", "struct", "{", "Version", "int", "\n", "Nonce", "[", "]", "byte", "\n", "Sealed", "[", "]", "byte", "\n", "}", "\n", "err", "=", "dec", ".", "Decode", "(", "&", "parts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// check parts", "if", "parts", ".", "Version", "!=", "1", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "parts", ".", "Version", ")", "\n", "}", "\n\n", "if", "len", "(", "parts", ".", "Nonce", ")", "!=", "NaclDHNonceSize", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "parts", ".", "Nonce", ")", ",", "NaclDHNonceSize", ")", "\n", "}", "\n", "var", "nonce", "[", "NaclDHNonceSize", "]", "byte", "\n", "copy", "(", "nonce", "[", ":", "]", ",", "parts", ".", "Nonce", ")", "\n\n", "expectedSealedLength", ":=", "PerUserKeySeedSize", "+", "secretbox", ".", "Overhead", "\n", "if", "len", "(", "parts", ".", "Sealed", ")", "!=", "expectedSealedLength", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "parts", ".", "Sealed", ")", ",", "expectedSealedLength", ")", "\n", "}", "\n\n", "// open secretbox", "var", "symmetricKey2", "[", "NaclSecretBoxKeySize", "]", "byte", "=", "symmetricKey", "\n", "contents", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "parts", ".", "Sealed", ",", "&", "nonce", ",", "&", "symmetricKey2", ")", "\n", "if", "!", "ok", "{", "return", "res", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "contents", ")", "!=", "PerUserKeySeedSize", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "contents", ")", ",", "PerUserKeySeedSize", ")", "\n", "}", "\n", "return", "MakeByte32", "(", "contents", ")", ",", "nil", "\n", "}" ]

[ "Opens", "the", "output", "of", "NewPerUserKeyPrev" ]

[ "func", "NewPerUserKeyring", "(", "g", "*", "GlobalContext", ",", "uid", "keybase1", ".", "UID", ")", "(", "*", "PerUserKeyring", ",", "error", ")", "{", "if", "uid", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "PerUserKeyring", "{", "Contextified", ":", "NewContextified", "(", "g", ")", ",", "uid", ":", "uid", ",", "generations", ":", "make", "(", "perUserKeyMap", ")", ",", "seqgen", ":", "make", "(", "perUserKeySeqGenMap", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewPerUserKeyring", "makes", "a", "new", "per", "-", "user", "-", "key", "keyring", "for", "a", "given", "UID", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "PrepareBoxForNewDevice", "(", "m", "MetaContext", ",", "receiverKey", "NaclDHKeyPair", ",", "senderKey", "NaclDHKeyPair", ")", "(", "box", "keybase1", ".", "PerUserKeyBox", ",", "err", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "gen", ":=", "s", ".", "currentGenerationLocked", "(", ")", "\n", "if", "gen", "<", "1", "{", "return", "box", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "full", ",", "ok", ":=", "s", ".", "generations", "[", "gen", "]", "\n", "if", "!", "ok", "{", "return", "box", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "box", ",", "err", "=", "NewPerUserKeyBox", "(", "full", ".", "seed", ",", "receiverKey", ",", "senderKey", ",", "gen", ")", "\n", "return", "box", ",", "err", "\n", "}" ]

[ "PrepareBoxForNewDevice", "encrypts", "the", "latest", "shared", "key", "seed", "for", "a", "new", "device", ".", "The", "returned", "box", "should", "be", "pushed", "to", "the", "server", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "PrepareBoxesForDevices", "(", "m", "MetaContext", ",", "contents", "PerUserKeySeed", ",", "generation", "keybase1", ".", "PerUserKeyGeneration", ",", "receiverKeys", "[", "]", "NaclDHKeyPair", ",", "senderKey", "GenericKey", ")", "(", "boxes", "[", "]", "keybase1", ".", "PerUserKeyBox", ",", "err", "error", ")", "{", "// Do not lock self because we do not use self.", "if", "contents", ".", "IsBlank", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "senderKeyDH", ",", "ok", ":=", "senderKey", ".", "(", "NaclDHKeyPair", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "senderKey", ")", "\n", "}", "\n\n", "for", "_", ",", "receiverKey", ":=", "range", "receiverKeys", "{", "box", ",", "err", ":=", "NewPerUserKeyBox", "(", "contents", ",", "receiverKey", ",", "senderKeyDH", ",", "generation", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "boxes", "=", "append", "(", "boxes", ",", "box", ")", "\n", "}", "\n", "return", "boxes", ",", "nil", "\n", "}" ]

[ "Encrypt", "seed", "for", "receiverKeys", ".", "Use", "senderKey", "to", "encrypt", ".", "Does", "not", "use", "the", "keyring", "at", "all", ".", "Attached", "for", "organizational", "purposes", ".", "Used", "when", "creating", "a", "new", "seed", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "PreparePrev", "(", "m", "MetaContext", ",", "newSeed", "PerUserKeySeed", ",", "newGeneration", "keybase1", ".", "PerUserKeyGeneration", ")", "(", "PerUserKeyPrev", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "if", "newSeed", ".", "IsBlank", "(", ")", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "currentGen", ":=", "s", ".", "currentGenerationLocked", "(", ")", "\n", "if", "currentGen", "==", "0", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "currentGen", "!=", "newGeneration", "-", "1", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "currentGen", ",", "newGeneration", ")", "\n", "}", "\n\n", "symmetricKey", ",", "err", ":=", "newSeed", ".", "derivePrevKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "contents", ":=", "s", ".", "generations", "[", "currentGen", "]", ".", "seed", "\n\n", "return", "newPerUserKeyPrev", "(", "contents", ",", "symmetricKey", ")", "\n", "}" ]

[ "Prepares", "a", "prev", "secretbox", "containing", "generation", "n", "-", "1", "encrypted", "for", "generation", "n", ".", "Asserts", "that", "the", "current", "generation", "is", "n", "-", "1", ".", "The", "generation", "parameter", "is", "n", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "AddKey", "(", "m", "MetaContext", ",", "generation", "keybase1", ".", "PerUserKeyGeneration", ",", "seqno", "keybase1", ".", "Seqno", ",", "seed", "PerUserKeySeed", ")", "error", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ",", "generation", ",", "seqno", ")", "\n\n", "if", "seed", ".", "IsBlank", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "currentGen", ":=", "s", ".", "currentGenerationLocked", "(", ")", "\n\n", "if", "generation", "!=", "currentGen", "+", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "generation", ",", "currentGen", ")", "\n", "}", "\n\n", "_", ",", "exists", ":=", "s", ".", "generations", "[", "generation", "]", "\n", "if", "exists", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "generation", ")", "\n", "}", "\n\n", "expanded", ",", "err", ":=", "expandPerUserKey", "(", "seed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "s", ".", "generations", "[", "generation", "]", "=", "expanded", ".", "lower", "(", ")", "\n", "s", ".", "seqgen", "[", "seqno", "]", "=", "generation", "\n\n", "return", "nil", "\n", "}" ]

[ "AddKey", "registers", "a", "full", "key", "locally", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "CurrentGeneration", "(", ")", "keybase1", ".", "PerUserKeyGeneration", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n", "return", "s", ".", "currentGenerationLocked", "(", ")", "\n", "}" ]

[ "CurrentGeneration", "returns", "what", "generation", "we", "re", "on", ".", "The", "version", "possible", "Version", "is", "1", ".", "Version", "0", "implies", "no", "keys", "are", "available", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "GetEncryptionKeyByGeneration", "(", "m", "MetaContext", ",", "gen", "keybase1", ".", "PerUserKeyGeneration", ")", "(", "*", "NaclDHKeyPair", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "return", "s", ".", "getEncryptionKeyByGenerationLocked", "(", "m", ",", "gen", ")", "\n", "}" ]

[ "Get", "the", "encryption", "key", "of", "a", "generation", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "GetEncryptionKeyBySeqno", "(", "m", "MetaContext", ",", "seqno", "keybase1", ".", "Seqno", ")", "(", "*", "NaclDHKeyPair", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "gen", ",", "ok", ":=", "s", ".", "seqgen", "[", "seqno", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "seqno", ")", "\n", "}", "\n", "return", "s", ".", "getEncryptionKeyByGenerationLocked", "(", "m", ",", "gen", ")", "\n", "}" ]

[ "Get", "the", "encryption", "key", "at", "the", "user", "sigchain", "seqno", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "GetEncryptionKeyByKID", "(", "m", "MetaContext", ",", "kid", "keybase1", ".", "KID", ")", "(", "*", "NaclDHKeyPair", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "key", ":=", "range", "s", ".", "generations", "{", "if", "key", ".", "encKey", ".", "GetKID", "(", ")", ".", "Equal", "(", "kid", ")", "{", "return", "key", ".", "encKey", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "NotFoundError", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "kid", ")", "}", "\n", "}" ]

[ "GetEncryptionKeyByKID", "finds", "an", "encryption", "key", "that", "matches", "kid", "." ]

[ "func", "(", "s", "*", "PerUserKeyring", ")", "Sync", "(", "m", "MetaContext", ")", "(", "err", "error", ")", "{", "return", "s", ".", "syncAsConfiguredDevice", "(", "m", ",", "nil", ")", "\n", "}" ]

[ "Sync", "our", "PerUserKeyring", "with", "the", "server", ".", "It", "will", "either", "add", "all", "new", "keys", "since", "our", "last", "update", "or", "not", "at", "all", "if", "there", "was", "an", "error", ".", "Pass", "it", "a", "standard", "Go", "network", "context", "." ]

[ "func", "(", "c", "*", "perUserKeyChecker", ")", "checkPublic", "(", "key", "importedPerUserKey", ",", "generation", "keybase1", ".", "PerUserKeyGeneration", ")", "error", "{", "// sig key", "if", "expectedSigKID", ",", "ok", ":=", "c", ".", "expectedPUKSigKIDs", "[", "generation", "]", ";", "ok", "{", "if", "!", "expectedSigKID", ".", "SecureEqual", "(", "key", ".", "sigKey", ".", "GetKID", "(", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "expectedSigKID", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "generation", ")", "\n", "}", "\n\n", "// enc key", "if", "expectedEncKID", ",", "ok", ":=", "c", ".", "expectedPUKEncKIDs", "[", "generation", "]", ";", "ok", "{", "if", "!", "expectedEncKID", ".", "SecureEqual", "(", "key", ".", "encKey", ".", "GetKID", "(", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "expectedEncKID", ".", "String", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "generation", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkPublic", "checks", "that", "a", "key", "matches", "the", "KIDs", "published", "by", "the", "user", "." ]

[ "func", "importPerUserKeyBox", "(", "box", "*", "keybase1", ".", "PerUserKeyBox", ",", "decryptionKey", "GenericKey", ",", "wantedGeneration", "keybase1", ".", "PerUserKeyGeneration", ",", "checker", "*", "perUserKeyChecker", ")", "(", "*", "importedPerUserKey", ",", "error", ")", "{", "if", "box", "==", "nil", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "box", ".", "Generation", "!=", "wantedGeneration", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ",", "box", ".", "Generation", ")", "\n", "}", "\n", "if", "!", "decryptionKey", ".", "GetKID", "(", ")", ".", "Equal", "(", "box", ".", "ReceiverKID", ")", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ",", "box", ".", "ReceiverKID", ".", "String", "(", ")", ")", "\n", "}", "\n", "rawKey", ",", "encryptingKID", ",", "err", ":=", "decryptionKey", ".", "DecryptFromString", "(", "box", ".", "Box", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "checker", ".", "allowedEncryptingKIDs", ")", "==", "0", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "checker", ".", "allowedEncryptingKIDs", "[", "encryptingKID", "]", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ",", "encryptingKID", ")", "\n", "}", "\n", "seed", ",", "err", ":=", "MakeByte32Soft", "(", "rawKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "imp", ",", "err", ":=", "expandPerUserKey", "(", "seed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "NewPerUserKeyImportError", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "checker", ".", "checkPublic", "(", "imp", ",", "wantedGeneration", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "imp", ",", "nil", "\n", "}" ]

[ "Decrypt", "expand", "and", "check", "a", "per", "-", "user", "-", "key", "from", "a", "Box", "." ]

[ "func", "importPerUserKeyPrev", "(", "generation", "keybase1", ".", "PerUserKeyGeneration", ",", "prev", "perUserKeyPrevResp", ",", "decryptionKey", "NaclSecretBoxKey", ",", "wantedGeneration", "keybase1", ".", "PerUserKeyGeneration", ",", "checker", "*", "perUserKeyChecker", ")", "(", "*", "importedPerUserKey", ",", "error", ")", "{", "if", "generation", "!=", "prev", ".", "Generation", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "generation", ",", "prev", ".", "Generation", ")", "\n", "}", "\n\n", "seed", ",", "err", ":=", "openPerUserKeyPrev", "(", "prev", ".", "Ctext", ",", "decryptionKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "imp", ",", "err", ":=", "expandPerUserKey", "(", "seed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "checker", ".", "checkPublic", "(", "imp", ",", "generation", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "imp", ",", "nil", "\n", "}" ]

[ "Decrypt", "expand", "and", "check", "a", "per", "-", "user", "-", "key", "from", "a", "SecretBox", "." ]

[ "func", "MakeLocalUsers", "(", "users", "[", "]", "kbname", ".", "NormalizedUsername", ")", "[", "]", "LocalUser", "{", "localUsers", ":=", "make", "(", "[", "]", "LocalUser", ",", "len", "(", "users", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "users", ")", ";", "i", "++", "{", "verifyingKey", ":=", "MakeLocalUserVerifyingKeyOrBust", "(", "users", "[", "i", "]", ")", "\n", "cryptPublicKey", ":=", "MakeLocalUserCryptPublicKeyOrBust", "(", "users", "[", "i", "]", ")", "\n", "localUsers", "[", "i", "]", "=", "LocalUser", "{", "UserInfo", ":", "UserInfo", "{", "Name", ":", "users", "[", "i", "]", ",", "UID", ":", "keybase1", ".", "MakeTestUID", "(", "uint32", "(", "i", "+", "1", ")", ")", ",", "VerifyingKeys", ":", "[", "]", "kbfscrypto", ".", "VerifyingKey", "{", "verifyingKey", "}", ",", "CryptPublicKeys", ":", "[", "]", "kbfscrypto", ".", "CryptPublicKey", "{", "cryptPublicKey", "}", ",", "KIDNames", ":", "map", "[", "keybase1", ".", "KID", "]", "string", "{", "verifyingKey", ".", "KID", "(", ")", ":", "\"", "\"", ",", "}", ",", "}", ",", "CurrentCryptPublicKeyIndex", ":", "0", ",", "CurrentVerifyingKeyIndex", ":", "0", ",", "}", "\n", "}", "\n", "return", "localUsers", "\n", "}" ]

[ "MakeLocalUsers", "is", "a", "helper", "function", "to", "generate", "a", "list", "of", "LocalUsers", "suitable", "to", "use", "with", "KeybaseDaemonLocal", "." ]

[ "func", "(", "lu", "*", "LocalUser", ")", "GetPublicKeys", "(", ")", "[", "]", "keybase1", ".", "PublicKey", "{", "sibkeys", ":=", "verifyingKeysToPublicKeys", "(", "lu", ".", "VerifyingKeys", ")", "\n", "subkeys", ":=", "cryptPublicKeysToPublicKeys", "(", "lu", ".", "CryptPublicKeys", ")", "\n", "return", "append", "(", "sibkeys", ",", "subkeys", "...", ")", "\n", "}" ]

[ "GetPublicKeys", "returns", "all", "of", "this", "LocalUser", "s", "public", "encryption", "keys", "." ]

[ "func", "(", "lu", "LocalUser", ")", "DeepCopy", "(", ")", "LocalUser", "{", "luCopy", ":=", "lu", "\n\n", "luCopy", ".", "VerifyingKeys", "=", "make", "(", "[", "]", "kbfscrypto", ".", "VerifyingKey", ",", "len", "(", "lu", ".", "VerifyingKeys", ")", ")", "\n", "copy", "(", "luCopy", ".", "VerifyingKeys", ",", "lu", ".", "VerifyingKeys", ")", "\n\n", "luCopy", ".", "CryptPublicKeys", "=", "make", "(", "[", "]", "kbfscrypto", ".", "CryptPublicKey", ",", "len", "(", "lu", ".", "CryptPublicKeys", ")", ")", "\n", "copy", "(", "luCopy", ".", "CryptPublicKeys", ",", "lu", ".", "CryptPublicKeys", ")", "\n\n", "luCopy", ".", "KIDNames", "=", "make", "(", "map", "[", "keybase1", ".", "KID", "]", "string", ",", "len", "(", "lu", ".", "KIDNames", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "lu", ".", "KIDNames", "{", "luCopy", ".", "KIDNames", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "luCopy", ".", "RevokedVerifyingKeys", "=", "make", "(", "map", "[", "kbfscrypto", ".", "VerifyingKey", "]", "RevokedKeyInfo", ",", "len", "(", "lu", ".", "RevokedVerifyingKeys", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "lu", ".", "RevokedVerifyingKeys", "{", "luCopy", ".", "RevokedVerifyingKeys", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "luCopy", ".", "RevokedCryptPublicKeys", "=", "make", "(", "map", "[", "kbfscrypto", ".", "CryptPublicKey", "]", "RevokedKeyInfo", ",", "len", "(", "lu", ".", "RevokedCryptPublicKeys", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "lu", ".", "RevokedCryptPublicKeys", "{", "luCopy", ".", "RevokedCryptPublicKeys", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "luCopy", ".", "Asserts", "=", "make", "(", "[", "]", "string", ",", "len", "(", "lu", ".", "Asserts", ")", ")", "\n", "copy", "(", "luCopy", ".", "Asserts", ",", "lu", ".", "Asserts", ")", "\n", "luCopy", ".", "UnverifiedKeys", "=", "make", "(", "[", "]", "keybase1", ".", "PublicKey", ",", "len", "(", "lu", ".", "UnverifiedKeys", ")", ")", "\n", "copy", "(", "luCopy", ".", "UnverifiedKeys", ",", "lu", ".", "UnverifiedKeys", ")", "\n\n", "return", "luCopy", "\n", "}" ]

[ "DeepCopy", "returns", "a", "deep", "copy", "of", "this", "LocalUser", "." ]

[ "func", "MakeLocalUserSigningKeyOrBust", "(", "name", "kbname", ".", "NormalizedUsername", ")", "kbfscrypto", ".", "SigningKey", "{", "return", "kbfscrypto", ".", "MakeFakeSigningKeyOrBust", "(", "string", "(", "name", ")", "+", "\"", "\"", ")", "\n", "}" ]

[ "Helper", "functions", "to", "get", "a", "various", "keys", "for", "a", "local", "user", ".", "Each", "function", "will", "return", "the", "same", "key", "will", "always", "be", "returned", "for", "a", "given", "user", ".", "MakeLocalUserSigningKeyOrBust", "returns", "a", "unique", "signing", "key", "for", "this", "user", "." ]

[ "func", "MakeLocalUserCryptPrivateKeyOrBust", "(", "name", "kbname", ".", "NormalizedUsername", ")", "kbfscrypto", ".", "CryptPrivateKey", "{", "return", "kbfscrypto", ".", "MakeFakeCryptPrivateKeyOrBust", "(", "string", "(", "name", ")", "+", "\"", "\"", ")", "\n", "}" ]

[ "MakeLocalUserCryptPrivateKeyOrBust", "returns", "a", "unique", "private", "encryption", "key", "for", "this", "user", "." ]

[ "func", "MakeLocalTLFCryptKeyOrBust", "(", "name", "string", ",", "keyGen", "kbfsmd", ".", "KeyGen", ")", "kbfscrypto", ".", "TLFCryptKey", "{", "// Put the key gen first to make it more likely to fit into the", "// 32-character \"random\" seed.", "return", "kbfscrypto", ".", "MakeFakeTLFCryptKeyOrBust", "(", "string", "(", "name", ")", "+", "\"", "\"", "+", "string", "(", "keyGen", ")", "+", "\"", "\"", ")", "\n", "}" ]

[ "MakeLocalTLFCryptKeyOrBust", "returns", "a", "unique", "private", "symmetric", "key", "for", "a", "TLF", "." ]

[ "func", "KeybaseServiceInfo", "(", "g", "*", "GlobalContext", ")", "ServiceInfo", "{", "return", "ServiceInfo", "{", "Version", ":", "VersionString", "(", ")", ",", "Label", ":", "g", ".", "Env", ".", "GetLabel", "(", ")", ",", "Pid", ":", "os", ".", "Getpid", "(", ")", ",", "}", "\n", "}" ]

[ "KeybaseServiceInfo", "is", "runtime", "info", "for", "the", "Keybase", "service", "." ]

[ "func", "(", "s", "ServiceInfo", ")", "WriteFile", "(", "path", "string", ",", "log", "logger", ".", "Logger", ")", "error", "{", "out", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "file", ":=", "NewFile", "(", "path", ",", "[", "]", "byte", "(", "out", ")", ",", "0644", ")", "\n", "return", "file", ".", "Save", "(", "log", ")", "\n", "}" ]

[ "WriteFile", "writes", "service", "info", "as", "JSON", "in", "runtimeDir", "." ]

[ "func", "WaitForServiceInfoFile", "(", "path", "string", ",", "label", "string", ",", "pid", "string", ",", "timeout", "time", ".", "Duration", ",", "log", "serviceLog", ")", "(", "*", "ServiceInfo", ",", "error", ")", "{", "if", "pid", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "lookForServiceInfo", ":=", "func", "(", ")", "(", "*", "ServiceInfo", ",", "error", ")", "{", "serviceInfo", ",", "err", ":=", "LoadServiceInfo", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "serviceInfo", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// Make sure the info file is the pid we are waiting for, otherwise it is", "// still starting up.", "if", "pid", "!=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "serviceInfo", ".", "Pid", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// PIDs match, the service has started up", "return", "serviceInfo", ",", "nil", "\n", "}", "\n\n", "log", ".", "Debug", "(", "\"", "\"", ",", "timeout", ")", "\n", "serviceInfo", ",", "err", ":=", "waitForServiceInfo", "(", "timeout", ",", "time", ".", "Millisecond", "*", "100", ",", "lookForServiceInfo", ")", "\n\n", "// If no service info was found, let's return an error", "if", "serviceInfo", "==", "nil", "{", "if", "err", "==", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "label", ",", "pid", ")", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "// We succeeded in finding service info", "log", ".", "Debug", "(", "\"", "\"", ",", "*", "serviceInfo", ")", "\n", "return", "serviceInfo", ",", "nil", "\n", "}" ]

[ "WaitForServiceInfoFile", "tries", "to", "wait", "for", "a", "service", "info", "file", "which", "should", "be", "written", "on", "successful", "service", "startup", "." ]

[ "func", "(", "h", "*", "Helper", ")", "GetChannelTopicName", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "topicType", "chat1", ".", "TopicType", ",", "convID", "chat1", ".", "ConversationID", ")", "(", "topicName", "string", ",", "err", "error", ")", "{", "defer", "h", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "h", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "teamID", ".", "String", "(", ")", ",", "convID", ".", "String", "(", ")", ")", "\n", "kuid", ",", "err", ":=", "CurrentUID", "(", "h", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "topicName", ",", "err", "\n", "}", "\n", "uid", ":=", "gregor1", ".", "UID", "(", "kuid", ".", "ToBytes", "(", ")", ")", "\n", "tlfID", ",", "err", ":=", "chat1", ".", "TeamIDToTLFID", "(", "teamID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "topicName", ",", "err", "\n", "}", "\n", "query", ":=", "&", "chat1", ".", "GetInboxLocalQuery", "{", "ConvIDs", ":", "[", "]", "chat1", ".", "ConversationID", "{", "convID", "}", ",", "}", "\n", "inbox", ",", "_", ",", "err", ":=", "h", ".", "G", "(", ")", ".", "InboxSource", ".", "Read", "(", "ctx", ",", "uid", ",", "types", ".", "ConversationLocalizerBlocking", ",", "types", ".", "InboxSourceDataSourceAll", ",", "nil", ",", "query", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "topicName", ",", "err", "\n", "}", "\n", "h", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "inbox", ".", "Convs", ")", ")", "\n", "for", "_", ",", "conv", ":=", "range", "inbox", ".", "Convs", "{", "if", "conv", ".", "GetConvID", "(", ")", ".", "Eq", "(", "convID", ")", "&&", "conv", ".", "GetMembersType", "(", ")", "==", "chat1", ".", "ConversationMembersType_TEAM", "{", "return", "conv", ".", "Info", ".", "TopicName", ",", "nil", "\n", "}", "\n", "}", "\n", "// Fallback to TeamChannelSource", "h", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "topicName", ",", "err", "=", "h", ".", "G", "(", ")", ".", "TeamChannelSource", ".", "GetChannelTopicName", "(", "ctx", ",", "uid", ",", "tlfID", ",", "topicType", ",", "convID", ")", "\n", "return", "topicName", ",", "err", "\n", "}" ]

[ "GetChannelTopicName", "gets", "the", "name", "of", "a", "team", "channel", "even", "if", "it", "s", "not", "in", "the", "inbox", "." ]

[ "func", "postJoinLeave", "(", "ctx", "context", ".", "Context", ",", "g", "*", "globals", ".", "Context", ",", "ri", "func", "(", ")", "chat1", ".", "RemoteInterface", ",", "uid", "gregor1", ".", "UID", ",", "convID", "chat1", ".", "ConversationID", ",", "body", "chat1", ".", "MessageBody", ")", "(", "err", "error", ")", "{", "typ", ",", "err", ":=", "body", ".", "MessageType", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "switch", "typ", "{", "case", "chat1", ".", "MessageType_JOIN", ",", "chat1", ".", "MessageType_LEAVE", ":", "// good", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "typ", ")", "\n", "}", "\n\n", "// Get the conversation from the inbox.", "query", ":=", "chat1", ".", "GetInboxLocalQuery", "{", "ConvIDs", ":", "[", "]", "chat1", ".", "ConversationID", "{", "convID", "}", ",", "}", "\n", "ib", ",", "_", ",", "err", ":=", "g", ".", "InboxSource", ".", "Read", "(", "ctx", ",", "uid", ",", "types", ".", "ConversationLocalizerBlocking", ",", "types", ".", "InboxSourceDataSourceAll", ",", "nil", ",", "&", "query", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "ib", ".", "Convs", ")", "!=", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "ib", ".", "Convs", ")", ")", "\n", "}", "\n\n", "conv", ":=", "ib", ".", "Convs", "[", "0", "]", "\n", "if", "conv", ".", "GetTopicType", "(", ")", "!=", "chat1", ".", "TopicType_CHAT", "{", "// only post these in chat convs", "return", "nil", "\n", "}", "\n", "plaintext", ":=", "chat1", ".", "MessagePlaintext", "{", "ClientHeader", ":", "chat1", ".", "MessageClientHeader", "{", "Conv", ":", "conv", ".", "Info", ".", "Triple", ",", "TlfName", ":", "conv", ".", "Info", ".", "TlfName", ",", "TlfPublic", ":", "conv", ".", "Info", ".", "Visibility", "==", "keybase1", ".", "TLFVisibility_PUBLIC", ",", "MessageType", ":", "typ", ",", "Supersedes", ":", "chat1", ".", "MessageID", "(", "0", ")", ",", "Deletes", ":", "nil", ",", "Prev", ":", "nil", ",", "// Filled by Sender", "Sender", ":", "nil", ",", "// Filled by Sender", "SenderDevice", ":", "nil", ",", "// Filled by Sender", "MerkleRoot", ":", "nil", ",", "// Filled by Boxer", "OutboxID", ":", "nil", ",", "OutboxInfo", ":", "nil", ",", "}", ",", "MessageBody", ":", "body", ",", "}", "\n\n", "// Send with a blocking sender", "sender", ":=", "NewBlockingSender", "(", "g", ",", "NewBoxer", "(", "g", ")", ",", "ri", ")", "\n", "_", ",", "_", ",", "err", "=", "sender", ".", "Send", "(", "ctx", ",", "convID", ",", "plaintext", ",", "0", ",", "nil", ",", "nil", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "Post", "a", "join", "or", "leave", "message", ".", "Must", "be", "called", "when", "the", "user", "is", "in", "the", "conv", ".", "Uses", "a", "blocking", "sender", "." ]

[ "func", "CheckAndRecordBodyHash", "(", "ctx", "context", ".", "Context", ",", "g", "*", "globals", ".", "Context", ",", "bodyHash", "chat1", ".", "Hash", ",", "uniqueMsgID", "chat1", ".", "MessageID", ",", "uniqueConvID", "chat1", ".", "ConversationID", ")", "error", "{", "bodyHashKey", ":=", "makeBodyHashIndexKey", "(", "bodyHash", ")", "\n", "bodyHashValue", ":=", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "uniqueConvID", ",", "uniqueMsgID", ")", ")", "\n", "existingVal", ",", "found", ",", "err", ":=", "g", ".", "LocalChatDb", ".", "GetRaw", "(", "bodyHashKey", ")", "\n", "// Log errors as warnings, and skip this check. That prevents a corrupt", "// leveldb cache from breaking chat.", "if", "err", "!=", "nil", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "found", "{", "if", "!", "bytes", ".", "Equal", "(", "existingVal", ",", "bodyHashValue", ")", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "existingVal", ")", ",", "string", "(", "bodyHashValue", ")", ")", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "err", "=", "g", ".", "LocalChatDb", ".", "PutRaw", "(", "bodyHashKey", ",", "bodyHashValue", ")", "\n", "// Also suppress write errors.", "if", "err", "!=", "nil", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndRecordBodyHash", "checks", "the", "current", "message", "s", "body", "hash", "against", "all", "the", "body", "hashes", "we", "ve", "seen", "to", "prevent", "replays", ".", "If", "the", "header", "hash", "is", "new", "add", "it", "to", "the", "set", "." ]

[ "func", "CheckAndRecordPrevPointer", "(", "ctx", "context", ".", "Context", ",", "g", "*", "globals", ".", "Context", ",", "msgID", "chat1", ".", "MessageID", ",", "convID", "chat1", ".", "ConversationID", ",", "uniqueHeaderHash", "chat1", ".", "Hash", ")", "error", "{", "prevKey", ":=", "makePrevIndexKey", "(", "convID", ",", "msgID", ")", "\n", "headerHashVal", ":=", "makePrevIndexValue", "(", "uniqueHeaderHash", ")", "\n", "existingVal", ",", "found", ",", "err", ":=", "g", ".", "LocalChatDb", ".", "GetRaw", "(", "prevKey", ")", "\n", "// Log errors as warnings, and skip this check. That prevents a corrupt", "// leveldb cache from breaking chat.", "if", "err", "!=", "nil", "{", "g", ".", "Log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "found", "{", "if", "!", "bytes", ".", "Equal", "(", "existingVal", ",", "headerHashVal", ")", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "convID", ".", "String", "(", ")", ",", "msgID", ".", "String", "(", ")", ")", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "string", "(", "existingVal", ")", ",", "string", "(", "headerHashVal", ")", ")", "\n", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "existingVal", ")", ",", "string", "(", "headerHashVal", ")", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "string", "(", "headerHashVal", ")", ",", "convID", ".", "String", "(", ")", ",", "msgID", ".", "String", "(", ")", ")", "\n", "err", "=", "g", ".", "LocalChatDb", ".", "PutRaw", "(", "prevKey", ",", "headerHashVal", ")", "\n", "// Also suppress write errors.", "if", "err", "!=", "nil", "{", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndRecordPrevPointer", "checks", "the", "current", "message", "s", "header", "hash", "against", "all", "the", "prev", "pointers", "we", "ve", "ever", "seen", ".", "If", "the", "current", "message", "is", "new", "add", "it", "to", "the", "set", "." ]

[ "func", "SetLogFileConfig", "(", "lfc", "*", "LogFileConfig", ")", "error", "{", "globalLock", ".", "Lock", "(", ")", "\n", "defer", "globalLock", ".", "Unlock", "(", ")", "\n\n", "first", ":=", "true", "\n", "var", "w", "=", "currentLogFileWriter", "\n", "if", "w", "!=", "nil", "{", "first", "=", "false", "\n", "w", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "w", ".", "lock", ".", "Unlock", "(", ")", "\n", "w", ".", "Close", "(", ")", "\n", "w", ".", "config", "=", "*", "lfc", "\n", "}", "else", "{", "w", "=", "NewLogFileWriter", "(", "*", "lfc", ")", "\n\n", "// Clean up the default logger, if it is in use", "select", "{", "case", "stdErrLoggingShutdown", "<-", "struct", "{", "}", "{", "}", ":", "default", ":", "}", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "Open", "(", "time", ".", "Now", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "first", "{", "buf", ",", "shutdown", ",", "_", ":=", "NewAutoFlushingBufferedWriter", "(", "w", ",", "loggingFrequency", ")", "\n", "w", ".", "stopFlushing", "=", "shutdown", "\n", "fileBackend", ":=", "logging", ".", "NewLogBackend", "(", "buf", ",", "\"", "\"", ",", "0", ")", "\n", "logging", ".", "SetBackend", "(", "fileBackend", ")", "\n\n", "stderrIsTerminal", "=", "false", "\n", "currentLogFileWriter", "=", "w", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetLogFileConfig", "sets", "the", "log", "file", "config", "to", "be", "used", "globally", "." ]

[ "func", "scanOldLogFiles", "(", "path", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "dname", ",", "fname", ":=", "filepath", ".", "Split", "(", "path", ")", "\n", "if", "dname", "==", "\"", "\"", "{", "dname", "=", "\"", "\"", "\n", "}", "\n", "dir", ",", "err", ":=", "os", ".", "Open", "(", "dname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "dir", ".", "Close", "(", ")", "\n", "ns", ",", "err", ":=", "dir", ".", "Readdirnames", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "names", ",", "err", ":=", "getLogFilenamesOrderByTime", "(", "fname", ",", "ns", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "res", "[", "]", "string", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "res", "=", "append", "(", "res", ",", "filepath", ".", "Join", "(", "dname", ",", "name", ")", ")", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "scanOldLogFiles", "finds", "old", "archived", "log", "files", "corresponding", "to", "the", "log", "file", "path", ".", "Returns", "the", "list", "of", "such", "log", "files", "sorted", "with", "the", "eldest", "one", "first", "." ]

[ "func", "(", "ei", "*", "ExtendedIdentify", ")", "OnError", "(", "ctx", "context", ".", "Context", ")", "{", "if", "ei", ".", "userBreaks", "==", "nil", "{", "return", "\n", "}", "\n\n", "// The identify got an error, so just send a nil breaks list so", "// that the goroutine waiting on the breaks can finish and the", "// error can be returned.", "select", "{", "case", "ei", ".", "userBreaks", "<-", "keybase1", ".", "TLFIdentifyFailure", "{", "Breaks", ":", "nil", ",", "User", ":", "keybase1", ".", "User", "{", "}", ",", "}", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "}", "\n", "}" ]

[ "OnError", "is", "called", "when", "the", "identify", "process", "has", "encountered", "a", "hard", "error", "." ]

[ "func", "MakeExtendedIdentify", "(", "ctx", "context", ".", "Context", ",", "behavior", "keybase1", ".", "TLFIdentifyBehavior", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "if", "_", ",", "ok", ":=", "ctx", ".", "Value", "(", "ctxExtendedIdentifyKey", ")", ".", "(", "*", "ExtendedIdentify", ")", ";", "ok", "{", "return", "nil", ",", "ExtendedIdentifyAlreadyExists", "{", "}", "\n", "}", "\n\n", "if", "!", "behavior", ".", "WarningInsteadOfErrorOnBrokenTracks", "(", ")", "{", "return", "libcontext", ".", "NewContextReplayable", "(", "ctx", ",", "func", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "ctxExtendedIdentifyKey", ",", "&", "ExtendedIdentify", "{", "Behavior", ":", "behavior", ",", "}", ")", "\n", "}", ")", ",", "nil", "\n", "}", "\n\n", "ch", ":=", "make", "(", "chan", "keybase1", ".", "TLFIdentifyFailure", ")", "\n", "return", "libcontext", ".", "NewContextReplayable", "(", "ctx", ",", "func", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "ctxExtendedIdentifyKey", ",", "&", "ExtendedIdentify", "{", "Behavior", ":", "behavior", ",", "userBreaks", ":", "ch", ",", "}", ")", "\n", "}", ")", ",", "nil", "\n", "}" ]

[ "MakeExtendedIdentify", "populates", "a", "context", "with", "an", "ExtendedIdentify", "directive", "." ]

[ "func", "GetExtendedIdentify", "(", "ctx", "context", ".", "Context", ")", "(", "ei", "*", "ExtendedIdentify", ")", "{", "if", "ei", ",", "ok", ":=", "ctx", ".", "Value", "(", "ctxExtendedIdentifyKey", ")", ".", "(", "*", "ExtendedIdentify", ")", ";", "ok", "{", "return", "ei", "\n", "}", "\n", "return", "&", "ExtendedIdentify", "{", "Behavior", ":", "keybase1", ".", "TLFIdentifyBehavior_DEFAULT_KBFS", ",", "}", "\n", "}" ]

[ "GetExtendedIdentify", "returns", "the", "extended", "identify", "info", "associated", "with", "the", "given", "context", "." ]

[ "func", "identifyUser", "(", "ctx", "context", ".", "Context", ",", "nug", "idutil", ".", "NormalizedUsernameGetter", ",", "identifier", "idutil", ".", "Identifier", ",", "name", "kbname", ".", "NormalizedUsername", ",", "id", "keybase1", ".", "UserOrTeamID", ",", "t", "tlf", ".", "Type", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "error", "{", "// Check to see if identify should be skipped altogether.", "ei", ":=", "GetExtendedIdentify", "(", "ctx", ")", "\n", "if", "ei", ".", "Behavior", "==", "keybase1", ".", "TLFIdentifyBehavior_CHAT_SKIP", "{", "return", "nil", "\n", "}", "\n\n", "var", "reason", "string", "\n", "nameAssertion", ":=", "name", ".", "String", "(", ")", "\n", "isImplicit", ":=", "false", "\n", "switch", "t", "{", "case", "tlf", ".", "Public", ":", "if", "id", ".", "IsTeam", "(", ")", "{", "isImplicit", "=", "true", "\n", "}", "\n", "reason", "=", "\"", "\"", "\n", "case", "tlf", ".", "Private", ":", "if", "id", ".", "IsTeam", "(", ")", "{", "isImplicit", "=", "true", "\n", "reason", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "nameAssertion", ")", "\n", "}", "else", "{", "reason", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "nameAssertion", ")", "\n", "}", "\n", "case", "tlf", ".", "SingleTeam", ":", "reason", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "nameAssertion", ")", "\n", "nameAssertion", "=", "\"", "\"", "+", "nameAssertion", "\n", "}", "\n", "var", "resultName", "kbname", ".", "NormalizedUsername", "\n", "var", "resultID", "keybase1", ".", "UserOrTeamID", "\n", "if", "isImplicit", "{", "assertions", ",", "extensionSuffix", ",", "err", ":=", "tlf", ".", "SplitExtension", "(", "name", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "iteamInfo", ",", "err", ":=", "identifier", ".", "IdentifyImplicitTeam", "(", "ctx", ",", "assertions", ",", "extensionSuffix", ",", "t", ",", "reason", ",", "offline", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "resultName", "=", "iteamInfo", ".", "Name", "\n", "resultID", "=", "iteamInfo", ".", "TID", ".", "AsUserOrTeam", "(", ")", "\n", "}", "else", "{", "var", "err", "error", "\n", "resultName", ",", "resultID", ",", "err", "=", "identifier", ".", "Identify", "(", "ctx", ",", "nameAssertion", ",", "reason", ",", "offline", ")", "\n", "if", "err", "!=", "nil", "{", "// Convert libkb.NoSigChainError into one we can report. (See", "// KBFS-1252).", "if", "_", ",", "ok", ":=", "err", ".", "(", "libkb", ".", "NoSigChainError", ")", ";", "ok", "{", "return", "idutil", ".", "NoSigChainError", "{", "User", ":", "name", "}", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "// The names of implicit teams can change out from under us,", "// unlike for regular users, so don't require that they remain the", "// same.", "if", "resultName", "!=", "name", "&&", "!", "isImplicit", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "resultName", ",", "name", ")", "\n", "}", "\n", "if", "resultID", "!=", "id", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "resultID", ",", "id", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "identifyUser", "is", "the", "preferred", "way", "to", "run", "identifies", "." ]

[ "func", "identifyUserToChan", "(", "ctx", "context", ".", "Context", ",", "nug", "idutil", ".", "NormalizedUsernameGetter", ",", "identifier", "idutil", ".", "Identifier", ",", "name", "kbname", ".", "NormalizedUsername", ",", "id", "keybase1", ".", "UserOrTeamID", ",", "t", "tlf", ".", "Type", ",", "offline", "keybase1", ".", "OfflineAvailability", ",", "errChan", "chan", "error", ")", "{", "errChan", "<-", "identifyUser", "(", "ctx", ",", "nug", ",", "identifier", ",", "name", ",", "id", ",", "t", ",", "offline", ")", "\n", "}" ]

[ "identifyUserToChan", "calls", "identifyUser", "and", "plugs", "the", "result", "into", "the", "error", "channnel", "." ]

[ "func", "identifyUsers", "(", "ctx", "context", ".", "Context", ",", "nug", "idutil", ".", "NormalizedUsernameGetter", ",", "identifier", "idutil", ".", "Identifier", ",", "names", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", ",", "t", "tlf", ".", "Type", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "error", "{", "eg", ",", "ctx", ":=", "errgroup", ".", "WithContext", "(", "ctx", ")", "\n\n", "// TODO: limit the number of concurrent identifies?", "// TODO: implement a version of errgroup with limited concurrency.", "for", "id", ",", "name", ":=", "range", "names", "{", "// Capture range variables.", "id", ",", "name", ":=", "id", ",", "name", "\n", "eg", ".", "Go", "(", "func", "(", ")", "error", "{", "return", "identifyUser", "(", "ctx", ",", "nug", ",", "identifier", ",", "name", ",", "id", ",", "t", ",", "offline", ")", "\n", "}", ")", "\n", "}", "\n\n", "return", "eg", ".", "Wait", "(", ")", "\n", "}" ]

[ "identifyUsers", "identifies", "the", "users", "in", "the", "given", "maps", "." ]

[ "func", "IdentifyUserList", "(", "ctx", "context", ".", "Context", ",", "nug", "idutil", ".", "NormalizedUsernameGetter", ",", "identifier", "idutil", ".", "Identifier", ",", "ids", "[", "]", "keybase1", ".", "UserOrTeamID", ",", "t", "tlf", ".", "Type", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "error", "{", "eg", ",", "ctx", ":=", "errgroup", ".", "WithContext", "(", "ctx", ")", "\n\n", "// TODO: limit the number of concurrent identifies?", "// TODO: implement concurrency limited version of errgroup.", "for", "_", ",", "id", ":=", "range", "ids", "{", "// Capture range variable.", "id", ":=", "id", "\n", "eg", ".", "Go", "(", "func", "(", ")", "error", "{", "return", "identifyUID", "(", "ctx", ",", "nug", ",", "identifier", ",", "id", ",", "t", ",", "offline", ")", "\n", "}", ")", "\n", "}", "\n\n", "return", "eg", ".", "Wait", "(", ")", "\n", "}" ]

[ "IdentifyUserList", "identifies", "the", "users", "in", "the", "given", "list", ".", "Only", "use", "this", "when", "the", "usernames", "are", "not", "known", "-", "like", "when", "rekeying", "." ]

[ "func", "identifyUsersForTLF", "(", "ctx", "context", ".", "Context", ",", "nug", "idutil", ".", "NormalizedUsernameGetter", ",", "identifier", "idutil", ".", "Identifier", ",", "names", "map", "[", "keybase1", ".", "UserOrTeamID", "]", "kbname", ".", "NormalizedUsername", ",", "t", "tlf", ".", "Type", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "error", "{", "ei", ":=", "GetExtendedIdentify", "(", "ctx", ")", "\n", "if", "ei", ".", "Behavior", "==", "keybase1", ".", "TLFIdentifyBehavior_CHAT_SKIP", "{", "return", "nil", "\n", "}", "\n\n", "eg", ",", "ctx", ":=", "errgroup", ".", "WithContext", "(", "ctx", ")", "\n\n", "eg", ".", "Go", "(", "func", "(", ")", "error", "{", "return", "ei", ".", "makeTlfBreaksIfNeeded", "(", "ctx", ",", "len", "(", "names", ")", ")", "\n", "}", ")", "\n\n", "eg", ".", "Go", "(", "func", "(", ")", "error", "{", "return", "identifyUsers", "(", "ctx", ",", "nug", ",", "identifier", ",", "names", ",", "t", ",", "offline", ")", "\n", "}", ")", "\n\n", "return", "eg", ".", "Wait", "(", ")", "\n", "}" ]

[ "identifyUsersForTLF", "is", "a", "helper", "for", "identifyHandle", "for", "easier", "testing", "." ]

[ "func", "IdentifyHandle", "(", "ctx", "context", ".", "Context", ",", "nug", "idutil", ".", "NormalizedUsernameGetter", ",", "identifier", "idutil", ".", "Identifier", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "h", "*", "Handle", ")", "error", "{", "offline", ":=", "keybase1", ".", "OfflineAvailability_NONE", "\n", "if", "osg", "!=", "nil", "{", "offline", "=", "osg", ".", "OfflineAvailabilityForID", "(", "h", ".", "tlfID", ")", "\n", "}", "\n", "return", "identifyUsersForTLF", "(", "ctx", ",", "nug", ",", "identifier", ",", "h", ".", "ResolvedUsersMap", "(", ")", ",", "h", ".", "Type", "(", ")", ",", "offline", ")", "\n", "}" ]

[ "IdentifyHandle", "identifies", "the", "canonical", "names", "in", "the", "given", "handle", "." ]

[ "func", "NewFS", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "log", "logger", ".", "Logger", ")", "(", "*", "FS", ",", "error", ")", "{", "if", "currentUserSIDErr", "!=", "nil", "{", "return", "nil", ",", "currentUserSIDErr", "\n", "}", "\n", "quLog", ":=", "config", ".", "MakeLogger", "(", "libkbfs", ".", "QuotaUsageLogModule", "(", "\"", "\"", ")", ")", "\n", "f", ":=", "&", "FS", "{", "config", ":", "config", ",", "log", ":", "log", ",", "vlog", ":", "config", ".", "MakeVLogger", "(", "log", ")", ",", "notifications", ":", "libfs", ".", "NewFSNotifications", "(", "log", ")", ",", "quotaUsage", ":", "libkbfs", ".", "NewEventuallyConsistentQuotaUsage", "(", "config", ",", "quLog", ",", "config", ".", "MakeVLogger", "(", "quLog", ")", ")", ",", "}", "\n\n", "f", ".", "root", "=", "&", "Root", "{", "private", ":", "&", "FolderList", "{", "fs", ":", "f", ",", "tlfType", ":", "tlf", ".", "Private", ",", "folders", ":", "make", "(", "map", "[", "string", "]", "fileOpener", ")", ",", "aliasCache", ":", "map", "[", "string", "]", "string", "{", "}", ",", "}", ",", "public", ":", "&", "FolderList", "{", "fs", ":", "f", ",", "tlfType", ":", "tlf", ".", "Public", ",", "folders", ":", "make", "(", "map", "[", "string", "]", "fileOpener", ")", ",", "aliasCache", ":", "map", "[", "string", "]", "string", "{", "}", ",", "}", ",", "team", ":", "&", "FolderList", "{", "fs", ":", "f", ",", "tlfType", ":", "tlf", ".", "SingleTeam", ",", "folders", ":", "make", "(", "map", "[", "string", "]", "fileOpener", ")", ",", "aliasCache", ":", "map", "[", "string", "]", "string", "{", "}", ",", "}", "}", "\n\n", "ctx", "=", "wrapContext", "(", "ctx", ",", "f", ")", "\n\n", "f", ".", "remoteStatus", ".", "Init", "(", "ctx", ",", "f", ".", "log", ",", "f", ".", "config", ",", "f", ")", "\n", "f", ".", "notifications", ".", "LaunchProcessor", "(", "ctx", ")", "\n", "go", "clearFolderListCacheLoop", "(", "ctx", ",", "f", ".", "root", ")", "\n\n", "return", "f", ",", "nil", "\n", "}" ]

[ "NewFS", "creates", "an", "FS" ]

[ "func", "wrapContext", "(", "ctx", "context", ".", "Context", ",", "f", "*", "FS", ")", "context", ".", "Context", "{", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "libfs", ".", "CtxAppIDKey", ",", "f", ")", "\n", "logTags", ":=", "make", "(", "logger", ".", "CtxLogTags", ")", "\n", "logTags", "[", "CtxIDKey", "]", "=", "CtxOpID", "\n", "ctx", "=", "logger", ".", "NewContextWithLogTags", "(", "ctx", ",", "logTags", ")", "\n", "return", "ctx", "\n", "}" ]

[ "Adds", "log", "tags", "etc" ]

[ "func", "(", "f", "*", "FS", ")", "WithContext", "(", "ctx", "context", ".", "Context", ")", "(", "context", ".", "Context", ",", "context", ".", "CancelFunc", ")", "{", "id", ",", "err", ":=", "libkbfs", ".", "MakeRandomRequestID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "f", ".", "log", ".", "CErrorf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "ctx", ",", "func", "(", ")", "{", "}", "\n", "}", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n\n", "// context.WithDeadline uses clock from `time` package, so we are not using", "// f.config.Clock() here", "start", ":=", "time", ".", "Now", "(", ")", "\n", "ctx", ",", "err", "=", "libcontext", ".", "NewContextWithCancellationDelayer", "(", "libcontext", ".", "NewContextReplayable", "(", "ctx", ",", "func", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "ctx", "=", "wrapContext", "(", "context", ".", "WithValue", "(", "ctx", ",", "CtxIDKey", ",", "id", ")", ",", "f", ")", "\n", "ctx", ",", "_", "=", "context", ".", "WithDeadline", "(", "ctx", ",", "start", ".", "Add", "(", "29", "*", "time", ".", "Second", ")", ")", "\n", "return", "ctx", "\n", "}", ")", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "ctx", ",", "cancel", "\n", "}" ]

[ "WithContext", "creates", "context", "for", "filesystem", "operations", "." ]

[ "func", "(", "f", "*", "FS", ")", "GetVolumeInformation", "(", "ctx", "context", ".", "Context", ")", "(", "dokan", ".", "VolumeInformation", ",", "error", ")", "{", "// TODO should this be explicitely refused to other users?", "// As the mount is limited to current session there is little need.", "return", "vinfo", ",", "nil", "\n", "}" ]

[ "GetVolumeInformation", "returns", "information", "about", "the", "whole", "filesystem", "for", "dokan", "." ]

[ "func", "(", "f", "*", "FS", ")", "GetDiskFreeSpace", "(", "ctx", "context", ".", "Context", ")", "(", "freeSpace", "dokan", ".", "FreeSpace", ",", "err", "error", ")", "{", "// TODO should this be refused to other users?", "// As the mount is limited to current session there is little need.", "f", ".", "logEnter", "(", "ctx", ",", "\"", "\"", ")", "\n", "// Refuse private directories while we are in a error state.", "if", "f", ".", "remoteStatus", ".", "ExtraFileName", "(", ")", "!=", "\"", "\"", "{", "f", ".", "log", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "dokan", ".", "FreeSpace", "{", "TotalNumberOfBytes", ":", "dummyFreeSpace", ",", "TotalNumberOfFreeBytes", ":", "dummyFreeSpace", ",", "FreeBytesAvailable", ":", "dummyFreeSpace", ",", "}", ",", "nil", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "f", ".", "vlog", ".", "CLogf", "(", "ctx", ",", "libkb", ".", "VLog1", ",", "\"", "\"", ")", "\n", "}", "else", "{", "// Don't report the error (perhaps resulting in a user", "// notification) since this method is mostly called by the", "// OS and not because of a user action.", "f", ".", "log", ".", "CDebugf", "(", "ctx", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "_", ",", "usageBytes", ",", "_", ",", "limitBytes", ",", "err", ":=", "f", ".", "quotaUsage", ".", "Get", "(", "ctx", ",", "quotaUsageStaleTolerance", "/", "2", ",", "quotaUsageStaleTolerance", ")", "\n", "if", "err", "!=", "nil", "{", "return", "dokan", ".", "FreeSpace", "{", "}", ",", "errToDokan", "(", "err", ")", "\n", "}", "\n", "free", ":=", "uint64", "(", "limitBytes", "-", "usageBytes", ")", "\n", "return", "dokan", ".", "FreeSpace", "{", "TotalNumberOfBytes", ":", "uint64", "(", "limitBytes", ")", ",", "TotalNumberOfFreeBytes", ":", "free", ",", "FreeBytesAvailable", ":", "free", ",", "}", ",", "nil", "\n", "}" ]

[ "GetDiskFreeSpace", "returns", "information", "about", "free", "space", "on", "the", "volume", "for", "dokan", "." ]

[ "func", "(", "oc", "*", "openContext", ")", "isCreation", "(", ")", "bool", "{", "switch", "oc", ".", "CreateDisposition", "{", "case", "dokan", ".", "FileSupersede", ",", "dokan", ".", "FileCreate", ",", "dokan", ".", "FileOpenIf", ",", "dokan", ".", "FileOverwriteIf", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isCreation", "checks", "the", "flags", "whether", "a", "file", "creation", "is", "wanted", "." ]

[ "func", "(", "oc", "*", "openContext", ")", "isTruncate", "(", ")", "bool", "{", "switch", "oc", ".", "CreateDisposition", "{", "case", "dokan", ".", "FileSupersede", ",", "dokan", ".", "FileOverwrite", ",", "dokan", ".", "FileOverwriteIf", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isTruncate", "checks", "the", "flags", "whether", "a", "file", "truncation", "is", "wanted", "." ]

[ "func", "(", "oc", "*", "openContext", ")", "returnDirNoCleanup", "(", "f", "dokan", ".", "File", ")", "(", "dokan", ".", "File", ",", "dokan", ".", "CreateStatus", ",", "error", ")", "{", "if", "err", ":=", "oc", ".", "ReturningDirAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "f", ",", "dokan", ".", "ExistingDir", ",", "nil", "\n", "}" ]

[ "returnDirNoCleanup", "returns", "a", "dir", "or", "nothing", "depending", "on", "the", "open", "flags", "and", "does", "not", "call", ".", "Cleanup", "on", "error", "." ]

[ "func", "(", "oc", "*", "openContext", ")", "returnFileNoCleanup", "(", "f", "dokan", ".", "File", ")", "(", "dokan", ".", "File", ",", "dokan", ".", "CreateStatus", ",", "error", ")", "{", "if", "err", ":=", "oc", ".", "ReturningFileAllowed", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "return", "f", ",", "dokan", ".", "ExistingFile", ",", "nil", "\n", "}" ]

[ "returnFileNoCleanup", "returns", "a", "file", "or", "nothing", "depending", "on", "the", "open", "flags", "and", "does", "not", "call", ".", "Cleanup", "on", "error", "." ]

[ "func", "(", "f", "*", "FS", ")", "CreateFile", "(", "ctx", "context", ".", "Context", ",", "fi", "*", "dokan", ".", "FileInfo", ",", "cd", "*", "dokan", ".", "CreateData", ")", "(", "dokan", ".", "File", ",", "dokan", ".", "CreateStatus", ",", "error", ")", "{", "// Only allow the current user access", "if", "!", "fi", ".", "IsRequestorUserSidEqualTo", "(", "currentUserSID", ")", "{", "f", ".", "log", ".", "CErrorf", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "openFakeRoot", "(", "ctx", ",", "f", ",", "fi", ")", "\n", "}", "\n", "return", "f", ".", "openRaw", "(", "ctx", ",", "fi", ",", "cd", ")", "\n", "}" ]

[ "CreateFile", "called", "from", "dokan", "may", "be", "a", "file", "or", "directory", "." ]

[ "func", "windowsPathSplit", "(", "raw", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "raw", "==", "``", "{", "raw", "=", "`\\`", "\n", "}", "\n", "if", "raw", "[", "0", "]", "!=", "'\\\\'", "||", "raw", "[", "len", "(", "raw", ")", "-", "1", "]", "==", "'*'", "{", "return", "nil", ",", "dokan", ".", "ErrObjectNameNotFound", "\n", "}", "\n", "return", "strings", ".", "Split", "(", "raw", "[", "1", ":", "]", ",", "`\\`", ")", ",", "nil", "\n", "}" ]

[ "windowsPathSplit", "handles", "paths", "we", "get", "from", "Dokan", ".", "As", "a", "special", "case", "means", "\\", "it", "gets", "generated", "on", "special", "occasions", "." ]

[ "func", "(", "f", "*", "FS", ")", "Printf", "(", "fmt", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "f", ".", "log", ".", "Info", "(", "\"", "\"", "+", "fmt", ",", "args", "...", ")", "\n", "}" ]

[ "Printf", "prints", "information", "from", "the", "Dokan", "library", "." ]

[ "func", "(", "f", "*", "FS", ")", "UserChanged", "(", "ctx", "context", ".", "Context", ",", "oldName", ",", "newName", "kbname", ".", "NormalizedUsername", ")", "{", "f", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "oldName", ",", "newName", ")", "\n", "f", ".", "root", ".", "public", ".", "userChanged", "(", "ctx", ",", "oldName", ",", "newName", ")", "\n", "f", ".", "root", ".", "private", ".", "userChanged", "(", "ctx", ",", "oldName", ",", "newName", ")", "\n", "}" ]

[ "UserChanged", "is", "called", "from", "libfs", "." ]

[ "func", "(", "r", "*", "Root", ")", "GetFileInformation", "(", "ctx", "context", ".", "Context", ",", "fi", "*", "dokan", ".", "FileInfo", ")", "(", "*", "dokan", ".", "Stat", ",", "error", ")", "{", "return", "defaultDirectoryInformation", "(", ")", "\n", "}" ]

[ "GetFileInformation", "for", "dokan", "stats", "." ]

[ "func", "(", "r", "*", "Root", ")", "FindFiles", "(", "ctx", "context", ".", "Context", ",", "fi", "*", "dokan", ".", "FileInfo", ",", "ignored", "string", ",", "callback", "func", "(", "*", "dokan", ".", "NamedStat", ")", "error", ")", "error", "{", "var", "ns", "dokan", ".", "NamedStat", "\n", "var", "err", "error", "\n", "ns", ".", "FileAttributes", "=", "dokan", ".", "FileAttributeDirectory", "\n", "ename", ",", "esize", ":=", "r", ".", "private", ".", "fs", ".", "remoteStatus", ".", "ExtraFileNameAndSize", "(", ")", "\n", "switch", "ename", "{", "case", "\"", "\"", ":", "ns", ".", "Name", "=", "PrivateName", "\n", "err", "=", "callback", "(", "&", "ns", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ns", ".", "Name", "=", "TeamName", "\n", "err", "=", "callback", "(", "&", "ns", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fallthrough", "\n", "case", "libfs", ".", "HumanNoLoginFileName", ":", "ns", ".", "Name", "=", "PublicName", "\n", "err", "=", "callback", "(", "&", "ns", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "ename", "!=", "\"", "\"", "{", "ns", ".", "Name", "=", "ename", "\n", "ns", ".", "FileAttributes", "=", "dokan", ".", "FileAttributeNormal", "\n", "ns", ".", "FileSize", "=", "esize", "\n", "err", "=", "callback", "(", "&", "ns", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "FindFiles", "for", "dokan", "readdir", "." ]

[ "func", "GetFileInfo", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "dir", "libkbfs", ".", "Node", ",", "name", "string", ")", "(", "data", "[", "]", "byte", ",", "t", "time", ".", "Time", ",", "err", "error", ")", "{", "node", ",", "ei", ",", "err", ":=", "config", ".", "KBFSOps", "(", ")", ".", "Lookup", "(", "ctx", ",", "dir", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "nmd", ",", "err", ":=", "config", ".", "KBFSOps", "(", ")", ".", "GetNodeMetadata", "(", "ctx", ",", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "data", ",", "err", "=", "PrettyJSON", "(", "fileInfoFile", "{", "nmd", ",", "ei", ".", "PrevRevisions", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "return", "data", ",", "time", ".", "Unix", "(", "0", ",", "ei", ".", "Mtime", ")", ",", "nil", "\n", "}" ]

[ "GetFileInfo", "returns", "serialized", "JSON", "containing", "status", "information", "for", "a", "file", "or", "directory", "entry", "." ]

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

[ "NewFavoriteList", "creates", "a", "FavoriteList", "engine", "." ]

[ "func", "(", "e", "*", "FavoriteList", ")", "Result", "(", ")", "keybase1", ".", "FavoritesResult", "{", "return", "keybase1", ".", "FavoritesResult", "{", "FavoriteFolders", ":", "e", ".", "result", ".", "Favorites", ",", "IgnoredFolders", ":", "e", ".", "result", ".", "Ignored", ",", "NewFolders", ":", "e", ".", "result", ".", "New", ",", "}", "\n", "}" ]

[ "Favorites", "returns", "the", "list", "of", "favorites", "that", "Run", "generated", "." ]

[ "func", "newWalletAPIHandler", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "indentOutput", "bool", ")", "*", "walletAPIHandler", "{", "return", "&", "walletAPIHandler", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "indent", ":", "indentOutput", "}", "\n", "}" ]

[ "newWalletAPIHandler", "makes", "a", "walletAPIHandler", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "handle", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "switch", "c", ".", "Params", ".", "Version", "{", "case", "0", ",", "1", ":", "return", "w", ".", "handleV1", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "default", ":", "return", "ErrInvalidVersion", "{", "version", ":", "c", ".", "Params", ".", "Version", "}", "\n", "}", "\n", "}" ]

[ "handle", "processes", "the", "Call", "based", "on", "the", "version", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "handleV1", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "if", "!", "validWalletMethodsV1", "[", "c", ".", "Method", "]", "{", "return", "ErrInvalidMethod", "{", "name", ":", "c", ".", "Method", ",", "version", ":", "1", "}", "\n", "}", "\n\n", "cli", ",", "err", ":=", "GetWalletClient", "(", "w", ".", "G", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "w", ".", "cli", "=", "cli", "\n\n", "switch", "c", ".", "Method", "{", "case", "balancesMethod", ":", "return", "w", ".", "balances", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "batchMethod", ":", "return", "w", ".", "batch", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "cancelMethod", ":", "return", "w", ".", "cancelPayment", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "detailsMethod", ":", "return", "w", ".", "details", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "getInflationMethod", ":", "return", "w", ".", "getInflation", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "historyMethod", ":", "return", "w", ".", "history", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "initializeMethod", ":", "return", "w", ".", "initializeWallet", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "lookupMethod", ":", "return", "w", ".", "lookup", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "sendMethod", ":", "return", "w", ".", "send", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "case", "setInflationMethod", ":", "return", "w", ".", "setInflation", "(", "ctx", ",", "c", ",", "wr", ")", "\n", "default", ":", "return", "ErrInvalidMethod", "{", "name", ":", "c", ".", "Method", ",", "version", ":", "1", "}", "\n", "}", "\n", "}" ]

[ "handleV1", "processes", "Call", "for", "version", "1", "of", "the", "wallet", "JSON", "API", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "balances", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "accounts", ",", "err", ":=", "w", ".", "cli", ".", "WalletGetAccountsCLILocal", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "return", "w", ".", "encodeResult", "(", "c", ",", "accounts", ",", "wr", ")", "\n", "}" ]

[ "balances", "returns", "the", "account", "balances", "for", "all", "accounts", "owned", "by", "the", "current", "user", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "batch", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "batchOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "arg", ":=", "stellar1", ".", "BatchLocalArg", "{", "BatchID", ":", "opts", ".", "BatchID", ",", "TimeoutSecs", ":", "opts", ".", "Timeout", ",", "UseMulti", ":", "true", ",", "}", "\n", "for", "_", ",", "p", ":=", "range", "opts", ".", "Payments", "{", "arg", ".", "Payments", "=", "append", "(", "arg", ".", "Payments", ",", "stellar1", ".", "BatchPaymentArg", "{", "Recipient", ":", "p", ".", "Recipient", ",", "Amount", ":", "p", ".", "Amount", ",", "Message", ":", "p", ".", "Message", "}", ")", "\n", "}", "\n\n", "result", ",", "err", ":=", "w", ".", "cli", ".", "BatchLocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "return", "w", ".", "encodeResult", "(", "c", ",", "result", ",", "wr", ")", "\n", "}" ]

[ "batch", "submits", "a", "batch", "of", "payments", "as", "fast", "as", "it", "can", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "cancelPayment", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "txIDOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "result", ",", "err", ":=", "w", ".", "cli", ".", "ClaimCLILocal", "(", "ctx", ",", "stellar1", ".", "ClaimCLILocalArg", "{", "TxID", ":", "opts", ".", "TxID", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "return", "w", ".", "encodeResult", "(", "c", ",", "result", ",", "wr", ")", "\n", "}" ]

[ "cancelPayment", "cancels", "a", "pending", "relay", "payment", "and", "yanks", "back", "the", "funds", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "details", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "txIDOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "detail", ",", "err", ":=", "w", ".", "cli", ".", "PaymentDetailCLILocal", "(", "ctx", ",", "opts", ".", "TxID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "return", "w", ".", "encodeResult", "(", "c", ",", "detail", ",", "wr", ")", "\n", "}" ]

[ "details", "outputs", "details", "for", "a", "single", "transaction", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "getInflation", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "accountIDOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "inflation", ",", "err", ":=", "w", ".", "getInflationLocal", "(", "ctx", ",", "opts", ".", "Convert", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "return", "w", ".", "encodeResult", "(", "c", ",", "inflation", ",", "wr", ")", "\n", "}" ]

[ "getInflation", "gets", "the", "inflation", "destination", "for", "an", "account", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "history", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "accountIDOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "a", ":=", "opts", ".", "Convert", "(", ")", "\n", "payments", ",", "err", ":=", "w", ".", "cli", ".", "RecentPaymentsCLILocal", "(", "ctx", ",", "&", "a", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "return", "w", ".", "encodeResult", "(", "c", ",", "payments", ",", "wr", ")", "\n", "}" ]

[ "history", "outputs", "recent", "payment", "history", "for", "the", "specified", "account", "ID", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "lookup", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "nameOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "if", "err", ":=", "w", ".", "registerIdentifyUI", "(", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "result", ",", "err", ":=", "w", ".", "cli", ".", "LookupCLILocal", "(", "ctx", ",", "opts", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "return", "w", ".", "encodeResult", "(", "c", ",", "result", ",", "wr", ")", "\n", "}" ]

[ "lookup", "outputs", "an", "account", "ID", "for", "a", "keybase", "username", "or", "federation", "address", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "send", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "sendOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "registerIdentifyUI", "(", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "// convert the amount if necessary", "amount", ":=", "opts", ".", "Amount", "\n", "var", "displayAmount", ",", "displayCurrency", "string", "\n", "if", "opts", ".", "Currency", "!=", "\"", "\"", "&&", "strings", ".", "ToUpper", "(", "opts", ".", "Currency", ")", "!=", "\"", "\"", "{", "exchangeRate", ",", "err", ":=", "w", ".", "cli", ".", "ExchangeRateLocal", "(", "ctx", ",", "stellar1", ".", "OutsideCurrencyCode", "(", "opts", ".", "Currency", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "amount", ",", "err", "=", "stellarnet", ".", "ConvertOutsideToXLM", "(", "opts", ".", "Amount", ",", "exchangeRate", ".", "Rate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "displayAmount", "=", "opts", ".", "Amount", "\n", "displayCurrency", "=", "opts", ".", "Currency", "\n", "}", "\n\n", "arg", ":=", "stellar1", ".", "SendCLILocalArg", "{", "Recipient", ":", "opts", ".", "Recipient", ",", "Amount", ":", "amount", ",", "Asset", ":", "stellar1", ".", "AssetNative", "(", ")", ",", "Note", ":", "opts", ".", "Message", ",", "DisplayAmount", ":", "displayAmount", ",", "DisplayCurrency", ":", "displayCurrency", ",", "FromAccountID", ":", "stellar1", ".", "AccountID", "(", "opts", ".", "FromAccountID", ")", ",", "}", "\n", "result", ",", "err", ":=", "w", ".", "cli", ".", "SendCLILocal", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "detail", ",", "err", ":=", "w", ".", "cli", ".", "PaymentDetailCLILocal", "(", "ctx", ",", "string", "(", "result", ".", "TxID", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n", "return", "w", ".", "encodeResult", "(", "c", ",", "detail", ",", "wr", ")", "\n", "}" ]

[ "send", "sends", "XLM", "to", "an", "account", "." ]

[ "func", "(", "w", "*", "walletAPIHandler", ")", "setInflation", "(", "ctx", "context", ".", "Context", ",", "c", "Call", ",", "wr", "io", ".", "Writer", ")", "error", "{", "var", "opts", "inflationOptions", "\n", "if", "err", ":=", "unmarshalOptions", "(", "c", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "destination", ",", "err", ":=", "getInflationDestinationAddrFromString", "(", "w", ".", "cli", ",", "opts", ".", "AccountIDConvert", "(", ")", ",", "opts", ".", "Destination", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "arg", ":=", "stellar1", ".", "SetInflationDestinationLocalArg", "{", "AccountID", ":", "opts", ".", "AccountIDConvert", "(", ")", ",", "Destination", ":", "destination", ",", "}", "\n", "if", "err", ":=", "w", ".", "cli", ".", "SetInflationDestinationLocal", "(", "ctx", ",", "arg", ")", ";", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "// get it for display", "inflation", ",", "err", ":=", "w", ".", "getInflationLocal", "(", "ctx", ",", "opts", ".", "AccountIDConvert", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "w", ".", "encodeErr", "(", "c", ",", "err", ",", "wr", ")", "\n", "}", "\n\n", "return", "w", ".", "encodeResult", "(", "c", ",", "inflation", ",", "wr", ")", "\n", "}" ]

[ "setInflation", "sets", "the", "inflation", "destination", "for", "an", "account", "." ]

[ "func", "(", "c", "*", "accountIDOptions", ")", "Check", "(", ")", "error", "{", "_", ",", "err", ":=", "strkey", ".", "Decode", "(", "strkey", ".", "VersionByteAccountID", ",", "c", ".", "AccountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ErrInvalidAccountID", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Check", "makes", "sure", "that", "AccountID", "exists", "and", "is", "valid", "." ]

[ "func", "(", "c", "*", "txIDOptions", ")", "Check", "(", ")", "error", "{", "if", "len", "(", "c", ".", "TxID", ")", "!=", "64", "{", "return", "ErrInvalidTxID", "\n", "}", "\n", "if", "_", ",", "err", ":=", "hex", ".", "DecodeString", "(", "c", ".", "TxID", ")", ";", "err", "!=", "nil", "{", "return", "ErrInvalidTxID", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Check", "makes", "sure", "that", "TxID", "exists", "and", "is", "valid", "." ]

[ "func", "(", "c", "*", "inflationOptions", ")", "Check", "(", ")", "error", "{", "_", ",", "err", ":=", "strkey", ".", "Decode", "(", "strkey", ".", "VersionByteAccountID", ",", "c", ".", "AccountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ErrInvalidAccountID", "\n", "}", "\n", "if", "c", ".", "Destination", "==", "\"", "\"", "{", "return", "ErrDestinationMissing", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Check", "makes", "sure", "that", "AccountID", "is", "valid", "and", "that", "Destination", "isn", "t", "empty", "." ]

[ "func", "(", "c", "*", "sendOptions", ")", "Check", "(", ")", "error", "{", "if", "strings", ".", "TrimSpace", "(", "c", ".", "Recipient", ")", "==", "\"", "\"", "{", "return", "ErrRecipientMissing", "\n", "}", "\n", "if", "strings", ".", "TrimSpace", "(", "c", ".", "Amount", ")", "==", "\"", "\"", "{", "return", "ErrAmountMissing", "\n", "}", "\n", "namt", ",", "err", ":=", "stellarnet", ".", "ParseStellarAmount", "(", "c", ".", "Amount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ErrInvalidAmount", "\n", "}", "\n", "if", "namt", "<", "0", "{", "return", "ErrInvalidAmount", "\n", "}", "\n\n", "if", "c", ".", "FromAccountID", "!=", "\"", "\"", "{", "_", ",", "err", ":=", "strkey", ".", "Decode", "(", "strkey", ".", "VersionByteAccountID", ",", "c", ".", "FromAccountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ErrInvalidAccountID", "\n", "}", "\n", "}", "\n", "if", "len", "(", "c", ".", "Message", ")", ">", "libkb", ".", "MaxStellarPaymentNoteLength", "{", "return", "ErrMessageTooLong", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Check", "makes", "sure", "that", "the", "send", "options", "are", "valid", "." ]

[ "func", "(", "c", "*", "batchOptions", ")", "Check", "(", ")", "error", "{", "for", "i", ",", "p", ":=", "range", "c", ".", "Payments", "{", "if", "strings", ".", "TrimSpace", "(", "p", ".", "Recipient", ")", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ",", "ErrRecipientMissing", ")", "\n", "}", "\n", "if", "strings", ".", "TrimSpace", "(", "p", ".", "Amount", ")", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ",", "ErrAmountMissing", ")", "\n", "}", "\n", "namt", ",", "err", ":=", "stellarnet", ".", "ParseStellarAmount", "(", "p", ".", "Amount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ",", "ErrInvalidAmount", ")", "\n", "}", "\n", "if", "namt", "<", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ",", "ErrInvalidAmount", ")", "\n", "}", "\n", "if", "len", "(", "p", ".", "Message", ")", ">", "libkb", ".", "MaxStellarPaymentNoteLength", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "i", ",", "ErrMessageTooLong", ")", "\n", "}", "\n", "}", "\n\n", "if", "c", ".", "Timeout", "<=", "0", "{", "c", ".", "Timeout", "=", "15", "*", "len", "(", "c", ".", "Payments", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Check", "makes", "sure", "that", "the", "batch", "options", "are", "valid", "." ]

[ "func", "(", "ccs", "*", "crChains", ")", "addNoopChain", "(", "ptr", "data", ".", "BlockPointer", ")", "{", "if", "_", ",", "ok", ":=", "ccs", ".", "byMostRecent", "[", "ptr", "]", ";", "ok", "{", "return", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ccs", ".", "byOriginal", "[", "ptr", "]", ";", "ok", "{", "return", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ccs", ".", "originals", "[", "ptr", "]", ";", "ok", "{", "return", "\n", "}", "\n", "chain", ":=", "&", "crChain", "{", "original", ":", "ptr", ",", "mostRecent", ":", "ptr", "}", "\n", "ccs", ".", "byOriginal", "[", "ptr", "]", "=", "chain", "\n", "ccs", ".", "byMostRecent", "[", "ptr", "]", "=", "chain", "\n", "}" ]

[ "addNoopChain", "adds", "a", "new", "chain", "with", "no", "ops", "to", "the", "chains", "struct", "if", "that", "pointer", "isn", "t", "involved", "in", "any", "chains", "yet", "." ]

[ "func", "(", "ccs", "*", "crChains", ")", "makeChainForNewOp", "(", "targetPtr", "data", ".", "BlockPointer", ",", "newOp", "op", ")", "error", "{", "switch", "realOp", ":=", "newOp", ".", "(", "type", ")", "{", "case", "*", "createOp", ":", "return", "ccs", ".", "makeChainForNewOpWithUpdate", "(", "targetPtr", ",", "newOp", ",", "&", "realOp", ".", "Dir", ")", "\n", "case", "*", "rmOp", ":", "return", "ccs", ".", "makeChainForNewOpWithUpdate", "(", "targetPtr", ",", "newOp", ",", "&", "realOp", ".", "Dir", ")", "\n", "case", "*", "renameOp", ":", "// In this case, we don't want to split the rename chain, so", "// just make up a new operation and later overwrite it with", "// the rename op.", "co", ",", "err", ":=", "newCreateOp", "(", "realOp", ".", "NewName", ",", "realOp", ".", "NewDir", ".", "Unref", ",", "data", ".", "File", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "ccs", ".", "makeChainForNewOpWithUpdate", "(", "targetPtr", ",", "co", ",", "&", "co", ".", "Dir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "chain", ",", "ok", ":=", "ccs", ".", "byMostRecent", "[", "targetPtr", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "targetPtr", ")", "\n", "}", "\n", "if", "len", "(", "chain", ".", "ops", ")", "!=", "1", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "targetPtr", ")", "\n", "}", "\n", "chain", ".", "ops", "[", "0", "]", "=", "realOp", "\n", "return", "nil", "\n", "case", "*", "setAttrOp", ":", "return", "ccs", ".", "makeChainForNewOpWithUpdate", "(", "targetPtr", ",", "newOp", ",", "&", "realOp", ".", "Dir", ")", "\n", "case", "*", "syncOp", ":", "return", "ccs", ".", "makeChainForNewOpWithUpdate", "(", "targetPtr", ",", "newOp", ",", "&", "realOp", ".", "File", ")", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "newOp", ")", "\n", "}", "\n", "}" ]

[ "makeChainForNewOp", "makes", "a", "new", "chain", "for", "an", "op", "that", "does", "not", "yet", "have", "its", "pointers", "initialized", ".", "It", "does", "so", "by", "setting", "Unref", "and", "Ref", "to", "be", "the", "same", "for", "the", "duration", "of", "this", "function", "and", "calling", "the", "usual", "makeChainForOp", "method", ".", "This", "function", "is", "not", "goroutine", "-", "safe", "with", "respect", "to", "newOp", ".", "Also", "note", "that", "rename", "ops", "will", "not", "be", "split", "into", "two", "ops", ";", "they", "will", "be", "placed", "only", "in", "the", "new", "directory", "chain", "." ]

[ "func", "newCRChains", "(", "ctx", "context", ".", "Context", ",", "codec", "kbfscodec", ".", "Codec", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "chainMDs", "[", "]", "chainMetadata", ",", "fbo", "*", "folderBlockOps", ",", "identifyTypes", "bool", ")", "(", "ccs", "*", "crChains", ",", "err", "error", ")", "{", "ccs", "=", "newCRChainsEmpty", "(", ")", "\n\n", "// For each MD update, turn each update in each op into map", "// entries and create chains for the BlockPointers that are", "// affected directly by the operation.", "for", "_", ",", "chainMD", ":=", "range", "chainMDs", "{", "// No new operations in these.", "if", "chainMD", ".", "IsWriterMetadataCopiedSet", "(", ")", "{", "continue", "\n", "}", "\n\n", "offline", ":=", "keybase1", ".", "OfflineAvailability_NONE", "\n", "if", "osg", "!=", "nil", "{", "offline", "=", "osg", ".", "OfflineAvailabilityForID", "(", "chainMD", ".", "TlfID", "(", ")", ")", "\n", "}", "\n\n", "winfo", ":=", "newWriterInfo", "(", "chainMD", ".", "LastModifyingWriter", "(", ")", ",", "chainMD", ".", "LastModifyingWriterVerifyingKey", "(", ")", ",", "chainMD", ".", "Revision", "(", ")", ",", "offline", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "chainData", ":=", "*", "chainMD", ".", "Data", "(", ")", "\n\n", "err", "=", "ccs", ".", "addOps", "(", "codec", ",", "chainData", ",", "winfo", ",", "chainMD", ".", "LocalTimestamp", "(", ")", ")", "\n\n", "if", "ptr", ":=", "chainData", ".", "cachedChanges", ".", "Info", ".", "BlockPointer", ";", "ptr", "!=", "data", ".", "ZeroPtr", "{", "ccs", ".", "blockChangePointers", "[", "ptr", "]", "=", "true", "\n\n", "// Any child block change pointers?", "infos", ",", "err", ":=", "fbo", ".", "GetIndirectFileBlockInfos", "(", "ctx", ",", "makeFBOLockState", "(", ")", ",", "chainMD", ",", "data", ".", "Path", "{", "FolderBranch", ":", "fbo", ".", "folderBranch", ",", "Path", ":", "[", "]", "data", ".", "PathNode", "{", "{", "BlockPointer", ":", "ptr", ",", "Name", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "chainMD", ".", "Revision", "(", ")", ")", ",", "}", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "info", ":=", "range", "infos", "{", "ccs", ".", "blockChangePointers", "[", "info", ".", "BlockPointer", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "!", "ccs", ".", "originalRoot", ".", "IsInitialized", "(", ")", "{", "// Find the original pointer for the root directory", "if", "rootChain", ",", "ok", ":=", "ccs", ".", "byMostRecent", "[", "chainData", ".", "Dir", ".", "BlockPointer", "]", ";", "ok", "{", "ccs", ".", "originalRoot", "=", "rootChain", ".", "original", "\n", "}", "\n", "}", "\n", "}", "\n\n", "mostRecentMD", ":=", "chainMDs", "[", "len", "(", "chainMDs", ")", "-", "1", "]", "\n\n", "for", "_", ",", "chain", ":=", "range", "ccs", ".", "byOriginal", "{", "toUnrefs", ":=", "chain", ".", "collapse", "(", "ccs", ".", "createdOriginals", ",", "ccs", ".", "originals", ")", "\n", "for", "_", ",", "unref", ":=", "range", "toUnrefs", "{", "ccs", ".", "toUnrefPointers", "[", "unref", "]", "=", "true", "\n", "}", "\n", "// NOTE: even if we've removed all its ops, still keep the", "// chain around so we can see the mapping between the original", "// and most recent pointers.", "// Figure out if this chain is a file or directory. We don't", "// need to do this for chains that represent a resolution in", "// progress, since in that case all actions are already", "// completed.", "if", "identifyTypes", "{", "err", ":=", "chain", ".", "identifyType", "(", "ctx", ",", "fbo", ",", "mostRecentMD", ",", "ccs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "ccs", ".", "mostRecentChainMDInfo", "=", "mostRecentMD", "\n", "return", "ccs", ",", "nil", "\n", "}" ]

[ "newCRChains", "builds", "a", "new", "crChains", "object", "from", "the", "given", "list", "of", "chainMetadatas", "which", "must", "be", "non", "-", "empty", "." ]

[ "func", "newCRChainsForIRMDs", "(", "ctx", "context", ".", "Context", ",", "codec", "kbfscodec", ".", "Codec", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "irmds", "[", "]", "ImmutableRootMetadata", ",", "fbo", "*", "folderBlockOps", ",", "identifyTypes", "bool", ")", "(", "ccs", "*", "crChains", ",", "err", "error", ")", "{", "chainMDs", ":=", "make", "(", "[", "]", "chainMetadata", ",", "len", "(", "irmds", ")", ")", "\n", "for", "i", ",", "irmd", ":=", "range", "irmds", "{", "chainMDs", "[", "i", "]", "=", "irmd", "\n", "}", "\n", "return", "newCRChains", "(", "ctx", ",", "codec", ",", "osg", ",", "chainMDs", ",", "fbo", ",", "identifyTypes", ")", "\n", "}" ]

[ "newCRChainsForIRMDs", "simply", "builds", "a", "list", "of", "chainMetadatas", "from", "the", "given", "list", "of", "ImmutableRootMetadatas", "and", "calls", "newCRChains", "with", "it", "." ]

[ "func", "(", "ccs", "*", "crChains", ")", "copyOpAndRevertUnrefsToOriginals", "(", "currOp", "op", ")", "op", "{", "var", "unrefs", "[", "]", "*", "data", ".", "BlockPointer", "\n", "var", "newOp", "op", "\n", "switch", "realOp", ":=", "currOp", ".", "(", "type", ")", "{", "case", "*", "createOp", ":", "newCreateOp", ":=", "*", "realOp", "\n", "unrefs", "=", "append", "(", "unrefs", ",", "&", "newCreateOp", ".", "Dir", ".", "Unref", ")", "\n", "newOp", "=", "&", "newCreateOp", "\n", "case", "*", "rmOp", ":", "newRmOp", ":=", "*", "realOp", "\n", "unrefs", "=", "append", "(", "unrefs", ",", "&", "newRmOp", ".", "Dir", ".", "Unref", ")", "\n", "newOp", "=", "&", "newRmOp", "\n", "case", "*", "renameOp", ":", "newRenameOp", ":=", "*", "realOp", "\n", "unrefs", "=", "append", "(", "unrefs", ",", "&", "newRenameOp", ".", "OldDir", ".", "Unref", ",", "&", "newRenameOp", ".", "NewDir", ".", "Unref", ",", "&", "newRenameOp", ".", "Renamed", ")", "\n", "newOp", "=", "&", "newRenameOp", "\n", "case", "*", "syncOp", ":", "newSyncOp", ":=", "*", "realOp", "\n", "unrefs", "=", "append", "(", "unrefs", ",", "&", "newSyncOp", ".", "File", ".", "Unref", ")", "\n", "newOp", "=", "&", "newSyncOp", "\n", "case", "*", "setAttrOp", ":", "newSetAttrOp", ":=", "*", "realOp", "\n", "unrefs", "=", "append", "(", "unrefs", ",", "&", "newSetAttrOp", ".", "Dir", ".", "Unref", ",", "&", "newSetAttrOp", ".", "File", ")", "\n", "newOp", "=", "&", "newSetAttrOp", "\n", "case", "*", "GCOp", ":", "// No need to copy a GCOp, it won't be modified", "newOp", "=", "realOp", "\n", "case", "*", "rekeyOp", ":", "newOp", "=", "realOp", "\n", "}", "\n", "for", "_", ",", "unref", ":=", "range", "unrefs", "{", "ok", ":=", "true", "\n", "// Loop over the originals, since if `changeOriginal` was", "// called, there might be a path of them.", "for", "ok", "{", "var", "original", "data", ".", "BlockPointer", "\n", "original", ",", "ok", "=", "ccs", ".", "originals", "[", "*", "unref", "]", "\n", "if", "ok", "{", "*", "unref", "=", "original", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "newOp", "\n", "}" ]

[ "copyOpAndRevertUnrefsToOriginals", "returns", "a", "shallow", "copy", "of", "the", "op", "modifying", "each", "custom", "BlockPointer", "field", "to", "reference", "the", "original", "version", "of", "the", "corresponding", "blocks", "." ]

[ "func", "(", "ccs", "*", "crChains", ")", "changeOriginal", "(", "oldOriginal", "data", ".", "BlockPointer", ",", "newOriginal", "data", ".", "BlockPointer", ")", "error", "{", "if", "oldOriginal", "==", "newOriginal", "{", "// This apparently can happen, but I'm not sure how. (See", "// KBFS-2946.) Maybe because of a self-conflict in some weird", "// error conditions. In this case, we can just pretend the", "// change worked, and let CR continue it's normal process.", "return", "nil", "\n", "}", "\n", "chain", ",", "ok", ":=", "ccs", ".", "byOriginal", "[", "oldOriginal", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "WithStack", "(", "NoChainFoundError", "{", "oldOriginal", "}", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ccs", ".", "byOriginal", "[", "newOriginal", "]", ";", "ok", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "newOriginal", ")", "\n", "}", "\n\n", "delete", "(", "ccs", ".", "byOriginal", ",", "oldOriginal", ")", "\n", "chain", ".", "original", "=", "newOriginal", "\n", "ccs", ".", "byOriginal", "[", "newOriginal", "]", "=", "chain", "\n", "ccs", ".", "originals", "[", "oldOriginal", "]", "=", "newOriginal", "\n\n", "if", "_", ",", "ok", ":=", "ccs", ".", "deletedOriginals", "[", "oldOriginal", "]", ";", "ok", "{", "delete", "(", "ccs", ".", "deletedOriginals", ",", "oldOriginal", ")", "\n", "ccs", ".", "deletedOriginals", "[", "newOriginal", "]", "=", "true", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ccs", ".", "createdOriginals", "[", "oldOriginal", "]", ";", "ok", "{", "delete", "(", "ccs", ".", "createdOriginals", ",", "oldOriginal", ")", "\n", "// We're swapping in an original made on some other branch, so", "// it shouldn't go in the `createdOriginals` map.", "}", "\n", "if", "ri", ",", "ok", ":=", "ccs", ".", "renamedOriginals", "[", "oldOriginal", "]", ";", "ok", "{", "delete", "(", "ccs", ".", "renamedOriginals", ",", "oldOriginal", ")", "\n", "ccs", ".", "renamedOriginals", "[", "newOriginal", "]", "=", "ri", "\n", "}", "\n", "for", "p", ",", "info", ":=", "range", "ccs", ".", "renamedOriginals", "{", "changed", ":=", "false", "\n", "if", "info", ".", "originalOldParent", "==", "oldOriginal", "{", "info", ".", "originalOldParent", "=", "newOriginal", "\n", "changed", "=", "true", "\n", "}", "\n", "if", "info", ".", "originalNewParent", "==", "oldOriginal", "{", "info", ".", "originalNewParent", "=", "newOriginal", "\n", "changed", "=", "true", "\n", "}", "\n", "if", "changed", "{", "ccs", ".", "renamedOriginals", "[", "p", "]", "=", "info", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "changeOriginal", "converts", "the", "original", "of", "a", "chain", "to", "a", "different", "original", "which", "originated", "in", "some", "other", "branch", "." ]

[ "func", "(", "ccs", "*", "crChains", ")", "remove", "(", "ctx", "context", ".", "Context", ",", "log", "logger", ".", "Logger", ",", "revision", "kbfsmd", ".", "Revision", ")", "[", "]", "*", "crChain", "{", "var", "chainsWithRemovals", "[", "]", "*", "crChain", "\n", "for", "_", ",", "chain", ":=", "range", "ccs", ".", "byOriginal", "{", "if", "chain", ".", "remove", "(", "ctx", ",", "log", ",", "revision", ")", "{", "chainsWithRemovals", "=", "append", "(", "chainsWithRemovals", ",", "chain", ")", "\n", "}", "\n", "}", "\n", "return", "chainsWithRemovals", "\n", "}" ]

[ "remove", "deletes", "all", "operations", "associated", "with", "the", "given", "revision", "from", "the", "chains", ".", "It", "leaves", "original", "block", "pointers", "in", "place", "though", "even", "when", "removing", "operations", "from", "the", "head", "of", "the", "chain", ".", "It", "returns", "the", "set", "of", "chains", "with", "at", "least", "one", "operation", "removed", "." ]

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

[ "NewBootstrap", "creates", "a", "Bootstrap", "engine", "." ]

[ "func", "(", "e", "*", "Bootstrap", ")", "signedUp", "(", "m", "libkb", ".", "MetaContext", ")", "bool", "{", "cr", ":=", "m", ".", "G", "(", ")", ".", "Env", ".", "GetConfig", "(", ")", "\n", "if", "cr", "==", "nil", "{", "return", "false", "\n", "}", "\n", "if", "uid", ":=", "cr", ".", "GetUID", "(", ")", ";", "uid", ".", "Exists", "(", ")", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "signedUp", "is", "true", "if", "there", "s", "a", "uid", "in", "config", ".", "json", "." ]

[ "func", "(", "m", "*", "DiskCacheMode", ")", "Set", "(", "s", "string", ")", "error", "{", "*", "m", "=", "DiskCacheModeOff", "\n", "switch", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "s", ")", ")", "{", "case", "\"", "\"", ":", "*", "m", "=", "DiskCacheModeLocal", "\n", "case", "\"", "\"", ":", "*", "m", "=", "DiskCacheModeRemote", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Set", "parses", "a", "string", "representing", "a", "disk", "block", "cache", "initialization", "mode", "and", "outputs", "the", "mode", "value", "corresponding", "to", "that", "string", ".", "Defaults", "to", "DiskCacheModeOff", "." ]

[ "func", "(", "c", "*", "ConfigLocal", ")", "KBFSOps", "(", ")", "KBFSOps", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "c", ".", "kbfs", "\n", "}" ]

[ "KBFSOps", "implements", "the", "Config", "interface", "for", "ConfigLocal", "." ]

[ "func", "(", "c", "*", "ConfigLocal", ")", "SetKBFSOps", "(", "k", "KBFSOps", ")", "{", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "c", ".", "kbfs", "=", "k", "\n", "}" ]

[ "SetKBFSOps", "implements", "the", "Config", "interface", "for", "ConfigLocal", "." ]

[ "func", "(", "c", "*", "ConfigLocal", ")", "KBPKI", "(", ")", "KBPKI", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "c", ".", "kbpki", "\n", "}" ]

[ "KBPKI", "implements", "the", "Config", "interface", "for", "ConfigLocal", "." ]

[ "func", "(", "c", "*", "ConfigLocal", ")", "CurrentSessionGetter", "(", ")", "idutil", ".", "CurrentSessionGetter", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "c", ".", "kbpki", "\n", "}" ]

[ "CurrentSessionGetter", "implements", "the", "Config", "interface", "for", "ConfigLocal", "." ]

[ "func", "(", "c", "*", "ConfigLocal", ")", "SetKBPKI", "(", "k", "KBPKI", ")", "{", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "c", ".", "kbpki", "=", "k", "\n", "}" ]

[ "SetKBPKI", "implements", "the", "Config", "interface", "for", "ConfigLocal", "." ]

[ "func", "(", "c", "*", "ConfigLocal", ")", "KeyManager", "(", ")", "KeyManager", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "c", ".", "keyman", "\n", "}" ]

[ "KeyManager", "implements", "the", "Config", "interface", "for", "ConfigLocal", "." ]