Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13k

[ "func", "(", "v", "*", "CredentialAuthority", ")", "pollOnce", "(", ")", "error", "{", "var", "err", "error", "\n", "var", "uids", "[", "]", "keybase1", ".", "UID", "\n", "err", "=", "v", ".", "runWithCancel", "(", "func", "(", "ctx", "context", ".", "Context", ")", "error", "{", "var", "err", "error", "\n", "uids", ",", "err", "=", "v", ".", "api", ".", "PollForChanges", "(", "ctx", ")", "\n", "return", "err", "\n", "}", ")", "\n", "if", "err", "==", "nil", "{", "for", "_", ",", "uid", ":=", "range", "uids", "{", "v", ".", "invalidateCh", "<-", "uid", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "pollOnce", "polls", "the", "API", "server", "once", "for", "which", "users", "have", "changed", "." ]

[ "func", "(", "v", "*", "CredentialAuthority", ")", "makeUser", "(", "uid", "keybase1", ".", "UID", ")", "*", "user", "{", "uw", ":=", "v", ".", "users", "[", "uid", "]", "\n", "if", "uw", "==", "nil", "{", "u", ":=", "newUser", "(", "uid", ",", "v", ")", "\n", "uw", "=", "&", "userWrapper", "{", "u", ":", "u", "}", "\n", "v", ".", "users", "[", "uid", "]", "=", "uw", "\n", "}", "\n", "uw", ".", "atime", "=", "v", ".", "eng", ".", "Now", "(", ")", "\n", "return", "uw", ".", "u", "\n", "}" ]

[ "makeUser", "either", "pulls", "a", "user", "from", "the", "in", "-", "memory", "table", "or", "constructs", "a", "new", "one", ".", "In", "either", "case", "it", "updates", "the", "CA", "s", "atime", "bit", "for", "now", "for", "this", "user", "record", "." ]

[ "func", "(", "u", "*", "user", ")", "repopulate", "(", ")", "error", "{", "if", "u", ".", "isPopulated", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "// Register that this item should eventually be cleaned out by the cleaner", "// thread. Don't block on the send, though, since that could deadlock the process", "// (since the process is blocked on sending to us).", "ctime", ":=", "u", ".", "Now", "(", ")", "\n", "go", "func", "(", ")", "{", "u", ".", "ca", ".", "cleanItemCh", "<-", "cleanItem", "{", "uid", ":", "u", ".", "uid", ",", "ctime", ":", "ctime", "}", "\n", "}", "(", ")", "\n\n", "un", ",", "sibkeys", ",", "subkeys", ",", "isDeleted", ",", "err", ":=", "u", ".", "ca", ".", "getUserFromServer", "(", "u", ".", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "u", ".", "isOK", "=", "false", "\n", "return", "err", "\n", "}", "\n", "u", ".", "username", "=", "un", "\n", "for", "_", ",", "k", ":=", "range", "sibkeys", "{", "u", ".", "sibkeys", "[", "k", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "for", "_", ",", "k", ":=", "range", "subkeys", "{", "u", ".", "subkeys", "[", "k", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "u", ".", "isOK", "=", "true", "\n", "u", ".", "ctime", "=", "ctime", "\n", "u", ".", "isDeleted", "=", "isDeleted", "\n", "u", ".", "ca", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "u", ")", "\n", "return", "nil", "\n", "}" ]

[ "repopulate", "is", "intended", "to", "repopulate", "our", "representation", "of", "the", "user", "with", "the", "server", "s", "up", "-", "to", "-", "date", "notion", "of", "what", "the", "user", "looks", "like", ".", "If", "our", "version", "is", "recent", "enough", "this", "is", "a", "no", "-", "op", ".", "If", "not", "we", "ll", "go", "to", "the", "server", "and", "send", "the", "main", "loop", "a", "Cleanup", "event", "to", "eventually", "clean", "us", "out", "." ]

[ "func", "(", "u", "*", "user", ")", "isPopulated", "(", ")", "bool", "{", "return", "u", ".", "isOK", "&&", "u", ".", "Now", "(", ")", ".", "Sub", "(", "u", ".", "ctime", ")", "<=", "userTimeout", "\n", "}" ]

[ "isPopulated", "returned", "true", "if", "this", "user", "is", "populated", "and", "current", "enough", "to", "trust", "." ]

[ "func", "(", "u", "*", "user", ")", "check", "(", "ca", "checkArg", ")", "{", "var", "err", "error", "\n\n", "defer", "func", "(", ")", "{", "u", ".", "ca", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "ca", ",", "err", ")", "\n", "ca", ".", "retCh", "<-", "err", "\n", "}", "(", ")", "\n\n", "if", "err", "=", "u", ".", "repopulate", "(", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "!", "ca", ".", "loadDeleted", "&&", "u", ".", "isDeleted", "{", "err", "=", "ErrUserDeleted", "\n", "return", "\n", "}", "\n\n", "if", "ca", ".", "username", "!=", "nil", "{", "if", "err", "=", "u", ".", "checkUsername", "(", "*", "ca", ".", "username", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "ca", ".", "kid", "!=", "nil", "{", "if", "err", "=", "u", ".", "checkKey", "(", "*", "ca", ".", "kid", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "ca", ".", "sibkeys", "!=", "nil", "{", "if", "err", "=", "u", ".", "compareSibkeys", "(", "ca", ".", "sibkeys", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "if", "ca", ".", "subkeys", "!=", "nil", "{", "if", "err", "=", "u", ".", "compareSubkeys", "(", "ca", ".", "subkeys", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "check", "that", "a", "user", "matches", "the", "given", "username", "and", "has", "the", "given", "key", "as", "one", "of", "its", "valid", "keys", ".", "This", "is", "where", "the", "actually", "work", "of", "this", "whole", "library", "happens", "." ]

[ "func", "(", "u", "*", "user", ")", "checkUsername", "(", "un", "libkb", ".", "NormalizedUsername", ")", "error", "{", "var", "err", "error", "\n", "if", "!", "u", ".", "username", ".", "Eq", "(", "un", ")", "{", "err", "=", "BadUsernameError", "{", "u", ".", "username", ",", "un", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "checkUsername", "checks", "that", "a", "username", "is", "a", "match", "for", "this", "user", "." ]

[ "func", "(", "u", "*", "user", ")", "compareSibkeys", "(", "sibkeys", "[", "]", "keybase1", ".", "KID", ")", "error", "{", "return", "compareKeys", "(", "sibkeys", ",", "u", ".", "sibkeys", ")", "\n", "}" ]

[ "compareSibkeys", "returns", "true", "if", "the", "passed", "set", "of", "sibkeys", "is", "equal", "." ]

[ "func", "(", "u", "*", "user", ")", "compareSubkeys", "(", "subkeys", "[", "]", "keybase1", ".", "KID", ")", "error", "{", "return", "compareKeys", "(", "subkeys", ",", "u", ".", "subkeys", ")", "\n", "}" ]

[ "compareSubkeys", "returns", "true", "if", "the", "passed", "set", "of", "subkeys", "is", "equal", "." ]

[ "func", "compareKeys", "(", "keys", "[", "]", "keybase1", ".", "KID", ",", "expected", "map", "[", "keybase1", ".", "KID", "]", "struct", "{", "}", ")", "error", "{", "if", "len", "(", "keys", ")", "!=", "len", "(", "expected", ")", "{", "return", "ErrKeysNotEqual", "\n", "}", "\n", "for", "_", ",", "kid", ":=", "range", "keys", "{", "if", "_", ",", "ok", ":=", "expected", "[", "kid", "]", ";", "!", "ok", "{", "return", "ErrKeysNotEqual", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Helper", "method", "for", "the", "two", "above", "." ]

[ "func", "(", "u", "*", "user", ")", "checkKey", "(", "kid", "keybase1", ".", "KID", ")", "error", "{", "var", "err", "error", "\n", "if", "_", ",", "ok", ":=", "u", ".", "sibkeys", "[", "kid", "]", ";", "!", "ok", "{", "if", "_", ",", "ok", ":=", "u", ".", "subkeys", "[", "kid", "]", ";", "!", "ok", "{", "err", "=", "BadKeyError", "{", "u", ".", "uid", ",", "kid", "}", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "checkKey", "checks", "that", "the", "given", "key", "is", "still", "valid", "for", "this", "user", "." ]

[ "func", "(", "v", "*", "CredentialAuthority", ")", "CheckUserKey", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "username", "*", "libkb", ".", "NormalizedUsername", ",", "kid", "*", "keybase1", ".", "KID", ",", "loadDeleted", "bool", ")", "(", "err", "error", ")", "{", "v", ".", "log", ".", "Debug", "(", "\"", "\"", ",", "uid", ",", "kid", ")", "\n", "retCh", ":=", "make", "(", "chan", "error", ",", "1", ")", "// buffered in case the ctx is canceled", "\n", "v", ".", "checkCh", "<-", "checkArg", "{", "uid", ":", "uid", ",", "username", ":", "username", ",", "kid", ":", "kid", ",", "loadDeleted", ":", "loadDeleted", ",", "retCh", ":", "retCh", "}", "\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "err", "=", "ctx", ".", "Err", "(", ")", "\n", "case", "err", "=", "<-", "retCh", ":", "}", "\n", "return", "err", "\n", "}" ]

[ "CheckUserKey", "is", "the", "main", "point", "of", "entry", "to", "this", "library", ".", "It", "takes", "as", "input", "a", "UID", "a", "username", "and", "a", "kid", "that", "should", "refer", "to", "a", "current", "valid", "triple", "perhaps", "extracted", "from", "a", "signed", "authentication", "statement", ".", "It", "returns", "an", "error", "if", "the", "check", "fails", "and", "nil", "otherwise", ".", "If", "username", "or", "kid", "are", "nil", "they", "aren", "t", "checked", "." ]

[ "func", "(", "v", "*", "CredentialAuthority", ")", "CheckUsers", "(", "ctx", "context", ".", "Context", ",", "users", "[", "]", "keybase1", ".", "UID", ")", "(", "err", "error", ")", "{", "for", "_", ",", "uid", ":=", "range", "users", "{", "if", "uid", "==", "keybase1", ".", "PUBLIC_UID", "{", "continue", "\n", "}", "\n", "if", "err", "=", "v", ".", "CheckUserKey", "(", "ctx", ",", "uid", ",", "nil", ",", "nil", ",", "false", ")", ";", "err", "!=", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "CheckUsers", "is", "used", "to", "validate", "all", "provided", "UIDs", "are", "known", "." ]

[ "func", "(", "v", "*", "CredentialAuthority", ")", "CompareUserKeys", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "sibkeys", ",", "subkeys", "[", "]", "keybase1", ".", "KID", ")", "(", "err", "error", ")", "{", "retCh", ":=", "make", "(", "chan", "error", ",", "1", ")", "// buffered in case the ctx is canceled", "\n", "v", ".", "checkCh", "<-", "checkArg", "{", "uid", ":", "uid", ",", "sibkeys", ":", "sibkeys", ",", "subkeys", ":", "subkeys", ",", "retCh", ":", "retCh", "}", "\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "err", "=", "ctx", ".", "Err", "(", ")", "\n", "case", "err", "=", "<-", "retCh", ":", "}", "\n", "return", "err", "\n", "}" ]

[ "CompareUserKeys", "compares", "the", "passed", "sets", "to", "the", "sets", "known", "by", "the", "API", "server", ".", "It", "returns", "true", "if", "the", "sets", "are", "equal", "." ]

[ "func", "(", "s", "Start", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "StartTime", ",", "s", ".", "CommitmentWindowMsec", ",", "s", ".", "RevealWindowMsec", ",", "s", ".", "SlackMsec", ",", "s", ".", "CommitmentWindowMsec", ")", "\n", "}" ]

[ "Excludes", "Params", "from", "being", "logged", "." ]

[ "func", "inflateTimeout", "(", "timeout", "int64", ",", "nPlayers", "int", ")", "int64", "{", "if", "nPlayers", "<=", "5", "{", "return", "timeout", "\n", "}", "\n", "return", "int64", "(", "math", ".", "Ceil", "(", "math", ".", "Log", "(", "float64", "(", "nPlayers", ")", ")", "*", "float64", "(", "timeout", ")", "/", "math", ".", "Log", "(", "5.0", ")", ")", ")", "\n", "}" ]

