Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "HasGroupingPolicy", "(", "params", "...", "interface", "{", "}", ")", "bool", "{", "e", ".", "m", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "m", ".", "RUnlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "HasGroupingPolicy", "(", "params", "...", ")", "\n", "}" ]

[ "HasGroupingPolicy", "determines", "whether", "a", "role", "inheritance", "rule", "exists", "." ]

[ "func", "EscapeAssertion", "(", "s", "string", ")", "string", "{", "//Replace the first dot, because it can't be recognized by the regexp.", "if", "(", "strings", ".", "HasPrefix", "(", "s", ",", "\"", "\"", ")", "||", "strings", ".", "HasPrefix", "(", "s", ",", "\"", "\"", ")", ")", "{", "s", "=", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "}", "\n", "var", "regex", "=", "regexp", ".", "MustCompile", "(", "`(\\|| |=|\\)|\\(|&|<|>|,|\\+|-|!|\\*|\\/)(r|p)\\.`", ")", "\n", "s", "=", "regex", ".", "ReplaceAllStringFunc", "(", "s", ",", "func", "(", "m", "string", ")", "string", "{", "return", "strings", ".", "Replace", "(", "m", ",", "\"", "\"", ",", "\"", "\"", ",", "1", ")", "\n", "}", ")", "\n", "return", "s", "\n", "}" ]

[ "EscapeAssertion", "escapes", "the", "dots", "in", "the", "assertion", "because", "the", "expression", "evaluation", "doesn", "t", "support", "such", "variable", "names", "." ]

[ "func", "ArrayRemoveDuplicates", "(", "s", "*", "[", "]", "string", ")", "{", "found", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "j", ":=", "0", "\n", "for", "i", ",", "x", ":=", "range", "*", "s", "{", "if", "!", "found", "[", "x", "]", "{", "found", "[", "x", "]", "=", "true", "\n", "(", "*", "s", ")", "[", "j", "]", "=", "(", "*", "s", ")", "[", "i", "]", "\n", "j", "++", "\n", "}", "\n", "}", "\n", "*", "s", "=", "(", "*", "s", ")", "[", ":", "j", "]", "\n", "}" ]

[ "ArrayRemoveDuplicates", "removes", "any", "duplicated", "elements", "in", "a", "string", "array", "." ]

[ "func", "NewAdapterMock", "(", "filePath", "string", ")", "*", "AdapterMock", "{", "a", ":=", "AdapterMock", "{", "}", "\n", "a", ".", "filePath", "=", "filePath", "\n", "return", "&", "a", "\n", "}" ]

[ "NewAdapterMock", "is", "the", "constructor", "for", "AdapterMock", "." ]

[ "func", "(", "a", "*", "AdapterMock", ")", "GetMockErr", "(", ")", "error", "{", "var", "returnError", "error", "\n", "if", "a", ".", "errorValue", "!=", "\"", "\"", "{", "returnError", "=", "errors", ".", "New", "(", "a", ".", "errorValue", ")", "\n", "}", "\n", "return", "returnError", "\n", "}" ]

[ "GetMockErr", "returns", "a", "mock", "error", "or", "nil" ]

[ "func", "LoadPolicyLine", "(", "line", "string", ",", "model", "model", ".", "Model", ")", "{", "if", "line", "==", "\"", "\"", "{", "return", "\n", "}", "\n\n", "if", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "{", "return", "\n", "}", "\n\n", "tokens", ":=", "strings", ".", "Split", "(", "line", ",", "\"", "\"", ")", "\n", "for", "i", ":=", "range", "tokens", "{", "tokens", "[", "i", "]", "=", "strings", ".", "TrimSpace", "(", "tokens", "[", "i", "]", ")", "\n", "}", "\n\n", "key", ":=", "tokens", "[", "0", "]", "\n", "sec", ":=", "key", "[", ":", "1", "]", "\n", "model", "[", "sec", "]", "[", "key", "]", ".", "Policy", "=", "append", "(", "model", "[", "sec", "]", "[", "key", "]", ".", "Policy", ",", "tokens", "[", "1", ":", "]", ")", "\n", "}" ]

[ "LoadPolicyLine", "loads", "a", "text", "line", "as", "a", "policy", "rule", "to", "model", "." ]

[ "func", "(", "e", "*", "DefaultEffector", ")", "MergeEffects", "(", "expr", "string", ",", "effects", "[", "]", "Effect", ",", "results", "[", "]", "float64", ")", "(", "bool", ",", "error", ")", "{", "result", ":=", "false", "\n", "if", "expr", "==", "\"", "\"", "{", "result", "=", "false", "\n", "for", "_", ",", "eft", ":=", "range", "effects", "{", "if", "eft", "==", "Allow", "{", "result", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "else", "if", "expr", "==", "\"", "\"", "{", "result", "=", "true", "\n", "for", "_", ",", "eft", ":=", "range", "effects", "{", "if", "eft", "==", "Deny", "{", "result", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "else", "if", "expr", "==", "\"", "\"", "{", "result", "=", "false", "\n", "for", "_", ",", "eft", ":=", "range", "effects", "{", "if", "eft", "==", "Allow", "{", "result", "=", "true", "\n", "}", "else", "if", "eft", "==", "Deny", "{", "result", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "else", "if", "expr", "==", "\"", "\"", "{", "result", "=", "false", "\n", "for", "_", ",", "eft", ":=", "range", "effects", "{", "if", "eft", "!=", "Indeterminate", "{", "if", "eft", "==", "Allow", "{", "result", "=", "true", "\n", "}", "else", "{", "result", "=", "false", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "else", "{", "return", "false", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "MergeEffects", "merges", "all", "matching", "results", "collected", "by", "the", "enforcer", "into", "a", "single", "decision", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "addPolicy", "(", "sec", "string", ",", "ptype", "string", ",", "rule", "[", "]", "string", ")", "bool", "{", "ruleAdded", ":=", "e", ".", "model", ".", "AddPolicy", "(", "sec", ",", "ptype", ",", "rule", ")", "\n", "if", "!", "ruleAdded", "{", "return", "ruleAdded", "\n", "}", "\n\n", "if", "e", ".", "adapter", "!=", "nil", "&&", "e", ".", "autoSave", "{", "if", "err", ":=", "e", ".", "adapter", ".", "AddPolicy", "(", "sec", ",", "ptype", ",", "rule", ")", ";", "err", "!=", "nil", "{", "if", "err", ".", "Error", "(", ")", "!=", "notImplemented", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "e", ".", "watcher", "!=", "nil", "{", "// error intentionally ignored", "e", ".", "watcher", ".", "Update", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "ruleAdded", "\n", "}" ]

[ "addPolicy", "adds", "a", "rule", "to", "the", "current", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "removePolicy", "(", "sec", "string", ",", "ptype", "string", ",", "rule", "[", "]", "string", ")", "bool", "{", "ruleRemoved", ":=", "e", ".", "model", ".", "RemovePolicy", "(", "sec", ",", "ptype", ",", "rule", ")", "\n", "if", "!", "ruleRemoved", "{", "return", "ruleRemoved", "\n", "}", "\n\n", "if", "e", ".", "adapter", "!=", "nil", "&&", "e", ".", "autoSave", "{", "if", "err", ":=", "e", ".", "adapter", ".", "RemovePolicy", "(", "sec", ",", "ptype", ",", "rule", ")", ";", "err", "!=", "nil", "{", "if", "err", ".", "Error", "(", ")", "!=", "notImplemented", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "e", ".", "watcher", "!=", "nil", "{", "// error intentionally ignored", "e", ".", "watcher", ".", "Update", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "ruleRemoved", "\n", "}" ]

[ "removePolicy", "removes", "a", "rule", "from", "the", "current", "policy", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "removeFilteredPolicy", "(", "sec", "string", ",", "ptype", "string", ",", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "bool", "{", "ruleRemoved", ":=", "e", ".", "model", ".", "RemoveFilteredPolicy", "(", "sec", ",", "ptype", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "if", "!", "ruleRemoved", "{", "return", "ruleRemoved", "\n", "}", "\n\n", "if", "e", ".", "adapter", "!=", "nil", "&&", "e", ".", "autoSave", "{", "if", "err", ":=", "e", ".", "adapter", ".", "RemoveFilteredPolicy", "(", "sec", ",", "ptype", ",", "fieldIndex", ",", "fieldValues", "...", ")", ";", "err", "!=", "nil", "{", "if", "err", ".", "Error", "(", ")", "!=", "notImplemented", "{", "panic", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "e", ".", "watcher", "!=", "nil", "{", "// error intentionally ignored", "e", ".", "watcher", ".", "Update", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "ruleRemoved", "\n", "}" ]

[ "removeFilteredPolicy", "removes", "rules", "based", "on", "field", "filters", "from", "the", "current", "policy", "." ]

[ "func", "(", "model", "Model", ")", "BuildRoleLinks", "(", "rm", "rbac", ".", "RoleManager", ")", "{", "for", "_", ",", "ast", ":=", "range", "model", "[", "\"", "\"", "]", "{", "ast", ".", "buildRoleLinks", "(", "rm", ")", "\n", "}", "\n", "}" ]

[ "BuildRoleLinks", "initializes", "the", "roles", "in", "RBAC", "." ]

[ "func", "(", "model", "Model", ")", "PrintPolicy", "(", ")", "{", "log", ".", "LogPrint", "(", "\"", "\"", ")", "\n", "for", "key", ",", "ast", ":=", "range", "model", "[", "\"", "\"", "]", "{", "log", ".", "LogPrint", "(", "key", ",", "\"", "\"", ",", "ast", ".", "Value", ",", "\"", "\"", ",", "ast", ".", "Policy", ")", "\n", "}", "\n\n", "for", "key", ",", "ast", ":=", "range", "model", "[", "\"", "\"", "]", "{", "log", ".", "LogPrint", "(", "key", ",", "\"", "\"", ",", "ast", ".", "Value", ",", "\"", "\"", ",", "ast", ".", "Policy", ")", "\n", "}", "\n", "}" ]

[ "PrintPolicy", "prints", "the", "policy", "to", "log", "." ]

[ "func", "(", "model", "Model", ")", "ClearPolicy", "(", ")", "{", "for", "_", ",", "ast", ":=", "range", "model", "[", "\"", "\"", "]", "{", "ast", ".", "Policy", "=", "nil", "\n", "}", "\n\n", "for", "_", ",", "ast", ":=", "range", "model", "[", "\"", "\"", "]", "{", "ast", ".", "Policy", "=", "nil", "\n", "}", "\n", "}" ]

[ "ClearPolicy", "clears", "all", "current", "policy", "." ]

[ "func", "(", "model", "Model", ")", "GetPolicy", "(", "sec", "string", ",", "ptype", "string", ")", "[", "]", "[", "]", "string", "{", "return", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "\n", "}" ]

[ "GetPolicy", "gets", "all", "rules", "in", "a", "policy", "." ]

[ "func", "(", "model", "Model", ")", "GetFilteredPolicy", "(", "sec", "string", ",", "ptype", "string", ",", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "[", "]", "[", "]", "string", "{", "res", ":=", "[", "]", "[", "]", "string", "{", "}", "\n\n", "for", "_", ",", "rule", ":=", "range", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "{", "matched", ":=", "true", "\n", "for", "i", ",", "fieldValue", ":=", "range", "fieldValues", "{", "if", "fieldValue", "!=", "\"", "\"", "&&", "rule", "[", "fieldIndex", "+", "i", "]", "!=", "fieldValue", "{", "matched", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "matched", "{", "res", "=", "append", "(", "res", ",", "rule", ")", "\n", "}", "\n", "}", "\n\n", "return", "res", "\n", "}" ]

[ "GetFilteredPolicy", "gets", "rules", "based", "on", "field", "filters", "from", "a", "policy", "." ]

