id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c160200 | if cache.useLimiter() {
cache.config.DiskLimiter().onSimpleByteTrackerDisable(ctx,
cache.cacheType, int64(cache.getCurrBytes()))
}
cache.hitMeter.Shutdown()
cache.missMeter.Shutdown()
cache.putMeter.Shutdown()
cache.updateMeter.Shutdown()
cache.evictCountMeter.Shutdown()
cache.evictSizeMeter.Shutdown()
ca... | |
c160201 | return strings.Split(m[0], " ")[1], true
}
return token, true
}
if IsSeitany(token) {
return token, true
}
return token, false
} | |
c160202 | %d", SeitanEncodedIKeyLength, len(token))
}
if token[seitanEncodedIKeyPlusOffset] != '+' {
return ikey, fmt.Errorf("invalid token format: expected %dth character to be '+'", seitanEncodedIKeyPlusOffset+1)
}
return SeitanIKey(strings.ToLower(token)), nil
} | |
c160203 | if err != nil {
return "", err
}
serializedRKB, err := codec.Encode(extra.GetReaderKeyBundle())
if err != nil {
return "", err
}
s = fmt.Sprintf("WKB size: %d\nRKB size: %d\n",
len(serializedWKB), len(serializedRKB))
}
s += DumpConfig().Sdump(extra)
return s, nil
} | |
c160204 | err := team.chain().GetUserRole(memberUV)
if err != nil {
return res, err
}
if role != expectedRole {
return res, fmt.Errorf("unexpected member role: expected %v but actual role is %v", expectedRole, role)
}
return memberUV, nil
} | |
c160205 | nil {
return ID{}, err
}
return ID{h}, nil
} | |
c160206 | nil {
return ID{}, err
}
return ID{h}, nil
} | |
c160207 |
return id.h.MarshalBinary()
} | |
c160208 | return id.h.UnmarshalBinary(data)
} | |
c160209 | != nil {
return ID{}, err
}
h, err := kbfshash.HashFromRaw(kbfshash.DefaultHashType, dh[:])
if err != nil {
return ID{}, err
}
return ID{h}, nil
} | |
c160210 | encodedEncryptedData, encryptionVer.ToHashType())
if err != nil {
return ID{}, err
}
return ID{h}, nil
} | |
c160211 |
return id.h.Verify(encodedEncryptedData)
} | |
c160212 | kbfshash.HashFromRaw(kbfshash.DefaultHashType, dh[:])
if err != nil {
panic(err)
}
return ID{h}
} | |
c160213 | FakeID(id.h.Bytes()[1] + b)
} | |
c160214 | _, point := range t.inner.UserLog[user] {
if point.SigMeta.SigChainLocation.Seqno > seqno {
return role, nil
}
role = point.Role
}
return role, nil
} | |
c160215 |
if !p.Role.IsOrAbove(role) {
return &p.SigMeta
}
}
return nil
} | |
c160216 | len(points) - 1; i >= 0; i-- {
point := points[i]
if err := point.SigMeta.SigChainLocation.Comparable(scl); err != nil {
return mkErr(err.Error())
}
if point.SigMeta.SigChainLocation.LessThanOrEqualTo(scl) && point.Role.IsOrAbove(role) {
// OK great, we found a point with the role in the log that's less ... | |
c160217 |
if seqno < 0 {
return false
}
return !t.inner.StubbedLinks[seqno]
} | |
c160218 | return
}
t.inner.UserLog[u] = append(t.inner.UserLog[u], keybase1.UserLogPoint{
Role: role,
SigMeta: sigMeta,
})
} | |
c160219 | subteamID,
Name: lastPoint.Name,
Seqno: lastPoint.Seqno,
}
existing, ok := resMap[entry.Name.String()]
replace := !ok || (entry.Seqno >= existing.Seqno)
if replace {
resMap[entry.Name.String()] = entry
}
}
for _, entry := range resMap {
res = append(res, keybase1.TeamIDAndName{
Id: entr... | |
c160220 |
return nil
}
}
if point.Seqno > seqno {
break
}
}
return fmt.Errorf("subteam %v did not have rename entry in log: %v %v",
subteamID, newName, seqno)
} | |
c160221 |
}
// Check that the link has not already been inflated.
if _, ok := state.inner.StubbedLinks[link.Seqno()]; !ok {
return TeamSigChainState{}, NewInflateErrorWithNote(link, "already inflated")
}
t := &teamSigchainPlayer{
Contextified: libkb.NewContextified(g),
reader: reader,
}
iRes, err := t.addIn... | |
c160222 | for use in the audit mechanism.
// For the purposes of testing, we disable this feature, so we can check
// the lazy-repopulation scheme for old stored teams (without a full cache bust).
if link.Seqno() == keybase1.Seqno(1) && !link.isStubbed() && !t.G().Env.Test.TeamNoHeadMerkleStore {
tmp := link.inner.Body.Mer... | |
c160223 | uv := range uvs {
fromRole, err := prev.GetUserRole(uv)
if err != nil {
continue // ignore error, user not in team
}
if toRole == keybase1.TeamRole_NONE && fromRole == keybase1.TeamRole_OWNER && readmittingResetUser(uv) {
continue
}
if fromRole == keybase1.TeamRole_OWNER {
// This is an i... | |
c160224 | roleUpdates {
for _, uv := range uvs {
stateToUpdate.inform(uv, role, sigMeta)
}
}
} | |
c160225 | but expected %v",
subteamName.Depth(), expectedDepth)
}
// The last part of the parent name at parentSeqno.
var parentLastPart keybase1.TeamNamePart
for _, point := range parent.inner.NameLog {
if point.Seqno > parentSeqno {
break
}
parentLastPart = point.LastPart
}
subteamSecondToLastPart := subte... | |
c160226 | &userKeyAPI{log: log, api: api}
} | |
c160227 | than that to avoid thrashing.
//
// To avoid memory pressure, it might be nice to additionally
// consider capping the total size of this cache (e.g., with
// github.com/keybase/cache). However, since the set in use is
// based on the sliding window, it seems like that should be the
// limiting factor. Eventuall... | |
c160228 | Instead use a
// KBFS-specific `HasEncodedObject()` method that just tells us
// whether or not the object exists.
err := ods.Storer.HasEncodedObject(hash)
if err != nil {
return nil, err
}
return o, nil
} | |
c160229 | edos,
hash: hash,
objType: ot,
size: -1,
recentCache: ods.recentCache,
}
// Need to see if this is a delta object, which means reading all
// the data.
_, err := o.cache()
_, notDelta := err.(notDeltaError)
if notDelta {
return ods.EncodedObject(ot, hash)
} else if err != ni... | |
c160230 | == nil {
tmp := time.Now()
s.start = &tmp
}
} | |
c160231 | time.Since(*s.start)
} else {
panic("SimpleTimer Stop()'ed without being started")
}
return s.GetTotal()
} | |
c160232 | r.G().Log.Info("timer: %s [%d ms]", prefix, dur/time.Millisecond)
} | |
c160233 | sel |= TimerXAPI
case 'r':
sel |= TimerRPC
}
}
return &TimerSet{sel: sel, Contextified: Contextified{g}}
} | |
c160234 | tmp.Start()
ret = tmp
} else {
ret = ReportingTimerDummy{}
}
return ret
} | |
c160235 |
SigchainV2TypeTeamDeleteRoot,
SigchainV2TypeTeamDeleteSubteam,
SigchainV2TypeTeamDeleteUpPointer,
SigchainV2TypeTeamKBFSSettings,
SigchainV2TypeTeamSettings:
return true
default:
return false
}
} | |
c160236 | Disallow stubbing of other known links.
// Allow stubbing of unknown link types for forward compatibility.
return !t.IsSupportedTeamType()
}
} | |
c160237 | != nil && *lastState != a.state {
ch <- a.state
} else {
a.updateChs = append(a.updateChs, ch)
}
return ch
} | |
c160238 |
// cancel RPCs if we go into the background
switch a.state {
case keybase1.MobileAppState_BACKGROUND:
a.G().RPCCanceler.CancelLiveContexts(RPCCancelerReasonBackground)
}
} else {
a.G().Log.Debug("MobileAppState.Update: ignoring update: %v, we are currently in state: %v",
state, a.state)
}
} | |
c160239 | defer a.Unlock()
return a.state
} | |
c160240 | {
return &BlockOpsConstrained{
BlockOps: delegate,
bwKBps: bwKBps,
}
} | |
c160241 | "", err
}
return filepath.EvalSymlinks(exePath)
} | |
c160242 | if fi.Mode()&os.ModeSymlink == 0 {
f, err := b.tree.File(filename)
if err != nil {
return nil, err
}
return newBrowserFile(f)
}
filename, err = b.followSymlink(filename)
if err != nil {
return nil, err
}
}
return nil, errors.New("cannot resolve deep symlink chain")
} | |
c160243 | return nil, errors.New("browser can't create files")
}
return b.Open(filename)
} | |
c160244 | b.tree.Size(filename)
switch errors.Cause(err) {
case nil:
// Git doesn't keep track of the mtime of individual files
// anywhere, so just use the timestamp from the commit.
fi = &browserFileInfo{entry, size, b.mtime}
case plumbing.ErrObjectNotFound:
// This is likely a git submodule.
sf := newSubmoduleFi... | |
c160245 | }
filename, err = b.followSymlink(filename)
if err != nil {
return nil, err
}
}
return nil, errors.New("cannot resolve deep symlink chain")
} | |
c160246 | path.Clean(path.Join(elem...))
} | |
c160247 | nil, err
}
}
childrenPathsToCache := make([]string, 0, len(dirTree.Entries))
for _, e := range dirTree.Entries {
fi, err := b.Lstat(path.Join(p, e.Name))
if err != nil {
return nil, err
}
fis = append(fis, fi)
childrenPathsToCache = append(childrenPathsToCache, path.Join(cachePath, e.Name))
}
b.sh... | |
c160248 | symlink, error right away.
if fi.Mode()&os.ModeSymlink == 0 {
return "", errors.New("not a symlink")
}
return b.readLink(link)
} | |
c160249 | err := b.tree.Tree(p)
if err != nil {
return nil, err
}
return &Browser{
tree: newTree,
root: b.Join(b.root, p),
mtime: b.mtime,
commitHash: b.commitHash,
sharedCache: b.sharedCache,
}, nil
} | |
c160250 | return errors.New("browser cannot mkdir")
} | |
c160251 | errors.New("browser cannot make symlinks")
} | |
c160252 |
Contextified: libkb.NewContextified(g),
}
} | |
c160253 | k.CurrentSession(ctx, 0)
if err != nil {
return err
}
return k.favoriteStore.FavoriteDelete(session.UID, folder)
} | |
c160254 |
if err != nil {
return keybase1.FavoritesResult{}, err
}
return keybase1.FavoritesResult{
FavoriteFolders: favs,
IgnoredFolders: []keybase1.Folder{},
NewFolders: []keybase1.Folder{},
}, nil
} | |
c160255 | error) {
return nil, checkContext(ctx)
} | |
c160256 | error) {
return nil, checkContext(ctx)
} | |
c160257 | bool) error {
return checkContext(ctx)
} | |
c160258 | notification *keybase1.FSNotification) error {
return checkContext(ctx)
} | |
c160259 | string) error {
return checkContext(ctx)
} | |
c160260 | *keybase1.FSPathSyncStatus) error {
return checkContext(ctx)
} | |
c160261 | keybase1.FolderSyncStatus) error {
return checkContext(ctx)
} | |
c160262 | metadata keybase1.GitLocalMetadata) error {
return nil
} | |
c160263 | "keybase.1.teams.findNextMerkleRootAfterTeamRemoval", []interface{}{__arg}, &res)
return
} | |
c160264 | err = c.Cli.Call(ctx, "keybase.1.teams.profileTeamLoad", []interface{}{__arg}, &res)
return
} | |
c160265 | c.Cli.Call(ctx, "keybase.1.teams.getTeamID", []interface{}{__arg}, &res)
return
} | |
c160266 | err error) {
err = c.Cli.Call(ctx, "keybase.1.fs.List", []interface{}{__arg}, &res)
return
} | |
c160267 | c.GetSessionChallenge(ctx)
if err != nil {
return err
}
// get a new signature
signature, err := b.authToken.Sign(ctx, session.Name,
session.UID, session.VerifyingKey, challenge)
if err != nil {
return err
}
return c.AuthenticateSession(ctx, signature)
} | |
c160268 | actual network.
bs.putConn = newBlockServerRemoteClientHandler(
"BlockServerRemotePut", log, config.Signer(),
config.CurrentSessionGetter(), blkSrvRemote, rpcLogFactory)
bs.getConn = newBlockServerRemoteClientHandler(
"BlockServerRemoteGet", log, config.Signer(),
config.CurrentSessionGetter(), blkSrvRemote, ... | |
c160269 | dbc := b.config.DiskBlockCache()
if dbc != nil {
// This used to be called in a goroutine to prevent blocking
// the `Get`. But we need this cached synchronously so prefetch
// operations can work correctly.
dbc.Put(ctx, tlfID, id, buf, serverHalf, cacheType)
}
}
}()
arg := kbfsblock.MakeGe... | |
c160270 | {
b.deferLog.CDebugf(
ctx, "GetEncodedSize id=%s tlf=%s context=%s sz=%d status=%s",
id, tlfID, context, size, status)
}
}()
arg := kbfsblock.MakeGetBlockArg(tlfID, id, context)
arg.SizeOnly = true
res, err := b.getConn.getClient().GetBlock(ctx, arg)
if err != nil {
return 0, 0, nil
}
return uin... | |
c160271 | "Put id=%s tlf=%s context=%s sz=%d err=%v",
id, tlfID, bContext, size, err)
} else {
b.deferLog.CDebugf(
ctx, "Put id=%s tlf=%s context=%s sz=%d",
id, tlfID, bContext, size)
}
}()
arg := kbfsblock.MakePutBlockArg(tlfID, id, bContext, buf, serverHalf)
// Handle OverQuota errors at the caller
ret... | |
c160272 |
b.deferLog.CDebugf(
ctx, "AddBlockReference id=%s tlf=%s context=%s",
id, tlfID, context)
}
}()
arg := kbfsblock.MakeAddReferenceArg(tlfID, id, context)
// Handle OverQuota errors at the caller
return b.putConn.getClient().AddReference(ctx, arg)
} | |
c160273 | b.deferLog.CDebugf(ctx, "RemoveBlockReferences batch size=%d", len(contexts))
}
}()
doneRefs, err := kbfsblock.BatchDowngradeReferences(ctx, b.log, tlfID, contexts, false, b.putConn.getClient())
return kbfsblock.GetLiveCounts(doneRefs), err
} | |
c160274 | done (err=%v)", contexts, err)
if err != nil {
b.deferLog.CWarningf(ctx, "ArchiveBlockReferences batch size=%d err=%v", len(contexts), err)
} else {
b.deferLog.CDebugf(ctx, "ArchiveBlockReferences batch size=%d", len(contexts))
}
}()
_, err = kbfsblock.BatchDowngradeReferences(ctx, b.log, tlfID, contexts... | |
c160275 | kbfsblock.GetReferenceCount(
ctx, tlfID, contexts, keybase1.BlockStatus_LIVE, b.getConn.getClient())
} | |
c160276 | (
bool, error) {
return false, nil
} | |
c160277 |
defer func() {
b.log.LazyTrace(ctx, "BServer: GetUserQuotaInfo done (err=%v)", err)
}()
res, err := b.getConn.getClient().GetUserQuotaInfo(ctx)
return kbfsblock.ParseGetQuotaInfoRes(b.config.Codec(), res, err)
} | |
c160278 | }
b.getConn.shutdown()
b.putConn.shutdown()
} | |
c160279 |
return &PGPDecrypt{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | |
c160280 | err != nil {
return ID{}, err
}
h, err := kbfshash.DefaultHash(buf)
if err != nil {
return ID{}, err
}
return ID{h}, nil
} | |
c160281 | ToggleAutostart(context, true, true)
if err != nil {
// Ignore if we couldn't write to autostart
log.Errorf("Autoinstall failed: %s.", err)
}
return false, nil
} | |
c160282 | return kbfsBinPathDefault(runMode, binPath)
} | |
c160283 |
return &PGPEncrypt{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | |
c160284 | return
}
k.keys[kid] = bundle
k.index = append(k.index, kid)
} | |
c160285 | sorted = append(sorted, k.keys[kid])
}
return sorted
} | |
c160286 |
s.valid = false
s.mtime = time.Time{}
s.token = ""
s.csrf = ""
s.checked = false
} | |
c160287 | if r.Len() > 0 {
return NaclSigningKeyPair{}, fmt.Errorf("Did not use %d secret byte(s)", r.Len())
}
return kp, err
} | |
c160288 | r.Len() > 0 {
return NaclDHKeyPair{}, fmt.Errorf("Did not use %d secret byte(s)", r.Len())
}
return kp, err
} | |
c160289 | err error) {
err = KeyCannotEncryptError{}
return
} | |
c160290 |
ctext = box.Seal(ctext, msg, &nonce, ((*[32]byte)(&k.Public)), ((*[32]byte)(sender.Private)))
ret := &NaclEncryptionInfo{
Ciphertext: ctext,
EncryptionType: kbcrypto.KIDNaclDH,
Nonce: nonce[:],
Receiver: k.GetKID().ToBytes(),
Sender: sender.GetKID().ToBytes(),
}
return ret, ni... | |
c160291 |
}
info, err := k.Encrypt(plaintext, senderDh)
if err != nil {
return "", err
}
return kbcrypto.EncodePacketToArmoredString(info)
} | |
c160292 | err = DecodeArmoredNaclEncryptionInfoPacket(ciphertext); err != nil {
return
}
return k.Decrypt(&nei)
} | |
c160293 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.loginUi.displayResetProgress", []interface{}{__arg}, nil)
return
} | |
c160294 |
h.Add("pdpka4", S{string(lp.pdpka4)})
h.Add("pdpka5", S{string(lp.pdpka5)})
} | |
c160295 | (oldDir string, err error) {
return j.j.move(newDir)
} | |
c160296 | kbnmAppName,
}
for _, whitelist := range hostmanifest.KnownInstallers() {
if err := whitelist.Uninstall(u, app); err != nil {
return err
}
}
return nil
} | |
c160297 | "stdio",
}
var manifest hostmanifest.AppManifest
for browser, whitelist := range hostmanifest.KnownInstallers() {
switch browser {
case "chrome", "chromium":
manifest = hostmanifest.ChromeApp{
App: app,
AllowedOrigins: []string{
// Production public version in the store
"chrome-extension... | |
c160298 |
g.SocketWrapper = nil
return g.GetSocket(clearError)
} | |
c160299 | make(chan stellar1.AccountID, 100),
rateGroup: &singleflight.Group{},
options: NewOptions(),
}
g.PushShutdownHook(ws.Shutdown)
go ws.backgroundRefresh()
return ws
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.