[ "For", "bigger", "groups", "everything", "is", "slower", "like", "the", "time", "to", "digest", "all", "required", "messages", ".", "So", "we", "re", "going", "to", "inflate", "our", "timeouts", "." ]

[ "func", "NewEventuallyConsistentQuotaUsage", "(", "config", "Config", ",", "log", "logger", ".", "Logger", ",", "vlog", "*", "libkb", ".", "VDebugLog", ")", "*", "EventuallyConsistentQuotaUsage", "{", "q", ":=", "&", "EventuallyConsistentQuotaUsage", "{", "config", ":", "config", ",", "log", ":", "log", ",", "}", "\n", "q", ".", "fetcher", "=", "newFetchDecider", "(", "q", ".", "log", ",", "vlog", ",", "q", ".", "getAndCache", ",", "ECQUCtxTagKey", "{", "}", ",", "ECQUID", ",", "q", ".", "config", ")", "\n", "return", "q", "\n", "}" ]

[ "NewEventuallyConsistentQuotaUsage", "creates", "a", "new", "EventuallyConsistentQuotaUsage", "object", "." ]

[ "func", "NewEventuallyConsistentTeamQuotaUsage", "(", "config", "Config", ",", "tid", "keybase1", ".", "TeamID", ",", "log", "logger", ".", "Logger", ",", "vlog", "*", "libkb", ".", "VDebugLog", ")", "*", "EventuallyConsistentQuotaUsage", "{", "q", ":=", "NewEventuallyConsistentQuotaUsage", "(", "config", ",", "log", ",", "vlog", ")", "\n", "q", ".", "tid", "=", "tid", "\n", "return", "q", "\n", "}" ]

[ "NewEventuallyConsistentTeamQuotaUsage", "creates", "a", "new", "EventuallyConsistentQuotaUsage", "object", "." ]

[ "func", "(", "q", "*", "EventuallyConsistentQuotaUsage", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "bgTolerance", ",", "blockTolerance", "time", ".", "Duration", ")", "(", "timestamp", "time", ".", "Time", ",", "usageBytes", ",", "archiveBytes", ",", "limitBytes", "int64", ",", "err", "error", ")", "{", "c", ":=", "q", ".", "getCached", "(", ")", "\n", "err", "=", "q", ".", "fetcher", ".", "Do", "(", "ctx", ",", "bgTolerance", ",", "blockTolerance", ",", "c", ".", "timestamp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Time", "{", "}", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "err", "\n", "}", "\n\n", "c", "=", "q", ".", "getCached", "(", ")", "\n", "switch", "q", ".", "config", ".", "DefaultBlockType", "(", ")", "{", "case", "keybase1", ".", "BlockType_DATA", ":", "return", "c", ".", "timestamp", ",", "c", ".", "usageBytes", ",", "c", ".", "archiveBytes", ",", "c", ".", "limitBytes", ",", "nil", "\n", "case", "keybase1", ".", "BlockType_GIT", ":", "return", "c", ".", "timestamp", ",", "c", ".", "gitUsageBytes", ",", "c", ".", "gitArchiveBytes", ",", "c", ".", "gitLimitBytes", ",", "nil", "\n", "default", ":", "return", "time", ".", "Time", "{", "}", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "q", ".", "config", ".", "DefaultBlockType", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "Get", "returns", "KBFS", "bytes", "used", "and", "limit", "for", "user", "for", "the", "current", "default", "block", "type", ".", "To", "help", "avoid", "having", "too", "frequent", "calls", "into", "bserver", "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", "(", "q", "*", "EventuallyConsistentQuotaUsage", ")", "GetAllTypes", "(", "ctx", "context", ".", "Context", ",", "bgTolerance", ",", "blockTolerance", "time", ".", "Duration", ")", "(", "timestamp", "time", ".", "Time", ",", "usageBytes", ",", "archiveBytes", ",", "limitBytes", ",", "gitUsageBytes", ",", "gitArchiveBytes", ",", "gitLimitBytes", "int64", ",", "err", "error", ")", "{", "c", ":=", "q", ".", "getCached", "(", ")", "\n", "err", "=", "q", ".", "fetcher", ".", "Do", "(", "ctx", ",", "bgTolerance", ",", "blockTolerance", ",", "c", ".", "timestamp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Time", "{", "}", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "err", "\n", "}", "\n\n", "c", "=", "q", ".", "getCached", "(", ")", "\n", "return", "c", ".", "timestamp", ",", "c", ".", "usageBytes", ",", "c", ".", "archiveBytes", ",", "c", ".", "limitBytes", ",", "c", ".", "gitUsageBytes", ",", "c", ".", "gitArchiveBytes", ",", "c", ".", "gitLimitBytes", ",", "nil", "\n", "}" ]

[ "GetAllTypes", "is", "the", "same", "as", "Get", "except", "it", "returns", "usage", "and", "limits", "for", "all", "block", "types", "." ]

[ "func", "NewKex2Provisionee", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "device", "*", "libkb", ".", "Device", ",", "secret", "kex2", ".", "Secret", ",", "expectedUID", "keybase1", ".", "UID", ",", "salt", "[", "]", "byte", ")", "*", "Kex2Provisionee", "{", "return", "&", "Kex2Provisionee", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "device", ":", "device", ",", "secret", ":", "secret", ",", "secretCh", ":", "make", "(", "chan", "kex2", ".", "Secret", ")", ",", "salt", ":", "salt", ",", "expectedUID", ":", "expectedUID", ",", "}", "\n", "}" ]

[ "NewKex2Provisionee", "creates", "a", "Kex2Provisionee", "engine", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "GetLogFactory", "(", ")", "rpc", ".", "LogFactory", "{", "return", "rpc", ".", "NewSimpleLogFactory", "(", "e", ".", "G", "(", ")", ".", "Log", ",", "nil", ")", "\n", "}" ]

[ "GetLogFactory", "implements", "GetLogFactory", "in", "kex2", ".", "Provisionee", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "HandleHello", "(", "_", "context", ".", "Context", ",", "harg", "keybase1", ".", "HelloArg", ")", "(", "res", "keybase1", ".", "HelloRes", ",", "err", "error", ")", "{", "m", ":=", "e", ".", "mctx", "\n", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "e", ".", "pps", "=", "harg", ".", "Pps", "\n", "res", ",", "err", "=", "e", ".", "handleHello", "(", "m", ",", "harg", ".", "Uid", ",", "harg", ".", "Token", ",", "harg", ".", "Csrf", ",", "harg", ".", "SigBody", ")", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "HandleHello", "implements", "HandleHello", "in", "kex2", ".", "Provisionee", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "HandleHello2", "(", "_", "context", ".", "Context", ",", "harg", "keybase1", ".", "Hello2Arg", ")", "(", "res", "keybase1", ".", "Hello2Res", ",", "err", "error", ")", "{", "m", ":=", "e", ".", "mctx", "\n", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "var", "res1", "keybase1", ".", "HelloRes", "\n", "res1", ",", "err", "=", "e", ".", "handleHello", "(", "m", ",", "harg", ".", "Uid", ",", "harg", ".", "Token", ",", "harg", ".", "Csrf", ",", "harg", ".", "SigBody", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "res", ".", "SigPayload", "=", "res1", "\n", "res", ".", "EncryptionKey", "=", "e", ".", "dh", ".", "GetKID", "(", ")", "\n", "res", ".", "DeviceEkKID", ",", "err", "=", "e", ".", "ekReboxer", ".", "getDeviceEKKID", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "HandleHello2", "implements", "HandleHello2", "in", "kex2", ".", "Provisionee", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "HandleDidCounterSign", "(", "_", "context", ".", "Context", ",", "sig", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "return", "e", ".", "handleDidCounterSign", "(", "e", ".", "mctx", ",", "sig", ",", "nil", ",", "nil", ")", "\n", "}" ]

[ "HandleDidCounterSign", "implements", "HandleDidCounterSign", "in", "kex2", ".", "Provisionee", "interface", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "updateTemporarySession", "(", "m", "libkb", ".", "MetaContext", ",", "uv", "keybase1", ".", "UserVersion", ")", "(", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "m", ".", "Debug", "(", "\"", "\"", ",", "m", ".", "LoginContext", "(", ")", ",", "m", ".", "LoginContext", "(", ")", ")", "\n", "return", "m", ".", "LoginContext", "(", ")", ".", "SaveState", "(", "string", "(", "e", ".", "sessionToken", ")", ",", "string", "(", "e", ".", "csrfToken", ")", ",", "libkb", ".", "NewNormalizedUsername", "(", "e", ".", "username", ")", ",", "uv", ",", "e", ".", "device", ".", "ID", ")", "\n", "}" ]

[ "updateTemporarySession", "commits", "the", "session", "token", "and", "csrf", "token", "to", "our", "temporary", "session", "stored", "in", "our", "provisional", "login", "context", ".", "We", "ll", "need", "that", "to", "post", "successfully", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "postSigs", "(", "signingArgs", ",", "encryptArgs", "*", "libkb", ".", "HTTPArgs", ",", "perUserKeyBox", "*", "keybase1", ".", "PerUserKeyBox", ",", "reboxArg", "*", "keybase1", ".", "UserEkReboxArg", ")", "error", "{", "payload", ":=", "make", "(", "libkb", ".", "JSONPayload", ")", "\n", "payload", "[", "\"", "\"", "]", "=", "[", "]", "map", "[", "string", "]", "string", "{", "firstValues", "(", "signingArgs", ".", "ToValues", "(", ")", ")", ",", "firstValues", "(", "encryptArgs", ".", "ToValues", "(", ")", ")", "}", "\n\n", "// Post the per-user-secret encrypted for the provisionee device by the provisioner.", "if", "perUserKeyBox", "!=", "nil", "{", "libkb", ".", "AddPerUserKeyServerArg", "(", "payload", ",", "perUserKeyBox", ".", "Generation", ",", "[", "]", "keybase1", ".", "PerUserKeyBox", "{", "*", "perUserKeyBox", "}", ",", "nil", ")", "\n", "}", "\n\n", "libkb", ".", "AddUserEKReBoxServerArg", "(", "payload", ",", "reboxArg", ")", "\n\n", "mctx", ":=", "e", ".", "mctx", ".", "WithAPITokener", "(", "e", ")", "\n", "arg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "JSONPayload", ":", "payload", ",", "}", "\n", "// MerkleCheckPostedUserSig was not added here. Changing kex2 is risky and there's no obvious attack.", "_", ",", "err", ":=", "e", ".", "G", "(", ")", ".", "API", ".", "PostJSON", "(", "mctx", ",", "arg", ")", "\n", "return", "err", "\n", "}" ]

[ "postSigs", "takes", "the", "HTTP", "args", "for", "the", "signing", "key", "and", "encrypt", "key", "and", "posts", "them", "to", "the", "api", "server", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "saveKeys", "(", "m", "libkb", ".", "MetaContext", ")", "error", "{", "_", ",", "err", ":=", "libkb", ".", "WriteLksSKBToKeyring", "(", "m", ",", "e", ".", "eddsa", ",", "e", ".", "lks", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "_", ",", "err", "=", "libkb", ".", "WriteLksSKBToKeyring", "(", "m", ",", "e", ".", "dh", ",", "e", ".", "lks", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "saveKeys", "writes", "the", "device", "keys", "to", "LKSec", "." ]

[ "func", "(", "e", "*", "Kex2Provisionee", ")", "saveConfig", "(", "m", "libkb", ".", "MetaContext", ",", "uv", "keybase1", ".", "UserVersion", ")", "(", "err", "error", ")", "{", "defer", "m", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "if", "e", ".", "eddsa", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "e", ".", "dh", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "deviceName", "string", "\n", "if", "e", ".", "device", ".", "Description", "!=", "nil", "{", "deviceName", "=", "*", "e", ".", "device", ".", "Description", "\n", "}", "\n\n", "return", "m", ".", "SwitchUserNewConfigActiveDevice", "(", "uv", ",", "libkb", ".", "NewNormalizedUsername", "(", "e", ".", "username", ")", ",", "e", ".", "salt", ",", "e", ".", "device", ".", "ID", ",", "e", ".", "eddsa", ",", "e", ".", "dh", ",", "deviceName", ")", "\n", "}" ]

