id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c160900 | path.Clean(path.Join(elem...))
} | |
c160901 | }
now := rfs.config.Clock().Now()
return []os.FileInfo{
&wrappedReadFileInfo{"private", 0, now, true},
&wrappedReadFileInfo{"public", 0, now, true},
&wrappedReadFileInfo{"team", 0, now, true},
}, nil
} | |
c160902 | return "", errors.New("RootFS cannot read links")
} | |
c160903 | // haven't yet implemented folderlist browsing.
return nil, errors.New("RootFS cannot chroot")
} | |
c160904 | errors.New("RootFS cannot rename files")
} | |
c160905 | return errors.New("RootFS cannot mkdir")
} | |
c160906 | }
if generation == maxGeneration {
_, created, cerr := e.GetOrCreateLatestTeamEK(mctx, teamID)
if cerr != nil {
mctx.Debug("Unable to GetOrCreateLatestTeamEK: %v", cerr)
}
if e.backgroundCreationTestCh != nil {
e.backgroundCreationTestCh <- created
}
}
}(libkb.NewMetaCo... | |
c160907 | Log) (bool, error) {
return false, nil
} | |
c160908 | path := range keybaseLogFiles {
fmt.Fprintf(logFile, " --- %s ---\n", path)
// We have to parse the contents and write them because some files need to
// be decoded from utf16
s, err := newScannerUTF16or8(path)
if err != nil {
fmt.Fprintf(logFile, " --- NewScannerUTF16(%s) returns %v---\n", path, err)... | |
c160909 | logFile.Close()
if err != nil {
return "", err
}
if len(watchdogLogFiles) == 0 {
fmt.Fprintf(logFile, " --- NO WATCHDOG LOGS FOUND!?! ---\n")
}
for _, path := range watchdogLogFiles {
fmt.Fprintf(logFile, " --- %s ---\n", path)
// append the files
func() {
fd, err := os.Open(path)
defer fd.C... | |
c160910 |
err := chains.addOps(codec, mdInfo.pmd, winfo, mdInfo.localTimestamp)
if err != nil {
return err
}
}
if !processedOne {
return nil
}
mostRecentMDInfo := mdInfos[len(mdInfos)-1]
chains.mostRecentChainMDInfo = mostRecentMDInfo.kmd
// Does the last op already have a valid path in each chain? If
// so... | |
c160911 | log, osg, mdInfos, cpp, newUnflushedPaths)
if err != nil {
return nil, err
}
if len(newUnflushedPaths) > 1 {
return nil, fmt.Errorf("%d unflushed revisions on a single put",
len(newUnflushedPaths))
}
perRevMap, ok := newUnflushedPaths[mdInfo.revision]
if !ok {
panic(fmt.Errorf("Cannot find per-revision... | |
c160912 | // This was prepared before `upc.chainsPopulator` was set,
// and needs to be done again.
return false
}
// Update the cache with the prepared paths.
upc.unflushedPaths[mdInfo.revision] = perRevMap
default:
panic(fmt.Sprintf("Unknown unflushedPathsCache state: %v", upc.state))
}
return true
} | |
c160913 | default:
// We can't initialize with a nil revision map.
return true
}
}
if upc.unflushedPaths != nil {
reinitUpcCache(
mdInfo.revision, upc.unflushedPaths, perRevMap, isLocalSquash)
} else {
upc.unflushedPaths = unflushedPathsMap{mdInfo.revision: perRevMap}
}
upc.queue = nil
if upc.ready != nil ... | |
c160914 | &s3.AWS{},
stash: NewFileStash(runtimeDir),
env: env,
}
} | |
c160915 | return fmt.Errorf("unencrypted attachments not supported: asset: %#v", asset)
}
body, err := a.GetAssetReader(ctx, params, asset, signer)
defer func() {
if body != nil {
body.Close()
}
}()
if err != nil {
return err
}
a.Debug(ctx, "DownloadAsset: downloading %s from s3", asset.Path)
return a.DecryptAs... | |
c160916 | Subcommands: []cli.Command{
NewCmdRekeyStatus(cl, g),
NewCmdRekeyPaper(cl, g),
NewCmdRekeyTrigger(cl, g),
},
}
} | |
c160917 | arg.Options.SigVersion = &tmp
}
return &TrackToken{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | |
c160918 | }
return &CachedUPAKLoader{
Contextified: NewContextified(g),
Freshness: f,
cache: c,
noCache: false,
}
} | |
c160919 |
Freshness: time.Duration(0),
noCache: true,
}
} | |
c160920 | loadWithInfo).
var converted *keybase1.UserPlusAllKeys
if ret != nil {
tmp := keybase1.UPAKFromUPKV2AI(*ret)
converted = &tmp
}
return converted, user, err
} | |
c160921 | = m
defer tbs.Record("CachedUPAKLoader.LoadV2")()
return u.loadWithInfo(arg, nil, nil, true)
} | |
c160922 | range attempts {
if i > 0 {
u.G().VDL.CLogf(ctx, VLog0, "| reloading with arg: %s", arg.String())
}
upak, _, err := u.LoadV2(arg)
if err != nil {
return nil, nil, nil, err
}
if upak == nil {
return nil, nil, nil, fmt.Errorf("Nil user, nil error from LoadUser")
}
ret, key := upak.FindKID(kid... | |
c160923 |
}
// Try again with a forced load in case the device is very new.
larg = larg.WithForcePoll(true)
upakV2, _, err = u.loadWithInfo(larg, nil, nil, false)
if err != nil {
return nil, nil, nil, err
}
upakV1 = keybase1.UPAKFromUPKV2AI(*upakV2)
deviceKey, revoked, err = u.extractDeviceKey(upakV1, deviceID)
ret... | |
c160924 | return
return upakV2, nil
}
}
// Try again with a forced load in case the device is very new.
larg = larg.WithForcePoll(true)
upakV2, _, err = u.loadWithInfo(larg, nil, nil, false)
if err != nil {
return nil, err
}
return upakV2, nil
} | |
c160925 |
if len(namePkgs) == 0 {
return empty, UserNotFoundError{UID: uid, Msg: "in CachedUPAKLoader"}
}
if u.TestDeadlocker != nil {
u.TestDeadlocker()
}
return namePkgs[0].NormalizedUsername, nil
} | |
c160926 | upak == nil {
return UserNotFoundError{UID: uid, Msg: "in CachedUPAKLoader"}
}
ret = NewNormalizedUsername(upak.Current.Username)
return nil
}, false)
return ret, err
} | |
c160927 | return keybase1.UID(""), err
}
if !un.Eq(un2) {
m.Warning("Unexpected mismatched usernames (uid=%s): %s != %s", rres.GetUID(), un.String(), un2.String())
return keybase1.UID(""), NewBadUsernameError(un.String())
}
return rres.GetUID(), nil
} | |
c160928 |
if err != nil {
u.G().Log.Warning("Failed to remove %s v1 object from disk cache: %s", uid, err)
}
} | |
c160929 | User, err error) {
err = c.Cli.Call(ctx, "keybase.1.user.loadUser", []interface{}{__arg}, &res)
return
} | |
c160930 | "keybase.1.user.loadUserPlusKeys", []interface{}{__arg}, &res)
return
} | |
c160931 | []PublicKey, err error) {
err = c.Cli.Call(ctx, "keybase.1.user.loadPublicKeys", []interface{}{__arg}, &res)
return
} | |
c160932 | []UserSummary, err error) {
err = c.Cli.Call(ctx, "keybase.1.user.listTracking", []interface{}{__arg}, &res)
return
} | |
c160933 | c.Cli.Call(ctx, "keybase.1.user.getUPAK", []interface{}{__arg}, &res)
return
} | |
c160934 | err = c.Cli.Call(ctx, "keybase.1.user.getUPAKLite", []interface{}{__arg}, &res)
return
} | |
c160935 | "keybase.1.user.findNextMerkleRootAfterReset", []interface{}{__arg}, &res)
return
} | |
c160936 | var onced bool
r.startOnce.Do(func() {
onced = true
go r.loop(libkb.NewMetaContextBackground(mctx.G()), trigger)
})
if !onced {
select {
case r.kickCh <- trigger:
default:
}
}
} | |
c160937 | libkb.NewContextified(g),
usernameOrEmail: usernameOrEmail,
}
} | |
c160938 |
if b.open {
err = drain(os.Stdin)
}
b.open = false
return err
} | |
c160939 | finfo.Mode(); mode.IsDir() {
return fmt.Errorf("A directory is not a valid file")
}
return nil
} | |
c160940 | externalKeyStore = TypeSafeExternalKeyStoreProxy{s}
externalKeyStoreInitialized = false
} | |
c160941 |
wmdV3.MDDiskUsage = wmdV2.MDDiskUsage
wmdV3.RefBytes = wmdV2.RefBytes
wmdV3.UnrefBytes = wmdV2.UnrefBytes
wmdV3.MDRefBytes = wmdV2.MDRefBytes
if wmdV2.ID.Type() == tlf.Public {
wmdV3.LatestKeyGen = PublicKeyGen
} else {
wmdV3.LatestKeyGen = wmdV2.WKeys.LatestKeyGeneration()
}
return wmdV3
} | |
c160942 | if latest < FirstValidKeyGen {
return 0, 0
}
// We keep track of all known key generations.
return FirstValidKeyGen, latest + 1
} | |
c160943 | md.WriterMetadataSigInfo, prevMd.WriterMetadataSigInfo)
if err != nil {
return false, err
}
if !writerSigInfoEqual {
// Signature/public key mismatch.
return false, nil
}
onlyUserRKeysChanged, err := md.haveOnlyUserRKeysChanged(
codec, prevMd, user)
if err != nil {
return false, err
}
if !onlyUserRK... | |
c160944 | range md.Writers {
if w == user.AsUserOrTeam() {
return true, nil
}
}
return false, nil
}
return md.WKeys.IsWriter(user, deviceKey), nil
} | |
c160945 | md.RKeys.IsReader(user, deviceKey), nil
case tlf.SingleTeam:
// There are no read-only users of single-team TLFs.
return false, nil
default:
panic(fmt.Sprintf("Unexpected TLF type: %s", md.ID.Type()))
}
} | |
c160946 | (MutableRootMetadata, error) {
return md.deepCopy(codec)
} | |
c160947 | copy a v2 signature into a v3 MD
// blindly.
mdCopy, err := md.makeSuccessorCopyV2(
codec, isReadableAndWriter)
if err != nil {
return nil, nil, err
}
return mdCopy, nil, nil
}
// Upconvert to the new version.
return md.makeSuccessorCopyV3(codec, tlfCryptKeyGetter)
} | |
c160948 | // MakeBareTlfHandle.
if _, ok := wkb.WKeys[r]; !ok &&
r != keybase1.PublicUID {
readers = append(readers, r.AsUserOrTeam())
}
}
} else {
writers = md.Writers
if md.ID.Type() == tlf.Public {
readers = []keybase1.UserOrTeamID{keybase1.PublicUID.AsUserOrTeam()}
}
}
return tlf.MakeHandle(
... | |
c160949 |
if md.FinalizedInfo != nil {
extensions = append(extensions, *md.FinalizedInfo)
}
return extensions
} | |
c160950 | }
// TODO: This may be incorrect, since dkim may
// contain negative EPubKey indices, and the
// upconversion code assumes that writers will
// only contain non-negative EPubKey indices.
//
// See KBFS-1719.
md.WKeys[i].WKeys[reader] = dkim
delete(rkb.RKeys, reader)
}
}
return nil
} | |
c160951 | return nil, err
}
}
}
var rRemovalInfo ServerHalfRemovalInfo
for _, rkb := range md.RKeys {
removalInfo := rkb.RKeys.RemoveDevicesNotIn(updatedReaderKeys)
if rRemovalInfo == nil {
rRemovalInfo = removalInfo
} else {
err := rRemovalInfo.AddGeneration(removalInfo)
if err != nil {
return nil... | |
c160952 | }
i := int(keyGen - FirstValidKeyGen)
if i >= len(md.WKeys) || i >= len(md.RKeys) {
return nil, nil, NewKeyGenerationError{md.ID, keyGen}
}
return &md.WKeys[i], &md.RKeys[i], nil
} | |
c160953 | nil, nil, errors.New(
"GetUserDevicePublicKeys called with no key generations (V2)")
}
wUDKIM := md.WKeys[len(md.WKeys)-1]
rUDKIM := md.RKeys[len(md.RKeys)-1]
return wUDKIM.WKeys.ToPublicKeys(), rUDKIM.RKeys.ToPublicKeys(), nil
} | |
c160954 |
}
}
info, ok := dkim[key.KID()]
if !ok {
return kbfscrypto.TLFEphemeralPublicKey{},
kbfscrypto.EncryptedTLFCryptKeyClientHalf{},
kbfscrypto.TLFCryptKeyServerHalfID{}, false, nil
}
_, _, ePubKey, err := GetEphemeralPublicKeyInfoV2(info, *wkb, *rkb)
if err != nil {
return kbfscrypto.TLFEphemeralPublic... | |
c160955 | md.PrevRoot != (ID{}) {
return fmt.Errorf("Invalid PrevRoot %s for initial revision", md.PrevRoot)
}
} else {
if md.PrevRoot == (ID{}) {
return errors.New("No PrevRoot for non-initial revision")
}
}
}
if len(md.SerializedPrivateMetadata) == 0 {
return errors.New("No private metadata")
}
if... | |
c160956 | md.WriterMetadataSigInfo.VerifyingKey, key)
}
}
// Verify the user and device are the last modifier.
user := md.GetLastModifyingUser()
if user != uid {
return fmt.Errorf("Last modifier %s != %s", user, uid)
}
return nil
} | |
c160957 |
return codec.Encode(md.WriterMetadataV2)
} | |
c160958 | keybase1.UID) {
md.WriterMetadataV2.LastModifyingWriter = user
} | |
c160959 | []keybase1.SocialAssertion) {
md.Extra.UnresolvedWriters = writers
} | |
c160960 | = nil
md.RKeys = nil
md.Extra.UnresolvedWriters = nil
md.UnresolvedReaders = nil
} | |
c160961 | return InitialExtraMetadataVer
}
// Let other types of MD objects use the older version since they
// are still compatible with older clients.
return PreExtraMetadataVer
} | |
c160962 | "No key generations in GetCurrentTLFPublicKey")
}
return md.WKeys[len(md.WKeys)-1].TLFPublicKey, nil
} | |
c160963 | len(writers)+len(readers))
users = append(users, writers...)
users = append(users, readers...)
return users
} | |
c160964 |
existingReaderKeys :=
md.RKeys[len(md.RKeys)-1].RKeys.ToPublicKeys()
if !existingReaderKeys.Equals(updatedReaderKeys) {
return nil, nil, fmt.Errorf(
"existingReaderKeys=%+v != updatedReaderKeys=%+v",
existingReaderKeys, updatedReaderKeys)
}
}
newWriterKeys := TLFWriterKeyBundleV2{
WKeys: ... | |
c160965 | err != nil {
return nil, err
}
serverHalves[keyGen-FirstValidKeyGen] = serverHalvesGen
}
return serverHalves, nil
}
// Usual rekey case.
for keyGen := FirstValidKeyGen; keyGen <= md.LatestKeyGeneration(); keyGen++ {
serverHalvesGen, err := md.updateKeyGeneration(
keyGen, updatedWriterKeys, up... | |
c160966 | error {
// Nothing to do.
return nil
} | |
c160967 | kbfscrypto.TLFCryptKey{}, errors.New(
"TLF crypt key not symmetrically encrypted")
} | |
c160968 | nil {
return *sc.localChainNextHighSkipOverride, nil
}
if len(sc.chainLinks) == 0 {
return NewInitialHighSkip(), nil
}
return sc.GetLastLink().ExpectedNextHighSkip(mctx, uid)
} | |
c160969 | return cropToRightmostSubchain(m, sc.chainLinks, eldest, sc.uid)
} | |
c160970 |
curr := links[i]
prev := links[i-1]
isStart, err := isSubchainStart(m, curr, prev, uid)
if err != nil {
return nil, err
}
if isStart {
return links[i:], nil
}
}
// If we didn't find a start anywhere in the middle of the chain, then this
// user has no resets, and we'll return the whole chain. Sa... | |
c160971 | "last known seqno: %d\n", sc.GetLastKnownSeqno())
fmt.Fprintf(w, "last known id: %s\n", sc.GetLastKnownID())
} | |
c160972 | link := range sc.chainLinks {
if link.GetSigID().Match(query, false) {
return link
}
}
return nil
} | |
c160973 | err = l.chain.Store(l.M())
}
return
} | |
c160974 |
sort.Sort(UIDList(readersCopy))
}
var unresolvedWritersCopy []keybase1.SocialAssertion
if len(unresolvedWriters) > 0 {
unresolvedWritersCopy = make([]keybase1.SocialAssertion, len(unresolvedWriters))
copy(unresolvedWritersCopy, unresolvedWriters)
sort.Sort(SocialAssertionList(unresolvedWritersCopy))
}
v... | |
c160975 | len(h.Writers) == 1 && h.Writers[0].IsTeamOrSubteam() {
return SingleTeam
}
return Private
} | |
c160976 | TeamKeying
}
return h.Type().ToKeyingType()
} | |
c160977 | single team TLF")
}
return h.findUserInList(user, h.Writers)
} | |
c160978 |
return h.TypeForKeying() == PublicKeying ||
h.findUserInList(user, h.Readers) ||
h.IsWriter(user)
} | |
c160979 | = append(resolvedUsers, h.Writers...)
if h.TypeForKeying() == PrivateKeying {
resolvedUsers = append(resolvedUsers, h.Readers...)
}
return resolvedUsers
} | |
c160980 | 0 || len(h.UnresolvedReaders) > 0
} | |
c160981 | h.UnresolvedWriters...)
unresolvedUsers = append(unresolvedUsers, h.UnresolvedReaders...)
return unresolvedUsers
} | |
c160982 | range h.Writers {
delete(resolvedReaders, u)
}
h.Readers = uidSetToSlice(resolvedReaders)
sort.Sort(UIDList(h.Writers))
sort.Sort(UIDList(h.Readers))
sort.Sort(SocialAssertionList(h.UnresolvedWriters))
sort.Sort(SocialAssertionList(h.UnresolvedReaders))
h.sorted = true
return h
} | |
c160983 | nil {
extensions = append(extensions, *h.FinalizedInfo)
}
return extensions
} | |
c160984 | other.Readers[i] != v {
return false
}
}
for i, v := range h.UnresolvedReaders {
if other.UnresolvedReaders[i] != v {
return false
}
}
if h.IsConflict() != other.IsConflict() {
return false
}
if h.IsFinal() != other.IsFinal() {
return false
}
if h.ConflictInfo != nil &&
h.ConflictInfo.String(... | |
c160985 | u := range b {
if !aMap[u] {
return false
}
delete(aMap, u)
}
return len(aMap) == 0
} | |
c160986 | checkUIDEquality(h.Writers, writers) &&
checkUIDEquality(h.Readers, readers)
} | |
c160987 | "No offset, cannot use common time; "+
"falling back to local time")
return clock.Now()
}
return clock.Now().Add(-offset)
} | |
c160988 |
case err != nil:
return false, err
default: // err == nil
modCommonTime := fi.ModTime()
if modCommonTime.Add(workTimeLimit).After(currCommonTime) {
log.CDebugf(ctx, "Other worker is still working; "+
"modCommonTime=%s, currCommonTime=%s, workTimeLimit=%s",
modCommonTime, currCommonTime, workTimeLimi... | |
c160989 | keybase1.FsInterface {
return &fs{config: config, log: log}
} | |
c160990 | result, err = f.keybase(ctx)
case KeybaseChildPathType:
result, err = f.favorites(ctx, kbfsPath)
default:
result, err = f.tlf(ctx, kbfsPath)
}
if err != nil {
f.log.CErrorf(ctx, "Error listing path %q: %s", arg.Path, err)
}
return result, err
} | |
c160991 | err2 != nil {
mctx.Debug("PrimeSecretStore: clearing secret store entry returned an error: %s", err2)
if err == nil {
err = err2
} else {
mctx.Debug("suppressing store clearing error because something else has errored prior")
}
}
}()
// Try to fetch first, we should get an error back.
_, err ... | |
c160992 | f.fuse = fuse
f.conn = conn
} | |
c160993 | context.Context) {
f.notifications.LaunchProcessor(ctx)
} | |
c160994 | time limit,
// so we don't hose the entire mount (Fixed in OSXFUSE 3.2.0).
// The timeout is 60 seconds, but it looks like sometimes it
// tries multiple attempts within that 60 seconds, so let's go
// a little under 60/3 to be safe.
//
// It should be safe to ignore the CancelFunc here because... | |
c160995 |
},
})
f.fuse = srv
f.notifications.LaunchProcessor(ctx)
f.remoteStatus.Init(ctx, f.log, f.config, f)
// Blocks forever, unless an interrupt signal is received
// (handled by libkbfs.Init).
return srv.Serve(f)
} | |
c160996 | {
return err
} else if session == (idutil.SessionInfo{}) {
// If user is not logged in, don't bother getting quota info. Otherwise
// reading a public TLF while logged out can fail on macOS.
return nil
}
_, usageBytes, _, limitBytes, err := f.quotaUsage.Get(
ctx, quotaUsageStaleTolerance/2, quotaUsageStal... | |
c160997 | PrivateName:
return r.private, nil
case PublicName:
return r.public, nil
}
if req.Name == TeamName {
return r.team, nil
}
// Don't want to pop up errors on special OS files.
if strings.HasPrefix(req.Name, ".") {
return nil, fuse.ENOENT
}
return nil, libkbfs.NoSuchFolderListError{
Name: req.Nam... | |
c160998 | without
// triggering a notification.
return nil, nil, syscall.ENOENT
}
return nil, nil, libkbfs.NewWriteUnsupportedError(tlfhandle.BuildCanonicalPath(r.PathType(), req.Name))
} | |
c160999 | }()
return nil, libkbfs.NewWriteUnsupportedError(tlfhandle.BuildCanonicalPath(r.PathType(), req.Name))
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.