Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "(", "df", "*", "DirtyFile", ")", "AssimilateDeferredNewBytes", "(", ")", "{", "df", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "df", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "df", ".", "deferredNewBytes", "==", "0", "{", "return", "\n", "}", "\n", "df", ".", "dirtyBcache", ".", "UpdateUnsyncedBytes", "(", "df", ".", "Path", ".", "Tlf", ",", "df", ".", "deferredNewBytes", ",", "false", ")", "\n", "df", ".", "deferredNewBytes", "=", "0", "\n", "}" ]

[ "AssimilateDeferredNewBytes", "is", "called", "to", "indicate", "that", "any", "deferred", "bytes", "should", "be", "included", "in", "the", "count", "of", "the", "next", "sync", "." ]

[ "func", "(", "g", "*", "GlobalContext", ")", "simulateServiceRestart", "(", ")", "{", "defer", "g", ".", "switchUserMu", ".", "Acquire", "(", "NewMetaContext", "(", "context", ".", "TODO", "(", ")", ",", "g", ")", ",", "\"", "\"", ")", "(", ")", "\n", "g", ".", "ActiveDevice", ".", "Clear", "(", ")", "\n", "}" ]

[ "simulateServiceRestart", "simulates", "what", "happens", "when", "a", "service", "restarts", "for", "the", "purposes", "of", "testing", "." ]

[ "func", "(", "g", "*", "GlobalContext", ")", "Shutdown", "(", ")", "error", "{", "var", "err", "error", "\n", "didShutdown", ":=", "false", "\n\n", "// Wrap in a Once.Do so that we don't inadvertedly", "// run this code twice.", "g", ".", "shutdownOnce", ".", "Do", "(", "func", "(", ")", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\\n", "\"", ",", "g", ")", "\n", "didShutdown", "=", "true", "\n\n", "epick", ":=", "FirstErrorPicker", "{", "}", "\n\n", "if", "g", ".", "NotifyRouter", "!=", "nil", "{", "g", ".", "NotifyRouter", ".", "Shutdown", "(", ")", "\n", "}", "\n\n", "if", "g", ".", "UIRouter", "!=", "nil", "{", "g", ".", "UIRouter", ".", "Shutdown", "(", ")", "\n", "}", "\n\n", "if", "g", ".", "ConnectionManager", "!=", "nil", "{", "g", ".", "ConnectionManager", ".", "Shutdown", "(", ")", "\n", "}", "\n\n", "if", "g", ".", "UI", "!=", "nil", "{", "epick", ".", "Push", "(", "g", ".", "UI", ".", "Shutdown", "(", ")", ")", "\n", "}", "\n", "if", "g", ".", "LocalDb", "!=", "nil", "{", "epick", ".", "Push", "(", "g", ".", "LocalDb", ".", "Close", "(", ")", ")", "\n", "}", "\n", "if", "g", ".", "LocalChatDb", "!=", "nil", "{", "epick", ".", "Push", "(", "g", ".", "LocalChatDb", ".", "Close", "(", ")", ")", "\n", "}", "\n\n", "// Shutdown can still race with Logout, so make sure that we hold onto", "// the cacheMu before shutting down the caches. See comments in", "// shutdownCachesLocked", "g", ".", "cacheMu", ".", "Lock", "(", ")", "\n", "g", ".", "shutdownCachesLocked", "(", ")", "\n", "g", ".", "cacheMu", ".", "Unlock", "(", ")", "\n\n", "if", "g", ".", "Resolver", "!=", "nil", "{", "g", ".", "Resolver", ".", "Shutdown", "(", "NewMetaContextBackground", "(", "g", ")", ")", "\n", "}", "\n\n", "for", "_", ",", "hook", ":=", "range", "g", ".", "ShutdownHooks", "{", "epick", ".", "Push", "(", "hook", "(", ")", ")", "\n", "}", "\n\n", "g", ".", "Identify3State", ".", "Shutdown", "(", ")", "\n\n", "err", "=", "epick", ".", "Error", "(", ")", "\n\n", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "g", ".", "ExitCode", ",", "err", ")", "\n", "}", ")", "\n\n", "// Make a little bit of a statement if we wind up here a second time", "// (which is a bug).", "if", "!", "didShutdown", "{", "g", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "Shutdown", "is", "called", "exactly", "once", "per", "-", "process", "and", "does", "whatever", "cleanup", "is", "necessary", "to", "shut", "down", "the", "server", "." ]