[ "cacheKeys", "caches", "the", "device", "keys", "in", "the", "Account", "object", "." ]

[ "func", "(", "p", "*", "Paragraph", ")", "Buffer", "(", "b", "[", "]", "byte", ")", "{", "p", ".", "data", "=", "append", "(", "p", ".", "data", ",", "b", "...", ")", "\n", "}" ]

[ "Buffer", "adds", "data", "to", "the", "internal", "paragraph", "buffer", "." ]

[ "func", "makePad", "(", "l", "int", ")", "[", "]", "byte", "{", "ret", ":=", "make", "(", "[", "]", "byte", ",", "l", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "l", ";", "i", "++", "{", "ret", "[", "i", "]", "=", "' '", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "makePad", "makes", "a", "whitespace", "pad", "that", "is", "l", "bytes", "long", "." ]

[ "func", "spacify", "(", "s", "string", ")", "string", "{", "v", ":=", "spaceRE", ".", "Split", "(", "s", ",", "-", "1", ")", "\n", "if", "len", "(", "v", ")", ">", "0", "&&", "v", "[", "0", "]", "==", "\"", "\"", "{", "v", "=", "v", "[", "1", ":", "]", "\n", "}", "\n", "l", ":=", "len", "(", "v", ")", "\n", "if", "l", ">", "0", "&&", "v", "[", "l", "-", "1", "]", "==", "\"", "\"", "{", "v", "=", "v", "[", "0", ":", "(", "l", "-", "1", ")", "]", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "v", ",", "\"", "\"", ")", "\n", "}" ]

[ "specify", "replaces", "arbitrary", "strings", "of", "whitespace", "with", "a", "single", "character", ".", "Also", "strips", "off", "leading", "and", "trailing", "whitespace", "." ]

[ "func", "(", "p", "Paragraph", ")", "Output", "(", "out", "io", ".", "Writer", ")", "{", "s", ":=", "[", "]", "byte", "(", "spacify", "(", "string", "(", "p", ".", "data", ")", ")", ")", "\n", "if", "len", "(", "s", ")", "==", "0", "{", "out", ".", "Write", "(", "nl", ")", "\n", "return", "\n", "}", "\n", "indent", ":=", "p", ".", "indent", "*", "INDENT", "\n", "width", ":=", "p", ".", "cols", "-", "indent", "-", "len", "(", "p", ".", "prefix", ")", "\n", "wrapped", ":=", "text", ".", "WrapBytes", "(", "s", ",", "width", ")", "\n", "lines", ":=", "bytes", ".", "Split", "(", "wrapped", ",", "nl", ")", "\n", "gutter", ":=", "makePad", "(", "indent", ")", "\n", "pad", ":=", "makePad", "(", "len", "(", "p", ".", "prefix", ")", ")", "\n\n", "for", "i", ",", "line", ":=", "range", "lines", "{", "out", ".", "Write", "(", "gutter", ")", "\n", "if", "i", "==", "0", "{", "out", ".", "Write", "(", "[", "]", "byte", "(", "p", ".", "prefix", ")", ")", "\n", "}", "else", "{", "out", ".", "Write", "(", "pad", ")", "\n", "}", "\n", "out", ".", "Write", "(", "line", ")", "\n", "out", ".", "Write", "(", "nl", ")", "\n", "}", "\n", "}" ]

[ "Output", "a", "paragraph", "to", "the", "io", ".", "Writer", "applying", "the", "proper", "formatting", "." ]

[ "func", "NewTlfEditHistoryFile", "(", "folder", "*", "Folder", ")", "*", "SpecialReadFile", "{", "return", "&", "SpecialReadFile", "{", "read", ":", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "libfs", ".", "GetEncodedTlfEditHistory", "(", "ctx", ",", "folder", ".", "fs", ".", "config", ",", "folder", ".", "getFolderBranch", "(", ")", ")", "\n", "}", ",", "fs", ":", "folder", ".", "fs", ",", "}", "\n", "}" ]

[ "NewTlfEditHistoryFile", "returns", "a", "special", "read", "file", "that", "contains", "a", "text", "representation", "of", "the", "file", "edit", "history", "for", "that", "TLF", "." ]

[ "func", "annotateResolvingRequest", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "req", "*", "chatConversationResolvingRequest", ")", "(", "err", "error", ")", "{", "userOrTeamResult", ",", "err", ":=", "CheckUserOrTeamName", "(", "context", ".", "TODO", "(", ")", ",", "g", ",", "req", ".", "TlfName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "switch", "userOrTeamResult", "{", "case", "keybase1", ".", "UserOrTeamResult_USER", ":", "if", "g", ".", "Env", ".", "GetChatMemberType", "(", ")", "==", "\"", "\"", "{", "req", ".", "MembersType", "=", "chat1", ".", "ConversationMembersType_IMPTEAMNATIVE", "\n", "}", "else", "{", "req", ".", "MembersType", "=", "chat1", ".", "ConversationMembersType_KBFS", "\n", "}", "\n", "case", "keybase1", ".", "UserOrTeamResult_TEAM", ":", "req", ".", "MembersType", "=", "chat1", ".", "ConversationMembersType_TEAM", "\n", "}", "\n", "if", "req", ".", "TopicType", "==", "chat1", ".", "TopicType_CHAT", "&&", "len", "(", "req", ".", "TopicName", ")", "!=", "0", "&&", "req", ".", "MembersType", "!=", "chat1", ".", "ConversationMembersType_TEAM", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Set the default topic name to #general if none is specified", "if", "req", ".", "MembersType", "==", "chat1", ".", "ConversationMembersType_TEAM", "&&", "len", "(", "req", ".", "TopicName", ")", "==", "0", "{", "req", ".", "TopicName", "=", "globals", ".", "DefaultTeamTopic", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "The", "purpose", "of", "this", "function", "is", "to", "provide", "more", "information", "in", "resolvingRequest", "with", "the", "ability", "to", "use", "the", "socket", "since", "this", "is", "not", "available", "at", "parse", "time", "." ]

[ "func", "(", "c", "*", "CmdChatSetRetention", ")", "showNonTeamConv", "(", "conv", "*", "chat1", ".", "ConversationLocal", ")", "{", "dui", ":=", "c", ".", "G", "(", ")", ".", "UI", ".", "GetDumbOutputUI", "(", ")", "\n", "if", "conv", ".", "TeamRetention", "!=", "nil", "{", "c", ".", "println", "(", "dui", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n", "policy", ":=", "chat1", ".", "RetentionPolicy", "{", "}", "\n", "if", "conv", ".", "ConvRetention", "!=", "nil", "{", "policy", "=", "*", "conv", ".", "ConvRetention", "\n", "}", "\n", "c", ".", "println", "(", "dui", ",", "policy", ".", "HumanSummary", "(", ")", ")", "\n", "}" ]

[ "Show", "a", "non", "-", "team", "conv", "policy" ]

[ "func", "(", "c", "*", "CmdChatSetRetention", ")", "showTeamChannelHTeam", "(", "conv", "*", "chat1", ".", "ConversationLocal", ")", "{", "dui", ":=", "c", ".", "G", "(", ")", ".", "UI", ".", "GetDumbOutputUI", "(", ")", "\n", "policy", ":=", "chat1", ".", "RetentionPolicy", "{", "}", "\n", "if", "conv", ".", "TeamRetention", "!=", "nil", "{", "policy", "=", "*", "conv", ".", "TeamRetention", "\n", "}", "\n", "c", ".", "println", "(", "dui", ",", "\"", "\"", ",", "policy", ".", "HumanSummary", "(", ")", ")", "\n", "}" ]

[ "Show", "the", "team", "policy" ]

[ "func", "(", "c", "*", "CmdChatSetRetention", ")", "showTeamChannelHChannel", "(", "conv", "*", "chat1", ".", "ConversationLocal", ")", "{", "dui", ":=", "c", ".", "G", "(", ")", ".", "UI", ".", "GetDumbOutputUI", "(", ")", "\n", "policy", ":=", "chat1", ".", "RetentionPolicy", "{", "}", "\n", "if", "conv", ".", "ConvRetention", "!=", "nil", "{", "policy", "=", "*", "conv", ".", "ConvRetention", "\n", "}", "\n", "typ", ",", "err", ":=", "policy", ".", "Typ", "(", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "println", "(", "dui", ",", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "var", "description", "string", "\n", "switch", "typ", "{", "case", "chat1", ".", "RetentionPolicyType_NONE", ",", "chat1", ".", "RetentionPolicyType_INHERIT", ":", "description", "=", "\"", "\"", "\n", "default", ":", "description", "=", "policy", ".", "HumanSummary", "(", ")", "\n", "}", "\n", "c", ".", "println", "(", "dui", ",", "\"", "\"", ",", "conv", ".", "Info", ".", "TopicName", ",", "description", ")", "\n", "}" ]

[ "Show", "the", "channel", "s", "policy" ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "GetWithLifetime", "(", "ptr", "BlockPointer", ")", "(", "Block", ",", "BlockCacheLifetime", ",", "error", ")", "{", "if", "b", ".", "cleanTransient", "!=", "nil", "{", "if", "tmp", ",", "ok", ":=", "b", ".", "cleanTransient", ".", "Get", "(", "ptr", ".", "ID", ")", ";", "ok", "{", "block", ",", "ok", ":=", "tmp", ".", "(", "Block", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "NoCacheEntry", ",", "BadDataError", "{", "ptr", ".", "ID", "}", "\n", "}", "\n", "return", "block", ",", "TransientEntry", ",", "nil", "\n", "}", "\n", "}", "\n\n", "block", ":=", "func", "(", ")", "Block", "{", "b", ".", "cleanLock", ".", "RLock", "(", ")", "\n", "defer", "b", ".", "cleanLock", ".", "RUnlock", "(", ")", "\n", "return", "b", ".", "cleanPermanent", "[", "ptr", ".", "ID", "]", "\n", "}", "(", ")", "\n", "if", "block", "!=", "nil", "{", "return", "block", ",", "PermanentEntry", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "NoCacheEntry", ",", "NoSuchBlockError", "{", "ptr", ".", "ID", "}", "\n", "}" ]

[ "GetWithLifetime", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "Get", "(", "ptr", "BlockPointer", ")", "(", "Block", ",", "error", ")", "{", "block", ",", "_", ",", "err", ":=", "b", ".", "GetWithLifetime", "(", "ptr", ")", "\n", "return", "block", ",", "err", "\n", "}" ]

[ "Get", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "CheckForKnownPtr", "(", "tlf", "tlf", ".", "ID", ",", "block", "*", "FileBlock", ")", "(", "BlockPointer", ",", "error", ")", "{", "if", "block", ".", "IsInd", "{", "return", "BlockPointer", "{", "}", ",", "NotDirectFileBlockError", "{", "}", "\n", "}", "\n\n", "if", "b", ".", "ids", "==", "nil", "{", "return", "BlockPointer", "{", "}", ",", "nil", "\n", "}", "\n\n", "key", ":=", "idCacheKey", "{", "tlf", ",", "block", ".", "GetHash", "(", ")", "}", "\n", "tmp", ",", "ok", ":=", "b", ".", "ids", ".", "Get", "(", "key", ")", "\n", "if", "!", "ok", "{", "return", "BlockPointer", "{", "}", ",", "nil", "\n", "}", "\n\n", "ptr", ",", "ok", ":=", "tmp", ".", "(", "BlockPointer", ")", "\n", "if", "!", "ok", "{", "return", "BlockPointer", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tmp", ")", "\n", "}", "\n", "return", "ptr", ",", "nil", "\n", "}" ]

[ "CheckForKnownPtr", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "SetCleanBytesCapacity", "(", "capacity", "uint64", ")", "{", "atomic", ".", "StoreUint64", "(", "&", "b", ".", "cleanBytesCapacity", ",", "capacity", ")", "\n", "}" ]

