id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
158,400 | casbin/casbin | enforcer_synced.go | HasGroupingPolicy | func (e *SyncedEnforcer) HasGroupingPolicy(params ...interface{}) bool {
e.m.RLock()
defer e.m.RUnlock()
return e.Enforcer.HasGroupingPolicy(params...)
} | go | func (e *SyncedEnforcer) HasGroupingPolicy(params ...interface{}) bool {
e.m.RLock()
defer e.m.RUnlock()
return e.Enforcer.HasGroupingPolicy(params...)
} | [
"func",
"(",
"e",
"*",
"SyncedEnforcer",
")",
"HasGroupingPolicy",
"(",
"params",
"...",
"interface",
"{",
"}",
")",
"bool",
"{",
"e",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"e",
... | // HasGroupingPolicy determines whether a role inheritance rule exists. | [
"HasGroupingPolicy",
"determines",
"whether",
"a",
"role",
"inheritance",
"rule",
"exists",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_synced.go#L196-L200 |
158,401 | casbin/casbin | util/util.go | EscapeAssertion | func EscapeAssertion(s string) string {
//Replace the first dot, because it can't be recognized by the regexp.
if (strings.HasPrefix(s, "r") || strings.HasPrefix(s, "p")) {
s = strings.Replace(s, ".", "_",1)
}
var regex = regexp.MustCompile(`(\|| |=|\)|\(|&|<|>|,|\+|-|!|\*|\/)(r|p)\.`)
s = regex.ReplaceAllStringFunc(s, func(m string) string {
return strings.Replace(m, ".", "_", 1)
})
return s
} | go | func EscapeAssertion(s string) string {
//Replace the first dot, because it can't be recognized by the regexp.
if (strings.HasPrefix(s, "r") || strings.HasPrefix(s, "p")) {
s = strings.Replace(s, ".", "_",1)
}
var regex = regexp.MustCompile(`(\|| |=|\)|\(|&|<|>|,|\+|-|!|\*|\/)(r|p)\.`)
s = regex.ReplaceAllStringFunc(s, func(m string) string {
return strings.Replace(m, ".", "_", 1)
})
return s
} | [
"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",
",",
... | // EscapeAssertion escapes the dots in the assertion, because the expression evaluation doesn't support such variable names. | [
"EscapeAssertion",
"escapes",
"the",
"dots",
"in",
"the",
"assertion",
"because",
"the",
"expression",
"evaluation",
"doesn",
"t",
"support",
"such",
"variable",
"names",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/util/util.go#L24-L34 |
158,402 | casbin/casbin | util/util.go | ArrayRemoveDuplicates | func ArrayRemoveDuplicates(s *[]string) {
found := make(map[string]bool)
j := 0
for i, x := range *s {
if !found[x] {
found[x] = true
(*s)[j] = (*s)[i]
j++
}
}
*s = (*s)[:j]
} | go | func ArrayRemoveDuplicates(s *[]string) {
found := make(map[string]bool)
j := 0
for i, x := range *s {
if !found[x] {
found[x] = true
(*s)[j] = (*s)[i]
j++
}
}
*s = (*s)[:j]
} | [
"func",
"ArrayRemoveDuplicates",
"(",
"s",
"*",
"[",
"]",
"string",
")",
"{",
"found",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"j",
":=",
"0",
"\n",
"for",
"i",
",",
"x",
":=",
"range",
"*",
"s",
"{",
"if",
"!",
"found"... | // ArrayRemoveDuplicates removes any duplicated elements in a string array. | [
"ArrayRemoveDuplicates",
"removes",
"any",
"duplicated",
"elements",
"in",
"a",
"string",
"array",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/util/util.go#L74-L85 |
158,403 | casbin/casbin | persist/file-adapter/adapter_mock.go | NewAdapterMock | func NewAdapterMock(filePath string) *AdapterMock {
a := AdapterMock{}
a.filePath = filePath
return &a
} | go | func NewAdapterMock(filePath string) *AdapterMock {
a := AdapterMock{}
a.filePath = filePath
return &a
} | [
"func",
"NewAdapterMock",
"(",
"filePath",
"string",
")",
"*",
"AdapterMock",
"{",
"a",
":=",
"AdapterMock",
"{",
"}",
"\n",
"a",
".",
"filePath",
"=",
"filePath",
"\n",
"return",
"&",
"a",
"\n",
"}"
] | // NewAdapterMock is the constructor for AdapterMock. | [
"NewAdapterMock",
"is",
"the",
"constructor",
"for",
"AdapterMock",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/persist/file-adapter/adapter_mock.go#L36-L40 |
158,404 | casbin/casbin | persist/file-adapter/adapter_mock.go | GetMockErr | func (a *AdapterMock) GetMockErr() error {
var returnError error
if a.errorValue != "" {
returnError = errors.New(a.errorValue)
}
return returnError
} | go | func (a *AdapterMock) GetMockErr() error {
var returnError error
if a.errorValue != "" {
returnError = errors.New(a.errorValue)
}
return returnError
} | [
"func",
"(",
"a",
"*",
"AdapterMock",
")",
"GetMockErr",
"(",
")",
"error",
"{",
"var",
"returnError",
"error",
"\n",
"if",
"a",
".",
"errorValue",
"!=",
"\"",
"\"",
"{",
"returnError",
"=",
"errors",
".",
"New",
"(",
"a",
".",
"errorValue",
")",
"\n... | // GetMockErr returns a mock error or nil | [
"GetMockErr",
"returns",
"a",
"mock",
"error",
"or",
"nil"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/persist/file-adapter/adapter_mock.go#L79-L85 |
158,405 | casbin/casbin | persist/adapter.go | LoadPolicyLine | func LoadPolicyLine(line string, model model.Model) {
if line == "" {
return
}
if strings.HasPrefix(line, "#") {
return
}
tokens := strings.Split(line, ",")
for i := range tokens {
tokens[i] = strings.TrimSpace(tokens[i])
}
key := tokens[0]
sec := key[:1]
model[sec][key].Policy = append(model[sec][key].Policy, tokens[1:])
} | go | func LoadPolicyLine(line string, model model.Model) {
if line == "" {
return
}
if strings.HasPrefix(line, "#") {
return
}
tokens := strings.Split(line, ",")
for i := range tokens {
tokens[i] = strings.TrimSpace(tokens[i])
}
key := tokens[0]
sec := key[:1]
model[sec][key].Policy = append(model[sec][key].Policy, tokens[1:])
} | [
"func",
"LoadPolicyLine",
"(",
"line",
"string",
",",
"model",
"model",
".",
"Model",
")",
"{",
"if",
"line",
"==",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"line",
",",
"\"",
"\"",
")",
"{",
"return",
"... | // LoadPolicyLine loads a text line as a policy rule to model. | [
"LoadPolicyLine",
"loads",
"a",
"text",
"line",
"as",
"a",
"policy",
"rule",
"to",
"model",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/persist/adapter.go#L24-L41 |
158,406 | casbin/casbin | effect/default_effector.go | MergeEffects | func (e *DefaultEffector) MergeEffects(expr string, effects []Effect, results []float64) (bool, error) {
result := false
if expr == "some(where (p_eft == allow))" {
result = false
for _, eft := range effects {
if eft == Allow {
result = true
break
}
}
} else if expr == "!some(where (p_eft == deny))" {
result = true
for _, eft := range effects {
if eft == Deny {
result = false
break
}
}
} else if expr == "some(where (p_eft == allow)) && !some(where (p_eft == deny))" {
result = false
for _, eft := range effects {
if eft == Allow {
result = true
} else if eft == Deny {
result = false
break
}
}
} else if expr == "priority(p_eft) || deny" {
result = false
for _, eft := range effects {
if eft != Indeterminate {
if eft == Allow {
result = true
} else {
result = false
}
break
}
}
} else {
return false, errors.New("unsupported effect")
}
return result, nil
} | go | func (e *DefaultEffector) MergeEffects(expr string, effects []Effect, results []float64) (bool, error) {
result := false
if expr == "some(where (p_eft == allow))" {
result = false
for _, eft := range effects {
if eft == Allow {
result = true
break
}
}
} else if expr == "!some(where (p_eft == deny))" {
result = true
for _, eft := range effects {
if eft == Deny {
result = false
break
}
}
} else if expr == "some(where (p_eft == allow)) && !some(where (p_eft == deny))" {
result = false
for _, eft := range effects {
if eft == Allow {
result = true
} else if eft == Deny {
result = false
break
}
}
} else if expr == "priority(p_eft) || deny" {
result = false
for _, eft := range effects {
if eft != Indeterminate {
if eft == Allow {
result = true
} else {
result = false
}
break
}
}
} else {
return false, errors.New("unsupported effect")
}
return result, nil
} | [
"func",
"(",
"e",
"*",
"DefaultEffector",
")",
"MergeEffects",
"(",
"expr",
"string",
",",
"effects",
"[",
"]",
"Effect",
",",
"results",
"[",
"]",
"float64",
")",
"(",
"bool",
",",
"error",
")",
"{",
"result",
":=",
"false",
"\n",
"if",
"expr",
"=="... | // MergeEffects merges all matching results collected by the enforcer into a single decision. | [
"MergeEffects",
"merges",
"all",
"matching",
"results",
"collected",
"by",
"the",
"enforcer",
"into",
"a",
"single",
"decision",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/effect/default_effector.go#L30-L75 |
158,407 | casbin/casbin | internal_api.go | addPolicy | func (e *Enforcer) addPolicy(sec string, ptype string, rule []string) bool {
ruleAdded := e.model.AddPolicy(sec, ptype, rule)
if !ruleAdded {
return ruleAdded
}
if e.adapter != nil && e.autoSave {
if err := e.adapter.AddPolicy(sec, ptype, rule); err != nil {
if err.Error() != notImplemented {
panic(err)
}
}
if e.watcher != nil {
// error intentionally ignored
e.watcher.Update()
}
}
return ruleAdded
} | go | func (e *Enforcer) addPolicy(sec string, ptype string, rule []string) bool {
ruleAdded := e.model.AddPolicy(sec, ptype, rule)
if !ruleAdded {
return ruleAdded
}
if e.adapter != nil && e.autoSave {
if err := e.adapter.AddPolicy(sec, ptype, rule); err != nil {
if err.Error() != notImplemented {
panic(err)
}
}
if e.watcher != nil {
// error intentionally ignored
e.watcher.Update()
}
}
return ruleAdded
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"addPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"rule",
"[",
"]",
"string",
")",
"bool",
"{",
"ruleAdded",
":=",
"e",
".",
"model",
".",
"AddPolicy",
"(",
"sec",
",",
"ptype",
",",
"rule",
")"... | // addPolicy adds a rule to the current policy. | [
"addPolicy",
"adds",
"a",
"rule",
"to",
"the",
"current",
"policy",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/internal_api.go#L22-L41 |
158,408 | casbin/casbin | internal_api.go | removePolicy | func (e *Enforcer) removePolicy(sec string, ptype string, rule []string) bool {
ruleRemoved := e.model.RemovePolicy(sec, ptype, rule)
if !ruleRemoved {
return ruleRemoved
}
if e.adapter != nil && e.autoSave {
if err := e.adapter.RemovePolicy(sec, ptype, rule); err != nil {
if err.Error() != notImplemented {
panic(err)
}
}
if e.watcher != nil {
// error intentionally ignored
e.watcher.Update()
}
}
return ruleRemoved
} | go | func (e *Enforcer) removePolicy(sec string, ptype string, rule []string) bool {
ruleRemoved := e.model.RemovePolicy(sec, ptype, rule)
if !ruleRemoved {
return ruleRemoved
}
if e.adapter != nil && e.autoSave {
if err := e.adapter.RemovePolicy(sec, ptype, rule); err != nil {
if err.Error() != notImplemented {
panic(err)
}
}
if e.watcher != nil {
// error intentionally ignored
e.watcher.Update()
}
}
return ruleRemoved
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"removePolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"rule",
"[",
"]",
"string",
")",
"bool",
"{",
"ruleRemoved",
":=",
"e",
".",
"model",
".",
"RemovePolicy",
"(",
"sec",
",",
"ptype",
",",
"rule... | // removePolicy removes a rule from the current policy. | [
"removePolicy",
"removes",
"a",
"rule",
"from",
"the",
"current",
"policy",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/internal_api.go#L44-L63 |
158,409 | casbin/casbin | internal_api.go | removeFilteredPolicy | func (e *Enforcer) removeFilteredPolicy(sec string, ptype string, fieldIndex int, fieldValues ...string) bool {
ruleRemoved := e.model.RemoveFilteredPolicy(sec, ptype, fieldIndex, fieldValues...)
if !ruleRemoved {
return ruleRemoved
}
if e.adapter != nil && e.autoSave {
if err := e.adapter.RemoveFilteredPolicy(sec, ptype, fieldIndex, fieldValues...); err != nil {
if err.Error() != notImplemented {
panic(err)
}
}
if e.watcher != nil {
// error intentionally ignored
e.watcher.Update()
}
}
return ruleRemoved
} | go | func (e *Enforcer) removeFilteredPolicy(sec string, ptype string, fieldIndex int, fieldValues ...string) bool {
ruleRemoved := e.model.RemoveFilteredPolicy(sec, ptype, fieldIndex, fieldValues...)
if !ruleRemoved {
return ruleRemoved
}
if e.adapter != nil && e.autoSave {
if err := e.adapter.RemoveFilteredPolicy(sec, ptype, fieldIndex, fieldValues...); err != nil {
if err.Error() != notImplemented {
panic(err)
}
}
if e.watcher != nil {
// error intentionally ignored
e.watcher.Update()
}
}
return ruleRemoved
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"removeFilteredPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"fieldIndex",
"int",
",",
"fieldValues",
"...",
"string",
")",
"bool",
"{",
"ruleRemoved",
":=",
"e",
".",
"model",
".",
"RemoveFilteredPolicy"... | // removeFilteredPolicy removes rules based on field filters from the current policy. | [
"removeFilteredPolicy",
"removes",
"rules",
"based",
"on",
"field",
"filters",
"from",
"the",
"current",
"policy",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/internal_api.go#L66-L85 |
158,410 | casbin/casbin | model/policy.go | BuildRoleLinks | func (model Model) BuildRoleLinks(rm rbac.RoleManager) {
for _, ast := range model["g"] {
ast.buildRoleLinks(rm)
}
} | go | func (model Model) BuildRoleLinks(rm rbac.RoleManager) {
for _, ast := range model["g"] {
ast.buildRoleLinks(rm)
}
} | [
"func",
"(",
"model",
"Model",
")",
"BuildRoleLinks",
"(",
"rm",
"rbac",
".",
"RoleManager",
")",
"{",
"for",
"_",
",",
"ast",
":=",
"range",
"model",
"[",
"\"",
"\"",
"]",
"{",
"ast",
".",
"buildRoleLinks",
"(",
"rm",
")",
"\n",
"}",
"\n",
"}"
] | // BuildRoleLinks initializes the roles in RBAC. | [
"BuildRoleLinks",
"initializes",
"the",
"roles",
"in",
"RBAC",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L24-L28 |
158,411 | casbin/casbin | model/policy.go | PrintPolicy | func (model Model) PrintPolicy() {
log.LogPrint("Policy:")
for key, ast := range model["p"] {
log.LogPrint(key, ": ", ast.Value, ": ", ast.Policy)
}
for key, ast := range model["g"] {
log.LogPrint(key, ": ", ast.Value, ": ", ast.Policy)
}
} | go | func (model Model) PrintPolicy() {
log.LogPrint("Policy:")
for key, ast := range model["p"] {
log.LogPrint(key, ": ", ast.Value, ": ", ast.Policy)
}
for key, ast := range model["g"] {
log.LogPrint(key, ": ", ast.Value, ": ", ast.Policy)
}
} | [
"func",
"(",
"model",
"Model",
")",
"PrintPolicy",
"(",
")",
"{",
"log",
".",
"LogPrint",
"(",
"\"",
"\"",
")",
"\n",
"for",
"key",
",",
"ast",
":=",
"range",
"model",
"[",
"\"",
"\"",
"]",
"{",
"log",
".",
"LogPrint",
"(",
"key",
",",
"\"",
"\... | // PrintPolicy prints the policy to log. | [
"PrintPolicy",
"prints",
"the",
"policy",
"to",
"log",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L31-L40 |
158,412 | casbin/casbin | model/policy.go | ClearPolicy | func (model Model) ClearPolicy() {
for _, ast := range model["p"] {
ast.Policy = nil
}
for _, ast := range model["g"] {
ast.Policy = nil
}
} | go | func (model Model) ClearPolicy() {
for _, ast := range model["p"] {
ast.Policy = nil
}
for _, ast := range model["g"] {
ast.Policy = nil
}
} | [
"func",
"(",
"model",
"Model",
")",
"ClearPolicy",
"(",
")",
"{",
"for",
"_",
",",
"ast",
":=",
"range",
"model",
"[",
"\"",
"\"",
"]",
"{",
"ast",
".",
"Policy",
"=",
"nil",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ast",
":=",
"range",
"model",
"[... | // ClearPolicy clears all current policy. | [
"ClearPolicy",
"clears",
"all",
"current",
"policy",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L43-L51 |
158,413 | casbin/casbin | model/policy.go | GetPolicy | func (model Model) GetPolicy(sec string, ptype string) [][]string {
return model[sec][ptype].Policy
} | go | func (model Model) GetPolicy(sec string, ptype string) [][]string {
return model[sec][ptype].Policy
} | [
"func",
"(",
"model",
"Model",
")",
"GetPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"return",
"model",
"[",
"sec",
"]",
"[",
"ptype",
"]",
".",
"Policy",
"\n",
"}"
] | // GetPolicy gets all rules in a policy. | [
"GetPolicy",
"gets",
"all",
"rules",
"in",
"a",
"policy",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L54-L56 |
158,414 | casbin/casbin | model/policy.go | GetFilteredPolicy | func (model Model) GetFilteredPolicy(sec string, ptype string, fieldIndex int, fieldValues ...string) [][]string {
res := [][]string{}
for _, rule := range model[sec][ptype].Policy {
matched := true
for i, fieldValue := range fieldValues {
if fieldValue != "" && rule[fieldIndex+i] != fieldValue {
matched = false
break
}
}
if matched {
res = append(res, rule)
}
}
return res
} | go | func (model Model) GetFilteredPolicy(sec string, ptype string, fieldIndex int, fieldValues ...string) [][]string {
res := [][]string{}
for _, rule := range model[sec][ptype].Policy {
matched := true
for i, fieldValue := range fieldValues {
if fieldValue != "" && rule[fieldIndex+i] != fieldValue {
matched = false
break
}
}
if matched {
res = append(res, rule)
}
}
return res
} | [
"func",
"(",
"model",
"Model",
")",
"GetFilteredPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"fieldIndex",
"int",
",",
"fieldValues",
"...",
"string",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"res",
":=",
"[",
"]",
"[",
"]",
"string",
"... | // GetFilteredPolicy gets rules based on field filters from a policy. | [
"GetFilteredPolicy",
"gets",
"rules",
"based",
"on",
"field",
"filters",
"from",
"a",
"policy",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L59-L77 |
158,415 | casbin/casbin | model/policy.go | HasPolicy | 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
}
}
return false
} | go | 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
}
}
return false
} | [
"func",
"(",
"model",
"Model",
")",
"HasPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"rule",
"[",
"]",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"model",
"[",
"sec",
"]",
"[",
"ptype",
"]",
".",
"Policy",
"{"... | // HasPolicy determines whether a model has the specified policy rule. | [
"HasPolicy",
"determines",
"whether",
"a",
"model",
"has",
"the",
"specified",
"policy",
"rule",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L80-L88 |
158,416 | casbin/casbin | model/policy.go | AddPolicy | 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)
return true
}
return false
} | go | 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)
return true
}
return false
} | [
"func",
"(",
"model",
"Model",
")",
"AddPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"rule",
"[",
"]",
"string",
")",
"bool",
"{",
"if",
"!",
"model",
".",
"HasPolicy",
"(",
"sec",
",",
"ptype",
",",
"rule",
")",
"{",
"model",
"[",
... | // AddPolicy adds a policy rule to the model. | [
"AddPolicy",
"adds",
"a",
"policy",
"rule",
"to",
"the",
"model",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L91-L97 |
158,417 | casbin/casbin | model/policy.go | RemovePolicy | 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:]...)
return true
}
}
return false
} | go | 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:]...)
return true
}
}
return false
} | [
"func",
"(",
"model",
"Model",
")",
"RemovePolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"rule",
"[",
"]",
"string",
")",
"bool",
"{",
"for",
"i",
",",
"r",
":=",
"range",
"model",
"[",
"sec",
"]",
"[",
"ptype",
"]",
".",
"Policy",
... | // RemovePolicy removes a policy rule from the model. | [
"RemovePolicy",
"removes",
"a",
"policy",
"rule",
"from",
"the",
"model",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L100-L109 |
158,418 | casbin/casbin | model/policy.go | GetValuesForFieldInPolicy | func (model Model) GetValuesForFieldInPolicy(sec string, ptype string, fieldIndex int) []string {
values := []string{}
for _, rule := range model[sec][ptype].Policy {
values = append(values, rule[fieldIndex])
}
util.ArrayRemoveDuplicates(&values)
return values
} | go | func (model Model) GetValuesForFieldInPolicy(sec string, ptype string, fieldIndex int) []string {
values := []string{}
for _, rule := range model[sec][ptype].Policy {
values = append(values, rule[fieldIndex])
}
util.ArrayRemoveDuplicates(&values)
return values
} | [
"func",
"(",
"model",
"Model",
")",
"GetValuesForFieldInPolicy",
"(",
"sec",
"string",
",",
"ptype",
"string",
",",
"fieldIndex",
"int",
")",
"[",
"]",
"string",
"{",
"values",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"for",
"_",
",",
"rule",
":=",
... | // GetValuesForFieldInPolicy gets all values for a field for all rules in a policy, duplicated values are removed. | [
"GetValuesForFieldInPolicy",
"gets",
"all",
"values",
"for",
"a",
"field",
"for",
"all",
"rules",
"in",
"a",
"policy",
"duplicated",
"values",
"are",
"removed",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/policy.go#L136-L146 |
158,419 | casbin/casbin | model/model.go | AddDef | func (model Model) AddDef(sec string, key string, value string) bool {
ast := Assertion{}
ast.Key = key
ast.Value = value
if ast.Value == "" {
return false
}
if sec == "r" || sec == "p" {
ast.Tokens = strings.Split(ast.Value, ", ")
for i := range ast.Tokens {
ast.Tokens[i] = key + "_" + ast.Tokens[i]
}
} else {
ast.Value = util.RemoveComments(util.EscapeAssertion(ast.Value))
}
_, ok := model[sec]
if !ok {
model[sec] = make(AssertionMap)
}
model[sec][key] = &ast
return true
} | go | func (model Model) AddDef(sec string, key string, value string) bool {
ast := Assertion{}
ast.Key = key
ast.Value = value
if ast.Value == "" {
return false
}
if sec == "r" || sec == "p" {
ast.Tokens = strings.Split(ast.Value, ", ")
for i := range ast.Tokens {
ast.Tokens[i] = key + "_" + ast.Tokens[i]
}
} else {
ast.Value = util.RemoveComments(util.EscapeAssertion(ast.Value))
}
_, ok := model[sec]
if !ok {
model[sec] = make(AssertionMap)
}
model[sec][key] = &ast
return true
} | [
"func",
"(",
"model",
"Model",
")",
"AddDef",
"(",
"sec",
"string",
",",
"key",
"string",
",",
"value",
"string",
")",
"bool",
"{",
"ast",
":=",
"Assertion",
"{",
"}",
"\n",
"ast",
".",
"Key",
"=",
"key",
"\n",
"ast",
".",
"Value",
"=",
"value",
... | // AddDef adds an assertion to the model. | [
"AddDef",
"adds",
"an",
"assertion",
"to",
"the",
"model",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/model.go#L46-L71 |
158,420 | casbin/casbin | model/model.go | LoadModel | func (model Model) LoadModel(path string) {
cfg, err := config.NewConfig(path)
if err != nil {
panic(err)
}
loadSection(model, cfg, "r")
loadSection(model, cfg, "p")
loadSection(model, cfg, "e")
loadSection(model, cfg, "m")
loadSection(model, cfg, "g")
} | go | func (model Model) LoadModel(path string) {
cfg, err := config.NewConfig(path)
if err != nil {
panic(err)
}
loadSection(model, cfg, "r")
loadSection(model, cfg, "p")
loadSection(model, cfg, "e")
loadSection(model, cfg, "m")
loadSection(model, cfg, "g")
} | [
"func",
"(",
"model",
"Model",
")",
"LoadModel",
"(",
"path",
"string",
")",
"{",
"cfg",
",",
"err",
":=",
"config",
".",
"NewConfig",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"loadSection"... | // LoadModel loads the model from model CONF file. | [
"LoadModel",
"loads",
"the",
"model",
"from",
"model",
"CONF",
"file",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/model.go#L93-L105 |
158,421 | casbin/casbin | model/model.go | LoadModelFromText | func (model Model) LoadModelFromText(text string) {
cfg, err := config.NewConfigFromText(text)
if err != nil {
panic(err)
}
loadSection(model, cfg, "r")
loadSection(model, cfg, "p")
loadSection(model, cfg, "e")
loadSection(model, cfg, "m")
loadSection(model, cfg, "g")
} | go | func (model Model) LoadModelFromText(text string) {
cfg, err := config.NewConfigFromText(text)
if err != nil {
panic(err)
}
loadSection(model, cfg, "r")
loadSection(model, cfg, "p")
loadSection(model, cfg, "e")
loadSection(model, cfg, "m")
loadSection(model, cfg, "g")
} | [
"func",
"(",
"model",
"Model",
")",
"LoadModelFromText",
"(",
"text",
"string",
")",
"{",
"cfg",
",",
"err",
":=",
"config",
".",
"NewConfigFromText",
"(",
"text",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",... | // LoadModelFromText loads the model from the text. | [
"LoadModelFromText",
"loads",
"the",
"model",
"from",
"the",
"text",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/model.go#L108-L120 |
158,422 | casbin/casbin | model/model.go | PrintModel | func (model Model) PrintModel() {
log.LogPrint("Model:")
for k, v := range model {
for i, j := range v {
log.LogPrintf("%s.%s: %s", k, i, j.Value)
}
}
} | go | func (model Model) PrintModel() {
log.LogPrint("Model:")
for k, v := range model {
for i, j := range v {
log.LogPrintf("%s.%s: %s", k, i, j.Value)
}
}
} | [
"func",
"(",
"model",
"Model",
")",
"PrintModel",
"(",
")",
"{",
"log",
".",
"LogPrint",
"(",
"\"",
"\"",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"model",
"{",
"for",
"i",
",",
"j",
":=",
"range",
"v",
"{",
"log",
".",
"LogPrintf",
"(",... | // PrintModel prints the model to the log. | [
"PrintModel",
"prints",
"the",
"model",
"to",
"the",
"log",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/model.go#L123-L130 |
158,423 | casbin/casbin | rbac/default-role-manager/role_manager.go | NewRoleManager | func NewRoleManager(maxHierarchyLevel int) rbac.RoleManager {
rm := RoleManager{}
rm.allRoles = &sync.Map{}
rm.maxHierarchyLevel = maxHierarchyLevel
rm.hasPattern = false
return &rm
} | go | func NewRoleManager(maxHierarchyLevel int) rbac.RoleManager {
rm := RoleManager{}
rm.allRoles = &sync.Map{}
rm.maxHierarchyLevel = maxHierarchyLevel
rm.hasPattern = false
return &rm
} | [
"func",
"NewRoleManager",
"(",
"maxHierarchyLevel",
"int",
")",
"rbac",
".",
"RoleManager",
"{",
"rm",
":=",
"RoleManager",
"{",
"}",
"\n",
"rm",
".",
"allRoles",
"=",
"&",
"sync",
".",
"Map",
"{",
"}",
"\n",
"rm",
".",
"maxHierarchyLevel",
"=",
"maxHier... | // NewRoleManager is the constructor for creating an instance of the
// default RoleManager implementation. | [
"NewRoleManager",
"is",
"the",
"constructor",
"for",
"creating",
"an",
"instance",
"of",
"the",
"default",
"RoleManager",
"implementation",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac/default-role-manager/role_manager.go#L37-L44 |
158,424 | casbin/casbin | rbac/default-role-manager/role_manager.go | GetRoles | func (rm *RoleManager) GetRoles(name string, domain ...string) ([]string, error) {
if len(domain) == 1 {
name = domain[0] + "::" + name
} else if len(domain) > 1 {
return nil, errors.New("error: domain should be 1 parameter")
}
if !rm.hasRole(name) {
return []string{}, nil
}
roles := rm.createRole(name).getRoles()
if len(domain) == 1 {
for i := range roles {
roles[i] = roles[i][len(domain[0])+2:]
}
}
return roles, nil
} | go | func (rm *RoleManager) GetRoles(name string, domain ...string) ([]string, error) {
if len(domain) == 1 {
name = domain[0] + "::" + name
} else if len(domain) > 1 {
return nil, errors.New("error: domain should be 1 parameter")
}
if !rm.hasRole(name) {
return []string{}, nil
}
roles := rm.createRole(name).getRoles()
if len(domain) == 1 {
for i := range roles {
roles[i] = roles[i][len(domain[0])+2:]
}
}
return roles, nil
} | [
"func",
"(",
"rm",
"*",
"RoleManager",
")",
"GetRoles",
"(",
"name",
"string",
",",
"domain",
"...",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"len",
"(",
"domain",
")",
"==",
"1",
"{",
"name",
"=",
"domain",
"[",
"0",... | // GetRoles gets the roles that a subject inherits.
// domain is a prefix to the roles. | [
"GetRoles",
"gets",
"the",
"roles",
"that",
"a",
"subject",
"inherits",
".",
"domain",
"is",
"a",
"prefix",
"to",
"the",
"roles",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac/default-role-manager/role_manager.go#L148-L166 |
158,425 | casbin/casbin | rbac/default-role-manager/role_manager.go | GetUsers | func (rm *RoleManager) GetUsers(name string, domain ...string) ([]string, error) {
if len(domain) == 1 {
name = domain[0] + "::" + name
} else if len(domain) > 1 {
return nil, errors.New("error: domain should be 1 parameter")
}
if !rm.hasRole(name) {
return nil, errors.New("error: name does not exist")
}
names := []string{}
rm.allRoles.Range(func(_, value interface{}) bool {
role := value.(*Role)
if role.hasDirectRole(name) {
names = append(names, role.name)
}
return true
})
if len(domain) == 1 {
for i := range names {
names[i] = names[i][len(domain[0])+2:]
}
}
return names, nil
} | go | func (rm *RoleManager) GetUsers(name string, domain ...string) ([]string, error) {
if len(domain) == 1 {
name = domain[0] + "::" + name
} else if len(domain) > 1 {
return nil, errors.New("error: domain should be 1 parameter")
}
if !rm.hasRole(name) {
return nil, errors.New("error: name does not exist")
}
names := []string{}
rm.allRoles.Range(func(_, value interface{}) bool {
role := value.(*Role)
if role.hasDirectRole(name) {
names = append(names, role.name)
}
return true
})
if len(domain) == 1 {
for i := range names {
names[i] = names[i][len(domain[0])+2:]
}
}
return names, nil
} | [
"func",
"(",
"rm",
"*",
"RoleManager",
")",
"GetUsers",
"(",
"name",
"string",
",",
"domain",
"...",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"len",
"(",
"domain",
")",
"==",
"1",
"{",
"name",
"=",
"domain",
"[",
"0",... | // GetUsers gets the users that inherits a subject.
// domain is an unreferenced parameter here, may be used in other implementations. | [
"GetUsers",
"gets",
"the",
"users",
"that",
"inherits",
"a",
"subject",
".",
"domain",
"is",
"an",
"unreferenced",
"parameter",
"here",
"may",
"be",
"used",
"in",
"other",
"implementations",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac/default-role-manager/role_manager.go#L170-L195 |
158,426 | casbin/casbin | rbac/default-role-manager/role_manager.go | PrintRoles | func (rm *RoleManager) PrintRoles() error {
line := ""
rm.allRoles.Range(func(_, value interface{}) bool {
if text := value.(*Role).toString(); text != "" {
if line == "" {
line = text
} else {
line += ", " + text
}
}
return true
})
log.LogPrint(line)
return nil
} | go | func (rm *RoleManager) PrintRoles() error {
line := ""
rm.allRoles.Range(func(_, value interface{}) bool {
if text := value.(*Role).toString(); text != "" {
if line == "" {
line = text
} else {
line += ", " + text
}
}
return true
})
log.LogPrint(line)
return nil
} | [
"func",
"(",
"rm",
"*",
"RoleManager",
")",
"PrintRoles",
"(",
")",
"error",
"{",
"line",
":=",
"\"",
"\"",
"\n",
"rm",
".",
"allRoles",
".",
"Range",
"(",
"func",
"(",
"_",
",",
"value",
"interface",
"{",
"}",
")",
"bool",
"{",
"if",
"text",
":=... | // PrintRoles prints all the roles to log. | [
"PrintRoles",
"prints",
"all",
"the",
"roles",
"to",
"log",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac/default-role-manager/role_manager.go#L198-L212 |
158,427 | casbin/casbin | model/function.go | AddFunction | func (fm FunctionMap) AddFunction(name string, function Function) {
fm[name] = function
} | go | func (fm FunctionMap) AddFunction(name string, function Function) {
fm[name] = function
} | [
"func",
"(",
"fm",
"FunctionMap",
")",
"AddFunction",
"(",
"name",
"string",
",",
"function",
"Function",
")",
"{",
"fm",
"[",
"name",
"]",
"=",
"function",
"\n",
"}"
] | // AddFunction adds an expression function. | [
"AddFunction",
"adds",
"an",
"expression",
"function",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/function.go#L26-L28 |
158,428 | casbin/casbin | model/function.go | LoadFunctionMap | func LoadFunctionMap() FunctionMap {
fm := make(FunctionMap)
fm.AddFunction("keyMatch", util.KeyMatchFunc)
fm.AddFunction("keyMatch2", util.KeyMatch2Func)
fm.AddFunction("regexMatch", util.RegexMatchFunc)
fm.AddFunction("ipMatch", util.IPMatchFunc)
return fm
} | go | func LoadFunctionMap() FunctionMap {
fm := make(FunctionMap)
fm.AddFunction("keyMatch", util.KeyMatchFunc)
fm.AddFunction("keyMatch2", util.KeyMatch2Func)
fm.AddFunction("regexMatch", util.RegexMatchFunc)
fm.AddFunction("ipMatch", util.IPMatchFunc)
return fm
} | [
"func",
"LoadFunctionMap",
"(",
")",
"FunctionMap",
"{",
"fm",
":=",
"make",
"(",
"FunctionMap",
")",
"\n\n",
"fm",
".",
"AddFunction",
"(",
"\"",
"\"",
",",
"util",
".",
"KeyMatchFunc",
")",
"\n",
"fm",
".",
"AddFunction",
"(",
"\"",
"\"",
",",
"util"... | // LoadFunctionMap loads an initial function map. | [
"LoadFunctionMap",
"loads",
"an",
"initial",
"function",
"map",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/model/function.go#L31-L40 |
158,429 | casbin/casbin | rbac_api.go | GetUsersForRole | func (e *Enforcer) GetUsersForRole(name string) []string {
res, _ := e.model["g"]["g"].RM.GetUsers(name)
return res
} | go | func (e *Enforcer) GetUsersForRole(name string) []string {
res, _ := e.model["g"]["g"].RM.GetUsers(name)
return res
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"GetUsersForRole",
"(",
"name",
"string",
")",
"[",
"]",
"string",
"{",
"res",
",",
"_",
":=",
"e",
".",
"model",
"[",
"\"",
"\"",
"]",
"[",
"\"",
"\"",
"]",
".",
"RM",
".",
"GetUsers",
"(",
"name",
")",
... | // GetUsersForRole gets the users that has a role. | [
"GetUsersForRole",
"gets",
"the",
"users",
"that",
"has",
"a",
"role",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac_api.go#L24-L27 |
158,430 | casbin/casbin | rbac_api_with_domains.go | GetUsersForRoleInDomain | func (e *Enforcer) GetUsersForRoleInDomain(name string, domain string) []string {
res, _ := e.model["g"]["g"].RM.GetUsers(name, domain)
return res
} | go | func (e *Enforcer) GetUsersForRoleInDomain(name string, domain string) []string {
res, _ := e.model["g"]["g"].RM.GetUsers(name, domain)
return res
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"GetUsersForRoleInDomain",
"(",
"name",
"string",
",",
"domain",
"string",
")",
"[",
"]",
"string",
"{",
"res",
",",
"_",
":=",
"e",
".",
"model",
"[",
"\"",
"\"",
"]",
"[",
"\"",
"\"",
"]",
".",
"RM",
".",... | // GetUsersForRoleInDomain gets the users that has a role inside a domain. Add by Gordon | [
"GetUsersForRoleInDomain",
"gets",
"the",
"users",
"that",
"has",
"a",
"role",
"inside",
"a",
"domain",
".",
"Add",
"by",
"Gordon"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac_api_with_domains.go#L18-L21 |
158,431 | casbin/casbin | enforcer_synced_safe.go | NewSyncedEnforcerSafe | func NewSyncedEnforcerSafe(params ...interface{}) (enforcer *SyncedEnforcer, err error) {
e := &SyncedEnforcer{}
e.Enforcer, err = NewEnforcerSafe(params...)
if err != nil {
return nil, err
}
e.autoLoad = false
return e, nil
} | go | func NewSyncedEnforcerSafe(params ...interface{}) (enforcer *SyncedEnforcer, err error) {
e := &SyncedEnforcer{}
e.Enforcer, err = NewEnforcerSafe(params...)
if err != nil {
return nil, err
}
e.autoLoad = false
return e, nil
} | [
"func",
"NewSyncedEnforcerSafe",
"(",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"enforcer",
"*",
"SyncedEnforcer",
",",
"err",
"error",
")",
"{",
"e",
":=",
"&",
"SyncedEnforcer",
"{",
"}",
"\n",
"e",
".",
"Enforcer",
",",
"err",
"=",
"NewEnforce... | // NewSyncedEnforcerSafe creates a synchronized enforcer via file or DB. | [
"NewSyncedEnforcerSafe",
"creates",
"a",
"synchronized",
"enforcer",
"via",
"file",
"or",
"DB",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_synced_safe.go#L18-L28 |
158,432 | casbin/casbin | enforcer_synced_safe.go | RemoveFilteredPolicySafe | func (e *SyncedEnforcer) RemoveFilteredPolicySafe(fieldIndex int, fieldValues ...string) (result bool, err error) {
e.m.Lock()
defer e.m.Unlock()
return e.Enforcer.RemoveFilteredPolicySafe(fieldIndex, fieldValues...)
} | go | func (e *SyncedEnforcer) RemoveFilteredPolicySafe(fieldIndex int, fieldValues ...string) (result bool, err error) {
e.m.Lock()
defer e.m.Unlock()
return e.Enforcer.RemoveFilteredPolicySafe(fieldIndex, fieldValues...)
} | [
"func",
"(",
"e",
"*",
"SyncedEnforcer",
")",
"RemoveFilteredPolicySafe",
"(",
"fieldIndex",
"int",
",",
"fieldValues",
"...",
"string",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"e",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e"... | // RemoveFilteredPolicySafe calls RemoveFilteredPolicy in a safe way, returns error instead of causing panic. | [
"RemoveFilteredPolicySafe",
"calls",
"RemoveFilteredPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_synced_safe.go#L59-L63 |
158,433 | casbin/casbin | persist/file-adapter/adapter_filtered.go | NewFilteredAdapter | func NewFilteredAdapter(filePath string) *FilteredAdapter {
a := FilteredAdapter{}
a.filtered = true
a.Adapter = NewAdapter(filePath)
return &a
} | go | func NewFilteredAdapter(filePath string) *FilteredAdapter {
a := FilteredAdapter{}
a.filtered = true
a.Adapter = NewAdapter(filePath)
return &a
} | [
"func",
"NewFilteredAdapter",
"(",
"filePath",
"string",
")",
"*",
"FilteredAdapter",
"{",
"a",
":=",
"FilteredAdapter",
"{",
"}",
"\n",
"a",
".",
"filtered",
"=",
"true",
"\n",
"a",
".",
"Adapter",
"=",
"NewAdapter",
"(",
"filePath",
")",
"\n",
"return",
... | // NewFilteredAdapter is the constructor for FilteredAdapter. | [
"NewFilteredAdapter",
"is",
"the",
"constructor",
"for",
"FilteredAdapter",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/persist/file-adapter/adapter_filtered.go#L42-L47 |
158,434 | casbin/casbin | persist/file-adapter/adapter_filtered.go | LoadFilteredPolicy | func (a *FilteredAdapter) LoadFilteredPolicy(model model.Model, filter interface{}) error {
if filter == nil {
return a.LoadPolicy(model)
}
if a.filePath == "" {
return errors.New("invalid file path, file path cannot be empty")
}
filterValue, ok := filter.(*Filter)
if !ok {
return errors.New("invalid filter type")
}
err := a.loadFilteredPolicyFile(model, filterValue, persist.LoadPolicyLine)
if err == nil {
a.filtered = true
}
return err
} | go | func (a *FilteredAdapter) LoadFilteredPolicy(model model.Model, filter interface{}) error {
if filter == nil {
return a.LoadPolicy(model)
}
if a.filePath == "" {
return errors.New("invalid file path, file path cannot be empty")
}
filterValue, ok := filter.(*Filter)
if !ok {
return errors.New("invalid filter type")
}
err := a.loadFilteredPolicyFile(model, filterValue, persist.LoadPolicyLine)
if err == nil {
a.filtered = true
}
return err
} | [
"func",
"(",
"a",
"*",
"FilteredAdapter",
")",
"LoadFilteredPolicy",
"(",
"model",
"model",
".",
"Model",
",",
"filter",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"filter",
"==",
"nil",
"{",
"return",
"a",
".",
"LoadPolicy",
"(",
"model",
")",
"\... | // LoadFilteredPolicy loads only policy rules that match the filter. | [
"LoadFilteredPolicy",
"loads",
"only",
"policy",
"rules",
"that",
"match",
"the",
"filter",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/persist/file-adapter/adapter_filtered.go#L56-L73 |
158,435 | casbin/casbin | config/config.go | NewConfig | func NewConfig(confName string) (ConfigInterface, error) {
c := &Config{
data: make(map[string]map[string]string),
}
err := c.parse(confName)
return c, err
} | go | func NewConfig(confName string) (ConfigInterface, error) {
c := &Config{
data: make(map[string]map[string]string),
}
err := c.parse(confName)
return c, err
} | [
"func",
"NewConfig",
"(",
"confName",
"string",
")",
"(",
"ConfigInterface",
",",
"error",
")",
"{",
"c",
":=",
"&",
"Config",
"{",
"data",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"err"... | // NewConfig create an empty configuration representation from file. | [
"NewConfig",
"create",
"an",
"empty",
"configuration",
"representation",
"from",
"file",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L60-L66 |
158,436 | casbin/casbin | config/config.go | NewConfigFromText | func NewConfigFromText(text string) (ConfigInterface, error) {
c := &Config{
data: make(map[string]map[string]string),
}
err := c.parseBuffer(bufio.NewReader(strings.NewReader(text)))
return c, err
} | go | func NewConfigFromText(text string) (ConfigInterface, error) {
c := &Config{
data: make(map[string]map[string]string),
}
err := c.parseBuffer(bufio.NewReader(strings.NewReader(text)))
return c, err
} | [
"func",
"NewConfigFromText",
"(",
"text",
"string",
")",
"(",
"ConfigInterface",
",",
"error",
")",
"{",
"c",
":=",
"&",
"Config",
"{",
"data",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"... | // NewConfigFromText create an empty configuration representation from text. | [
"NewConfigFromText",
"create",
"an",
"empty",
"configuration",
"representation",
"from",
"text",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L69-L75 |
158,437 | casbin/casbin | config/config.go | Bool | func (c *Config) Bool(key string) (bool, error) {
return strconv.ParseBool(c.get(key))
} | go | func (c *Config) Bool(key string) (bool, error) {
return strconv.ParseBool(c.get(key))
} | [
"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 | [
"Bool",
"lookups",
"up",
"the",
"value",
"using",
"the",
"provided",
"key",
"and",
"converts",
"the",
"value",
"to",
"a",
"bool"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L186-L188 |
158,438 | casbin/casbin | config/config.go | Int | func (c *Config) Int(key string) (int, error) {
return strconv.Atoi(c.get(key))
} | go | func (c *Config) Int(key string) (int, error) {
return strconv.Atoi(c.get(key))
} | [
"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 | [
"Int",
"lookups",
"up",
"the",
"value",
"using",
"the",
"provided",
"key",
"and",
"converts",
"the",
"value",
"to",
"a",
"int"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L191-L193 |
158,439 | casbin/casbin | config/config.go | Int64 | func (c *Config) Int64(key string) (int64, error) {
return strconv.ParseInt(c.get(key), 10, 64)
} | go | func (c *Config) Int64(key string) (int64, error) {
return strconv.ParseInt(c.get(key), 10, 64)
} | [
"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 | [
"Int64",
"lookups",
"up",
"the",
"value",
"using",
"the",
"provided",
"key",
"and",
"converts",
"the",
"value",
"to",
"a",
"int64"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L196-L198 |
158,440 | casbin/casbin | config/config.go | Float64 | func (c *Config) Float64(key string) (float64, error) {
return strconv.ParseFloat(c.get(key), 64)
} | go | func (c *Config) Float64(key string) (float64, error) {
return strconv.ParseFloat(c.get(key), 64)
} | [
"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 | [
"Float64",
"lookups",
"up",
"the",
"value",
"using",
"the",
"provided",
"key",
"and",
"converts",
"the",
"value",
"to",
"a",
"float64"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L201-L203 |
158,441 | casbin/casbin | config/config.go | Strings | func (c *Config) Strings(key string) []string {
v := c.get(key)
if v == "" {
return nil
}
return strings.Split(v, ",")
} | go | func (c *Config) Strings(key string) []string {
v := c.get(key)
if v == "" {
return nil
}
return strings.Split(v, ",")
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Strings",
"(",
"key",
"string",
")",
"[",
"]",
"string",
"{",
"v",
":=",
"c",
".",
"get",
"(",
"key",
")",
"\n",
"if",
"v",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"strings",
"... | // Strings lookups up the value using the provided key and converts the value to an array of string
// by splitting the string by comma | [
"Strings",
"lookups",
"up",
"the",
"value",
"using",
"the",
"provided",
"key",
"and",
"converts",
"the",
"value",
"to",
"an",
"array",
"of",
"string",
"by",
"splitting",
"the",
"string",
"by",
"comma"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L212-L218 |
158,442 | casbin/casbin | config/config.go | Set | func (c *Config) Set(key string, value string) error {
c.Lock()
defer c.Unlock()
if len(key) == 0 {
return errors.New("key is empty")
}
var (
section string
option string
)
keys := strings.Split(strings.ToLower(key), "::")
if len(keys) >= 2 {
section = keys[0]
option = keys[1]
} else {
option = keys[0]
}
c.AddConfig(section, option, value)
return nil
} | go | func (c *Config) Set(key string, value string) error {
c.Lock()
defer c.Unlock()
if len(key) == 0 {
return errors.New("key is empty")
}
var (
section string
option string
)
keys := strings.Split(strings.ToLower(key), "::")
if len(keys) >= 2 {
section = keys[0]
option = keys[1]
} else {
option = keys[0]
}
c.AddConfig(section, option, value)
return nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Set",
"(",
"key",
"string",
",",
"value",
"string",
")",
"error",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"if",
"len",
"(",
"key",
")",
"==",
"0",
"{",
"return... | // Set sets the value for the specific key in the Config | [
"Set",
"sets",
"the",
"value",
"for",
"the",
"specific",
"key",
"in",
"the",
"Config"
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/config/config.go#L221-L243 |
158,443 | casbin/casbin | enforcer_safe.go | NewEnforcerSafe | func NewEnforcerSafe(params ...interface{}) (e *Enforcer, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
e = nil
}
}()
e = NewEnforcer(params...)
err = nil
return
} | go | func NewEnforcerSafe(params ...interface{}) (e *Enforcer, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
e = nil
}
}()
e = NewEnforcer(params...)
err = nil
return
} | [
"func",
"NewEnforcerSafe",
"(",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"e",
"*",
"Enforcer",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"err",
"=",
... | // NewEnforcerSafe calls NewEnforcer in a safe way, returns error instead of causing panic. | [
"NewEnforcerSafe",
"calls",
"NewEnforcer",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L22-L33 |
158,444 | casbin/casbin | enforcer_safe.go | RemovePolicySafe | func (e *Enforcer) RemovePolicySafe(params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveNamedPolicy("p", params...)
err = nil
return
} | go | func (e *Enforcer) RemovePolicySafe(params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveNamedPolicy("p", params...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"RemovePolicySafe",
"(",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!... | // RemovePolicySafe calls RemovePolicy in a safe way, returns error instead of causing panic. | [
"RemovePolicySafe",
"calls",
"RemovePolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L77-L88 |
158,445 | casbin/casbin | enforcer_safe.go | AddGroupingPolicySafe | func (e *Enforcer) AddGroupingPolicySafe(params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.AddGroupingPolicy(params...)
err = nil
return
} | go | func (e *Enforcer) AddGroupingPolicySafe(params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.AddGroupingPolicy(params...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"AddGroupingPolicySafe",
"(",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",... | // AddGroupingPolicySafe calls AddGroupingPolicy in a safe way, returns error instead of causing panic. | [
"AddGroupingPolicySafe",
"calls",
"AddGroupingPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L105-L116 |
158,446 | casbin/casbin | enforcer_safe.go | AddNamedGroupingPolicySafe | func (e *Enforcer) AddNamedGroupingPolicySafe(ptype string, params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.AddNamedGroupingPolicy(ptype, params...)
err = nil
return
} | go | func (e *Enforcer) AddNamedGroupingPolicySafe(ptype string, params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.AddNamedGroupingPolicy(ptype, params...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"AddNamedGroupingPolicySafe",
"(",
"ptype",
"string",
",",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"re... | // AddNamedGroupingPolicySafe calls AddNamedGroupingPolicy in a safe way, returns error instead of causing panic. | [
"AddNamedGroupingPolicySafe",
"calls",
"AddNamedGroupingPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L119-L130 |
158,447 | casbin/casbin | enforcer_safe.go | AddNamedPolicySafe | func (e *Enforcer) AddNamedPolicySafe(ptype string, params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.AddNamedPolicy(ptype, params...)
err = nil
return
} | go | func (e *Enforcer) AddNamedPolicySafe(ptype string, params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.AddNamedPolicy(ptype, params...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"AddNamedPolicySafe",
"(",
"ptype",
"string",
",",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
... | // AddNamedPolicySafe calls AddNamedPolicy in a safe way, returns error instead of causing panic. | [
"AddNamedPolicySafe",
"calls",
"AddNamedPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L133-L144 |
158,448 | casbin/casbin | enforcer_safe.go | RemoveGroupingPolicySafe | func (e *Enforcer) RemoveGroupingPolicySafe(params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveGroupingPolicy(params...)
err = nil
return
} | go | func (e *Enforcer) RemoveGroupingPolicySafe(params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveGroupingPolicy(params...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"RemoveGroupingPolicySafe",
"(",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"... | // RemoveGroupingPolicySafe calls RemoveGroupingPolicy in a safe way, returns error instead of causing panic. | [
"RemoveGroupingPolicySafe",
"calls",
"RemoveGroupingPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L147-L158 |
158,449 | casbin/casbin | enforcer_safe.go | RemoveFilteredGroupingPolicySafe | func (e *Enforcer) RemoveFilteredGroupingPolicySafe(fieldIndex int, fieldValues ...string) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveFilteredGroupingPolicy(fieldIndex, fieldValues...)
err = nil
return
} | go | func (e *Enforcer) RemoveFilteredGroupingPolicySafe(fieldIndex int, fieldValues ...string) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveFilteredGroupingPolicy(fieldIndex, fieldValues...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"RemoveFilteredGroupingPolicySafe",
"(",
"fieldIndex",
"int",
",",
"fieldValues",
"...",
"string",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recove... | // RemoveFilteredGroupingPolicySafe calls RemoveFilteredGroupingPolicy in a safe way, returns error instead of causing panic. | [
"RemoveFilteredGroupingPolicySafe",
"calls",
"RemoveFilteredGroupingPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L161-L172 |
158,450 | casbin/casbin | enforcer_safe.go | RemoveNamedGroupingPolicySafe | func (e *Enforcer) RemoveNamedGroupingPolicySafe(ptype string, params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveNamedGroupingPolicy(ptype, params...)
err = nil
return
} | go | func (e *Enforcer) RemoveNamedGroupingPolicySafe(ptype string, params ...interface{}) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveNamedGroupingPolicy(ptype, params...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"RemoveNamedGroupingPolicySafe",
"(",
"ptype",
"string",
",",
"params",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
... | // RemoveNamedGroupingPolicySafe calls RemoveNamedGroupingPolicy in a safe way, returns error instead of causing panic. | [
"RemoveNamedGroupingPolicySafe",
"calls",
"RemoveNamedGroupingPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L175-L186 |
158,451 | casbin/casbin | enforcer_safe.go | RemoveFilteredNamedGroupingPolicySafe | func (e *Enforcer) RemoveFilteredNamedGroupingPolicySafe(ptype string, fieldIndex int, fieldValues ...string) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveFilteredNamedGroupingPolicy(ptype, fieldIndex, fieldValues...)
err = nil
return
} | go | func (e *Enforcer) RemoveFilteredNamedGroupingPolicySafe(ptype string, fieldIndex int, fieldValues ...string) (result bool, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
result = false
}
}()
result = e.RemoveFilteredNamedGroupingPolicy(ptype, fieldIndex, fieldValues...)
err = nil
return
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"RemoveFilteredNamedGroupingPolicySafe",
"(",
"ptype",
"string",
",",
"fieldIndex",
"int",
",",
"fieldValues",
"...",
"string",
")",
"(",
"result",
"bool",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{... | // RemoveFilteredNamedGroupingPolicySafe calls RemoveFilteredNamedGroupingPolicy in a safe way, returns error instead of causing panic. | [
"RemoveFilteredNamedGroupingPolicySafe",
"calls",
"RemoveFilteredNamedGroupingPolicy",
"in",
"a",
"safe",
"way",
"returns",
"error",
"instead",
"of",
"causing",
"panic",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer_safe.go#L189-L200 |
158,452 | casbin/casbin | rbac_api_synced.go | GetPermissionsForUser | func (e *SyncedEnforcer) GetPermissionsForUser(user string) [][]string {
e.m.Lock()
defer e.m.Unlock()
return e.Enforcer.GetPermissionsForUser(user)
} | go | func (e *SyncedEnforcer) GetPermissionsForUser(user string) [][]string {
e.m.Lock()
defer e.m.Unlock()
return e.Enforcer.GetPermissionsForUser(user)
} | [
"func",
"(",
"e",
"*",
"SyncedEnforcer",
")",
"GetPermissionsForUser",
"(",
"user",
"string",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"e",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"m",
".",
"Unlock",
"(",
")",
"\n",
"return",
"e"... | // GetPermissionsForUser gets permissions for a user or role. | [
"GetPermissionsForUser",
"gets",
"permissions",
"for",
"a",
"user",
"or",
"role",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/rbac_api_synced.go#L110-L114 |
158,453 | casbin/casbin | enforcer.go | InitWithFile | func (e *Enforcer) InitWithFile(modelPath string, policyPath string) {
a := fileadapter.NewAdapter(policyPath)
e.InitWithAdapter(modelPath, a)
} | go | func (e *Enforcer) InitWithFile(modelPath string, policyPath string) {
a := fileadapter.NewAdapter(policyPath)
e.InitWithAdapter(modelPath, a)
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"InitWithFile",
"(",
"modelPath",
"string",
",",
"policyPath",
"string",
")",
"{",
"a",
":=",
"fileadapter",
".",
"NewAdapter",
"(",
"policyPath",
")",
"\n",
"e",
".",
"InitWithAdapter",
"(",
"modelPath",
",",
"a",
... | // InitWithFile initializes an enforcer with a model file and a policy file. | [
"InitWithFile",
"initializes",
"an",
"enforcer",
"with",
"a",
"model",
"file",
"and",
"a",
"policy",
"file",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer.go#L101-L104 |
158,454 | casbin/casbin | enforcer.go | InitWithAdapter | func (e *Enforcer) InitWithAdapter(modelPath string, adapter persist.Adapter) {
m := NewModel(modelPath, "")
e.InitWithModelAndAdapter(m, adapter)
e.modelPath = modelPath
} | go | func (e *Enforcer) InitWithAdapter(modelPath string, adapter persist.Adapter) {
m := NewModel(modelPath, "")
e.InitWithModelAndAdapter(m, adapter)
e.modelPath = modelPath
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"InitWithAdapter",
"(",
"modelPath",
"string",
",",
"adapter",
"persist",
".",
"Adapter",
")",
"{",
"m",
":=",
"NewModel",
"(",
"modelPath",
",",
"\"",
"\"",
")",
"\n",
"e",
".",
"InitWithModelAndAdapter",
"(",
"m"... | // InitWithAdapter initializes an enforcer with a database adapter. | [
"InitWithAdapter",
"initializes",
"an",
"enforcer",
"with",
"a",
"database",
"adapter",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer.go#L107-L112 |
158,455 | casbin/casbin | enforcer.go | InitWithModelAndAdapter | func (e *Enforcer) InitWithModelAndAdapter(m model.Model, adapter persist.Adapter) {
e.adapter = adapter
e.model = m
e.model.PrintModel()
e.fm = model.LoadFunctionMap()
e.initialize()
// Do not initialize the full policy when using a filtered adapter
fa, ok := e.adapter.(persist.FilteredAdapter)
if e.adapter != nil && (!ok || ok && !fa.IsFiltered()) {
// error intentionally ignored
e.LoadPolicy()
}
} | go | func (e *Enforcer) InitWithModelAndAdapter(m model.Model, adapter persist.Adapter) {
e.adapter = adapter
e.model = m
e.model.PrintModel()
e.fm = model.LoadFunctionMap()
e.initialize()
// Do not initialize the full policy when using a filtered adapter
fa, ok := e.adapter.(persist.FilteredAdapter)
if e.adapter != nil && (!ok || ok && !fa.IsFiltered()) {
// error intentionally ignored
e.LoadPolicy()
}
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"InitWithModelAndAdapter",
"(",
"m",
"model",
".",
"Model",
",",
"adapter",
"persist",
".",
"Adapter",
")",
"{",
"e",
".",
"adapter",
"=",
"adapter",
"\n\n",
"e",
".",
"model",
"=",
"m",
"\n",
"e",
".",
"model"... | // InitWithModelAndAdapter initializes an enforcer with a model and a database adapter. | [
"InitWithModelAndAdapter",
"initializes",
"an",
"enforcer",
"with",
"a",
"model",
"and",
"a",
"database",
"adapter",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer.go#L115-L130 |
158,456 | casbin/casbin | enforcer.go | NewModel | func NewModel(text ...string) model.Model {
m := make(model.Model)
if len(text) == 2 {
if text[0] != "" {
m.LoadModel(text[0])
}
} else if len(text) == 1 {
m.LoadModelFromText(text[0])
} else if len(text) != 0 {
panic("Invalid parameters for model.")
}
return m
} | go | func NewModel(text ...string) model.Model {
m := make(model.Model)
if len(text) == 2 {
if text[0] != "" {
m.LoadModel(text[0])
}
} else if len(text) == 1 {
m.LoadModelFromText(text[0])
} else if len(text) != 0 {
panic("Invalid parameters for model.")
}
return m
} | [
"func",
"NewModel",
"(",
"text",
"...",
"string",
")",
"model",
".",
"Model",
"{",
"m",
":=",
"make",
"(",
"model",
".",
"Model",
")",
"\n\n",
"if",
"len",
"(",
"text",
")",
"==",
"2",
"{",
"if",
"text",
"[",
"0",
"]",
"!=",
"\"",
"\"",
"{",
... | // NewModel creates a model. | [
"NewModel",
"creates",
"a",
"model",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer.go#L143-L157 |
158,457 | casbin/casbin | enforcer.go | SetModel | func (e *Enforcer) SetModel(m model.Model) {
e.model = m
e.fm = model.LoadFunctionMap()
} | go | func (e *Enforcer) SetModel(m model.Model) {
e.model = m
e.fm = model.LoadFunctionMap()
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"SetModel",
"(",
"m",
"model",
".",
"Model",
")",
"{",
"e",
".",
"model",
"=",
"m",
"\n",
"e",
".",
"fm",
"=",
"model",
".",
"LoadFunctionMap",
"(",
")",
"\n",
"}"
] | // SetModel sets the current model. | [
"SetModel",
"sets",
"the",
"current",
"model",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer.go#L174-L177 |
158,458 | casbin/casbin | enforcer.go | IsFiltered | func (e *Enforcer) IsFiltered() bool {
filteredAdapter, ok := e.adapter.(persist.FilteredAdapter)
if !ok {
return false
}
return filteredAdapter.IsFiltered()
} | go | func (e *Enforcer) IsFiltered() bool {
filteredAdapter, ok := e.adapter.(persist.FilteredAdapter)
if !ok {
return false
}
return filteredAdapter.IsFiltered()
} | [
"func",
"(",
"e",
"*",
"Enforcer",
")",
"IsFiltered",
"(",
")",
"bool",
"{",
"filteredAdapter",
",",
"ok",
":=",
"e",
".",
"adapter",
".",
"(",
"persist",
".",
"FilteredAdapter",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
... | // IsFiltered returns true if the loaded policy has been filtered. | [
"IsFiltered",
"returns",
"true",
"if",
"the",
"loaded",
"policy",
"has",
"been",
"filtered",
"."
] | 9814ac94c19c922c0afd5c2f34255e0d543ef372 | https://github.com/casbin/casbin/blob/9814ac94c19c922c0afd5c2f34255e0d543ef372/enforcer.go#L250-L256 |
158,459 | keybase/client | go/kbfs/libkbfs/leveldb.go | Close | func (ldb *LevelDb) Close() (err error) {
err = ldb.DB.Close()
// Hide the closer error.
_ = ldb.closer.Close()
return err
} | go | func (ldb *LevelDb) Close() (err error) {
err = ldb.DB.Close()
// Hide the closer error.
_ = ldb.closer.Close()
return err
} | [
"func",
"(",
"ldb",
"*",
"LevelDb",
")",
"Close",
"(",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"ldb",
".",
"DB",
".",
"Close",
"(",
")",
"\n",
"// Hide the closer error.",
"_",
"=",
"ldb",
".",
"closer",
".",
"Close",
"(",
")",
"\n",
"ret... | // Close closes the DB. | [
"Close",
"closes",
"the",
"DB",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L47-L52 |
158,460 | keybase/client | go/kbfs/libkbfs/leveldb.go | Get | func (ldb *LevelDb) Get(key []byte, ro *opt.ReadOptions) (
value []byte, err error) {
defer func() {
if err != nil {
err = errors.WithStack(err)
}
}()
return ldb.DB.Get(key, ro)
} | go | func (ldb *LevelDb) Get(key []byte, ro *opt.ReadOptions) (
value []byte, err error) {
defer func() {
if err != nil {
err = errors.WithStack(err)
}
}()
return ldb.DB.Get(key, ro)
} | [
"func",
"(",
"ldb",
"*",
"LevelDb",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"n... | // Get gets data from the DB. | [
"Get",
"gets",
"data",
"from",
"the",
"DB",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L55-L63 |
158,461 | keybase/client | go/kbfs/libkbfs/leveldb.go | GetWithMeter | func (ldb *LevelDb) GetWithMeter(key []byte, hitMeter, missMeter *CountMeter) (
value []byte, err error) {
defer func() {
if err == nil {
if hitMeter != nil {
hitMeter.Mark(1)
}
} else if missMeter != nil {
missMeter.Mark(1)
}
}()
return ldb.Get(key, nil)
} | go | func (ldb *LevelDb) GetWithMeter(key []byte, hitMeter, missMeter *CountMeter) (
value []byte, err error) {
defer func() {
if err == nil {
if hitMeter != nil {
hitMeter.Mark(1)
}
} else if missMeter != nil {
missMeter.Mark(1)
}
}()
return ldb.Get(key, nil)
} | [
"func",
"(",
"ldb",
"*",
"LevelDb",
")",
"GetWithMeter",
"(",
"key",
"[",
"]",
"byte",
",",
"hitMeter",
",",
"missMeter",
"*",
"CountMeter",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
... | // GetWithMeter gets data from the DB while tracking the hit rate. | [
"GetWithMeter",
"gets",
"data",
"from",
"the",
"DB",
"while",
"tracking",
"the",
"hit",
"rate",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L66-L78 |
158,462 | keybase/client | go/kbfs/libkbfs/leveldb.go | Put | func (ldb *LevelDb) Put(key, value []byte, wo *opt.WriteOptions) (err error) {
defer func() {
if err != nil {
err = errors.WithStack(err)
}
}()
return ldb.DB.Put(key, value, wo)
} | go | func (ldb *LevelDb) Put(key, value []byte, wo *opt.WriteOptions) (err error) {
defer func() {
if err != nil {
err = errors.WithStack(err)
}
}()
return ldb.DB.Put(key, value, wo)
} | [
"func",
"(",
"ldb",
"*",
"LevelDb",
")",
"Put",
"(",
"key",
",",
"value",
"[",
"]",
"byte",
",",
"wo",
"*",
"opt",
".",
"WriteOptions",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"err",
... | // Put puts data into the DB. | [
"Put",
"puts",
"data",
"into",
"the",
"DB",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L81-L88 |
158,463 | keybase/client | go/kbfs/libkbfs/leveldb.go | PutWithMeter | func (ldb *LevelDb) PutWithMeter(key, value []byte, putMeter *CountMeter) (
err error) {
defer func() {
if err == nil && putMeter != nil {
putMeter.Mark(1)
}
}()
return ldb.Put(key, value, nil)
} | go | func (ldb *LevelDb) PutWithMeter(key, value []byte, putMeter *CountMeter) (
err error) {
defer func() {
if err == nil && putMeter != nil {
putMeter.Mark(1)
}
}()
return ldb.Put(key, value, nil)
} | [
"func",
"(",
"ldb",
"*",
"LevelDb",
")",
"PutWithMeter",
"(",
"key",
",",
"value",
"[",
"]",
"byte",
",",
"putMeter",
"*",
"CountMeter",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"==",
"nil",
"&&",
"putMeter",... | // PutWithMeter gets data from the DB while tracking the hit rate. | [
"PutWithMeter",
"gets",
"data",
"from",
"the",
"DB",
"while",
"tracking",
"the",
"hit",
"rate",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L91-L99 |
158,464 | keybase/client | go/kbfs/libkbfs/leveldb.go | openLevelDBWithOptions | func openLevelDBWithOptions(stor storage.Storage, options *opt.Options) (
*LevelDb, error) {
db, err := leveldb.Open(stor, options)
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)
}
if err != nil {
stor.Close()
return nil, err
}
return &LevelDb{db, stor}, nil
} | go | func openLevelDBWithOptions(stor storage.Storage, options *opt.Options) (
*LevelDb, error) {
db, err := leveldb.Open(stor, options)
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)
}
if err != nil {
stor.Close()
return nil, err
}
return &LevelDb{db, stor}, nil
} | [
"func",
"openLevelDBWithOptions",
"(",
"stor",
"storage",
".",
"Storage",
",",
"options",
"*",
"opt",
".",
"Options",
")",
"(",
"*",
"LevelDb",
",",
"error",
")",
"{",
"db",
",",
"err",
":=",
"leveldb",
".",
"Open",
"(",
"stor",
",",
"options",
")",
... | // openLevelDB opens or recovers a leveldb.DB with a passed-in storage.Storage
// as its underlying storage layer, and with the options specified. | [
"openLevelDB",
"opens",
"or",
"recovers",
"a",
"leveldb",
".",
"DB",
"with",
"a",
"passed",
"-",
"in",
"storage",
".",
"Storage",
"as",
"its",
"underlying",
"storage",
"layer",
"and",
"with",
"the",
"options",
"specified",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L103-L119 |
158,465 | keybase/client | go/kbfs/libkbfs/leveldb.go | openLevelDB | func openLevelDB(stor storage.Storage) (*LevelDb, error) {
options := *leveldbOptions
options.Filter = filter.NewBloomFilter(16)
return openLevelDBWithOptions(stor, &options)
} | go | func openLevelDB(stor storage.Storage) (*LevelDb, error) {
options := *leveldbOptions
options.Filter = filter.NewBloomFilter(16)
return openLevelDBWithOptions(stor, &options)
} | [
"func",
"openLevelDB",
"(",
"stor",
"storage",
".",
"Storage",
")",
"(",
"*",
"LevelDb",
",",
"error",
")",
"{",
"options",
":=",
"*",
"leveldbOptions",
"\n",
"options",
".",
"Filter",
"=",
"filter",
".",
"NewBloomFilter",
"(",
"16",
")",
"\n",
"return",... | // openLevelDB opens or recovers a leveldb.DB with a passed-in storage.Storage
// as its underlying storage layer. | [
"openLevelDB",
"opens",
"or",
"recovers",
"a",
"leveldb",
".",
"DB",
"with",
"a",
"passed",
"-",
"in",
"storage",
".",
"Storage",
"as",
"its",
"underlying",
"storage",
"layer",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L123-L127 |
158,466 | keybase/client | go/kbfs/libkbfs/leveldb.go | openVersionedLevelDB | func openVersionedLevelDB(log logger.Logger, storageRoot string,
dbFolderName string, currentDiskCacheVersion uint64, dbFilename string) (
db *LevelDb, err error) {
dbPath := filepath.Join(storageRoot, dbFolderName)
versionPath, err := getVersionedPathForDiskCache(
log, dbPath, dbFolderName, currentDiskCacheVersion)
if err != nil {
return nil, err
}
p := filepath.Join(versionPath, dbFilename)
log.Debug("opening LevelDB: %s", p)
storage, err := storage.OpenFile(p, false)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
storage.Close()
}
}()
options := *leveldbOptions
if db, err = openLevelDBWithOptions(storage, &options); err != nil {
return nil, err
}
return db, nil
} | go | func openVersionedLevelDB(log logger.Logger, storageRoot string,
dbFolderName string, currentDiskCacheVersion uint64, dbFilename string) (
db *LevelDb, err error) {
dbPath := filepath.Join(storageRoot, dbFolderName)
versionPath, err := getVersionedPathForDiskCache(
log, dbPath, dbFolderName, currentDiskCacheVersion)
if err != nil {
return nil, err
}
p := filepath.Join(versionPath, dbFilename)
log.Debug("opening LevelDB: %s", p)
storage, err := storage.OpenFile(p, false)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
storage.Close()
}
}()
options := *leveldbOptions
if db, err = openLevelDBWithOptions(storage, &options); err != nil {
return nil, err
}
return db, nil
} | [
"func",
"openVersionedLevelDB",
"(",
"log",
"logger",
".",
"Logger",
",",
"storageRoot",
"string",
",",
"dbFolderName",
"string",
",",
"currentDiskCacheVersion",
"uint64",
",",
"dbFilename",
"string",
")",
"(",
"db",
"*",
"LevelDb",
",",
"err",
"error",
")",
"... | // 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. | [
"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",
"actu... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/leveldb.go#L212-L237 |
158,467 | keybase/client | go/libkb/stream_classifier.go | ClassifyStream | 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)
buf, err := stream.Peek(4096)
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
}
err = nil
}
sb := string(buf)
switch {
case strings.HasPrefix(sb, "-----BEGIN PGP MESSAGE-----"):
sc.Format = CryptoMessageFormatPGP
sc.Armored = true
sc.Type = CryptoMessageTypeAmbiguous
case strings.HasPrefix(sb, "-----BEGIN PGP SIGNATURE-----"):
sc.Format = CryptoMessageFormatPGP
sc.Armored = true
sc.Type = CryptoMessageTypeDetachedSignature
case strings.HasPrefix(sb, "-----BEGIN PGP SIGNED MESSAGE-----"):
sc.Format = CryptoMessageFormatPGP
sc.Armored = true
sc.Type = CryptoMessageTypeClearSignature
case isSaltpackMessage(stream, &sc):
// Format etc. set by isSaltpackBinary().
case isBase64KeybaseV0Sig(sb):
sc.Format = CryptoMessageFormatKeybaseV0
sc.Armored = true
sc.Type = CryptoMessageTypeAttachedSignature
case isPGPBinary(buf, &sc):
// Format etc. set by isPGPBinary().
case isUTF16Mark(buf):
err = UTF16UnsupportedError{}
default:
err = UnknownStreamError{}
}
return sc, stream, err
} | go | 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)
buf, err := stream.Peek(4096)
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
}
err = nil
}
sb := string(buf)
switch {
case strings.HasPrefix(sb, "-----BEGIN PGP MESSAGE-----"):
sc.Format = CryptoMessageFormatPGP
sc.Armored = true
sc.Type = CryptoMessageTypeAmbiguous
case strings.HasPrefix(sb, "-----BEGIN PGP SIGNATURE-----"):
sc.Format = CryptoMessageFormatPGP
sc.Armored = true
sc.Type = CryptoMessageTypeDetachedSignature
case strings.HasPrefix(sb, "-----BEGIN PGP SIGNED MESSAGE-----"):
sc.Format = CryptoMessageFormatPGP
sc.Armored = true
sc.Type = CryptoMessageTypeClearSignature
case isSaltpackMessage(stream, &sc):
// Format etc. set by isSaltpackBinary().
case isBase64KeybaseV0Sig(sb):
sc.Format = CryptoMessageFormatKeybaseV0
sc.Armored = true
sc.Type = CryptoMessageTypeAttachedSignature
case isPGPBinary(buf, &sc):
// Format etc. set by isPGPBinary().
case isUTF16Mark(buf):
err = UTF16UnsupportedError{}
default:
err = UnknownStreamError{}
}
return sc, stream, err
} | [
"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 ... | // 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. | [
"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",
"f... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/stream_classifier.go#L156-L198 |
158,468 | keybase/client | go/libkb/identify3.go | markShutdown | func (s *Identify3State) markShutdown(ch chan struct{}) bool {
s.shutdownMu.Lock()
defer s.shutdownMu.Unlock()
if s.shutdown {
return false
}
s.shutdownCh <- ch
s.shutdownCh = nil
s.shutdown = true
return true
} | go | func (s *Identify3State) markShutdown(ch chan struct{}) bool {
s.shutdownMu.Lock()
defer s.shutdownMu.Unlock()
if s.shutdown {
return false
}
s.shutdownCh <- ch
s.shutdownCh = nil
s.shutdown = true
return true
} | [
"func",
"(",
"s",
"*",
"Identify3State",
")",
"markShutdown",
"(",
"ch",
"chan",
"struct",
"{",
"}",
")",
"bool",
"{",
"s",
".",
"shutdownMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"shutdownMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
... | // markShutdown marks this state as having shutdown. Will return true the first
// time through, and false every other time. | [
"markShutdown",
"marks",
"this",
"state",
"as",
"having",
"shutdown",
".",
"Will",
"return",
"true",
"the",
"first",
"time",
"through",
"and",
"false",
"every",
"other",
"time",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/identify3.go#L162-L172 |
158,469 | keybase/client | go/libkb/identify3.go | getSessionToExpire | func (s *Identify3State) getSessionToExpire(mctx MetaContext, now time.Time) (*Identify3Session, time.Duration) {
sess := s.expirationQueue[0]
sess.Lock()
defer sess.Unlock()
expireAt := sess.created.Add(s.expireTime)
diff := expireAt.Sub(now)
if diff > 0 {
return nil, diff
}
s.expirationQueue = s.expirationQueue[1:]
// 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
}
mctx.Debug("Identify3State#getSessionToExpire: removing %s", sess.id)
s.removeFromTableLocked(sess.id)
return sess, diff
} | go | func (s *Identify3State) getSessionToExpire(mctx MetaContext, now time.Time) (*Identify3Session, time.Duration) {
sess := s.expirationQueue[0]
sess.Lock()
defer sess.Unlock()
expireAt := sess.created.Add(s.expireTime)
diff := expireAt.Sub(now)
if diff > 0 {
return nil, diff
}
s.expirationQueue = s.expirationQueue[1:]
// 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
}
mctx.Debug("Identify3State#getSessionToExpire: removing %s", sess.id)
s.removeFromTableLocked(sess.id)
return sess, diff
} | [
"func",
"(",
"s",
"*",
"Identify3State",
")",
"getSessionToExpire",
"(",
"mctx",
"MetaContext",
",",
"now",
"time",
".",
"Time",
")",
"(",
"*",
"Identify3Session",
",",
"time",
".",
"Duration",
")",
"{",
"sess",
":=",
"s",
".",
"expirationQueue",
"[",
"0... | // 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. | [
"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",
"."... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/identify3.go#L290-L309 |
158,470 | keybase/client | go/client/cmd_config.go | looksLikeBool | func (v *CmdConfigSet) looksLikeBool(s string) bool {
switch s {
case "t", "T", "true", "TRUE", "True":
return true
case "f", "F", "false", "FALSE", "False":
return true
}
return false
} | go | func (v *CmdConfigSet) looksLikeBool(s string) bool {
switch s {
case "t", "T", "true", "TRUE", "True":
return true
case "f", "F", "false", "FALSE", "False":
return true
}
return false
} | [
"func",
"(",
"v",
"*",
"CmdConfigSet",
")",
"looksLikeBool",
"(",
"s",
"string",
")",
"bool",
"{",
"switch",
"s",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"true",
"\n",
"case",
... | // like strconv.ParseBool, but without 0 and 1. | [
"like",
"strconv",
".",
"ParseBool",
"but",
"without",
"0",
"and",
"1",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_config.go#L149-L157 |
158,471 | keybase/client | go/client/cmd_simplefs_move.go | NewCmdSimpleFSMove | func NewCmdSimpleFSMove(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "mv",
ArgumentHelp: "<source> [source] <dest>",
Usage: "move one or more directory elements to dest",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdSimpleFSMove{
Contextified: libkb.NewContextified(g),
opCanceler: NewOpCanceler(g),
}, "mv", c)
cl.SetNoStandalone()
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "i, interactive",
Usage: "Prompt before overwrite",
},
cli.BoolFlag{
Name: "f, force",
Usage: "force overwrite",
},
},
}
} | go | func NewCmdSimpleFSMove(cl *libcmdline.CommandLine, g *libkb.GlobalContext) cli.Command {
return cli.Command{
Name: "mv",
ArgumentHelp: "<source> [source] <dest>",
Usage: "move one or more directory elements to dest",
Action: func(c *cli.Context) {
cl.ChooseCommand(&CmdSimpleFSMove{
Contextified: libkb.NewContextified(g),
opCanceler: NewOpCanceler(g),
}, "mv", c)
cl.SetNoStandalone()
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "i, interactive",
Usage: "Prompt before overwrite",
},
cli.BoolFlag{
Name: "f, force",
Usage: "force overwrite",
},
},
}
} | [
"func",
"NewCmdSimpleFSMove",
"(",
"cl",
"*",
"libcmdline",
".",
"CommandLine",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"cli",
".",
"Command",
"{",
"return",
"cli",
".",
"Command",
"{",
"Name",
":",
"\"",
"\"",
",",
"ArgumentHelp",
":",
"\"",
... | // NewCmdSimpleFSMove creates a new cli.Command. | [
"NewCmdSimpleFSMove",
"creates",
"a",
"new",
"cli",
".",
"Command",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_simplefs_move.go#L30-L53 |
158,472 | keybase/client | go/install/install_default.go | Install | func Install(context Context, binPath string, sourcePath string, components []string, force bool, timeout time.Duration, log Log) keybase1.InstallResult {
return keybase1.InstallResult{}
} | go | func Install(context Context, binPath string, sourcePath string, components []string, force bool, timeout time.Duration, log Log) keybase1.InstallResult {
return keybase1.InstallResult{}
} | [
"func",
"Install",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"sourcePath",
"string",
",",
"components",
"[",
"]",
"string",
",",
"force",
"bool",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"keybase1",
".",
"InstallResu... | // Install empty implementation for unsupported platforms | [
"Install",
"empty",
"implementation",
"for",
"unsupported",
"platforms"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_default.go#L17-L19 |
158,473 | keybase/client | go/install/install_default.go | Uninstall | func Uninstall(context Context, components []string, log Log) keybase1.UninstallResult {
return keybase1.UninstallResult{}
} | go | func Uninstall(context Context, components []string, log Log) keybase1.UninstallResult {
return keybase1.UninstallResult{}
} | [
"func",
"Uninstall",
"(",
"context",
"Context",
",",
"components",
"[",
"]",
"string",
",",
"log",
"Log",
")",
"keybase1",
".",
"UninstallResult",
"{",
"return",
"keybase1",
".",
"UninstallResult",
"{",
"}",
"\n",
"}"
] | // Uninstall empty implementation for unsupported platforms | [
"Uninstall",
"empty",
"implementation",
"for",
"unsupported",
"platforms"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_default.go#L22-L24 |
158,474 | keybase/client | go/kbfs/libkbfs/cr_actions.go | trackSyncPtrChangesInCreate | func trackSyncPtrChangesInCreate(
mostRecentTargetPtr data.BlockPointer, unmergedChain *crChain,
unmergedChains *crChains, toName string) {
targetChain, ok := unmergedChains.byMostRecent[mostRecentTargetPtr]
var refs, unrefs []data.BlockPointer
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)
if !ok {
continue
}
for _, ref := range op.Refs() {
if !unmergedChains.isDeleted(ref) {
refs = append(refs, ref)
}
}
for _, unref := range op.Unrefs() {
unrefs = append(unrefs, unref)
}
// Account for the file ptr too, if it's the most recent.
filePtr := syncOp.File.Ref
_, isMostRecent := unmergedChains.byMostRecent[filePtr]
if isMostRecent && !unmergedChains.isDeleted(filePtr) {
refs = append(refs, filePtr)
}
}
}
if len(refs) > 0 {
for _, uop := range unmergedChain.ops {
cop, ok := uop.(*createOp)
if !ok || cop.NewName != toName {
continue
}
for _, ref := range refs {
cop.AddRefBlock(ref)
}
for _, unref := range unrefs {
cop.AddUnrefBlock(unref)
}
break
}
}
} | go | func trackSyncPtrChangesInCreate(
mostRecentTargetPtr data.BlockPointer, unmergedChain *crChain,
unmergedChains *crChains, toName string) {
targetChain, ok := unmergedChains.byMostRecent[mostRecentTargetPtr]
var refs, unrefs []data.BlockPointer
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)
if !ok {
continue
}
for _, ref := range op.Refs() {
if !unmergedChains.isDeleted(ref) {
refs = append(refs, ref)
}
}
for _, unref := range op.Unrefs() {
unrefs = append(unrefs, unref)
}
// Account for the file ptr too, if it's the most recent.
filePtr := syncOp.File.Ref
_, isMostRecent := unmergedChains.byMostRecent[filePtr]
if isMostRecent && !unmergedChains.isDeleted(filePtr) {
refs = append(refs, filePtr)
}
}
}
if len(refs) > 0 {
for _, uop := range unmergedChain.ops {
cop, ok := uop.(*createOp)
if !ok || cop.NewName != toName {
continue
}
for _, ref := range refs {
cop.AddRefBlock(ref)
}
for _, unref := range unrefs {
cop.AddUnrefBlock(unref)
}
break
}
}
} | [
"func",
"trackSyncPtrChangesInCreate",
"(",
"mostRecentTargetPtr",
"data",
".",
"BlockPointer",
",",
"unmergedChain",
"*",
"crChain",
",",
"unmergedChains",
"*",
"crChains",
",",
"toName",
"string",
")",
"{",
"targetChain",
",",
"ok",
":=",
"unmergedChains",
".",
... | // 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. | [
"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",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/cr_actions.go#L276-L321 |
158,475 | keybase/client | go/kbfs/libkbfs/cr_actions.go | collapse | 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
indicesToRemove := make(map[int]bool)
for i, untypedAction := range cal {
switch action := untypedAction.(type) {
// Unmerged actions:
case *renameUnmergedAction:
setTopAction(action, action.fromName, i, infoMap, indicesToRemove)
case *copyUnmergedEntryAction:
untypedTopAction := infoMap[action.fromName].topAction
switch untypedTopAction.(type) {
case *renameUnmergedAction:
indicesToRemove[i] = true
default:
setTopAction(action, action.fromName, i, infoMap,
indicesToRemove)
}
case *copyUnmergedAttrAction:
untypedTopAction := infoMap[action.fromName].topAction
switch topAction := untypedTopAction.(type) {
case *renameUnmergedAction:
indicesToRemove[i] = true
case *copyUnmergedEntryAction:
indicesToRemove[i] = true
case *copyUnmergedAttrAction:
// Add attributes to the current top action, if not
// already there.
for _, a := range action.attr {
found := false
for _, topA := range topAction.attr {
if a == topA {
found = true
break
}
}
if !found {
topAction.attr = append(topAction.attr, a)
}
}
indicesToRemove[i] = true
default:
setTopAction(action, action.fromName, i, infoMap,
indicesToRemove)
}
// Merged actions
case *renameMergedAction:
// Prefix merged actions with a reserved prefix to keep
// them separate from the unmerged actions.
setTopAction(action, ".kbfs_merged_"+action.fromName, i, infoMap,
indicesToRemove)
}
}
if len(indicesToRemove) == 0 {
return cal
}
newList := make(crActionList, 0, len(cal)-len(indicesToRemove))
for i, action := range cal {
if indicesToRemove[i] {
continue
}
newList = append(newList, action)
}
return newList
} | go | 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
indicesToRemove := make(map[int]bool)
for i, untypedAction := range cal {
switch action := untypedAction.(type) {
// Unmerged actions:
case *renameUnmergedAction:
setTopAction(action, action.fromName, i, infoMap, indicesToRemove)
case *copyUnmergedEntryAction:
untypedTopAction := infoMap[action.fromName].topAction
switch untypedTopAction.(type) {
case *renameUnmergedAction:
indicesToRemove[i] = true
default:
setTopAction(action, action.fromName, i, infoMap,
indicesToRemove)
}
case *copyUnmergedAttrAction:
untypedTopAction := infoMap[action.fromName].topAction
switch topAction := untypedTopAction.(type) {
case *renameUnmergedAction:
indicesToRemove[i] = true
case *copyUnmergedEntryAction:
indicesToRemove[i] = true
case *copyUnmergedAttrAction:
// Add attributes to the current top action, if not
// already there.
for _, a := range action.attr {
found := false
for _, topA := range topAction.attr {
if a == topA {
found = true
break
}
}
if !found {
topAction.attr = append(topAction.attr, a)
}
}
indicesToRemove[i] = true
default:
setTopAction(action, action.fromName, i, infoMap,
indicesToRemove)
}
// Merged actions
case *renameMergedAction:
// Prefix merged actions with a reserved prefix to keep
// them separate from the unmerged actions.
setTopAction(action, ".kbfs_merged_"+action.fromName, i, infoMap,
indicesToRemove)
}
}
if len(indicesToRemove) == 0 {
return cal
}
newList := make(crActionList, 0, len(cal)-len(indicesToRemove))
for i, action := range cal {
if indicesToRemove[i] {
continue
}
newList = append(newList, action)
}
return newList
} | [
"func",
"(",
"cal",
"crActionList",
")",
"collapse",
"(",
")",
"crActionList",
"{",
"// Order of precedence for a given fromName:",
"// 1) renameUnmergedAction",
"// 2) copyUnmergedEntryAction",
"// 3) copyUnmergedAttrAction",
"infoMap",
":=",
"make",
"(",
"map",
"[",
"string... | // 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. | [
"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",
"direc... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/cr_actions.go#L1016-L1088 |
158,476 | keybase/client | go/ephemeral/user_ek.go | prepareNewUserEK | 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("prepareNewUserEK", func() error { return err })()
seed, err := newUserEphemeralSeed()
if err != nil {
return "", nil, newMetadata, nil, err
}
prevStatement, latestGeneration, wrongKID, err := fetchUserEKStatement(mctx, mctx.G().Env.GetUID())
if !wrongKID && err != nil {
return "", nil, newMetadata, nil, err
}
var newGeneration keybase1.EkGeneration
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
} else {
newGeneration = prevStatement.CurrentUserEkMetadata.Generation + 1
}
dhKeypair := seed.DeriveDHKey()
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()),
}
statement := keybase1.UserEkStatement{
CurrentUserEkMetadata: metadata,
}
statementJSON, err := json.Marshal(statement)
if err != nil {
return "", nil, newMetadata, nil, err
}
sig, _, err = pukSigning.SignToString(statementJSON)
if err != nil {
return "", nil, newMetadata, nil, err
}
boxes, myUserEKBoxed, err := boxUserEKForDevices(mctx, merkleRoot, seed, metadata)
if err != nil {
return "", nil, newMetadata, nil, err
}
return sig, boxes, metadata, myUserEKBoxed, nil
} | go | 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("prepareNewUserEK", func() error { return err })()
seed, err := newUserEphemeralSeed()
if err != nil {
return "", nil, newMetadata, nil, err
}
prevStatement, latestGeneration, wrongKID, err := fetchUserEKStatement(mctx, mctx.G().Env.GetUID())
if !wrongKID && err != nil {
return "", nil, newMetadata, nil, err
}
var newGeneration keybase1.EkGeneration
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
} else {
newGeneration = prevStatement.CurrentUserEkMetadata.Generation + 1
}
dhKeypair := seed.DeriveDHKey()
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()),
}
statement := keybase1.UserEkStatement{
CurrentUserEkMetadata: metadata,
}
statementJSON, err := json.Marshal(statement)
if err != nil {
return "", nil, newMetadata, nil, err
}
sig, _, err = pukSigning.SignToString(statementJSON)
if err != nil {
return "", nil, newMetadata, nil, err
}
boxes, myUserEKBoxed, err := boxUserEKForDevices(mctx, merkleRoot, seed, metadata)
if err != nil {
return "", nil, newMetadata, nil, err
}
return sig, boxes, metadata, myUserEKBoxed, nil
} | [
"func",
"prepareNewUserEK",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"merkleRoot",
"libkb",
".",
"MerkleRoot",
",",
"pukSigning",
"*",
"libkb",
".",
"NaclSigningKeyPair",
")",
"(",
"sig",
"string",
",",
"boxes",
"[",
"]",
"keybase1",
".",
"UserEkBoxMetad... | // 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. | [
"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",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/ephemeral/user_ek.go#L61-L117 |
158,477 | keybase/client | go/ephemeral/user_ek.go | publishNewUserEK | func publishNewUserEK(mctx libkb.MetaContext, merkleRoot libkb.MerkleRoot) (
metadata keybase1.UserEkMetadata, err error) {
defer mctx.TraceTimed("publishNewUserEK", func() error { return err })()
// Sign the statement blob with the latest PUK.
pukKeyring, err := mctx.G().GetPerUserKeyring(mctx.Ctx())
if err != nil {
return metadata, err
}
if err := pukKeyring.Sync(mctx); err != nil {
return metadata, err
}
if !pukKeyring.HasAnyKeys() {
return metadata, fmt.Errorf("A PUK is needed to generate ephemeral keys. Aborting.")
}
pukSigning, err := pukKeyring.GetLatestSigningKey(mctx)
if err != nil {
return metadata, err
}
sig, boxes, newMetadata, myBox, err := prepareNewUserEK(mctx, merkleRoot, pukSigning)
if err != nil {
return metadata, err
}
if err = postNewUserEK(mctx, sig, boxes); err != nil {
return metadata, err
}
// Cache the new box after we see the post succeeded.
if myBox == nil {
mctx.Debug("No box made for own deviceEK")
} else {
storage := mctx.G().GetUserEKBoxStorage()
err = storage.Put(mctx, newMetadata.Generation, *myBox)
}
return newMetadata, err
} | go | func publishNewUserEK(mctx libkb.MetaContext, merkleRoot libkb.MerkleRoot) (
metadata keybase1.UserEkMetadata, err error) {
defer mctx.TraceTimed("publishNewUserEK", func() error { return err })()
// Sign the statement blob with the latest PUK.
pukKeyring, err := mctx.G().GetPerUserKeyring(mctx.Ctx())
if err != nil {
return metadata, err
}
if err := pukKeyring.Sync(mctx); err != nil {
return metadata, err
}
if !pukKeyring.HasAnyKeys() {
return metadata, fmt.Errorf("A PUK is needed to generate ephemeral keys. Aborting.")
}
pukSigning, err := pukKeyring.GetLatestSigningKey(mctx)
if err != nil {
return metadata, err
}
sig, boxes, newMetadata, myBox, err := prepareNewUserEK(mctx, merkleRoot, pukSigning)
if err != nil {
return metadata, err
}
if err = postNewUserEK(mctx, sig, boxes); err != nil {
return metadata, err
}
// Cache the new box after we see the post succeeded.
if myBox == nil {
mctx.Debug("No box made for own deviceEK")
} else {
storage := mctx.G().GetUserEKBoxStorage()
err = storage.Put(mctx, newMetadata.Generation, *myBox)
}
return newMetadata, err
} | [
"func",
"publishNewUserEK",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"merkleRoot",
"libkb",
".",
"MerkleRoot",
")",
"(",
"metadata",
"keybase1",
".",
"UserEkMetadata",
",",
"err",
"error",
")",
"{",
"defer",
"mctx",
".",
"TraceTimed",
"(",
"\"",
"\"",
... | // Create a new userEK and upload it. Add our box to the local box store. | [
"Create",
"a",
"new",
"userEK",
"and",
"upload",
"it",
".",
"Add",
"our",
"box",
"to",
"the",
"local",
"box",
"store",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/ephemeral/user_ek.go#L120-L157 |
158,478 | keybase/client | go/ephemeral/user_ek.go | fetchUserEKStatements | func fetchUserEKStatements(mctx libkb.MetaContext, uids []keybase1.UID) (
statements map[keybase1.UID]*keybase1.UserEkStatement, err error) {
defer mctx.TraceTimed(fmt.Sprintf("fetchUserEKStatements: numUids: %v", len(uids)), func() error { return err })()
apiArg := libkb.APIArg{
Endpoint: "user/get_user_ek_batch",
SessionType: libkb.APISessionTypeREQUIRED,
Args: libkb.HTTPArgs{
"uids": libkb.S{Val: libkb.UidsToString(uids)},
},
}
res, err := mctx.G().GetAPI().Post(mctx, apiArg)
if err != nil {
return nil, err
}
parsedResponse := userEKStatementResponse{}
err = res.Body.UnmarshalAgain(&parsedResponse)
if err != nil {
return nil, err
}
statements = make(map[keybase1.UID]*keybase1.UserEkStatement)
for uid, sig := range parsedResponse.Sigs {
statement, _, wrongKID, err := verifySigWithLatestPUK(mctx, uid, *sig)
// 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("It looks like you revoked a device without generating new ephemeral keys. Are you running an old version?")
// Don't include this statement since it is invalid.
continue
} else if err != nil {
return nil, err
}
statements[uid] = statement
}
return statements, nil
} | go | func fetchUserEKStatements(mctx libkb.MetaContext, uids []keybase1.UID) (
statements map[keybase1.UID]*keybase1.UserEkStatement, err error) {
defer mctx.TraceTimed(fmt.Sprintf("fetchUserEKStatements: numUids: %v", len(uids)), func() error { return err })()
apiArg := libkb.APIArg{
Endpoint: "user/get_user_ek_batch",
SessionType: libkb.APISessionTypeREQUIRED,
Args: libkb.HTTPArgs{
"uids": libkb.S{Val: libkb.UidsToString(uids)},
},
}
res, err := mctx.G().GetAPI().Post(mctx, apiArg)
if err != nil {
return nil, err
}
parsedResponse := userEKStatementResponse{}
err = res.Body.UnmarshalAgain(&parsedResponse)
if err != nil {
return nil, err
}
statements = make(map[keybase1.UID]*keybase1.UserEkStatement)
for uid, sig := range parsedResponse.Sigs {
statement, _, wrongKID, err := verifySigWithLatestPUK(mctx, uid, *sig)
// 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("It looks like you revoked a device without generating new ephemeral keys. Are you running an old version?")
// Don't include this statement since it is invalid.
continue
} else if err != nil {
return nil, err
}
statements[uid] = statement
}
return statements, nil
} | [
"func",
"fetchUserEKStatements",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"uids",
"[",
"]",
"keybase1",
".",
"UID",
")",
"(",
"statements",
"map",
"[",
"keybase1",
".",
"UID",
"]",
"*",
"keybase1",
".",
"UserEkStatement",
",",
"err",
"error",
")",
... | // 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. | [
"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",... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/ephemeral/user_ek.go#L212-L251 |
158,479 | keybase/client | go/ephemeral/user_ek.go | fetchUserEKStatement | func fetchUserEKStatement(mctx libkb.MetaContext, uid keybase1.UID) (
statement *keybase1.UserEkStatement, latestGeneration keybase1.EkGeneration, wrongKID bool, err error) {
defer mctx.TraceTimed("fetchUserEKStatement", func() error { return err })()
apiArg := libkb.APIArg{
Endpoint: "user/user_ek",
SessionType: libkb.APISessionTypeREQUIRED,
Args: libkb.HTTPArgs{
"uids": libkb.S{Val: libkb.UidsToString([]keybase1.UID{uid})},
},
}
res, err := mctx.G().GetAPI().Get(mctx, apiArg)
if err != nil {
return nil, latestGeneration, false, err
}
parsedResponse := userEKStatementResponse{}
err = res.Body.UnmarshalAgain(&parsedResponse)
if err != nil {
return nil, latestGeneration, false, err
}
// User has no statements
if len(parsedResponse.Sigs) == 0 {
return nil, latestGeneration, false, nil
}
if len(parsedResponse.Sigs) != 1 {
return nil, latestGeneration, false, fmt.Errorf("Invalid server response, multiple userEK statements returned")
}
sig, ok := parsedResponse.Sigs[uid]
if !ok {
return nil, latestGeneration, false, fmt.Errorf("Invalid server response, wrong uid returned")
}
statement, latestGeneration, wrongKID, err = verifySigWithLatestPUK(mctx, uid, *sig)
// 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("It looks like you revoked a device without generating new ephemeral keys. Are you running an old version?")
return nil, latestGeneration, true, nil
} else if err != nil {
return nil, latestGeneration, false, err
}
return statement, latestGeneration, false, nil
} | go | func fetchUserEKStatement(mctx libkb.MetaContext, uid keybase1.UID) (
statement *keybase1.UserEkStatement, latestGeneration keybase1.EkGeneration, wrongKID bool, err error) {
defer mctx.TraceTimed("fetchUserEKStatement", func() error { return err })()
apiArg := libkb.APIArg{
Endpoint: "user/user_ek",
SessionType: libkb.APISessionTypeREQUIRED,
Args: libkb.HTTPArgs{
"uids": libkb.S{Val: libkb.UidsToString([]keybase1.UID{uid})},
},
}
res, err := mctx.G().GetAPI().Get(mctx, apiArg)
if err != nil {
return nil, latestGeneration, false, err
}
parsedResponse := userEKStatementResponse{}
err = res.Body.UnmarshalAgain(&parsedResponse)
if err != nil {
return nil, latestGeneration, false, err
}
// User has no statements
if len(parsedResponse.Sigs) == 0 {
return nil, latestGeneration, false, nil
}
if len(parsedResponse.Sigs) != 1 {
return nil, latestGeneration, false, fmt.Errorf("Invalid server response, multiple userEK statements returned")
}
sig, ok := parsedResponse.Sigs[uid]
if !ok {
return nil, latestGeneration, false, fmt.Errorf("Invalid server response, wrong uid returned")
}
statement, latestGeneration, wrongKID, err = verifySigWithLatestPUK(mctx, uid, *sig)
// 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("It looks like you revoked a device without generating new ephemeral keys. Are you running an old version?")
return nil, latestGeneration, true, nil
} else if err != nil {
return nil, latestGeneration, false, err
}
return statement, latestGeneration, false, nil
} | [
"func",
"fetchUserEKStatement",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"uid",
"keybase1",
".",
"UID",
")",
"(",
"statement",
"*",
"keybase1",
".",
"UserEkStatement",
",",
"latestGeneration",
"keybase1",
".",
"EkGeneration",
",",
"wrongKID",
"bool",
",",
... | // 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. | [
"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",... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/ephemeral/user_ek.go#L258-L303 |
158,480 | keybase/client | go/kbfs/kbfsmd/key_bundle_v2.go | GetEphemeralPublicKeyInfoV2 | func GetEphemeralPublicKeyInfoV2(info TLFCryptKeyInfo,
wkb TLFWriterKeyBundleV2, rkb TLFReaderKeyBundleV2) (
keyLocation EPubKeyLocationV2, index int,
ePubKey kbfscrypto.TLFEphemeralPublicKey, err error) {
var publicKeys kbfscrypto.TLFEphemeralPublicKeys
if info.EPubKeyIndex >= 0 {
index = info.EPubKeyIndex
publicKeys = wkb.TLFEphemeralPublicKeys
keyLocation = WriterEPubKeys
} else {
index = -1 - info.EPubKeyIndex
publicKeys = rkb.TLFReaderEphemeralPublicKeys
keyLocation = ReaderEPubKeys
}
keyCount := len(publicKeys)
if index >= keyCount {
return EPubKeyLocationV2(0),
0, kbfscrypto.TLFEphemeralPublicKey{},
fmt.Errorf("Invalid key in %s with index %d >= %d",
keyLocation, index, keyCount)
}
return keyLocation, index, publicKeys[index], nil
} | go | func GetEphemeralPublicKeyInfoV2(info TLFCryptKeyInfo,
wkb TLFWriterKeyBundleV2, rkb TLFReaderKeyBundleV2) (
keyLocation EPubKeyLocationV2, index int,
ePubKey kbfscrypto.TLFEphemeralPublicKey, err error) {
var publicKeys kbfscrypto.TLFEphemeralPublicKeys
if info.EPubKeyIndex >= 0 {
index = info.EPubKeyIndex
publicKeys = wkb.TLFEphemeralPublicKeys
keyLocation = WriterEPubKeys
} else {
index = -1 - info.EPubKeyIndex
publicKeys = rkb.TLFReaderEphemeralPublicKeys
keyLocation = ReaderEPubKeys
}
keyCount := len(publicKeys)
if index >= keyCount {
return EPubKeyLocationV2(0),
0, kbfscrypto.TLFEphemeralPublicKey{},
fmt.Errorf("Invalid key in %s with index %d >= %d",
keyLocation, index, keyCount)
}
return keyLocation, index, publicKeys[index], nil
} | [
"func",
"GetEphemeralPublicKeyInfoV2",
"(",
"info",
"TLFCryptKeyInfo",
",",
"wkb",
"TLFWriterKeyBundleV2",
",",
"rkb",
"TLFReaderKeyBundleV2",
")",
"(",
"keyLocation",
"EPubKeyLocationV2",
",",
"index",
"int",
",",
"ePubKey",
"kbfscrypto",
".",
"TLFEphemeralPublicKey",
... | // GetEphemeralPublicKeyInfoV2 encapsulates all the ugly logic needed to
// deal with the "negative hack" from
// RootMetadataV2.UpdateKeyGeneration. | [
"GetEphemeralPublicKeyInfoV2",
"encapsulates",
"all",
"the",
"ugly",
"logic",
"needed",
"to",
"deal",
"with",
"the",
"negative",
"hack",
"from",
"RootMetadataV2",
".",
"UpdateKeyGeneration",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/key_bundle_v2.go#L49-L72 |
158,481 | keybase/client | go/kbfs/kbfsmd/key_bundle_v2.go | IsWriter | func (wkb TLFWriterKeyBundleV2) IsWriter(user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey) bool {
_, ok := wkb.WKeys[user][deviceKey.KID()]
return ok
} | go | func (wkb TLFWriterKeyBundleV2) IsWriter(user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey) bool {
_, ok := wkb.WKeys[user][deviceKey.KID()]
return ok
} | [
"func",
"(",
"wkb",
"TLFWriterKeyBundleV2",
")",
"IsWriter",
"(",
"user",
"keybase1",
".",
"UID",
",",
"deviceKey",
"kbfscrypto",
".",
"CryptPublicKey",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"wkb",
".",
"WKeys",
"[",
"user",
"]",
"[",
"deviceKey",
".",... | // IsWriter returns true if the given user device is in the writer set. | [
"IsWriter",
"returns",
"true",
"if",
"the",
"given",
"user",
"device",
"is",
"in",
"the",
"writer",
"set",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/key_bundle_v2.go#L221-L224 |
158,482 | keybase/client | go/kbfs/kbfsmd/key_bundle_v2.go | IsWriter | func (wkg TLFWriterKeyGenerationsV2) IsWriter(user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey) bool {
keyGen := wkg.LatestKeyGeneration()
if keyGen < 1 {
return false
}
return wkg[keyGen-1].IsWriter(user, deviceKey)
} | go | func (wkg TLFWriterKeyGenerationsV2) IsWriter(user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey) bool {
keyGen := wkg.LatestKeyGeneration()
if keyGen < 1 {
return false
}
return wkg[keyGen-1].IsWriter(user, deviceKey)
} | [
"func",
"(",
"wkg",
"TLFWriterKeyGenerationsV2",
")",
"IsWriter",
"(",
"user",
"keybase1",
".",
"UID",
",",
"deviceKey",
"kbfscrypto",
".",
"CryptPublicKey",
")",
"bool",
"{",
"keyGen",
":=",
"wkg",
".",
"LatestKeyGeneration",
"(",
")",
"\n",
"if",
"keyGen",
... | // IsWriter returns whether or not the user+device is an authorized writer
// for the latest generation. | [
"IsWriter",
"returns",
"whether",
"or",
"not",
"the",
"user",
"+",
"device",
"is",
"an",
"authorized",
"writer",
"for",
"the",
"latest",
"generation",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/key_bundle_v2.go#L237-L243 |
158,483 | keybase/client | go/kbfs/kbfsmd/key_bundle_v2.go | ToTLFWriterKeyBundleV3 | func (wkg TLFWriterKeyGenerationsV2) ToTLFWriterKeyBundleV3(
codec kbfscodec.Codec,
tlfCryptKeyGetter func() ([]kbfscrypto.TLFCryptKey, error)) (
TLFWriterKeyBundleV2, TLFWriterKeyBundleV3, error) {
keyGen := wkg.LatestKeyGeneration()
if keyGen < FirstValidKeyGen {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{},
errors.New("No key generations to convert")
}
// Copy the latest UserDeviceKeyInfoMap.
wkbV2 := wkg[keyGen-FirstValidKeyGen]
ePubKeyCount := len(wkbV2.TLFEphemeralPublicKeys)
udkimV3, err := writerUDKIMV2ToV3(codec, wkbV2.WKeys, ePubKeyCount)
if err != nil {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{}, err
}
wkbV3 := TLFWriterKeyBundleV3{
Keys: udkimV3,
TLFEphemeralPublicKeys: make(
kbfscrypto.TLFEphemeralPublicKeys, ePubKeyCount),
TLFPublicKey: wkbV2.TLFPublicKey,
}
// Copy all of the TLFEphemeralPublicKeys at this generation.
copy(wkbV3.TLFEphemeralPublicKeys[:], wkbV2.TLFEphemeralPublicKeys)
if keyGen > FirstValidKeyGen {
// Fetch all of the TLFCryptKeys.
keys, err := tlfCryptKeyGetter()
if err != nil {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{}, err
}
// Sanity check.
if len(keys) != int(keyGen) {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{},
fmt.Errorf("expected %d keys, found %d", keyGen, len(keys))
}
// Save the current key.
currKey := keys[len(keys)-1]
// Get rid of the most current generation as that's in the UserDeviceKeyInfoMap already.
keys = keys[:len(keys)-1]
// Encrypt the historic keys with the current key.
wkbV3.EncryptedHistoricTLFCryptKeys, err = kbfscrypto.EncryptTLFCryptKeys(codec, keys, currKey)
if err != nil {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{}, err
}
}
return wkbV2, wkbV3, nil
} | go | func (wkg TLFWriterKeyGenerationsV2) ToTLFWriterKeyBundleV3(
codec kbfscodec.Codec,
tlfCryptKeyGetter func() ([]kbfscrypto.TLFCryptKey, error)) (
TLFWriterKeyBundleV2, TLFWriterKeyBundleV3, error) {
keyGen := wkg.LatestKeyGeneration()
if keyGen < FirstValidKeyGen {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{},
errors.New("No key generations to convert")
}
// Copy the latest UserDeviceKeyInfoMap.
wkbV2 := wkg[keyGen-FirstValidKeyGen]
ePubKeyCount := len(wkbV2.TLFEphemeralPublicKeys)
udkimV3, err := writerUDKIMV2ToV3(codec, wkbV2.WKeys, ePubKeyCount)
if err != nil {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{}, err
}
wkbV3 := TLFWriterKeyBundleV3{
Keys: udkimV3,
TLFEphemeralPublicKeys: make(
kbfscrypto.TLFEphemeralPublicKeys, ePubKeyCount),
TLFPublicKey: wkbV2.TLFPublicKey,
}
// Copy all of the TLFEphemeralPublicKeys at this generation.
copy(wkbV3.TLFEphemeralPublicKeys[:], wkbV2.TLFEphemeralPublicKeys)
if keyGen > FirstValidKeyGen {
// Fetch all of the TLFCryptKeys.
keys, err := tlfCryptKeyGetter()
if err != nil {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{}, err
}
// Sanity check.
if len(keys) != int(keyGen) {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{},
fmt.Errorf("expected %d keys, found %d", keyGen, len(keys))
}
// Save the current key.
currKey := keys[len(keys)-1]
// Get rid of the most current generation as that's in the UserDeviceKeyInfoMap already.
keys = keys[:len(keys)-1]
// Encrypt the historic keys with the current key.
wkbV3.EncryptedHistoricTLFCryptKeys, err = kbfscrypto.EncryptTLFCryptKeys(codec, keys, currKey)
if err != nil {
return TLFWriterKeyBundleV2{}, TLFWriterKeyBundleV3{}, err
}
}
return wkbV2, wkbV3, nil
} | [
"func",
"(",
"wkg",
"TLFWriterKeyGenerationsV2",
")",
"ToTLFWriterKeyBundleV3",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"tlfCryptKeyGetter",
"func",
"(",
")",
"(",
"[",
"]",
"kbfscrypto",
".",
"TLFCryptKey",
",",
"error",
")",
")",
"(",
"TLFWriterKeyBundle... | // ToTLFWriterKeyBundleV3 converts a TLFWriterKeyGenerationsV2 to a TLFWriterKeyBundleV3. | [
"ToTLFWriterKeyBundleV3",
"converts",
"a",
"TLFWriterKeyGenerationsV2",
"to",
"a",
"TLFWriterKeyBundleV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/key_bundle_v2.go#L246-L295 |
158,484 | keybase/client | go/kbfs/kbfsmd/key_bundle_v2.go | IsReader | func (rkg TLFReaderKeyGenerationsV2) IsReader(user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey) bool {
keyGen := rkg.LatestKeyGeneration()
if keyGen < 1 {
return false
}
return rkg[keyGen-1].IsReader(user, deviceKey)
} | go | func (rkg TLFReaderKeyGenerationsV2) IsReader(user keybase1.UID, deviceKey kbfscrypto.CryptPublicKey) bool {
keyGen := rkg.LatestKeyGeneration()
if keyGen < 1 {
return false
}
return rkg[keyGen-1].IsReader(user, deviceKey)
} | [
"func",
"(",
"rkg",
"TLFReaderKeyGenerationsV2",
")",
"IsReader",
"(",
"user",
"keybase1",
".",
"UID",
",",
"deviceKey",
"kbfscrypto",
".",
"CryptPublicKey",
")",
"bool",
"{",
"keyGen",
":=",
"rkg",
".",
"LatestKeyGeneration",
"(",
")",
"\n",
"if",
"keyGen",
... | // IsReader returns whether or not the user+device is an authorized reader
// for the latest generation. | [
"IsReader",
"returns",
"whether",
"or",
"not",
"the",
"user",
"+",
"device",
"is",
"an",
"authorized",
"reader",
"for",
"the",
"latest",
"generation",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/key_bundle_v2.go#L331-L337 |
158,485 | keybase/client | go/kbfs/kbfsmd/key_bundle_v2.go | ToTLFReaderKeyBundleV3 | func (rkg TLFReaderKeyGenerationsV2) ToTLFReaderKeyBundleV3(
codec kbfscodec.Codec, wkb TLFWriterKeyBundleV2) (
TLFReaderKeyBundleV3, error) {
keyGen := rkg.LatestKeyGeneration()
if keyGen < FirstValidKeyGen {
return TLFReaderKeyBundleV3{}, errors.New("No key generations to convert")
}
rkbV3 := TLFReaderKeyBundleV3{
Keys: make(UserDeviceKeyInfoMapV3),
}
// Copy the latest UserDeviceKeyInfoMap.
rkb := rkg[keyGen-FirstValidKeyGen]
// Copy all of the TLFReaderEphemeralPublicKeys.
rkbV3.TLFEphemeralPublicKeys = make(kbfscrypto.TLFEphemeralPublicKeys,
len(rkb.TLFReaderEphemeralPublicKeys))
copy(rkbV3.TLFEphemeralPublicKeys[:], rkb.TLFReaderEphemeralPublicKeys)
// Track a mapping of old writer ephemeral pubkey index to new
// reader ephemeral pubkey index.
pubKeyIndicesMap := make(map[int]int)
// 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)
for kid, info := range dkim {
var infoCopy TLFCryptKeyInfo
err := kbfscodec.Update(codec, &infoCopy, info)
if err != nil {
return TLFReaderKeyBundleV3{}, err
}
keyLocation, index, ePubKey, err :=
GetEphemeralPublicKeyInfoV2(info, wkb, rkb)
if err != nil {
return TLFReaderKeyBundleV3{}, err
}
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]
if !ok {
rkbV3.TLFEphemeralPublicKeys =
append(rkbV3.TLFEphemeralPublicKeys, ePubKey)
// TODO: This index depends on
// map iteration order, which
// varies. Impose a consistent
// order on these indices.
newIndex = len(rkbV3.TLFEphemeralPublicKeys) - 1
pubKeyIndicesMap[index] = newIndex
}
infoCopy.EPubKeyIndex = newIndex
case ReaderEPubKeys:
// Use the real index in the reader list.
infoCopy.EPubKeyIndex = index
default:
return TLFReaderKeyBundleV3{}, fmt.Errorf("Unknown key location %s", keyLocation)
}
dkimV3[kbfscrypto.MakeCryptPublicKey(kid)] = infoCopy
}
rkbV3.Keys[uid] = dkimV3
}
return rkbV3, nil
} | go | func (rkg TLFReaderKeyGenerationsV2) ToTLFReaderKeyBundleV3(
codec kbfscodec.Codec, wkb TLFWriterKeyBundleV2) (
TLFReaderKeyBundleV3, error) {
keyGen := rkg.LatestKeyGeneration()
if keyGen < FirstValidKeyGen {
return TLFReaderKeyBundleV3{}, errors.New("No key generations to convert")
}
rkbV3 := TLFReaderKeyBundleV3{
Keys: make(UserDeviceKeyInfoMapV3),
}
// Copy the latest UserDeviceKeyInfoMap.
rkb := rkg[keyGen-FirstValidKeyGen]
// Copy all of the TLFReaderEphemeralPublicKeys.
rkbV3.TLFEphemeralPublicKeys = make(kbfscrypto.TLFEphemeralPublicKeys,
len(rkb.TLFReaderEphemeralPublicKeys))
copy(rkbV3.TLFEphemeralPublicKeys[:], rkb.TLFReaderEphemeralPublicKeys)
// Track a mapping of old writer ephemeral pubkey index to new
// reader ephemeral pubkey index.
pubKeyIndicesMap := make(map[int]int)
// 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)
for kid, info := range dkim {
var infoCopy TLFCryptKeyInfo
err := kbfscodec.Update(codec, &infoCopy, info)
if err != nil {
return TLFReaderKeyBundleV3{}, err
}
keyLocation, index, ePubKey, err :=
GetEphemeralPublicKeyInfoV2(info, wkb, rkb)
if err != nil {
return TLFReaderKeyBundleV3{}, err
}
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]
if !ok {
rkbV3.TLFEphemeralPublicKeys =
append(rkbV3.TLFEphemeralPublicKeys, ePubKey)
// TODO: This index depends on
// map iteration order, which
// varies. Impose a consistent
// order on these indices.
newIndex = len(rkbV3.TLFEphemeralPublicKeys) - 1
pubKeyIndicesMap[index] = newIndex
}
infoCopy.EPubKeyIndex = newIndex
case ReaderEPubKeys:
// Use the real index in the reader list.
infoCopy.EPubKeyIndex = index
default:
return TLFReaderKeyBundleV3{}, fmt.Errorf("Unknown key location %s", keyLocation)
}
dkimV3[kbfscrypto.MakeCryptPublicKey(kid)] = infoCopy
}
rkbV3.Keys[uid] = dkimV3
}
return rkbV3, nil
} | [
"func",
"(",
"rkg",
"TLFReaderKeyGenerationsV2",
")",
"ToTLFReaderKeyBundleV3",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"wkb",
"TLFWriterKeyBundleV2",
")",
"(",
"TLFReaderKeyBundleV3",
",",
"error",
")",
"{",
"keyGen",
":=",
"rkg",
".",
"LatestKeyGeneration",
... | // ToTLFReaderKeyBundleV3 converts a TLFReaderKeyGenerationsV2 to a TLFReaderkeyBundleV3. | [
"ToTLFReaderKeyBundleV3",
"converts",
"a",
"TLFReaderKeyGenerationsV2",
"to",
"a",
"TLFReaderkeyBundleV3",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfsmd/key_bundle_v2.go#L340-L410 |
158,486 | keybase/client | go/engine/paperkey.go | NewPaperKey | func NewPaperKey(g *libkb.GlobalContext) *PaperKey {
return &PaperKey{
Contextified: libkb.NewContextified(g),
}
} | go | func NewPaperKey(g *libkb.GlobalContext) *PaperKey {
return &PaperKey{
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewPaperKey",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"*",
"PaperKey",
"{",
"return",
"&",
"PaperKey",
"{",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"}",
"\n",
"}"
] | // NewPaperKey creates a PaperKey engine. | [
"NewPaperKey",
"creates",
"a",
"PaperKey",
"engine",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/paperkey.go#L28-L32 |
158,487 | keybase/client | go/teams/keys.go | GetAndVerifyPerTeamKey | func GetAndVerifyPerTeamKey(mctx libkb.MetaContext, teamData *keybase1.TeamData,
gen keybase1.PerTeamKeyGeneration) (ret keybase1.PerTeamKeySeedItem, err error) {
ret, ok := teamData.PerTeamKeySeedsUnverified[gen]
if !ok {
return ret, libkb.NotFoundError{
Msg: fmt.Sprintf("no team secret found at generation %v", gen)}
}
km, err := NewTeamKeyManagerWithSecret(ret.Seed, gen)
if err != nil {
return ret, err
}
chainKey, err := TeamSigChainState{inner: teamData.Chain}.GetPerTeamKeyAtGeneration(gen)
if err != nil {
return ret, err
}
// Takes roughly 280us on android (Honor 6X)
localSigKey, err := km.SigningKey()
if err != nil {
return ret, err
}
// Takes roughly 900us on android (Honor 6X)
localEncKey, err := km.EncryptionKey()
if err != nil {
return ret, err
}
if !chainKey.SigKID.SecureEqual(localSigKey.GetKID()) {
mctx.Debug("sig KID gen:%v (local) %v != %v (chain)", gen, localSigKey.GetKID(), chainKey.SigKID)
return ret, fmt.Errorf("wrong team key found at generation %v", gen)
}
if !chainKey.EncKID.SecureEqual(localEncKey.GetKID()) {
mctx.Debug("enc KID gen:%v (local) %v != %v (chain)", gen, localEncKey.GetKID(), chainKey.EncKID)
return ret, fmt.Errorf("wrong team key (enc) found at generation %v", gen)
}
return ret, nil
} | go | func GetAndVerifyPerTeamKey(mctx libkb.MetaContext, teamData *keybase1.TeamData,
gen keybase1.PerTeamKeyGeneration) (ret keybase1.PerTeamKeySeedItem, err error) {
ret, ok := teamData.PerTeamKeySeedsUnverified[gen]
if !ok {
return ret, libkb.NotFoundError{
Msg: fmt.Sprintf("no team secret found at generation %v", gen)}
}
km, err := NewTeamKeyManagerWithSecret(ret.Seed, gen)
if err != nil {
return ret, err
}
chainKey, err := TeamSigChainState{inner: teamData.Chain}.GetPerTeamKeyAtGeneration(gen)
if err != nil {
return ret, err
}
// Takes roughly 280us on android (Honor 6X)
localSigKey, err := km.SigningKey()
if err != nil {
return ret, err
}
// Takes roughly 900us on android (Honor 6X)
localEncKey, err := km.EncryptionKey()
if err != nil {
return ret, err
}
if !chainKey.SigKID.SecureEqual(localSigKey.GetKID()) {
mctx.Debug("sig KID gen:%v (local) %v != %v (chain)", gen, localSigKey.GetKID(), chainKey.SigKID)
return ret, fmt.Errorf("wrong team key found at generation %v", gen)
}
if !chainKey.EncKID.SecureEqual(localEncKey.GetKID()) {
mctx.Debug("enc KID gen:%v (local) %v != %v (chain)", gen, localEncKey.GetKID(), chainKey.EncKID)
return ret, fmt.Errorf("wrong team key (enc) found at generation %v", gen)
}
return ret, nil
} | [
"func",
"GetAndVerifyPerTeamKey",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"teamData",
"*",
"keybase1",
".",
"TeamData",
",",
"gen",
"keybase1",
".",
"PerTeamKeyGeneration",
")",
"(",
"ret",
"keybase1",
".",
"PerTeamKeySeedItem",
",",
"err",
"error",
")",
... | // Get a PTK seed and verify against the sigchain that is the correct key. | [
"Get",
"a",
"PTK",
"seed",
"and",
"verify",
"against",
"the",
"sigchain",
"that",
"is",
"the",
"correct",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/keys.go#L19-L61 |
158,488 | keybase/client | go/teams/keys.go | SigningKey | func (t *TeamKeyManager) SigningKey() (libkb.NaclSigningKeyPair, error) {
if t.signingKey == nil {
key, err := libkb.MakeNaclSigningKeyPairFromSecretBytes(derivedSecret(t.sharedSecret, libkb.TeamEdDSADerivationString))
if err != nil {
return libkb.NaclSigningKeyPair{}, err
}
t.signingKey = &key
}
return *t.signingKey, nil
} | go | func (t *TeamKeyManager) SigningKey() (libkb.NaclSigningKeyPair, error) {
if t.signingKey == nil {
key, err := libkb.MakeNaclSigningKeyPairFromSecretBytes(derivedSecret(t.sharedSecret, libkb.TeamEdDSADerivationString))
if err != nil {
return libkb.NaclSigningKeyPair{}, err
}
t.signingKey = &key
}
return *t.signingKey, nil
} | [
"func",
"(",
"t",
"*",
"TeamKeyManager",
")",
"SigningKey",
"(",
")",
"(",
"libkb",
".",
"NaclSigningKeyPair",
",",
"error",
")",
"{",
"if",
"t",
".",
"signingKey",
"==",
"nil",
"{",
"key",
",",
"err",
":=",
"libkb",
".",
"MakeNaclSigningKeyPairFromSecretB... | // EncryptionKey returns the derived NaclSigningKeyPair from the team's shared secret. | [
"EncryptionKey",
"returns",
"the",
"derived",
"NaclSigningKeyPair",
"from",
"the",
"team",
"s",
"shared",
"secret",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/keys.go#L110-L119 |
158,489 | keybase/client | go/teams/keys.go | EncryptionKey | func (t *TeamKeyManager) EncryptionKey() (libkb.NaclDHKeyPair, error) {
if t.encryptionKey == nil {
key, err := libkb.MakeNaclDHKeyPairFromSecretBytes(derivedSecret(t.sharedSecret, libkb.TeamDHDerivationString))
if err != nil {
return libkb.NaclDHKeyPair{}, err
}
t.encryptionKey = &key
}
return *t.encryptionKey, nil
} | go | func (t *TeamKeyManager) EncryptionKey() (libkb.NaclDHKeyPair, error) {
if t.encryptionKey == nil {
key, err := libkb.MakeNaclDHKeyPairFromSecretBytes(derivedSecret(t.sharedSecret, libkb.TeamDHDerivationString))
if err != nil {
return libkb.NaclDHKeyPair{}, err
}
t.encryptionKey = &key
}
return *t.encryptionKey, nil
} | [
"func",
"(",
"t",
"*",
"TeamKeyManager",
")",
"EncryptionKey",
"(",
")",
"(",
"libkb",
".",
"NaclDHKeyPair",
",",
"error",
")",
"{",
"if",
"t",
".",
"encryptionKey",
"==",
"nil",
"{",
"key",
",",
"err",
":=",
"libkb",
".",
"MakeNaclDHKeyPairFromSecretBytes... | // EncryptionKey returns the derived NaclDHKeyPair from the team's shared secret. | [
"EncryptionKey",
"returns",
"the",
"derived",
"NaclDHKeyPair",
"from",
"the",
"team",
"s",
"shared",
"secret",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/keys.go#L122-L131 |
158,490 | keybase/client | go/teams/keys.go | SharedSecretBoxes | func (t *TeamKeyManager) SharedSecretBoxes(mctx libkb.MetaContext, senderKey libkb.GenericKey, recipients map[keybase1.UserVersion]keybase1.PerUserKey) (boxes *PerTeamSharedSecretBoxes, err error) {
defer mctx.Trace("SharedSecretBoxes", func() error { return err })()
// make the nonce prefix, skipping the zero counter
// (0 used for previous key encryption nonce)
n, err := newNonce24SkipZero()
if err != nil {
return nil, err
}
// make the recipient boxes with the new secret and the nonce prefix
return t.sharedBoxes(t.sharedSecret, t.generation, n, senderKey, recipients)
} | go | func (t *TeamKeyManager) SharedSecretBoxes(mctx libkb.MetaContext, senderKey libkb.GenericKey, recipients map[keybase1.UserVersion]keybase1.PerUserKey) (boxes *PerTeamSharedSecretBoxes, err error) {
defer mctx.Trace("SharedSecretBoxes", func() error { return err })()
// make the nonce prefix, skipping the zero counter
// (0 used for previous key encryption nonce)
n, err := newNonce24SkipZero()
if err != nil {
return nil, err
}
// make the recipient boxes with the new secret and the nonce prefix
return t.sharedBoxes(t.sharedSecret, t.generation, n, senderKey, recipients)
} | [
"func",
"(",
"t",
"*",
"TeamKeyManager",
")",
"SharedSecretBoxes",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"senderKey",
"libkb",
".",
"GenericKey",
",",
"recipients",
"map",
"[",
"keybase1",
".",
"UserVersion",
"]",
"keybase1",
".",
"PerUserKey",
")",
... | // SharedSecretBoxes creates the PerTeamSharedSecretBoxes for recipients with the
// existing team shared secret. | [
"SharedSecretBoxes",
"creates",
"the",
"PerTeamSharedSecretBoxes",
"for",
"recipients",
"with",
"the",
"existing",
"team",
"shared",
"secret",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/keys.go#L135-L147 |
158,491 | keybase/client | go/teams/keys.go | RotateSharedSecretBoxes | 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("RotateSharedSecretBoxes", func() error { return err })()
// make a new secret
nextSecret, err := newSharedSecret()
if err != nil {
return nil, nil, err
}
// derive new key from new secret for PrevKey
key := derivedSecret(nextSecret, libkb.TeamPrevKeySecretBoxDerivationString)
var keyb [32]byte
copy(keyb[:], key)
// encrypt existing secret with derived key and nonce counter 0
nonce, err := newNonce24()
if err != nil {
return nil, nil, err
}
nonceBytes, counter := nonce.Nonce()
if counter != 0 {
// this should never happen, but might as well make sure it is zero
return nil, nil, errors.New("nonce counter not 0 for first use")
}
sealed := secretbox.Seal(nil, t.sharedSecret.ToBytes(), &nonceBytes, &keyb)
// encode encrypted prev key
prevKeyEncoded, err := encodeSealedPrevKey(nonceBytes, sealed)
if err != nil {
return nil, nil, err
}
// make the recipient boxes with the new secret and the incrementing nonce24
t.setNextSharedSecret(mctx, nextSecret)
boxes, err = t.sharedBoxes(t.sharedSecret, t.generation, nonce, senderKey, recipients)
if err != nil {
return nil, nil, err
}
// insert encoded encrypted PrevKey
boxes.PrevKey = &prevKeyEncoded
// need a new PerTeamKey section since the key was rotated
keySection, err = t.perTeamKeySection()
if err != nil {
return nil, nil, err
}
return boxes, keySection, nil
} | go | 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("RotateSharedSecretBoxes", func() error { return err })()
// make a new secret
nextSecret, err := newSharedSecret()
if err != nil {
return nil, nil, err
}
// derive new key from new secret for PrevKey
key := derivedSecret(nextSecret, libkb.TeamPrevKeySecretBoxDerivationString)
var keyb [32]byte
copy(keyb[:], key)
// encrypt existing secret with derived key and nonce counter 0
nonce, err := newNonce24()
if err != nil {
return nil, nil, err
}
nonceBytes, counter := nonce.Nonce()
if counter != 0 {
// this should never happen, but might as well make sure it is zero
return nil, nil, errors.New("nonce counter not 0 for first use")
}
sealed := secretbox.Seal(nil, t.sharedSecret.ToBytes(), &nonceBytes, &keyb)
// encode encrypted prev key
prevKeyEncoded, err := encodeSealedPrevKey(nonceBytes, sealed)
if err != nil {
return nil, nil, err
}
// make the recipient boxes with the new secret and the incrementing nonce24
t.setNextSharedSecret(mctx, nextSecret)
boxes, err = t.sharedBoxes(t.sharedSecret, t.generation, nonce, senderKey, recipients)
if err != nil {
return nil, nil, err
}
// insert encoded encrypted PrevKey
boxes.PrevKey = &prevKeyEncoded
// need a new PerTeamKey section since the key was rotated
keySection, err = t.perTeamKeySection()
if err != nil {
return nil, nil, err
}
return boxes, keySection, nil
} | [
"func",
"(",
"t",
"*",
"TeamKeyManager",
")",
"RotateSharedSecretBoxes",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"senderKey",
"libkb",
".",
"GenericKey",
",",
"recipients",
"map",
"[",
"keybase1",
".",
"UserVersion",
"]",
"keybase1",
".",
"PerUserKey",
... | // RotateSharedSecretBoxes creates a new shared secret for the team and the
// required PerTeamKey section. | [
"RotateSharedSecretBoxes",
"creates",
"a",
"new",
"shared",
"secret",
"for",
"the",
"team",
"and",
"the",
"required",
"PerTeamKey",
"section",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/keys.go#L151-L200 |
158,492 | keybase/client | go/kbfs/libkbfs/dirty_bcache_disk.go | Get | 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 %s doesn't match branch %s", branch, d.branch)
}
info, ok := d.getInfo(ptr)
if !ok {
return nil, data.NoSuchBlockError{ID: ptr.ID}
}
// 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)
if err != nil {
return nil, err
}
block := info.newBlock()
err = assembleBlock(
ctx, d.config.keyGetter(), d.config.Codec(),
d.config.cryptoPure(), d.kmd, info.tmpPtr, block, data, serverHalf)
if err != nil {
return nil, err
}
return block, nil
} | go | 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 %s doesn't match branch %s", branch, d.branch)
}
info, ok := d.getInfo(ptr)
if !ok {
return nil, data.NoSuchBlockError{ID: ptr.ID}
}
// 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)
if err != nil {
return nil, err
}
block := info.newBlock()
err = assembleBlock(
ctx, d.config.keyGetter(), d.config.Codec(),
d.config.cryptoPure(), d.kmd, info.tmpPtr, block, data, serverHalf)
if err != nil {
return nil, err
}
return block, nil
} | [
"func",
"(",
"d",
"*",
"DirtyBlockCacheDisk",
")",
"Get",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"ptr",
"data",
".",
"BlockPointer",
",",
"branch",
"data",
".",
"BranchName",
")",
"(",
"data",
".",
"Block",
",",
"... | // Get implements the DirtyBlockCache interface for
// DirtyBlockCacheDisk. | [
"Get",
"implements",
"the",
"DirtyBlockCache",
"interface",
"for",
"DirtyBlockCacheDisk",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/dirty_bcache_disk.go#L80-L108 |
158,493 | keybase/client | go/kbfs/libkbfs/dirty_bcache_disk.go | Put | 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 %s doesn't match branch %s", branch, d.branch)
}
// 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)
if err != nil {
return err
}
err = d.diskCache.Put(
ctx, tlfID, id, readyBlockData.Buf, readyBlockData.ServerHalf)
if err != nil {
return err
}
directType := data.DirectBlock
if block.IsIndirect() {
directType = data.IndirectBlock
}
_, isDir := block.(*data.DirBlock)
info := dirtyBlockCacheDiskInfo{
tmpPtr: data.BlockPointer{
ID: id,
KeyGen: d.kmd.LatestKeyGeneration(),
DataVer: block.DataVersion(),
DirectType: directType,
},
isDir: isDir,
}
d.saveInfo(ptr, info)
// TODO: have an in-memory LRU cache of limited size to optimize
// frequent block access?
return nil
} | go | 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 %s doesn't match branch %s", branch, d.branch)
}
// 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)
if err != nil {
return err
}
err = d.diskCache.Put(
ctx, tlfID, id, readyBlockData.Buf, readyBlockData.ServerHalf)
if err != nil {
return err
}
directType := data.DirectBlock
if block.IsIndirect() {
directType = data.IndirectBlock
}
_, isDir := block.(*data.DirBlock)
info := dirtyBlockCacheDiskInfo{
tmpPtr: data.BlockPointer{
ID: id,
KeyGen: d.kmd.LatestKeyGeneration(),
DataVer: block.DataVersion(),
DirectType: directType,
},
isDir: isDir,
}
d.saveInfo(ptr, info)
// TODO: have an in-memory LRU cache of limited size to optimize
// frequent block access?
return nil
} | [
"func",
"(",
"d",
"*",
"DirtyBlockCacheDisk",
")",
"Put",
"(",
"ctx",
"context",
".",
"Context",
",",
"tlfID",
"tlf",
".",
"ID",
",",
"ptr",
"data",
".",
"BlockPointer",
",",
"branch",
"data",
".",
"BranchName",
",",
"block",
"data",
".",
"Block",
")",... | // 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. | [
"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",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/dirty_bcache_disk.go#L114-L155 |
158,494 | keybase/client | go/client/cmd_team_delete.go | listSubteamsRecursive | 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,
})
if err != nil {
return res, err
}
// Sort the response alphabetically
sort.Slice(subs, func(i, j int) bool {
return subs[i].Name.String() < subs[j].Name.String()
})
for _, sub := range subs {
res = append(res, sub.Name)
}
return res, err
} | go | 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,
})
if err != nil {
return res, err
}
// Sort the response alphabetically
sort.Slice(subs, func(i, j int) bool {
return subs[i].Name.String() < subs[j].Name.String()
})
for _, sub := range subs {
res = append(res, sub.Name)
}
return res, err
} | [
"func",
"(",
"c",
"*",
"CmdTeamDelete",
")",
"listSubteamsRecursive",
"(",
"cli",
"*",
"keybase1",
".",
"TeamsClient",
")",
"(",
"res",
"[",
"]",
"keybase1",
".",
"TeamName",
",",
"err",
"error",
")",
"{",
"subs",
",",
"err",
":=",
"cli",
".",
"TeamLis... | // List the subteams of c.Team | [
"List",
"the",
"subteams",
"of",
"c",
".",
"Team"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_team_delete.go#L103-L119 |
158,495 | keybase/client | go/service/prove.go | NewProveHandler | func NewProveHandler(xp rpc.Transporter, g *libkb.GlobalContext) *ProveHandler {
return &ProveHandler{
BaseHandler: NewBaseHandler(g, xp),
Contextified: libkb.NewContextified(g),
}
} | go | func NewProveHandler(xp rpc.Transporter, g *libkb.GlobalContext) *ProveHandler {
return &ProveHandler{
BaseHandler: NewBaseHandler(g, xp),
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewProveHandler",
"(",
"xp",
"rpc",
".",
"Transporter",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"*",
"ProveHandler",
"{",
"return",
"&",
"ProveHandler",
"{",
"BaseHandler",
":",
"NewBaseHandler",
"(",
"g",
",",
"xp",
")",
",",
"Contexti... | // NewProveHandler makes a new ProveHandler object from an RPC transport. | [
"NewProveHandler",
"makes",
"a",
"new",
"ProveHandler",
"object",
"from",
"an",
"RPC",
"transport",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/service/prove.go#L29-L34 |
158,496 | keybase/client | go/service/prove.go | StartProof | func (ph *ProveHandler) StartProof(ctx context.Context, arg keybase1.StartProofArg) (res keybase1.StartProofResult, err error) {
ctx = libkb.WithLogTag(ctx, "PV")
defer ph.G().CTraceTimed(ctx, fmt.Sprintf("StartProof: Service: %v, Username: %v", arg.Service, arg.Username), func() error { return err })()
eng := engine.NewProve(ph.G(), &arg)
uis := libkb.UIs{
ProveUI: ph.getProveUI(arg.SessionID),
SecretUI: ph.getSecretUI(arg.SessionID, ph.G()),
LogUI: ph.getLogUI(arg.SessionID),
SessionID: arg.SessionID,
}
m := libkb.NewMetaContext(ctx, ph.G()).WithUIs(uis)
if err = engine.RunEngine2(m, eng); err != nil {
return res, err
}
res.SigID = eng.SigID()
return res, err
} | go | func (ph *ProveHandler) StartProof(ctx context.Context, arg keybase1.StartProofArg) (res keybase1.StartProofResult, err error) {
ctx = libkb.WithLogTag(ctx, "PV")
defer ph.G().CTraceTimed(ctx, fmt.Sprintf("StartProof: Service: %v, Username: %v", arg.Service, arg.Username), func() error { return err })()
eng := engine.NewProve(ph.G(), &arg)
uis := libkb.UIs{
ProveUI: ph.getProveUI(arg.SessionID),
SecretUI: ph.getSecretUI(arg.SessionID, ph.G()),
LogUI: ph.getLogUI(arg.SessionID),
SessionID: arg.SessionID,
}
m := libkb.NewMetaContext(ctx, ph.G()).WithUIs(uis)
if err = engine.RunEngine2(m, eng); err != nil {
return res, err
}
res.SigID = eng.SigID()
return res, err
} | [
"func",
"(",
"ph",
"*",
"ProveHandler",
")",
"StartProof",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"keybase1",
".",
"StartProofArg",
")",
"(",
"res",
"keybase1",
".",
"StartProofResult",
",",
"err",
"error",
")",
"{",
"ctx",
"=",
"libkb",
".",... | // Prove handles the `keybase.1.startProof` RPC. | [
"Prove",
"handles",
"the",
"keybase",
".",
"1",
".",
"startProof",
"RPC",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/service/prove.go#L77-L93 |
158,497 | keybase/client | go/service/prove.go | CheckProof | func (ph *ProveHandler) CheckProof(ctx context.Context, arg keybase1.CheckProofArg) (res keybase1.CheckProofStatus, err error) {
ctx = libkb.WithLogTag(ctx, "PV")
defer ph.G().CTraceTimed(ctx, fmt.Sprintf("CheckProof: SigID: %v", arg.SigID), func() error { return err })()
eng := engine.NewProveCheck(ph.G(), arg.SigID)
m := libkb.NewMetaContext(ctx, ph.G())
if err = engine.RunEngine2(m, eng); err != nil {
return res, err
}
found, status, state, text := eng.Results()
return keybase1.CheckProofStatus{
Found: found,
Status: status,
State: state,
ProofText: text,
}, nil
} | go | func (ph *ProveHandler) CheckProof(ctx context.Context, arg keybase1.CheckProofArg) (res keybase1.CheckProofStatus, err error) {
ctx = libkb.WithLogTag(ctx, "PV")
defer ph.G().CTraceTimed(ctx, fmt.Sprintf("CheckProof: SigID: %v", arg.SigID), func() error { return err })()
eng := engine.NewProveCheck(ph.G(), arg.SigID)
m := libkb.NewMetaContext(ctx, ph.G())
if err = engine.RunEngine2(m, eng); err != nil {
return res, err
}
found, status, state, text := eng.Results()
return keybase1.CheckProofStatus{
Found: found,
Status: status,
State: state,
ProofText: text,
}, nil
} | [
"func",
"(",
"ph",
"*",
"ProveHandler",
")",
"CheckProof",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"keybase1",
".",
"CheckProofArg",
")",
"(",
"res",
"keybase1",
".",
"CheckProofStatus",
",",
"err",
"error",
")",
"{",
"ctx",
"=",
"libkb",
".",... | // Prove handles the `keybase.1.checkProof` RPC. | [
"Prove",
"handles",
"the",
"keybase",
".",
"1",
".",
"checkProof",
"RPC",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/service/prove.go#L106-L121 |
158,498 | keybase/client | go/service/prove.go | ListProofServices | func (ph *ProveHandler) ListProofServices(ctx context.Context) (res []string, err error) {
ctx = libkb.WithLogTag(ctx, "PV")
defer ph.G().CTraceTimed(ctx, fmt.Sprintf("ListProofServices"), func() error { return err })()
mctx := libkb.NewMetaContext(ctx, ph.G())
return ph.G().GetProofServices().ListServicesThatAcceptNewProofs(mctx), nil
} | go | func (ph *ProveHandler) ListProofServices(ctx context.Context) (res []string, err error) {
ctx = libkb.WithLogTag(ctx, "PV")
defer ph.G().CTraceTimed(ctx, fmt.Sprintf("ListProofServices"), func() error { return err })()
mctx := libkb.NewMetaContext(ctx, ph.G())
return ph.G().GetProofServices().ListServicesThatAcceptNewProofs(mctx), nil
} | [
"func",
"(",
"ph",
"*",
"ProveHandler",
")",
"ListProofServices",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"res",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"ctx",
"=",
"libkb",
".",
"WithLogTag",
"(",
"ctx",
",",
"\"",
"\"",
")",
"... | // Prove handles the `keybase.1.listProofServices` RPC. | [
"Prove",
"handles",
"the",
"keybase",
".",
"1",
".",
"listProofServices",
"RPC",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/service/prove.go#L124-L129 |
158,499 | keybase/client | go/kbfs/libkbfs/conflict_renamer.go | ConflictRename | func (cr WriterDeviceDateConflictRenamer) ConflictRename(
ctx context.Context, op op, original string) (string, error) {
now := cr.config.Clock().Now()
winfo := op.getWriterInfo()
ui, err := cr.config.KeybaseService().LoadUserPlusKeys(
ctx, winfo.uid, "", winfo.offline)
if err != nil {
return "", err
}
deviceName := ui.KIDNames[winfo.key.KID()]
return cr.ConflictRenameHelper(
now, string(ui.Name), deviceName, original), nil
} | go | func (cr WriterDeviceDateConflictRenamer) ConflictRename(
ctx context.Context, op op, original string) (string, error) {
now := cr.config.Clock().Now()
winfo := op.getWriterInfo()
ui, err := cr.config.KeybaseService().LoadUserPlusKeys(
ctx, winfo.uid, "", winfo.offline)
if err != nil {
return "", err
}
deviceName := ui.KIDNames[winfo.key.KID()]
return cr.ConflictRenameHelper(
now, string(ui.Name), deviceName, original), nil
} | [
"func",
"(",
"cr",
"WriterDeviceDateConflictRenamer",
")",
"ConflictRename",
"(",
"ctx",
"context",
".",
"Context",
",",
"op",
"op",
",",
"original",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"now",
":=",
"cr",
".",
"config",
".",
"Clock",
"(... | // ConflictRename implements the ConflictRename interface for
// TimeAndWriterConflictRenamer. | [
"ConflictRename",
"implements",
"the",
"ConflictRename",
"interface",
"for",
"TimeAndWriterConflictRenamer",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/conflict_renamer.go#L25-L37 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.