id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c5400 | "", 3) + "@" + randomFrom(jsonData.Domains)
} | |
c5401 | break
case TwoCharCountry:
country = randomFrom(jsonData.CountriesTwoChars)
break
case ThreeCharCountry:
country = randomFrom(jsonData.CountriesThreeChars)
break
}
return country
} | |
c5402 | randomFrom(jsonData.StatesSmall)
}
return randomFrom(jsonData.States)
} | |
c5403 | randomFrom(jsonData.StreetTypes))
} | |
c5404 | randomFrom(jsonData.StreetNameGB), randomFrom(jsonData.StreetTypesGB))
}
return ""
} | |
c5405 | City(), State(Small), PostalCode("US"))
} | |
c5406 | = stringList[Number(0, len(stringList))]
}
return str
} | |
c5407 | := privateRand.Intn(255)
blocks = append(blocks, strconv.Itoa(number))
}
return strings.Join(blocks, ".")
} | |
c5408 | number := uint8(privateRand.Intn(255))
ip = append(ip, number)
}
return ip.String()
} | |
c5409 | := fmt.Sprintf("%02x", privateRand.Intn(255))
blocks = append(blocks, number)
}
return strings.Join(blocks, ":")
} | |
c5410 | 0, 0, 0, 0, 0, time.UTC).Day()
day := Number(1, maxDay+1)
date := time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
return date.Format(DateOutputLayout)
} | |
c5411 |
}
d.scanResp = nil
}
if d.advData != nil {
if err := d.hci.SendCmdWithAdvOff(d.advData); err != nil {
return err
}
d.advData = nil
}
return nil
} | |
c5412 | d.(*device).chkLE = chk
return nil
}
} | |
c5413 |
d.(*device).maxConn = n
return nil
}
} | |
c5414 | dd.update(); err != nil {
return err
}
return dd.hci.SetAdvertiseEnable(en)
}
} | |
c5415 | d.(*device).advData = c
return nil
}
} | |
c5416 | d.(*device).scanResp = c
return nil
}
} | |
c5417 | Option {
return func(d Device) error {
d.(*device).advParam = c
return nil
}
} | |
c5418 | if rsp == nil {
return err
}
rsp.Write(b)
return err
}
} | |
c5419 |
d.(*device).role = r
return nil
}
} | |
c5420 | {
return ioc(directionWrite, t, nr, size)
} | |
c5421 | {
return ioc(directionRead|directionWrite, t, nr, size)
} | |
c5422 | u,
svc: s,
props: props,
h: h,
vh: vh,
}
return c
} | |
c5423 | u,
h: h,
char: char,
}
return cd
} | |
c5424 | case C.TYPE_DICT:
d := make(Dict)
C.XpcDictApply(unsafe.Pointer(&d), v)
return d
case C.TYPE_INT64:
return int64(C.xpc_int64_get_value(v))
case C.TYPE_STRING:
return C.GoString(C.xpc_string_get_string_ptr(v))
case C.TYPE_UUID:
a := [16]byte{}
C.XpcUUIDGetBytes(unsafe.Pointer(&a), v)
return UUID(a... | |
c5425 | typeTxPower:
a.TxPowerLevel = int(d[0])
case typeServiceSol16:
a.SolicitedService = uuidList(a.SolicitedService, d, 2)
case typeServiceSol128:
a.SolicitedService = uuidList(a.SolicitedService, d, 16)
case typeServiceSol32:
a.SolicitedService = uuidList(a.SolicitedService, d, 4)
case typeManufacture... | |
c5426 | [31]byte{}
copy(b[:], a.b)
return b
} | |
c5427 |
return 31
}
return len(a.b)
} | |
c5428 | a.AppendField(typeFlags, []byte{f})
} | |
c5429 | = byte(typeShortName)
}
return a.AppendField(typ, []byte(n))
} | |
c5430 | {
d := append([]byte{uint8(id), uint8(id >> 8)}, b...)
return a.AppendField(typeManufacturerData, d)
} | |
c5431 |
break
}
switch l = u.Len(); {
case l == 2 && fit:
a.AppendField(typeAllUUID16, u.b)
case l == 16 && fit:
a.AppendField(typeAllUUID128, u.b)
case l == 2 && !fit:
a.AppendField(typeSomeUUID16, u.b)
case l == 16 && !fit:
a.AppendField(typeSomeUUID128, u.b)
}
}
return fit
} | |
c5432 | already disconnected", hh)
return nil
}
if err, _ := h.c.Send(cmd.Disconnect{ConnectionHandle: hh, Reason: 0x13}); err != nil {
return fmt.Errorf("l2conn: failed to disconnect, %s", err)
}
return nil
} | |
c5433 | handle LE signaling channel (CID: 5)
return nil
} | |
c5434 | if err != nil {
return UUID{}, err
}
if err := lenErr(len(b)); err != nil {
return UUID{}, err
}
return UUID{reverse(b)}, nil
} | |
c5435 | err != nil {
panic(err)
}
return u
} | |
c5436 | bytes.Equal(u.b, v.b)
} | |
c5437 | 0; i < l/2+1; i++ {
b[i], b[l-i-1] = u[l-i-1], u[i]
}
return b
} | |
c5438 | h := range hh {
h(d)
}
} | |
c5439 | Device) { d.(*device).centralConnected = f }
} | |
c5440 | Device) { d.(*device).centralDisconnected = f }
} | |
c5441 | int)) Handler {
return func(d Device) { d.(*device).peripheralDiscovered = f }
} | |
c5442 | Handler {
return func(d Device) { d.(*device).peripheralConnected = f }
} | |
c5443 | Handler {
return func(d Device) { d.(*device).peripheralDisconnected = f }
} | |
c5444 | opts {
err = opt(d)
}
return err
} | |
c5445 |
return attr{}, false
}
return r.aa[i], true
} | |
c5446 |
if w.chunk == nil {
w.chunk = make([]byte, 0, w.mtu)
}
} | |
c5447 | = append(w.b, w.chunk...)
}
w.chunk = w.chunk[:0]
w.chunked = false
return success
} | |
c5448 | w.mtu - len(w.b)
if writeable > len(w.chunk) {
writeable = len(w.chunk)
}
w.b = append(w.b, w.chunk[:writeable]...)
w.chunk = w.chunk[:0]
w.chunked = false
} | |
c5449 | return w.WriteFit([]byte{b})
} | |
c5450 | return len(b)
}
if avail < 0 {
return 0
}
return avail
} | |
c5451 | chunked write in progress")
}
if len(w.chunk) < int(offset) {
w.chunk = w.chunk[:0]
return false
}
w.chunk = w.chunk[offset:]
return true
} | |
c5452 | otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
},
)
return rv
} | |
c5453 | Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
})
} | |
c5454 | fmt.Printf("buf=%v\n", buf)
}
mac.Write(buf)
sum := mac.Sum(nil)
// "Dynamic truncation" in RFC 4226
// http://tools.ietf.org/html/rfc4226#section-5.4
offset := sum[len(sum)-1] & 0xf
value := int64(((int(sum[offset]) & 0x7f) << 24) |
((int(sum[offset+1] & 0xff)) << 16) |
((int(sum[offset+2] & 0xff)) << 8... | |
c5455 | v := url.Values{}
secret := make([]byte, opts.SecretSize)
_, err := rand.Read(secret)
if err != nil {
return nil, err
}
v.Set("secret", strings.TrimRight(base32.StdEncoding.EncodeToString(secret), "="))
v.Set("issuer", opts.Issuer)
v.Set("algorithm", opts.Algorithm.String())
v.Set("digits", opts.Digits.Stri... | |
c5456 | 1,
Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
},
)
return rv
} | |
c5457 |
Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
})
} | |
c5458 | {
return issuer
}
p := strings.TrimPrefix(k.url.Path, "/")
i := strings.Index(p, ":")
if i == -1 {
return ""
}
return p[:i]
} | |
c5459 | "/")
i := strings.Index(p, ":")
if i == -1 {
return p
}
return p[i+1:]
} | |
c5460 |
return q.Get("secret")
} | |
c5461 | d)
return fmt.Sprintf(f, in)
} | |
c5462 |
if *flag_build_dir != "" {
cmd.Dir = *flag_build_dir
} else {
cmd.Dir = *flag_directory
}
output, err := cmd.CombinedOutput()
if err == nil {
log.Println(okColor("Build ok."))
} else {
log.Println(failColor("Error while building:\n"), failColor(string(output)))
}
return err == nil
} | |
c5463 | select {
case eventPath = <-jobs:
threshold = createThreshold()
case <-threshold:
buildStarted <- eventPath
buildDone <- build()
}
}
} | |
c5464 | != nil {
err = fmt.Errorf("can't get stderr pipe for command: %s", err)
return
}
if err = cmd.Start(); err != nil {
err = fmt.Errorf("can't start command: %s", err)
return
}
return
} | |
c5465 | stopped. Waiting for build to complete."))
if !<-buildSuccess {
continue
}
}
log.Println(okColor("Restarting the given command."))
cmd, stdoutPipe, stderrPipe, err := startCommand(command)
if err != nil {
log.Fatal(failColor("Could not start command: %s", err))
}
pipeChan <- stdoutPipe
pi... | |
c5466 | {
if f[i].Str > f[j].Str {
return true
} else if f[i].Str < f[j].Str {
return false
}
}
return f[i].Name < f[j].Name
} | |
c5467 | err != nil {
return nil, err
}
} else if codec == Snappy {
avroWriter.compressedWriter = newSnappyWriter(avroWriter.blockBuffer)
} else {
avroWriter.compressedWriter = avroWriter.blockBuffer
}
err = avroWriter.writeHeader(schema)
if err != nil {
return nil, err
}
return avroWriter, nil
} | |
c5468 | nil {
return err
}
avroWriter.nextBlockRecords += 1
// If the block if full, flush and reset the compressed writer,
// write the header and the block contents
if avroWriter.nextBlockRecords >= avroWriter.recordsPerBlock {
return avroWriter.Flush()
}
return nil
} | |
c5469 |
fwWriter.Close()
fwWriter.Reset(avroWriter.blockBuffer)
}
if avroWriter.nextBlockRecords > 0 {
block := &avro.AvroContainerBlock{
NumRecords: avroWriter.nextBlockRecords,
RecordBytes: avroWriter.blockBuffer.Bytes(),
Sync: avroWriter.syncMarker,
}
err := block.Serialize(avroWriter.writer)
... | |
c5470 | re: regexp.MustCompile(invalidTokensExpr)}
} | |
c5471 | = n.re.ReplaceAllString(name, " ")
return strings.Replace(strings.Title(name), " ", "", -1)
} | |
c5472 | vm.Instruction{vm.EvalGreater, 0},
vm.Instruction{vm.CondJump, block.start + 7},
vm.Instruction{vm.Read, vm.UnusedLong},
vm.Instruction{vm.MultLong, -1},
vm.Instruction{vm.PushLoop, 0},
}, nil
} | |
c5473 | vm.Instruction{vm.EvalEqual, 0},
vm.Instruction{vm.CondJump, block.start},
vm.Instruction{vm.Jump, block.start + 7},
}, nil
} | |
c5474 | }
return nil
}
n.Definitions[d.AvroName()] = d
for _, alias := range d.Aliases() {
if existing, ok := n.Definitions[alias]; ok {
return fmt.Errorf("Alias for %q is %q, but %q is already aliased with that name", d.AvroName(), alias, existing.AvroName())
}
n.Definitions[alias] = d
}
return nil
} | |
c5475 | {
field, ok := f.(map[string]interface{})
if !ok {
return nil, NewWrongMapValueTypeError("fields", "map[]", field)
}
fieldName, err := getMapString(field, "name")
if err != nil {
return nil, err
}
t, ok := field["type"]
if !ok {
return nil, NewRequiredMapKeyError("type")
}
fieldType, er... | |
c5476 | err != nil {
return nil, err
}
symbolSlice, err := getMapArray(schemaMap, "symbols")
if err != nil {
return nil, err
}
symbolStr, ok := interfaceSliceToStringSlice(symbolSlice)
if !ok {
return nil, fmt.Errorf("'symbols' must be an array of strings")
}
aliases, err := parseAliases(schemaMap, namespace)... | |
c5477 | err != nil {
return nil, err
}
sizeBytes, err := getMapFloat(schemaMap, "size")
if err != nil {
return nil, err
}
aliases, err := parseAliases(schemaMap, namespace)
if err != nil {
return nil, err
}
return NewFixedDefinition(ParseAvroName(namespace, name), aliases, int(sizeBytes), schemaMap), nil
} | |
c5478 |
return nil, fmt.Errorf("Field aliases expected to be array of strings, got %v", aliases)
}
qualifiedAliases = append(qualifiedAliases, ParseAvroName(namespace, aliasString))
}
return qualifiedAliases, nil
} | |
c5479 | separator); \"full\" uses all namespace string.")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s [flags] <target directory> <schema files>\n\nWhere 'flags' are:\n", os.Args[0])
flag.PrintDefaults()
os.Exit(1)
}
flag.Parse()
if flag.NArg() < 2 {
flag.Usage()
}
cfg.namespacedNames = strings.ToLo... | |
c5480 | reader)
if err != nil {
return nil, err
}
log("%v", program)
compiled, err := program.CompileToVM()
log("%v", compiled)
return compiled, err
} | |
c5481 |
if _, ok := m1[k]; !ok {
m1[k] = v
}
}
return m1
} | |
c5482 | if err != nil {
return fmt.Errorf("Failed to updte meta: %s, err: %s",
meta.URL, err)
}
}
return nil
} | |
c5483 | name := range []string{"modified", "recent"} {
url = append(url, fmt.Sprintf(formatTemplate, name))
}
} else {
feed := strconv.Itoa(year)
url = append(url, fmt.Sprintf(formatTemplate, feed))
}
return
} | |
c5484 |
}
log.Debugf("Migrating DB (%s).", driver.Name())
if err := driver.MigrateDB(); err != nil {
return nil, false, err
}
return driver, false, nil
} | |
c5485 | DB. Type: %s. err: %s", r.name, err)
return
}
return
} | |
c5486 | if cpe.NvdJSONID != 0 {
if _, ok := checkedIDs[cpe.NvdJSONID]; ok {
continue
}
affects := []models.Affect{}
result := r.conn.Where(&models.Affect{NvdJSONID: cpe.NvdJSONID}).Find(&affects)
if result.Error != nil && result.Error != gorm.ErrRecordNotFound {
return nil, result.Error
}
... | |
c5487 | } else if cpe.NvdJSONID != 0 {
json := models.NvdJSON{}
err = r.conn.Select("cve_id").Where("ID = ?", cpe.NvdJSONID).First(&json).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, err
}
cveIDs[i] = json.CveID
}
// If we didn't find a CVE something is weird.
if cveIDs[i] == ""... | |
c5488 | := r.conn.Where(m).First(&meta).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, err
}
return &meta, nil
} | |
c5489 |
}
} else {
meta.Hash = mm.Hash
m.LastModifiedDate = mm.LastModifiedDate
if err := tx.Save(&meta).Error; err != nil {
return rollback(tx, err)
}
}
if err := tx.Commit().Error; err != nil {
return rollback(tx, err)
}
return nil
} | |
c5490 | req.Year,
URL: req.URL,
Body: body,
}
}
return
}
}
errs := []error{}
timeout := time.After(10 * 60 * time.Second)
for range reqs {
select {
case res := <-resChan:
results = append(results, res)
log.Infof("Fetched... %s", res.URL)
case err := <-errChan:
errs = append(errs, err... | |
c5491 | f := range tasks {
f()
}
}()
}
return tasks
} | |
c5492 | == "windows" {
defaultLogDir = filepath.Join(os.Getenv("APPDATA"), "vuls")
}
return defaultLogDir
} | |
c5493 | fmt.Sprintf("%s", wfn.Get(common.AttributeUpdate)),
Edition: fmt.Sprintf("%s", wfn.Get(common.AttributeEdition)),
Language: fmt.Sprintf("%s", wfn.Get(common.AttributeLanguage)),
SoftwareEdition: fmt.Sprintf("%s", wfn.Get(common.AttributeSwEdition)),
TargetSW: fmt.Sprintf("%s", wfn... | |
c5494 | log.Errorf("Failed to cast CVSS score. score: %s, err; %s",
str,
ignorableError,
)
f = 0
}
return f
} | |
c5495 |
return NewRedis(dbType, dbpath, debugSQL)
}
return nil, false, fmt.Errorf("Invalid database dialect, %s", dbType)
} | |
c5496 | }
}
if len(c.DumpPath) != 0 {
if ok, _ := valid.IsFilePath(c.DumpPath); !ok {
log.Errorf("JSON path must be a *Absolute* file path. dumppath: %s", c.DumpPath)
return false
}
}
_, err := valid.ValidateStruct(c)
if err != nil {
log.Errorf("error: " + err.Error())
return false
}
return true
} | |
c5497 | rdf
if err = xml.Unmarshal([]byte(res.Body), &rdf); err != nil {
return nil, fmt.Errorf(
"Failed to unmarshal. url: %s, err: %s", res.URL, err)
}
items = append(items, rdf.Items...)
}
return items, nil
} | |
c5498 | if err != nil {
return nil, err
}
return convert(items)
} | |
c5499 | nil, fmt.Errorf(
"Failed to unmarshal. url: %s, err: %s",
res.URL, err)
}
for _, e := range nvd.Entries {
cve, err := convertToModel(e)
if err != nil {
return nil, fmt.Errorf("Failed to convert to model. cve: %s, err: %s",
e.CveID, err)
}
cves = append(cves, *cve)
}
}
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.