id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c18400 | return nil, err
}
if err := c.Do(ctx, req, &alert); err != nil {
return nil, err
}
return &alert, err
} | |
c18401 |
}
if err := c.Do(ctx, req, nil); err != nil {
return false, err
}
return true, nil
} | |
c18402 | if err := c.Do(ctx, req, &profile); err != nil {
return nil, err
}
return &profile, err
} | |
c18403 | nil, err
}
if err := c.Do(ctx, req, &host); err != nil {
return nil, err
}
return &host, nil
} | |
c18404 |
}{Query: query}
req, err := c.NewRequest("GET", hostSearchTokensPath, options, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &tokens); err != nil {
return nil, err
}
return &tokens, nil
} | |
c18405 |
if err := c.Do(ctx, req, &protocols); err != nil {
return nil, err
}
return protocols, err
} | |
c18406 | baseURL,
ExploitBaseURL: exploitBaseURL,
StreamBaseURL: streamBaseURL,
Client: client,
m: &sync.Mutex{},
}
} | |
c18407 | defer c.m.Unlock()
c.Debug = debug
} | |
c18408 |
if err != nil {
return nil, err
}
return c.newRequest(method, u, params, body)
} | |
c18409 | nil {
return nil, err
}
if err := c.Do(ctx, req, &dnsResolved); err != nil {
return nil, err
}
return dnsResolved, nil
} | |
c18410 | err := c.NewRequest("GET", reversePath, params, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &dnsReversed); err != nil {
return nil, err
}
return dnsReversed, nil
} | |
c18411 |
body.Add("protocol", protocol)
req, err := c.NewRequest("POST", scanInternetPath, nil, strings.NewReader(body.Encode()))
if err != nil {
return "", err
}
if err := c.Do(ctx, req, crawlScanInternetStatus); err != nil {
return "", err
}
return crawlScanInternetStatus.ID, nil
} | |
c18412 | return nil, err
}
if err := c.Do(ctx, req, &scanStatus); err != nil {
return nil, err
}
return &scanStatus, nil
} | |
c18413 | if err := json.Unmarshal(b, &n); err != nil {
return err
}
*v = IntString(strconv.Itoa(n))
return nil
} | |
c18414 | if err := c.Do(ctx, req, &apiInfo); err != nil {
return nil, err
}
return &apiInfo, nil
} | |
c18415 | err := c.Do(ctx, req, &ip); err != nil {
return nil, err
}
return net.ParseIP(strings.Trim(ip.String(), "\"")), nil
} | |
c18416 |
if err := c.Do(ctx, req, &headers); err != nil {
return nil, err
}
return headers, nil
} | |
c18417 |
if err := c.Do(ctx, req, &services); err != nil {
return nil, err
}
return services, err
} | |
c18418 | if err != nil {
return nil, err
}
return c.newRequest("GET", u, params, nil)
} | |
c18419 | != http.StatusOK {
resp.Body.Close()
return nil, getErrorFromResponse(resp)
}
return resp, nil
} | |
c18420 | := c.DoStream(ctx, req)
if err != nil {
return nil, err
}
return resp, nil
} | |
c18421 | if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | |
c18422 | path := fmt.Sprintf(bannersCountryPath, strings.Join(strCountries, ","))
resp, err := c.startStreaming(ctx, path)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | |
c18423 | fmt.Sprintf(bannersPortsPath, strings.Join(strPorts, ","))
resp, err := c.startStreaming(ctx, path)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | |
c18424 | err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | |
c18425 | {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | |
c18426 | if err := c.Do(ctx, req, &ports); err != nil {
return nil, err
}
return ports, nil
} | |
c18427 |
return nil, err
}
var found ExploitSearch
if err := c.Do(ctx, req, &found); err != nil {
return nil, err
}
return &found, nil
} | |
c18428 | }
if err := c.Do(ctx, req, &queryTags); err != nil {
return nil, err
}
return &queryTags, nil
} | |
c18429 | }
if err := c.Do(ctx, req, &querySearch); err != nil {
return nil, err
}
return &querySearch, nil
} | |
c18430 | err != nil {
return nil, err
}
if err := c.Do(ctx, req, &querySearch); err != nil {
return nil, err
}
return &querySearch, nil
} | |
c18431 | Notification: make(chan WatcherNotification, notificationLen),
}
heap.Init(&w.fds)
go w.watch()
return w
} | |
c18432 | if pin.Number == p.Number {
// found pin
w.removeFd(fd)
return
}
}
} | |
c18433 |
w.AddPinWithEdgeAndLogic(p, EdgeBoth, ActiveHigh)
} | |
c18434 |
setEdgeTrigger(pin, edge)
w.cmdChan <- watcherCmd{
pin: pin,
action: watcherAdd,
}
} | |
c18435 | pin: pin,
action: watcherRemove,
}
} | |
c18436 | watcherCmd{
pin: Pin{},
action: watcherClose,
}
} | |
c18437 | * time.Millisecond)
pin.direction = inDirection
setDirection(pin, inDirection, 0)
pin = openPin(pin, false)
return pin
} | |
c18438 | inDirection {
return 0, errors.New("pin is not configured for input")
}
return readPin(p)
} | |
c18439 | {
return errors.New("pin is not configured for output")
}
return writePin(p, 1)
} | |
c18440 |
body, err := ioutil.ReadAll(os.Stdin)
if err != nil {
fmt.Fprintln(os.Stderr, "error reading stdin")
os.Exit(11)
}
msg, err := mail.ReadMessage(bytes.NewReader(body))
if err != nil {
fmt.Fprintln(os.Stderr, "error parsing message body")
os.Exit(11)
}
if len(recip) == 0 {
// We only need to parse the... | |
c18441 | nil, errors.New("dexec: Config is nil")
}
return &createContainer{opt: opts}, nil
} | |
c18442 | return &Cmd{Method: method, Path: name, Args: arg, docker: d}
} | |
c18443 | == nil {
c.Stderr = ioutil.Discard
}
cmd := append([]string{c.Path}, c.Args...)
if err := c.Method.create(c.docker, cmd); err != nil {
return err
}
if err := c.Method.run(c.docker, c.Stdin, c.Stdout, c.Stderr); err != nil {
return err
}
return nil
} | |
c18444 | io.Pipe()
c.Stdout = pw
c.closeAfterWait = append(c.closeAfterWait, pw)
return pr, nil
} | |
c18445 | io.Pipe()
c.Stderr = pw
c.closeAfterWait = append(c.closeAfterWait, pw)
return pr, nil
} | |
c18446 | copy(addr[:], ipnet.IP.To4())
return
}
}
}
err = errors.New("You do not appear to be connected to the Internet")
return
} | |
c18447 | {
return
}
addr := addrs[0]
ipAddr, err := net.ResolveIPAddr("ip", addr)
if err != nil {
return
}
copy(destAddr[:], ipAddr.IP.To4())
return
} | |
c18448 | temp dir:", err)
}
}()
// Write the source code file.
tempFile := filepath.Join(tempDir, "generate.go")
err = ioutil.WriteFile(tempFile, []byte(src), 0600)
if err != nil {
return err
}
// Compile and run the program.
cmd := exec.Command("go", "run", "-tags="+tags, tempFile)
cmd.Stdout = os.Stdout
cmd.S... | |
c18449 |
err = t.ExecuteTemplate(buf, "Trailer", toc)
if err != nil {
return err
}
// Write output file (all at once).
fmt.Println("writing", opt.Filename)
err = ioutil.WriteFile(opt.Filename, buf.Bytes(), 0644)
return err
} | |
c18450 | return err
case nil:
toc.HasCompressedFile = true
// If compressed file is not smaller than original, revert and write original file.
case errCompressedNotSmaller:
_, err = r.Seek(0, io.SeekStart)
if err != nil {
return err
}
buf.Truncate(marker)
// Write FileInfo.
err = wr... | |
c18451 | := range fis {
paths[i] = pathpkg.Join(dirname, fis[i].Name())
}
sort.Strings(paths)
return paths, nil
} | |
c18452 | err
}
if sw.N >= file.UncompressedSize {
return errCompressedNotSmaller
}
err = t.ExecuteTemplate(w, "CompressedFileInfo-After", file)
return err
} | |
c18453 | = io.Copy(sw, r)
if err != nil {
return err
}
err = t.ExecuteTemplate(w, "FileInfo-After", file)
return err
} | |
c18454 | string, but %T", e)
}
if lit.Kind != token.STRING {
return "", fmt.Errorf("not a string, but %v", lit.Kind)
}
return strconv.Unquote(lit.Value)
} | |
c18455 | if len(tags) != 1 {
return "", fmt.Errorf("%q is not a valid single build tag, but %q", tagFlag, tags)
}
return tags[0], nil
} | |
c18456 | import package %q: %v", importPath, err)
}
dpkg, err := computeDoc(bpkg)
if err != nil {
return "", "", fmt.Errorf("can't get godoc of package %q: %v", importPath, err)
}
for _, v := range dpkg.Vars {
if len(v.Names) == 1 && v.Names[0] == variableName {
variableComment = strings.TrimSuffix(v.Doc, "\n")
... | |
c18457 |
return nil, err
}
files[file] = f
}
apkg := &ast.Package{
Name: bpkg.Name,
Files: files,
}
return doc.New(apkg, bpkg.ImportPath, 0), nil
} | |
c18458 | opt.VariableComment = fmt.Sprintf("%s statically implements the virtual filesystem provided to vfsgen.", opt.VariableName)
}
} | |
c18459 | result, err = dirWindows()
} else {
// Unix-like system, so just assume Unix
result, err = dirUnix()
}
if err != nil {
return "", err
}
homedirCache = result
return result, nil
} | |
c18460 | home dir")
}
dir, err := Dir()
if err != nil {
return "", err
}
return filepath.Join(dir, path[1:]), nil
} | |
c18461 | append(b, pre.String()...)
}
}
if len(v.Build) > 0 {
b = append(b, '+')
b = append(b, v.Build[0]...)
for _, build := range v.Build[1:] {
b = append(b, '.')
b = append(b, build...)
}
}
return string(b)
} | |
c18462 | be incremented for %q", v.String())
}
v.Patch += 1
return nil
} | |
c18463 | version can not be incremented for %q", v.String())
}
v.Minor += 1
v.Patch = 0
return nil
} | |
c18464 | build := range v.Build {
if len(build) == 0 {
return fmt.Errorf("Build meta data can not be empty %q", build)
}
if !containsOnly(build, alphanum) {
return fmt.Errorf("Invalid character(s) found in build meta data %q", build)
}
}
return nil
} | |
c18465 | err := Parse(s)
vp = &v
return
} | |
c18466 | + s + `): ` + err.Error())
}
return v
} | |
c18467 |
return PRVersion{}, err
}
v.VersionNum = num
v.IsNum = true
} else if containsOnly(s, alphanum) {
v.VersionStr = s
v.IsNum = false
} else {
return PRVersion{}, fmt.Errorf("Invalid character(s) found in prerelease %q", s)
}
return v, nil
} | |
c18468 | strconv.FormatUint(v.VersionNum, 10)
}
return v.VersionStr
} | |
c18469 |
return "", fmt.Errorf("Invalid character(s) found in build meta data %q", s)
}
return s, nil
} | |
c18470 | bool {
return vr.c(v, vr.v)
})
} | |
c18471 | Range(func(v Version) bool {
return rf(v) || f(v)
})
} | |
c18472 | Range(func(v Version) bool {
return rf(v) && f(v)
})
} | |
c18473 | range is '||'")
}
ORparts = append(ORparts, parts[last:i])
last = i + 1
}
}
if last == len(parts) {
return nil, fmt.Errorf("Last element in range is '||'")
}
ORparts = append(ORparts, parts[last:])
return ORparts, nil
} | |
c18474 | == s {
return true
}
}
return false
} | |
c18475 | < len(s)-1 {
result = append(result, s[last:])
}
for i, v := range result {
result[i] = strings.Replace(v, " ", "", -1)
}
// parts := strings.Split(s, " ")
// for _, x := range parts {
// if s := strings.TrimSpace(x); len(s) != 0 {
// result = append(result, s)
// }
// }
return
} | |
c18476 | "", "", fmt.Errorf("Could not get version from string: %q", s)
}
return strings.TrimSpace(s[0:i]), s[i:], nil
} | |
c18477 | wildcard := parts[nparts-1]
possibleWildcardType := wildcardTypefromInt(nparts)
if wildcard == "x" {
return possibleWildcardType
}
return noneWildcard
} | |
c18478 | parts := strings.Split(vStr2, ".")
// handle 1.x
if len(parts) == 2 {
return vStr2 + ".0"
}
return vStr2
} | |
c18479 | := strconv.Atoi(parts[0])
if err != nil {
return "", err
}
parts[0] = strconv.Itoa(i + 1)
return strings.Join(parts, "."), nil
} | |
c18480 | ParseRange(` + s + `): ` + err.Error())
}
return r
} | |
c18481 | ok {
return v.(dataloader.Thunk), ok
}
return nil, ok
} | |
c18482 | {
c.c.Set(key.String(), value, 0)
} | |
c18483 | _, found := c.c.Get(key.String()); found {
c.c.Delete(key.String())
return true
}
return false
} | |
c18484 | *Loader) {
l.wait = d
}
} | |
c18485 |
l.clearCacheOnBatch = true
l.cacheLock.Unlock()
}
} | |
c18486 |
}
// Set defaults
if loader.cache == nil {
loader.cache = NewCache()
}
if loader.tracer == nil {
loader.tracer = &NoopTracer{}
}
return loader
} | |
c18487 | l.cache.Delete(ctx, key)
l.cacheLock.Unlock()
return l
} | |
c18488 |
l.cache.Clear()
l.cacheLock.Unlock()
return l
} | |
c18489 | (interface{}, error) {
return value, nil
}
l.cache.Set(ctx, key, thunk)
}
return l
} | |
c18490 | batchFn: l.batchFn,
silent: silent,
tracer: tracer,
}
} | |
c18491 | {
close(b.input)
b.finished = true
}
} | |
c18492 |
return
}
if len(items) != len(keys) {
err := &Result{Error: fmt.Errorf(`
The batch function supplied did not return an array of responses
the same length as the array of keys.
Keys:
%v
Values:
%v
`, keys, items)}
for _, req := range reqs {
req.channel <- err
close(req.channel)
}... | |
c18493 | if the batcher has already been closed and a
// new one has been created. So reset the loader state only if the batcher
// is the current one
if l.curBatcher == b {
l.reset()
}
l.batchLock.Unlock()
} | |
c18494 | value dataloader.Thunk) {
c.ARCCache.Add(key, value)
} | |
c18495 | {
if c.ARCCache.Contains(key) {
c.ARCCache.Remove(key)
return true
}
return false
} | |
c18496 | list[i] = l[i].String()
}
return list
} | |
c18497 | spanCtx, func(thunk Thunk) {
// TODO: is there anything we should do with the results?
span.Finish()
}
} | |
c18498 | spanCtx, func(thunk ThunkMany) {
// TODO: is there anything we should do with the results?
span.Finish()
}
} | |
c18499 | spanCtx, func(results []*Result) {
// TODO: is there anything we should do with the results?
span.Finish()
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.