id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c180200 | GenerateKeyPairWithReader(typ, bits, rand.Reader)
} | |
c180201 | case Secp256k1:
return GenerateSecp256k1Key(src)
case ECDSA:
return GenerateECDSAKeyPair(src)
default:
return nil, nil, ErrBadKeyType
}
} | |
c180202 | if x == nil {
return nil, fmt.Errorf("malformed public key: %d %v", len(theirPub), theirPub)
}
if !curve.IsOnCurve(x, y) {
return nil, errors.New("invalid public key")
}
// Generate shared secret.
secret, _ := curve.ScalarMult(x, y, priv)
return secret.Bytes(), nil
}
return pubKey, done, nil
} | |
c180203 | := PubKeyUnmarshallers[pmes.GetType()]
if !ok {
return nil, ErrBadKeyType
}
return um(pmes.GetData())
} | |
c180204 | k.Type()
data, err := k.Raw()
if err != nil {
return nil, err
}
pbmes.Data = data
return proto.Marshal(pbmes)
} | |
c180205 | := PrivKeyUnmarshallers[pmes.GetType()]
if !ok {
return nil, ErrBadKeyType
}
return um(pmes.GetData())
} | |
c180206 | k.Type()
data, err := k.Raw()
if err != nil {
return nil, err
}
pbmes.Data = data
return proto.Marshal(pbmes)
} | |
c180207 | := k2.Bytes()
return bytes.Equal(b1, b2) && err1 == err2
} | |
c180208 | return GenerateECDSAKeyPairWithCurve(ECDSACurve, src)
} | |
c180209 | := ecdsa.GenerateKey(curve, src)
if err != nil {
return nil, nil, err
}
return &ECDSAPrivateKey{priv}, &ECDSAPublicKey{&priv.PublicKey}, nil
} | |
c180210 |
}
return &ECDSAPrivateKey{priv}, &ECDSAPublicKey{&priv.PublicKey}, nil
} | |
c180211 | return nil, err
}
return &ECDSAPrivateKey{priv}, nil
} | |
c180212 | pubIfc.(*ecdsa.PublicKey)
if !ok {
return nil, ErrNotECDSAPubKey
}
return &ECDSAPublicKey{pub}, nil
} | |
c180213 |
}
return ePriv.priv.D.Cmp(oPriv.priv.D) == 0
} | |
c180214 | != nil {
return nil, err
}
return asn1.Marshal(ECDSASig{
R: r,
S: s,
})
} | |
c180215 |
return ePub.pub.X != nil && ePub.pub.Y != nil && oPub.pub.X != nil && oPub.pub.Y != nil &&
0 == ePub.pub.X.Cmp(oPub.pub.X) && 0 == ePub.pub.Y.Cmp(oPub.pub.Y)
} | |
c180216 |
return false, ErrNilSig
}
hash := sha256.Sum256(data)
return ecdsa.Verify(ePub.pub, hash[:], sig.R, sig.S), nil
} | |
c180217 | nil, nil, err
}
k := (*Secp256k1PrivateKey)(privk)
return k, k.GetPublic(), nil
} | |
c180218 | }
privk, _ := btcec.PrivKeyFromBytes(btcec.S256(), data)
return (*Secp256k1PrivateKey)(privk), nil
} | |
c180219 | return nil, err
}
return (*Secp256k1PublicKey)(k), nil
} | |
c180220 | := o.(*Secp256k1PrivateKey)
if !ok {
return false
}
return k.D.Cmp(sk.D) == 0
} | |
c180221 |
sig, err := (*btcec.PrivateKey)(k).Sign(hash[:])
if err != nil {
return nil, err
}
return sig.Serialize(), nil
} | |
c180222 | }
return (*btcec.PublicKey)(k).IsEqual((*btcec.PublicKey)(sk))
} | |
c180223 |
if err != nil {
return false, err
}
hash := sha256.Sum256(data)
return sig.Verify(hash[:], (*btcec.PublicKey)(k)), nil
} | |
c180224 | an
// elliptic curve multiplication.
buf := make([]byte, len(k.k))
copy(buf, k.k)
return buf, nil
} | |
c180225 | return ed25519.Sign(k.k, msg), nil
} | |
c180226 | o.(*Ed25519PublicKey)
if !ok {
return false
}
return bytes.Equal(k.k, edk.k)
} | |
c180227 |
return ed25519.Verify(k.k, data, sig), nil
} | |
c180228 | 32")
}
return &Ed25519PublicKey{
k: ed25519.PublicKey(data),
}, nil
} | |
c180229 | copy(newKey, data[:ed25519.PrivateKeySize])
data = newKey
case ed25519.PrivateKeySize:
default:
return nil, fmt.Errorf(
"expected ed25519 data size to be %d or %d, got %d",
ed25519.PrivateKeySize,
ed25519.PrivateKeySize+ed25519.PublicKeySize,
len(data),
)
}
return &Ed25519PrivateKey{
k: ed25519.PrivateKey(data),
}, nil
} | |
c180230 | len(target),
MatrixForStrings(source, target, op), op)
} | |
c180231 | backtrace(len(matrix)-1, len(matrix[0])-1, matrix, op)
} | |
c180232 | %2d", matrix[0][0])
for j, _ := range target {
fmt.Fprintf(writer, " %2d", matrix[0][j+1])
}
fmt.Fprintf(writer, "\n")
for i, sourceRune := range source {
fmt.Fprintf(writer, "%c %2d", sourceRune, matrix[i+1][0])
for j, _ := range target {
fmt.Fprintf(writer, " %2d", matrix[i+1][j+1])
}
fmt.Fprintf(writer, "\n")
}
} | |
c180233 | Lockfile(""), ErrNeedAbsPath
}
return Lockfile(path), nil
} | |
c180234 | != nil {
return nil, err
}
if running {
proc, err := os.FindProcess(pid)
if err != nil {
return nil, err
}
return proc, nil
}
return nil, ErrDeadOwner
} | |
c180235 | check later, if this process is still alive.
// We cannot ignore ALL errors, since failure to support hard links, disk full
// as well as many other errors can happen to a filesystem operation
// and we really want to abort on those.
if err := os.Link(tmplock.Name(), name); err != nil {
if !os.IsExist(err) {
return err
}
}
fiTmp, err := os.Lstat(tmplock.Name())
if err != nil {
return err
}
fiLock, err := os.Lstat(name)
if err != nil {
// tell user that a retry would be a good idea
if os.IsNotExist(err) {
return ErrNotExist
}
return err
}
// Success
if os.SameFile(fiTmp, fiLock) {
return nil
}
proc, err := l.GetOwner()
switch err {
default:
// Other errors -> defensively fail and let caller handle this
return err
case nil:
if proc.Pid != os.Getpid() {
return ErrBusy
}
case ErrDeadOwner, ErrInvalidPid:
// cases we can fix below
}
// clean stale/invalid lockfile
err = os.Remove(name)
if err != nil {
// If it doesn't exist, then it doesn't matter who removed it.
if !os.IsNotExist(err) {
return err
}
}
// now that the stale lockfile is gone, let's recurse
return l.TryLock()
} | |
c180236 | give a better error for logging here.
if os.IsNotExist(err) {
return ErrRogueDeletion
}
// Other errors -> defensively fail and let caller handle this
return err
}
} | |
c180237 | make([]Logger, 0),
hookPreQueue: make([]HookPreQueue, 0),
}
for _, f := range configs {
f(b)
}
return b
} | |
c180238 | old logger we might already have a reference to
if b.fallbackLogger != nil && b.fallbackLogger.IsInitialized() {
b.fallbackLogger.ShutdownLogger()
}
b.fallbackLogger = logger
return nil
} | |
c180239 | return err
}
}
b.loggers = append(b.loggers, logger)
if hook, ok := logger.(HookPreQueue); ok {
b.hookPreQueue = append(b.hookPreQueue, hook)
}
logger.SetBase(b)
return nil
} | |
c180240 |
if m == nil {
m = NewAttrs()
}
seq := atomic.AddUint64(&b.sequence, 1)
m.SetAttr(b.config.SequenceAttr, seq)
}
nm := newMessage(ts, b, level, m, msg, a...)
for _, hook := range b.hookPreQueue {
err := hook.PreQueue(nm)
if err != nil {
return err
}
}
return b.queue.queueMessage(nm)
} | |
c180241 |
return b.LogWithTime(level, b.clock.Now(), m, msg, a...)
} | |
c180242 |
return b.Warningm(m, msg, a...)
} | |
c180243 | = f
}
parsedTpl, err := template.New(getLevelName(level)).
Funcs(fMap).
Parse(tpl)
if err != nil {
return nil, err
}
tpls[level] = parsedTpl
}
newTpl := &Template{
tpls: tpls,
}
return newTpl, nil
} | |
c180244 | return "", ErrUnknownLevel
}
err := execTpl.Execute(&buf, msg)
if err != nil {
return "", err
}
return buf.String(), nil
} | |
c180245 | Message: msg,
Level: level,
LevelName: level.String(),
Attrs: msgAttrs,
}
return tplMsg
} | |
c180246 |
if attrs == nil {
attrs = NewAttrs()
}
return &LogAdapter{
base: base,
attrs: attrs,
}
} | |
c180247 | la.attrs.SetAttr(key, value)
} | |
c180248 |
mergedAttrs.MergeAttrs(attrs)
return la.base.LogWithTime(level, ts, mergedAttrs, msg, a...)
} | |
c180249 | mergedAttrs.MergeAttrs(attrs)
return la.base.Log(level, mergedAttrs, msg, a...)
} | |
c180250 |
return la.Debugm(m, msg, a...)
} | |
c180251 |
newAttrs.SetAttr(attrKey, attrVal)
}
return newAttrs
} | |
c180252 |
newAttrs.MergeAttrs(attr)
}
return newAttrs
} | |
c180253 |
for hash, val := range attrs.attrs {
a.attrs[hash] = val
}
} | |
c180254 |
value = valVal.Type().String()
}
hash := getAttrHash(key)
a.attrs[hash] = value
return a
} | |
c180255 | a.attrsLock.RUnlock()
return a.attrs[getAttrHash(key)]
} | |
c180256 |
defer a.attrsLock.Unlock()
delete(a.attrs, getAttrHash(key))
} | |
c180257 | := range a.attrs {
key, _ := getHashAttr(hash)
attrs[key] = val
}
return attrs
} | |
c180258 | curDefault.Debugm(m, msg, a...)
} | |
c180259 | curDefault.Infom(m, msg, a...)
} | |
c180260 | curDefault.Warningm(m, msg, a...)
} | |
c180261 | error {
return Errorm(m, msg, a...)
} | |
c180262 | curDefault.Errorm(m, msg, a...)
} | |
c180263 | curDefault.Fatalm(m, msg, a...)
} | |
c180264 | curDefault.Dief(exitCode, msg, a...)
} | |
c180265 | curDefault.Diem(exitCode, m, msg, a...)
} | |
c180266 | nil
case "err":
fallthrough
case "error":
return LevelError, nil
case "fatal":
return LevelFatal, nil
case "none":
return LevelNone, nil
}
return 0, ErrUnknownLevel
} | |
c180267 | := make(chan error)
callQueue <- func() {
errChan <- f()
}
return <-errChan
} | |
c180268 | return nil, errors.New("the project id was not provided")
}
// set default project name
if sh.logName == "" {
err = LogName(DefaultName)(sh)
if err != nil {
return nil, err
}
}
// If error reporting log name not set, set it to log name
// plus string suffix
if sh.errorReportingLogName == "" {
sh.errorReportingLogName = sh.logName + "_errors"
}
return sh, nil
} | |
c180269 | httpReq = x
default:
labels[k] = fmt.Sprintf("%v", v)
}
}
// write log entry
if sh.agentClient != nil {
sh.sendLogMessageViaAgent(entry, labels, httpReq)
} else {
sh.sendLogMessageViaAPI(entry, labels, httpReq)
}
}(sh.copyEntry(entry))
return nil
} | |
c180270 |
sh.levels = levels
return nil
}
} | |
c180271 | sh.projectID = projectID
return nil
}
} | |
c180272 | *StackdriverHook) error {
sh.service = service
return nil
}
} | |
c180273 |
sh.service = service.Entries
return nil
}
} | |
c180274 | sh.errorService = errorService
return nil
}
} | |
c180275 | create error reporting service
e, err := errorReporting.New(client)
if err != nil {
return err
} else {
ErrorService(e)
}
return LoggingService(l)(sh)
}
} | |
c180276 | *StackdriverHook) error {
sh.resource = resource
return nil
}
} | |
c180277 |
sh.errorReportingLogName = name
return nil
}
} | |
c180278 |
sh.labels = labels
return nil
}
} | |
c180279 | sh.partialSuccess = enabled
return nil
}
} | |
c180280 | if !sliceContains(scopes, s) {
// NOTE: if you are seeing this error, you probably need to
// recreate your compute instance with the correct scope
//
// as of August 2016, there is not a way to add a scope to an
// existing compute instance
return fmt.Errorf("missing required scope %s in compute metadata", s)
}
}
return HTTPClient(&http.Client{
Transport: &oauth2.Transport{
Source: google.ComputeTokenSource(serviceAccount),
},
})(sh)
}
} | |
c180281 | NewEncoder(c.NewEmitter(w))
} | |
c180282 | NewDecoder(c.NewParser(r))
} | |
c180283 | NewStreamEncoder(c.NewEmitter(w))
} | |
c180284 | NewStreamDecoder(c.NewParser(r))
} | |
c180285 |
reg.codecs = make(map[string]Codec)
}
reg.codecs[mimetype] = codec
} | |
c180286 | reg.mutex.Lock()
delete(reg.codecs, mimetype)
} | |
c180287 | bool) {
reg.mutex.RLock()
codec, ok = reg.codecs[mimetype]
reg.mutex.RUnlock()
return
} | |
c180288 |
reg.mutex.RLock()
for mimetype, codec := range reg.codecs {
codecs[mimetype] = codec
}
reg.mutex.RUnlock()
return
} | |
c180289 | for _, c := range s {
if !unicode.IsUpper(c) {
s = ""
break
}
}
}
return s
} | |
c180290 | = adapter
adapterMutex.Unlock()
// We have to clear the struct cache because it may now have become invalid.
// Because installing adapters is done in the package initialization phase
// it's unlikely that any encoding or decoding operations are taking place
// at this time so there should be no performance impact of clearing the
// cache.
structCache.clear()
} | |
c180291 | ok = adapterStore[typ]
adapterMutex.RUnlock()
return
} | |
c180292 | = fmtInt(buf[:w], u)
} else {
w--
buf[w] = 's'
w, u = fmtFrac(buf[:w], u, 9)
// u is now integer seconds
w = fmtInt(buf[:w], u%60)
u /= 60
// u is now integer minutes
if u > 0 {
w--
buf[w] = 'm'
w = fmtInt(buf[:w], u%60)
u /= 60
// u is now integer hours
// Stop at hours because days can be different lengths.
if u > 0 {
w--
buf[w] = 'h'
w = fmtInt(buf[:w], u)
}
}
}
if neg {
w--
buf[w] = '-'
}
return append(b, buf[w:]...)
} | |
c180293 | w--
buf[w] = byte(v%10) + '0'
v /= 10
}
}
return w
} | |
c180294 | {
return objconv.NewDecoder(NewParser(r))
} | |
c180295 | {
return objconv.NewStreamDecoder(NewParser(r))
} | |
c180296 |
u.reset(b)
err := (objconv.Decoder{Parser: u}).Decode(v)
u.reset(nil)
unmarshalerPool.Put(u)
return err
} | |
c180297 |
return "time"
case Duration:
return "duration"
case Error:
return "error"
case Array:
return "array"
case Map:
return "map"
default:
return "<type>"
}
} | |
c180298 | v = reflect.Zero(t)
zeroMutex.Lock()
zeroCache[t] = v
zeroMutex.Unlock()
}
return v
} | |
c180299 | stack: []reflect.Value{reflect.ValueOf(v)},
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.