[ "SetCleanBytesCapacity", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "Put", "(", "ptr", "BlockPointer", ",", "tlf", "tlf", ".", "ID", ",", "block", "Block", ",", "lifetime", "BlockCacheLifetime", ",", "hashBehavior", "BlockCacheHashBehavior", ")", "error", "{", "// We first check if the block shouldn't be cached, since CommonBlocks can", "// take this path.", "if", "lifetime", "==", "NoCacheEntry", "{", "return", "nil", "\n", "}", "\n", "// Just in case we tried to cache a block type that shouldn't be cached,", "// return an error. This is an insurance check. That said, this got rid of", "// a flake in TestSBSConflicts, so we should still look for the underlying", "// error.", "switch", "block", ".", "(", "type", ")", "{", "case", "*", "DirBlock", ":", "case", "*", "FileBlock", ":", "case", "*", "CommonBlock", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "default", ":", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "block", ")", "\n", "}", "\n\n", "var", "wasInCache", "bool", "\n\n", "switch", "lifetime", "{", "case", "TransientEntry", ":", "// If it's the right type of block, store the hash -> ID mapping.", "if", "fBlock", ",", "isFileBlock", ":=", "block", ".", "(", "*", "FileBlock", ")", ";", "b", ".", "ids", "!=", "nil", "&&", "isFileBlock", "&&", "!", "fBlock", ".", "IsInd", "&&", "hashBehavior", "==", "DoCacheHash", "{", "key", ":=", "idCacheKey", "{", "tlf", ",", "fBlock", ".", "GetHash", "(", ")", "}", "\n", "// zero out the refnonce, it doesn't matter", "ptr", ".", "RefNonce", "=", "kbfsblock", ".", "ZeroRefNonce", "\n", "b", ".", "ids", ".", "Add", "(", "key", ",", "ptr", ")", "\n", "}", "\n", "if", "b", ".", "cleanTransient", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "// We could use `cleanTransient.Contains()`, but that wouldn't update", "// the LRU time. By using `Get`, we make it less likely that another", "// goroutine will evict this block before we can `Put` it again.", "_", ",", "wasInCache", "=", "b", ".", "cleanTransient", ".", "Get", "(", "ptr", ".", "ID", ")", "\n", "// Cache it later, once we know there's room", "case", "PermanentEntry", ":", "if", "hashBehavior", "!=", "SkipCacheHash", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "func", "(", ")", "{", "b", ".", "cleanLock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "cleanLock", ".", "Unlock", "(", ")", "\n", "_", ",", "wasInCache", "=", "b", ".", "cleanPermanent", "[", "ptr", ".", "ID", "]", "\n", "b", ".", "cleanPermanent", "[", "ptr", ".", "ID", "]", "=", "block", "\n", "}", "(", ")", "\n\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "lifetime", ")", "\n", "}", "\n\n", "transientCacheHasRoom", ":=", "true", "\n", "// We must make room whether the cache is transient or permanent, but only", "// if it wasn't already in the cache.", "// TODO: This is racy, where another goroutine can evict or add this block", "// between our check above and our attempt to make room. If the other", "// goroutine evicts this block, we under-count its size as 0. If the other", "// goroutine inserts this block, we double-count it.", "if", "!", "wasInCache", "{", "size", ":=", "uint64", "(", "getCachedBlockSize", "(", "block", ")", ")", "\n", "transientCacheHasRoom", "=", "b", ".", "makeRoomForSize", "(", "size", ",", "lifetime", ")", "\n", "}", "\n", "if", "lifetime", "==", "TransientEntry", "{", "if", "!", "transientCacheHasRoom", "{", "return", "CachePutCacheFullError", "{", "ptr", ".", "ID", "}", "\n", "}", "\n", "b", ".", "cleanTransient", ".", "Add", "(", "ptr", ".", "ID", ",", "block", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Put", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", ".", "This", "method", "is", "idempotent", "for", "a", "given", "ptr", "but", "that", "invariant", "is", "not", "currently", "goroutine", "-", "safe", "and", "it", "does", "not", "hold", "if", "a", "block", "size", "changes", "between", "Puts", ".", "That", "is", "we", "assume", "that", "a", "cached", "block", "associated", "with", "a", "given", "pointer", "will", "never", "change", "its", "size", "even", "when", "it", "gets", "Put", "into", "the", "cache", "again", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "DeletePermanent", "(", "id", "kbfsblock", ".", "ID", ")", "error", "{", "b", ".", "cleanLock", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "cleanLock", ".", "Unlock", "(", ")", "\n", "block", ",", "ok", ":=", "b", ".", "cleanPermanent", "[", "id", "]", "\n", "if", "ok", "{", "delete", "(", "b", ".", "cleanPermanent", ",", "id", ")", "\n", "b", ".", "subtractBlockBytes", "(", "block", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeletePermanent", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "DeleteTransient", "(", "id", "kbfsblock", ".", "ID", ",", "tlf", "tlf", ".", "ID", ")", "error", "{", "if", "b", ".", "cleanTransient", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// If the block is cached and a file block, delete the known", "// pointer as well.", "if", "tmp", ",", "ok", ":=", "b", ".", "cleanTransient", ".", "Get", "(", "id", ")", ";", "ok", "{", "block", ",", "ok", ":=", "tmp", ".", "(", "Block", ")", "\n", "if", "!", "ok", "{", "return", "BadDataError", "{", "id", "}", "\n", "}", "\n\n", "// Remove the key if it exists", "if", "fBlock", ",", "ok", ":=", "block", ".", "(", "*", "FileBlock", ")", ";", "b", ".", "ids", "!=", "nil", "&&", "ok", "&&", "!", "fBlock", ".", "IsInd", "{", "_", ",", "hash", ":=", "kbfshash", ".", "DoRawDefaultHash", "(", "fBlock", ".", "Contents", ")", "\n", "key", ":=", "idCacheKey", "{", "tlf", ",", "hash", "}", "\n", "b", ".", "ids", ".", "Remove", "(", "key", ")", "\n", "}", "\n\n", "b", ".", "cleanTransient", ".", "Remove", "(", "id", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteTransient", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "b", "*", "BlockCacheStandard", ")", "DeleteKnownPtr", "(", "tlf", "tlf", ".", "ID", ",", "block", "*", "FileBlock", ")", "error", "{", "if", "block", ".", "IsInd", "{", "return", "NotDirectFileBlockError", "{", "}", "\n", "}", "\n\n", "if", "b", ".", "ids", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "_", ",", "hash", ":=", "kbfshash", ".", "DoRawDefaultHash", "(", "block", ".", "Contents", ")", "\n", "key", ":=", "idCacheKey", "{", "tlf", ",", "hash", "}", "\n", "b", ".", "ids", ".", "Remove", "(", "key", ")", "\n", "return", "nil", "\n", "}" ]

[ "DeleteKnownPtr", "implements", "the", "BlockCache", "interface", "for", "BlockCacheStandard", "." ]

