Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "(", "md", "*", "RootMetadata", ")", "SetRevision", "(", "revision", "kbfsmd", ".", "Revision", ")", "{", "md", ".", "bareMd", ".", "SetRevision", "(", "revision", ")", "\n", "}" ]

[ "SetRevision", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetWriters", "(", "writers", "[", "]", "keybase1", ".", "UserOrTeamID", ")", "{", "md", ".", "bareMd", ".", "SetWriters", "(", "writers", ")", "\n", "}" ]

[ "SetWriters", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetUnresolvedReaders", "(", "readers", "[", "]", "keybase1", ".", "SocialAssertion", ")", "{", "md", ".", "bareMd", ".", "SetUnresolvedReaders", "(", "readers", ")", "\n", "}" ]

[ "SetUnresolvedReaders", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetUnresolvedWriters", "(", "writers", "[", "]", "keybase1", ".", "SocialAssertion", ")", "{", "md", ".", "bareMd", ".", "SetUnresolvedWriters", "(", "writers", ")", "\n", "}" ]

[ "SetUnresolvedWriters", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetConflictInfo", "(", "ci", "*", "tlf", ".", "HandleExtension", ")", "{", "md", ".", "bareMd", ".", "SetConflictInfo", "(", "ci", ")", "\n", "}" ]

[ "SetConflictInfo", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetFinalizedInfo", "(", "fi", "*", "tlf", ".", "HandleExtension", ")", "{", "md", ".", "bareMd", ".", "SetFinalizedInfo", "(", "fi", ")", "\n", "}" ]

[ "SetFinalizedInfo", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetLastModifyingWriter", "(", "user", "keybase1", ".", "UID", ")", "{", "md", ".", "bareMd", ".", "SetLastModifyingWriter", "(", "user", ")", "\n", "}" ]

[ "SetLastModifyingWriter", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetLastModifyingUser", "(", "user", "keybase1", ".", "UID", ")", "{", "md", ".", "bareMd", ".", "SetLastModifyingUser", "(", "user", ")", "\n", "}" ]

[ "SetLastModifyingUser", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "SetTlfID", "(", "tlf", "tlf", ".", "ID", ")", "{", "md", ".", "bareMd", ".", "SetTlfID", "(", "tlf", ")", "\n", "}" ]

[ "SetTlfID", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "HasKeyForUser", "(", "user", "keybase1", ".", "UID", ")", "(", "bool", ",", "error", ")", "{", "writers", ",", "readers", ",", "err", ":=", "md", ".", "bareMd", ".", "GetUserDevicePublicKeys", "(", "md", ".", "extra", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "return", "len", "(", "writers", "[", "user", "]", ")", ">", "0", "||", "len", "(", "readers", "[", "user", "]", ")", ">", "0", ",", "nil", "\n", "}" ]

[ "HasKeyForUser", "wraps", "the", "respective", "method", "of", "the", "underlying", "BareRootMetadata", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "fakeInitialRekey", "(", ")", "{", "bh", ",", "err", ":=", "md", ".", "tlfHandle", ".", "ToBareHandle", "(", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "md", ".", "extra", "=", "kbfsmd", ".", "FakeInitialRekey", "(", "md", ".", "bareMd", ",", "bh", ",", "kbfscrypto", ".", "TLFPublicKey", "{", "}", ")", "\n", "}" ]

[ "fakeInitialRekey", "wraps", "the", "FakeInitialRekey", "test", "function", "for", "convenience", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "AddKeyGeneration", "(", "codec", "kbfscodec", ".", "Codec", ",", "wKeys", ",", "rKeys", "kbfsmd", ".", "UserDevicePublicKeys", ",", "ePubKey", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "ePrivKey", "kbfscrypto", ".", "TLFEphemeralPrivateKey", ",", "pubKey", "kbfscrypto", ".", "TLFPublicKey", ",", "privKey", "kbfscrypto", ".", "TLFPrivateKey", ",", "currCryptKey", ",", "nextCryptKey", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "serverHalves", "kbfsmd", ".", "UserDeviceKeyServerHalves", ",", "err", "error", ")", "{", "nextExtra", ",", "serverHalves", ",", "err", ":=", "md", ".", "bareMd", ".", "AddKeyGeneration", "(", "codec", ",", "md", ".", "extra", ",", "wKeys", ",", "rKeys", ",", "ePubKey", ",", "ePrivKey", ",", "pubKey", ",", "currCryptKey", ",", "nextCryptKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "md", ".", "extra", "=", "nextExtra", "\n", "md", ".", "data", ".", "TLFPrivateKey", "=", "privKey", "\n", "return", "serverHalves", ",", "nil", "\n", "}" ]

[ "AddKeyGeneration", "adds", "a", "new", "key", "generation", "to", "this", "revision", "of", "metadata", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "GetHistoricTLFCryptKey", "(", "codec", "kbfscodec", ".", "Codec", ",", "keyGen", "kbfsmd", ".", "KeyGen", ",", "currentKey", "kbfscrypto", ".", "TLFCryptKey", ")", "(", "kbfscrypto", ".", "TLFCryptKey", ",", "error", ")", "{", "return", "md", ".", "bareMd", ".", "GetHistoricTLFCryptKey", "(", "codec", ",", "keyGen", ",", "currentKey", ",", "md", ".", "extra", ")", "\n", "}" ]

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

[ "func", "(", "md", "*", "RootMetadata", ")", "IsWriter", "(", "ctx", "context", ".", "Context", ",", "checker", "kbfsmd", ".", "TeamMembershipChecker", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "uid", "keybase1", ".", "UID", ",", "verifyingKey", "kbfscrypto", ".", "VerifyingKey", ")", "(", "bool", ",", "error", ")", "{", "h", ":=", "md", ".", "GetTlfHandle", "(", ")", "\n", "return", "IsWriterFromHandle", "(", "ctx", ",", "h", ",", "checker", ",", "osg", ",", "uid", ",", "verifyingKey", ")", "\n", "}" ]

[ "IsWriter", "checks", "that", "the", "given", "user", "is", "a", "valid", "writer", "of", "the", "TLF", "right", "now", ".", "Implements", "the", "KeyMetadata", "interface", "for", "RootMetadata", "." ]

[ "func", "(", "md", "*", "RootMetadata", ")", "IsReader", "(", "ctx", "context", ".", "Context", ",", "checker", "kbfsmd", ".", "TeamMembershipChecker", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "uid", "keybase1", ".", "UID", ")", "(", "bool", ",", "error", ")", "{", "h", ":=", "md", ".", "GetTlfHandle", "(", ")", "\n", "return", "isReaderFromHandle", "(", "ctx", ",", "h", ",", "checker", ",", "osg", ",", "uid", ")", "\n", "}" ]

[ "IsReader", "checks", "that", "the", "given", "user", "is", "a", "valid", "reader", "of", "the", "TLF", "right", "now", "." ]

[ "func", "(", "md", "ReadOnlyRootMetadata", ")", "CheckValidSuccessor", "(", "currID", "kbfsmd", ".", "ID", ",", "nextMd", "ReadOnlyRootMetadata", ")", "error", "{", "return", "md", ".", "bareMd", ".", "CheckValidSuccessor", "(", "currID", ",", "nextMd", ".", "bareMd", ")", "\n", "}" ]

[ "CheckValidSuccessor", "makes", "sure", "the", "given", "ReadOnlyRootMetadata", "is", "a", "valid", "successor", "to", "the", "current", "one", "and", "returns", "an", "error", "otherwise", "." ]

[ "func", "MakeImmutableRootMetadata", "(", "rmd", "*", "RootMetadata", ",", "writerVerifyingKey", "kbfscrypto", ".", "VerifyingKey", ",", "mdID", "kbfsmd", ".", "ID", ",", "localTimestamp", "time", ".", "Time", ",", "putToServer", "bool", ")", "ImmutableRootMetadata", "{", "if", "writerVerifyingKey", "==", "(", "kbfscrypto", ".", "VerifyingKey", "{", "}", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "mdID", "==", "(", "kbfsmd", ".", "ID", "{", "}", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "localTimestamp", ".", "IsZero", "(", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "bareMDV2", ",", "ok", ":=", "rmd", ".", "bareMd", ".", "(", "*", "kbfsmd", ".", "RootMetadataV2", ")", ";", "ok", "{", "writerSig", ":=", "bareMDV2", ".", "WriterMetadataSigInfo", "\n", "if", "writerSig", ".", "IsNil", "(", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "writerSig", ".", "VerifyingKey", "!=", "writerVerifyingKey", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "writerSig", ".", "VerifyingKey", ",", "writerVerifyingKey", ")", ")", "\n", "}", "\n", "}", "\n", "return", "ImmutableRootMetadata", "{", "rmd", ".", "ReadOnly", "(", ")", ",", "mdID", ",", "writerVerifyingKey", ",", "localTimestamp", ",", "putToServer", "}", "\n", "}" ]

[ "MakeImmutableRootMetadata", "makes", "a", "new", "ImmutableRootMetadata", "from", "the", "given", "RMD", "and", "its", "corresponding", "MdID", "." ]

[ "func", "(", "f", "*", "ReclaimQuotaFile", ")", "WriteFile", "(", "ctx", "context", ".", "Context", ",", "fi", "*", "dokan", ".", "FileInfo", ",", "bs", "[", "]", "byte", ",", "offset", "int64", ")", "(", "n", "int", ",", "err", "error", ")", "{", "f", ".", "folder", ".", "fs", ".", "logEnter", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "f", ".", "folder", ".", "reportErr", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "err", ")", "}", "(", ")", "\n", "if", "len", "(", "bs", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n", "err", "=", "libkbfs", ".", "ForceQuotaReclamationForTesting", "(", "f", ".", "folder", ".", "fs", ".", "config", ",", "f", ".", "folder", ".", "getFolderBranch", "(", ")", ")", "\n", "return", "len", "(", "bs", ")", ",", "err", "\n", "}" ]

[ "WriteFile", "implements", "writes", "for", "dokan", ".", "Note", "a", "write", "triggers", "quota", "reclamation", "but", "does", "not", "wait", "for", "it", "to", "finish", ".", "If", "you", "want", "to", "wait", "write", "to", "SyncFromServerFileName", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "findPayload", "(", "tag", "txPayloadTag", ",", "forUID", "keybase1", ".", "UID", ")", "interface", "{", "}", "{", "minSeqno", ":=", "0", "\n", "hasUID", ":=", "!", "forUID", ".", "IsNil", "(", ")", "\n", "if", "hasUID", "{", "minSeqno", "=", "tx", ".", "lastChangeForUID", "[", "forUID", "]", "\n", "}", "\n\n", "for", "i", ",", "v", ":=", "range", "tx", ".", "payloads", "{", "if", "i", ">=", "minSeqno", "&&", "v", ".", "Tag", "==", "tag", "{", "if", "hasUID", "&&", "i", ">", "minSeqno", "{", "tx", ".", "lastChangeForUID", "[", "forUID", "]", "=", "i", "\n", "}", "\n", "return", "v", ".", "Val", "\n", "}", "\n", "}", "\n\n", "if", "hasUID", "{", "tx", ".", "lastChangeForUID", "[", "forUID", "]", "=", "len", "(", "tx", ".", "payloads", ")", "\n", "}", "\n", "ret", ":=", "txPayload", "{", "Tag", ":", "tag", ",", "}", "\n", "switch", "tag", "{", "case", "txPayloadTagCryptomembers", ":", "ret", ".", "Val", "=", "&", "keybase1", ".", "TeamChangeReq", "{", "}", "\n", "case", "txPayloadTagInviteKeybase", ",", "txPayloadTagInviteSocial", ":", "ret", ".", "Val", "=", "&", "SCTeamInvites", "{", "}", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "tag", ")", ")", "\n", "}", "\n", "tx", ".", "payloads", "=", "append", "(", "tx", ".", "payloads", ",", "ret", ")", "\n", "return", "ret", ".", "Val", "\n", "}" ]

[ "Internal", "AddMemberTx", "methods", ".", "They", "should", "not", "be", "used", "by", "consumers", "of", "AddMemberTx", "API", ".", "Users", "of", "this", "API", "should", "avoid", "lowercase", "methods", "and", "fields", "at", "all", "cost", "even", "from", "same", "package", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "removeMember", "(", "uv", "keybase1", ".", "UserVersion", ")", "{", "// Precondition: UV is a cryptomember.", "payload", ":=", "tx", ".", "changeMembershipPayload", "(", "uv", ".", "Uid", ")", "\n", "payload", ".", "None", "=", "append", "(", "payload", ".", "None", ",", "uv", ")", "\n", "}" ]

[ "Methods", "modifying", "payloads", "are", "supposed", "to", "always", "succeed", "given", "the", "preconditions", "are", "satisfied", ".", "If", "not", "the", "usual", "result", "is", "either", "a", "no", "-", "op", "or", "an", "invalid", "transaction", "that", "is", "rejected", "by", "team", "player", "pre", "-", "check", "or", "by", "the", "server", ".", "Public", "methods", "should", "make", "sure", "that", "internal", "methods", "are", "always", "called", "with", "these", "preconditions", "satisfied", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "createKeybaseInvite", "(", "uv", "keybase1", ".", "UserVersion", ",", "role", "keybase1", ".", "TeamRole", ")", "{", "// Preconditions: UV is a PUKless user, and not already in the", "// team, role is valid enum value and not NONE or OWNER.", "tx", ".", "createInvite", "(", "\"", "\"", ",", "uv", ".", "TeamInviteName", "(", ")", ",", "role", ",", "uv", ".", "Uid", ")", "\n", "}" ]

[ "createKeybaseInvite", "queues", "Keybase", "-", "type", "invite", "for", "given", "UV", "and", "role", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "createInvite", "(", "typ", "string", ",", "name", "keybase1", ".", "TeamInviteName", ",", "role", "keybase1", ".", "TeamRole", ",", "uid", "keybase1", ".", "UID", ")", "{", "var", "payload", "*", "SCTeamInvites", "\n", "if", "typ", "==", "\"", "\"", "{", "payload", "=", "tx", ".", "inviteKeybasePayload", "(", "uid", ")", "\n", "}", "else", "{", "payload", "=", "tx", ".", "inviteSocialPayload", "(", "uid", ")", "\n", "}", "\n\n", "invite", ":=", "SCTeamInvite", "{", "Type", ":", "typ", ",", "Name", ":", "name", ",", "ID", ":", "NewInviteID", "(", ")", ",", "}", "\n\n", "switch", "role", "{", "case", "keybase1", ".", "TeamRole_READER", ":", "payload", ".", "Readers", "=", "appendToInviteList", "(", "invite", ",", "payload", ".", "Readers", ")", "\n", "case", "keybase1", ".", "TeamRole_WRITER", ":", "payload", ".", "Writers", "=", "appendToInviteList", "(", "invite", ",", "payload", ".", "Writers", ")", "\n", "case", "keybase1", ".", "TeamRole_ADMIN", ":", "payload", ".", "Admins", "=", "appendToInviteList", "(", "invite", ",", "payload", ".", "Admins", ")", "\n", "case", "keybase1", ".", "TeamRole_OWNER", ":", "payload", ".", "Owners", "=", "appendToInviteList", "(", "invite", ",", "payload", ".", "Owners", ")", "\n", "}", "\n", "}" ]

[ "createInvite", "queues", "an", "invite", "for", "invite", "name", "with", "role", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "sweepCryptoMembers", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "exceptAdminsRemovingOwners", "bool", ")", "{", "team", ":=", "tx", ".", "team", "\n", "var", "myRole", "keybase1", ".", "TeamRole", "\n", "if", "exceptAdminsRemovingOwners", "{", "var", "err", "error", "\n", "myRole", ",", "err", "=", "tx", ".", "team", ".", "myRole", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "myRole", "=", "keybase1", ".", "TeamRole_NONE", "\n", "}", "\n", "}", "\n", "for", "chainUv", ":=", "range", "team", ".", "chain", "(", ")", ".", "inner", ".", "UserLog", "{", "chainRole", ":=", "team", ".", "chain", "(", ")", ".", "getUserRole", "(", "chainUv", ")", "\n", "if", "chainUv", ".", "Uid", ".", "Equal", "(", "uid", ")", "&&", "chainRole", "!=", "keybase1", ".", "TeamRole_NONE", "{", "if", "exceptAdminsRemovingOwners", "&&", "myRole", "==", "keybase1", ".", "TeamRole_ADMIN", "&&", "chainRole", "==", "keybase1", ".", "TeamRole_OWNER", "{", "// Skip if we're an admin and they're an owner.", "continue", "\n", "}", "\n", "tx", ".", "removeMember", "(", "chainUv", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "sweepCryptoMembers", "will", "queue", "removes", "for", "all", "cryptomembers", "with", "given", "UID", ".", "exceptAdminsRemovingOwners", "-", "But", "don", "t", "try", "to", "remove", "owners", "if", "we", "are", "admin", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "sweepCryptoMembersOlderThan", "(", "uv", "keybase1", ".", "UserVersion", ")", "{", "team", ":=", "tx", ".", "team", "\n", "for", "chainUv", ":=", "range", "team", ".", "chain", "(", ")", ".", "inner", ".", "UserLog", "{", "if", "chainUv", ".", "Uid", ".", "Equal", "(", "uv", ".", "Uid", ")", "&&", "chainUv", ".", "EldestSeqno", "<", "uv", ".", "EldestSeqno", "&&", "team", ".", "chain", "(", ")", ".", "getUserRole", "(", "chainUv", ")", "!=", "keybase1", ".", "TeamRole_NONE", "{", "tx", ".", "removeMember", "(", "chainUv", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "sweepCryptoMembersOlderThan", "will", "queue", "removes", "for", "all", "cryptomembers", "with", "same", "UID", "as", "given", "and", "EldestSeqno", "lower", "than", "in", "given", "UV", "." ]

[ "func", "(", "tx", "*", "AddMemberTx", ")", "AddMemberByUsername", "(", "ctx", "context", ".", "Context", ",", "username", "string", ",", "role", "keybase1", ".", "TeamRole", ")", "(", "err", "error", ")", "{", "team", ":=", "tx", ".", "team", "\n", "g", ":=", "team", ".", "G", "(", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "g", ")", "\n\n", "defer", "m", ".", "Trace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "username", ",", "role", ",", "team", ".", "Name", "(", ")", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "upak", ",", "err", ":=", "engine", ".", "ResolveAndCheck", "(", "m", ",", "username", ",", "true", "/* useTracking */", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "_", ",", "err", "=", "tx", ".", "addMemberByUPKV2", "(", "ctx", ",", "upak", ",", "role", ")", "\n", "return", "err", "\n", "}" ]

[ "AddMemberByUsername", "will", "add", "member", "by", "username", "and", "role", ".", "It", "checks", "if", "given", "username", "can", "become", "crypto", "member", "or", "a", "PUKless", "member", ".", "It", "will", "also", "clean", "up", "old", "invites", "and", "memberships", "if", "necessary", "." ]

[ "func", "newNonce24", "(", ")", "(", "*", "nonce24", ",", "error", ")", "{", "prefix", ",", "err", ":=", "libkb", ".", "RandBytes", "(", "20", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "nonce24", "{", "prefix", ":", "prefix", "}", ",", "nil", "\n", "}" ]

[ "newNonce24", "creates", "a", "nonce", "with", "a", "random", "20", "byte", "prefix", "and", "a", "counter", "starting", "at", "0", "." ]

[ "func", "newNonce24SkipZero", "(", ")", "(", "*", "nonce24", ",", "error", ")", "{", "n", ",", "err", ":=", "newNonce24", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "n", ".", "counter", "=", "1", "\n", "return", "n", ",", "nil", "\n", "}" ]

[ "newNonce24", "creates", "a", "nonce", "with", "a", "random", "20", "byte", "prefix", "and", "a", "counter", "starting", "at", "1", "." ]

[ "func", "(", "n", "*", "nonce24", ")", "Nonce", "(", ")", "(", "[", "24", "]", "byte", ",", "uint32", ")", "{", "var", "nonce", "[", "24", "]", "byte", "\n", "copy", "(", "nonce", "[", ":", "20", "]", ",", "n", ".", "prefix", ")", "\n", "copy", "(", "nonce", "[", "20", ":", "24", "]", ",", "n", ".", "counterBytes", "(", ")", ")", "\n", "counter", ":=", "n", ".", "counter", "\n", "n", ".", "counter", "++", "\n", "return", "nonce", ",", "counter", "\n", "}" ]

[ "Nonce", "gets", "the", "24", "byte", "nonce", "prefix", "+", "counter", "and", "increments", "the", "counter", "so", "that", "the", "nonce", "isn", "t", "reused", "." ]

[ "func", "NewFileInfoFile", "(", "fs", "*", "FS", ",", "dir", "libkbfs", ".", "Node", ",", "name", "string", ")", "*", "SpecialReadFile", "{", "return", "&", "SpecialReadFile", "{", "read", ":", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "libfs", ".", "GetFileInfo", "(", "ctx", ",", "fs", ".", "config", ",", "dir", ",", "name", ")", "\n", "}", ",", "fs", ":", "fs", ",", "}", "\n", "}" ]

[ "NewFileInfoFile", "returns", "a", "special", "file", "that", "contains", "a", "text", "representation", "of", "a", "file", "s", "KBFS", "metadata", "." ]

[ "func", "NewKeybaseServiceBase", "(", "config", "Config", ",", "kbCtx", "Context", ",", "log", "logger", ".", "Logger", ")", "*", "KeybaseServiceBase", "{", "k", ":=", "KeybaseServiceBase", "{", "config", ":", "config", ",", "context", ":", "kbCtx", ",", "log", ":", "log", ",", "userCache", ":", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "idutil", ".", "UserInfo", ")", ",", "userCacheUnverifiedKeys", ":", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "[", "]", "keybase1", ".", "PublicKey", ")", ",", "teamCache", ":", "make", "(", "map", "[", "keybase1", ".", "TeamID", "]", "idutil", ".", "TeamInfo", ")", ",", "}", "\n", "if", "config", "!=", "nil", "{", "k", ".", "merkleRoot", "=", "NewEventuallyConsistentMerkleRoot", "(", "config", ",", "&", "keybaseServiceMerkleGetter", "{", "&", "k", "}", ")", "\n", "}", "\n", "return", "&", "k", "\n", "}" ]

[ "NewKeybaseServiceBase", "makes", "a", "new", "KeybaseService", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FillClients", "(", "identifyClient", "keybase1", ".", "IdentifyInterface", ",", "userClient", "keybase1", ".", "UserInterface", ",", "teamsClient", "keybase1", ".", "TeamsInterface", ",", "merkleClient", "keybase1", ".", "MerkleInterface", ",", "sessionClient", "keybase1", ".", "SessionInterface", ",", "favoriteClient", "keybase1", ".", "FavoriteInterface", ",", "kbfsClient", "keybase1", ".", "KbfsInterface", ",", "kbfsMountClient", "keybase1", ".", "KbfsMountInterface", ",", "gitClient", "keybase1", ".", "GitInterface", ")", "{", "k", ".", "identifyClient", "=", "identifyClient", "\n", "k", ".", "userClient", "=", "userClient", "\n", "k", ".", "teamsClient", "=", "teamsClient", "\n", "k", ".", "merkleClient", "=", "merkleClient", "\n", "k", ".", "sessionClient", "=", "sessionClient", "\n", "k", ".", "favoriteClient", "=", "favoriteClient", "\n", "k", ".", "kbfsClient", "=", "kbfsClient", "\n", "k", ".", "kbfsMountClient", "=", "kbfsMountClient", "\n", "k", ".", "gitClient", "=", "gitClient", "\n", "}" ]

[ "FillClients", "sets", "the", "client", "protocol", "implementations", "needed", "for", "a", "KeybaseService", "." ]

[ "func", "updateKIDNamesFromParents", "(", "kidNames", "map", "[", "keybase1", ".", "KID", "]", "string", ",", "parents", "map", "[", "keybase1", ".", "KID", "]", "keybase1", ".", "KID", ")", "{", "for", "kid", ",", "parent", ":=", "range", "parents", "{", "if", "_", ",", "ok", ":=", "kidNames", "[", "kid", "]", ";", "ok", "{", "continue", "\n", "}", "\n", "if", "parentName", ",", "ok", ":=", "kidNames", "[", "parent", "]", ";", "ok", "{", "kidNames", "[", "kid", "]", "=", "parentName", "\n", "}", "\n", "}", "\n", "}" ]

[ "updateKIDNamesFromParents", "sets", "the", "name", "of", "each", "KID", "without", "a", "name", "that", "has", "a", "a", "parent", "with", "a", "name", "to", "that", "parent", "s", "name", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "ClearCaches", "(", "ctx", "context", ".", "Context", ")", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "k", ".", "setCachedCurrentSession", "(", "idutil", ".", "SessionInfo", "{", "}", ")", "\n", "func", "(", ")", "{", "k", ".", "userCacheLock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "userCacheLock", ".", "Unlock", "(", ")", "\n", "k", ".", "userCache", "=", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "idutil", ".", "UserInfo", ")", "\n", "k", ".", "userCacheUnverifiedKeys", "=", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "[", "]", "keybase1", ".", "PublicKey", ")", "\n", "}", "(", ")", "\n", "k", ".", "teamCacheLock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "teamCacheLock", ".", "Unlock", "(", ")", "\n", "k", ".", "teamCache", "=", "make", "(", "map", "[", "keybase1", ".", "TeamID", "]", "idutil", ".", "TeamInfo", ")", "\n", "}" ]

[ "ClearCaches", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "LoggedIn", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "name", ")", "\n", "// Since we don't have the whole session, just clear the cache and", "// repopulate it. The `CurrentSession` call executes the \"logged", "// in\" flow.", "k", ".", "setCachedCurrentSession", "(", "idutil", ".", "SessionInfo", "{", "}", ")", "\n", "const", "sessionID", "=", "0", "\n", "_", ",", "err", ":=", "k", ".", "CurrentSession", "(", "ctx", ",", "sessionID", ")", "\n", "if", "err", "!=", "nil", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "name", ",", "err", ")", "\n", "if", "k", ".", "config", "!=", "nil", "{", "serviceLoggedOut", "(", "ctx", ",", "k", ".", "config", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "LoggedIn", "implements", "keybase1", ".", "NotifySessionInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "LoggedOut", "(", "ctx", "context", ".", "Context", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "k", ".", "setCachedCurrentSession", "(", "idutil", ".", "SessionInfo", "{", "}", ")", "\n", "if", "k", ".", "config", "!=", "nil", "{", "serviceLoggedOut", "(", "ctx", ",", "k", ".", "config", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LoggedOut", "implements", "keybase1", ".", "NotifySessionInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "KeyfamilyChanged", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "uid", ")", "\n", "k", ".", "setCachedUserInfo", "(", "uid", ",", "idutil", ".", "UserInfo", "{", "}", ")", "\n", "k", ".", "clearCachedUnverifiedKeys", "(", "uid", ")", "\n\n", "if", "k", ".", "getCachedCurrentSession", "(", ")", ".", "UID", "==", "uid", "{", "mdServer", ":=", "k", ".", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "!=", "nil", "{", "// Ignore any errors for now, we don't want to block this", "// notification and it's not worth spawning a goroutine for.", "mdServer", ".", "CheckForRekeys", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "KeyfamilyChanged", "implements", "keybase1", ".", "NotifyKeyfamilyInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "ReachabilityChanged", "(", "ctx", "context", ".", "Context", ",", "reachability", "keybase1", ".", "Reachability", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "reachability", ")", "\n", "if", "reachability", ".", "Reachable", "==", "keybase1", ".", "Reachable_YES", "{", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "PushConnectionStatusChange", "(", "GregorServiceName", ",", "nil", ")", "\n", "}", "else", "{", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "PushConnectionStatusChange", "(", "GregorServiceName", ",", "errDisconnected", "{", "}", ")", "\n", "}", "\n", "mdServer", ":=", "k", ".", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "!=", "nil", "{", "mdServer", ".", "CheckReachability", "(", "ctx", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ReachabilityChanged", "implements", "keybase1", ".", "ReachabiltyInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "StartReachability", "(", "ctx", "context", ".", "Context", ")", "(", "res", "keybase1", ".", "Reachability", ",", "err", "error", ")", "{", "return", "k", ".", "CheckReachability", "(", "ctx", ")", "\n", "}" ]

[ "StartReachability", "implements", "keybase1", ".", "ReachabilityInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "CheckReachability", "(", "ctx", "context", ".", "Context", ")", "(", "res", "keybase1", ".", "Reachability", ",", "err", "error", ")", "{", "res", ".", "Reachable", "=", "keybase1", ".", "Reachable_NO", "\n", "mdServer", ":=", "k", ".", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "!=", "nil", "&&", "mdServer", ".", "IsConnected", "(", ")", "{", "res", ".", "Reachable", "=", "keybase1", ".", "Reachable_YES", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "CheckReachability", "implements", "keybase1", ".", "ReachabilityInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "PaperKeyCached", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "PaperKeyCachedArg", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Uid", ")", "\n\n", "if", "k", ".", "getCachedCurrentSession", "(", ")", ".", "UID", "==", "arg", ".", "Uid", "{", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "KickoffAllOutstandingRekeys", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// Ignore and log errors here. For now the only way it could error", "// is when the method is called on a folderBranchOps which is a", "// developer mistake and not recoverable from code.", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "// Ignore any errors for now, we don't want to block this", "// notification and it's not worth spawning a goroutine for.", "mdServer", ":=", "k", ".", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "!=", "nil", "{", "mdServer", ".", "CheckForRekeys", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PaperKeyCached", "implements", "keybase1", ".", "NotifyPaperKeyInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "ClientOutOfDate", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "ClientOutOfDateArg", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ")", "\n", "return", "nil", "\n", "}" ]

[ "ClientOutOfDate", "implements", "keybase1", ".", "NotifySessionInterface", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "RootAuditError", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "RootAuditErrorArg", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "arg", ".", "Message", ")", "\n", "return", "nil", "\n", "}" ]

[ "RootAuditError", "implements", "keybase1", ".", "NotifyAuditInterface", "." ]

[ "func", "ConvertIdentifyError", "(", "assertion", "string", ",", "err", "error", ")", "error", "{", "switch", "err", ".", "(", "type", ")", "{", "case", "libkb", ".", "NotFoundError", ":", "return", "idutil", ".", "NoSuchUserError", "{", "Input", ":", "assertion", "}", "\n", "case", "libkb", ".", "ResolutionError", ":", "return", "idutil", ".", "NoSuchUserError", "{", "Input", ":", "assertion", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "ConvertIdentifyError", "converts", "a", "errors", "during", "identify", "into", "KBFS", "errors" ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "Resolve", "(", "ctx", "context", ".", "Context", ",", "assertion", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "kbname", ".", "NormalizedUsername", ",", "keybase1", ".", "UserOrTeamID", ",", "error", ")", "{", "res", ",", "err", ":=", "k", ".", "identifyClient", ".", "Resolve3", "(", "ctx", ",", "keybase1", ".", "Resolve3Arg", "{", "Assertion", ":", "assertion", ",", "Oa", ":", "offline", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "ConvertIdentifyError", "(", "assertion", ",", "err", ")", "\n", "}", "\n", "return", "kbname", ".", "NewNormalizedUsername", "(", "res", ".", "Name", ")", ",", "res", ".", "Id", ",", "nil", "\n", "}" ]

[ "Resolve", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "Identify", "(", "ctx", "context", ".", "Context", ",", "assertion", ",", "reason", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "kbname", ".", "NormalizedUsername", ",", "keybase1", ".", "UserOrTeamID", ",", "error", ")", "{", "// setting UseDelegateUI to true here will cause daemon to use", "// registered identify ui providers instead of terminal if any", "// are available. If not, then it will use the terminal UI.", "arg", ":=", "keybase1", ".", "IdentifyLiteArg", "{", "Assertion", ":", "assertion", ",", "UseDelegateUI", ":", "true", ",", "Reason", ":", "keybase1", ".", "IdentifyReason", "{", "Reason", ":", "reason", "}", ",", "// No need to go back and forth with the UI until the service", "// knows for sure there's a need for a dialogue.", "CanSuppressUI", ":", "true", ",", "Oa", ":", "offline", ",", "}", "\n\n", "ei", ":=", "tlfhandle", ".", "GetExtendedIdentify", "(", "ctx", ")", "\n", "arg", ".", "IdentifyBehavior", "=", "ei", ".", "Behavior", "\n\n", "res", ",", "err", ":=", "k", ".", "identifyClient", ".", "IdentifyLite", "(", "ctx", ",", "arg", ")", "\n", "// IdentifyLite still returns keybase1.UserPlusKeys data (sans", "// keys), even if it gives a NoSigChainError or a UserDeletedError,", "// and in KBFS it's fine if the user doesn't have a full sigchain", "// (e.g., it's just like the sharing before signup case, except", "// the user already has a UID). Both types of users are based", "// entirely on server trust anyway.", "switch", "err", ".", "(", "type", ")", "{", "case", "nil", ":", "case", "libkb", ".", "NoSigChainError", ",", "libkb", ".", "UserDeletedError", ":", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ",", "res", ".", "Ul", ".", "Name", ",", "err", ")", "\n", "ei", ".", "OnError", "(", "ctx", ")", "\n", "default", ":", "// If the caller is waiting for breaks, let them know we got an error.", "ei", ".", "OnError", "(", "ctx", ")", "\n", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "ConvertIdentifyError", "(", "assertion", ",", "err", ")", "\n", "}", "\n\n", "// This is required for every identify call. The userBreak", "// function will take care of checking if res.TrackBreaks is nil", "// or not.", "name", ":=", "kbname", ".", "NormalizedUsername", "(", "res", ".", "Ul", ".", "Name", ")", "\n", "if", "res", ".", "Ul", ".", "Id", ".", "IsUser", "(", ")", "{", "asUser", ",", "err", ":=", "res", ".", "Ul", ".", "Id", ".", "AsUser", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", ",", "keybase1", ".", "UserOrTeamID", "(", "\"", "\"", ")", ",", "err", "\n", "}", "\n", "ei", ".", "UserBreak", "(", "ctx", ",", "name", ",", "asUser", ",", "res", ".", "TrackBreaks", ")", "\n", "}", "else", "if", "!", "res", ".", "Ul", ".", "Id", ".", "IsNil", "(", ")", "{", "ei", ".", "TeamBreak", "(", "ctx", ",", "res", ".", "Ul", ".", "Id", ".", "AsTeamOrBust", "(", ")", ",", "res", ".", "TrackBreaks", ")", "\n", "}", "\n\n", "return", "name", ",", "res", ".", "Ul", ".", "Id", ",", "nil", "\n", "}" ]

[ "Identify", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "NormalizeSocialAssertion", "(", "ctx", "context", ".", "Context", ",", "assertion", "string", ")", "(", "keybase1", ".", "SocialAssertion", ",", "error", ")", "{", "return", "k", ".", "identifyClient", ".", "NormalizeSocialAssertion", "(", "ctx", ",", "assertion", ")", "\n", "}" ]

[ "NormalizeSocialAssertion", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "ResolveIdentifyImplicitTeam", "(", "ctx", "context", ".", "Context", ",", "assertions", ",", "suffix", "string", ",", "tlfType", "tlf", ".", "Type", ",", "doIdentifies", "bool", ",", "reason", "string", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "idutil", ".", "ImplicitTeamInfo", ",", "error", ")", "{", "if", "tlfType", "!=", "tlf", ".", "Private", "&&", "tlfType", "!=", "tlf", ".", "Public", "{", "return", "idutil", ".", "ImplicitTeamInfo", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tlfType", ")", "\n", "}", "\n\n", "arg", ":=", "keybase1", ".", "ResolveIdentifyImplicitTeamArg", "{", "Assertions", ":", "assertions", ",", "Suffix", ":", "suffix", ",", "DoIdentifies", ":", "doIdentifies", ",", "Reason", ":", "keybase1", ".", "IdentifyReason", "{", "Reason", ":", "reason", "}", ",", "Create", ":", "true", ",", "IsPublic", ":", "tlfType", "==", "tlf", ".", "Public", ",", "Oa", ":", "offline", ",", "}", "\n\n", "ei", ":=", "tlfhandle", ".", "GetExtendedIdentify", "(", "ctx", ")", "\n", "arg", ".", "IdentifyBehavior", "=", "ei", ".", "Behavior", "\n\n", "res", ",", "err", ":=", "k", ".", "identifyClient", ".", "ResolveIdentifyImplicitTeam", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "ImplicitTeamInfo", "{", "}", ",", "ConvertIdentifyError", "(", "assertions", ",", "err", ")", "\n", "}", "\n", "name", ":=", "kbname", ".", "NormalizedUsername", "(", "res", ".", "DisplayName", ")", "\n\n", "// Exactly one break callback is required for every identify call.", "if", "doIdentifies", "{", "if", "len", "(", "res", ".", "TrackBreaks", ")", ">", "0", "{", "// Iterate the map to get one entry, then break.", "for", "userVer", ",", "breaks", ":=", "range", "res", ".", "TrackBreaks", "{", "// TODO: resolve the UID into a username so we don't have to", "// pass in the full display name here?", "ei", ".", "UserBreak", "(", "ctx", ",", "name", ",", "userVer", ".", "Uid", ",", "&", "breaks", ")", "\n", "break", "\n", "}", "\n", "}", "else", "{", "ei", ".", "TeamBreak", "(", "ctx", ",", "keybase1", ".", "TeamID", "(", "\"", "\"", ")", ",", "nil", ")", "\n", "}", "\n", "}", "\n\n", "iteamInfo", ":=", "idutil", ".", "ImplicitTeamInfo", "{", "Name", ":", "name", ",", "TID", ":", "res", ".", "TeamID", ",", "}", "\n", "if", "res", ".", "FolderID", "!=", "\"", "\"", "{", "iteamInfo", ".", "TlfID", ",", "err", "=", "tlf", ".", "ParseID", "(", "res", ".", "FolderID", ".", "String", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "ImplicitTeamInfo", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "iteamInfo", ",", "nil", "\n", "}" ]

[ "ResolveIdentifyImplicitTeam", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "ResolveImplicitTeamByID", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "name", "string", ",", "err", "error", ")", "{", "arg", ":=", "keybase1", ".", "ResolveImplicitTeamArg", "{", "Id", ":", "teamID", ",", "}", "\n\n", "res", ",", "err", ":=", "k", ".", "identifyClient", ".", "ResolveImplicitTeam", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "res", ".", "Name", ",", "nil", "\n", "}" ]

[ "ResolveImplicitTeamByID", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "LoadUserPlusKeys", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "pollForKID", "keybase1", ".", "KID", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "idutil", ".", "UserInfo", ",", "error", ")", "{", "cachedUserInfo", ":=", "k", ".", "getCachedUserInfo", "(", "uid", ")", "\n", "if", "cachedUserInfo", ".", "Name", "!=", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", "{", "if", "pollForKID", "==", "keybase1", ".", "KID", "(", "\"", "\"", ")", "{", "return", "cachedUserInfo", ",", "nil", "\n", "}", "\n", "// Skip the cache if pollForKID isn't present in", "// `VerifyingKeys` or one of the revoked verifying keys.", "for", "_", ",", "key", ":=", "range", "cachedUserInfo", ".", "VerifyingKeys", "{", "if", "key", ".", "KID", "(", ")", ".", "Equal", "(", "pollForKID", ")", "{", "return", "cachedUserInfo", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Check if the key is revoked, and fill in the merkle info in", "// that case.", "cachedUserInfo", ",", "exists", ",", "err", ":=", "k", ".", "checkForRevokedVerifyingKey", "(", "ctx", ",", "cachedUserInfo", ",", "pollForKID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n", "if", "exists", "{", "return", "cachedUserInfo", ",", "nil", "\n", "}", "\n", "}", "\n\n", "arg", ":=", "keybase1", ".", "LoadUserPlusKeysV2Arg", "{", "Uid", ":", "uid", ",", "PollForKID", ":", "pollForKID", ",", "Oa", ":", "offline", ",", "}", "\n", "res", ",", "err", ":=", "k", ".", "userClient", ".", "LoadUserPlusKeysV2", "(", "ctx", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "userInfo", ",", "err", ":=", "k", ".", "processUserPlusKeys", "(", "ctx", ",", "res", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "pollForKID", "!=", "keybase1", ".", "KID", "(", "\"", "\"", ")", "{", "// Fill in merkle info if we were explicitly trying to load a", "// revoked key.", "userInfo", ",", "_", ",", "err", "=", "k", ".", "checkForRevokedVerifyingKey", "(", "ctx", ",", "userInfo", ",", "pollForKID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "UserInfo", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n", "return", "userInfo", ",", "nil", "\n", "}" ]

[ "LoadUserPlusKeys", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "CreateTeamTLF", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "tlfID", "tlf", ".", "ID", ")", "(", "err", "error", ")", "{", "return", "k", ".", "kbfsClient", ".", "CreateTLF", "(", "ctx", ",", "keybase1", ".", "CreateTLFArg", "{", "TeamID", ":", "teamID", ",", "TlfID", ":", "keybase1", ".", "TLFID", "(", "tlfID", ".", "String", "(", ")", ")", ",", "}", ")", "\n", "}" ]

[ "CreateTeamTLF", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "GetTeamSettings", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "offline", "keybase1", ".", "OfflineAvailability", ")", "(", "keybase1", ".", "KBFSTeamSettings", ",", "error", ")", "{", "// TODO: get invalidations from the server and cache the settings?", "return", "k", ".", "kbfsClient", ".", "GetKBFSTeamSettings", "(", "ctx", ",", "keybase1", ".", "GetKBFSTeamSettingsArg", "{", "TeamID", ":", "teamID", ",", "Oa", ":", "offline", ",", "}", ")", "\n", "}" ]

[ "GetTeamSettings", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "GetCurrentMerkleRoot", "(", "ctx", "context", ".", "Context", ")", "(", "keybase1", ".", "MerkleRootV2", ",", "time", ".", "Time", ",", "error", ")", "{", "// Refresh the cached value in the background if the cached value", "// is older than 30s; if our cached value is more than 60s old,", "// block.", "_", ",", "root", ",", "rootTime", ",", "err", ":=", "k", ".", "merkleRoot", ".", "Get", "(", "ctx", ",", "30", "*", "time", ".", "Second", ",", "60", "*", "time", ".", "Second", ")", "\n", "return", "root", ",", "rootTime", ",", "err", "\n", "}" ]

[ "GetCurrentMerkleRoot", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "VerifyMerkleRoot", "(", "ctx", "context", ".", "Context", ",", "root", "keybase1", ".", "MerkleRootV2", ",", "kbfsRoot", "keybase1", ".", "KBFSRoot", ")", "error", "{", "return", "k", ".", "merkleClient", ".", "VerifyMerkleRootAndKBFS", "(", "ctx", ",", "keybase1", ".", "VerifyMerkleRootAndKBFSArg", "{", "Root", ":", "root", ",", "ExpectedKBFSRoot", ":", "kbfsRoot", ",", "}", ")", "\n", "}" ]

[ "VerifyMerkleRoot", "implements", "the", "KBPKI", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "CurrentSession", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "idutil", ".", "SessionInfo", ",", "error", ")", "{", "ctx", "=", "CtxWithRandomIDReplayable", "(", "ctx", ",", "CtxKeybaseServiceIDKey", ",", "CtxKeybaseServiceOpID", ",", "k", ".", "log", ")", "\n\n", "s", ",", "newSession", ",", "err", ":=", "k", ".", "getCurrentSession", "(", "ctx", ",", "sessionID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idutil", ".", "SessionInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "if", "newSession", "&&", "k", ".", "config", "!=", "nil", "{", "// Don't hold the lock while calling `serviceLoggedIn`.", "_", "=", "serviceLoggedIn", "(", "ctx", ",", "k", ".", "config", ",", "s", ",", "TLFJournalBackgroundWorkEnabled", ")", "\n", "}", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "CurrentSession", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FavoriteAdd", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "error", "{", "return", "k", ".", "favoriteClient", ".", "FavoriteAdd", "(", "ctx", ",", "keybase1", ".", "FavoriteAddArg", "{", "Folder", ":", "folder", "}", ")", "\n", "}" ]

[ "FavoriteAdd", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FavoriteDelete", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "error", "{", "return", "k", ".", "favoriteClient", ".", "FavoriteIgnore", "(", "ctx", ",", "keybase1", ".", "FavoriteIgnoreArg", "{", "Folder", ":", "folder", "}", ")", "\n", "}" ]

[ "FavoriteDelete", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FavoriteList", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "keybase1", ".", "FavoritesResult", ",", "error", ")", "{", "return", "k", ".", "favoriteClient", ".", "GetFavorites", "(", "ctx", ",", "sessionID", ")", "\n", "}" ]

[ "FavoriteList", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "NotifyOnlineStatusChanged", "(", "ctx", "context", ".", "Context", ",", "online", "bool", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "online", ")", "\n", "return", "k", ".", "kbfsClient", ".", "FSOnlineStatusChangedEvent", "(", "ctx", ",", "online", ")", "\n", "}" ]

[ "NotifyOnlineStatusChanged", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "Notify", "(", "ctx", "context", ".", "Context", ",", "notification", "*", "keybase1", ".", "FSNotification", ")", "error", "{", "// Reduce log spam by not repeating log lines for", "// notifications with the same filename.", "//", "// TODO: Only do this in debug mode.", "func", "(", ")", "{", "k", ".", "lastNotificationFilenameLock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lastNotificationFilenameLock", ".", "Unlock", "(", ")", "\n", "if", "notification", ".", "Filename", "!=", "k", ".", "lastNotificationFilename", "{", "k", ".", "lastNotificationFilename", "=", "notification", ".", "Filename", "\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "notification", ".", "Filename", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "k", ".", "kbfsClient", ".", "FSEvent", "(", "ctx", ",", "*", "notification", ")", "\n", "}" ]

[ "Notify", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "NotifyPathUpdated", "(", "ctx", "context", ".", "Context", ",", "path", "string", ")", "error", "{", "// Reduce log spam by not repeating log lines for", "// notifications with the same filename.", "//", "// TODO: Only do this in debug mode.", "func", "(", ")", "{", "k", ".", "lastNotificationFilenameLock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lastNotificationFilenameLock", ".", "Unlock", "(", ")", "\n", "if", "path", "!=", "k", ".", "lastPathUpdated", "{", "k", ".", "lastPathUpdated", "=", "path", "\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "path", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "k", ".", "kbfsClient", ".", "FSPathUpdate", "(", "ctx", ",", "path", ")", "\n", "}" ]

[ "NotifyPathUpdated", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "NotifySyncStatus", "(", "ctx", "context", ".", "Context", ",", "status", "*", "keybase1", ".", "FSPathSyncStatus", ")", "error", "{", "// Reduce log spam by not repeating log lines for", "// notifications with the same pathname.", "//", "// TODO: Only do this in debug mode.", "func", "(", ")", "{", "k", ".", "lastNotificationFilenameLock", ".", "Lock", "(", ")", "\n", "defer", "k", ".", "lastNotificationFilenameLock", ".", "Unlock", "(", ")", "\n", "if", "status", ".", "Path", "!=", "k", ".", "lastSyncNotificationPath", "{", "k", ".", "lastSyncNotificationPath", "=", "status", ".", "Path", "\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "status", ".", "Path", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "k", ".", "kbfsClient", ".", "FSSyncEvent", "(", "ctx", ",", "*", "status", ")", "\n", "}" ]

[ "NotifySyncStatus", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "NotifyOverallSyncStatus", "(", "ctx", "context", ".", "Context", ",", "status", "keybase1", ".", "FolderSyncStatus", ")", "error", "{", "return", "k", ".", "kbfsClient", ".", "FSOverallSyncEvent", "(", "ctx", ",", "status", ")", "\n", "}" ]

[ "NotifyOverallSyncStatus", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FlushUserFromLocalCache", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ")", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "uid", ")", "\n", "k", ".", "setCachedUserInfo", "(", "uid", ",", "idutil", ".", "UserInfo", "{", "}", ")", "\n", "}" ]

[ "FlushUserFromLocalCache", "implements", "the", "KeybaseService", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FSEditListRequest", "(", "ctx", "context", ".", "Context", ",", "req", "keybase1", ".", "FSEditListRequest", ")", "(", "err", "error", ")", "{", "ctx", "=", "CtxWithRandomIDReplayable", "(", "ctx", ",", "CtxKeybaseServiceIDKey", ",", "CtxKeybaseServiceOpID", ",", "k", ".", "log", ")", "\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "req", ".", "Folder", ".", "Name", ",", "!", "req", ".", "Folder", ".", "Private", ")", "\n", "tlfHandle", ",", "err", ":=", "getHandleFromFolderName", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "req", ".", "Folder", ".", "Name", ",", "!", "req", ".", "Folder", ".", "Private", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "rootNode", ",", "_", ",", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "GetOrCreateRootNode", "(", "ctx", ",", "tlfHandle", ",", "data", ".", "MasterBranch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "history", ",", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "GetEditHistory", "(", "ctx", ",", "rootNode", ".", "GetFolderBranch", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// TODO(KBFS-2996) Convert the edits to an RPC response.", "resp", ":=", "keybase1", ".", "FSEditListArg", "{", "RequestID", ":", "req", ".", "RequestID", ",", "Edits", ":", "history", ",", "}", "\n\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "len", "(", "resp", ".", "Edits", ".", "History", ")", ")", "\n", "return", "k", ".", "kbfsClient", ".", "FSEditList", "(", "ctx", ",", "resp", ")", "\n", "}" ]

[ "FSEditListRequest", "implements", "keybase1", ".", "NotifyFSRequestInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FSSyncStatusRequest", "(", "ctx", "context", ".", "Context", ",", "req", "keybase1", ".", "FSSyncStatusRequest", ")", "(", "err", "error", ")", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "req", ")", "\n\n", "resp", ":=", "keybase1", ".", "FSSyncStatusArg", "{", "RequestID", ":", "req", ".", "RequestID", "}", "\n\n", "// For now, just return the number of syncing bytes.", "jManager", ",", "err", ":=", "GetJournalManager", "(", "k", ".", "config", ")", "\n", "if", "err", "==", "nil", "{", "status", ",", "_", ":=", "jManager", ".", "Status", "(", "ctx", ")", "\n", "resp", ".", "Status", ".", "TotalSyncingBytes", "=", "status", ".", "UnflushedBytes", "\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "status", ".", "UnflushedBytes", ")", "\n", "}", "else", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "k", ".", "kbfsClient", ".", "FSSyncStatus", "(", "ctx", ",", "resp", ")", "\n", "}" ]

[ "FSSyncStatusRequest", "implements", "keybase1", ".", "NotifyFSRequestInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "TeamChangedByID", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "TeamChangedByIDArg", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "arg", ".", "TeamID", ",", "arg", ".", "Changes", ".", "MembershipChanged", ",", "arg", ".", "Changes", ".", "KeyRotated", ",", "arg", ".", "Changes", ".", "Renamed", ")", "\n", "k", ".", "setCachedTeamInfo", "(", "arg", ".", "TeamID", ",", "idutil", ".", "TeamInfo", "{", "}", ")", "\n\n", "if", "arg", ".", "Changes", ".", "Renamed", "{", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "TeamNameChanged", "(", "ctx", ",", "arg", ".", "TeamID", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "TeamChangedByID", "implements", "keybase1", ".", "NotifyTeamInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "TeamChangedByName", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "TeamChangedByNameArg", ")", "error", "{", "// ignore", "return", "nil", "\n", "}" ]

[ "TeamChangedByName", "implements", "keybase1", ".", "NotifyTeamInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "TeamDeleted", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "TeamDeleted", "implements", "keybase1", ".", "NotifyTeamInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonRPC", ")", "TeamAbandoned", "(", "ctx", "context", ".", "Context", ",", "tid", "keybase1", ".", "TeamID", ")", "error", "{", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tid", ")", "\n", "k", ".", "setCachedTeamInfo", "(", "tid", ",", "idutil", ".", "TeamInfo", "{", "}", ")", "\n", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "TeamAbandoned", "(", "ctx", ",", "tid", ")", "\n", "return", "nil", "\n", "}" ]

[ "TeamAbandoned", "implements", "keybase1", ".", "NotifyTeamInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseDaemonRPC", ")", "AvatarUpdated", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "AvatarUpdatedArg", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "AvatarUpdated", "implements", "keybase1", ".", "NotifyTeamInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "StartMigration", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "(", "err", "error", ")", "{", "mdServer", ":=", "k", ".", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// Making a favorite here to reuse the code that converts from", "// `keybase1.FolderType` into `tlf.Type`.", "fav", ":=", "favorites", ".", "NewFolderFromProtocol", "(", "folder", ")", "\n", "handle", ",", "err", ":=", "GetHandleFromFolderNameAndType", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "fav", ".", "Name", ",", "fav", ".", "Type", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "k", ".", "config", ".", "MDServer", "(", ")", ".", "StartImplicitTeamMigration", "(", "ctx", ",", "handle", ".", "TlfID", "(", ")", ")", "\n", "}" ]

[ "StartMigration", "implements", "keybase1", ".", "ImplicitTeamMigrationInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "FinalizeMigration", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ")", "(", "err", "error", ")", "{", "fav", ":=", "favorites", ".", "NewFolderFromProtocol", "(", "folder", ")", "\n", "handle", ",", "err", ":=", "GetHandleFromFolderNameAndType", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "fav", ".", "Name", ",", "fav", ".", "Type", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "handle", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "// Clear the cache for this implicit team, to ensure we get", "// all the latest key generations for the team info during the", "// migration.", "id", ":=", "handle", ".", "FirstResolvedWriter", "(", ")", "\n", "if", "id", ".", "IsTeamOrSubteam", "(", ")", "{", "tid", ",", "err", ":=", "id", ".", "AsTeam", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "tid", ",", "handle", ".", "GetCanonicalPath", "(", ")", ")", "\n", "k", ".", "setCachedTeamInfo", "(", "tid", ",", "idutil", ".", "TeamInfo", "{", "}", ")", "\n", "}", "\n", "}", "\n", "return", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "MigrateToImplicitTeam", "(", "ctx", ",", "handle", ".", "TlfID", "(", ")", ")", "\n", "}" ]

[ "FinalizeMigration", "implements", "keybase1", ".", "ImplicitTeamMigrationInterface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "GetTLFCryptKeys", "(", "ctx", "context", ".", "Context", ",", "query", "keybase1", ".", "TLFQuery", ")", "(", "res", "keybase1", ".", "GetTLFCryptKeysRes", ",", "err", "error", ")", "{", "if", "ctx", ",", "err", "=", "tlfhandle", ".", "MakeExtendedIdentify", "(", "CtxWithRandomIDReplayable", "(", "ctx", ",", "CtxKeybaseServiceIDKey", ",", "CtxKeybaseServiceOpID", ",", "k", ".", "log", ")", ",", "query", ".", "IdentifyBehavior", ",", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "GetTLFCryptKeysRes", "{", "}", ",", "err", "\n", "}", "\n\n", "tlfHandle", ",", "err", ":=", "getHandleFromFolderName", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "query", ".", "TlfName", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "res", ".", "NameIDBreaks", ".", "CanonicalName", "=", "keybase1", ".", "CanonicalTlfName", "(", "tlfHandle", ".", "GetCanonicalName", "(", ")", ")", "\n\n", "keys", ",", "id", ",", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "GetTLFCryptKeys", "(", "ctx", ",", "tlfHandle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "res", ".", "NameIDBreaks", ".", "TlfID", "=", "keybase1", ".", "TLFID", "(", "id", ".", "String", "(", ")", ")", "\n\n", "for", "i", ",", "key", ":=", "range", "keys", "{", "res", ".", "CryptKeys", "=", "append", "(", "res", ".", "CryptKeys", ",", "keybase1", ".", "CryptKey", "{", "KeyGeneration", ":", "int", "(", "kbfsmd", ".", "FirstValidKeyGen", ")", "+", "i", ",", "Key", ":", "keybase1", ".", "Bytes32", "(", "key", ".", "Data", "(", ")", ")", ",", "}", ")", "\n", "}", "\n\n", "if", "query", ".", "IdentifyBehavior", ".", "WarningInsteadOfErrorOnBrokenTracks", "(", ")", "{", "res", ".", "NameIDBreaks", ".", "Breaks", "=", "tlfhandle", ".", "GetExtendedIdentify", "(", "ctx", ")", ".", "GetTlfBreakAndClose", "(", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "GetTLFCryptKeys", "implements", "the", "TlfKeysInterface", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "GetPublicCanonicalTLFNameAndID", "(", "ctx", "context", ".", "Context", ",", "query", "keybase1", ".", "TLFQuery", ")", "(", "res", "keybase1", ".", "CanonicalTLFNameAndIDWithBreaks", ",", "err", "error", ")", "{", "if", "ctx", ",", "err", "=", "tlfhandle", ".", "MakeExtendedIdentify", "(", "CtxWithRandomIDReplayable", "(", "ctx", ",", "CtxKeybaseServiceIDKey", ",", "CtxKeybaseServiceOpID", ",", "k", ".", "log", ")", ",", "query", ".", "IdentifyBehavior", ",", ")", ";", "err", "!=", "nil", "{", "return", "keybase1", ".", "CanonicalTLFNameAndIDWithBreaks", "{", "}", ",", "err", "\n", "}", "\n\n", "tlfHandle", ",", "err", ":=", "getHandleFromFolderName", "(", "ctx", ",", "k", ".", "config", ".", "KBPKI", "(", ")", ",", "k", ".", "config", ".", "MDOps", "(", ")", ",", "k", ".", "config", ",", "query", ".", "TlfName", ",", "true", "/* public */", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "res", ".", "CanonicalName", "=", "keybase1", ".", "CanonicalTlfName", "(", "tlfHandle", ".", "GetCanonicalName", "(", ")", ")", "\n\n", "id", ",", "err", ":=", "k", ".", "config", ".", "KBFSOps", "(", ")", ".", "GetTLFID", "(", "ctx", ",", "tlfHandle", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "res", ".", "TlfID", "=", "keybase1", ".", "TLFID", "(", "id", ".", "String", "(", ")", ")", "\n\n", "if", "query", ".", "IdentifyBehavior", ".", "WarningInsteadOfErrorOnBrokenTracks", "(", ")", "{", "res", ".", "Breaks", "=", "tlfhandle", ".", "GetExtendedIdentify", "(", "ctx", ")", ".", "GetTlfBreakAndClose", "(", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "GetPublicCanonicalTLFNameAndID", "implements", "the", "TlfKeysInterface", "interface", "for", "KeybaseServiceBase", "." ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "EstablishMountDir", "(", "ctx", "context", ".", "Context", ")", "(", "string", ",", "error", ")", "{", "dir", ",", "err", ":=", "k", ".", "kbfsMountClient", ".", "GetCurrentMountDir", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "k", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "dir", "==", "\"", "\"", "{", "dirs", ",", "err", ":=", "k", ".", "kbfsMountClient", ".", "GetAllAvailableMountDirs", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "k", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "dir", ",", "err", "=", "chooseDefaultMount", "(", "ctx", ",", "dirs", ",", "k", ".", "log", ")", "\n", "if", "err", "!=", "nil", "{", "k", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "err2", ":=", "k", ".", "kbfsMountClient", ".", "SetCurrentMountDir", "(", "ctx", ",", "dir", ")", "\n", "if", "err2", "!=", "nil", "{", "k", ".", "log", ".", "CInfof", "(", "ctx", ",", "\"", "\"", ",", "err2", ")", "\n", "}", "\n", "// Continue mounting even if we can't save the mount", "k", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "dir", ",", "dirs", ")", "\n", "}", "\n", "return", "dir", ",", "err", "\n", "}" ]

[ "EstablishMountDir", "asks", "the", "service", "for", "the", "current", "mount", "path" ]

[ "func", "(", "k", "*", "KeybaseServiceBase", ")", "PutGitMetadata", "(", "ctx", "context", ".", "Context", ",", "folder", "keybase1", ".", "Folder", ",", "repoID", "keybase1", ".", "RepoID", ",", "metadata", "keybase1", ".", "GitLocalMetadata", ")", "error", "{", "return", "k", ".", "gitClient", ".", "PutGitMetadata", "(", "ctx", ",", "keybase1", ".", "PutGitMetadataArg", "{", "Folder", ":", "folder", ",", "RepoID", ":", "repoID", ",", "Metadata", ":", "metadata", ",", "}", ")", "\n", "}" ]

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

[ "func", "NewEventuallyConsistentMerkleRoot", "(", "config", "Config", ",", "getter", "idutil", ".", "MerkleRootGetter", ")", "*", "EventuallyConsistentMerkleRoot", "{", "ecmr", ":=", "&", "EventuallyConsistentMerkleRoot", "{", "config", ":", "config", ",", "log", ":", "config", ".", "MakeLogger", "(", "ECMRID", ")", ",", "getter", ":", "getter", ",", "}", "\n", "ecmr", ".", "fetcher", "=", "newFetchDecider", "(", "ecmr", ".", "log", ",", "config", ".", "MakeVLogger", "(", "ecmr", ".", "log", ")", ",", "ecmr", ".", "getAndCache", ",", "ECMRCtxTagKey", "{", "}", ",", "ECMRID", ",", "ecmr", ".", "config", ")", "\n", "return", "ecmr", "\n", "}" ]

[ "NewEventuallyConsistentMerkleRoot", "creates", "a", "new", "EventuallyConsistentMerkleRoot", "object", "." ]

[ "func", "(", "ecmr", "*", "EventuallyConsistentMerkleRoot", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "bgTolerance", ",", "blockTolerance", "time", ".", "Duration", ")", "(", "timestamp", "time", ".", "Time", ",", "root", "keybase1", ".", "MerkleRootV2", ",", "rootTime", "time", ".", "Time", ",", "err", "error", ")", "{", "c", ":=", "ecmr", ".", "getCached", "(", ")", "\n", "err", "=", "ecmr", ".", "fetcher", ".", "Do", "(", "ctx", ",", "bgTolerance", ",", "blockTolerance", ",", "c", ".", "timestamp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Time", "{", "}", ",", "keybase1", ".", "MerkleRootV2", "{", "}", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n", "c", "=", "ecmr", ".", "getCached", "(", ")", "\n", "return", "c", ".", "timestamp", ",", "c", ".", "root", ",", "c", ".", "rootTime", ",", "nil", "\n", "}" ]

[ "Get", "returns", "the", "current", "merkle", "root", "and", "the", "server", "timestamp", "of", "that", "root", ".", "To", "help", "avoid", "having", "too", "frequent", "calls", "into", "the", "API", "server", "caller", "can", "provide", "a", "positive", "tolerance", "to", "accept", "stale", "LimitBytes", "and", "UsageBytes", "data", ".", "If", "tolerance", "is", "0", "or", "negative", "this", "always", "makes", "a", "blocking", "RPC", "to", "bserver", "and", "return", "latest", "quota", "usage", ".", "1", ")", "If", "the", "age", "of", "cached", "data", "is", "more", "than", "blockTolerance", "a", "blocking", "RPC", "is", "issued", "and", "the", "function", "only", "returns", "after", "RPC", "finishes", "with", "the", "newest", "data", "from", "RPC", ".", "The", "RPC", "causes", "cached", "data", "to", "be", "refreshed", "as", "well", ".", "2", ")", "Otherwise", "if", "the", "age", "of", "cached", "data", "is", "more", "than", "bgTolerance", "a", "background", "RPC", "is", "spawned", "to", "refresh", "cached", "data", "and", "the", "stale", "data", "is", "returned", "immediately", ".", "3", ")", "Otherwise", "the", "cached", "stale", "data", "is", "returned", "immediately", "." ]

[ "func", "(", "c", "ChainLink", ")", "checkSpecialLinksTable", "(", "tab", "map", "[", "keybase1", ".", "LinkID", "]", "SpecialChainLink", ",", "uid", "keybase1", ".", "UID", ",", "why", "string", ")", "(", "found", "bool", ",", "reason", "string", ",", "err", "error", ")", "{", "var", "scl", "SpecialChainLink", "\n\n", "// The combination of hashVerified and chainVerified should ensure that this link", "// is only considered here after all prevs have been successfully checked.", "if", "!", "c", ".", "canTrustID", "(", ")", "{", "return", "false", ",", "\"", "\"", ",", "ChainLinkError", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "why", ",", "c", ".", "id", ",", "uid", ",", "c", ".", "hashVerified", ",", "c", ".", "chainVerified", ",", "c", ".", "diskVersion", ")", "}", "\n", "}", "\n\n", "scl", ",", "found", "=", "tab", "[", "c", ".", "LinkID", "(", ")", ".", "Export", "(", ")", "]", "\n", "if", "!", "found", "{", "return", "false", ",", "\"", "\"", ",", "nil", "\n", "}", "\n", "if", "!", "c", ".", "GetSeqno", "(", ")", ".", "Eq", "(", "scl", ".", "Seqno", ")", "{", "return", "false", ",", "\"", "\"", ",", "NewChainLinkWrongSeqnoError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "why", ",", "c", ".", "GetSeqno", "(", ")", ",", "scl", ".", "Seqno", ")", ")", "\n", "}", "\n", "if", "!", "scl", ".", "UID", ".", "Equal", "(", "uid", ")", "{", "return", "false", ",", "\"", "\"", ",", "NewUIDMismatchError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "why", ",", "scl", ".", "UID", ",", "uid", ")", ")", "\n", "}", "\n", "return", "true", ",", "scl", ".", "Reason", ",", "nil", "\n", "}" ]

[ "See", "NCC", "-", "KB2018", "-", "006" ]

[ "func", "(", "c", "ChainLink", ")", "ToMerkleTriple", "(", ")", "*", "MerkleTriple", "{", "if", "c", ".", "IsStubbed", "(", ")", "{", "return", "nil", "\n", "}", "\n", "return", "&", "MerkleTriple", "{", "Seqno", ":", "c", ".", "GetSeqno", "(", ")", ",", "LinkID", ":", "c", ".", "id", ",", "SigID", ":", "c", ".", "GetSigID", "(", ")", ",", "}", "\n", "}" ]

[ "ToLinkSummary", "converts", "a", "ChainLink", "into", "a", "MerkleTriple", "object", "." ]

[ "func", "(", "c", "ChainLink", ")", "IsHighUserLink", "(", "mctx", "MetaContext", ",", "uid", "keybase1", ".", "UID", ")", "(", "bool", ",", "error", ")", "{", "v2Type", ",", "err", ":=", "c", ".", "GetSigchainV2Type", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "hardcodedEldest", ":=", "false", "\n", "if", "c", ".", "GetSeqno", "(", ")", ">", "1", "{", "prevLink", ":=", "c", ".", "parent", ".", "GetLinkFromSeqno", "(", "c", ".", "GetSeqno", "(", ")", "-", "1", ")", "\n", "if", "prevLink", "==", "nil", "{", "return", "false", ",", "ChainLinkWrongSeqnoError", "{", "}", "\n", "}", "\n", "hardcodedEldest", ",", "err", "=", "isSubchainStart", "(", "mctx", ",", "&", "c", ",", "prevLink", ",", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "}", "\n\n", "isFirstLink", ":=", "v2Type", "==", "SigchainV2TypeEldest", "||", "c", ".", "GetSeqno", "(", ")", "==", "1", "||", "hardcodedEldest", "\n", "isNewHighLink", ":=", "isFirstLink", "||", "v2Type", "==", "SigchainV2TypeRevoke", "||", "v2Type", "==", "SigchainV2TypeWebServiceBindingWithRevoke", "||", "v2Type", "==", "SigchainV2TypeCryptocurrencyWithRevoke", "||", "v2Type", "==", "SigchainV2TypeSibkey", "||", "v2Type", "==", "SigchainV2TypePGPUpdate", "\n", "return", "isNewHighLink", ",", "nil", "\n", "}" ]

[ "IsHighUserLink", "determines", "whether", "a", "chainlink", "counts", "as", "high", "in", "a", "user", "s", "chain", "which", "is", "defined", "as", "an", "Eldest", "link", "a", "link", "with", "seqno", "=", "1", "a", "link", "that", "is", "Sibkey", "PGPUpdate", "Revoke", "or", "any", "link", "that", "is", "revoking", "." ]

[ "func", "(", "t", "*", "Team", ")", "ApplicationKey", "(", "ctx", "context", ".", "Context", ",", "application", "keybase1", ".", "TeamApplication", ")", "(", "keybase1", ".", "TeamApplicationKey", ",", "error", ")", "{", "latestGen", ":=", "t", ".", "chain", "(", ")", ".", "GetLatestGeneration", "(", ")", "\n", "return", "t", ".", "ApplicationKeyAtGeneration", "(", "ctx", ",", "application", ",", "latestGen", ")", "\n", "}" ]

[ "ApplicationKey", "returns", "the", "most", "recent", "key", "for", "an", "application", "." ]

[ "func", "(", "t", "*", "Team", ")", "InviteMember", "(", "ctx", "context", ".", "Context", ",", "username", "string", ",", "role", "keybase1", ".", "TeamRole", ",", "resolvedUsername", "libkb", ".", "NormalizedUsername", ",", "uv", "keybase1", ".", "UserVersion", ")", "(", "keybase1", ".", "TeamAddMemberResult", ",", "error", ")", "{", "// if a user version was previously loaded, then there is a keybase user for username, but", "// without a PUK or without any keys.", "if", "uv", ".", "Uid", ".", "Exists", "(", ")", "{", "return", "t", ".", "inviteKeybaseMember", "(", "ctx", ",", "uv", ",", "role", ",", "resolvedUsername", ")", "\n", "}", "\n\n", "// If a social, or email, or other type of invite, assert it's not an owner.", "if", "role", ".", "IsOrAbove", "(", "keybase1", ".", "TeamRole_OWNER", ")", "{", "return", "keybase1", ".", "TeamAddMemberResult", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "t", ".", "inviteSBSMember", "(", "ctx", ",", "username", ",", "role", ")", "\n", "}" ]

[ "If", "uv", ".", "Uid", "is", "set", "then", "username", "is", "ignored", ".", "Otherwise", "resolvedUsername", "and", "uv", "are", "ignored", "." ]

[ "func", "(", "t", "*", "Team", ")", "ForceMerkleRootUpdate", "(", "ctx", "context", ".", "Context", ")", "error", "{", "return", "ForceMerkleRootUpdateByTeamID", "(", "t", ".", "MetaContext", "(", "ctx", ")", ",", "t", ".", "ID", ")", "\n", "}" ]

[ "ForceMerkleRootUpdate", "will", "call", "LookupTeam", "on", "MerkleClient", "to", "update", "cached", "merkle", "root", "to", "include", "latest", "team", "sigs", ".", "Needed", "if", "client", "wants", "to", "create", "a", "signature", "that", "refers", "to", "an", "adminship", "signature", "s", "merkle_root", "has", "to", "be", "more", "fresh", "than", "adminship", "s", "." ]

[ "func", "(", "t", "*", "Team", ")", "AllAdmins", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "keybase1", ".", "UserVersion", ",", "error", ")", "{", "set", ":=", "make", "(", "map", "[", "keybase1", ".", "UserVersion", "]", "bool", ")", "\n\n", "owners", ",", "err", ":=", "t", ".", "UsersWithRole", "(", "keybase1", ".", "TeamRole_OWNER", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "m", ":=", "range", "owners", "{", "set", "[", "m", "]", "=", "true", "\n", "}", "\n\n", "admins", ",", "err", ":=", "t", ".", "UsersWithRole", "(", "keybase1", ".", "TeamRole_ADMIN", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "m", ":=", "range", "admins", "{", "set", "[", "m", "]", "=", "true", "\n", "}", "\n\n", "if", "t", ".", "IsSubteam", "(", ")", "{", "imp", ",", "err", ":=", "t", ".", "G", "(", ")", ".", "GetTeamLoader", "(", ")", ".", "ImplicitAdmins", "(", "ctx", ",", "t", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "m", ":=", "range", "imp", "{", "set", "[", "m", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "var", "all", "[", "]", "keybase1", ".", "UserVersion", "\n", "for", "uv", ":=", "range", "set", "{", "all", "=", "append", "(", "all", ",", "uv", ")", "\n", "}", "\n", "return", "all", ",", "nil", "\n", "}" ]

[ "All", "admins", "owners", "and", "implicit", "admins", "of", "this", "team", "." ]

[ "func", "(", "t", "*", "Team", ")", "notify", "(", "ctx", "context", ".", "Context", ",", "changes", "keybase1", ".", "TeamChangeSet", ",", "latestSeqno", "keybase1", ".", "Seqno", ")", "error", "{", "changes", ".", "KeyRotated", "=", "changes", ".", "KeyRotated", "||", "t", ".", "rotated", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "t", ".", "G", "(", ")", ")", "\n", "var", "err", "error", "\n", "if", "latestSeqno", ">", "0", "{", "err", "=", "HintLatestSeqno", "(", "m", ",", "t", ".", "ID", ",", "latestSeqno", ")", "\n", "}", "\n", "t", ".", "G", "(", ")", ".", "NotifyRouter", ".", "HandleTeamChangedByBothKeys", "(", "ctx", ",", "t", ".", "ID", ",", "t", ".", "Name", "(", ")", ".", "String", "(", ")", ",", "t", ".", "NextSeqno", "(", ")", ",", "t", ".", "IsImplicit", "(", ")", ",", "changes", ")", "\n", "return", "err", "\n", "}" ]

[ "Send", "notifyrouter", "messages", ".", "Modifies", "changes", "Update", "to", "the", "latest", "seqno", "that", "we", "re", "passing", "though", "don", "t", "make", "any", "assumptions", "about", "number", "of", "sigs", ".", "Note", "that", "we", "re", "probably", "going", "to", "be", "getting", "this", "same", "notification", "a", "second", "time", "since", "it", "will", "bounce", "off", "a", "gregor", "and", "back", "to", "us", ".", "But", "they", "are", "idempotent", "so", "it", "should", "be", "fine", "to", "be", "double", "-", "notified", "." ]

[ "func", "NewFastTeamLoader", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "FastTeamChainLoader", "{", "ret", ":=", "&", "FastTeamChainLoader", "{", "world", ":", "NewLoaderContextFromG", "(", "g", ")", ",", "featureFlagGate", ":", "libkb", ".", "NewFeatureFlagGate", "(", "libkb", ".", "FeatureFTL", ",", "2", "*", "time", ".", "Minute", ")", ",", "storage", ":", "NewFTLStorage", "(", "g", ")", ",", "}", "\n", "return", "ret", "\n", "}" ]

[ "NewFastLoader", "makes", "a", "new", "fast", "loader", "and", "initializes", "it", "." ]

[ "func", "NewFastTeamLoaderAndInstall", "(", "g", "*", "libkb", ".", "GlobalContext", ")", "*", "FastTeamChainLoader", "{", "l", ":=", "NewFastTeamLoader", "(", "g", ")", "\n", "g", ".", "SetFastTeamLoader", "(", "l", ")", "\n", "g", ".", "AddLogoutHook", "(", "l", ",", "\"", "\"", ")", "\n", "g", ".", "AddDbNukeHook", "(", "l", ",", "\"", "\"", ")", "\n", "return", "l", "\n", "}" ]

[ "NewFastTeamLoaderAndInstall", "creates", "a", "new", "loader", "and", "installs", "it", "into", "G", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "Load", "(", "m", "libkb", ".", "MetaContext", ",", "arg", "keybase1", ".", "FastTeamLoadArg", ")", "(", "res", "keybase1", ".", "FastTeamLoadRes", ",", "err", "error", ")", "{", "m", "=", "ftlLogTag", "(", "m", ")", "\n", "defer", "m", ".", "TraceTimed", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "arg", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "originalArg", ":=", "arg", ".", "DeepCopy", "(", ")", "\n\n", "err", "=", "f", ".", "featureFlagGate", ".", "ErrorIfFlagged", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "res", ",", "err", "=", "f", ".", "loadOneAttempt", "(", "m", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "if", "arg", ".", "AssertTeamName", "!=", "nil", "&&", "!", "arg", ".", "AssertTeamName", ".", "Eq", "(", "res", ".", "Name", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "arg", ".", "AssertTeamName", ".", "String", "(", ")", ",", "res", ".", "Name", ".", "String", "(", ")", ")", "\n", "arg", ".", "ForceRefresh", "=", "true", "\n", "res", ",", "err", "=", "f", ".", "loadOneAttempt", "(", "m", ",", "arg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "if", "!", "arg", ".", "AssertTeamName", ".", "Eq", "(", "res", ".", "Name", ")", "{", "return", "res", ",", "NewBadNameError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "arg", ".", "AssertTeamName", ".", "String", "(", ")", ",", "res", ".", "Name", ".", "String", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "ShouldRunBoxAudit", "(", "m", ")", "{", "newM", ",", "shouldReload", ":=", "VerifyBoxAudit", "(", "m", ",", "res", ".", "Name", ".", "ToTeamID", "(", "arg", ".", "Public", ")", ")", "\n", "if", "shouldReload", "{", "return", "f", ".", "Load", "(", "newM", ",", "originalArg", ")", "\n", "}", "\n", "}", "else", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "Load", "fast", "-", "loads", "the", "given", "team", ".", "Provide", "some", "hints", "as", "to", "how", "to", "load", "it", ".", "You", "can", "specify", "an", "application", "and", "key", "generations", "needed", "if", "you", "are", "entering", "chat", ".", "Those", "links", "will", "be", "returned", "unstubbed", "from", "the", "server", "and", "then", "the", "keys", "can", "be", "output", "in", "the", "result", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "verifyTeamNameViaParentLoad", "(", "m", "libkb", ".", "MetaContext", ",", "id", "keybase1", ".", "TeamID", ",", "isPublic", "bool", ",", "unverifiedName", "keybase1", ".", "TeamName", ",", "parent", "*", "keybase1", ".", "UpPointer", ",", "bottomSubteam", "keybase1", ".", "TeamID", ",", "forceRefresh", "bool", ")", "(", "res", "keybase1", ".", "TeamName", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "id", ",", "unverifiedName", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "if", "parent", "==", "nil", "{", "if", "!", "unverifiedName", ".", "IsRootTeam", "(", ")", "{", "return", "res", ",", "NewBadNameError", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "unverifiedName", ".", "ToTeamID", "(", "isPublic", ")", ".", "Eq", "(", "id", ")", "{", "return", "res", ",", "NewBadNameError", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "unverifiedName", ",", "nil", "\n", "}", "\n\n", "if", "parent", ".", "ParentID", ".", "IsPublic", "(", ")", "!=", "isPublic", "{", "return", "res", ",", "NewBadPublicError", "(", "parent", ".", "ParentID", ",", "isPublic", ")", "\n", "}", "\n\n", "parentRes", ",", "err", ":=", "f", ".", "load", "(", "m", ",", "fastLoadArg", "{", "FastTeamLoadArg", ":", "keybase1", ".", "FastTeamLoadArg", "{", "ID", ":", "parent", ".", "ParentID", ",", "Public", ":", "isPublic", ",", "ForceRefresh", ":", "forceRefresh", ",", "}", ",", "downPointersNeeded", ":", "[", "]", "keybase1", ".", "Seqno", "{", "parent", ".", "ParentSeqno", "}", ",", "needLatestName", ":", "true", ",", "readSubteamID", ":", "bottomSubteam", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "downPointer", ",", "ok", ":=", "parentRes", ".", "downPointers", "[", "parent", ".", "ParentSeqno", "]", "\n", "if", "!", "ok", "{", "return", "res", ",", "NewBadNameError", "(", "\"", "\"", ")", "\n", "}", "\n", "suffix", ":=", "downPointer", ".", "NameComponent", "\n\n", "parentName", ",", "err", ":=", "f", ".", "verifyTeamNameViaParentLoad", "(", "m", ",", "parent", ".", "ParentID", ",", "isPublic", ",", "parentRes", ".", "unverifiedName", ",", "parentRes", ".", "upPointer", ",", "bottomSubteam", ",", "forceRefresh", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "return", "parentName", ".", "Append", "(", "suffix", ")", "\n", "}" ]

[ "verifyTeamNameViaParentLoad", "takes", "a", "team", "ID", "and", "a", "pointer", "to", "a", "parent", "team", "s", "sigchain", "and", "computes", "the", "full", "resolved", "team", "name", ".", "If", "the", "pointer", "is", "null", "we", "ll", "assume", "this", "is", "a", "root", "team", "and", "do", "the", "verification", "via", "hash", "-", "comparison", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "load", "(", "m", "libkb", ".", "MetaContext", ",", "arg", "fastLoadArg", ")", "(", "res", "*", "fastLoadRes", ",", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "arg", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// Single-flight lock by team ID.", "lock", ":=", "f", ".", "locktab", ".", "AcquireOnName", "(", "m", ".", "Ctx", "(", ")", ",", "m", ".", "G", "(", ")", ",", "arg", ".", "ID", ".", "String", "(", ")", ")", "\n", "defer", "lock", ".", "Release", "(", "m", ".", "Ctx", "(", ")", ")", "\n\n", "return", "f", ".", "loadLockedWithRetries", "(", "m", ",", "arg", ")", "\n", "}" ]

[ "load", "acquires", "a", "lock", "by", "team", "ID", "and", "the", "runs", "loadLockedWithRetries", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "loadLockedWithRetries", "(", "m", "libkb", ".", "MetaContext", ",", "arg", "fastLoadArg", ")", "(", "res", "*", "fastLoadRes", ",", "err", "error", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "2", ";", "i", "++", "{", "res", ",", "err", "=", "f", ".", "loadLocked", "(", "m", ",", "arg", ")", "\n", "if", "err", "==", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "FTLMissingSeedError", ")", ";", "!", "ok", "{", "return", "nil", ",", "err", "\n", "}", "\n", "m", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "arg", ".", "forceReset", "=", "true", "\n", "}", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "loadLockedWithRetries", "attempts", "two", "loads", "of", "the", "team", ".", "If", "the", "first", "iteration", "returns", "an", "FTLMissingSeedError", "we", "ll", "blast", "through", "the", "cache", "and", "attempt", "a", "full", "reload", "a", "second", "time", ".", "Then", "that", "s", "for", "all", "the", "marbles", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "deriveSeedAtGeneration", "(", "m", "libkb", ".", "MetaContext", ",", "gen", "keybase1", ".", "PerTeamKeyGeneration", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "(", "seed", "keybase1", ".", "PerTeamKeySeed", ",", "err", "error", ")", "{", "seed", ",", "ok", ":=", "state", ".", "Chain", ".", "PerTeamKeySeedsVerified", "[", "gen", "]", "\n", "if", "ok", "{", "return", "seed", ",", "nil", "\n", "}", "\n", "var", "tmp", "keybase1", ".", "PerTeamKeySeed", "\n", "tmp", ",", "ok", "=", "state", ".", "PerTeamKeySeedsUnverified", "[", "gen", "]", "\n", "if", "!", "ok", "{", "// See CORE-9207. We can hit this case if we previously loaded a parent team for verifying a subteam", "// name before we were members of the team, and then later get added to the team, and then try to", "// reload the team. We didn't have boxes from the first time around, so just force a full reload.", "// It's inefficient but it's a very rare case.", "return", "seed", ",", "NewFTLMissingSeedError", "(", "gen", ")", "\n", "}", "\n\n", "ptkChain", ",", "ok", ":=", "state", ".", "Chain", ".", "PerTeamKeys", "[", "gen", "]", "\n", "if", "!", "ok", "{", "return", "seed", ",", "NewFastLoadError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gen", ")", ")", "\n", "}", "\n\n", "km", ",", "err", ":=", "NewTeamKeyManagerWithSecret", "(", "tmp", ",", "gen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "seed", ",", "err", "\n", "}", "\n\n", "sigKey", ",", "err", ":=", "km", ".", "SigningKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "seed", ",", "err", "\n", "}", "\n\n", "if", "!", "ptkChain", ".", "SigKID", ".", "SecureEqual", "(", "sigKey", ".", "GetKID", "(", ")", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "gen", ",", "sigKey", ".", "GetKID", "(", ")", ",", "ptkChain", ".", "SigKID", ")", "\n", "return", "seed", ",", "NewFastLoadError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gen", ")", ")", "\n", "}", "\n\n", "encKey", ",", "err", ":=", "km", ".", "EncryptionKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "seed", ",", "err", "\n", "}", "\n\n", "if", "!", "ptkChain", ".", "EncKID", ".", "SecureEqual", "(", "encKey", ".", "GetKID", "(", ")", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "gen", ",", "encKey", ".", "GetKID", "(", ")", ",", "ptkChain", ".", "EncKID", ")", "\n", "return", "seed", ",", "NewFastLoadError", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gen", ")", ")", "\n", "}", "\n\n", "// write back to cache", "seed", "=", "tmp", "\n", "state", ".", "Chain", ".", "PerTeamKeySeedsVerified", "[", "gen", "]", "=", "seed", "\n", "return", "seed", ",", "err", "\n", "}" ]

[ "dervieSeedAtGeneration", "either", "goes", "to", "cache", "or", "rederives", "the", "PTK", "private", "seed", "for", "the", "given", "generation", "gen", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "deriveKeyForApplicationAtGeneration", "(", "m", "libkb", ".", "MetaContext", ",", "app", "keybase1", ".", "TeamApplication", ",", "gen", "keybase1", ".", "PerTeamKeyGeneration", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "(", "key", "keybase1", ".", "TeamApplicationKey", ",", "err", "error", ")", "{", "seed", ",", "err", ":=", "f", ".", "deriveSeedAtGeneration", "(", "m", ",", "gen", ",", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "key", ",", "err", "\n", "}", "\n\n", "var", "mask", "*", "keybase1", ".", "MaskB64", "\n", "if", "m", ":=", "state", ".", "ReaderKeyMasks", "[", "app", "]", ";", "m", "!=", "nil", "{", "tmp", ",", "ok", ":=", "m", "[", "gen", "]", "\n", "if", "ok", "{", "mask", "=", "&", "tmp", "\n", "}", "\n", "}", "\n", "if", "mask", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "app", ",", "gen", ")", "\n", "if", "state", ".", "ID", "(", ")", ".", "IsSubTeam", "(", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "key", ",", "NewNotExplicitMemberOfSubteamError", "(", ")", "\n", "}", "\n", "return", "key", ",", "NewFastLoadError", "(", "\"", "\"", ")", "\n", "}", "\n\n", "rkm", ":=", "keybase1", ".", "ReaderKeyMask", "{", "Application", ":", "app", ",", "Generation", ":", "gen", ",", "Mask", ":", "*", "mask", ",", "}", "\n", "return", "applicationKeyForMask", "(", "rkm", ",", "seed", ")", "\n", "}" ]

[ "deriveKeyForApplicationAtGeneration", "pulls", "from", "cache", "or", "generates", "the", "PTK", "for", "the", "given", "application", "at", "the", "given", "generation", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "deriveKeysForApplication", "(", "m", "libkb", ".", "MetaContext", ",", "app", "keybase1", ".", "TeamApplication", ",", "arg", "fastLoadArg", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "(", "keys", "[", "]", "keybase1", ".", "TeamApplicationKey", ",", "err", "error", ")", "{", "var", "didLatest", "bool", "\n", "doKey", ":=", "func", "(", "gen", "keybase1", ".", "PerTeamKeyGeneration", ")", "error", "{", "var", "key", "keybase1", ".", "TeamApplicationKey", "\n", "key", ",", "err", "=", "f", ".", "deriveKeyForApplicationAtGeneration", "(", "m", ",", "app", ",", "gen", ",", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "keys", "=", "append", "(", "keys", ",", "key", ")", "\n", "if", "gen", "==", "state", ".", "LatestKeyGeneration", "{", "didLatest", "=", "true", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "if", "arg", ".", "NeedLatestKey", "{", "// This debug is useful to have since it will spell out which version is the latest in the log", "// if the caller asked for latest.", "m", ".", "Debug", "(", "\"", "\"", ",", "state", ".", "LatestKeyGeneration", ")", "\n", "}", "\n\n", "for", "_", ",", "gen", ":=", "range", "arg", ".", "KeyGenerationsNeeded", "{", "if", "err", "=", "doKey", "(", "gen", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "!", "didLatest", "&&", "arg", ".", "NeedLatestKey", "{", "if", "err", "=", "doKey", "(", "state", ".", "LatestKeyGeneration", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "keys", ",", "nil", "\n", "}" ]

[ "deriveKeysForApplication", "pulls", "from", "cache", "or", "generates", "several", "geneartions", "of", "PTKs", "for", "the", "given", "application", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "toResult", "(", "m", "libkb", ".", "MetaContext", ",", "arg", "fastLoadArg", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "(", "res", "*", "fastLoadRes", ",", "err", "error", ")", "{", "res", "=", "&", "fastLoadRes", "{", "unverifiedName", ":", "state", ".", "Name", ",", "downPointers", ":", "state", ".", "Chain", ".", "DownPointers", ",", "upPointer", ":", "state", ".", "Chain", ".", "LastUpPointer", ",", "}", "\n", "res", ".", "applicationKeys", ",", "err", "=", "f", ".", "deriveKeys", "(", "m", ",", "arg", ",", "state", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "toResult", "turns", "the", "current", "fast", "state", "into", "a", "fastLoadRes", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "findStateInCache", "(", "m", "libkb", ".", "MetaContext", ",", "id", "keybase1", ".", "TeamID", ")", "*", "keybase1", ".", "FastTeamData", "{", "tmp", ":=", "f", ".", "storage", ".", "Get", "(", "m", ",", "id", ",", "id", ".", "IsPublic", "(", ")", ")", "\n", "if", "tmp", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "tmp", "\n", "}" ]

[ "findState", "in", "cache", "finds", "the", "team", "ID", "s", "state", "in", "an", "in", "-", "memory", "cache", "." ]

[ "func", "stateHasKeys", "(", "m", "libkb", ".", "MetaContext", ",", "shoppingList", "*", "shoppingList", ",", "arg", "fastLoadArg", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "(", "fresh", "bool", ")", "{", "gens", ":=", "make", "(", "map", "[", "keybase1", ".", "PerTeamKeyGeneration", "]", "struct", "{", "}", ")", "\n\n", "fresh", "=", "true", "\n\n", "if", "arg", ".", "NeedLatestKey", "&&", "!", "state", ".", "LoadedLatest", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "shoppingList", ".", "needMerkleRefresh", "=", "true", "\n", "shoppingList", ".", "needLatestKey", "=", "true", "\n", "fresh", "=", "false", "\n", "}", "\n\n", "// The key generations needed are the ones passed in, and also, potentially, our cached", "// LatestKeyGeneration from the state. It could be that when we go to the server, this is no", "// longer the LatestKeyGeneration, but it might be. It depends. But in either case, we should", "// pull down the mask, since it's a bug to not have it if it turns out the server refresh", "// didn't budge the latest key generation.", "kgn", ":=", "append", "(", "[", "]", "keybase1", ".", "PerTeamKeyGeneration", "{", "}", ",", "arg", ".", "KeyGenerationsNeeded", "...", ")", "\n", "if", "arg", ".", "NeedLatestKey", "&&", "state", ".", "LoadedLatest", "&&", "state", ".", "LatestKeyGeneration", ">", "0", "{", "kgn", "=", "append", "(", "kgn", ",", "state", ".", "LatestKeyGeneration", ")", "\n", "}", "\n\n", "for", "_", ",", "app", ":=", "range", "arg", ".", "Applications", "{", "for", "_", ",", "gen", ":=", "range", "kgn", "{", "add", ":=", "false", "\n", "if", "state", ".", "ReaderKeyMasks", "[", "app", "]", "==", "nil", "||", "state", ".", "ReaderKeyMasks", "[", "app", "]", "[", "gen", "]", "==", "nil", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "app", ",", "gen", ")", "\n", "add", "=", "true", "\n", "}", "\n", "if", "!", "stateHasKeySeed", "(", "m", ",", "gen", ",", "state", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "gen", ")", "\n", "add", "=", "true", "\n", "}", "\n", "if", "add", "{", "gens", "[", "gen", "]", "=", "struct", "{", "}", "{", "}", "\n", "fresh", "=", "false", "\n", "}", "\n", "}", "\n", "}", "\n\n", "shoppingList", ".", "applications", "=", "append", "(", "[", "]", "keybase1", ".", "TeamApplication", "{", "}", ",", "arg", ".", "Applications", "...", ")", "\n\n", "if", "!", "fresh", "{", "for", "gen", ":=", "range", "gens", "{", "shoppingList", ".", "generations", "=", "append", "(", "shoppingList", ".", "generations", ",", "gen", ")", "\n", "}", "\n", "}", "\n", "return", "fresh", "\n", "}" ]

[ "stateHasKeys", "checks", "to", "see", "if", "the", "given", "state", "has", "the", "keys", "specified", "in", "the", "shopping", "list", ".", "If", "not", "it", "will", "modify", "the", "shopping", "list", "and", "return", "false", ".", "If", "yes", "it", "will", "leave", "the", "shopping", "list", "unchanged", "and", "return", "true", "." ]

[ "func", "stateHasDownPointers", "(", "m", "libkb", ".", "MetaContext", ",", "shoppingList", "*", "shoppingList", ",", "arg", "fastLoadArg", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "(", "ret", "bool", ")", "{", "ret", "=", "true", "\n\n", "for", "_", ",", "seqno", ":=", "range", "arg", ".", "downPointersNeeded", "{", "if", "_", ",", "ok", ":=", "state", ".", "Chain", ".", "DownPointers", "[", "seqno", "]", ";", "!", "ok", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "seqno", ")", "\n", "shoppingList", ".", "addDownPointer", "(", "seqno", ")", "\n", "ret", "=", "false", "\n", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "stateHasDownPointers", "checks", "to", "see", "if", "the", "given", "state", "has", "the", "down", "pointers", "specified", "in", "the", "shopping", "list", ".", "If", "not", "it", "will", "change", "the", "shopping", "list", "to", "have", "the", "down", "pointers", "and", "return", "false", ".", "If", "yes", "it", "will", "leave", "the", "shopping", "list", "unchanged", "and", "return", "true", "." ]

[ "func", "(", "f", "*", "FastTeamChainLoader", ")", "computeWithPreviousState", "(", "m", "libkb", ".", "MetaContext", ",", "s", "*", "shoppingList", ",", "arg", "fastLoadArg", ",", "state", "*", "keybase1", ".", "FastTeamData", ")", "{", "cachedAt", ":=", "state", ".", "CachedAt", ".", "Time", "(", ")", "\n", "s", ".", "linksSince", "=", "state", ".", "Chain", ".", "Last", ".", "Seqno", "\n\n", "if", "arg", ".", "forceReset", "{", "s", ".", "linksSince", "=", "keybase1", ".", "Seqno", "(", "0", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "arg", ".", "needChainTail", "(", ")", "&&", "m", ".", "G", "(", ")", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "Sub", "(", "cachedAt", ")", ">", "time", ".", "Hour", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "cachedAt", ")", "\n", "s", ".", "needMerkleRefresh", "=", "true", "\n", "}", "\n", "if", "arg", ".", "needChainTail", "(", ")", "&&", "state", ".", "LatestSeqnoHint", ">", "state", ".", "Chain", ".", "Last", ".", "Seqno", "{", "m", ".", "Debug", "(", "\"", "\"", ",", "state", ".", "LatestSeqnoHint", ",", "state", ".", "Chain", ".", "Last", ".", "Seqno", ")", "\n", "s", ".", "needMerkleRefresh", "=", "true", "\n", "}", "\n", "if", "arg", ".", "ForceRefresh", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "s", ".", "needMerkleRefresh", "=", "true", "\n", "}", "\n", "if", "!", "s", ".", "needMerkleRefresh", "&&", "f", ".", "InForceRepollMode", "(", "m", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "s", ".", "needMerkleRefresh", "=", "true", "\n", "}", "\n", "if", "!", "stateHasKeys", "(", "m", ",", "s", ",", "arg", ",", "state", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "stateHasDownPointers", "(", "m", ",", "s", ",", "arg", ",", "state", ")", "{", "m", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "computeWithPreviousState", "looks", "into", "the", "given", "load", "arg", "and", "also", "our", "current", "cached", "state", "to", "figure", "what", "to", "get", "from", "the", "server", ".", "The", "results", "are", "compiled", "into", "a", "shopping", "list", "that", "we", "ll", "later", "use", "when", "we", "concoct", "our", "server", "request", "." ]