[ "func", "(", "model", "Model", ")", "HasPolicy", "(", "sec", "string", ",", "ptype", "string", ",", "rule", "[", "]", "string", ")", "bool", "{", "for", "_", ",", "r", ":=", "range", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "{", "if", "util", ".", "ArrayEquals", "(", "rule", ",", "r", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "HasPolicy", "determines", "whether", "a", "model", "has", "the", "specified", "policy", "rule", "." ]

[ "func", "(", "model", "Model", ")", "AddPolicy", "(", "sec", "string", ",", "ptype", "string", ",", "rule", "[", "]", "string", ")", "bool", "{", "if", "!", "model", ".", "HasPolicy", "(", "sec", ",", "ptype", ",", "rule", ")", "{", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "=", "append", "(", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", ",", "rule", ")", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "AddPolicy", "adds", "a", "policy", "rule", "to", "the", "model", "." ]

[ "func", "(", "model", "Model", ")", "RemovePolicy", "(", "sec", "string", ",", "ptype", "string", ",", "rule", "[", "]", "string", ")", "bool", "{", "for", "i", ",", "r", ":=", "range", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "{", "if", "util", ".", "ArrayEquals", "(", "rule", ",", "r", ")", "{", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "=", "append", "(", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "[", ":", "i", "]", ",", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "RemovePolicy", "removes", "a", "policy", "rule", "from", "the", "model", "." ]

[ "func", "(", "model", "Model", ")", "GetValuesForFieldInPolicy", "(", "sec", "string", ",", "ptype", "string", ",", "fieldIndex", "int", ")", "[", "]", "string", "{", "values", ":=", "[", "]", "string", "{", "}", "\n\n", "for", "_", ",", "rule", ":=", "range", "model", "[", "sec", "]", "[", "ptype", "]", ".", "Policy", "{", "values", "=", "append", "(", "values", ",", "rule", "[", "fieldIndex", "]", ")", "\n", "}", "\n\n", "util", ".", "ArrayRemoveDuplicates", "(", "&", "values", ")", "\n\n", "return", "values", "\n", "}" ]

[ "GetValuesForFieldInPolicy", "gets", "all", "values", "for", "a", "field", "for", "all", "rules", "in", "a", "policy", "duplicated", "values", "are", "removed", "." ]

[ "func", "(", "model", "Model", ")", "AddDef", "(", "sec", "string", ",", "key", "string", ",", "value", "string", ")", "bool", "{", "ast", ":=", "Assertion", "{", "}", "\n", "ast", ".", "Key", "=", "key", "\n", "ast", ".", "Value", "=", "value", "\n\n", "if", "ast", ".", "Value", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n\n", "if", "sec", "==", "\"", "\"", "||", "sec", "==", "\"", "\"", "{", "ast", ".", "Tokens", "=", "strings", ".", "Split", "(", "ast", ".", "Value", ",", "\"", "\"", ")", "\n", "for", "i", ":=", "range", "ast", ".", "Tokens", "{", "ast", ".", "Tokens", "[", "i", "]", "=", "key", "+", "\"", "\"", "+", "ast", ".", "Tokens", "[", "i", "]", "\n", "}", "\n", "}", "else", "{", "ast", ".", "Value", "=", "util", ".", "RemoveComments", "(", "util", ".", "EscapeAssertion", "(", "ast", ".", "Value", ")", ")", "\n", "}", "\n\n", "_", ",", "ok", ":=", "model", "[", "sec", "]", "\n", "if", "!", "ok", "{", "model", "[", "sec", "]", "=", "make", "(", "AssertionMap", ")", "\n", "}", "\n\n", "model", "[", "sec", "]", "[", "key", "]", "=", "&", "ast", "\n", "return", "true", "\n", "}" ]

[ "AddDef", "adds", "an", "assertion", "to", "the", "model", "." ]

[ "func", "(", "model", "Model", ")", "LoadModel", "(", "path", "string", ")", "{", "cfg", ",", "err", ":=", "config", ".", "NewConfig", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "}" ]

[ "LoadModel", "loads", "the", "model", "from", "model", "CONF", "file", "." ]

[ "func", "(", "model", "Model", ")", "LoadModelFromText", "(", "text", "string", ")", "{", "cfg", ",", "err", ":=", "config", ".", "NewConfigFromText", "(", "text", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n\n", "loadSection", "(", "model", ",", "cfg", ",", "\"", "\"", ")", "\n", "}" ]

[ "LoadModelFromText", "loads", "the", "model", "from", "the", "text", "." ]

[ "func", "(", "model", "Model", ")", "PrintModel", "(", ")", "{", "log", ".", "LogPrint", "(", "\"", "\"", ")", "\n", "for", "k", ",", "v", ":=", "range", "model", "{", "for", "i", ",", "j", ":=", "range", "v", "{", "log", ".", "LogPrintf", "(", "\"", "\"", ",", "k", ",", "i", ",", "j", ".", "Value", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "PrintModel", "prints", "the", "model", "to", "the", "log", "." ]

[ "func", "NewRoleManager", "(", "maxHierarchyLevel", "int", ")", "rbac", ".", "RoleManager", "{", "rm", ":=", "RoleManager", "{", "}", "\n", "rm", ".", "allRoles", "=", "&", "sync", ".", "Map", "{", "}", "\n", "rm", ".", "maxHierarchyLevel", "=", "maxHierarchyLevel", "\n", "rm", ".", "hasPattern", "=", "false", "\n\n", "return", "&", "rm", "\n", "}" ]

[ "NewRoleManager", "is", "the", "constructor", "for", "creating", "an", "instance", "of", "the", "default", "RoleManager", "implementation", "." ]

[ "func", "(", "rm", "*", "RoleManager", ")", "GetRoles", "(", "name", "string", ",", "domain", "...", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "len", "(", "domain", ")", "==", "1", "{", "name", "=", "domain", "[", "0", "]", "+", "\"", "\"", "+", "name", "\n", "}", "else", "if", "len", "(", "domain", ")", ">", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "rm", ".", "hasRole", "(", "name", ")", "{", "return", "[", "]", "string", "{", "}", ",", "nil", "\n", "}", "\n\n", "roles", ":=", "rm", ".", "createRole", "(", "name", ")", ".", "getRoles", "(", ")", "\n", "if", "len", "(", "domain", ")", "==", "1", "{", "for", "i", ":=", "range", "roles", "{", "roles", "[", "i", "]", "=", "roles", "[", "i", "]", "[", "len", "(", "domain", "[", "0", "]", ")", "+", "2", ":", "]", "\n", "}", "\n", "}", "\n", "return", "roles", ",", "nil", "\n", "}" ]

[ "GetRoles", "gets", "the", "roles", "that", "a", "subject", "inherits", ".", "domain", "is", "a", "prefix", "to", "the", "roles", "." ]

[ "func", "(", "rm", "*", "RoleManager", ")", "GetUsers", "(", "name", "string", ",", "domain", "...", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "if", "len", "(", "domain", ")", "==", "1", "{", "name", "=", "domain", "[", "0", "]", "+", "\"", "\"", "+", "name", "\n", "}", "else", "if", "len", "(", "domain", ")", ">", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "rm", ".", "hasRole", "(", "name", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "names", ":=", "[", "]", "string", "{", "}", "\n", "rm", ".", "allRoles", ".", "Range", "(", "func", "(", "_", ",", "value", "interface", "{", "}", ")", "bool", "{", "role", ":=", "value", ".", "(", "*", "Role", ")", "\n", "if", "role", ".", "hasDirectRole", "(", "name", ")", "{", "names", "=", "append", "(", "names", ",", "role", ".", "name", ")", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "if", "len", "(", "domain", ")", "==", "1", "{", "for", "i", ":=", "range", "names", "{", "names", "[", "i", "]", "=", "names", "[", "i", "]", "[", "len", "(", "domain", "[", "0", "]", ")", "+", "2", ":", "]", "\n", "}", "\n", "}", "\n", "return", "names", ",", "nil", "\n", "}" ]

[ "GetUsers", "gets", "the", "users", "that", "inherits", "a", "subject", ".", "domain", "is", "an", "unreferenced", "parameter", "here", "may", "be", "used", "in", "other", "implementations", "." ]

[ "func", "(", "rm", "*", "RoleManager", ")", "PrintRoles", "(", ")", "error", "{", "line", ":=", "\"", "\"", "\n", "rm", ".", "allRoles", ".", "Range", "(", "func", "(", "_", ",", "value", "interface", "{", "}", ")", "bool", "{", "if", "text", ":=", "value", ".", "(", "*", "Role", ")", ".", "toString", "(", ")", ";", "text", "!=", "\"", "\"", "{", "if", "line", "==", "\"", "\"", "{", "line", "=", "text", "\n", "}", "else", "{", "line", "+=", "\"", "\"", "+", "text", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}", ")", "\n", "log", ".", "LogPrint", "(", "line", ")", "\n", "return", "nil", "\n", "}" ]

[ "PrintRoles", "prints", "all", "the", "roles", "to", "log", "." ]

[ "func", "(", "fm", "FunctionMap", ")", "AddFunction", "(", "name", "string", ",", "function", "Function", ")", "{", "fm", "[", "name", "]", "=", "function", "\n", "}" ]

[ "AddFunction", "adds", "an", "expression", "function", "." ]

[ "func", "LoadFunctionMap", "(", ")", "FunctionMap", "{", "fm", ":=", "make", "(", "FunctionMap", ")", "\n\n", "fm", ".", "AddFunction", "(", "\"", "\"", ",", "util", ".", "KeyMatchFunc", ")", "\n", "fm", ".", "AddFunction", "(", "\"", "\"", ",", "util", ".", "KeyMatch2Func", ")", "\n", "fm", ".", "AddFunction", "(", "\"", "\"", ",", "util", ".", "RegexMatchFunc", ")", "\n", "fm", ".", "AddFunction", "(", "\"", "\"", ",", "util", ".", "IPMatchFunc", ")", "\n\n", "return", "fm", "\n", "}" ]