[ "func", "(", "e", "*", "PaperProvisionEngine", ")", "fetchLKS", "(", "m", "libkb", ".", "MetaContext", ",", "encKey", "libkb", ".", "GenericKey", ")", "error", "{", "gen", ",", "clientLKS", ",", "err", ":=", "fetchLKS", "(", "m", ",", "encKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "e", ".", "lks", "=", "libkb", ".", "NewLKSecWithClientHalf", "(", "clientLKS", ",", "gen", ",", "e", ".", "User", ".", "GetUID", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "copied", "from", "loginProvision" ]

[ "func", "(", "e", "*", "PaperProvisionEngine", ")", "makeDeviceKeysWithSigner", "(", "m", "libkb", ".", "MetaContext", ",", "signer", "libkb", ".", "GenericKey", ")", "error", "{", "args", ",", "err", ":=", "e", ".", "makeDeviceWrapArgs", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "args", ".", "Signer", "=", "signer", "\n", "args", ".", "IsEldest", "=", "false", "// just to be explicit", "\n", "args", ".", "EldestKID", "=", "e", ".", "User", ".", "GetEldestKID", "(", ")", "\n\n", "return", "e", ".", "makeDeviceKeys", "(", "m", ",", "args", ")", "\n", "}" ]

[ "copied", "from", "loginProvision", "makeDeviceKeysWithSigner", "creates", "device", "keys", "given", "a", "signing", "key", "." ]

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

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

[ "func", "(", "e", "*", "PaperProvisionEngine", ")", "makeDeviceKeys", "(", "m", "libkb", ".", "MetaContext", ",", "args", "*", "DeviceWrapArgs", ")", "error", "{", "e", ".", "deviceWrapEng", "=", "NewDeviceWrap", "(", "m", ".", "G", "(", ")", ",", "args", ")", "\n", "return", "RunEngine2", "(", "m", ",", "e", ".", "deviceWrapEng", ")", "\n", "}" ]

[ "Copied", "from", "loginProvision", ".", "makeDeviceKeys", "uses", "DeviceWrap", "to", "generate", "device", "keys", "and", "sets", "active", "device", "." ]

[ "func", "Start", "(", "ctx", "context", ".", "Context", ",", "options", "StartOptions", ",", "kbCtx", "libkbfs", ".", "Context", ",", "defaultLogPath", "string", ",", "input", "io", ".", "Reader", ",", "output", "io", ".", "Writer", ",", "errput", "io", ".", "Writer", ")", "*", "libfs", ".", "Error", "{", "// Ideally we wouldn't print this if the verbosity is 0, but we", "// don't know that until we start parsing options. TODO: get rid", "// of this once we integrate with the kbfs daemon.", "errput", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "ctx", ",", "config", ",", "err", ":=", "libgit", ".", "Init", "(", "ctx", ",", "options", ".", "KbfsParams", ",", "kbCtx", ",", "nil", ",", "defaultLogPath", ",", "kbCtx", ".", "GetVDebugSetting", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "libfs", ".", "InitError", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "defer", "config", ".", "Shutdown", "(", "ctx", ")", "\n\n", "config", ".", "MakeLogger", "(", "\"", "\"", ")", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "options", ".", "Remote", ",", "options", ".", "Repo", ",", "options", ".", "KbfsParams", ".", "StorageRoot", ")", "\n", "errput", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ")", "\n\n", "r", ",", "err", ":=", "newRunner", "(", "ctx", ",", "config", ",", "options", ".", "Remote", ",", "options", ".", "Repo", ",", "options", ".", "GitDir", ",", "input", ",", "output", ",", "errput", ")", "\n", "if", "err", "!=", "nil", "{", "return", "libfs", ".", "InitError", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "errCh", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "func", "(", ")", "{", "errCh", "<-", "r", ".", "processCommands", "(", "ctx", ")", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "err", ":=", "<-", "errCh", ":", "if", "err", "!=", "nil", "{", "return", "libfs", ".", "InitError", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "libfs", ".", "InitError", "(", "ctx", ".", "Err", "(", ")", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "Start", "starts", "the", "kbfsgit", "logic", "and", "begins", "listening", "for", "git", "commands", "from", "input", "and", "responding", "to", "them", "via", "output", "." ]

[ "func", "(", "e", "TlfNameNotCanonical", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "Name", ",", "e", ".", "NameToTry", ")", "\n", "}" ]

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

[ "func", "safeWriteToFileOnce", "(", "g", "SafeWriteLogger", ",", "t", "SafeWriter", ",", "mode", "os", ".", "FileMode", ")", "(", "err", "error", ")", "{", "fn", ":=", "t", ".", "GetFilename", "(", ")", "\n", "g", ".", "Debug", "(", "\"", "\"", ",", "fn", ")", "\n", "defer", "func", "(", ")", "{", "g", ".", "Debug", "(", "\"", "\"", ",", "fn", ",", "ErrToOk", "(", "err", ")", ")", "\n", "}", "(", ")", "\n\n", "tmpfn", ",", "tmp", ",", "err", ":=", "OpenTempFile", "(", "fn", ",", "\"", "\"", ",", "mode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "g", ".", "Debug", "(", "\"", "\"", ",", "tmpfn", ")", "\n", "defer", "tmp", ".", "Close", "(", ")", "\n", "defer", "ShredFile", "(", "tmpfn", ")", "\n\n", "g", ".", "Debug", "(", "\"", "\"", ",", "tmpfn", ")", "\n", "n", ",", "err", ":=", "t", ".", "WriteTo", "(", "tmp", ")", "\n", "if", "err", "!=", "nil", "{", "g", ".", "Errorf", "(", "\"", "\"", ",", "tmpfn", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "if", "n", "!=", "0", "{", "// unfortunately, some implementations always return 0 for the number", "// of bytes written, so not much info there, but will log it when", "// it isn't 0.", "g", ".", "Debug", "(", "\"", "\"", ",", "tmpfn", ",", "n", ")", "\n", "}", "\n\n", "if", "err", ":=", "tmp", ".", "Sync", "(", ")", ";", "err", "!=", "nil", "{", "g", ".", "Errorf", "(", "\"", "\"", ",", "tmpfn", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "tmp", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "g", ".", "Errorf", "(", "\"", "\"", ",", "tmpfn", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "g", ".", "Debug", "(", "\"", "\"", ",", "tmpfn", ",", "fn", ")", "\n", "if", "err", ":=", "os", ".", "Rename", "(", "tmpfn", ",", "fn", ")", ";", "err", "!=", "nil", "{", "g", ".", "Errorf", "(", "\"", "\"", ",", "tmpfn", ",", "fn", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "g", ".", "Debug", "(", "\"", "\"", ")", "\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "fn", ")", "\n", "if", "err", "!=", "nil", "{", "g", ".", "Errorf", "(", "\"", "\"", ",", "fn", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "g", ".", "Debug", "(", "\"", "\"", ",", "info", ".", "Name", "(", ")", ")", "\n", "g", ".", "Debug", "(", "\"", "\"", ",", "info", ".", "Size", "(", ")", ")", "\n", "g", ".", "Debug", "(", "\"", "\"", ",", "info", ".", "Mode", "(", ")", ")", "\n", "g", ".", "Debug", "(", "\"", "\"", ",", "info", ".", "ModTime", "(", ")", ")", "\n\n", "g", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "g", ".", "Debug", "(", "\"", "\"", ",", "fn", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "SafeWriteToFile", "to", "safely", "write", "to", "a", "file", ".", "Use", "mode", "=", "0", "for", "default", "permissions", "." ]

[ "func", "Contains", "(", "s", "string", ",", "list", "[", "]", "string", ")", "bool", "{", "return", "IsIn", "(", "s", ",", "list", ",", "false", ")", "\n", "}" ]

[ "Contains", "returns", "true", "if", "string", "is", "contained", "in", "string", "slice" ]

[ "func", "IsIn", "(", "needle", "string", ",", "haystack", "[", "]", "string", ",", "ci", "bool", ")", "bool", "{", "for", "_", ",", "h", ":=", "range", "haystack", "{", "if", "(", "ci", "&&", "Cicmp", "(", "h", ",", "needle", ")", ")", "||", "(", "!", "ci", "&&", "h", "==", "needle", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsIn", "checks", "for", "needle", "in", "haystack", "ci", "means", "case", "-", "insensitive", "." ]

[ "func", "IsPossiblePhoneNumber", "(", "phone", "keybase1", ".", "PhoneNumber", ")", "error", "{", "if", "!", "phoneRE", ".", "MatchString", "(", "string", "(", "phone", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "IsPossiblePhoneNumber", "checks", "if", "s", "is", "string", "of", "digits", "in", "phone", "number", "format" ]

[ "func", "MakeURI", "(", "prot", "string", ",", "host", "string", ")", "string", "{", "if", "prot", "==", "\"", "\"", "{", "return", "host", "\n", "}", "\n", "if", "prot", "[", "len", "(", "prot", ")", "-", "1", "]", "!=", "':'", "{", "prot", "+=", "\"", "\"", "\n", "}", "\n", "return", "prot", "+", "\"", "\"", "+", "host", "\n", "}" ]

[ "MakeURI", "makes", "a", "URI", "string", "out", "of", "the", "given", "protocol", "and", "host", "strings", "adding", "necessary", "punctuation", "in", "between", "." ]

[ "func", "RemoveNilErrors", "(", "errs", "[", "]", "error", ")", "[", "]", "error", "{", "var", "r", "[", "]", "error", "\n", "for", "_", ",", "err", ":=", "range", "errs", "{", "if", "err", "!=", "nil", "{", "r", "=", "append", "(", "r", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "r", "\n", "}" ]

[ "RemoveNilErrors", "returns", "error", "slice", "with", "ni", "errors", "removed", "." ]

[ "func", "CombineErrors", "(", "errs", "...", "error", ")", "error", "{", "errs", "=", "RemoveNilErrors", "(", "errs", ")", "\n", "if", "len", "(", "errs", ")", "==", "0", "{", "return", "nil", "\n", "}", "else", "if", "len", "(", "errs", ")", "==", "1", "{", "return", "errs", "[", "0", "]", "\n", "}", "\n\n", "msgs", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "err", ":=", "range", "errs", "{", "msgs", "=", "append", "(", "msgs", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "msgs", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "CombineErrors", "returns", "a", "single", "error", "for", "multiple", "errors", "or", "nil", "if", "none", "." ]

[ "func", "SplitByRunes", "(", "s", "string", ",", "separators", "[", "]", "rune", ")", "[", "]", "string", "{", "f", ":=", "func", "(", "r", "rune", ")", "bool", "{", "for", "_", ",", "s", ":=", "range", "separators", "{", "if", "r", "==", "s", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "return", "strings", ".", "FieldsFunc", "(", "s", ",", "f", ")", "\n", "}" ]

[ "SplitByRunes", "splits", "string", "by", "runes" ]

[ "func", "DigestForFileAtPath", "(", "path", "string", ")", "(", "string", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "return", "Digest", "(", "f", ")", "\n", "}" ]

[ "DigestForFileAtPath", "returns", "a", "SHA256", "digest", "for", "file", "at", "specified", "path" ]

[ "func", "Digest", "(", "r", "io", ".", "Reader", ")", "(", "string", ",", "error", ")", "{", "hasher", ":=", "sha256", ".", "New", "(", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "hasher", ",", "r", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "digest", ":=", "hex", ".", "EncodeToString", "(", "hasher", ".", "Sum", "(", "nil", ")", ")", "\n", "return", "digest", ",", "nil", "\n", "}" ]

[ "Digest", "returns", "a", "SHA256", "digest" ]

[ "func", "JoinPredicate", "(", "arr", "[", "]", "string", ",", "delimeter", "string", ",", "f", "func", "(", "s", "string", ")", "bool", ")", "string", "{", "arrNew", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "arr", ")", ")", "\n", "for", "_", ",", "s", ":=", "range", "arr", "{", "if", "f", "(", "s", ")", "{", "arrNew", "=", "append", "(", "arrNew", ",", "s", ")", "\n", "}", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "arrNew", ",", "delimeter", ")", "\n", "}" ]

[ "JoinPredicate", "joins", "strings", "with", "predicate" ]

[ "func", "LogTagsFromContext", "(", "ctx", "context", ".", "Context", ")", "(", "map", "[", "interface", "{", "}", "]", "string", ",", "bool", ")", "{", "tags", ",", "ok", ":=", "logger", ".", "LogTagsFromContext", "(", "ctx", ")", "\n", "return", "map", "[", "interface", "{", "}", "]", "string", "(", "tags", ")", ",", "ok", "\n", "}" ]

[ "LogTagsFromContext", "is", "a", "wrapper", "around", "logger", ".", "LogTagsFromContext", "that", "simply", "casts", "the", "result", "to", "the", "type", "expected", "by", "rpc", ".", "Connection", "." ]

[ "func", "MobilePermissionDeniedCheck", "(", "g", "*", "GlobalContext", ",", "err", "error", ",", "msg", "string", ")", "{", "if", "!", "os", ".", "IsPermission", "(", "err", ")", "{", "return", "\n", "}", "\n", "if", "g", ".", "GetAppType", "(", ")", "!=", "MobileAppType", "{", "return", "\n", "}", "\n", "g", ".", "Log", ".", "Warning", "(", "\"", "\"", ",", "msg", ",", "err", ")", "\n", "os", ".", "Exit", "(", "4", ")", "\n", "}" ]

[ "MobilePermissionDeniedCheck", "panics", "if", "err", "is", "a", "permission", "denied", "error", "and", "if", "app", "is", "a", "mobile", "app", ".", "This", "has", "caused", "issues", "opening", "config", ".", "json", "and", "secretkeys", "files", "where", "it", "seems", "to", "be", "stuck", "in", "a", "permission", "denied", "state", "and", "force", "-", "killing", "the", "app", "is", "the", "only", "option", "." ]

[ "func", "IsNoSpaceOnDeviceError", "(", "err", "error", ")", "bool", "{", "if", "err", "==", "nil", "{", "return", "false", "\n", "}", "\n", "switch", "err", ":=", "err", ".", "(", "type", ")", "{", "case", "NoSpaceOnDeviceError", ":", "return", "true", "\n", "case", "*", "os", ".", "PathError", ":", "return", "err", ".", "Err", "==", "syscall", ".", "ENOSPC", "\n", "case", "*", "os", ".", "LinkError", ":", "return", "err", ".", "Err", "==", "syscall", ".", "ENOSPC", "\n", "case", "*", "os", ".", "SyscallError", ":", "return", "err", ".", "Err", "==", "syscall", ".", "ENOSPC", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "IsNoSpaceOnDeviceError", "will", "return", "true", "if", "err", "is", "an", "os", "error", "for", "no", "space", "left", "on", "device", "." ]

[ "func", "AcquireWithTimeout", "(", "lock", "sync", ".", "Locker", ",", "timeout", "time", ".", "Duration", ")", "(", "err", "error", ")", "{", "ctx2", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "timeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "return", "AcquireWithContext", "(", "ctx2", ",", "lock", ")", "\n", "}" ]

[ "AcquireWithTimeout", "attempts", "to", "acquire", "a", "lock", "with", "a", "timeout", ".", "Convenience", "wrapper", "around", "AcquireWithContext", ".", "Returns", "nil", "if", "the", "lock", "was", "acquired", ".", "Returns", "context", ".", "DeadlineExceeded", "if", "it", "was", "not", "." ]

[ "func", "DirSize", "(", "dirPath", "string", ")", "(", "size", "uint64", ",", "numFiles", "int", ",", "err", "error", ")", "{", "err", "=", "filepath", ".", "Walk", "(", "dirPath", ",", "func", "(", "_", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "info", ".", "IsDir", "(", ")", "{", "size", "+=", "uint64", "(", "info", ".", "Size", "(", ")", ")", "\n", "numFiles", "++", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "size", ",", "numFiles", ",", "err", "\n", "}" ]

[ "DirSize", "walks", "the", "file", "tree", "the", "size", "of", "the", "given", "directory" ]

[ "func", "NewProofInfo", "(", "link", "libkb", ".", "RemoteProofChainLink", ",", "h", "libkb", ".", "SigHint", ")", "ProofInfo", "{", "return", "ProofInfo", "{", "ArmoredSig", ":", "link", ".", "GetArmoredSig", "(", ")", ",", "RemoteUsername", ":", "link", ".", "GetRemoteUsername", "(", ")", ",", "Username", ":", "link", ".", "GetUsername", "(", ")", ",", "Hostname", ":", "link", ".", "GetHostname", "(", ")", ",", "Protocol", ":", "link", ".", "GetProtocol", "(", ")", ",", "APIURL", ":", "h", ".", "GetAPIURL", "(", ")", ",", "}", "\n", "}" ]

[ "NewProofInfo", "creates", "a", "new", "ProofInfo" ]

[ "func", "CheckProof", "(", "m", "libkb", ".", "MetaContext", ",", "pvlS", "string", ",", "service", "keybase1", ".", "ProofType", ",", "info", "ProofInfo", ")", "libkb", ".", "ProofError", "{", "m1", ":=", "newMetaContext", "(", "m", ",", "info", ".", "stubDNS", ")", "\n", "perr", ":=", "checkProofInner", "(", "m1", ",", "pvlS", ",", "service", ",", "info", ")", "\n", "if", "perr", "!=", "nil", "{", "debug", "(", "m1", ",", "\"", "\"", ",", "perr", ")", "\n", "}", "\n", "if", "perr", "!=", "nil", "&&", "perr", ".", "GetProofStatus", "(", ")", "==", "keybase1", ".", "ProofStatus_INVALID_PVL", "{", "return", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "perr", "\n", "}" ]

[ "CheckProof", "verifies", "one", "proof", "by", "running", "the", "pvl", "on", "the", "provided", "proof", "information", "." ]

[ "func", "chunkGetScripts", "(", "pvl", "*", "pvlT", ",", "service", "keybase1", ".", "ProofType", ")", "(", "[", "]", "scriptT", ",", "libkb", ".", "ProofError", ")", "{", "scripts", ",", "ok", ":=", "pvl", ".", "Services", ".", "Map", "[", "service", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "service", ")", "\n", "}", "\n", "return", "scripts", ",", "nil", "\n", "}" ]

[ "Get", "the", "list", "of", "scripts", "for", "a", "given", "service", "." ]

[ "func", "validateChunk", "(", "m", "metaContext", ",", "pvl", "*", "pvlT", ",", "service", "keybase1", ".", "ProofType", ")", "libkb", ".", "ProofError", "{", "if", "pvl", ".", "PvlVersion", "!=", "SupportedVersion", "{", "return", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "pvl", ".", "PvlVersion", ",", "SupportedVersion", ")", "\n", "}", "\n\n", "debug", "(", "m", ",", "\"", "\"", ",", "pvl", ".", "PvlVersion", ",", "pvl", ".", "Revision", ")", "\n\n", "scripts", ",", "perr", ":=", "chunkGetScripts", "(", "pvl", ",", "service", ")", "\n", "if", "perr", "!=", "nil", "{", "return", "perr", "\n", "}", "\n", "if", "len", "(", "scripts", ")", "==", "0", "{", "return", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "service", ")", "\n", "}", "\n\n", "// Scan all the scripts (for this service) for errors. Report the first error.", "var", "errs", "[", "]", "libkb", ".", "ProofError", "\n", "for", "whichscript", ",", "script", ":=", "range", "scripts", "{", "perr", "=", "validateScript", "(", "m", ",", "&", "script", ",", "service", ",", "whichscript", ")", "\n", "errs", "=", "append", "(", "errs", ",", "perr", ")", "\n", "}", "\n", "return", "errs", "[", "0", "]", "\n", "}" ]

[ "Check", "that", "a", "chunk", "of", "PVL", "is", "valid", "code", ".", "Will", "always", "accept", "valid", "code", "but", "may", "not", "always", "notice", "invalidities", "." ]

[ "func", "runDNS", "(", "m", "metaContext", ",", "userdomain", "string", ",", "scripts", "[", "]", "scriptT", ",", "mknewstate", "stateMaker", ",", "sigIDMedium", "string", ")", "libkb", ".", "ProofError", "{", "domains", ":=", "[", "]", "string", "{", "userdomain", ",", "\"", "\"", "+", "userdomain", "}", "\n", "var", "errs", "[", "]", "libkb", ".", "ProofError", "\n", "for", "_", ",", "d", ":=", "range", "domains", "{", "debug", "(", "m", ",", "\"", "\"", ",", "d", ")", "\n\n", "err", ":=", "runDNSOne", "(", "m", ",", "d", ",", "scripts", ",", "mknewstate", ",", "sigIDMedium", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "}", "else", "{", "return", "nil", "\n", "}", "\n", "}", "\n\n", "// Return only the error for the first domain error", "if", "len", "(", "errs", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "var", "descs", "[", "]", "string", "\n", "for", "_", ",", "err", ":=", "range", "errs", "{", "descs", "=", "append", "(", "descs", ",", "err", ".", "GetDesc", "(", ")", ")", "\n", "}", "\n", "// Use the code from the first error", "return", "libkb", ".", "NewProofError", "(", "errs", "[", "0", "]", ".", "GetProofStatus", "(", ")", ",", "strings", ".", "Join", "(", "descs", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "Run", "each", "script", "on", "each", "TXT", "record", "of", "each", "domain", ".", "Succeed", "if", "any", "succeed", "." ]

[ "func", "runDNSOne", "(", "m", "metaContext", ",", "domain", "string", ",", "scripts", "[", "]", "scriptT", ",", "mknewstate", "stateMaker", ",", "sigIDMedium", "string", ")", "libkb", ".", "ProofError", "{", "// Fetch TXT records", "var", "txts", "[", "]", "string", "\n", "var", "err", "error", "\n", "if", "m", ".", "getStubDNS", "(", ")", "==", "nil", "{", "txts", ",", "err", "=", "runDNSTXTQuery", "(", "m", ",", "domain", ")", "\n", "}", "else", "{", "txts", ",", "err", "=", "m", ".", "getStubDNS", "(", ")", ".", "LookupTXT", "(", "domain", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_DNS_ERROR", ",", "\"", "\"", ",", "domain", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "record", ":=", "range", "txts", "{", "debug", "(", "m", ",", "\"", "\"", ",", "domain", ",", "record", ")", "\n\n", "// Try all scripts.", "for", "i", ",", "script", ":=", "range", "scripts", "{", "state", ",", "err", ":=", "mknewstate", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "state", ".", "Regs", ".", "Set", "(", "\"", "\"", ",", "record", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "runScript", "(", "m", ",", "&", "script", ",", "state", ")", ";", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Discard error, it has already been reported by stepInstruction.", "}", "\n", "}", "\n\n", "return", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_NOT_FOUND", ",", "\"", "\"", ",", "len", "(", "txts", ")", ",", "domain", ",", "sigIDMedium", ")", "\n", "}" ]

[ "Run", "each", "script", "on", "each", "TXT", "record", "of", "the", "domain", "." ]

[ "func", "stepInstruction", "(", "m", "metaContext", ",", "ins", "instructionT", ",", "state", "scriptState", ")", "(", "scriptState", ",", "libkb", ".", "ProofError", ")", "{", "debugWithState", "(", "m", ",", "state", ",", "\"", "\"", ",", "ins", ".", "Name", "(", ")", ",", "ins", ")", "\n\n", "var", "newState", "scriptState", "\n", "var", "stepErr", "libkb", ".", "ProofError", "\n", "var", "customErrSpec", "*", "errorT", "\n", "switch", "{", "case", "ins", ".", "AssertRegexMatch", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepAssertRegexMatch", "(", "m", ",", "*", "ins", ".", "AssertRegexMatch", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "AssertRegexMatch", ".", "Error", "\n", "case", "ins", ".", "AssertFindBase64", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepAssertFindBase64", "(", "m", ",", "*", "ins", ".", "AssertFindBase64", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "AssertFindBase64", ".", "Error", "\n", "case", "ins", ".", "AssertCompare", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepAssertCompare", "(", "m", ",", "*", "ins", ".", "AssertCompare", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "AssertCompare", ".", "Error", "\n", "case", "ins", ".", "WhitespaceNormalize", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepWhitespaceNormalize", "(", "m", ",", "*", "ins", ".", "WhitespaceNormalize", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "WhitespaceNormalize", ".", "Error", "\n", "case", "ins", ".", "RegexCapture", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepRegexCapture", "(", "m", ",", "*", "ins", ".", "RegexCapture", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "RegexCapture", ".", "Error", "\n", "case", "ins", ".", "ReplaceAll", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepReplaceAll", "(", "m", ",", "*", "ins", ".", "ReplaceAll", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "ReplaceAll", ".", "Error", "\n", "case", "ins", ".", "ParseURL", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepParseURL", "(", "m", ",", "*", "ins", ".", "ParseURL", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "ParseURL", ".", "Error", "\n", "case", "ins", ".", "Fetch", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepFetch", "(", "m", ",", "*", "ins", ".", "Fetch", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "Fetch", ".", "Error", "\n", "case", "ins", ".", "ParseHTML", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepParseHTML", "(", "m", ",", "*", "ins", ".", "ParseHTML", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "ParseHTML", ".", "Error", "\n", "case", "ins", ".", "SelectorJSON", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepSelectorJSON", "(", "m", ",", "*", "ins", ".", "SelectorJSON", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "SelectorJSON", ".", "Error", "\n", "case", "ins", ".", "SelectorCSS", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepSelectorCSS", "(", "m", ",", "*", "ins", ".", "SelectorCSS", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "SelectorCSS", ".", "Error", "\n", "case", "ins", ".", "Fill", "!=", "nil", ":", "newState", ",", "stepErr", "=", "stepFill", "(", "m", ",", "*", "ins", ".", "Fill", ",", "state", ")", "\n", "customErrSpec", "=", "ins", ".", "Fill", ".", "Error", "\n", "default", ":", "newState", "=", "state", "\n", "stepErr", "=", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "ins", ")", "\n", "}", "\n\n", "if", "stepErr", "!=", "nil", "{", "debugWithStateError", "(", "m", ",", "state", ",", "stepErr", ")", "\n", "stepErr", "=", "replaceCustomError", "(", "m", ",", "state", ",", "customErrSpec", ",", "stepErr", ")", "\n", "}", "\n", "return", "newState", ",", "stepErr", "\n\n", "}" ]

[ "stepInstruction", "decides", "which", "instruction", "to", "run", "." ]

[ "func", "interpretRegex", "(", "m", "metaContext", ",", "state", "scriptState", ",", "rdesc", "regexDescriptor", ")", "(", "*", "regexp", ".", "Regexp", ",", "libkb", ".", "ProofError", ")", "{", "// Check that regex is bounded by \"^\" and \"$\".", "if", "!", "strings", ".", "HasPrefix", "(", "rdesc", ".", "Template", ",", "\"", "\"", ")", "{", "return", "nil", ",", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "\"", "\"", ",", "rdesc", ".", "Template", ")", "\n", "}", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "rdesc", ".", "Template", ",", "\"", "\"", ")", "{", "return", "nil", ",", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "\"", "\"", ",", "rdesc", ".", "Template", ")", "\n", "}", "\n\n", "var", "optstring", "=", "\"", "\"", "\n", "if", "rdesc", ".", "CaseInsensitive", "{", "optstring", "+=", "\"", "\"", "\n", "}", "\n", "if", "rdesc", ".", "MultiLine", "{", "optstring", "+=", "\"", "\"", "\n", "}", "\n\n", "var", "prefix", "=", "\"", "\"", "\n", "if", "len", "(", "optstring", ")", ">", "0", "{", "prefix", "=", "\"", "\"", "+", "optstring", "+", "\"", "\"", "\n", "}", "\n\n", "// Do variable interpolation.", "prepattern", ",", "perr", ":=", "substituteReEscape", "(", "rdesc", ".", "Template", ",", "state", ")", "\n", "if", "perr", "!=", "nil", "{", "return", "nil", ",", "perr", "\n", "}", "\n", "pattern", ":=", "prefix", "+", "prepattern", "\n\n", "// Build the regex.", "re", ",", "err", ":=", "regexp", ".", "Compile", "(", "pattern", ")", "\n", "if", "err", "!=", "nil", "{", "debugWithState", "(", "m", ",", "state", ",", "\"", "\\n", "\\n", "\"", ",", "err", ",", "rdesc", ".", "Template", ",", "pattern", ")", "\n", "return", "nil", ",", "libkb", ".", "NewProofError", "(", "keybase1", ".", "ProofStatus_INVALID_PVL", ",", "\"", "\"", ",", "err", ",", "rdesc", ".", "Template", ")", "\n", "}", "\n", "return", "re", ",", "nil", "\n", "}" ]

[ "Take", "a", "regex", "descriptor", "do", "variable", "substitution", "and", "build", "a", "regex", "." ]

[ "func", "replaceCustomError", "(", "m", "metaContext", ",", "state", "scriptState", ",", "spec", "*", "errorT", ",", "err1", "libkb", ".", "ProofError", ")", "libkb", ".", "ProofError", "{", "if", "err1", "==", "nil", "{", "return", "err1", "\n", "}", "\n\n", "// Don't rewrite invalid_pvl errors", "if", "err1", ".", "GetProofStatus", "(", ")", "==", "keybase1", ".", "ProofStatus_INVALID_PVL", "{", "return", "err1", "\n", "}", "\n\n", "if", "spec", "==", "nil", "{", "return", "err1", "\n", "}", "\n\n", "if", "(", "spec", ".", "Status", "!=", "err1", ".", "GetProofStatus", "(", ")", ")", "||", "(", "spec", ".", "Description", "!=", "err1", ".", "GetDesc", "(", ")", ")", "{", "newDesc", ":=", "spec", ".", "Description", "\n", "subbedDesc", ",", "subErr", ":=", "substituteExact", "(", "spec", ".", "Description", ",", "state", ")", "\n", "if", "subErr", "==", "nil", "{", "newDesc", "=", "subbedDesc", "\n", "}", "\n", "err2", ":=", "libkb", ".", "NewProofError", "(", "spec", ".", "Status", ",", "newDesc", ")", "\n", "debugWithState", "(", "m", ",", "state", ",", "\"", "\"", ")", "\n", "debugWithStateError", "(", "m", ",", "state", ",", "err2", ")", "\n\n", "return", "err2", "\n", "}", "\n", "return", "err1", "\n", "}" ]

[ "Use", "a", "custom", "error", "spec", "to", "derive", "an", "error", ".", "spec", "can", "be", "none", "Copies", "over", "the", "error", "code", "if", "none", "is", "specified", "." ]

[ "func", "(", "f", "*", "ReclaimQuotaFile", ")", "Write", "(", "ctx", "context", ".", "Context", ",", "req", "*", "fuse", ".", "WriteRequest", ",", "resp", "*", "fuse", ".", "WriteResponse", ")", "(", "err", "error", ")", "{", "f", ".", "folder", ".", "fs", ".", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "func", "(", ")", "{", "err", "=", "f", ".", "folder", ".", "processError", "(", "ctx", ",", "libkbfs", ".", "WriteMode", ",", "err", ")", "}", "(", ")", "\n", "if", "len", "(", "req", ".", "Data", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "err", "=", "libkbfs", ".", "ForceQuotaReclamationForTesting", "(", "f", ".", "folder", ".", "fs", ".", "config", ",", "f", ".", "folder", ".", "getFolderBranch", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "resp", ".", "Size", "=", "len", "(", "req", ".", "Data", ")", "\n", "return", "nil", "\n", "}" ]

[ "Write", "implements", "the", "fs", ".", "HandleWriter", "interface", "for", "ReclaimQuotaFile", ".", "Note", "a", "write", "triggers", "quota", "reclamation", "but", "does", "not", "wait", "for", "it", "to", "finish", ".", "If", "you", "want", "to", "wait", "write", "to", "SyncFromServerFileName", "." ]

[ "func", "NewListTrackers", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "uid", "keybase1", ".", "UID", ")", "*", "ListTrackersEngine", "{", "return", "&", "ListTrackersEngine", "{", "uid", ":", "uid", ",", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "}", "\n", "}" ]

[ "NewListTrackers", "creates", "a", "TrackerList", "engine", "for", "uid", "." ]

[ "func", "(", "e", "*", "ListTrackersEngine", ")", "List", "(", ")", "[", "]", "libkb", ".", "Tracker", "{", "if", "e", ".", "trackers", "==", "nil", "{", "return", "[", "]", "libkb", ".", "Tracker", "{", "}", "\n", "}", "\n", "return", "e", ".", "trackers", ".", "Trackers", "\n", "}" ]

[ "List", "returns", "the", "array", "of", "trackers", "for", "this", "user", "." ]

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

[ "NewDeviceAdd", "creates", "a", "DeviceAdd", "engine", "." ]

[ "func", "EnableAdminFeature", "(", "ctx", "context", ".", "Context", ",", "runMode", "kbconst", ".", "RunMode", ",", "config", "Config", ")", "bool", "{", "if", "runMode", "==", "kbconst", ".", "DevelRunMode", "{", "// All users in devel mode are admins.", "return", "true", "\n", "}", "\n", "const", "sessionID", "=", "0", "\n", "session", ",", "err", ":=", "config", ".", "KeybaseService", "(", ")", ".", "CurrentSession", "(", "ctx", ",", "sessionID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "libkb", ".", "IsKeybaseAdmin", "(", "session", ".", "UID", ")", "\n", "}" ]

[ "EnableAdminFeature", "returns", "true", "if", "admin", "features", "should", "be", "enabled", "for", "the", "currently", "-", "logged", "-", "in", "user", "." ]

[ "func", "setHomeTlfIdsForDbcAndFavorites", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "username", "string", ")", "{", "if", "config", ".", "DiskBlockCache", "(", ")", "==", "nil", "{", "return", "\n", "}", "\n\n", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "publicHandle", ",", "err", ":=", "getHandleFromFolderName", "(", "ctx", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ".", "MDOps", "(", ")", ",", "config", ",", "username", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "else", "if", "publicHandle", ".", "TlfID", "(", ")", "!=", "tlf", ".", "NullID", "{", "err", "=", "config", ".", "DiskBlockCache", "(", ")", ".", "AddHomeTLF", "(", "ctx", ",", "publicHandle", ".", "TlfID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "privateHandle", ",", "err", ":=", "getHandleFromFolderName", "(", "ctx", ",", "config", ".", "KBPKI", "(", ")", ",", "config", ".", "MDOps", "(", ")", ",", "config", ",", "username", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "else", "if", "privateHandle", ".", "TlfID", "(", ")", "!=", "tlf", ".", "NullID", "{", "err", "=", "config", ".", "DiskBlockCache", "(", ")", ".", "AddHomeTLF", "(", "ctx", ",", "privateHandle", ".", "TlfID", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// Send to Favorites cache", "info", ":=", "homeTLFInfo", "{", "}", "\n", "if", "publicHandle", "!=", "nil", "{", "teamID", ":=", "publicHandle", ".", "ToFavToAdd", "(", "false", ")", ".", "Data", ".", "TeamID", "\n", "if", "teamID", "!=", "nil", "{", "info", ".", "PublicTeamID", "=", "*", "teamID", "\n", "}", "\n", "}", "\n", "if", "privateHandle", "!=", "nil", "{", "teamID", ":=", "privateHandle", ".", "ToFavToAdd", "(", "false", ")", ".", "Data", ".", "TeamID", "\n", "if", "teamID", "!=", "nil", "{", "info", ".", "PrivateTeamID", "=", "*", "teamID", "\n", "}", "\n", "}", "\n", "config", ".", "KBFSOps", "(", ")", ".", "SetFavoritesHomeTLFInfo", "(", "ctx", ",", "info", ")", "\n", "}" ]

[ "setHomeTlfIdsForDbcAndFavorites", "sets", "the", "user", "s", "home", "TLFs", "on", "the", "disk", "block", "cache", "and", "the", "favorites", "cache", "." ]

[ "func", "serviceLoggedIn", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ",", "session", "idutil", ".", "SessionInfo", ",", "bws", "TLFJournalBackgroundWorkStatus", ")", "(", "wg", "*", "sync", ".", "WaitGroup", ")", "{", "wg", "=", "&", "sync", ".", "WaitGroup", "{", "}", "// To avoid returning a nil pointer.", "\n", "log", ":=", "config", ".", "MakeLogger", "(", "\"", "\"", ")", "\n", "if", "jManager", ",", "err", ":=", "GetJournalManager", "(", "config", ")", ";", "err", "==", "nil", "{", "err", ":=", "jManager", ".", "EnableExistingJournals", "(", "ctx", ",", "session", ".", "UID", ",", "session", ".", "VerifyingKey", ",", "bws", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "// Initializing the FBOs uses the mdserver, and this", "// function might be called as part of MDServer.OnConnect,", "// so be safe and initialize them in the background to", "// avoid deadlocks.", "newCtx", ":=", "CtxWithRandomIDReplayable", "(", "context", ".", "Background", "(", ")", ",", "CtxKeybaseServiceIDKey", ",", "CtxKeybaseServiceOpID", ",", "log", ")", "\n", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "CtxKeybaseServiceOpID", ",", "newCtx", ".", "Value", "(", "CtxKeybaseServiceIDKey", ")", ")", "\n", "wg", "=", "jManager", ".", "MakeFBOsForExistingJournals", "(", "newCtx", ")", "\n", "}", "\n", "}", "\n", "err", ":=", "config", ".", "MakeDiskBlockCacheIfNotExists", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "CWarningf", "(", "ctx", ",", "\"", "\"", "+", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "// Asynchronously set the TLF IDs for the home folders on the disk block", "// cache.", "go", "setHomeTlfIdsForDbcAndFavorites", "(", "context", ".", "Background", "(", ")", ",", "config", ",", "session", ".", "Name", ".", "String", "(", ")", ")", "\n\n", "// Launch auth refreshes in the background, in case we are", "// currently disconnected from one of these servers.", "mdServer", ":=", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "!=", "nil", "{", "go", "mdServer", ".", "RefreshAuthToken", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "\n", "bServer", ":=", "config", ".", "BlockServer", "(", ")", "\n", "if", "bServer", "!=", "nil", "{", "go", "bServer", ".", "RefreshAuthToken", "(", "context", ".", "Background", "(", ")", ")", "\n", "}", "\n\n", "config", ".", "KBFSOps", "(", ")", ".", "RefreshCachedFavorites", "(", "ctx", ")", "\n", "config", ".", "KBFSOps", "(", ")", ".", "PushStatusChange", "(", ")", "\n", "return", "wg", "\n", "}" ]

[ "serviceLoggedIn", "should", "be", "called", "when", "a", "new", "user", "logs", "in", ".", "It", "shouldn", "t", "be", "called", "again", "until", "after", "serviceLoggedOut", "is", "called", "." ]

[ "func", "serviceLoggedOut", "(", "ctx", "context", ".", "Context", ",", "config", "Config", ")", "{", "if", "jManager", ",", "err", ":=", "GetJournalManager", "(", "config", ")", ";", "err", "==", "nil", "{", "jManager", ".", "shutdownExistingJournals", "(", "ctx", ")", "\n", "}", "\n", "config", ".", "ResetCaches", "(", ")", "\n", "config", ".", "UserHistory", "(", ")", ".", "Clear", "(", ")", "\n", "config", ".", "Chat", "(", ")", ".", "ClearCache", "(", ")", "\n", "mdServer", ":=", "config", ".", "MDServer", "(", ")", "\n", "if", "mdServer", "!=", "nil", "{", "mdServer", ".", "RefreshAuthToken", "(", "ctx", ")", "\n", "}", "\n", "bServer", ":=", "config", ".", "BlockServer", "(", ")", "\n", "if", "bServer", "!=", "nil", "{", "bServer", ".", "RefreshAuthToken", "(", "ctx", ")", "\n", "}", "\n", "config", ".", "KBFSOps", "(", ")", ".", "ClearCachedFavorites", "(", "ctx", ")", "\n", "config", ".", "KBFSOps", "(", ")", ".", "PushStatusChange", "(", ")", "\n\n", "// Clear any cached MD for all private TLFs, as they shouldn't be", "// readable by a logged out user. We assume that a logged-out", "// call always comes before a logged-in call.", "config", ".", "KBFSOps", "(", ")", ".", "ClearPrivateFolderMD", "(", "ctx", ")", "\n", "}" ]

[ "serviceLoggedOut", "should", "be", "called", "when", "the", "current", "user", "logs", "out", "." ]

[ "func", "NewKeyServerMeasured", "(", "delegate", "KeyServer", ",", "r", "metrics", ".", "Registry", ")", "KeyServerMeasured", "{", "getTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "putTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "deleteTimer", ":=", "metrics", ".", "GetOrRegisterTimer", "(", "\"", "\"", ",", "r", ")", "\n", "return", "KeyServerMeasured", "{", "delegate", ":", "delegate", ",", "getTimer", ":", "getTimer", ",", "putTimer", ":", "putTimer", ",", "deleteTimer", ":", "deleteTimer", ",", "}", "\n", "}" ]

[ "NewKeyServerMeasured", "creates", "and", "returns", "a", "new", "KeyServerMeasured", "instance", "with", "the", "given", "delegate", "and", "registry", "." ]

[ "func", "(", "b", "KeyServerMeasured", ")", "GetTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ")", "(", "serverHalf", "kbfscrypto", ".", "TLFCryptKeyServerHalf", ",", "err", "error", ")", "{", "b", ".", "getTimer", ".", "Time", "(", "func", "(", ")", "{", "serverHalf", ",", "err", "=", "b", ".", "delegate", ".", "GetTLFCryptKeyServerHalf", "(", "ctx", ",", "serverHalfID", ",", "key", ")", "\n", "}", ")", "\n", "return", "serverHalf", ",", "err", "\n", "}" ]

[ "GetTLFCryptKeyServerHalf", "implements", "the", "KeyServer", "interface", "for", "KeyServerMeasured", "." ]

[ "func", "(", "b", "KeyServerMeasured", ")", "PutTLFCryptKeyServerHalves", "(", "ctx", "context", ".", "Context", ",", "keyServerHalves", "kbfsmd", ".", "UserDeviceKeyServerHalves", ")", "(", "err", "error", ")", "{", "b", ".", "putTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "b", ".", "delegate", ".", "PutTLFCryptKeyServerHalves", "(", "ctx", ",", "keyServerHalves", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "PutTLFCryptKeyServerHalves", "implements", "the", "KeyServer", "interface", "for", "KeyServerMeasured", "." ]

[ "func", "(", "b", "KeyServerMeasured", ")", "DeleteTLFCryptKeyServerHalf", "(", "ctx", "context", ".", "Context", ",", "uid", "keybase1", ".", "UID", ",", "key", "kbfscrypto", ".", "CryptPublicKey", ",", "serverHalfID", "kbfscrypto", ".", "TLFCryptKeyServerHalfID", ")", "(", "err", "error", ")", "{", "b", ".", "deleteTimer", ".", "Time", "(", "func", "(", ")", "{", "err", "=", "b", ".", "delegate", ".", "DeleteTLFCryptKeyServerHalf", "(", "ctx", ",", "uid", ",", "key", ",", "serverHalfID", ")", "\n", "}", ")", "\n", "return", "err", "\n", "}" ]

[ "DeleteTLFCryptKeyServerHalf", "implements", "the", "KeyServer", "interface", "for", "KeyServerMeasured", "." ]

[ "func", "(", "d", "DeviceID", ")", "Eq", "(", "d2", "DeviceID", ")", "bool", "{", "return", "hmac", ".", "Equal", "(", "d", "[", ":", "]", ",", "d2", "[", ":", "]", ")", "\n", "}" ]

[ "Eq", "returns", "true", "if", "the", "two", "device", "IDs", "are", "equal" ]

[ "func", "(", "s", "SessionID", ")", "Eq", "(", "s2", "SessionID", ")", "bool", "{", "return", "hmac", ".", "Equal", "(", "s", "[", ":", "]", ",", "s2", "[", ":", "]", ")", "\n", "}" ]

[ "Eq", "returns", "true", "if", "the", "two", "session", "IDs", "are", "equal" ]

[ "func", "NewConn", "(", "ctx", "context", ".", "Context", ",", "lctx", "LogContext", ",", "r", "MessageRouter", ",", "s", "Secret", ",", "d", "DeviceID", ",", "readTimeout", "time", ".", "Duration", ")", "(", "con", "net", ".", "Conn", ",", "err", "error", ")", "{", "mac", ":=", "hmac", ".", "New", "(", "sha256", ".", "New", ",", "[", "]", "byte", "(", "s", "[", ":", "]", ")", ")", "\n", "mac", ".", "Write", "(", "[", "]", "byte", "(", "sessionIDText", ")", ")", "\n", "tmp", ":=", "mac", ".", "Sum", "(", "nil", ")", "\n", "var", "sessionID", "SessionID", "\n", "copy", "(", "sessionID", "[", ":", "]", ",", "tmp", ")", "\n", "ret", ":=", "&", "Conn", "{", "router", ":", "r", ",", "secret", ":", "s", ",", "sessionID", ":", "sessionID", ",", "deviceID", ":", "d", ",", "readSeqno", ":", "0", ",", "readTimeout", ":", "readTimeout", ",", "writeSeqno", ":", "0", ",", "ctx", ":", "ctx", ",", "lctx", ":", "lctx", ",", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "NewConn", "establishes", "a", "Kex", "session", "based", "on", "the", "given", "secret", ".", "Will", "work", "for", "both", "ends", "of", "the", "connection", "regardless", "of", "which", "order", "the", "two", "started", "their", "connection", ".", "Will", "communicate", "with", "the", "other", "end", "via", "the", "given", "message", "router", ".", "You", "can", "specify", "an", "optional", "timeout", "to", "cancel", "any", "reads", "longer", "than", "that", "timeout", "." ]

[ "func", "(", "c", "*", "Conn", ")", "Read", "(", "out", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "c", ".", "readMutex", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "readMutex", ".", "Unlock", "(", ")", "\n\n", "// The first error kills the whole stream", "if", "err", "=", "c", ".", "getErrorForRead", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "// First see if there's anything buffered, and read that", "// out now.", "if", "n", ",", "err", "=", "c", ".", "readBufferedMsgsIntoBytes", "(", "out", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "c", ".", "setReadError", "(", "err", ")", "\n", "}", "\n", "if", "n", ">", "0", "{", "return", "n", ",", "nil", "\n", "}", "\n\n", "var", "poll", "time", ".", "Duration", "\n", "if", "!", "c", ".", "readDeadline", ".", "IsZero", "(", ")", "{", "poll", "=", "c", ".", "readDeadline", ".", "Sub", "(", "time", ".", "Now", "(", ")", ")", "\n", "if", "poll", ".", "Nanoseconds", "(", ")", "<", "0", "{", "return", "0", ",", "c", ".", "setReadError", "(", "ErrTimedOut", ")", "\n", "}", "\n", "}", "else", "{", "poll", "=", "c", ".", "readTimeout", "\n", "}", "\n\n", "var", "msgs", "[", "]", "[", "]", "byte", "\n", "msgs", ",", "err", "=", "c", ".", "pollLoop", "(", "poll", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "c", ".", "setReadError", "(", "err", ")", "\n", "}", "\n", "if", "_", ",", "err", "=", "c", ".", "decryptIncomingMessages", "(", "msgs", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "c", ".", "setReadError", "(", "err", ")", "\n", "}", "\n", "if", "n", ",", "err", "=", "c", ".", "readBufferedMsgsIntoBytes", "(", "out", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "c", ".", "setReadError", "(", "err", ")", "\n", "}", "\n\n", "if", "n", "==", "0", "{", "switch", "{", "case", "c", ".", "getClosed", "(", ")", ":", "c", ".", "lctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "err", "=", "io", ".", "EOF", "\n", "case", "poll", ">", "0", ":", "err", "=", "ErrTimedOut", "\n", "default", ":", "err", "=", "ErrAgain", "\n", "}", "\n", "}", "\n\n", "return", "n", ",", "err", "\n", "}" ]

[ "Read", "data", "from", "the", "connection", "returning", "plaintext", "data", "if", "all", "cryptographic", "checks", "passed", ".", "Obeys", "the", "net", ".", "Conn", "interface", ".", "Returns", "the", "number", "of", "bytes", "read", "into", "the", "output", "buffer", "." ]

[ "func", "(", "c", "*", "Conn", ")", "Write", "(", "buf", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "c", ".", "writeMutex", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "writeMutex", ".", "Unlock", "(", ")", "\n\n", "// Our protocol specifies that writing an empty buffer means \"close\"", "// the connection. We don't want callers of `Write` to do this by", "// accident, we want them to call `Close()` explicitly. So short-circuit", "// the write operation here for empty buffers.", "if", "len", "(", "buf", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "return", "c", ".", "writeWithLock", "(", "buf", ")", "\n", "}" ]

[ "Write", "data", "to", "the", "connection", "encrypting", "and", "MAC", "ing", "along", "the", "way", ".", "Obeys", "the", "net", ".", "Conn", "interface" ]

[ "func", "(", "c", "*", "Conn", ")", "Close", "(", ")", "error", "{", "c", ".", "writeMutex", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "writeMutex", ".", "Unlock", "(", ")", "\n\n", "c", ".", "lctx", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// set closed so that the read loop will bail out above", "c", ".", "setClosed", "(", ")", "\n\n", "// Write an empty buffer to signal EOF", "if", "_", ",", "err", ":=", "c", ".", "writeWithLock", "(", "[", "]", "byte", "{", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// All subsequent writes should fail.", "c", ".", "setWriteError", "(", "io", ".", "EOF", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Close", "the", "connection", "to", "the", "server", "sending", "an", "empty", "buffer", "via", "POST", "through", "the", "MessageRouter", ".", "Fulfills", "the", "net", ".", "Conn", "interface" ]

[ "func", "(", "c", "*", "Conn", ")", "SetReadDeadline", "(", "t", "time", ".", "Time", ")", "error", "{", "c", ".", "readMutex", ".", "Lock", "(", ")", "\n", "c", ".", "readDeadline", "=", "t", "\n", "c", ".", "readMutex", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetReadDeadline", "sets", "the", "deadline", "for", "future", "Read", "calls", ".", "A", "zero", "value", "for", "t", "means", "Read", "will", "not", "time", "out", "." ]

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

[ "NewHasServerKeys", "creates", "a", "HasServerKeys", "engine", "." ]

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

[ "NewSessionHandler", "creates", "a", "SessionHandler", "for", "the", "xp", "transport", "." ]

[ "func", "(", "h", "*", "SessionHandler", ")", "CurrentSession", "(", "ctx", "context", ".", "Context", ",", "sessionID", "int", ")", "(", "keybase1", ".", "Session", ",", "error", ")", "{", "var", "s", "keybase1", ".", "Session", "\n\n", "nist", ",", "uid", ",", "_", ",", "err", ":=", "h", ".", "G", "(", ")", ".", "ActiveDevice", ".", "NISTAndUIDDeviceID", "(", "ctx", ")", "\n", "if", "nist", "==", "nil", "{", "return", "s", ",", "libkb", ".", "NoSessionError", "{", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "s", ",", "err", "\n", "}", "\n\n", "un", ",", "err", ":=", "h", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "LookupUsername", "(", "ctx", ",", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "s", ",", "err", "\n", "}", "\n", "sibkey", ",", "err", ":=", "h", ".", "G", "(", ")", ".", "ActiveDevice", ".", "SigningKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "s", ",", "err", "\n", "}", "\n", "subkey", ",", "err", ":=", "h", ".", "G", "(", ")", ".", "ActiveDevice", ".", "EncryptionKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "s", ",", "err", "\n", "}", "\n\n", "s", ".", "Uid", "=", "uid", "\n", "s", ".", "Username", "=", "un", ".", "String", "(", ")", "\n", "s", ".", "Token", "=", "nist", ".", "Token", "(", ")", ".", "String", "(", ")", "\n", "s", ".", "DeviceSubkeyKid", "=", "subkey", ".", "GetKID", "(", ")", "\n", "s", ".", "DeviceSibkeyKid", "=", "sibkey", ".", "GetKID", "(", ")", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "CurrentSession", "uses", "the", "global", "session", "to", "find", "the", "session", ".", "If", "the", "user", "isn", "t", "logged", "in", "it", "returns", "libkb", ".", "NoSessionError", ".", "This", "function", "was", "modified", "to", "use", "cached", "information", "instead", "of", "loading", "the", "full", "self", "user", ".", "This", "does", "do", "a", "full", "call", "to", "sesscheck", "and", "ensures", "that", "the", "session", "token", "is", "valid", "." ]

[ "func", "NewClaimSeqnoProvider", "(", "mctx", "libkb", ".", "MetaContext", ",", "walletState", "*", "WalletState", ")", "(", "seqnoProvider", "*", "ClaimSeqnoProvider", ",", "unlock", "func", "(", ")", ")", "{", "walletState", ".", "SeqnoLock", "(", ")", "\n", "return", "&", "ClaimSeqnoProvider", "{", "mctx", ":", "mctx", ",", "walletState", ":", "walletState", ",", "}", ",", "walletState", ".", "SeqnoUnlock", "\n", "}" ]

[ "NewClaimSeqnoProvider", "creates", "a", "ClaimSeqnoProvider", "for", "use", "in", "relay", "claims", "." ]

[ "func", "Load", "(", "ctx", "context", ".", "Context", ",", "g", "*", "libkb", ".", "GlobalContext", ",", "lArg", "keybase1", ".", "LoadTeamArg", ")", "(", "*", "Team", ",", "error", ")", "{", "teamData", ",", "err", ":=", "g", ".", "GetTeamLoader", "(", ")", ".", "Load", "(", "ctx", ",", "lArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ret", ":=", "NewTeam", "(", "ctx", ",", "g", ",", "teamData", ")", "\n\n", "if", "lArg", ".", "RefreshUIDMapper", "{", "// If we just loaded the group, then inform the UIDMapper of any UID->EldestSeqno", "// mappings, so that we're guaranteed they aren't stale.", "ret", ".", "refreshUIDMapper", "(", "ctx", ",", "g", ")", "\n", "}", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "Load", "a", "Team", "from", "the", "TeamLoader", ".", "Can", "be", "called", "from", "inside", "the", "teams", "package", "." ]