id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c161200 | leaf
pubKeyData := pubKey.Data()
privKeyData := ePrivKey.Data()
encryptedData := box.Seal(
nil, leafBytes[:], nonce, &pubKeyData, &privKeyData)
return EncryptedMerkleLeaf{
Version: kbfscrypto.EncryptionSecretbox,
EncryptedData: encryptedData,
}, nil
} | |
c161201 |
return MerkleLeaf{}, err
}
// decode the leaf
var leaf MerkleLeaf
if err := codec.Decode(leafBytes, &leaf); err != nil {
return MerkleLeaf{}, err
}
return leaf, nil
} | |
c161202 |
return nil, err
}
defer tok.Close()
tokUser, err := tok.GetTokenUser()
if err != nil {
return nil, err
}
return (*windows.SID)(tokUser.User.Sid), nil
} | |
c161203 | &userSID, nil, nil, nil, &secDesc)
if err != nil {
return nil, err
}
return userSID, nil
} | |
c161204 | * float64(fetchInitialInterval))
return lastAttempt.Add(time.Duration(wait))
} | |
c161205 |
f.Debug(ctx, "Failure: not starting new retrier, not running")
return nil
}
key := f.key(uid, desc)
if _, ok := f.retriers[key]; !ok {
f.Debug(ctx, "Failure: spawning new retrier: desc: %s", desc)
control := newRetrierControl(desc)
f.retriers[key] = control
f.spawnRetrier(ctx, uid, desc, control)
}
r... | |
c161206 | fmt.Sprintf("Success(%s)", desc))()
key := f.key(uid, desc)
if control, ok := f.retriers[key]; ok {
control.Shutdown()
}
return nil
} | |
c161207 | defer f.Unlock()
f.offline = true
} | |
c161208 |
defer f.Unlock()
return f.offline
} | |
c161209 |
for _, control := range f.retriers {
control.Force()
}
} | |
c161210 | {
return &FavoriteHandler{
BaseHandler: NewBaseHandler(g, xp),
Contextified: libkb.NewContextified(g),
}
} | |
c161211 | h.G()),
}
m := libkb.NewMetaContext(ctx, h.G()).WithUIs(uis)
return engine.RunEngine2(m, eng)
} | |
c161212 | := libkb.NewMetaContext(ctx, h.G())
return engine.RunEngine2(m, eng)
} | |
c161213 | engine.RunEngine2(m, eng); err != nil {
return keybase1.FavoritesResult{}, err
}
return eng.Result(), nil
} | |
c161214 | = config.KBFSOps().FolderStatus(ctx, folderBranch)
if err != nil {
return nil, time.Time{}, err
}
data, err = PrettyJSON(status)
return
} | |
c161215 | {
config.Reporter().ReportErr(ctx, "", tlf.Private, libkbfs.ReadMode, err)
}
data, err = PrettyJSON(status)
return
} | |
c161216 | if err != nil {
f.log.CWarningf(nil,
"Failed to read cached favorites from disk: %v", err)
}
// launch background loop
go f.loop()
} | |
c161217 | newFav := range f.favCache {
if _, present := oldCache[newFav]; !present {
f.config.KBFSOps().RefreshEditHistory(newFav)
}
}
} | |
c161218 |
f.log.CWarningf(context.Background(),
"Could not close disk favorites cache: %v", err)
}
}
return f.wg.Wait(context.Background())
} | |
c161219 | // else's context being canceled.
for doAdd {
req, doSend := f.startOrJoinAddReq(ctx, fav)
if doSend {
return f.sendReq(ctx, req)
}
doAdd, err = f.waitOnReq(ctx, req)
}
return err
} | |
c161220 | f.sendReq(ctx, &favReq{
ctx: ctx,
toDel: []favorites.Folder{fav},
done: make(chan struct{}),
})
} | |
c161221 | make(chan struct{}),
ctx: context.Background(),
}
f.wg.Add(1)
select {
case f.reqChan <- req:
case <-ctx.Done():
f.wg.Done()
return
}
} | |
c161222 |
favChan := make(chan []favorites.Folder, 1)
req := &favReq{
ctx: ctx,
favs: favChan,
done: make(chan struct{}),
}
err := f.sendReq(ctx, req)
if err != nil {
return nil, err
}
return <-favChan, nil
} | |
c161223 | context.Background(),
}
f.wg.Add(1)
select {
case f.reqChan <- req:
case <-ctx.Done():
f.wg.Done()
return
}
} | |
c161224 | TeamID: &f.homeTLFInfo.PrivateTeamID,
},
},
}, nil
}
return keybase1.FavoritesResult{}, nil
}
if f.hasShutdown() {
return keybase1.FavoritesResult{}, data.ShutdownHappenedError{}
}
favChan := make(chan keybase1.FavoritesResult, 1)
req := &favReq{
ctx: ctx,
favsAll: favChan,
done: ... | |
c161225 |
if !reUsernameQuery.MatchString(s) {
return "", errInvalidInput
}
return s, nil
} | |
c161226 | return findKeybaseBinary(keybaseBinary)
},
}
} | |
c161227 | case "query":
return h.handleQuery(req)
}
return nil, errInvalidMethod
} | |
c161228 | "send", "--private", idQuery)
cmd.Env = append(os.Environ(), "KEYBASE_LOG_FORMAT=plain")
cmd.Stdin = strings.NewReader(req.Body)
cmd.Stdout = &out
cmd.Stderr = &out
if err := h.Run(cmd); err != nil {
return parseError(&out, err)
}
return nil
} | |
c161229 | circuit errors
if parts[0] == "[ERRO]" {
lastErrLine = strings.Join(parts[2:], " ")
if lastErrLine == "Not found" {
return nil, errUserNotFound
}
continue
}
if parts[2] != "Identifying" {
continue
}
resp := &resultQuery{
Username: parts[3],
}
return resp, nil
}
if err := scanne... | |
c161230 | " ", 3)
if len(parts) < 3 {
continue
}
if parts[0] != "[ERRO]" {
continue
}
if strings.HasSuffix(parts[2], "No resolution found") {
return errUserNotFound
}
if strings.HasPrefix(parts[2], "Not found") {
return errUserNotFound
}
lastErr = fmt.Errorf(parts[2])
}
if lastErr != nil {
ret... | |
c161231 | cmd := exec.Command(binPath, "id", idQuery)
cmd.Env = append(os.Environ(), "KEYBASE_LOG_FORMAT=plain")
cmd.Stdout = &out
cmd.Stderr = &out
if err := h.Run(cmd); err != nil {
return nil, parseError(&out, err)
}
return parseQuery(&out)
} | |
c161232 | cli.IntFlag{
Name: "rev",
Usage: "a revision number for the KBFS folder of the source paths",
},
cli.StringFlag{
Name: "time",
Usage: "a time for the KBFS folder of the source paths (eg \"2018-07-27 22:05\")",
},
cli.StringFlag{
Name: "reltime, relative-time",
Usage: "a relative... | |
c161233 | the filesystem was mounted ok or it was not mounted
// and an err is not nil. DokanMain does not return errors after the
// mount, but if such errors occured they can be catched by BlockTillDone.
err = <-ec
if err != nil {
return nil, err
}
return &MountHandle{ec, cfg.Path}, nil
} | |
c161234 | return fi.isRequestorUserSidEqualTo(sid)
} | |
c161235 | fsTableGetFileCount(uint32(fi.ptr.DokanOptions.GlobalContext))
} | |
c161236 | (err error) {
err = c.Cli.Call(ctx, "keybase.1.track.trackWithToken", []interface{}{__arg}, nil)
return
} | |
c161237 | = libkbfs.RequestRekeyAndWaitForOneFinishEvent(ctx,
f.folder.fs.config.KBFSOps(), f.folder.getFolderBranch().Tlf)
if err != nil {
return err
}
f.folder.fs.NotificationGroupWait()
resp.Size = len(req.Data)
return nil
} | |
c161238 |
uintptr(0),
uintptr(0),
uintptr(0),
uintptr(0),
0)
if callErr != nil {
return "", callErr
}
return syscall.UTF16ToString(VolumeNameBuffer), nil
} | |
c161239 | err := queryDosDeviceProc.Call(
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(path))),
uintptr(unsafe.Pointer(&VolumeNameBuffer[0])),
uintptr(nVolumeNameSize))
if ret == 0 {
return "", err
}
return syscall.UTF16ToString(VolumeNameBuffer), nil
} | |
c161240 | match != nil {
lx.buffer = lx.buffer[match[3]:]
}
}
} | |
c161241 | {
return writers, readers, fmt.Errorf("too many reader divisions ('#') in assertions: %v", assertions)
}
writers, err = ParseAssertionList(ctx, split[0])
if err != nil {
return writers, readers, err
}
if len(split) >= 2 && len(split[1]) > 0 {
readers, err = ParseAssertionList(ctx, split[1])
if err != ni... | |
c161242 |
if err != nil {
return res, err
}
return unpackAssertionList(expr)
} | |
c161243 | sublist, err := unpackAssertionList(sub)
if err != nil {
return res, err
}
res = append(res, sublist...)
}
return res, nil
default:
// Just one item.
err = checkAssertionListItem(expr)
return []AssertionExpression{expr}, err
}
} | |
c161244 | return fmt.Errorf("assertion parse fault: unexpected OR")
}
// Anything else is allowed.
return nil
} | |
c161245 | histories: make(map[tlfKey]writersByRevision),
log: log,
vlog: vlog,
}
} | |
c161246 | user history for TLF %s, "+
"user %s", tlfName, loggedInUser)
history := tlfHistory.getHistory(loggedInUser)
key := tlfKey{tlfName, tlfType}
uh.lock.Lock()
defer uh.lock.Unlock()
uh.histories[key] = history
} | |
c161247 |
defer uh.lock.RUnlock()
return uh.getTlfHistoryLocked(tlfName, tlfType)
} | |
c161248 | 0 {
serverTime = wh.Edits[0].ServerTime
}
clusters = append(clusters, keybase1.FSFolderEditHistory{
Folder: history.Folder,
ServerTime: serverTime,
History: []keybase1.FSFolderWriterEditHistory{wh},
})
}
}
}
// We need to sort these by the ServerTime of these particular e... | |
c161249 | uh.lock.Unlock()
uh.histories = make(map[tlfKey]writersByRevision)
} | |
c161250 | {
key := tlfKey{tlfName, tlfType}
uh.lock.Lock()
defer uh.lock.Unlock()
delete(uh.histories, key)
} | |
c161251 | }
sigID := u.GetSigIDFromSeqno(leaf.Public.Seqno)
if sigID.IsNil() {
return res, MerkleClientError{fmt.Sprintf("unknown seqno in sigchain: %d", arg.Loc.Seqno), merkleErrorBadSeqno}
}
if !sigID.Equal(leaf.Public.SigID) {
return res, MerkleClientError{fmt.Sprintf("sigID sent down by server didn't match: %s != %s... | |
c161252 | WithUID(uid).WithForcePoll(forcePoll))
if err != nil {
return err
}
if foundLinkID, found := upak.SeqnoLinkIDs[seqno]; found {
if foundLinkID.Eq(linkID.Export()) {
return nil
}
}
}
return fmt.Errorf("sigchain link not found at seqno %v", seqno)
} | |
c161253 | stellar1.PaymentID) {
if p.done {
return
}
p.enqueuePayment(paymentID)
} | |
c161254 | p.done {
return
}
p.enqueueRequest(requestID)
} | |
c161255 |
id, err = libkb.RandString("", 8)
if err != nil {
return id, ch, err
}
p.Lock()
p.listeners[id] = ch
p.Unlock()
return id, ch, nil
} | |
c161256 | delete(p.listeners, id)
p.Unlock()
} | |
c161257 |
}
p.requests[id] = request
p.rlist = append(p.rlist, id)
p.Unlock()
return isUpdate
} | |
c161258 | range v {
ret = append(ret, Feature(strings.TrimSpace(f)))
}
return ret
} | |
c161259 | Feature("admin") {
return true
}
}
return IsKeybaseAdmin(uid)
} | |
c161260 | }
rawFeature, ok := raw.Features[string(f)]
if !ok {
m.Info("Feature %q wasn't returned from server", f)
return false, nil
}
slot.readFrom(m, rawFeature)
m.Debug("Feature (fetched) %q -> %v (will cache for %ds)", f, slot.on, rawFeature.CacheSec)
return slot.on, nil
} | |
c161261 | m.Info("Error checking feature %q: %v", f, err)
return false
}
return on
} | |
c161262 | s.features = make(map[Feature]*featureSlot)
} | |
c161263 | {
return &FeatureFlagGate{
feature: f,
cacheFor: d,
}
} | |
c161264 | }
m.Debug("Server reports feature %q is flagged off", f.feature)
f.Lock()
defer f.Unlock()
f.lastCheck = m.G().Clock().Now()
f.lastError = err
} | |
c161265 |
if diff > f.cacheFor {
m.Debug("Feature flag %q expired %d ago, let's give it another try", f.feature, diff)
f.lastError = nil
f.lastCheck = time.Time{}
}
return f.lastError
} | |
c161266 |
checkInviteDone: make(chan struct{}),
Contextified: libkb.NewContextified(g),
}
} | |
c161267 |
// Start broadcast handler goroutine
go g.broadcastMessageHandler()
// Start the app state monitor thread
go g.monitorAppState()
// Start replay thread
go g.syncReplayThread()
} | |
c161268 | "Cannot push state in firehose handler: %s", err)
return
}
g.Debug(context.Background(), "PushFirehoseHandler: pushing state with %d items", len(s.Items_))
handler.PushState(s, keybase1.PushReason_RECONNECTED)
} | |
c161269 | freshHandlers = append(freshHandlers, h)
}
}
g.firehoseHandlers = freshHandlers
return
} | |
c161270 | len(msgs))
for _, msg := range msgs {
g.Debug(ctx, "replayInBandMessages: replaying: %s", msg.Metadata().MsgID())
// If we have a handler, just run it on that, otherwise run it against
// all of the handlers we know about
if handler == nil {
err = g.handleInBandMessage(ctx, cli, msg)
} else {
_, err =... | |
c161271 | {
t = *pt
}
g.Debug(ctx, "serverSync: starting replay from: %s", t)
} else {
g.Debug(ctx, "serverSync: performing a fresh replay")
}
// Sync down everything from the server
consumedMsgs, err := gcli.Sync(ctx, cli, syncRes)
if err != nil {
g.Debug(ctx, "serverSync: error syncing from the server, reason... | |
c161272 | we can return to Gregor as fast as possible. Note
// that this can block, but broadcastCh has a large buffer to try and mitigate
g.broadcastCh <- m
return nil
} | |
c161273 | {
g.Debug(ctx, "handleInBandMessage() failed to run %s handler: %s", handler.Name(), err)
}
}
freshHandlers = append(freshHandlers, handler)
} else {
g.Debug(ctx, "skipping handler as it's marked dead: %s", handler.Name())
}
}
if len(g.ibmHandlers) != len(freshHandlers) {
g.Debug(ctx, "Chang... | |
c161274 |
category := ""
if item.Category() != nil {
category = item.Category().String()
g.Debug(ctx, "item %s has category %s", id, category)
}
if handled, err := handler.Create(ctx, cli, category, item); err != nil {
return handled, err
}
}
dismissal := update.Dismissal()
if dismissal != nil... | |
c161275 | g.chatAwareReconnectIsLong(ctx) {
return GregorConnectionLongRetryInterval
}
return 0
} | |
c161276 | grutils.FormMessageForDismissItem(ctx, g.currentUID(), id)
if err != nil {
return err
}
gcli, err := g.getGregorCli()
if err != nil {
return err
}
return gcli.ConsumeMessage(ctx, dismissal)
} | |
c161277 | := &KBFSContext{g: g}
c.initKBFSSocket()
return c
} | |
c161278 |
g.ConfigureMerkleClient()
return NewContextFromGlobalContext(g)
} | |
c161279 | return c.g.MobileAppState.NextUpdate(lastState)
} | |
c161280 | return errors.New(
"keybase isn't running; open the Keybase app")
}
return errors.New(
"keybase isn't running; try `run_keybase`")
}
err = conn.Close()
if err != nil {
return err
}
return nil
} | |
c161281 | net.Conn, rpc.Transporter, bool, error) {
return c.g.GetSocket(clearError)
} | |
c161282 | {
return &libkb.RPCLogFactory{Contextified: libkb.NewContextified(c.g)}
} | |
c161283 | {
c.g.Log.Debug("removing stale socket file: %s", sf)
if err = os.Remove(sf); err != nil {
c.g.Log.Warning("error removing stale socket file: %s", err)
return err
}
}
case nil:
return errors.New("socket not initialized")
default:
return errors.New("invalid socket type")
}
return nil
} | |
c161284 | c.kbfsSocketMtx.Unlock()
err := c.cleanupSocketFile()
if err != nil {
return nil, err
}
return c.kbfsSocket.BindToSocket()
} | |
c161285 | SUB_TEAMID_PUBLIC_SUFFIX_HEX:
return true
}
return false
} | |
c161286 |
if status, ok := e.(Status); ok {
return status
}
return Status{
Name: "GENERIC",
Code: int(StatusCode_SCGeneric),
Desc: e.Error(),
}
} | |
c161287 | nil, nil
}
if targ.Code == int(StatusCode_SCOk) {
return nil, nil
}
if eu.Upcaster != nil {
appError = eu.Upcaster(*targ)
} else {
appError = *targ
}
return appError, nil
} | |
c161288 | // report errors on its own. No popups needed.
return true
default:
// TLFIdentifyBehavior_DEFAULT_KBFS, for filesystem activity that
// doesn't have any other UI to report errors with.
return false
}
} | |
c161289 | _ := u.FindKID(kid)
return (incarnation != nil)
} | |
c161290 | they *must* be sorted.
var remoteTracks []RemoteTrack
for _, track := range uV2.Current.RemoteTracks {
remoteTracks = append(remoteTracks, track)
}
sort.Slice(remoteTracks, func(i, j int) bool { return remoteTracks[i].Username < remoteTracks[j].Username })
// Apart from all the key mangling above, everything e... | |
c161291 |
if public {
useSuffix = TEAMID_PUBLIC_SUFFIX
}
bs := append(sum[:15], useSuffix)
res, err := TeamIDFromString(hex.EncodeToString(bs))
if err != nil {
panic(err)
}
return res
} | |
c161292 |
return LockID(binary.BigEndian.Uint64(sum[:8]))
} | |
c161293 | := RegisterGregorFirehoseFilteredArg{Systems: systems}
err = c.Cli.Call(ctx, "keybase.1.delegateUiCtl.registerGregorFirehoseFiltered", []interface{}{__arg}, nil)
return
} | |
c161294 |
}
} else {
if ret, err = KbOpenSig(armored); err == nil {
id = kbcrypto.ComputeSigIDFromSigBody(ret)
}
}
return
} | |
c161295 | } else {
payload, kid, sigID, err = SigExtractKbPayloadAndKID(armored)
}
return payload, kid, sigID, err
} | |
c161296 | AnonymousPermissions: "read,list",
},
},
}
v1.EnsureInit()
return v1
} | |
c161297 | return c.aclCheckerInitErr
} | |
c161298 | return false
}
match, err := p.check(ctx, c.bcryptLimiter, cleartextPassword)
return err == nil && match
} | |
c161299 | perms, maxPerms, realm := c.aclChecker.getPermissions(path, username)
return perms.read, perms.list, maxPerms.read, maxPerms.list, realm, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.