[ "LoadFunctionMap", "loads", "an", "initial", "function", "map", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetUsersForRole", "(", "name", "string", ")", "[", "]", "string", "{", "res", ",", "_", ":=", "e", ".", "model", "[", "\"", "\"", "]", "[", "\"", "\"", "]", ".", "RM", ".", "GetUsers", "(", "name", ")", "\n", "return", "res", "\n", "}" ]

[ "GetUsersForRole", "gets", "the", "users", "that", "has", "a", "role", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "GetUsersForRoleInDomain", "(", "name", "string", ",", "domain", "string", ")", "[", "]", "string", "{", "res", ",", "_", ":=", "e", ".", "model", "[", "\"", "\"", "]", "[", "\"", "\"", "]", ".", "RM", ".", "GetUsers", "(", "name", ",", "domain", ")", "\n", "return", "res", "\n", "}" ]

[ "GetUsersForRoleInDomain", "gets", "the", "users", "that", "has", "a", "role", "inside", "a", "domain", ".", "Add", "by", "Gordon" ]

[ "func", "NewSyncedEnforcerSafe", "(", "params", "...", "interface", "{", "}", ")", "(", "enforcer", "*", "SyncedEnforcer", ",", "err", "error", ")", "{", "e", ":=", "&", "SyncedEnforcer", "{", "}", "\n", "e", ".", "Enforcer", ",", "err", "=", "NewEnforcerSafe", "(", "params", "...", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "e", ".", "autoLoad", "=", "false", "\n", "return", "e", ",", "nil", "\n", "}" ]

[ "NewSyncedEnforcerSafe", "creates", "a", "synchronized", "enforcer", "via", "file", "or", "DB", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "RemoveFilteredPolicySafe", "(", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "e", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "m", ".", "Unlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "RemoveFilteredPolicySafe", "(", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "}" ]

[ "RemoveFilteredPolicySafe", "calls", "RemoveFilteredPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "NewFilteredAdapter", "(", "filePath", "string", ")", "*", "FilteredAdapter", "{", "a", ":=", "FilteredAdapter", "{", "}", "\n", "a", ".", "filtered", "=", "true", "\n", "a", ".", "Adapter", "=", "NewAdapter", "(", "filePath", ")", "\n", "return", "&", "a", "\n", "}" ]

[ "NewFilteredAdapter", "is", "the", "constructor", "for", "FilteredAdapter", "." ]

[ "func", "(", "a", "*", "FilteredAdapter", ")", "LoadFilteredPolicy", "(", "model", "model", ".", "Model", ",", "filter", "interface", "{", "}", ")", "error", "{", "if", "filter", "==", "nil", "{", "return", "a", ".", "LoadPolicy", "(", "model", ")", "\n", "}", "\n", "if", "a", ".", "filePath", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "filterValue", ",", "ok", ":=", "filter", ".", "(", "*", "Filter", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "err", ":=", "a", ".", "loadFilteredPolicyFile", "(", "model", ",", "filterValue", ",", "persist", ".", "LoadPolicyLine", ")", "\n", "if", "err", "==", "nil", "{", "a", ".", "filtered", "=", "true", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "LoadFilteredPolicy", "loads", "only", "policy", "rules", "that", "match", "the", "filter", "." ]

[ "func", "NewConfig", "(", "confName", "string", ")", "(", "ConfigInterface", ",", "error", ")", "{", "c", ":=", "&", "Config", "{", "data", ":", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "string", ")", ",", "}", "\n", "err", ":=", "c", ".", "parse", "(", "confName", ")", "\n", "return", "c", ",", "err", "\n", "}" ]

[ "NewConfig", "create", "an", "empty", "configuration", "representation", "from", "file", "." ]

[ "func", "NewConfigFromText", "(", "text", "string", ")", "(", "ConfigInterface", ",", "error", ")", "{", "c", ":=", "&", "Config", "{", "data", ":", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "string", ")", ",", "}", "\n", "err", ":=", "c", ".", "parseBuffer", "(", "bufio", ".", "NewReader", "(", "strings", ".", "NewReader", "(", "text", ")", ")", ")", "\n", "return", "c", ",", "err", "\n", "}" ]

[ "NewConfigFromText", "create", "an", "empty", "configuration", "representation", "from", "text", "." ]

[ "func", "(", "c", "*", "Config", ")", "Bool", "(", "key", "string", ")", "(", "bool", ",", "error", ")", "{", "return", "strconv", ".", "ParseBool", "(", "c", ".", "get", "(", "key", ")", ")", "\n", "}" ]

[ "Bool", "lookups", "up", "the", "value", "using", "the", "provided", "key", "and", "converts", "the", "value", "to", "a", "bool" ]

[ "func", "(", "c", "*", "Config", ")", "Int", "(", "key", "string", ")", "(", "int", ",", "error", ")", "{", "return", "strconv", ".", "Atoi", "(", "c", ".", "get", "(", "key", ")", ")", "\n", "}" ]

[ "Int", "lookups", "up", "the", "value", "using", "the", "provided", "key", "and", "converts", "the", "value", "to", "a", "int" ]

[ "func", "(", "c", "*", "Config", ")", "Int64", "(", "key", "string", ")", "(", "int64", ",", "error", ")", "{", "return", "strconv", ".", "ParseInt", "(", "c", ".", "get", "(", "key", ")", ",", "10", ",", "64", ")", "\n", "}" ]

[ "Int64", "lookups", "up", "the", "value", "using", "the", "provided", "key", "and", "converts", "the", "value", "to", "a", "int64" ]

[ "func", "(", "c", "*", "Config", ")", "Float64", "(", "key", "string", ")", "(", "float64", ",", "error", ")", "{", "return", "strconv", ".", "ParseFloat", "(", "c", ".", "get", "(", "key", ")", ",", "64", ")", "\n", "}" ]

[ "Float64", "lookups", "up", "the", "value", "using", "the", "provided", "key", "and", "converts", "the", "value", "to", "a", "float64" ]

[ "func", "(", "c", "*", "Config", ")", "Strings", "(", "key", "string", ")", "[", "]", "string", "{", "v", ":=", "c", ".", "get", "(", "key", ")", "\n", "if", "v", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "return", "strings", ".", "Split", "(", "v", ",", "\"", "\"", ")", "\n", "}" ]

[ "Strings", "lookups", "up", "the", "value", "using", "the", "provided", "key", "and", "converts", "the", "value", "to", "an", "array", "of", "string", "by", "splitting", "the", "string", "by", "comma" ]

[ "func", "(", "c", "*", "Config", ")", "Set", "(", "key", "string", ",", "value", "string", ")", "error", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "if", "len", "(", "key", ")", "==", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "(", "section", "string", "\n", "option", "string", "\n", ")", "\n\n", "keys", ":=", "strings", ".", "Split", "(", "strings", ".", "ToLower", "(", "key", ")", ",", "\"", "\"", ")", "\n", "if", "len", "(", "keys", ")", ">=", "2", "{", "section", "=", "keys", "[", "0", "]", "\n", "option", "=", "keys", "[", "1", "]", "\n", "}", "else", "{", "option", "=", "keys", "[", "0", "]", "\n", "}", "\n\n", "c", ".", "AddConfig", "(", "section", ",", "option", ",", "value", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "sets", "the", "value", "for", "the", "specific", "key", "in", "the", "Config" ]

[ "func", "NewEnforcerSafe", "(", "params", "...", "interface", "{", "}", ")", "(", "e", "*", "Enforcer", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "e", "=", "nil", "\n", "}", "\n", "}", "(", ")", "\n\n", "e", "=", "NewEnforcer", "(", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "NewEnforcerSafe", "calls", "NewEnforcer", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemovePolicySafe", "(", "params", "...", "interface", "{", "}", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "RemoveNamedPolicy", "(", "\"", "\"", ",", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "RemovePolicySafe", "calls", "RemovePolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "AddGroupingPolicySafe", "(", "params", "...", "interface", "{", "}", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "AddGroupingPolicy", "(", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "AddGroupingPolicySafe", "calls", "AddGroupingPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "AddNamedGroupingPolicySafe", "(", "ptype", "string", ",", "params", "...", "interface", "{", "}", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "AddNamedGroupingPolicy", "(", "ptype", ",", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "AddNamedGroupingPolicySafe", "calls", "AddNamedGroupingPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "AddNamedPolicySafe", "(", "ptype", "string", ",", "params", "...", "interface", "{", "}", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "AddNamedPolicy", "(", "ptype", ",", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "AddNamedPolicySafe", "calls", "AddNamedPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveGroupingPolicySafe", "(", "params", "...", "interface", "{", "}", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "RemoveGroupingPolicy", "(", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "RemoveGroupingPolicySafe", "calls", "RemoveGroupingPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveFilteredGroupingPolicySafe", "(", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "RemoveFilteredGroupingPolicy", "(", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "RemoveFilteredGroupingPolicySafe", "calls", "RemoveFilteredGroupingPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveNamedGroupingPolicySafe", "(", "ptype", "string", ",", "params", "...", "interface", "{", "}", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "RemoveNamedGroupingPolicy", "(", "ptype", ",", "params", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "RemoveNamedGroupingPolicySafe", "calls", "RemoveNamedGroupingPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "RemoveFilteredNamedGroupingPolicySafe", "(", "ptype", "string", ",", "fieldIndex", "int", ",", "fieldValues", "...", "string", ")", "(", "result", "bool", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "result", "=", "false", "\n", "}", "\n", "}", "(", ")", "\n\n", "result", "=", "e", ".", "RemoveFilteredNamedGroupingPolicy", "(", "ptype", ",", "fieldIndex", ",", "fieldValues", "...", ")", "\n", "err", "=", "nil", "\n", "return", "\n", "}" ]

[ "RemoveFilteredNamedGroupingPolicySafe", "calls", "RemoveFilteredNamedGroupingPolicy", "in", "a", "safe", "way", "returns", "error", "instead", "of", "causing", "panic", "." ]

[ "func", "(", "e", "*", "SyncedEnforcer", ")", "GetPermissionsForUser", "(", "user", "string", ")", "[", "]", "[", "]", "string", "{", "e", ".", "m", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "m", ".", "Unlock", "(", ")", "\n", "return", "e", ".", "Enforcer", ".", "GetPermissionsForUser", "(", "user", ")", "\n", "}" ]

[ "GetPermissionsForUser", "gets", "permissions", "for", "a", "user", "or", "role", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "InitWithFile", "(", "modelPath", "string", ",", "policyPath", "string", ")", "{", "a", ":=", "fileadapter", ".", "NewAdapter", "(", "policyPath", ")", "\n", "e", ".", "InitWithAdapter", "(", "modelPath", ",", "a", ")", "\n", "}" ]

[ "InitWithFile", "initializes", "an", "enforcer", "with", "a", "model", "file", "and", "a", "policy", "file", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "InitWithAdapter", "(", "modelPath", "string", ",", "adapter", "persist", ".", "Adapter", ")", "{", "m", ":=", "NewModel", "(", "modelPath", ",", "\"", "\"", ")", "\n", "e", ".", "InitWithModelAndAdapter", "(", "m", ",", "adapter", ")", "\n\n", "e", ".", "modelPath", "=", "modelPath", "\n", "}" ]

[ "InitWithAdapter", "initializes", "an", "enforcer", "with", "a", "database", "adapter", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "InitWithModelAndAdapter", "(", "m", "model", ".", "Model", ",", "adapter", "persist", ".", "Adapter", ")", "{", "e", ".", "adapter", "=", "adapter", "\n\n", "e", ".", "model", "=", "m", "\n", "e", ".", "model", ".", "PrintModel", "(", ")", "\n", "e", ".", "fm", "=", "model", ".", "LoadFunctionMap", "(", ")", "\n\n", "e", ".", "initialize", "(", ")", "\n\n", "// Do not initialize the full policy when using a filtered adapter", "fa", ",", "ok", ":=", "e", ".", "adapter", ".", "(", "persist", ".", "FilteredAdapter", ")", "\n", "if", "e", ".", "adapter", "!=", "nil", "&&", "(", "!", "ok", "||", "ok", "&&", "!", "fa", ".", "IsFiltered", "(", ")", ")", "{", "// error intentionally ignored", "e", ".", "LoadPolicy", "(", ")", "\n", "}", "\n", "}" ]

[ "InitWithModelAndAdapter", "initializes", "an", "enforcer", "with", "a", "model", "and", "a", "database", "adapter", "." ]

[ "func", "NewModel", "(", "text", "...", "string", ")", "model", ".", "Model", "{", "m", ":=", "make", "(", "model", ".", "Model", ")", "\n\n", "if", "len", "(", "text", ")", "==", "2", "{", "if", "text", "[", "0", "]", "!=", "\"", "\"", "{", "m", ".", "LoadModel", "(", "text", "[", "0", "]", ")", "\n", "}", "\n", "}", "else", "if", "len", "(", "text", ")", "==", "1", "{", "m", ".", "LoadModelFromText", "(", "text", "[", "0", "]", ")", "\n", "}", "else", "if", "len", "(", "text", ")", "!=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "m", "\n", "}" ]

[ "NewModel", "creates", "a", "model", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "SetModel", "(", "m", "model", ".", "Model", ")", "{", "e", ".", "model", "=", "m", "\n", "e", ".", "fm", "=", "model", ".", "LoadFunctionMap", "(", ")", "\n", "}" ]

[ "SetModel", "sets", "the", "current", "model", "." ]

[ "func", "(", "e", "*", "Enforcer", ")", "IsFiltered", "(", ")", "bool", "{", "filteredAdapter", ",", "ok", ":=", "e", ".", "adapter", ".", "(", "persist", ".", "FilteredAdapter", ")", "\n", "if", "!", "ok", "{", "return", "false", "\n", "}", "\n", "return", "filteredAdapter", ".", "IsFiltered", "(", ")", "\n", "}" ]

[ "IsFiltered", "returns", "true", "if", "the", "loaded", "policy", "has", "been", "filtered", "." ]

[ "func", "(", "ldb", "*", "LevelDb", ")", "Close", "(", ")", "(", "err", "error", ")", "{", "err", "=", "ldb", ".", "DB", ".", "Close", "(", ")", "\n", "// Hide the closer error.", "_", "=", "ldb", ".", "closer", ".", "Close", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "Close", "closes", "the", "DB", "." ]

[ "func", "(", "ldb", "*", "LevelDb", ")", "Get", "(", "key", "[", "]", "byte", ",", "ro", "*", "opt", ".", "ReadOptions", ")", "(", "value", "[", "]", "byte", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "WithStack", "(", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "ldb", ".", "DB", ".", "Get", "(", "key", ",", "ro", ")", "\n", "}" ]

[ "Get", "gets", "data", "from", "the", "DB", "." ]

[ "func", "(", "ldb", "*", "LevelDb", ")", "GetWithMeter", "(", "key", "[", "]", "byte", ",", "hitMeter", ",", "missMeter", "*", "CountMeter", ")", "(", "value", "[", "]", "byte", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "{", "if", "hitMeter", "!=", "nil", "{", "hitMeter", ".", "Mark", "(", "1", ")", "\n", "}", "\n", "}", "else", "if", "missMeter", "!=", "nil", "{", "missMeter", ".", "Mark", "(", "1", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "ldb", ".", "Get", "(", "key", ",", "nil", ")", "\n", "}" ]

[ "GetWithMeter", "gets", "data", "from", "the", "DB", "while", "tracking", "the", "hit", "rate", "." ]

[ "func", "(", "ldb", "*", "LevelDb", ")", "Put", "(", "key", ",", "value", "[", "]", "byte", ",", "wo", "*", "opt", ".", "WriteOptions", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "WithStack", "(", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "ldb", ".", "DB", ".", "Put", "(", "key", ",", "value", ",", "wo", ")", "\n", "}" ]

[ "Put", "puts", "data", "into", "the", "DB", "." ]

[ "func", "(", "ldb", "*", "LevelDb", ")", "PutWithMeter", "(", "key", ",", "value", "[", "]", "byte", ",", "putMeter", "*", "CountMeter", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "err", "==", "nil", "&&", "putMeter", "!=", "nil", "{", "putMeter", ".", "Mark", "(", "1", ")", "\n", "}", "\n", "}", "(", ")", "\n", "return", "ldb", ".", "Put", "(", "key", ",", "value", ",", "nil", ")", "\n", "}" ]

[ "PutWithMeter", "gets", "data", "from", "the", "DB", "while", "tracking", "the", "hit", "rate", "." ]

[ "func", "openLevelDBWithOptions", "(", "stor", "storage", ".", "Storage", ",", "options", "*", "opt", ".", "Options", ")", "(", "*", "LevelDb", ",", "error", ")", "{", "db", ",", "err", ":=", "leveldb", ".", "Open", "(", "stor", ",", "options", ")", "\n", "if", "ldberrors", ".", "IsCorrupted", "(", "err", ")", "{", "// There's a possibility that if the leveldb wasn't closed properly", "// last time while it was being written, then the manifest is corrupt.", "// This means leveldb must rebuild its manifest, which takes longer", "// than a simple `Open`.", "// TODO: log here", "db", ",", "err", "=", "leveldb", ".", "Recover", "(", "stor", ",", "options", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "stor", ".", "Close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "LevelDb", "{", "db", ",", "stor", "}", ",", "nil", "\n", "}" ]

[ "openLevelDB", "opens", "or", "recovers", "a", "leveldb", ".", "DB", "with", "a", "passed", "-", "in", "storage", ".", "Storage", "as", "its", "underlying", "storage", "layer", "and", "with", "the", "options", "specified", "." ]

[ "func", "openLevelDB", "(", "stor", "storage", ".", "Storage", ")", "(", "*", "LevelDb", ",", "error", ")", "{", "options", ":=", "*", "leveldbOptions", "\n", "options", ".", "Filter", "=", "filter", ".", "NewBloomFilter", "(", "16", ")", "\n", "return", "openLevelDBWithOptions", "(", "stor", ",", "&", "options", ")", "\n", "}" ]

[ "openLevelDB", "opens", "or", "recovers", "a", "leveldb", ".", "DB", "with", "a", "passed", "-", "in", "storage", ".", "Storage", "as", "its", "underlying", "storage", "layer", "." ]

[ "func", "openVersionedLevelDB", "(", "log", "logger", ".", "Logger", ",", "storageRoot", "string", ",", "dbFolderName", "string", ",", "currentDiskCacheVersion", "uint64", ",", "dbFilename", "string", ")", "(", "db", "*", "LevelDb", ",", "err", "error", ")", "{", "dbPath", ":=", "filepath", ".", "Join", "(", "storageRoot", ",", "dbFolderName", ")", "\n", "versionPath", ",", "err", ":=", "getVersionedPathForDiskCache", "(", "log", ",", "dbPath", ",", "dbFolderName", ",", "currentDiskCacheVersion", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "p", ":=", "filepath", ".", "Join", "(", "versionPath", ",", "dbFilename", ")", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "p", ")", "\n", "storage", ",", "err", ":=", "storage", ".", "OpenFile", "(", "p", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "storage", ".", "Close", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n", "options", ":=", "*", "leveldbOptions", "\n", "if", "db", ",", "err", "=", "openLevelDBWithOptions", "(", "storage", ",", "&", "options", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "db", ",", "nil", "\n", "}" ]

[ "openVersionedLevelDB", "opens", "a", "level", "DB", "under", "a", "versioned", "path", "on", "the", "local", "filesystem", "under", "storageRoot", ".", "The", "path", "include", "dbFolderName", "and", "dbFilename", ".", "Note", "that", "dbFilename", "is", "actually", "created", "as", "a", "folder", ";", "it", "s", "just", "where", "raw", "LevelDb", "lives", "." ]

[ "func", "ClassifyStream", "(", "r", "io", ".", "Reader", ")", "(", "sc", "StreamClassification", ",", "out", "io", ".", "Reader", ",", "err", "error", ")", "{", "// 4096 is currently the default buffer size. It is specified explicitly because go 1.9 does not", "// expose the size of a bufio.Reader (go 1.10 does).", "stream", ":=", "bufio", ".", "NewReaderSize", "(", "r", ",", "4096", ")", "\n\n", "buf", ",", "err", ":=", "stream", ".", "Peek", "(", "4096", ")", "\n", "if", "err", "!=", "nil", "{", "// If we had a short peek (for example, due to a short stream), we can still continue and ignore the error", "if", "len", "(", "buf", ")", "==", "0", "{", "return", "sc", ",", "stream", ",", "err", "\n", "}", "\n", "err", "=", "nil", "\n", "}", "\n\n", "sb", ":=", "string", "(", "buf", ")", "\n", "switch", "{", "case", "strings", ".", "HasPrefix", "(", "sb", ",", "\"", "\"", ")", ":", "sc", ".", "Format", "=", "CryptoMessageFormatPGP", "\n", "sc", ".", "Armored", "=", "true", "\n", "sc", ".", "Type", "=", "CryptoMessageTypeAmbiguous", "\n", "case", "strings", ".", "HasPrefix", "(", "sb", ",", "\"", "\"", ")", ":", "sc", ".", "Format", "=", "CryptoMessageFormatPGP", "\n", "sc", ".", "Armored", "=", "true", "\n", "sc", ".", "Type", "=", "CryptoMessageTypeDetachedSignature", "\n", "case", "strings", ".", "HasPrefix", "(", "sb", ",", "\"", "\"", ")", ":", "sc", ".", "Format", "=", "CryptoMessageFormatPGP", "\n", "sc", ".", "Armored", "=", "true", "\n", "sc", ".", "Type", "=", "CryptoMessageTypeClearSignature", "\n", "case", "isSaltpackMessage", "(", "stream", ",", "&", "sc", ")", ":", "// Format etc. set by isSaltpackBinary().", "case", "isBase64KeybaseV0Sig", "(", "sb", ")", ":", "sc", ".", "Format", "=", "CryptoMessageFormatKeybaseV0", "\n", "sc", ".", "Armored", "=", "true", "\n", "sc", ".", "Type", "=", "CryptoMessageTypeAttachedSignature", "\n", "case", "isPGPBinary", "(", "buf", ",", "&", "sc", ")", ":", "// Format etc. set by isPGPBinary().", "case", "isUTF16Mark", "(", "buf", ")", ":", "err", "=", "UTF16UnsupportedError", "{", "}", "\n", "default", ":", "err", "=", "UnknownStreamError", "{", "}", "\n", "}", "\n", "return", "sc", ",", "stream", ",", "err", "\n", "}" ]

[ "ClassifyStream", "takes", "a", "stream", "reader", "in", "and", "returns", "a", "likely", "classification", "of", "that", "stream", "without", "consuming", "any", "data", "from", "it", ".", "It", "returns", "a", "reader", "that", "you", "should", "read", "from", "instead", "in", "addition", "to", "the", "classification", ".", "If", "classification", "fails", "there", "will", "be", "a", "UnknownStreamError", "or", "additional", "EOF", "errors", "if", "the", "stream", "ended", "before", "classification", "could", "go", "." ]

[ "func", "(", "s", "*", "Identify3State", ")", "markShutdown", "(", "ch", "chan", "struct", "{", "}", ")", "bool", "{", "s", ".", "shutdownMu", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "shutdownMu", ".", "Unlock", "(", ")", "\n", "if", "s", ".", "shutdown", "{", "return", "false", "\n", "}", "\n", "s", ".", "shutdownCh", "<-", "ch", "\n", "s", ".", "shutdownCh", "=", "nil", "\n", "s", ".", "shutdown", "=", "true", "\n", "return", "true", "\n", "}" ]

[ "markShutdown", "marks", "this", "state", "as", "having", "shutdown", ".", "Will", "return", "true", "the", "first", "time", "through", "and", "false", "every", "other", "time", "." ]

[ "func", "(", "s", "*", "Identify3State", ")", "getSessionToExpire", "(", "mctx", "MetaContext", ",", "now", "time", ".", "Time", ")", "(", "*", "Identify3Session", ",", "time", ".", "Duration", ")", "{", "sess", ":=", "s", ".", "expirationQueue", "[", "0", "]", "\n", "sess", ".", "Lock", "(", ")", "\n", "defer", "sess", ".", "Unlock", "(", ")", "\n", "expireAt", ":=", "sess", ".", "created", ".", "Add", "(", "s", ".", "expireTime", ")", "\n", "diff", ":=", "expireAt", ".", "Sub", "(", "now", ")", "\n", "if", "diff", ">", "0", "{", "return", "nil", ",", "diff", "\n", "}", "\n", "s", ".", "expirationQueue", "=", "s", ".", "expirationQueue", "[", "1", ":", "]", "\n\n", "// Only send the expiration if the session is still in the cache table.", "// If not, that means it was already acted upon", "if", "_", ",", "found", ":=", "s", ".", "cache", "[", "sess", ".", "id", "]", ";", "!", "found", "{", "return", "nil", ",", "diff", "\n", "}", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "sess", ".", "id", ")", "\n", "s", ".", "removeFromTableLocked", "(", "sess", ".", "id", ")", "\n", "return", "sess", ",", "diff", "\n", "}" ]

[ "getSessionToExpire", "should", "be", "called", "when", "holding", "the", "Identify3State", "Mutex", ".", "It", "looks", "in", "the", "expiration", "queue", "and", "pops", "off", "those", "sessions", "that", "are", "ready", "to", "be", "marked", "expired", "." ]

[ "func", "(", "v", "*", "CmdConfigSet", ")", "looksLikeBool", "(", "s", "string", ")", "bool", "{", "switch", "s", "{", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "true", "\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "like", "strconv", ".", "ParseBool", "but", "without", "0", "and", "1", "." ]

[ "func", "NewCmdSimpleFSMove", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Action", ":", "func", "(", "c", "*", "cli", ".", "Context", ")", "{", "cl", ".", "ChooseCommand", "(", "&", "CmdSimpleFSMove", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "opCanceler", ":", "NewOpCanceler", "(", "g", ")", ",", "}", ",", "\"", "\"", ",", "c", ")", "\n", "cl", ".", "SetNoStandalone", "(", ")", "\n", "}", ",", "Flags", ":", "[", "]", "cli", ".", "Flag", "{", "cli", ".", "BoolFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "cli", ".", "BoolFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "NewCmdSimpleFSMove", "creates", "a", "new", "cli", ".", "Command", "." ]

[ "func", "Install", "(", "context", "Context", ",", "binPath", "string", ",", "sourcePath", "string", ",", "components", "[", "]", "string", ",", "force", "bool", ",", "timeout", "time", ".", "Duration", ",", "log", "Log", ")", "keybase1", ".", "InstallResult", "{", "return", "keybase1", ".", "InstallResult", "{", "}", "\n", "}" ]

[ "Install", "empty", "implementation", "for", "unsupported", "platforms" ]

[ "func", "Uninstall", "(", "context", "Context", ",", "components", "[", "]", "string", ",", "log", "Log", ")", "keybase1", ".", "UninstallResult", "{", "return", "keybase1", ".", "UninstallResult", "{", "}", "\n", "}" ]

[ "Uninstall", "empty", "implementation", "for", "unsupported", "platforms" ]

[ "func", "trackSyncPtrChangesInCreate", "(", "mostRecentTargetPtr", "data", ".", "BlockPointer", ",", "unmergedChain", "*", "crChain", ",", "unmergedChains", "*", "crChains", ",", "toName", "string", ")", "{", "targetChain", ",", "ok", ":=", "unmergedChains", ".", "byMostRecent", "[", "mostRecentTargetPtr", "]", "\n", "var", "refs", ",", "unrefs", "[", "]", "data", ".", "BlockPointer", "\n", "if", "ok", "&&", "targetChain", ".", "isFile", "(", ")", "{", "// The create op also needs to reference the child block ptrs", "// created by any sync ops (and not unreferenced by future", "// ones).", "for", "_", ",", "op", ":=", "range", "targetChain", ".", "ops", "{", "syncOp", ",", "ok", ":=", "op", ".", "(", "*", "syncOp", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "for", "_", ",", "ref", ":=", "range", "op", ".", "Refs", "(", ")", "{", "if", "!", "unmergedChains", ".", "isDeleted", "(", "ref", ")", "{", "refs", "=", "append", "(", "refs", ",", "ref", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "unref", ":=", "range", "op", ".", "Unrefs", "(", ")", "{", "unrefs", "=", "append", "(", "unrefs", ",", "unref", ")", "\n", "}", "\n", "// Account for the file ptr too, if it's the most recent.", "filePtr", ":=", "syncOp", ".", "File", ".", "Ref", "\n", "_", ",", "isMostRecent", ":=", "unmergedChains", ".", "byMostRecent", "[", "filePtr", "]", "\n", "if", "isMostRecent", "&&", "!", "unmergedChains", ".", "isDeleted", "(", "filePtr", ")", "{", "refs", "=", "append", "(", "refs", ",", "filePtr", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "len", "(", "refs", ")", ">", "0", "{", "for", "_", ",", "uop", ":=", "range", "unmergedChain", ".", "ops", "{", "cop", ",", "ok", ":=", "uop", ".", "(", "*", "createOp", ")", "\n", "if", "!", "ok", "||", "cop", ".", "NewName", "!=", "toName", "{", "continue", "\n", "}", "\n", "for", "_", ",", "ref", ":=", "range", "refs", "{", "cop", ".", "AddRefBlock", "(", "ref", ")", "\n", "}", "\n", "for", "_", ",", "unref", ":=", "range", "unrefs", "{", "cop", ".", "AddUnrefBlock", "(", "unref", ")", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n", "}" ]

[ "trackSyncPtrChangesInCreate", "makes", "sure", "the", "correct", "set", "of", "refs", "and", "unrefs", "from", "the", "syncOps", "on", "the", "unmerged", "branch", "makes", "it", "into", "the", "createOp", "for", "a", "new", "file", "." ]

[ "func", "(", "cal", "crActionList", ")", "collapse", "(", ")", "crActionList", "{", "// Order of precedence for a given fromName:", "// 1) renameUnmergedAction", "// 2) copyUnmergedEntryAction", "// 3) copyUnmergedAttrAction", "infoMap", ":=", "make", "(", "map", "[", "string", "]", "collapseActionInfo", ")", "// fromName -> info", "\n", "indicesToRemove", ":=", "make", "(", "map", "[", "int", "]", "bool", ")", "\n", "for", "i", ",", "untypedAction", ":=", "range", "cal", "{", "switch", "action", ":=", "untypedAction", ".", "(", "type", ")", "{", "// Unmerged actions:", "case", "*", "renameUnmergedAction", ":", "setTopAction", "(", "action", ",", "action", ".", "fromName", ",", "i", ",", "infoMap", ",", "indicesToRemove", ")", "\n", "case", "*", "copyUnmergedEntryAction", ":", "untypedTopAction", ":=", "infoMap", "[", "action", ".", "fromName", "]", ".", "topAction", "\n", "switch", "untypedTopAction", ".", "(", "type", ")", "{", "case", "*", "renameUnmergedAction", ":", "indicesToRemove", "[", "i", "]", "=", "true", "\n", "default", ":", "setTopAction", "(", "action", ",", "action", ".", "fromName", ",", "i", ",", "infoMap", ",", "indicesToRemove", ")", "\n", "}", "\n", "case", "*", "copyUnmergedAttrAction", ":", "untypedTopAction", ":=", "infoMap", "[", "action", ".", "fromName", "]", ".", "topAction", "\n", "switch", "topAction", ":=", "untypedTopAction", ".", "(", "type", ")", "{", "case", "*", "renameUnmergedAction", ":", "indicesToRemove", "[", "i", "]", "=", "true", "\n", "case", "*", "copyUnmergedEntryAction", ":", "indicesToRemove", "[", "i", "]", "=", "true", "\n", "case", "*", "copyUnmergedAttrAction", ":", "// Add attributes to the current top action, if not", "// already there.", "for", "_", ",", "a", ":=", "range", "action", ".", "attr", "{", "found", ":=", "false", "\n", "for", "_", ",", "topA", ":=", "range", "topAction", ".", "attr", "{", "if", "a", "==", "topA", "{", "found", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "topAction", ".", "attr", "=", "append", "(", "topAction", ".", "attr", ",", "a", ")", "\n", "}", "\n", "}", "\n", "indicesToRemove", "[", "i", "]", "=", "true", "\n", "default", ":", "setTopAction", "(", "action", ",", "action", ".", "fromName", ",", "i", ",", "infoMap", ",", "indicesToRemove", ")", "\n", "}", "\n\n", "// Merged actions", "case", "*", "renameMergedAction", ":", "// Prefix merged actions with a reserved prefix to keep", "// them separate from the unmerged actions.", "setTopAction", "(", "action", ",", "\"", "\"", "+", "action", ".", "fromName", ",", "i", ",", "infoMap", ",", "indicesToRemove", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "indicesToRemove", ")", "==", "0", "{", "return", "cal", "\n", "}", "\n\n", "newList", ":=", "make", "(", "crActionList", ",", "0", ",", "len", "(", "cal", ")", "-", "len", "(", "indicesToRemove", ")", ")", "\n", "for", "i", ",", "action", ":=", "range", "cal", "{", "if", "indicesToRemove", "[", "i", "]", "{", "continue", "\n", "}", "\n", "newList", "=", "append", "(", "newList", ",", "action", ")", "\n", "}", "\n\n", "return", "newList", "\n", "}" ]

[ "collapse", "drops", "any", "actions", "that", "are", "made", "irrelevant", "by", "other", "actions", "in", "the", "list", ".", "It", "assumes", "that", "file", "-", "related", "actions", "have", "already", "been", "merged", "into", "their", "parent", "directory", "action", "lists", "." ]

[ "func", "prepareNewUserEK", "(", "mctx", "libkb", ".", "MetaContext", ",", "merkleRoot", "libkb", ".", "MerkleRoot", ",", "pukSigning", "*", "libkb", ".", "NaclSigningKeyPair", ")", "(", "sig", "string", ",", "boxes", "[", "]", "keybase1", ".", "UserEkBoxMetadata", ",", "newMetadata", "keybase1", ".", "UserEkMetadata", ",", "myBox", "*", "keybase1", ".", "UserEkBoxed", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "seed", ",", "err", ":=", "newUserEphemeralSeed", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "newMetadata", ",", "nil", ",", "err", "\n", "}", "\n\n", "prevStatement", ",", "latestGeneration", ",", "wrongKID", ",", "err", ":=", "fetchUserEKStatement", "(", "mctx", ",", "mctx", ".", "G", "(", ")", ".", "Env", ".", "GetUID", "(", ")", ")", "\n", "if", "!", "wrongKID", "&&", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "newMetadata", ",", "nil", ",", "err", "\n", "}", "\n", "var", "newGeneration", "keybase1", ".", "EkGeneration", "\n", "if", "prevStatement", "==", "nil", "{", "// Even if the userEK statement was signed by the wrong key (this can", "// happen when legacy clients roll the PUK), fetchUserEKStatement will", "// return the generation number from the last (unverifiable) statement.", "// If there was never any statement, latestGeneration will be 0, so", "// adding one is correct in all cases.", "newGeneration", "=", "latestGeneration", "+", "1", "\n", "}", "else", "{", "newGeneration", "=", "prevStatement", ".", "CurrentUserEkMetadata", ".", "Generation", "+", "1", "\n", "}", "\n\n", "dhKeypair", ":=", "seed", ".", "DeriveDHKey", "(", ")", "\n\n", "metadata", ":=", "keybase1", ".", "UserEkMetadata", "{", "Kid", ":", "dhKeypair", ".", "GetKID", "(", ")", ",", "Generation", ":", "newGeneration", ",", "HashMeta", ":", "merkleRoot", ".", "HashMeta", "(", ")", ",", "// The ctime is derivable from the hash meta, by fetching the hashed", "// root from the server, but including it saves readers a potential", "// extra round trip.", "Ctime", ":", "keybase1", ".", "TimeFromSeconds", "(", "merkleRoot", ".", "Ctime", "(", ")", ")", ",", "}", "\n\n", "statement", ":=", "keybase1", ".", "UserEkStatement", "{", "CurrentUserEkMetadata", ":", "metadata", ",", "}", "\n", "statementJSON", ",", "err", ":=", "json", ".", "Marshal", "(", "statement", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "newMetadata", ",", "nil", ",", "err", "\n", "}", "\n", "sig", ",", "_", ",", "err", "=", "pukSigning", ".", "SignToString", "(", "statementJSON", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "newMetadata", ",", "nil", ",", "err", "\n", "}", "\n\n", "boxes", ",", "myUserEKBoxed", ",", "err", ":=", "boxUserEKForDevices", "(", "mctx", ",", "merkleRoot", ",", "seed", ",", "metadata", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "newMetadata", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "sig", ",", "boxes", ",", "metadata", ",", "myUserEKBoxed", ",", "nil", "\n", "}" ]

[ "There", "are", "two", "cases", "where", "we", "need", "to", "generate", "a", "new", "userEK", ".", "One", "is", "where", "we", "re", "rolling", "the", "userEK", "by", "itself", "and", "we", "need", "to", "sign", "it", "with", "the", "current", "PUK", ".", "The", "other", "is", "where", "we", "re", "rolling", "the", "PUK", "and", "we", "need", "to", "sign", "a", "new", "userEK", "with", "the", "new", "PUK", "to", "upload", "both", "together", ".", "This", "helper", "covers", "the", "steps", "common", "to", "both", "cases", "." ]

[ "func", "publishNewUserEK", "(", "mctx", "libkb", ".", "MetaContext", ",", "merkleRoot", "libkb", ".", "MerkleRoot", ")", "(", "metadata", "keybase1", ".", "UserEkMetadata", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// Sign the statement blob with the latest PUK.", "pukKeyring", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetPerUserKeyring", "(", "mctx", ".", "Ctx", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "metadata", ",", "err", "\n", "}", "\n", "if", "err", ":=", "pukKeyring", ".", "Sync", "(", "mctx", ")", ";", "err", "!=", "nil", "{", "return", "metadata", ",", "err", "\n", "}", "\n", "if", "!", "pukKeyring", ".", "HasAnyKeys", "(", ")", "{", "return", "metadata", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "pukSigning", ",", "err", ":=", "pukKeyring", ".", "GetLatestSigningKey", "(", "mctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "metadata", ",", "err", "\n", "}", "\n\n", "sig", ",", "boxes", ",", "newMetadata", ",", "myBox", ",", "err", ":=", "prepareNewUserEK", "(", "mctx", ",", "merkleRoot", ",", "pukSigning", ")", "\n", "if", "err", "!=", "nil", "{", "return", "metadata", ",", "err", "\n", "}", "\n\n", "if", "err", "=", "postNewUserEK", "(", "mctx", ",", "sig", ",", "boxes", ")", ";", "err", "!=", "nil", "{", "return", "metadata", ",", "err", "\n", "}", "\n\n", "// Cache the new box after we see the post succeeded.", "if", "myBox", "==", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "else", "{", "storage", ":=", "mctx", ".", "G", "(", ")", ".", "GetUserEKBoxStorage", "(", ")", "\n", "err", "=", "storage", ".", "Put", "(", "mctx", ",", "newMetadata", ".", "Generation", ",", "*", "myBox", ")", "\n", "}", "\n", "return", "newMetadata", ",", "err", "\n", "}" ]

[ "Create", "a", "new", "userEK", "and", "upload", "it", ".", "Add", "our", "box", "to", "the", "local", "box", "store", "." ]

[ "func", "fetchUserEKStatements", "(", "mctx", "libkb", ".", "MetaContext", ",", "uids", "[", "]", "keybase1", ".", "UID", ")", "(", "statements", "map", "[", "keybase1", ".", "UID", "]", "*", "keybase1", ".", "UserEkStatement", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "uids", ")", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "apiArg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "Args", ":", "libkb", ".", "HTTPArgs", "{", "\"", "\"", ":", "libkb", ".", "S", "{", "Val", ":", "libkb", ".", "UidsToString", "(", "uids", ")", "}", ",", "}", ",", "}", "\n", "res", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetAPI", "(", ")", ".", "Post", "(", "mctx", ",", "apiArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "parsedResponse", ":=", "userEKStatementResponse", "{", "}", "\n", "err", "=", "res", ".", "Body", ".", "UnmarshalAgain", "(", "&", "parsedResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "statements", "=", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "*", "keybase1", ".", "UserEkStatement", ")", "\n", "for", "uid", ",", "sig", ":=", "range", "parsedResponse", ".", "Sigs", "{", "statement", ",", "_", ",", "wrongKID", ",", "err", ":=", "verifySigWithLatestPUK", "(", "mctx", ",", "uid", ",", "*", "sig", ")", "\n", "// Check the wrongKID condition before checking the error, since an error", "// is still returned in this case. TODO: Turn this warning into an error", "// after EK support is sufficiently widespread.", "if", "wrongKID", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "// Don't include this statement since it is invalid.", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "statements", "[", "uid", "]", "=", "statement", "\n", "}", "\n\n", "return", "statements", ",", "nil", "\n", "}" ]

[ "Returns", "nil", "if", "the", "user", "has", "never", "published", "a", "userEK", ".", "If", "the", "user", "has", "published", "a", "userEK", "but", "has", "since", "rolled", "their", "PUK", "without", "publishing", "a", "new", "one", "this", "function", "will", "also", "return", "nil", "and", "log", "a", "warning", ".", "This", "is", "a", "transitional", "thing", "and", "eventually", "when", "all", "reasonably", "up", "to", "date", "clients", "in", "the", "wild", "have", "EK", "support", "we", "will", "make", "that", "case", "an", "error", "." ]

[ "func", "fetchUserEKStatement", "(", "mctx", "libkb", ".", "MetaContext", ",", "uid", "keybase1", ".", "UID", ")", "(", "statement", "*", "keybase1", ".", "UserEkStatement", ",", "latestGeneration", "keybase1", ".", "EkGeneration", ",", "wrongKID", "bool", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "apiArg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "Args", ":", "libkb", ".", "HTTPArgs", "{", "\"", "\"", ":", "libkb", ".", "S", "{", "Val", ":", "libkb", ".", "UidsToString", "(", "[", "]", "keybase1", ".", "UID", "{", "uid", "}", ")", "}", ",", "}", ",", "}", "\n", "res", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetAPI", "(", ")", ".", "Get", "(", "mctx", ",", "apiArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "err", "\n", "}", "\n\n", "parsedResponse", ":=", "userEKStatementResponse", "{", "}", "\n", "err", "=", "res", ".", "Body", ".", "UnmarshalAgain", "(", "&", "parsedResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "err", "\n", "}", "\n", "// User has no statements", "if", "len", "(", "parsedResponse", ".", "Sigs", ")", "==", "0", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "nil", "\n", "}", "\n", "if", "len", "(", "parsedResponse", ".", "Sigs", ")", "!=", "1", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "sig", ",", "ok", ":=", "parsedResponse", ".", "Sigs", "[", "uid", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "statement", ",", "latestGeneration", ",", "wrongKID", ",", "err", "=", "verifySigWithLatestPUK", "(", "mctx", ",", "uid", ",", "*", "sig", ")", "\n", "// Check the wrongKID condition before checking the error, since an error", "// is still returned in this case. TODO: Turn this warning into an error", "// after EK support is sufficiently widespread.", "if", "wrongKID", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "latestGeneration", ",", "true", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "err", "\n", "}", "\n\n", "return", "statement", ",", "latestGeneration", ",", "false", ",", "nil", "\n", "}" ]

[ "Returns", "nil", "if", "the", "user", "has", "never", "published", "a", "userEK", ".", "If", "the", "user", "has", "published", "a", "userEK", "but", "has", "since", "rolled", "their", "PUK", "without", "publishing", "a", "new", "one", "this", "function", "will", "return", "wrongKID", ".", "This", "allows", "clients", "to", "chose", "the", "correct", "generation", "number", "but", "not", "include", "the", "statement", "when", "generating", "a", "new", "userEK", "." ]

[ "func", "GetEphemeralPublicKeyInfoV2", "(", "info", "TLFCryptKeyInfo", ",", "wkb", "TLFWriterKeyBundleV2", ",", "rkb", "TLFReaderKeyBundleV2", ")", "(", "keyLocation", "EPubKeyLocationV2", ",", "index", "int", ",", "ePubKey", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "err", "error", ")", "{", "var", "publicKeys", "kbfscrypto", ".", "TLFEphemeralPublicKeys", "\n", "if", "info", ".", "EPubKeyIndex", ">=", "0", "{", "index", "=", "info", ".", "EPubKeyIndex", "\n", "publicKeys", "=", "wkb", ".", "TLFEphemeralPublicKeys", "\n", "keyLocation", "=", "WriterEPubKeys", "\n", "}", "else", "{", "index", "=", "-", "1", "-", "info", ".", "EPubKeyIndex", "\n", "publicKeys", "=", "rkb", ".", "TLFReaderEphemeralPublicKeys", "\n", "keyLocation", "=", "ReaderEPubKeys", "\n", "}", "\n", "keyCount", ":=", "len", "(", "publicKeys", ")", "\n", "if", "index", ">=", "keyCount", "{", "return", "EPubKeyLocationV2", "(", "0", ")", ",", "0", ",", "kbfscrypto", ".", "TLFEphemeralPublicKey", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyLocation", ",", "index", ",", "keyCount", ")", "\n", "}", "\n\n", "return", "keyLocation", ",", "index", ",", "publicKeys", "[", "index", "]", ",", "nil", "\n", "}" ]

[ "GetEphemeralPublicKeyInfoV2", "encapsulates", "all", "the", "ugly", "logic", "needed", "to", "deal", "with", "the", "negative", "hack", "from", "RootMetadataV2", ".", "UpdateKeyGeneration", "." ]

[ "func", "(", "wkb", "TLFWriterKeyBundleV2", ")", "IsWriter", "(", "user", "keybase1", ".", "UID", ",", "deviceKey", "kbfscrypto", ".", "CryptPublicKey", ")", "bool", "{", "_", ",", "ok", ":=", "wkb", ".", "WKeys", "[", "user", "]", "[", "deviceKey", ".", "KID", "(", ")", "]", "\n", "return", "ok", "\n", "}" ]

[ "IsWriter", "returns", "true", "if", "the", "given", "user", "device", "is", "in", "the", "writer", "set", "." ]

[ "func", "(", "wkg", "TLFWriterKeyGenerationsV2", ")", "IsWriter", "(", "user", "keybase1", ".", "UID", ",", "deviceKey", "kbfscrypto", ".", "CryptPublicKey", ")", "bool", "{", "keyGen", ":=", "wkg", ".", "LatestKeyGeneration", "(", ")", "\n", "if", "keyGen", "<", "1", "{", "return", "false", "\n", "}", "\n", "return", "wkg", "[", "keyGen", "-", "1", "]", ".", "IsWriter", "(", "user", ",", "deviceKey", ")", "\n", "}" ]

[ "IsWriter", "returns", "whether", "or", "not", "the", "user", "+", "device", "is", "an", "authorized", "writer", "for", "the", "latest", "generation", "." ]

[ "func", "(", "wkg", "TLFWriterKeyGenerationsV2", ")", "ToTLFWriterKeyBundleV3", "(", "codec", "kbfscodec", ".", "Codec", ",", "tlfCryptKeyGetter", "func", "(", ")", "(", "[", "]", "kbfscrypto", ".", "TLFCryptKey", ",", "error", ")", ")", "(", "TLFWriterKeyBundleV2", ",", "TLFWriterKeyBundleV3", ",", "error", ")", "{", "keyGen", ":=", "wkg", ".", "LatestKeyGeneration", "(", ")", "\n", "if", "keyGen", "<", "FirstValidKeyGen", "{", "return", "TLFWriterKeyBundleV2", "{", "}", ",", "TLFWriterKeyBundleV3", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Copy the latest UserDeviceKeyInfoMap.", "wkbV2", ":=", "wkg", "[", "keyGen", "-", "FirstValidKeyGen", "]", "\n", "ePubKeyCount", ":=", "len", "(", "wkbV2", ".", "TLFEphemeralPublicKeys", ")", "\n", "udkimV3", ",", "err", ":=", "writerUDKIMV2ToV3", "(", "codec", ",", "wkbV2", ".", "WKeys", ",", "ePubKeyCount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TLFWriterKeyBundleV2", "{", "}", ",", "TLFWriterKeyBundleV3", "{", "}", ",", "err", "\n", "}", "\n", "wkbV3", ":=", "TLFWriterKeyBundleV3", "{", "Keys", ":", "udkimV3", ",", "TLFEphemeralPublicKeys", ":", "make", "(", "kbfscrypto", ".", "TLFEphemeralPublicKeys", ",", "ePubKeyCount", ")", ",", "TLFPublicKey", ":", "wkbV2", ".", "TLFPublicKey", ",", "}", "\n", "// Copy all of the TLFEphemeralPublicKeys at this generation.", "copy", "(", "wkbV3", ".", "TLFEphemeralPublicKeys", "[", ":", "]", ",", "wkbV2", ".", "TLFEphemeralPublicKeys", ")", "\n\n", "if", "keyGen", ">", "FirstValidKeyGen", "{", "// Fetch all of the TLFCryptKeys.", "keys", ",", "err", ":=", "tlfCryptKeyGetter", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TLFWriterKeyBundleV2", "{", "}", ",", "TLFWriterKeyBundleV3", "{", "}", ",", "err", "\n", "}", "\n", "// Sanity check.", "if", "len", "(", "keys", ")", "!=", "int", "(", "keyGen", ")", "{", "return", "TLFWriterKeyBundleV2", "{", "}", ",", "TLFWriterKeyBundleV3", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyGen", ",", "len", "(", "keys", ")", ")", "\n", "}", "\n", "// Save the current key.", "currKey", ":=", "keys", "[", "len", "(", "keys", ")", "-", "1", "]", "\n", "// Get rid of the most current generation as that's in the UserDeviceKeyInfoMap already.", "keys", "=", "keys", "[", ":", "len", "(", "keys", ")", "-", "1", "]", "\n", "// Encrypt the historic keys with the current key.", "wkbV3", ".", "EncryptedHistoricTLFCryptKeys", ",", "err", "=", "kbfscrypto", ".", "EncryptTLFCryptKeys", "(", "codec", ",", "keys", ",", "currKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TLFWriterKeyBundleV2", "{", "}", ",", "TLFWriterKeyBundleV3", "{", "}", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "wkbV2", ",", "wkbV3", ",", "nil", "\n", "}" ]

[ "ToTLFWriterKeyBundleV3", "converts", "a", "TLFWriterKeyGenerationsV2", "to", "a", "TLFWriterKeyBundleV3", "." ]

[ "func", "(", "rkg", "TLFReaderKeyGenerationsV2", ")", "IsReader", "(", "user", "keybase1", ".", "UID", ",", "deviceKey", "kbfscrypto", ".", "CryptPublicKey", ")", "bool", "{", "keyGen", ":=", "rkg", ".", "LatestKeyGeneration", "(", ")", "\n", "if", "keyGen", "<", "1", "{", "return", "false", "\n", "}", "\n", "return", "rkg", "[", "keyGen", "-", "1", "]", ".", "IsReader", "(", "user", ",", "deviceKey", ")", "\n", "}" ]

[ "IsReader", "returns", "whether", "or", "not", "the", "user", "+", "device", "is", "an", "authorized", "reader", "for", "the", "latest", "generation", "." ]

[ "func", "(", "rkg", "TLFReaderKeyGenerationsV2", ")", "ToTLFReaderKeyBundleV3", "(", "codec", "kbfscodec", ".", "Codec", ",", "wkb", "TLFWriterKeyBundleV2", ")", "(", "TLFReaderKeyBundleV3", ",", "error", ")", "{", "keyGen", ":=", "rkg", ".", "LatestKeyGeneration", "(", ")", "\n", "if", "keyGen", "<", "FirstValidKeyGen", "{", "return", "TLFReaderKeyBundleV3", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "rkbV3", ":=", "TLFReaderKeyBundleV3", "{", "Keys", ":", "make", "(", "UserDeviceKeyInfoMapV3", ")", ",", "}", "\n\n", "// Copy the latest UserDeviceKeyInfoMap.", "rkb", ":=", "rkg", "[", "keyGen", "-", "FirstValidKeyGen", "]", "\n\n", "// Copy all of the TLFReaderEphemeralPublicKeys.", "rkbV3", ".", "TLFEphemeralPublicKeys", "=", "make", "(", "kbfscrypto", ".", "TLFEphemeralPublicKeys", ",", "len", "(", "rkb", ".", "TLFReaderEphemeralPublicKeys", ")", ")", "\n", "copy", "(", "rkbV3", ".", "TLFEphemeralPublicKeys", "[", ":", "]", ",", "rkb", ".", "TLFReaderEphemeralPublicKeys", ")", "\n\n", "// Track a mapping of old writer ephemeral pubkey index to new", "// reader ephemeral pubkey index.", "pubKeyIndicesMap", ":=", "make", "(", "map", "[", "int", "]", "int", ")", "\n\n", "// We need to copy these in a slightly annoying way to work around", "// the negative index hack. In V3 readers always have their ePubKey", "// in the TLFReaderEphemeralPublicKeys list. In V2 they only do if", "// the index is negative. Otherwise it's in the writer's list.", "for", "uid", ",", "dkim", ":=", "range", "rkb", ".", "RKeys", "{", "dkimV3", ":=", "make", "(", "DeviceKeyInfoMapV3", ")", "\n", "for", "kid", ",", "info", ":=", "range", "dkim", "{", "var", "infoCopy", "TLFCryptKeyInfo", "\n", "err", ":=", "kbfscodec", ".", "Update", "(", "codec", ",", "&", "infoCopy", ",", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TLFReaderKeyBundleV3", "{", "}", ",", "err", "\n", "}", "\n\n", "keyLocation", ",", "index", ",", "ePubKey", ",", "err", ":=", "GetEphemeralPublicKeyInfoV2", "(", "info", ",", "wkb", ",", "rkb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "TLFReaderKeyBundleV3", "{", "}", ",", "err", "\n", "}", "\n\n", "switch", "keyLocation", "{", "case", "WriterEPubKeys", ":", "// Map the old index in the writer list to a new index", "// at the end of the reader list.", "newIndex", ",", "ok", ":=", "pubKeyIndicesMap", "[", "index", "]", "\n", "if", "!", "ok", "{", "rkbV3", ".", "TLFEphemeralPublicKeys", "=", "append", "(", "rkbV3", ".", "TLFEphemeralPublicKeys", ",", "ePubKey", ")", "\n", "// TODO: This index depends on", "// map iteration order, which", "// varies. Impose a consistent", "// order on these indices.", "newIndex", "=", "len", "(", "rkbV3", ".", "TLFEphemeralPublicKeys", ")", "-", "1", "\n", "pubKeyIndicesMap", "[", "index", "]", "=", "newIndex", "\n", "}", "\n", "infoCopy", ".", "EPubKeyIndex", "=", "newIndex", "\n", "case", "ReaderEPubKeys", ":", "// Use the real index in the reader list.", "infoCopy", ".", "EPubKeyIndex", "=", "index", "\n", "default", ":", "return", "TLFReaderKeyBundleV3", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyLocation", ")", "\n", "}", "\n", "dkimV3", "[", "kbfscrypto", ".", "MakeCryptPublicKey", "(", "kid", ")", "]", "=", "infoCopy", "\n", "}", "\n", "rkbV3", ".", "Keys", "[", "uid", "]", "=", "dkimV3", "\n", "}", "\n", "return", "rkbV3", ",", "nil", "\n", "}" ]

[ "ToTLFReaderKeyBundleV3", "converts", "a", "TLFReaderKeyGenerationsV2", "to", "a", "TLFReaderkeyBundleV3", "." ]

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

[ "NewPaperKey", "creates", "a", "PaperKey", "engine", "." ]

[ "func", "GetAndVerifyPerTeamKey", "(", "mctx", "libkb", ".", "MetaContext", ",", "teamData", "*", "keybase1", ".", "TeamData", ",", "gen", "keybase1", ".", "PerTeamKeyGeneration", ")", "(", "ret", "keybase1", ".", "PerTeamKeySeedItem", ",", "err", "error", ")", "{", "ret", ",", "ok", ":=", "teamData", ".", "PerTeamKeySeedsUnverified", "[", "gen", "]", "\n", "if", "!", "ok", "{", "return", "ret", ",", "libkb", ".", "NotFoundError", "{", "Msg", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "gen", ")", "}", "\n", "}", "\n\n", "km", ",", "err", ":=", "NewTeamKeyManagerWithSecret", "(", "ret", ".", "Seed", ",", "gen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ret", ",", "err", "\n", "}", "\n\n", "chainKey", ",", "err", ":=", "TeamSigChainState", "{", "inner", ":", "teamData", ".", "Chain", "}", ".", "GetPerTeamKeyAtGeneration", "(", "gen", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ret", ",", "err", "\n", "}", "\n\n", "// Takes roughly 280us on android (Honor 6X)", "localSigKey", ",", "err", ":=", "km", ".", "SigningKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ret", ",", "err", "\n", "}", "\n\n", "// Takes roughly 900us on android (Honor 6X)", "localEncKey", ",", "err", ":=", "km", ".", "EncryptionKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ret", ",", "err", "\n", "}", "\n\n", "if", "!", "chainKey", ".", "SigKID", ".", "SecureEqual", "(", "localSigKey", ".", "GetKID", "(", ")", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "gen", ",", "localSigKey", ".", "GetKID", "(", ")", ",", "chainKey", ".", "SigKID", ")", "\n", "return", "ret", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "gen", ")", "\n", "}", "\n\n", "if", "!", "chainKey", ".", "EncKID", ".", "SecureEqual", "(", "localEncKey", ".", "GetKID", "(", ")", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "gen", ",", "localEncKey", ".", "GetKID", "(", ")", ",", "chainKey", ".", "EncKID", ")", "\n", "return", "ret", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "gen", ")", "\n", "}", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "Get", "a", "PTK", "seed", "and", "verify", "against", "the", "sigchain", "that", "is", "the", "correct", "key", "." ]

[ "func", "(", "t", "*", "TeamKeyManager", ")", "SigningKey", "(", ")", "(", "libkb", ".", "NaclSigningKeyPair", ",", "error", ")", "{", "if", "t", ".", "signingKey", "==", "nil", "{", "key", ",", "err", ":=", "libkb", ".", "MakeNaclSigningKeyPairFromSecretBytes", "(", "derivedSecret", "(", "t", ".", "sharedSecret", ",", "libkb", ".", "TeamEdDSADerivationString", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "libkb", ".", "NaclSigningKeyPair", "{", "}", ",", "err", "\n", "}", "\n", "t", ".", "signingKey", "=", "&", "key", "\n", "}", "\n", "return", "*", "t", ".", "signingKey", ",", "nil", "\n", "}" ]

[ "EncryptionKey", "returns", "the", "derived", "NaclSigningKeyPair", "from", "the", "team", "s", "shared", "secret", "." ]

[ "func", "(", "t", "*", "TeamKeyManager", ")", "EncryptionKey", "(", ")", "(", "libkb", ".", "NaclDHKeyPair", ",", "error", ")", "{", "if", "t", ".", "encryptionKey", "==", "nil", "{", "key", ",", "err", ":=", "libkb", ".", "MakeNaclDHKeyPairFromSecretBytes", "(", "derivedSecret", "(", "t", ".", "sharedSecret", ",", "libkb", ".", "TeamDHDerivationString", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "libkb", ".", "NaclDHKeyPair", "{", "}", ",", "err", "\n", "}", "\n", "t", ".", "encryptionKey", "=", "&", "key", "\n", "}", "\n", "return", "*", "t", ".", "encryptionKey", ",", "nil", "\n", "}" ]

[ "EncryptionKey", "returns", "the", "derived", "NaclDHKeyPair", "from", "the", "team", "s", "shared", "secret", "." ]

[ "func", "(", "t", "*", "TeamKeyManager", ")", "SharedSecretBoxes", "(", "mctx", "libkb", ".", "MetaContext", ",", "senderKey", "libkb", ".", "GenericKey", ",", "recipients", "map", "[", "keybase1", ".", "UserVersion", "]", "keybase1", ".", "PerUserKey", ")", "(", "boxes", "*", "PerTeamSharedSecretBoxes", ",", "err", "error", ")", "{", "defer", "mctx", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// make the nonce prefix, skipping the zero counter", "// (0 used for previous key encryption nonce)", "n", ",", "err", ":=", "newNonce24SkipZero", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// make the recipient boxes with the new secret and the nonce prefix", "return", "t", ".", "sharedBoxes", "(", "t", ".", "sharedSecret", ",", "t", ".", "generation", ",", "n", ",", "senderKey", ",", "recipients", ")", "\n", "}" ]

[ "SharedSecretBoxes", "creates", "the", "PerTeamSharedSecretBoxes", "for", "recipients", "with", "the", "existing", "team", "shared", "secret", "." ]

[ "func", "(", "t", "*", "TeamKeyManager", ")", "RotateSharedSecretBoxes", "(", "mctx", "libkb", ".", "MetaContext", ",", "senderKey", "libkb", ".", "GenericKey", ",", "recipients", "map", "[", "keybase1", ".", "UserVersion", "]", "keybase1", ".", "PerUserKey", ")", "(", "boxes", "*", "PerTeamSharedSecretBoxes", ",", "keySection", "*", "SCPerTeamKey", ",", "err", "error", ")", "{", "defer", "mctx", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// make a new secret", "nextSecret", ",", "err", ":=", "newSharedSecret", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "// derive new key from new secret for PrevKey", "key", ":=", "derivedSecret", "(", "nextSecret", ",", "libkb", ".", "TeamPrevKeySecretBoxDerivationString", ")", "\n", "var", "keyb", "[", "32", "]", "byte", "\n", "copy", "(", "keyb", "[", ":", "]", ",", "key", ")", "\n\n", "// encrypt existing secret with derived key and nonce counter 0", "nonce", ",", "err", ":=", "newNonce24", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "nonceBytes", ",", "counter", ":=", "nonce", ".", "Nonce", "(", ")", "\n", "if", "counter", "!=", "0", "{", "// this should never happen, but might as well make sure it is zero", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "sealed", ":=", "secretbox", ".", "Seal", "(", "nil", ",", "t", ".", "sharedSecret", ".", "ToBytes", "(", ")", ",", "&", "nonceBytes", ",", "&", "keyb", ")", "\n\n", "// encode encrypted prev key", "prevKeyEncoded", ",", "err", ":=", "encodeSealedPrevKey", "(", "nonceBytes", ",", "sealed", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "// make the recipient boxes with the new secret and the incrementing nonce24", "t", ".", "setNextSharedSecret", "(", "mctx", ",", "nextSecret", ")", "\n", "boxes", ",", "err", "=", "t", ".", "sharedBoxes", "(", "t", ".", "sharedSecret", ",", "t", ".", "generation", ",", "nonce", ",", "senderKey", ",", "recipients", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "// insert encoded encrypted PrevKey", "boxes", ".", "PrevKey", "=", "&", "prevKeyEncoded", "\n\n", "// need a new PerTeamKey section since the key was rotated", "keySection", ",", "err", "=", "t", ".", "perTeamKeySection", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "boxes", ",", "keySection", ",", "nil", "\n", "}" ]

[ "RotateSharedSecretBoxes", "creates", "a", "new", "shared", "secret", "for", "the", "team", "and", "the", "required", "PerTeamKey", "section", "." ]

[ "func", "(", "d", "*", "DirtyBlockCacheDisk", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "ptr", "data", ".", "BlockPointer", ",", "branch", "data", ".", "BranchName", ")", "(", "data", ".", "Block", ",", "error", ")", "{", "if", "branch", "!=", "d", ".", "branch", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "branch", ",", "d", ".", "branch", ")", "\n", "}", "\n\n", "info", ",", "ok", ":=", "d", ".", "getInfo", "(", "ptr", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "data", ".", "NoSuchBlockError", "{", "ID", ":", "ptr", ".", "ID", "}", "\n", "}", "\n\n", "// Look it up under the temp ID, which is an actual hash that can", "// be verified.", "data", ",", "serverHalf", ",", "_", ",", "err", ":=", "d", ".", "diskCache", ".", "Get", "(", "ctx", ",", "tlfID", ",", "info", ".", "tmpPtr", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "block", ":=", "info", ".", "newBlock", "(", ")", "\n", "err", "=", "assembleBlock", "(", "ctx", ",", "d", ".", "config", ".", "keyGetter", "(", ")", ",", "d", ".", "config", ".", "Codec", "(", ")", ",", "d", ".", "config", ".", "cryptoPure", "(", ")", ",", "d", ".", "kmd", ",", "info", ".", "tmpPtr", ",", "block", ",", "data", ",", "serverHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "block", ",", "nil", "\n", "}" ]

[ "Get", "implements", "the", "DirtyBlockCache", "interface", "for", "DirtyBlockCacheDisk", "." ]

[ "func", "(", "d", "*", "DirtyBlockCacheDisk", ")", "Put", "(", "ctx", "context", ".", "Context", ",", "tlfID", "tlf", ".", "ID", ",", "ptr", "data", ".", "BlockPointer", ",", "branch", "data", ".", "BranchName", ",", "block", "data", ".", "Block", ")", "error", "{", "if", "branch", "!=", "d", ".", "branch", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "branch", ",", "d", ".", "branch", ")", "\n", "}", "\n\n", "// Need to ready the block, since the disk cache expects encrypted", "// data and a block ID that can be verified against that data.", "id", ",", "_", ",", "readyBlockData", ",", "err", ":=", "d", ".", "config", ".", "BlockOps", "(", ")", ".", "Ready", "(", "ctx", ",", "d", ".", "kmd", ",", "block", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "err", "=", "d", ".", "diskCache", ".", "Put", "(", "ctx", ",", "tlfID", ",", "id", ",", "readyBlockData", ".", "Buf", ",", "readyBlockData", ".", "ServerHalf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "directType", ":=", "data", ".", "DirectBlock", "\n", "if", "block", ".", "IsIndirect", "(", ")", "{", "directType", "=", "data", ".", "IndirectBlock", "\n", "}", "\n", "_", ",", "isDir", ":=", "block", ".", "(", "*", "data", ".", "DirBlock", ")", "\n\n", "info", ":=", "dirtyBlockCacheDiskInfo", "{", "tmpPtr", ":", "data", ".", "BlockPointer", "{", "ID", ":", "id", ",", "KeyGen", ":", "d", ".", "kmd", ".", "LatestKeyGeneration", "(", ")", ",", "DataVer", ":", "block", ".", "DataVersion", "(", ")", ",", "DirectType", ":", "directType", ",", "}", ",", "isDir", ":", "isDir", ",", "}", "\n", "d", ".", "saveInfo", "(", "ptr", ",", "info", ")", "\n\n", "// TODO: have an in-memory LRU cache of limited size to optimize", "// frequent block access?", "return", "nil", "\n", "}" ]

[ "Put", "implements", "the", "DirtyBlockCache", "interface", "for", "DirtyBlockCacheDisk", ".", "Note", "than", "any", "modifications", "made", "to", "block", "after", "the", "Put", "will", "require", "another", "Put", "call", "in", "order", "for", "them", "to", "be", "reflected", "in", "the", "next", "Get", "call", "for", "that", "block", "pointer", "." ]

[ "func", "(", "c", "*", "CmdTeamDelete", ")", "listSubteamsRecursive", "(", "cli", "*", "keybase1", ".", "TeamsClient", ")", "(", "res", "[", "]", "keybase1", ".", "TeamName", ",", "err", "error", ")", "{", "subs", ",", "err", ":=", "cli", ".", "TeamListSubteamsRecursive", "(", "context", ".", "TODO", "(", ")", ",", "keybase1", ".", "TeamListSubteamsRecursiveArg", "{", "ParentTeamName", ":", "c", ".", "Team", ".", "String", "(", ")", ",", "ForceRepoll", ":", "true", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "// Sort the response alphabetically", "sort", ".", "Slice", "(", "subs", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "subs", "[", "i", "]", ".", "Name", ".", "String", "(", ")", "<", "subs", "[", "j", "]", ".", "Name", ".", "String", "(", ")", "\n", "}", ")", "\n", "for", "_", ",", "sub", ":=", "range", "subs", "{", "res", "=", "append", "(", "res", ",", "sub", ".", "Name", ")", "\n", "}", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "List", "the", "subteams", "of", "c", ".", "Team" ]

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

[ "NewProveHandler", "makes", "a", "new", "ProveHandler", "object", "from", "an", "RPC", "transport", "." ]

[ "func", "(", "ph", "*", "ProveHandler", ")", "StartProof", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "StartProofArg", ")", "(", "res", "keybase1", ".", "StartProofResult", ",", "err", "error", ")", "{", "ctx", "=", "libkb", ".", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "ph", ".", "G", "(", ")", ".", "CTraceTimed", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "arg", ".", "Service", ",", "arg", ".", "Username", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "eng", ":=", "engine", ".", "NewProve", "(", "ph", ".", "G", "(", ")", ",", "&", "arg", ")", "\n", "uis", ":=", "libkb", ".", "UIs", "{", "ProveUI", ":", "ph", ".", "getProveUI", "(", "arg", ".", "SessionID", ")", ",", "SecretUI", ":", "ph", ".", "getSecretUI", "(", "arg", ".", "SessionID", ",", "ph", ".", "G", "(", ")", ")", ",", "LogUI", ":", "ph", ".", "getLogUI", "(", "arg", ".", "SessionID", ")", ",", "SessionID", ":", "arg", ".", "SessionID", ",", "}", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "ph", ".", "G", "(", ")", ")", ".", "WithUIs", "(", "uis", ")", "\n", "if", "err", "=", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "res", ".", "SigID", "=", "eng", ".", "SigID", "(", ")", "\n", "return", "res", ",", "err", "\n", "}" ]

[ "Prove", "handles", "the", "keybase", ".", "1", ".", "startProof", "RPC", "." ]

[ "func", "(", "ph", "*", "ProveHandler", ")", "CheckProof", "(", "ctx", "context", ".", "Context", ",", "arg", "keybase1", ".", "CheckProofArg", ")", "(", "res", "keybase1", ".", "CheckProofStatus", ",", "err", "error", ")", "{", "ctx", "=", "libkb", ".", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "ph", ".", "G", "(", ")", ".", "CTraceTimed", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "arg", ".", "SigID", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "eng", ":=", "engine", ".", "NewProveCheck", "(", "ph", ".", "G", "(", ")", ",", "arg", ".", "SigID", ")", "\n", "m", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "ph", ".", "G", "(", ")", ")", "\n", "if", "err", "=", "engine", ".", "RunEngine2", "(", "m", ",", "eng", ")", ";", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "found", ",", "status", ",", "state", ",", "text", ":=", "eng", ".", "Results", "(", ")", "\n", "return", "keybase1", ".", "CheckProofStatus", "{", "Found", ":", "found", ",", "Status", ":", "status", ",", "State", ":", "state", ",", "ProofText", ":", "text", ",", "}", ",", "nil", "\n", "}" ]

[ "Prove", "handles", "the", "keybase", ".", "1", ".", "checkProof", "RPC", "." ]

[ "func", "(", "ph", "*", "ProveHandler", ")", "ListProofServices", "(", "ctx", "context", ".", "Context", ")", "(", "res", "[", "]", "string", ",", "err", "error", ")", "{", "ctx", "=", "libkb", ".", "WithLogTag", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "ph", ".", "G", "(", ")", ".", "CTraceTimed", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "mctx", ":=", "libkb", ".", "NewMetaContext", "(", "ctx", ",", "ph", ".", "G", "(", ")", ")", "\n", "return", "ph", ".", "G", "(", ")", ".", "GetProofServices", "(", ")", ".", "ListServicesThatAcceptNewProofs", "(", "mctx", ")", ",", "nil", "\n", "}" ]

[ "Prove", "handles", "the", "keybase", ".", "1", ".", "listProofServices", "RPC", "." ]

[ "func", "(", "cr", "WriterDeviceDateConflictRenamer", ")", "ConflictRename", "(", "ctx", "context", ".", "Context", ",", "op", "op", ",", "original", "string", ")", "(", "string", ",", "error", ")", "{", "now", ":=", "cr", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n", "winfo", ":=", "op", ".", "getWriterInfo", "(", ")", "\n", "ui", ",", "err", ":=", "cr", ".", "config", ".", "KeybaseService", "(", ")", ".", "LoadUserPlusKeys", "(", "ctx", ",", "winfo", ".", "uid", ",", "\"", "\"", ",", "winfo", ".", "offline", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "deviceName", ":=", "ui", ".", "KIDNames", "[", "winfo", ".", "key", ".", "KID", "(", ")", "]", "\n", "return", "cr", ".", "ConflictRenameHelper", "(", "now", ",", "string", "(", "ui", ".", "Name", ")", ",", "deviceName", ",", "original", ")", ",", "nil", "\n", "}" ]

[ "ConflictRename", "implements", "the", "ConflictRename", "interface", "for", "TimeAndWriterConflictRenamer", "." ]