[ "func", "(", "g", "*", "GlobalContext", ")", "LogoutSelfCheck", "(", "ctx", "context", ".", "Context", ")", "error", "{", "mctx", ":=", "NewMetaContext", "(", "ctx", ",", "g", ")", "\n", "uid", ":=", "g", ".", "ActiveDevice", ".", "UID", "(", ")", "\n", "if", "uid", ".", "IsNil", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "deviceID", ":=", "g", ".", "ActiveDevice", ".", "DeviceID", "(", ")", "\n", "if", "deviceID", ".", "IsNil", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "arg", ":=", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "Args", ":", "HTTPArgs", "{", "\"", "\"", ":", "S", "{", "Val", ":", "uid", ".", "String", "(", ")", "}", ",", "\"", "\"", ":", "S", "{", "Val", ":", "deviceID", ".", "String", "(", ")", "}", ",", "}", ",", "SessionType", ":", "APISessionTypeREQUIRED", ",", "}", "\n", "res", ",", "err", ":=", "g", ".", "API", ".", "Post", "(", "mctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "logout", ",", "err", ":=", "res", ".", "Body", ".", "AtKey", "(", "\"", "\"", ")", ".", "GetBool", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "logout", ")", "\n", "if", "logout", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "g", ".", "Logout", "(", "mctx", ".", "Ctx", "(", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "LogoutSelfCheck", "checks", "with", "the", "API", "server", "to", "see", "if", "this", "uid", "+", "device", "pair", "should", "logout", "." ]

[ "func", "(", "g", "*", "GlobalContext", ")", "GetPerUserKeyring", "(", "ctx", "context", ".", "Context", ")", "(", "ret", "*", "PerUserKeyring", ",", "err", "error", ")", "{", "defer", "g", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "myUID", ":=", "g", ".", "ActiveDevice", ".", "UID", "(", ")", "\n", "if", "myUID", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Don't do any operations under these locks that could come back and hit them again.", "// That's why GetMyUID up above is not under this lock.", "g", ".", "perUserKeyringMu", ".", "Lock", "(", ")", "\n", "defer", "g", ".", "perUserKeyringMu", ".", "Unlock", "(", ")", "\n\n", "makeNew", ":=", "func", "(", ")", "(", "*", "PerUserKeyring", ",", "error", ")", "{", "pukring", ",", "err", ":=", "NewPerUserKeyring", "(", "g", ",", "myUID", ")", "\n", "if", "err", "!=", "nil", "{", "g", ".", "Log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "g", ".", "perUserKeyring", "=", "nil", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "g", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "g", ".", "perUserKeyring", "=", "pukring", "\n", "return", "g", ".", "perUserKeyring", ",", "nil", "\n", "}", "\n\n", "if", "g", ".", "perUserKeyring", "==", "nil", "{", "return", "makeNew", "(", ")", "\n", "}", "\n", "pukUID", ":=", "g", ".", "perUserKeyring", ".", "GetUID", "(", ")", "\n", "if", "pukUID", ".", "Equal", "(", "myUID", ")", "{", "return", "g", ".", "perUserKeyring", ",", "nil", "\n", "}", "\n", "return", "makeNew", "(", ")", "\n", "}" ]

[ "GetPerUserKeyring", "recreates", "PerUserKeyring", "if", "the", "uid", "changes", "or", "this", "is", "none", "installed", "." ]

[ "func", "(", "sfn", "*", "specialFileNode", ")", "ShouldCreateMissedLookup", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "bool", ",", "context", ".", "Context", ",", "data", ".", "EntryType", ",", "os", ".", "FileInfo", ",", "string", ")", "{", "if", "!", "perTlfWrappedNodeNames", "[", "name", "]", "{", "return", "sfn", ".", "Node", ".", "ShouldCreateMissedLookup", "(", "ctx", ",", "name", ")", "\n", "}", "\n\n", "switch", "name", "{", "case", "StatusFileName", ":", "sfn", ":=", "&", "statusFileNode", "{", "Node", ":", "nil", ",", "fb", ":", "sfn", ".", "GetFolderBranch", "(", ")", ",", "config", ":", "sfn", ".", "config", ",", "log", ":", "sfn", ".", "log", ",", "}", "\n", "f", ":=", "sfn", ".", "GetFile", "(", "ctx", ")", "\n", "return", "true", ",", "ctx", ",", "data", ".", "FakeFile", ",", "f", ".", "(", "*", "wrappedReadFile", ")", ".", "GetInfo", "(", ")", ",", "\"", "\"", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "}", "\n\n", "}" ]

[ "ShouldCreateMissedLookup", "implements", "the", "Node", "interface", "for", "specialFileNode", "." ]

[ "func", "(", "sfn", "*", "specialFileNode", ")", "WrapChild", "(", "child", "libkbfs", ".", "Node", ")", "libkbfs", ".", "Node", "{", "child", "=", "sfn", ".", "Node", ".", "WrapChild", "(", "child", ")", "\n", "name", ":=", "child", ".", "GetBasename", "(", ")", "\n", "if", "!", "perTlfWrappedNodeNames", "[", "name", "]", "{", "if", "child", ".", "EntryType", "(", ")", "==", "data", ".", "Dir", "{", "// Wrap this child too, so we can look up special files in", "// subdirectories of this node as well.", "return", "&", "specialFileNode", "{", "Node", ":", "child", ",", "config", ":", "sfn", ".", "config", ",", "log", ":", "sfn", ".", "log", ",", "}", "\n", "}", "\n", "return", "child", "\n", "}", "\n\n", "switch", "name", "{", "case", "StatusFileName", ":", "return", "&", "statusFileNode", "{", "Node", ":", "&", "libkbfs", ".", "ReadonlyNode", "{", "Node", ":", "child", "}", ",", "fb", ":", "sfn", ".", "GetFolderBranch", "(", ")", ",", "config", ":", "sfn", ".", "config", ",", "log", ":", "sfn", ".", "log", ",", "}", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "}", "\n", "}" ]

[ "WrapChild", "implements", "the", "Node", "interface", "for", "specialFileNode", "." ]

[ "func", "AddRootWrapper", "(", "config", "libkbfs", ".", "Config", ")", "{", "rw", ":=", "rootWrapper", "{", "config", ",", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "}", "\n", "config", ".", "AddRootNodeWrapper", "(", "rw", ".", "wrap", ")", "\n", "}" ]

[ "AddRootWrapper", "should", "be", "called", "on", "startup", "by", "any", "KBFS", "interface", "that", "wants", "to", "handle", "special", "files", "." ]

[ "func", "NewDelegateUICtlHandler", "(", "xp", "rpc", ".", "Transporter", ",", "id", "libkb", ".", "ConnectionID", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "rekeyMaster", "*", "rekeyMaster", ")", "*", "DelegateUICtlHandler", "{", "return", "&", "DelegateUICtlHandler", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "BaseHandler", ":", "NewBaseHandler", "(", "g", ",", "xp", ")", ",", "id", ":", "id", ",", "rekeyMaster", ":", "rekeyMaster", ",", "}", "\n", "}" ]

[ "NewDelegateUICtlHandler", "creates", "a", "new", "handler", "for", "setting", "up", "notification", "channels" ]

[ "func", "(", "v", "EncryptionVer", ")", "ToHashType", "(", ")", "kbfshash", ".", "HashType", "{", "switch", "v", "{", "case", "EncryptionSecretbox", ":", "return", "kbfshash", ".", "SHA256Hash", "\n", "case", "EncryptionSecretboxWithKeyNonce", ":", "return", "kbfshash", ".", "SHA256HashV2", "\n", "default", ":", "return", "kbfshash", ".", "InvalidHash", "\n", "}", "\n", "}" ]

[ "ToHashType", "returns", "the", "type", "of", "the", "hash", "that", "should", "be", "used", "for", "the", "given", "encryption", "version", "." ]

[ "func", "encryptDataWithNonce", "(", "data", "[", "]", "byte", ",", "key", "[", "32", "]", "byte", ",", "nonce", "[", "24", "]", "byte", ",", "ver", "EncryptionVer", ")", "(", "encryptedData", ",", "error", ")", "{", "sealedData", ":=", "secretbox", ".", "Seal", "(", "nil", ",", "data", ",", "&", "nonce", ",", "&", "key", ")", "\n\n", "return", "encryptedData", "{", "Version", ":", "ver", ",", "Nonce", ":", "nonce", "[", ":", "]", ",", "EncryptedData", ":", "sealedData", ",", "}", ",", "nil", "\n", "}" ]

[ "encryptDataWithNonce", "encrypts", "the", "given", "data", "with", "the", "given", "symmetric", "key", "and", "nonce", "." ]

[ "func", "encryptData", "(", "data", "[", "]", "byte", ",", "key", "[", "32", "]", "byte", ")", "(", "encryptedData", ",", "error", ")", "{", "var", "nonce", "[", "24", "]", "byte", "\n", "err", ":=", "RandRead", "(", "nonce", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "encryptedData", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "encryptDataWithNonce", "(", "data", ",", "key", ",", "nonce", ",", "EncryptionSecretbox", ")", "\n", "}" ]

[ "encryptData", "encrypts", "the", "given", "data", "with", "the", "given", "symmetric", "key", "." ]

[ "func", "decryptData", "(", "encryptedData", "encryptedData", ",", "key", "[", "32", "]", "byte", ",", "nonce", "[", "24", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "switch", "encryptedData", ".", "Version", "{", "case", "EncryptionSecretbox", ":", "// We're good, no nonce check needed.", "case", "EncryptionSecretboxWithKeyNonce", ":", "if", "!", "bytes", ".", "Equal", "(", "nonce", "[", ":", "]", ",", "encryptedData", ".", "Nonce", ")", "{", "return", "nil", ",", "errors", ".", "WithStack", "(", "InvalidNonceError", "{", "encryptedData", ".", "Nonce", "}", ")", "\n", "}", "\n", "default", ":", "return", "nil", ",", "errors", ".", "WithStack", "(", "UnknownEncryptionVer", "{", "encryptedData", ".", "Version", "}", ")", "\n", "}", "\n\n", "decryptedData", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "encryptedData", ".", "EncryptedData", ",", "&", "nonce", ",", "&", "key", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "WithStack", "(", "libkb", ".", "DecryptionError", "{", "Cause", ":", "errors", ".", "New", "(", "\"", "\"", ")", "}", ")", "\n", "}", "\n\n", "return", "decryptedData", ",", "nil", "\n", "}" ]

[ "decryptData", "decrypts", "the", "given", "encrypted", "data", "with", "the", "given", "symmetric", "key", "and", "nonce", "." ]

[ "func", "EncryptTLFCryptKeyClientHalf", "(", "privateKey", "TLFEphemeralPrivateKey", ",", "publicKey", "CryptPublicKey", ",", "clientHalf", "TLFCryptKeyClientHalf", ")", "(", "encryptedClientHalf", "EncryptedTLFCryptKeyClientHalf", ",", "err", "error", ")", "{", "var", "nonce", "[", "24", "]", "byte", "\n", "err", "=", "RandRead", "(", "nonce", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "keypair", ",", "err", ":=", "libkb", ".", "ImportKeypairFromKID", "(", "publicKey", ".", "KID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "errors", ".", "WithStack", "(", "err", ")", "\n", "}", "\n\n", "dhKeyPair", ",", "ok", ":=", "keypair", ".", "(", "libkb", ".", "NaclDHKeyPair", ")", "\n", "if", "!", "ok", "{", "return", "EncryptedTLFCryptKeyClientHalf", "{", "}", ",", "errors", ".", "WithStack", "(", "libkb", ".", "KeyCannotEncryptError", "{", "}", ")", "\n", "}", "\n\n", "clientHalfData", ":=", "clientHalf", ".", "Data", "(", ")", "\n", "privateKeyData", ":=", "privateKey", ".", "Data", "(", ")", "\n", "encryptedBytes", ":=", "box", ".", "Seal", "(", "nil", ",", "clientHalfData", "[", ":", "]", ",", "&", "nonce", ",", "(", "*", "[", "32", "]", "byte", ")", "(", "&", "dhKeyPair", ".", "Public", ")", ",", "&", "privateKeyData", ")", "\n\n", "return", "EncryptedTLFCryptKeyClientHalf", "{", "encryptedData", "{", "Version", ":", "EncryptionSecretbox", ",", "EncryptedData", ":", "encryptedBytes", ",", "Nonce", ":", "nonce", "[", ":", "]", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "EncryptTLFCryptKeyClientHalf", "encrypts", "a", "TLFCryptKeyClientHalf", "using", "both", "a", "TLF", "s", "ephemeral", "private", "key", "and", "a", "device", "pubkey", "." ]

[ "func", "EncryptEncodedPrivateMetadata", "(", "encodedPrivateMetadata", "[", "]", "byte", ",", "key", "TLFCryptKey", ")", "(", "encryptedPrivateMetadata", "EncryptedPrivateMetadata", ",", "err", "error", ")", "{", "encryptedData", ",", "err", ":=", "encryptData", "(", "encodedPrivateMetadata", ",", "key", ".", "Data", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedPrivateMetadata", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "EncryptedPrivateMetadata", "{", "encryptedData", "}", ",", "nil", "\n", "}" ]

[ "EncryptEncodedPrivateMetadata", "encrypts", "an", "encoded", "PrivateMetadata", "object", "." ]

[ "func", "DecryptPrivateMetadata", "(", "encryptedPrivateMetadata", "EncryptedPrivateMetadata", ",", "key", "TLFCryptKey", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "encryptedPrivateMetadata", ".", "encryptedData", ".", "Version", "==", "EncryptionSecretboxWithKeyNonce", "{", "// Only blocks should have v2 encryption.", "return", "nil", ",", "errors", ".", "WithStack", "(", "InvalidEncryptionVer", "{", "encryptedPrivateMetadata", ".", "encryptedData", ".", "Version", "}", ")", "\n", "}", "\n\n", "nonce", ",", "err", ":=", "encryptedPrivateMetadata", ".", "encryptedData", ".", "Nonce24", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "decryptData", "(", "encryptedPrivateMetadata", ".", "encryptedData", ",", "key", ".", "Data", "(", ")", ",", "nonce", ")", "\n", "}" ]

[ "DecryptPrivateMetadata", "decrypts", "a", "PrivateMetadata", "object", "but", "does", "not", "decode", "it", "." ]

[ "func", "EncryptPaddedEncodedBlock", "(", "paddedEncodedBlock", "[", "]", "byte", ",", "tlfCryptKey", "TLFCryptKey", ",", "blockServerHalf", "BlockCryptKeyServerHalf", ",", "ver", "EncryptionVer", ")", "(", "encryptedBlock", "EncryptedBlock", ",", "err", "error", ")", "{", "var", "ed", "encryptedData", "\n", "switch", "ver", "{", "case", "EncryptionSecretbox", ":", "key", ":=", "UnmaskBlockCryptKey", "(", "blockServerHalf", ",", "tlfCryptKey", ")", "\n", "ed", ",", "err", "=", "encryptData", "(", "paddedEncodedBlock", ",", "key", ".", "Data", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedBlock", "{", "}", ",", "err", "\n", "}", "\n", "case", "EncryptionSecretboxWithKeyNonce", ":", "key", ":=", "MakeBlockHashKey", "(", "blockServerHalf", ",", "tlfCryptKey", ")", "\n", "ed", ",", "err", "=", "encryptDataWithNonce", "(", "paddedEncodedBlock", ",", "key", ".", "cryptKey", "(", ")", ",", "key", ".", "nonce", "(", ")", ",", "EncryptionSecretboxWithKeyNonce", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedBlock", "{", "}", ",", "err", "\n", "}", "\n", "default", ":", "return", "EncryptedBlock", "{", "}", ",", "errors", ".", "WithStack", "(", "UnknownEncryptionVer", "{", "ver", "}", ")", "\n", "}", "\n\n", "return", "EncryptedBlock", "{", "ed", "}", ",", "nil", "\n", "}" ]

[ "EncryptPaddedEncodedBlock", "encrypts", "a", "padded", "encoded", "block", "." ]

[ "func", "DecryptBlock", "(", "encryptedBlock", "EncryptedBlock", ",", "tlfCryptKey", "TLFCryptKey", ",", "blockServerHalf", "BlockCryptKeyServerHalf", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "switch", "encryptedBlock", ".", "encryptedData", ".", "Version", "{", "case", "EncryptionSecretbox", ":", "nonce", ",", "err", ":=", "encryptedBlock", ".", "encryptedData", ".", "Nonce24", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "key", ":=", "UnmaskBlockCryptKey", "(", "blockServerHalf", ",", "tlfCryptKey", ")", "\n", "return", "decryptData", "(", "encryptedBlock", ".", "encryptedData", ",", "key", ".", "Data", "(", ")", ",", "nonce", ")", "\n", "case", "EncryptionSecretboxWithKeyNonce", ":", "key", ":=", "MakeBlockHashKey", "(", "blockServerHalf", ",", "tlfCryptKey", ")", "\n", "return", "decryptData", "(", "encryptedBlock", ".", "encryptedData", ",", "key", ".", "cryptKey", "(", ")", ",", "key", ".", "nonce", "(", ")", ")", "\n", "default", ":", "return", "nil", ",", "errors", ".", "WithStack", "(", "InvalidEncryptionVer", "{", "encryptedBlock", ".", "encryptedData", ".", "Version", "}", ")", "\n", "}", "\n", "}" ]

[ "DecryptBlock", "decrypts", "a", "block", "but", "does", "not", "unpad", "or", "decode", "it", "." ]

[ "func", "EncryptTLFCryptKeys", "(", "codec", "kbfscodec", ".", "Codec", ",", "oldKeys", "[", "]", "TLFCryptKey", ",", "key", "TLFCryptKey", ")", "(", "encryptedTLFCryptKeys", "EncryptedTLFCryptKeys", ",", "err", "error", ")", "{", "encodedKeys", ",", "err", ":=", "codec", ".", "Encode", "(", "oldKeys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedTLFCryptKeys", "{", "}", ",", "err", "\n", "}", "\n\n", "encryptedData", ",", "err", ":=", "encryptData", "(", "encodedKeys", ",", "key", ".", "Data", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "EncryptedTLFCryptKeys", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "EncryptedTLFCryptKeys", "{", "encryptedData", "}", ",", "nil", "\n", "}" ]

[ "EncryptTLFCryptKeys", "encrypts", "a", "TLFCryptKey", "array", "." ]

[ "func", "DecryptTLFCryptKeys", "(", "codec", "kbfscodec", ".", "Codec", ",", "encryptedTLFCryptKeys", "EncryptedTLFCryptKeys", ",", "key", "TLFCryptKey", ")", "(", "[", "]", "TLFCryptKey", ",", "error", ")", "{", "if", "encryptedTLFCryptKeys", ".", "encryptedData", ".", "Version", "==", "EncryptionSecretboxWithKeyNonce", "{", "// Only blocks should have v2 encryption.", "return", "nil", ",", "errors", ".", "WithStack", "(", "InvalidEncryptionVer", "{", "encryptedTLFCryptKeys", ".", "encryptedData", ".", "Version", "}", ")", "\n", "}", "\n\n", "nonce", ",", "err", ":=", "encryptedTLFCryptKeys", ".", "encryptedData", ".", "Nonce24", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "encodedKeys", ",", "err", ":=", "decryptData", "(", "encryptedTLFCryptKeys", ".", "encryptedData", ",", "key", ".", "Data", "(", ")", ",", "nonce", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "oldKeys", "[", "]", "TLFCryptKey", "\n", "err", "=", "codec", ".", "Decode", "(", "encodedKeys", ",", "&", "oldKeys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "oldKeys", ",", "nil", "\n", "}" ]

[ "DecryptTLFCryptKeys", "decrypts", "a", "TLFCryptKey", "array", "but", "does", "not", "decode", "it", "." ]

[ "func", "MakeEncryptedMerkleLeaf", "(", "version", "EncryptionVer", ",", "data", "[", "]", "byte", ",", "nonce", "*", "[", "24", "]", "byte", ")", "EncryptedMerkleLeaf", "{", "return", "EncryptedMerkleLeaf", "{", "encryptedData", "{", "Version", ":", "version", ",", "EncryptedData", ":", "data", ",", "Nonce", ":", "nonce", "[", ":", "]", ",", "}", ",", "}", "\n", "}" ]

[ "MakeEncryptedMerkleLeaf", "constructs", "an", "EncryptedMerkleLeaf", "." ]

[ "func", "PrepareMerkleLeaf", "(", "encryptedMerkleLeaf", "EncryptedMerkleLeaf", ")", "(", "nonce", "[", "24", "]", "byte", ",", "err", "error", ")", "{", "if", "encryptedMerkleLeaf", ".", "Version", "!=", "EncryptionSecretbox", "{", "return", "nonce", ",", "errors", ".", "WithStack", "(", "UnknownEncryptionVer", "{", "Ver", ":", "encryptedMerkleLeaf", ".", "Version", "}", ")", "\n", "}", "\n\n", "if", "len", "(", "encryptedMerkleLeaf", ".", "Nonce", ")", "!=", "len", "(", "nonce", ")", "{", "return", "nonce", ",", "errors", ".", "WithStack", "(", "InvalidNonceError", "{", "Nonce", ":", "encryptedMerkleLeaf", ".", "Nonce", "}", ")", "\n", "}", "\n", "copy", "(", "nonce", "[", ":", "]", ",", "encryptedMerkleLeaf", ".", "Nonce", ")", "\n", "return", "nonce", ",", "nil", "\n", "}" ]

[ "PrepareMerkleLeaf", "verifies", "the", "correctness", "of", "the", "given", "leaf", "and", "returns", "its", "nonce", "." ]

[ "func", "DecryptMerkleLeaf", "(", "privateKey", "TLFPrivateKey", ",", "publicKey", "TLFEphemeralPublicKey", ",", "encryptedMerkleLeaf", "EncryptedMerkleLeaf", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "nonce", ",", "err", ":=", "PrepareMerkleLeaf", "(", "encryptedMerkleLeaf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "publicKeyData", ":=", "publicKey", ".", "Data", "(", ")", "\n", "privateKeyData", ":=", "privateKey", ".", "Data", "(", ")", "\n", "decryptedData", ",", "ok", ":=", "box", ".", "Open", "(", "nil", ",", "encryptedMerkleLeaf", ".", "EncryptedData", ",", "&", "nonce", ",", "&", "publicKeyData", ",", "&", "privateKeyData", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "WithStack", "(", "libkb", ".", "DecryptionError", "{", "Cause", ":", "errors", ".", "New", "(", "\"", "\"", ")", "}", ")", "\n", "}", "\n", "return", "decryptedData", ",", "nil", "\n", "}" ]

[ "DecryptMerkleLeaf", "decrypts", "an", "EncryptedMerkleLeaf", "using", "the", "given", "private", "TLF", "key", "and", "ephemeral", "public", "key", "." ]

[ "func", "NewPerUserKeyUpkeep", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "args", "*", "PerUserKeyUpkeepArgs", ")", "*", "PerUserKeyUpkeep", "{", "return", "&", "PerUserKeyUpkeep", "{", "args", ":", "args", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPerUserKeyUpkeep", "creates", "a", "PerUserKeyUpkeep", "engine", "." ]

[ "func", "(", "e", "*", "PerUserKeyUpkeep", ")", "shouldRollKey", "(", "m", "libkb", ".", "MetaContext", ",", "uid", "keybase1", ".", "UID", ",", "upak", "*", "keybase1", ".", "UserPlusKeysV2", ")", "(", "bool", ",", "error", ")", "{", "if", "len", "(", "upak", ".", "PerUserKeys", ")", "==", "0", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "false", ",", "nil", "\n", "}", "\n", "m", ".", "Debug", "(", "\"", "\"", ",", "len", "(", "upak", ".", "PerUserKeys", ")", ")", "\n\n", "lastPuk", ":=", "upak", ".", "PerUserKeys", "[", "len", "(", "upak", ".", "PerUserKeys", ")", "-", "1", "]", "\n", "if", "!", "lastPuk", ".", "SignedByKID", ".", "IsValid", "(", ")", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "m", ".", "Debug", "(", "\"", "\"", ",", "lastPuk", ".", "SignedByKID", ".", "String", "(", ")", ")", "\n", "return", "!", "e", ".", "keyIsActiveSibkey", "(", "m", ",", "lastPuk", ".", "SignedByKID", ",", "upak", ")", ",", "nil", "\n", "}" ]

[ "Whether", "we", "should", "roll", "the", "per", "-", "user", "-", "key", "." ]

[ "func", "findDokanUninstall", "(", "log", "Log", ",", "wow64", "bool", ")", "(", "result", "string", ")", "{", "dokanRegexp", ":=", "regexp", ".", "MustCompile", "(", "\"", "\"", ")", "\n", "var", "access", "uint32", "=", "registry", ".", "ENUMERATE_SUB_KEYS", "|", "registry", ".", "QUERY_VALUE", "\n", "// Assume this is build 64 bit, so we need this flag to see 32 bit WOW registry", "// https://msdn.microsoft.com/en-us/library/windows/desktop/aa384129(v=vs.110).aspx", "if", "wow64", "{", "access", "=", "access", "|", "registry", ".", "WOW64_32KEY", "\n", "}", "\n\n", "k", ",", "err", ":=", "registry", ".", "OpenKey", "(", "registry", ".", "LOCAL_MACHINE", ",", "\"", "\\\\", "\\\\", "\\\\", "\\\\", "\"", ",", "access", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Info", "(", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "defer", "k", ".", "Close", "(", ")", "\n\n", "names", ",", "err", ":=", "k", ".", "ReadSubKeyNames", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Info", "(", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "return", "\n", "}", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "subKey", ",", "err", ":=", "registry", ".", "OpenKey", "(", "k", ",", "name", ",", "registry", ".", "QUERY_VALUE", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Info", "(", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ",", "name", ")", "\n", "}", "\n\n", "displayName", ",", "_", ",", "err", ":=", "subKey", ".", "GetStringValue", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "// this error is not interesting to log", "continue", "\n", "}", "\n", "if", "!", "dokanRegexp", ".", "MatchString", "(", "displayName", ")", "{", "continue", "\n", "}", "\n\n", "result", ",", "_", ",", "err", ":=", "subKey", ".", "GetStringValue", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "result", ",", "_", ",", "err", "=", "subKey", ".", "GetStringValue", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Info", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "else", "{", "return", "result", "\n", "}", "\n\n", "}", "\n", "return", "\n", "}" ]

[ "Read", "all", "the", "uninstall", "subkeys", "and", "find", "the", "ones", "with", "DisplayName", "starting", "with", "Dokan", "Library", "and", "containing", "Bundle" ]

[ "func", "(", "cache", "*", "DiskBlockCacheService", ")", "GetBlock", "(", "ctx", "context", ".", "Context", ",", "arg", "kbgitkbfs", ".", "GetBlockArg", ")", "(", "kbgitkbfs", ".", "GetBlockRes", ",", "error", ")", "{", "// TODO: make sure this isn't remote.", "dbc", ":=", "cache", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "==", "nil", "{", "return", "kbgitkbfs", ".", "GetBlockRes", "{", "}", ",", "DiskBlockCacheError", "{", "\"", "\"", "}", "\n", "}", "\n", "tlfID", ":=", "tlf", ".", "ID", "{", "}", "\n", "err", ":=", "tlfID", ".", "UnmarshalBinary", "(", "arg", ".", "TlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbgitkbfs", ".", "GetBlockRes", "{", "}", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "blockID", ":=", "kbfsblock", ".", "ID", "{", "}", "\n", "err", "=", "blockID", ".", "UnmarshalBinary", "(", "arg", ".", "BlockID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbgitkbfs", ".", "GetBlockRes", "{", "}", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "buf", ",", "serverHalf", ",", "prefetchStatus", ",", "err", ":=", "dbc", ".", "Get", "(", "ctx", ",", "tlfID", ",", "blockID", ",", "DiskBlockAnyCache", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbgitkbfs", ".", "GetBlockRes", "{", "}", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "protocolPrefetchStatus", ":=", "prefetchStatus", ".", "ToProtocol", "(", ")", "\n\n", "return", "kbgitkbfs", ".", "GetBlockRes", "{", "Buf", ":", "buf", ",", "ServerHalf", ":", "serverHalf", ".", "Bytes", "(", ")", ",", "PrefetchStatus", ":", "protocolPrefetchStatus", ",", "}", ",", "nil", "\n", "}" ]

[ "GetBlock", "implements", "the", "DiskBlockCacheInterface", "interface", "for", "DiskBlockCacheService", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheService", ")", "GetPrefetchStatus", "(", "ctx", "context", ".", "Context", ",", "arg", "kbgitkbfs", ".", "GetPrefetchStatusArg", ")", "(", "prefetchStatus", "kbgitkbfs", ".", "PrefetchStatus", ",", "err", "error", ")", "{", "dbc", ":=", "cache", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "==", "nil", "{", "return", "NoPrefetch", ".", "ToProtocol", "(", ")", ",", "DiskBlockCacheError", "{", "\"", "\"", "}", "\n", "}", "\n", "tlfID", ":=", "tlf", ".", "ID", "{", "}", "\n", "err", "=", "tlfID", ".", "UnmarshalBinary", "(", "arg", ".", "TlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NoPrefetch", ".", "ToProtocol", "(", ")", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "blockID", ":=", "kbfsblock", ".", "ID", "{", "}", "\n", "err", "=", "blockID", ".", "UnmarshalBinary", "(", "arg", ".", "BlockID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NoPrefetch", ".", "ToProtocol", "(", ")", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n\n", "cacheType", ":=", "DiskBlockAnyCache", "\n", "if", "cache", ".", "config", ".", "IsSyncedTlf", "(", "tlfID", ")", "{", "cacheType", "=", "DiskBlockSyncCache", "\n", "}", "\n\n", "dbStatus", ",", "err", ":=", "dbc", ".", "GetPrefetchStatus", "(", "ctx", ",", "tlfID", ",", "blockID", ",", "cacheType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NoPrefetch", ".", "ToProtocol", "(", ")", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "return", "dbStatus", ".", "ToProtocol", "(", ")", ",", "nil", "\n", "}" ]

[ "GetPrefetchStatus", "implements", "the", "DiskBlockCacheInterface", "interface", "for", "DiskBlockCacheService", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheService", ")", "PutBlock", "(", "ctx", "context", ".", "Context", ",", "arg", "kbgitkbfs", ".", "PutBlockArg", ")", "error", "{", "dbc", ":=", "cache", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "==", "nil", "{", "return", "DiskBlockCacheError", "{", "\"", "\"", "}", "\n", "}", "\n", "tlfID", ":=", "tlf", ".", "ID", "{", "}", "\n", "err", ":=", "tlfID", ".", "UnmarshalBinary", "(", "arg", ".", "TlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "blockID", ":=", "kbfsblock", ".", "ID", "{", "}", "\n", "err", "=", "blockID", ".", "UnmarshalBinary", "(", "arg", ".", "BlockID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "serverHalf", ":=", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", "\n", "err", "=", "serverHalf", ".", "UnmarshalBinary", "(", "arg", ".", "ServerHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "cacheType", ":=", "DiskBlockAnyCache", "\n", "if", "cache", ".", "config", ".", "IsSyncedTlf", "(", "tlfID", ")", "{", "cacheType", "=", "DiskBlockSyncCache", "\n", "}", "\n", "err", "=", "dbc", ".", "Put", "(", "ctx", ",", "tlfID", ",", "blockID", ",", "arg", ".", "Buf", ",", "serverHalf", ",", "cacheType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "PutBlock", "implements", "the", "DiskBlockCacheInterface", "interface", "for", "DiskBlockCacheService", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheService", ")", "DeleteBlocks", "(", "ctx", "context", ".", "Context", ",", "blockIDs", "[", "]", "[", "]", "byte", ")", "(", "kbgitkbfs", ".", "DeleteBlocksRes", ",", "error", ")", "{", "dbc", ":=", "cache", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "==", "nil", "{", "return", "kbgitkbfs", ".", "DeleteBlocksRes", "{", "}", ",", "DiskBlockCacheError", "{", "\"", "\"", "}", "\n", "}", "\n", "blocks", ":=", "make", "(", "[", "]", "kbfsblock", ".", "ID", ",", "0", ",", "len", "(", "blockIDs", ")", ")", "\n", "for", "_", ",", "b", ":=", "range", "blockIDs", "{", "blockID", ":=", "kbfsblock", ".", "ID", "{", "}", "\n", "err", ":=", "blockID", ".", "UnmarshalBinary", "(", "b", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbgitkbfs", ".", "DeleteBlocksRes", "{", "}", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "blocks", "=", "append", "(", "blocks", ",", "blockID", ")", "\n", "}", "\n", "numRemoved", ",", "sizeRemoved", ",", "err", ":=", "dbc", ".", "Delete", "(", "ctx", ",", "blocks", ",", "DiskBlockAnyCache", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbgitkbfs", ".", "DeleteBlocksRes", "{", "}", ",", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "return", "kbgitkbfs", ".", "DeleteBlocksRes", "{", "NumRemoved", ":", "numRemoved", ",", "SizeRemoved", ":", "sizeRemoved", ",", "}", ",", "nil", "\n", "}" ]

[ "DeleteBlocks", "implements", "the", "DiskBlockCacheInterface", "interface", "for", "DiskBlockCacheService", "." ]

[ "func", "(", "cache", "*", "DiskBlockCacheService", ")", "UpdateBlockMetadata", "(", "ctx", "context", ".", "Context", ",", "arg", "kbgitkbfs", ".", "UpdateBlockMetadataArg", ")", "error", "{", "dbc", ":=", "cache", ".", "config", ".", "DiskBlockCache", "(", ")", "\n", "if", "dbc", "==", "nil", "{", "return", "DiskBlockCacheError", "{", "\"", "\"", "}", "\n", "}", "\n", "tlfID", ":=", "tlf", ".", "ID", "{", "}", "\n", "err", ":=", "tlfID", ".", "UnmarshalBinary", "(", "arg", ".", "TlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "blockID", ":=", "kbfsblock", ".", "ID", "{", "}", "\n", "err", "=", "blockID", ".", "UnmarshalBinary", "(", "arg", ".", "BlockID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "err", "=", "dbc", ".", "UpdateMetadata", "(", "ctx", ",", "tlfID", ",", "blockID", ",", "PrefetchStatus", "(", "arg", ".", "PrefetchStatus", ")", ",", "DiskBlockAnyCache", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newDiskBlockCacheError", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UpdateBlockMetadata", "implements", "the", "DiskBlockCacheInterface", "interface", "for", "DiskBlockCacheService", "." ]

[ "func", "BoxAndEncode", "(", "a", "*", "stellar1", ".", "Bundle", ",", "pukGen", "keybase1", ".", "PerUserKeyGeneration", ",", "puk", "libkb", ".", "PerUserKeySeed", ")", "(", "*", "BoxedEncoded", ",", "error", ")", "{", "err", ":=", "a", ".", "CheckInvariants", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "accountsVisible", ",", "accountsSecret", ":=", "visibilitySplit", "(", "a", ")", "\n\n", "// visible portion parent", "visibleV2", ":=", "newVisibleParent", "(", "a", ",", "accountsVisible", ")", "\n\n", "boxed", ":=", "newBoxedEncoded", "(", ")", "\n\n", "// encrypted account bundles", "for", "i", ",", "acctEntry", ":=", "range", "visibleV2", ".", "Accounts", "{", "secret", ",", "ok", ":=", "a", ".", "AccountBundles", "[", "acctEntry", ".", "AccountID", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "ab", ",", "err", ":=", "accountBoxAndEncode", "(", "acctEntry", ".", "AccountID", ",", "secret", ",", "pukGen", ",", "puk", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "boxed", ".", "AcctBundles", "[", "acctEntry", ".", "AccountID", "]", "=", "*", "ab", "\n\n", "visibleV2", ".", "Accounts", "[", "i", "]", ".", "EncAcctBundleHash", "=", "ab", ".", "EncHash", "\n", "}", "\n\n", "// have to do this after to get hashes of encrypted account bundles", "visiblePack", ",", "err", ":=", "libkb", ".", "MsgpackEncode", "(", "visibleV2", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "visibleHash", ":=", "sha256", ".", "Sum256", "(", "visiblePack", ")", "\n", "boxed", ".", "VisParentB64", "=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "visiblePack", ")", "\n\n", "// secret portion parent", "versionedSecret", ":=", "stellar1", ".", "NewBundleSecretVersionedWithV2", "(", "stellar1", ".", "BundleSecretV2", "{", "VisibleHash", ":", "visibleHash", "[", ":", "]", ",", "Accounts", ":", "accountsSecret", ",", "}", ")", "\n", "boxed", ".", "EncParent", ",", "boxed", ".", "EncParentB64", ",", "err", "=", "parentBoxAndEncode", "(", "versionedSecret", ",", "pukGen", ",", "puk", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "boxed", ",", "nil", "\n", "}" ]

[ "BoxAndEncode", "encrypts", "and", "encodes", "a", "Bundle", "object", "." ]

[ "func", "unboxParent", "(", "encBundle", "stellar1", ".", "EncryptedBundle", ",", "hash", "stellar1", ".", "Hash", ",", "visB64", "string", ",", "puk", "libkb", ".", "PerUserKeySeed", ")", "(", "*", "stellar1", ".", "Bundle", ",", "stellar1", ".", "BundleVersion", ",", "error", ")", "{", "versioned", ",", "err", ":=", "decryptParent", "(", "encBundle", ",", "puk", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "version", ",", "err", ":=", "versioned", ".", "Version", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "var", "bundleOut", "stellar1", ".", "Bundle", "\n", "switch", "version", "{", "case", "stellar1", ".", "BundleVersion_V2", ":", "bundleOut", ",", "err", "=", "unboxParentV2", "(", "versioned", ",", "visB64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "default", ":", "return", "nil", ",", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "version", ")", "\n", "}", "\n\n", "bundleOut", ".", "OwnHash", "=", "hash", "\n", "if", "len", "(", "bundleOut", ".", "OwnHash", ")", "==", "0", "{", "return", "nil", ",", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "bundleOut", ",", "version", ",", "nil", "\n", "}" ]

[ "unboxParent", "unboxes", "an", "encrypted", "parent", "bundle", "and", "decodes", "the", "visual", "portion", "of", "the", "bundle", ".", "It", "validates", "the", "visible", "hash", "in", "the", "secret", "portion", "." ]

[ "func", "decryptParent", "(", "encBundle", "stellar1", ".", "EncryptedBundle", ",", "puk", "libkb", ".", "PerUserKeySeed", ")", "(", "res", "stellar1", ".", "BundleSecretVersioned", ",", "err", "error", ")", "{", "switch", "encBundle", ".", "V", "{", "case", "1", ":", "// CORE-8135", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "case", "2", ":", "default", ":", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "encBundle", ".", "V", ")", "\n", "}", "\n\n", "// Derive key", "reason", ":=", "libkb", ".", "DeriveReasonPUKStellarBundle", "\n", "symmetricKey", ",", "err", ":=", "puk", ".", "DeriveSymmetricKey", "(", "reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// Secretbox", "clearpack", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "encBundle", ".", "E", ",", "(", "*", "[", "libkb", ".", "NaclDHNonceSize", "]", "byte", ")", "(", "&", "encBundle", ".", "N", ")", ",", "(", "*", "[", "libkb", ".", "NaclSecretBoxKeySize", "]", "byte", ")", "(", "&", "symmetricKey", ")", ")", "\n", "if", "!", "ok", "{", "return", "res", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Msgpack (inner)", "err", "=", "libkb", ".", "MsgpackDecode", "(", "&", "res", ",", "clearpack", ")", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "decryptParent", "decrypts", "an", "encrypted", "parent", "bundle", "with", "the", "provided", "puk", "." ]

[ "func", "decode", "(", "encryptedB64", "string", ")", "(", "stellar1", ".", "EncryptedAccountBundle", ",", "stellar1", ".", "Hash", ",", "error", ")", "{", "cipherpack", ",", "err", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "encryptedB64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "stellar1", ".", "EncryptedAccountBundle", "{", "}", ",", "stellar1", ".", "Hash", "{", "}", ",", "err", "\n", "}", "\n", "encHash", ":=", "sha256", ".", "Sum256", "(", "cipherpack", ")", "\n", "var", "enc", "stellar1", ".", "EncryptedAccountBundle", "\n", "if", "err", "=", "libkb", ".", "MsgpackDecode", "(", "&", "enc", ",", "cipherpack", ")", ";", "err", "!=", "nil", "{", "return", "stellar1", ".", "EncryptedAccountBundle", "{", "}", ",", "stellar1", ".", "Hash", "{", "}", ",", "err", "\n", "}", "\n", "return", "enc", ",", "encHash", "[", ":", "]", ",", "nil", "\n", "}" ]

[ "decode", "decodes", "a", "base64", "-", "encoded", "encrypted", "account", "bundle", "." ]

[ "func", "unbox", "(", "encBundle", "stellar1", ".", "EncryptedAccountBundle", ",", "hash", "stellar1", ".", "Hash", "/* visB64 string, */", ",", "puk", "libkb", ".", "PerUserKeySeed", ")", "(", "*", "stellar1", ".", "AccountBundle", ",", "stellar1", ".", "AccountBundleVersion", ",", "error", ")", "{", "versioned", ",", "err", ":=", "decrypt", "(", "encBundle", ",", "puk", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n", "version", ",", "err", ":=", "versioned", ".", "Version", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "0", ",", "err", "\n", "}", "\n\n", "var", "bundleOut", "stellar1", ".", "AccountBundle", "\n", "switch", "version", "{", "case", "stellar1", ".", "AccountBundleVersion_V1", ":", "secretV1", ":=", "versioned", ".", "V1", "(", ")", "\n", "bundleOut", "=", "stellar1", ".", "AccountBundle", "{", "AccountID", ":", "secretV1", ".", "AccountID", ",", "Signers", ":", "secretV1", ".", "Signers", ",", "}", "\n", "case", "stellar1", ".", "AccountBundleVersion_V2", ",", "stellar1", ".", "AccountBundleVersion_V3", ",", "stellar1", ".", "AccountBundleVersion_V4", ",", "stellar1", ".", "AccountBundleVersion_V5", ",", "stellar1", ".", "AccountBundleVersion_V6", ",", "stellar1", ".", "AccountBundleVersion_V7", ",", "stellar1", ".", "AccountBundleVersion_V8", ",", "stellar1", ".", "AccountBundleVersion_V9", ",", "stellar1", ".", "AccountBundleVersion_V10", ":", "return", "nil", ",", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "return", "nil", ",", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "bundleOut", ".", "OwnHash", "=", "hash", "\n", "if", "len", "(", "bundleOut", ".", "OwnHash", ")", "==", "0", "{", "return", "nil", ",", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "bundleOut", ",", "version", ",", "nil", "\n", "}" ]

[ "unbox", "unboxes", "an", "encrypted", "account", "bundle", "and", "decodes", "the", "visual", "portion", "of", "the", "bundle", ".", "It", "validates", "the", "visible", "hash", "in", "the", "secret", "portion", "." ]

[ "func", "decrypt", "(", "encBundle", "stellar1", ".", "EncryptedAccountBundle", ",", "puk", "libkb", ".", "PerUserKeySeed", ")", "(", "stellar1", ".", "AccountBundleSecretVersioned", ",", "error", ")", "{", "var", "empty", "stellar1", ".", "AccountBundleSecretVersioned", "\n", "if", "encBundle", ".", "V", "!=", "1", "{", "return", "empty", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Derive key", "reason", ":=", "libkb", ".", "DeriveReasonPUKStellarAcctBundle", "\n", "symmetricKey", ",", "err", ":=", "puk", ".", "DeriveSymmetricKey", "(", "reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "empty", ",", "err", "\n", "}", "\n\n", "// Secretbox", "clearpack", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "encBundle", ".", "E", ",", "(", "*", "[", "libkb", ".", "NaclDHNonceSize", "]", "byte", ")", "(", "&", "encBundle", ".", "N", ")", ",", "(", "*", "[", "libkb", ".", "NaclSecretBoxKeySize", "]", "byte", ")", "(", "&", "symmetricKey", ")", ")", "\n", "if", "!", "ok", "{", "return", "empty", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Msgpack (inner)", "var", "bver", "stellar1", ".", "AccountBundleSecretVersioned", "\n", "err", "=", "libkb", ".", "MsgpackDecode", "(", "&", "bver", ",", "clearpack", ")", "\n", "if", "err", "!=", "nil", "{", "return", "empty", ",", "err", "\n", "}", "\n", "return", "bver", ",", "nil", "\n", "}" ]

[ "decrypt", "decrypts", "an", "encrypted", "account", "bundle", "with", "the", "provided", "puk", "." ]

[ "func", "merge", "(", "secret", "stellar1", ".", "BundleSecretV2", ",", "visible", "stellar1", ".", "BundleVisibleV2", ")", "(", "stellar1", ".", "Bundle", ",", "error", ")", "{", "if", "len", "(", "secret", ".", "Accounts", ")", "!=", "len", "(", "visible", ".", "Accounts", ")", "{", "return", "stellar1", ".", "Bundle", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "accounts", ":=", "convertVisibleAccounts", "(", "visible", ".", "Accounts", ")", "\n\n", "// these should be in the same order", "for", "i", ",", "secretAccount", ":=", "range", "secret", ".", "Accounts", "{", "if", "accounts", "[", "i", "]", ".", "AccountID", "!=", "secretAccount", ".", "AccountID", "{", "return", "stellar1", ".", "Bundle", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "accounts", "[", "i", "]", ".", "Name", "=", "secretAccount", ".", "Name", "\n", "}", "\n", "return", "stellar1", ".", "Bundle", "{", "Revision", ":", "visible", ".", "Revision", ",", "Prev", ":", "visible", ".", "Prev", ",", "Accounts", ":", "accounts", ",", "}", ",", "nil", "\n", "}" ]

[ "merge", "combines", "the", "versioned", "secret", "account", "bundle", "and", "the", "visible", "account", "bundle", "into", "a", "stellar1", ".", "AccountBundle", "for", "local", "use", "." ]

[ "func", "NewSaltpackVerify", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "SaltpackVerifyArg", ")", "*", "SaltpackVerify", "{", "return", "&", "SaltpackVerify", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewSaltpackVerify", "creates", "a", "SaltpackVerify", "engine", "." ]

[ "func", "CheckUsername", "(", "s", "string", ")", "bool", "{", "return", "len", "(", "s", ")", ">=", "2", "&&", "len", "(", "s", ")", "<=", "16", "&&", "usernameRE", ".", "MatchString", "(", "s", ")", "\n", "}" ]

[ "CheckUsername", "returns", "true", "if", "the", "given", "string", "can", "be", "a", "Keybase", "username", "." ]

[ "func", "(", "n", "NormalizedUsername", ")", "Eq", "(", "n2", "NormalizedUsername", ")", "bool", "{", "return", "string", "(", "n", ")", "==", "string", "(", "n2", ")", "\n", "}" ]

[ "Eq", "returns", "true", "if", "the", "given", "normalized", "usernames", "are", "equal" ]

[ "func", "(", "s", "*", "store", ")", "deleteOldVersions", "(", "ctx", "context", ".", "Context", ",", "keyFn", "func", "(", "int", ")", "(", "libkb", ".", "DbKey", ",", "error", ")", ",", "maxVersion", "int", ")", "{", "for", "version", ":=", "1", ";", "version", "<", "maxVersion", ";", "version", "++", "{", "key", ",", "err", ":=", "keyFn", "(", "version", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "version", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "version", ",", "key", ")", "\n", "if", "err", ":=", "s", ".", "G", "(", ")", ".", "LocalChatDb", ".", "Delete", "(", "key", ")", ";", "err", "!=", "nil", "{", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "deleteOldVersions", "purges", "old", "disk", "structures", "so", "we", "don", "t", "error", "out", "on", "msg", "pack", "decode", "or", "strand", "indexes", "with", "ephemeral", "content", "." ]

[ "func", "(", "s", "*", "store", ")", "addTokens", "(", "ctx", "context", ".", "Context", ",", "batch", "*", "addTokenBatch", ",", "uid", "gregor1", ".", "UID", ",", "convID", "chat1", ".", "ConversationID", ",", "tokens", "tokenMap", ",", "msgID", "chat1", ".", "MessageID", ")", "error", "{", "for", "token", ",", "aliases", ":=", "range", "tokens", "{", "// Update the token entry with the msg ID hit", "te", ",", "err", ":=", "s", ".", "getTokenEntryWithBatch", "(", "ctx", ",", "batch", ",", "uid", ",", "convID", ",", "token", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "te", ".", "MsgIDs", "[", "msgID", "]", "=", "chat1", ".", "EmptyStruct", "{", "}", "\n\n", "// Update all the aliases to point at the token", "for", "alias", ":=", "range", "aliases", "{", "aliasEntry", ",", "err", ":=", "s", ".", "getAliasEntryWithBatch", "(", "ctx", ",", "batch", ",", "alias", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "aliasEntry", ".", "Aliases", "[", "token", "]", "=", "chat1", ".", "EmptyStruct", "{", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "addTokens", "add", "the", "given", "tokens", "to", "the", "index", "under", "the", "given", "message", "id", "when", "ingesting", "EDIT", "messages", "the", "msgID", "is", "of", "the", "superseded", "msg", "but", "the", "tokens", "are", "from", "the", "EDIT", "itself", "." ]

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

[ "NewDeviceHandler", "creates", "a", "DeviceHandler", "for", "the", "xp", "transport", "." ]

[ "func", "(", "h", "*", "DeviceHandler", ")", "DeviceList", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "[", "]", "keybase1", ".", "Device", ",", "error", ")", "{", "uis", ":=", "libkb", ".", "UIs", "{", "LogUI", ":", "h", ".", "getLogUI", "(", "sessionID", ")", ",", "SessionID", ":", "sessionID", ",", "}", "\n", "eng", ":=", "engine", ".", "NewDevList", "(", "h", ".", "G", "(", ")", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "h", ".", "G", "(", ")", ")", ".", "WithUIs", "(", "uis", ")", "\n", "if", "err", ":=", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "eng", ".", "List", "(", ")", ",", "nil", "\n", "}" ]

[ "DeviceList", "returns", "a", "list", "of", "all", "the", "devices", "for", "a", "user", "." ]

[ "func", "(", "h", "*", "DeviceHandler", ")", "DeviceHistoryList", "(", "nctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "[", "]", "keybase1", ".", "DeviceDetail", ",", "error", ")", "{", "uis", ":=", "libkb", ".", "UIs", "{", "LogUI", ":", "h", ".", "getLogUI", "(", "sessionID", ")", ",", "SessionID", ":", "sessionID", ",", "}", "\n", "eng", ":=", "engine", ".", "NewDeviceHistorySelf", "(", "h", ".", "G", "(", ")", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "nctx", ",", "h", ".", "G", "(", ")", ")", ".", "WithUIs", "(", "uis", ")", "\n", "if", "err", ":=", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "eng", ".", "Devices", "(", ")", ",", "nil", "\n", "}" ]

[ "DeviceHistoryList", "returns", "a", "list", "of", "all", "the", "devices", "for", "a", "user", "with", "detailed", "history", "and", "provisioner", "revoker", "information", "." ]

[ "func", "(", "h", "*", "DeviceHandler", ")", "CheckDeviceNameFormat", "(", "_", "context", ".", "Context", ",", "arg", "keybase1", ".", "CheckDeviceNameFormatArg", ")", "(", "bool", ",", "error", ")", "{", "ok", ":=", "libkb", ".", "CheckDeviceName", ".", "F", "(", "arg", ".", "Name", ")", "\n", "if", "ok", "{", "return", "ok", ",", "nil", "\n", "}", "\n", "return", "false", ",", "errors", ".", "New", "(", "libkb", ".", "CheckDeviceName", ".", "Hint", ")", "\n", "}" ]

[ "CheckDeviceNameFormat", "verifies", "that", "the", "device", "name", "has", "a", "valid", "format", "." ]

[ "func", "NewCmdCtlStart", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Flags", ":", "[", "]", "cli", ".", "Flag", "{", "cli", ".", "StringFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "availableCtlComponents", ")", ",", "}", ",", "cli", ".", "StringFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "availableCtlComponents", ")", ",", "}", ",", "}", ",", "Action", ":", "func", "(", "c", "*", "cli", ".", "Context", ")", "{", "cl", ".", "ChooseCommand", "(", "newCmdCtlStart", "(", "g", ")", ",", "\"", "\"", ",", "c", ")", "\n", "cl", ".", "SetForkCmd", "(", "libcmdline", ".", "NoFork", ")", "\n", "cl", ".", "SetLogForward", "(", "libcmdline", ".", "LogForwardNone", ")", "\n", "cl", ".", "SetNoStandalone", "(", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewCmdCtlStart", "constructs", "ctl", "start", "command" ]

[ "func", "MakeImmutableBareRootMetadata", "(", "rmd", "kbfsmd", ".", "RootMetadata", ",", "extra", "kbfsmd", ".", "ExtraMetadata", ",", "mdID", "kbfsmd", ".", "ID", ",", "localTimestamp", "time", ".", "Time", ")", "ImmutableBareRootMetadata", "{", "if", "mdID", "==", "(", "kbfsmd", ".", "ID", "{", "}", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ImmutableBareRootMetadata", "{", "rmd", ",", "extra", ",", "mdID", ",", "localTimestamp", "}", "\n", "}" ]

[ "MakeImmutableBareRootMetadata", "makes", "a", "new", "ImmutableBareRootMetadata", "from", "the", "given", "BareRootMetadata", "and", "its", "corresponding", "MdID", "." ]

[ "func", "(", "ibrmd", "ImmutableBareRootMetadata", ")", "MakeBareTlfHandleWithExtra", "(", ")", "(", "tlf", ".", "Handle", ",", "error", ")", "{", "return", "ibrmd", ".", "RootMetadata", ".", "MakeBareTlfHandle", "(", "ibrmd", ".", "extra", ")", "\n", "}" ]

[ "MakeBareTlfHandleWithExtra", "makes", "a", "BareTlfHandle", "for", "this", "ImmutableBareRootMetadata", ".", "Should", "be", "used", "only", "by", "servers", "and", "MDOps", "." ]

[ "func", "(", "j", "mdJournal", ")", "getExtraMetadata", "(", "wkbID", "kbfsmd", ".", "TLFWriterKeyBundleID", ",", "rkbID", "kbfsmd", ".", "TLFReaderKeyBundleID", ",", "wkbNew", ",", "rkbNew", "bool", ")", "(", "kbfsmd", ".", "ExtraMetadata", ",", "error", ")", "{", "if", "(", "wkbID", "==", "kbfsmd", ".", "TLFWriterKeyBundleID", "{", "}", ")", "!=", "(", "rkbID", "==", "kbfsmd", ".", "TLFReaderKeyBundleID", "{", "}", ")", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "wkbID", "==", "kbfsmd", ".", "TLFWriterKeyBundleID", "{", "}", ",", "rkbID", "==", "kbfsmd", ".", "TLFReaderKeyBundleID", "{", "}", ")", "\n", "}", "\n\n", "if", "wkbID", "==", "(", "kbfsmd", ".", "TLFWriterKeyBundleID", "{", "}", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "wkb", ",", "err", ":=", "kbfsmd", ".", "DeserializeTLFWriterKeyBundleV3", "(", "j", ".", "codec", ",", "j", ".", "writerKeyBundleV3Path", "(", "wkbID", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "kbfsmd", ".", "CheckWKBID", "(", "j", ".", "codec", ",", "wkbID", ",", "wkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "rkb", ",", "err", ":=", "kbfsmd", ".", "DeserializeTLFReaderKeyBundleV3", "(", "j", ".", "codec", ",", "j", ".", "readerKeyBundleV3Path", "(", "rkbID", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", "=", "kbfsmd", ".", "CheckRKBID", "(", "j", ".", "codec", ",", "rkbID", ",", "rkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "kbfsmd", ".", "NewExtraMetadataV3", "(", "wkb", ",", "rkb", ",", "wkbNew", ",", "rkbNew", ")", ",", "nil", "\n", "}" ]

[ "getExtraMetadata", "gets", "the", "extra", "metadata", "corresponding", "to", "the", "given", "IDs", "if", "any", "after", "checking", "them", "." ]

[ "func", "(", "j", "mdJournal", ")", "getEarliestWithExtra", "(", "ctx", "context", ".", "Context", ",", "verifyBranchID", "bool", ")", "(", "kbfsmd", ".", "ID", ",", "kbfsmd", ".", "MutableRootMetadata", ",", "kbfsmd", ".", "ExtraMetadata", ",", "time", ".", "Time", ",", "error", ")", "{", "entry", ",", "exists", ",", "err", ":=", "j", ".", "j", ".", "getEarliestEntry", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsmd", ".", "ID", "{", "}", ",", "nil", ",", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "if", "!", "exists", "{", "return", "kbfsmd", ".", "ID", "{", "}", ",", "nil", ",", "nil", ",", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}", "\n", "earliest", ",", "extra", ",", "timestamp", ",", "err", ":=", "j", ".", "getMDAndExtra", "(", "ctx", ",", "entry", ",", "verifyBranchID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbfsmd", ".", "ID", "{", "}", ",", "nil", ",", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "return", "entry", ".", "ID", ",", "earliest", ",", "extra", ",", "timestamp", ",", "nil", "\n", "}" ]

[ "getEarliestWithExtra", "returns", "a", "kbfsmd", ".", "MutableRootMetadata", "so", "that", "it", "can", "be", "put", "in", "a", "RootMetadataSigned", "object", "." ]

[ "func", "(", "j", "*", "mdJournal", ")", "clearHelper", "(", "ctx", "context", ".", "Context", ",", "bid", "kbfsmd", ".", "BranchID", ",", "earliestBranchRevision", "kbfsmd", ".", "Revision", ")", "(", "err", "error", ")", "{", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "bid", ")", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "j", ".", "deferLog", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "bid", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "if", "bid", "==", "kbfsmd", ".", "NullBranchID", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "j", ".", "branchID", "!=", "bid", "{", "// Nothing to do.", "j", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "bid", ",", "j", ".", "branchID", ")", "\n", "return", "nil", "\n", "}", "\n\n", "head", ",", "err", ":=", "j", ".", "getHead", "(", "ctx", ",", "bid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "head", "==", "(", "ImmutableBareRootMetadata", "{", "}", ")", "{", "// The journal has been flushed but not cleared yet.", "j", ".", "branchID", "=", "kbfsmd", ".", "NullBranchID", "\n", "return", "nil", "\n", "}", "\n\n", "if", "head", ".", "BID", "(", ")", "!=", "j", ".", "branchID", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "head", ".", "BID", "(", ")", ",", "j", ".", "branchID", ")", "\n", "}", "\n\n", "latestRevision", ",", "err", ":=", "j", ".", "j", ".", "readLatestRevision", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "allEntries", ",", "err", ":=", "j", ".", "j", ".", "getEntryRange", "(", "earliestBranchRevision", ",", "latestRevision", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "j", ".", "j", ".", "clearFrom", "(", "earliestBranchRevision", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "j", ".", "branchID", "=", "kbfsmd", ".", "NullBranchID", "\n\n", "// No need to set lastMdID in this case.", "// Garbage-collect the old branch entries. TODO: we'll eventually", "// need a sweeper to clean up entries left behind if we crash", "// here.", "for", "_", ",", "entry", ":=", "range", "allEntries", "{", "err", ":=", "j", ".", "removeMD", "(", "entry", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "clearHelper", "removes", "all", "the", "journal", "entries", "starting", "from", "earliestBranchRevision", "and", "deletes", "the", "corresponding", "MD", "updates", ".", "All", "MDs", "from", "earliestBranchRevision", "onwards", "must", "have", "branch", "equal", "to", "the", "given", "one", "which", "must", "not", "be", "kbfsmd", ".", "NullBranchID", ".", "This", "means", "that", "if", "bid", "!", "=", "kbfsmd", ".", "PendingLocalSquashBranchID", "earliestBranchRevision", "must", "equal", "the", "earliest", "revision", "and", "if", "bid", "==", "kbfsmd", ".", "PendingLocalSquashBranchID", "earliestBranchRevision", "must", "equal", "one", "past", "the", "last", "local", "squash", "revision", ".", "If", "the", "branch", "is", "a", "pending", "local", "squash", "it", "preserves", "the", "MD", "updates", "corresponding", "to", "the", "prefix", "of", "existing", "local", "squashes", "so", "they", "can", "be", "re", "-", "used", "in", "the", "newly", "-", "resolved", "journal", "." ]

[ "func", "(", "j", "*", "mdJournal", ")", "clear", "(", "ctx", "context", ".", "Context", ",", "bid", "kbfsmd", ".", "BranchID", ")", "error", "{", "earliestBranchRevision", ",", "err", ":=", "j", ".", "j", ".", "readEarliestRevision", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "earliestBranchRevision", "!=", "kbfsmd", ".", "RevisionUninitialized", "&&", "bid", "==", "kbfsmd", ".", "PendingLocalSquashBranchID", "{", "latestRevision", ",", "err", ":=", "j", ".", "j", ".", "readLatestRevision", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", ";", "earliestBranchRevision", "<=", "latestRevision", ";", "earliestBranchRevision", "++", "{", "entry", ",", "err", ":=", "j", ".", "j", ".", "readJournalEntry", "(", "earliestBranchRevision", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "entry", ".", "IsLocalSquash", "{", "break", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "j", ".", "clearHelper", "(", "ctx", ",", "bid", ",", "earliestBranchRevision", ")", "\n", "}" ]

[ "clear", "removes", "all", "the", "journal", "entries", "and", "deletes", "the", "corresponding", "MD", "updates", ".", "If", "the", "branch", "is", "a", "pending", "local", "squash", "it", "preserves", "the", "MD", "updates", "corresponding", "to", "the", "prefix", "of", "existing", "local", "squashes", "so", "they", "can", "be", "re", "-", "used", "in", "the", "newly", "-", "resolved", "journal", "." ]

[ "func", "(", "e", "MDRevisionMismatch", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "e", ".", "Rev", ",", "e", ".", "Curr", ")", "\n", "}" ]

[ "Error", "implements", "the", "error", "interface", "for", "MDRevisionMismatch", "." ]

[ "func", "(", "e", "InvalidNonPrivateTLFOperation", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "opName", ",", "e", ".", "id", ",", "e", ".", "ver", ")", "\n", "}" ]

[ "Error", "implements", "the", "error", "interface", "for", "InvalidNonPrivateTLFOperation", "." ]

[ "func", "(", "e", "InvalidKeyGenerationError", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int", "(", "e", ".", "KeyGen", ")", ",", "e", ".", "TlfID", ")", "\n", "}" ]

[ "Error", "implements", "the", "error", "interface", "for", "InvalidKeyGenerationError", "." ]

[ "func", "(", "e", "NewKeyGenerationError", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "e", ".", "TlfID", ",", "e", ".", "KeyGen", ")", "\n", "}" ]

[ "Error", "implements", "the", "error", "interface", "for", "NewKeyGenerationError", "." ]

[ "func", "(", "e", "InvalidMetadataVersionError", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int", "(", "e", ".", "MetadataVer", ")", ",", "e", ".", "TlfID", ")", "\n", "}" ]

[ "Error", "implements", "the", "error", "interface", "for", "InvalidMetadataVersionError", "." ]

[ "func", "(", "e", "NewMetadataVersionError", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "Tlf", ",", "e", ".", "MetadataVer", ")", "\n", "}" ]

[ "Error", "implements", "the", "error", "interface", "for", "NewMetadataVersionError", "." ]

[ "func", "ProofUserAgent", "(", ")", "string", "{", "var", "os", "string", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "// Either ios or mac", "if", "isIOS", "{", "os", "=", "\"", "\"", "\n", "}", "else", "{", "os", "=", "\"", "\"", "\n", "}", "\n", "}", "else", "{", "os", "=", "runtime", ".", "GOOS", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "os", ",", "Version", ")", "\n", "}" ]

[ "Returns", "a", "simplified", "UserAgent", "that", "s", "used", "as", "the", "kb_ua", "GET", "param", "." ]

[ "func", "(", "i", "item", ")", "isDismissedAt", "(", "t", "time", ".", "Time", ")", "bool", "{", "if", "i", ".", "dismissedImmediate", "{", "return", "true", "\n", "}", "\n", "if", "i", ".", "dtime", "!=", "nil", "&&", "isBeforeOrSame", "(", "*", "i", ".", "dtime", ",", "t", ")", "{", "return", "true", "\n", "}", "\n", "if", "dt", ":=", "i", ".", "item", ".", "DTime", "(", ")", ";", "dt", "!=", "nil", "&&", "isBeforeOrSame", "(", "toTime", "(", "i", ".", "ctime", ",", "dt", ")", ",", "t", ")", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isDismissedAt", "returns", "true", "if", "item", "i", "is", "dismissed", "at", "time", "t", ".", "It", "will", "always", "return", "true", "if", "the", "dismissedImmediate", "flag", "was", "turned", "out", "." ]

[ "func", "(", "m", "loggedMsg", ")", "isDismissedAt", "(", "t", "time", ".", "Time", ")", "bool", "{", "return", "m", ".", "i", "!=", "nil", "&&", "m", ".", "i", ".", "isDismissedAt", "(", "t", ")", "\n", "}" ]

[ "isDismissedAt", "returns", "true", "if", "the", "log", "message", "has", "an", "associated", "item", "and", "that", "item", "was", "dismissed", "at", "time", "t", "." ]

[ "func", "(", "u", "*", "user", ")", "addItem", "(", "now", "time", ".", "Time", ",", "i", "gregor", ".", "Item", ")", "*", "item", "{", "msgID", ":=", "i", ".", "Metadata", "(", ")", ".", "MsgID", "(", ")", ".", "Bytes", "(", ")", "\n", "for", "_", ",", "it", ":=", "range", "u", ".", "items", "{", "if", "bytes", ".", "Equal", "(", "msgID", ",", "it", ".", "item", ".", "Metadata", "(", ")", ".", "MsgID", "(", ")", ".", "Bytes", "(", ")", ")", "{", "return", "it", "\n", "}", "\n", "}", "\n", "newItem", ":=", "&", "item", "{", "item", ":", "i", ",", "ctime", ":", "nowIfZero", "(", "now", ",", "i", ".", "Metadata", "(", ")", ".", "CTime", "(", ")", ")", "}", "\n", "if", "i", ".", "DTime", "(", ")", "!=", "nil", "{", "newItem", ".", "dtime", "=", "i", ".", "DTime", "(", ")", ".", "Time", "(", ")", "\n", "}", "\n", "u", ".", "items", "=", "append", "(", "u", ".", "items", ",", "newItem", ")", "\n", "return", "newItem", "\n", "}" ]

[ "addItem", "adds", "an", "item", "for", "this", "user" ]

[ "func", "(", "u", "*", "user", ")", "logMessage", "(", "t", "time", ".", "Time", ",", "m", "gregor", ".", "InBandMessage", ",", "i", "*", "item", ")", "{", "for", "_", ",", "l", ":=", "range", "u", ".", "log", "{", "if", "bytes", ".", "Equal", "(", "l", ".", "m", ".", "Metadata", "(", ")", ".", "MsgID", "(", ")", ".", "Bytes", "(", ")", ",", "m", ".", "Metadata", "(", ")", ".", "MsgID", "(", ")", ".", "Bytes", "(", ")", ")", "{", "return", "\n", "}", "\n", "}", "\n", "u", ".", "log", "=", "append", "(", "u", ".", "log", ",", "loggedMsg", "{", "m", ",", "t", ",", "i", "}", ")", "\n", "}" ]

[ "logMessage", "logs", "a", "message", "for", "this", "user", "and", "potentially", "associates", "an", "item" ]

[ "func", "(", "m", "*", "MemEngine", ")", "getUser", "(", "uid", "gregor", ".", "UID", ")", "*", "user", "{", "uidHex", ":=", "uidToString", "(", "uid", ")", "\n", "if", "u", ",", "ok", ":=", "m", ".", "users", "[", "uidHex", "]", ";", "ok", "{", "return", "u", "\n", "}", "\n", "u", ":=", "newUser", "(", "m", ".", "log", ")", "\n", "m", ".", "users", "[", "uidHex", "]", "=", "u", "\n", "return", "u", "\n", "}" ]

[ "getUser", "gets", "or", "makes", "a", "new", "user", "object", "for", "the", "given", "UID", "." ]

[ "func", "(", "f", "*", "jsonFileTransaction", ")", "Rollback", "(", ")", "error", "{", "f", ".", "f", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "f", ".", "f", ".", "which", ",", "f", ".", "f", ".", "filename", ")", "\n", "err", ":=", "f", ".", "f", ".", "Load", "(", "false", ")", "\n", "if", "!", "f", ".", "f", ".", "exists", "{", "// Before transaction there was no file, so set in-memory", "// wrapper to clean state as well.", "f", ".", "f", ".", "jw", "=", "jsonw", ".", "NewDictionary", "(", ")", "\n", "f", ".", "f", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "f", ".", "f", ".", "G", "(", ")", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "ErrToOk", "(", "err", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "Rollback", "reloads", "config", "from", "unchanged", "config", "file", "bringing", "its", "state", "back", "to", "from", "before", "the", "transaction", "changes", ".", "Note", "that", "it", "only", "works", "for", "changes", "that", "do", "not", "affect", "UserConfig", "which", "caches", "values", "and", "has", "to", "be", "reloaded", "manually", "." ]

[ "func", "NewCmdDevice", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Subcommands", ":", "[", "]", "cli", ".", "Command", "{", "NewCmdDeviceRemove", "(", "cl", ",", "g", ")", ",", "NewCmdDeviceList", "(", "cl", ",", "g", ")", ",", "NewCmdDeviceAdd", "(", "cl", ",", "g", ")", ",", "}", ",", "}", "\n", "}" ]

[ "NewCmdDevice", "creates", "the", "device", "command", "which", "is", "just", "a", "holder", "for", "subcommands", "." ]

[ "func", "NewPaperKeyGen", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "PaperKeyGenArg", ")", "*", "PaperKeyGen", "{", "return", "&", "PaperKeyGen", "{", "arg", ":", "arg", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewPaperKeyGen", "creates", "a", "PaperKeyGen", "engine", "." ]

[ "func", "newChatLocal", "(", "config", "Config", ")", "*", "chatLocal", "{", "return", "newChatLocalWithData", "(", "config", ",", "&", "chatLocalSharedData", "{", "convs", ":", "make", "(", "convLocalByTypeMap", ")", ",", "convsByID", ":", "make", "(", "convLocalByIDMap", ")", ",", "newChannelCBs", ":", "map", "[", "Config", "]", "newConvCB", "{", "config", ":", "nil", ",", "}", ",", "}", ")", "\n", "}" ]

[ "newChatLocal", "constructs", "a", "new", "local", "chat", "implementation", "." ]

[ "func", "(", "c", "TlfClient", ")", "CryptKeys", "(", "ctx", "context", ".", "Context", ",", "query", "TLFQuery", ")", "(", "res", "GetTLFCryptKeysRes", ",", "err", "error", ")", "{", "__arg", ":=", "CryptKeysArg", "{", "Query", ":", "query", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "CryptKeys", "returns", "TLF", "crypt", "keys", "from", "all", "generations", "." ]

[ "func", "debugServiceToString", "(", "service", "keybase1", ".", "ProofType", ")", "string", "{", "s", ",", "err", ":=", "serviceToString", "(", "service", ")", "\n", "if", "err", "!=", "nil", "{", "return", "string", "(", "service", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "debugServiceToString", "returns", "the", "name", "of", "a", "service", "or", "number", "string", "if", "it", "is", "invalid", "." ]

[ "func", "(", "s", "*", "Server", ")", "WalletInitLocal", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "mctx", ",", "fin", ",", "err", ":=", "s", ".", "Preamble", "(", "ctx", ",", "preambleArg", "{", "RPCName", ":", "\"", "\"", ",", "Err", ":", "&", "err", ",", "}", ")", "\n", "defer", "fin", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "stellar", ".", "CreateWallet", "(", "mctx", ")", "\n", "return", "err", "\n", "}" ]

[ "WalletInitLocal", "creates", "and", "posts", "an", "initial", "stellar", "bundle", "for", "a", "user", ".", "Only", "succeeds", "if", "they", "do", "not", "already", "have", "one", ".", "Safe", "to", "call", "even", "if", "the", "user", "has", "a", "bundle", "already", "." ]

[ "func", "getLocalCurrencyAndExchangeRate", "(", "mctx", "libkb", ".", "MetaContext", ",", "remoter", "remote", ".", "Remoter", ",", "account", "*", "stellar1", ".", "OwnAccountCLILocal", ",", "exchangeRates", "exchangeRateMap", ")", "error", "{", "displayCurrency", ",", "err", ":=", "stellar", ".", "GetAccountDisplayCurrency", "(", "mctx", ",", "account", ".", "AccountID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "rate", ",", "ok", ":=", "exchangeRates", "[", "displayCurrency", "]", "\n", "if", "!", "ok", "{", "var", "err", "error", "\n", "rate", ",", "err", "=", "remoter", ".", "ExchangeRate", "(", "mctx", ".", "Ctx", "(", ")", ",", "displayCurrency", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "exchangeRates", "[", "displayCurrency", "]", "=", "rate", "\n", "}", "\n", "account", ".", "ExchangeRate", "=", "&", "rate", "\n", "return", "nil", "\n", "}" ]

[ "getLocalCurrencyAndExchangeRate", "gets", "display", "currency", "setting", "for", "accountID", "and", "fetches", "exchange", "rate", "is", "set", ".", "Arguments", "account", "and", "exchangeRates", "may", "end", "up", "mutated", "." ]

[ "func", "(", "s", "*", "Server", ")", "checkDisplayAmount", "(", "ctx", "context", ".", "Context", ",", "arg", "stellar1", ".", "SendCLILocalArg", ")", "error", "{", "if", "arg", ".", "DisplayAmount", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "exchangeRate", ",", "err", ":=", "s", ".", "remoter", ".", "ExchangeRate", "(", "ctx", ",", "arg", ".", "DisplayCurrency", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "xlmAmount", ",", "err", ":=", "stellarnet", ".", "ConvertOutsideToXLM", "(", "arg", ".", "DisplayAmount", ",", "exchangeRate", ".", "Rate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "currentAmt", ",", "err", ":=", "stellarnet", ".", "ParseStellarAmount", "(", "xlmAmount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "argAmt", ",", "err", ":=", "stellarnet", ".", "ParseStellarAmount", "(", "arg", ".", "Amount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "percentageAmountChange", "(", "currentAmt", ",", "argAmt", ")", ">", "1.0", "{", "s", ".", "G", "(", ")", ".", "Log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "argAmt", ",", "currentAmt", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "check", "that", "the", "display", "amount", "is", "within", "1%", "of", "current", "exchange", "rates" ]

[ "func", "(", "c", "*", "ConnectionManager", ")", "AddConnection", "(", "xp", "rpc", ".", "Transporter", ",", "closeListener", "chan", "error", ")", "ConnectionID", "{", "c", ".", "Lock", "(", ")", "\n", "c", ".", "nxt", "++", "// increment first, since 0 is reserved", "\n", "id", ":=", "c", ".", "nxt", "\n", "c", ".", "lookup", "[", "id", "]", "=", "&", "rpcConnection", "{", "transporter", ":", "xp", "}", "\n", "c", ".", "Unlock", "(", ")", "\n\n", "if", "closeListener", "!=", "nil", "{", "go", "func", "(", ")", "{", "<-", "closeListener", "\n", "c", ".", "removeConnection", "(", "id", ")", "\n", "}", "(", ")", "\n", "}", "\n\n", "return", "id", "\n", "}" ]

[ "AddConnection", "adds", "a", "new", "connection", "to", "the", "table", "of", "Connection", "object", "with", "a", "related", "closeListener", ".", "We", "ll", "listen", "for", "a", "close", "on", "that", "channel", "and", "when", "one", "occurs", "we", "ll", "remove", "the", "connection", "from", "the", "pool", "." ]

[ "func", "(", "c", "*", "ConnectionManager", ")", "LookupConnection", "(", "i", "ConnectionID", ")", "rpc", ".", "Transporter", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "if", "conn", ":=", "c", ".", "lookup", "[", "i", "]", ";", "conn", "!=", "nil", "{", "return", "conn", ".", "transporter", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LookupConnection", "looks", "up", "a", "connection", "given", "a", "connectionID", "or", "returns", "nil", "if", "no", "such", "connection", "was", "found", "." ]

[ "func", "(", "c", "*", "ConnectionManager", ")", "WaitForClientType", "(", "clientType", "keybase1", ".", "ClientType", ",", "timeout", "time", ".", "Duration", ")", "bool", "{", "if", "c", ".", "hasClientType", "(", "clientType", ")", "{", "return", "true", "\n", "}", "\n", "ticker", ":=", "time", ".", "NewTicker", "(", "time", ".", "Second", ")", "\n", "deadline", ":=", "time", ".", "After", "(", "timeout", ")", "\n", "defer", "ticker", ".", "Stop", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "if", "c", ".", "hasClientType", "(", "clientType", ")", "{", "return", "true", "\n", "}", "\n", "case", "<-", "deadline", ":", "return", "false", "\n", "}", "\n", "}", "\n", "}" ]

[ "WaitForClientType", "returns", "true", "if", "client", "type", "is", "connected", "or", "waits", "until", "timeout", "for", "the", "connection" ]

[ "func", "(", "c", "*", "ConnectionManager", ")", "ApplyAll", "(", "f", "ApplyFn", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "c", ".", "lookup", "{", "if", "!", "f", "(", "k", ",", "v", ".", "transporter", ")", "{", "break", "\n", "}", "\n", "}", "\n", "}" ]

[ "ApplyAll", "applies", "the", "given", "function", "f", "to", "all", "connections", "in", "the", "table", ".", "If", "you", "re", "going", "to", "do", "something", "blocking", "please", "do", "it", "in", "a", "GoRoutine", "since", "we", "re", "holding", "the", "lock", "for", "all", "connections", "as", "we", "do", "this", "." ]

[ "func", "(", "c", "*", "ConnectionManager", ")", "ApplyAllDetails", "(", "f", "ApplyDetailsFn", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "c", ".", "lookup", "{", "status", ":=", "v", ".", "details", "\n", "var", "details", "*", "keybase1", ".", "ClientDetails", "\n", "if", "status", "!=", "nil", "{", "details", "=", "&", "status", ".", "Details", "\n", "}", "\n", "if", "!", "f", "(", "k", ",", "v", ".", "transporter", ",", "details", ")", "{", "break", "\n", "}", "\n", "}", "\n", "}" ]

[ "ApplyAllDetails", "applies", "the", "given", "function", "f", "to", "all", "connections", "in", "the", "table", ".", "If", "you", "re", "going", "to", "do", "something", "blocking", "please", "do", "it", "in", "a", "GoRoutine", "since", "we", "re", "holding", "the", "lock", "for", "all", "connections", "as", "we", "do", "this", "." ]

[ "func", "newBlockServerDisk", "(", "codec", "kbfscodec", ".", "Codec", ",", "log", "logger", ".", "Logger", ",", "dirPath", "string", ",", "shutdownFunc", "func", "(", "logger", ".", "Logger", ")", ")", "*", "BlockServerDisk", "{", "bserv", ":=", "&", "BlockServerDisk", "{", "codec", ",", "log", ",", "dirPath", ",", "shutdownFunc", ",", "sync", ".", "RWMutex", "{", "}", ",", "make", "(", "map", "[", "tlf", ".", "ID", "]", "*", "blockServerDiskTlfStorage", ")", ",", "}", "\n", "return", "bserv", "\n", "}" ]

[ "newBlockServerDisk", "constructs", "a", "new", "BlockServerDisk", "that", "stores", "its", "data", "in", "the", "given", "directory", "." ]

[ "func", "NewBlockServerDir", "(", "codec", "kbfscodec", ".", "Codec", ",", "log", "logger", ".", "Logger", ",", "dirPath", "string", ")", "*", "BlockServerDisk", "{", "return", "newBlockServerDisk", "(", "codec", ",", "log", ",", "dirPath", ",", "nil", ")", "\n", "}" ]

[ "NewBlockServerDir", "constructs", "a", "new", "BlockServerDisk", "that", "stores", "its", "data", "in", "the", "given", "directory", "." ]

[ "func", "NewBlockServerTempDir", "(", "codec", "kbfscodec", ".", "Codec", ",", "log", "logger", ".", "Logger", ")", "(", "*", "BlockServerDisk", ",", "error", ")", "{", "tempdir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "os", ".", "TempDir", "(", ")", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "newBlockServerDisk", "(", "codec", ",", "log", ",", "tempdir", ",", "func", "(", "log", "logger", ".", "Logger", ")", "{", "err", ":=", "ioutil", ".", "RemoveAll", "(", "tempdir", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warning", "(", "\"", "\"", ",", "tempdir", ",", "err", ")", "\n", "}", "\n", "}", ")", ",", "nil", "\n", "}" ]

[ "NewBlockServerTempDir", "constructs", "a", "new", "BlockServerDisk", "that", "stores", "its", "data", "in", "a", "temp", "directory", "which", "is", "cleaned", "up", "on", "shutdown", "." ]

[ "func", "(", "b", "*", "BlockServerDisk", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "_", "DiskBlockCacheType", ")", "(", "data", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ")", "\n", "tlfStorage", ",", "err", ":=", "b", ".", "getStorage", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n\n", "tlfStorage", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "tlfStorage", ".", "lock", ".", "RUnlock", "(", ")", "\n", "if", "tlfStorage", ".", "store", "==", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "errBlockServerDiskShutdown", "\n", "}", "\n\n", "data", ",", "keyServerHalf", ",", "err", ":=", "tlfStorage", ".", "store", ".", "getDataWithContext", "(", "ctx", ",", "id", ",", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "kbfscrypto", ".", "BlockCryptKeyServerHalf", "{", "}", ",", "err", "\n", "}", "\n", "return", "data", ",", "keyServerHalf", ",", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerDisk", ")", "Put", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ",", "buf", "[", "]", "byte", ",", "serverHalf", "kbfscrypto", ".", "BlockCryptKeyServerHalf", ",", "_", "DiskBlockCacheType", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ",", "len", "(", "buf", ")", ")", "\n\n", "if", "context", ".", "GetRefNonce", "(", ")", "!=", "kbfsblock", ".", "ZeroRefNonce", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "tlfStorage", ",", "err", ":=", "b", ".", "getStorage", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "tlfStorage", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "tlfStorage", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "tlfStorage", ".", "store", "==", "nil", "{", "return", "errBlockServerDiskShutdown", "\n", "}", "\n\n", "_", ",", "err", "=", "tlfStorage", ".", "store", ".", "put", "(", "ctx", ",", "true", ",", "id", ",", "context", ",", "buf", ",", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "tlfStorage", ".", "store", ".", "addReference", "(", "ctx", ",", "id", ",", "context", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerDisk", ")", "AddBlockReference", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "id", "kbfsblock", ".", "ID", ",", "context", "kbfsblock", ".", "Context", ")", "error", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "id", ",", "tlfID", ",", "context", ")", "\n", "tlfStorage", ",", "err", ":=", "b", ".", "getStorage", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "tlfStorage", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "tlfStorage", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "tlfStorage", ".", "store", "==", "nil", "{", "return", "errBlockServerDiskShutdown", "\n", "}", "\n\n", "hasRef", ",", "err", ":=", "tlfStorage", ".", "store", ".", "hasAnyRef", "(", "ctx", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "hasRef", "{", "return", "kbfsblock", ".", "ServerErrorBlockNonExistent", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "id", ")", "}", "\n", "}", "\n\n", "hasNonArchivedRef", ",", "err", ":=", "tlfStorage", ".", "store", ".", "hasNonArchivedRef", "(", "ctx", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "hasNonArchivedRef", "{", "return", "kbfsblock", ".", "ServerErrorBlockArchived", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "id", ")", "}", "\n", "}", "\n\n", "return", "tlfStorage", ".", "store", ".", "addReference", "(", "ctx", ",", "id", ",", "context", ",", "\"", "\"", ")", "\n", "}" ]

[ "AddBlockReference", "implements", "the", "BlockServer", "interface", "for", "BlockServerDisk", "." ]

[ "func", "(", "b", "*", "BlockServerDisk", ")", "RemoveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "liveCounts", "map", "[", "kbfsblock", ".", "ID", "]", "int", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ",", "contexts", ")", "\n", "tlfStorage", ",", "err", ":=", "b", ".", "getStorage", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "tlfStorage", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "tlfStorage", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "tlfStorage", ".", "store", "==", "nil", "{", "return", "nil", ",", "errBlockServerDiskShutdown", "\n", "}", "\n\n", "liveCounts", "=", "make", "(", "map", "[", "kbfsblock", ".", "ID", "]", "int", ")", "\n", "for", "id", ",", "idContexts", ":=", "range", "contexts", "{", "liveCount", ",", "err", ":=", "tlfStorage", ".", "store", ".", "removeReferences", "(", "ctx", ",", "id", ",", "idContexts", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "liveCounts", "[", "id", "]", "=", "liveCount", "\n\n", "if", "liveCount", "==", "0", "{", "err", ":=", "tlfStorage", ".", "store", ".", "remove", "(", "ctx", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "liveCounts", ",", "nil", "\n", "}" ]

[ "RemoveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerDisk", "." ]

[ "func", "(", "b", "*", "BlockServerDisk", ")", "ArchiveBlockReferences", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "contexts", "kbfsblock", ".", "ContextMap", ")", "(", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "func", "(", ")", "{", "err", "=", "translateToBlockServerError", "(", "err", ")", "\n", "}", "(", ")", "\n", "b", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "tlfID", ",", "contexts", ")", "\n", "tlfStorage", ",", "err", ":=", "b", ".", "getStorage", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "tlfStorage", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "tlfStorage", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "tlfStorage", ".", "store", "==", "nil", "{", "return", "errBlockServerDiskShutdown", "\n", "}", "\n\n", "for", "id", ",", "idContexts", ":=", "range", "contexts", "{", "for", "_", ",", "context", ":=", "range", "idContexts", "{", "hasContext", ",", "_", ",", "err", ":=", "tlfStorage", ".", "store", ".", "hasContext", "(", "ctx", ",", "id", ",", "context", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "hasContext", "{", "return", "kbfsblock", ".", "ServerErrorBlockNonExistent", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", "+", "\"", "\"", ",", "id", ",", "context", ")", ",", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "tlfStorage", ".", "store", ".", "archiveReferences", "(", "ctx", ",", "contexts", ",", "\"", "\"", ")", "\n", "}" ]

[ "ArchiveBlockReferences", "implements", "the", "BlockServer", "interface", "for", "BlockServerDisk", "." ]

[ "func", "(", "b", "*", "BlockServerDisk", ")", "IsUnflushed", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "_", "kbfsblock", ".", "ID", ")", "(", "bool", ",", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "tlfStorage", ",", "err", ":=", "b", ".", "getStorage", "(", "tlfID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "tlfStorage", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "tlfStorage", ".", "lock", ".", "RUnlock", "(", ")", "\n", "if", "tlfStorage", ".", "store", "==", "nil", "{", "return", "false", ",", "errBlockServerDiskShutdown", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerDisk", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "{", "tlfStorage", ":=", "func", "(", ")", "map", "[", "tlf", ".", "ID", "]", "*", "blockServerDiskTlfStorage", "{", "b", ".", "tlfStorageLock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "tlfStorageLock", ".", "Unlock", "(", ")", "\n", "// Make further accesses error out.", "tlfStorage", ":=", "b", ".", "tlfStorage", "\n", "b", ".", "tlfStorage", "=", "nil", "\n", "return", "tlfStorage", "\n", "}", "(", ")", "\n\n", "for", "_", ",", "s", ":=", "range", "tlfStorage", "{", "func", "(", ")", "{", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "store", "==", "nil", "{", "// Already shutdown.", "return", "\n", "}", "\n\n", "// Make further accesses error out.", "s", ".", "store", "=", "nil", "\n", "}", "(", ")", "\n", "}", "\n\n", "if", "b", ".", "shutdownFunc", "!=", "nil", "{", "b", ".", "shutdownFunc", "(", "b", ".", "log", ")", "\n", "}", "\n", "}" ]

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

[ "func", "(", "b", "*", "BlockServerDisk", ")", "GetUserQuotaInfo", "(", "ctx", "context", ".", "Context", ")", "(", "info", "*", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Return a dummy value here.", "return", "&", "kbfsblock", ".", "QuotaInfo", "{", "Limit", ":", "math", ".", "MaxInt64", "}", ",", "nil", "\n", "}" ]

[ "GetUserQuotaInfo", "implements", "the", "BlockServer", "interface", "for", "BlockServerDisk", "." ]

[ "func", "(", "b", "*", "BlockServerDisk", ")", "GetTeamQuotaInfo", "(", "ctx", "context", ".", "Context", ",", "_", "keybase1", ".", "TeamID", ")", "(", "info", "*", "kbfsblock", ".", "QuotaInfo", ",", "err", "error", ")", "{", "if", "err", ":=", "checkContext", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// TODO: check team membership and return error if not a reader?", "// Return a dummy value here.", "return", "&", "kbfsblock", ".", "QuotaInfo", "{", "Limit", ":", "math", ".", "MaxInt64", "}", ",", "nil", "\n", "}" ]

[ "GetTeamQuotaInfo", "implements", "the", "BlockServer", "interface", "for", "BlockServerDisk", "." ]

[ "func", "newLoginProvision", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "arg", "*", "loginProvisionArg", ")", "*", "loginProvision", "{", "return", "&", "loginProvision", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "arg", ":", "arg", ",", "}", "\n", "}" ]

[ "newLoginProvision", "creates", "a", "loginProvision", "engine", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "paper", "(", "m", "libkb", ".", "MetaContext", ",", "device", "*", "libkb", ".", "Device", ",", "keys", "*", "libkb", ".", "DeviceWithKeys", ")", "(", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// get the paper key from the user if we're in the interactive flow", "if", "keys", "==", "nil", "{", "expectedPrefix", ":=", "device", ".", "Description", "\n", "keys", ",", "err", "=", "e", ".", "getValidPaperKey", "(", "m", ",", "expectedPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "u", ":=", "e", ".", "arg", ".", "User", "\n", "uv", ":=", "u", ".", "ToUserVersion", "(", ")", "\n", "nn", ":=", "u", ".", "GetNormalizedName", "(", ")", "\n\n", "// Set the active device to be a special paper key active device, which keeps", "// a cached copy around for DeviceKeyGen, which requires it to be in memory.", "// It also will establish a NIST so that API calls can proceed on behalf of the user.", "m", "=", "m", ".", "WithProvisioningKeyActiveDevice", "(", "keys", ",", "uv", ")", "\n", "m", ".", "LoginContext", "(", ")", ".", "SetUsernameUserVersion", "(", "nn", ",", "uv", ")", "\n\n", "// need lksec to store device keys locally", "if", "err", ":=", "e", ".", "fetchLKS", "(", "m", ",", "keys", ".", "EncryptionKey", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "e", ".", "makeDeviceKeysWithSigner", "(", "m", ",", "keys", ".", "SigningKey", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// The DeviceWrap engine (called via makeDeviceKeysWithSigner) sets", "// the global ActiveDevice to be a valid device. So we're OK to remove", "// our temporary thread-local paperkey device installed just above.", "m", "=", "m", ".", "WithGlobalActiveDevice", "(", ")", "\n\n", "// Cache the paper keys globally now that we're logged in. Note we must call", "// this after the m.WithGlobalActiveDevice() above, since we want to cache", "// the paper key on the global and not thread-local active device.", "m", ".", "ActiveDevice", "(", ")", ".", "CacheProvisioningKey", "(", "m", ",", "keys", ")", "\n\n", "e", ".", "saveToSecretStore", "(", "m", ")", "\n", "return", "nil", "\n", "}" ]

[ "paper", "attempts", "to", "provision", "the", "device", "via", "a", "paper", "key", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "pgpProvision", "(", "m", "libkb", ".", "MetaContext", ")", "(", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "err", "=", "e", ".", "passphraseLogin", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// After obtaining login session, this will be called before the login state is released.", "// It tries to get the pgp key and uses it to provision new device keys for this device.", "signer", ",", "err", ":=", "e", ".", "syncedPGPKey", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "e", ".", "makeDeviceKeysWithSigner", "(", "m", ",", "signer", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "e", ".", "saveToSecretStore", "(", "m", ")", "\n", "return", "nil", "\n", "}" ]

[ "pgpProvision", "attempts", "to", "provision", "with", "a", "synced", "pgp", "key", ".", "It", "needs", "to", "get", "a", "session", "first", "to", "look", "for", "a", "synced", "pgp", "key", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "makeDeviceWrapArgs", "(", "m", "libkb", ".", "MetaContext", ")", "(", "*", "DeviceWrapArgs", ",", "error", ")", "{", "if", "err", ":=", "e", ".", "ensureLKSec", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "devname", ",", "err", ":=", "e", ".", "deviceName", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "e", ".", "devname", "=", "devname", "\n\n", "return", "&", "DeviceWrapArgs", "{", "Me", ":", "e", ".", "arg", ".", "User", ",", "DeviceName", ":", "e", ".", "devname", ",", "DeviceType", ":", "e", ".", "arg", ".", "DeviceType", ",", "Lks", ":", "e", ".", "lks", ",", "PerUserKeyring", ":", "e", ".", "perUserKeyring", ",", "}", ",", "nil", "\n", "}" ]

[ "makeDeviceWrapArgs", "creates", "a", "base", "set", "of", "args", "for", "DeviceWrap", ".", "It", "ensures", "that", "LKSec", "is", "created", ".", "It", "also", "gets", "a", "new", "device", "name", "for", "this", "device", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "ensureLKSec", "(", "m", "libkb", ".", "MetaContext", ")", "error", "{", "if", "e", ".", "lks", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "pps", ",", "err", ":=", "e", ".", "ppStream", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "e", ".", "lks", "=", "libkb", ".", "NewLKSec", "(", "pps", ",", "e", ".", "arg", ".", "User", ".", "GetUID", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "ensureLKSec", "ensures", "we", "have", "LKSec", "for", "saving", "device", "keys", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "ppStream", "(", "m", "libkb", ".", "MetaContext", ")", "(", "ret", "*", "libkb", ".", "PassphraseStream", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "if", "ret", "=", "m", ".", "PassphraseStream", "(", ")", ";", "ret", "!=", "nil", "{", "return", "ret", ",", "nil", "\n", "}", "\n", "if", "err", "=", "e", ".", "passphraseLogin", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "ret", "=", "m", ".", "PassphraseStream", "(", ")", ";", "ret", "!=", "nil", "{", "return", "ret", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "ppStream", "gets", "the", "passphrase", "stream", "either", "cached", "or", "via", "SecretUI", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "deviceName", "(", "m", "libkb", ".", "MetaContext", ")", "(", "string", ",", "error", ")", "{", "var", "names", "[", "]", "string", "\n", "upk", ",", "_", ",", "err", ":=", "m", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "LoadV2", "(", "libkb", ".", "NewLoadUserArgWithMetaContext", "(", "m", ")", ".", "WithUID", "(", "e", ".", "arg", ".", "User", ".", "GetUID", "(", ")", ")", ".", "WithPublicKeyOptional", "(", ")", ".", "WithForcePoll", "(", "true", ")", ".", "WithSelf", "(", "true", ")", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "else", "{", "names", "=", "upk", ".", "AllDeviceNames", "(", ")", "\n", "}", "\n\n", "// Fully non-interactive flow", "if", "e", ".", "arg", ".", "DeviceName", "!=", "\"", "\"", "{", "return", "e", ".", "automatedDeviceName", "(", "m", ",", "names", ",", "e", ".", "arg", ".", "DeviceName", ")", "\n", "}", "\n\n", "arg", ":=", "keybase1", ".", "PromptNewDeviceNameArg", "{", "ExistingDevices", ":", "names", ",", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "10", ";", "i", "++", "{", "devname", ",", "err", ":=", "m", ".", "UIs", "(", ")", ".", "ProvisionUI", ".", "PromptNewDeviceName", "(", "m", ".", "Ctx", "(", ")", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "!", "libkb", ".", "CheckDeviceName", ".", "F", "(", "devname", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "devname", ")", "\n", "arg", ".", "ErrorMessage", "=", "\"", "\"", "+", "libkb", ".", "CheckDeviceName", ".", "Hint", "\n", "continue", "\n", "}", "\n", "devname", "=", "libkb", ".", "CheckDeviceName", ".", "Transform", "(", "devname", ")", "\n", "var", "dupname", "string", "\n", "normalizedDevName", ":=", "libkb", ".", "CheckDeviceName", ".", "Normalize", "(", "devname", ")", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "if", "normalizedDevName", "==", "libkb", ".", "CheckDeviceName", ".", "Normalize", "(", "name", ")", "{", "dupname", "=", "name", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "dupname", "!=", "\"", "\"", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "devname", ",", "dupname", ")", "\n", "var", "dupnameErrMsg", "string", "\n", "// if we have a collision on the normalized values add some extra", "// info the error message so the user isn't confused why we", "// consider the names equal.", "if", "devname", "!=", "dupname", "{", "dupnameErrMsg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dupname", ")", "\n", "}", "\n", "arg", ".", "ErrorMessage", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "devname", ",", "dupnameErrMsg", ")", "\n", "continue", "\n", "}", "\n\n", "return", "devname", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "libkb", ".", "RetryExhaustedError", "{", "}", "\n", "}" ]

[ "deviceName", "gets", "a", "new", "device", "name", "from", "the", "user", "." ]

[ "func", "(", "e", "*", "loginProvision", ")", "makeDeviceKeys", "(", "m", "libkb", ".", "MetaContext", ",", "args", "*", "DeviceWrapArgs", ")", "error", "{", "eng", ":=", "NewDeviceWrap", "(", "m", ".", "G", "(", ")", ",", "args", ")", "\n", "if", "err", ":=", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Finish provisoning by calling SwitchConfigAndActiveDevice. we", "// can't undo that, so do not error out after that.", "if", "err", ":=", "eng", ".", "SwitchConfigAndActiveDevice", "(", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "e", ".", "signingKey", "=", "eng", ".", "SigningKey", "(", ")", "\n", "e", ".", "encryptionKey", "=", "eng", ".", "EncryptionKey", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "makeDeviceKeys", "uses", "DeviceWrap", "to", "generate", "device", "keys", "." ]