_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q16200 | dropTableIfExists | train | func (mg *Migration) dropTableIfExists(structPtr interface{}) {
tn := tableName(structPtr)
_, err := mg.db.Exec(mg.dialect.dropTableSql(tn))
if err != nil && !mg.dialect.catchMigrationError(err) {
panic(err)
}
} | go | {
"resource": ""
} |
q16201 | DropTable | train | func (mg *Migration) DropTable(strutPtr interface{}) {
if !strings.HasSuffix(mg.dbName, "test") {
panic("Drop table can only be executed on database which name has 'test' suffix")
}
mg.dropTableIfExists(strutPtr)
} | go | {
"resource": ""
} |
q16202 | CreateIndexIfNotExists | train | func (mg *Migration) CreateIndexIfNotExists(table interface{}, name string, unique bool, columns ...string) error {
tn := tableName(table)
name = tn + "_" + name
if !mg.dialect.indexExists(mg, tn, name) {
sql := mg.dialect.createIndexSql(name, tn, unique, columns...)
if mg.Log {
fmt.Println(sql)
}
_, err ... | go | {
"resource": ""
} |
q16203 | GetMigration | train | func GetMigration() (mg *Migration, err error) {
if driver == "" || dial == nil {
panic("database driver has not been registered, should call Register first.")
}
db, err := sql.Open(driver, driverSource)
if err != nil {
return nil, err
}
return &Migration{db, dbName, dial, false}, nil
} | go | {
"resource": ""
} |
q16204 | WithMigration | train | func WithMigration(task func(mg *Migration) error) error {
mg, err := GetMigration()
if err != nil {
return err
}
defer mg.Close()
return task(mg)
} | go | {
"resource": ""
} |
q16205 | Register | train | func Register(driverName, driverSourceName, databaseName string, dialect Dialect) {
driverSource = driverSourceName
dbName = databaseName
if db == nil {
var err error
var database *sql.DB
database, err = sql.Open(driverName, driverSource)
if err != nil {
panic(err)
}
RegisterWithDb(driverName, databas... | go | {
"resource": ""
} |
q16206 | SetConnectionLimit | train | func SetConnectionLimit(maxCon int, blocking bool) {
if maxCon > 0 {
connectionLimit = make(chan struct{}, maxCon)
} else if maxCon < 0 {
connectionLimit = nil
}
blockingOnLimit = blocking
} | go | {
"resource": ""
} |
q16207 | Begin | train | func (q *Qbs) Begin() error {
if q.tx != nil {
panic("cannot start nested transaction")
}
tx, err := db.Begin()
q.tx = tx
q.txStmtMap = make(map[string]*sql.Stmt)
return err
} | go | {
"resource": ""
} |
q16208 | Commit | train | func (q *Qbs) Commit() error {
err := q.tx.Commit()
q.updateTxError(err)
q.tx = nil
for _, v := range q.txStmtMap {
v.Close()
}
q.txStmtMap = nil
return q.firstTxError
} | go | {
"resource": ""
} |
q16209 | Rollback | train | func (q *Qbs) Rollback() error {
err := q.tx.Rollback()
q.tx = nil
for _, v := range q.txStmtMap {
v.Close()
}
q.txStmtMap = nil
return q.updateTxError(err)
} | go | {
"resource": ""
} |
q16210 | Condition | train | func (q *Qbs) Condition(condition *Condition) *Qbs {
q.criteria.condition = condition
return q
} | go | {
"resource": ""
} |
q16211 | OmitFields | train | func (q *Qbs) OmitFields(fieldName ...string) *Qbs {
q.criteria.omitFields = fieldName
return q
} | go | {
"resource": ""
} |
q16212 | Find | train | func (q *Qbs) Find(structPtr interface{}) error {
q.criteria.model = structPtrToModel(structPtr, !q.criteria.omitJoin, q.criteria.omitFields)
q.criteria.limit = 1
if !q.criteria.model.pkZero() {
idPath := q.Dialect.quote(q.criteria.model.table) + "." + q.Dialect.quote(q.criteria.model.pk.name)
idCondition := New... | go | {
"resource": ""
} |
q16213 | FindAll | train | func (q *Qbs) FindAll(ptrOfSliceOfStructPtr interface{}) error {
strucType := reflect.TypeOf(ptrOfSliceOfStructPtr).Elem().Elem().Elem()
strucPtr := reflect.New(strucType).Interface()
q.criteria.model = structPtrToModel(strucPtr, !q.criteria.omitJoin, q.criteria.omitFields)
query, args := q.Dialect.querySql(q.crite... | go | {
"resource": ""
} |
q16214 | Exec | train | func (q *Qbs) Exec(query string, args ...interface{}) (sql.Result, error) {
defer q.Reset()
query = q.Dialect.substituteMarkers(query)
q.log(query, args...)
stmt, err := q.prepare(query)
if err != nil {
return nil, q.updateTxError(err)
}
result, err := stmt.Exec(args...)
if err != nil {
return nil, q.update... | go | {
"resource": ""
} |
q16215 | QueryRow | train | func (q *Qbs) QueryRow(query string, args ...interface{}) *sql.Row {
q.log(query, args...)
query = q.Dialect.substituteMarkers(query)
stmt, err := q.prepare(query)
if err != nil {
q.updateTxError(err)
return nil
}
return stmt.QueryRow(args...)
} | go | {
"resource": ""
} |
q16216 | Query | train | func (q *Qbs) Query(query string, args ...interface{}) (rows *sql.Rows, err error) {
q.log(query, args...)
query = q.Dialect.substituteMarkers(query)
stmt, err := q.prepare(query)
if err != nil {
q.updateTxError(err)
return
}
return stmt.Query(args...)
} | go | {
"resource": ""
} |
q16217 | prepare | train | func (q *Qbs) prepare(query string) (stmt *sql.Stmt, err error) {
var ok bool
if q.tx != nil {
stmt, ok = q.txStmtMap[query]
if ok {
return
}
stmt, err = q.tx.Prepare(query)
if err != nil {
q.updateTxError(err)
return
}
q.txStmtMap[query] = stmt
} else {
mu.RLock()
stmt, ok = stmtMap[query... | go | {
"resource": ""
} |
q16218 | Save | train | func (q *Qbs) Save(structPtr interface{}) (affected int64, err error) {
if v, ok := structPtr.(Validator); ok {
err = v.Validate(q)
if err != nil {
return
}
}
model := structPtrToModel(structPtr, true, q.criteria.omitFields)
if model.pk == nil {
panic("no primary key field")
}
q.criteria.model = model
... | go | {
"resource": ""
} |
q16219 | Update | train | func (q *Qbs) Update(structPtr interface{}) (affected int64, err error) {
if v, ok := structPtr.(Validator); ok {
err := v.Validate(q)
if err != nil {
return 0, err
}
}
model := structPtrToModel(structPtr, true, q.criteria.omitFields)
q.criteria.model = model
q.criteria.mergePkCondition(q.Dialect)
if q.c... | go | {
"resource": ""
} |
q16220 | Delete | train | func (q *Qbs) Delete(structPtr interface{}) (affected int64, err error) {
model := structPtrToModel(structPtr, true, q.criteria.omitFields)
q.criteria.model = model
q.criteria.mergePkCondition(q.Dialect)
if q.criteria.condition == nil {
panic("Can not delete without condition")
}
return q.Dialect.delete(q)
} | go | {
"resource": ""
} |
q16221 | ContainsValue | train | func (q *Qbs) ContainsValue(table interface{}, column string, value interface{}) bool {
quotedColumn := q.Dialect.quote(column)
quotedTable := q.Dialect.quote(tableName(table))
query := fmt.Sprintf("SELECT %v FROM %v WHERE %v = ?", quotedColumn, quotedTable, quotedColumn)
row := q.QueryRow(query, value)
var result... | go | {
"resource": ""
} |
q16222 | Close | train | func (q *Qbs) Close() error {
if connectionLimit != nil {
<-connectionLimit
}
if q.tx != nil {
return q.Rollback()
}
return nil
} | go | {
"resource": ""
} |
q16223 | Count | train | func (q *Qbs) Count(table interface{}) int64 {
quotedTable := q.Dialect.quote(tableName(table))
query := "SELECT COUNT(*) FROM " + quotedTable
var row *sql.Row
if q.criteria.condition != nil {
conditionSql, args := q.criteria.condition.Merge()
query += " WHERE " + conditionSql
row = q.QueryRow(query, args...)... | go | {
"resource": ""
} |
q16224 | QueryMap | train | func (q *Qbs) QueryMap(query string, args ...interface{}) (map[string]interface{}, error) {
mapSlice, err := q.doQueryMap(query, true, args...)
if len(mapSlice) == 1 {
return mapSlice[0], err
}
return nil, sql.ErrNoRows
} | go | {
"resource": ""
} |
q16225 | QueryMapSlice | train | func (q *Qbs) QueryMapSlice(query string, args ...interface{}) ([]map[string]interface{}, error) {
return q.doQueryMap(query, false, args...)
} | go | {
"resource": ""
} |
q16226 | QueryStruct | train | func (q *Qbs) QueryStruct(dest interface{}, query string, args ...interface{}) error {
query = q.Dialect.substituteMarkers(query)
stmt, err := q.prepare(query)
if err != nil {
return q.updateTxError(err)
}
rows, err := stmt.Query(args...)
if err != nil {
return q.updateTxError(err)
}
defer rows.Close()
out... | go | {
"resource": ""
} |
q16227 | Iterate | train | func (q *Qbs) Iterate(structPtr interface{}, do func() error) error {
q.criteria.model = structPtrToModel(structPtr, !q.criteria.omitJoin, q.criteria.omitFields)
query, args := q.Dialect.querySql(q.criteria)
q.log(query, args...)
defer q.Reset()
stmt, err := q.prepare(query)
if err != nil {
return q.updateTxErr... | go | {
"resource": ""
} |
q16228 | StringsToInterfaces | train | func StringsToInterfaces(strs ...string) []interface{} {
ret := make([]interface{}, len(strs))
for i := 0; i < len(strs); i++ {
ret[i] = strs[i]
}
return ret
} | go | {
"resource": ""
} |
q16229 | New | train | func New(settings *Settings, customHeadersFunc func(*http.Request) [][]byte) EventSource {
if settings == nil {
settings = DefaultSettings()
}
es := new(eventSource)
es.customHeadersFunc = customHeadersFunc
es.sink = make(chan message, 1)
es.close = make(chan bool)
es.staled = make(chan *consumer, 1)
es.add ... | go | {
"resource": ""
} |
q16230 | ExampleAll | train | func ExampleAll() error {
b, err := ioutil.ReadFile("cli-spinners/spinners.json")
if err != nil {
return err
}
o := make(map[string]interface{})
err = json.Unmarshal(b, &o)
if err != nil {
return err
}
// Generate example/all/main.go
tpl, err := template.New("example-all").Funcs(helpers()).Parse(exampleAl... | go | {
"resource": ""
} |
q16231 | New | train | func New(o io.Writer, s spin.Spinner, text string, options ...func(*Wow)) *Wow {
isTerminal := terminal.IsTerminal(int(os.Stdout.Fd()))
wow := Wow{out: o, s: s, txt: text, IsTerminal: isTerminal}
for _, option := range options {
option(&wow)
}
return &wow
} | go | {
"resource": ""
} |
q16232 | Start | train | func (w *Wow) Start() {
if !w.running {
ctx, done := context.WithCancel(context.Background())
w.done = done
w.running = true
go w.run(ctx)
}
} | go | {
"resource": ""
} |
q16233 | Stop | train | func (w *Wow) Stop() {
if w.done != nil {
w.done()
}
w.running = false
} | go | {
"resource": ""
} |
q16234 | Spinner | train | func (w *Wow) Spinner(s spin.Spinner) *Wow {
w.Stop()
w.s = s
w.Start()
return w
} | go | {
"resource": ""
} |
q16235 | Text | train | func (w *Wow) Text(txt string) *Wow {
w.mu.Lock()
w.txt = txt
w.mu.Unlock()
return w
} | go | {
"resource": ""
} |
q16236 | Persist | train | func (w *Wow) Persist() {
w.Stop()
at := len(w.s.Frames) - 1
txt := erase + w.s.Frames[at] + w.txt + "\n"
if w.IsTerminal {
fmt.Fprint(w.out, txt)
}
} | go | {
"resource": ""
} |
q16237 | PersistWith | train | func (w *Wow) PersistWith(s spin.Spinner, text string) {
w.Stop()
var a string
if len(s.Frames) > 0 {
a = s.Frames[len(s.Frames)-1]
}
txt := erase + a + text + "\n"
if w.IsTerminal {
fmt.Fprint(w.out, txt)
}
} | go | {
"resource": ""
} |
q16238 | MpIms | train | func (res *MpImListAPIResponse) MpIms() ([]*MpIm, error) {
var mpim []*MpIm
err := json.Unmarshal(res.RawMpIms, &mpim)
if err != nil {
return nil, err
}
return mpim, nil
} | go | {
"resource": ""
} |
q16239 | FindMpIm | train | func (sl *Slack) FindMpIm(cb func(*MpIm) bool) (*MpIm, error) {
mpims, err := sl.MpImList()
if err != nil {
return nil, err
}
for _, mpim := range mpims {
if cb(mpim) {
return mpim, nil
}
}
return nil, errors.New("No such mpim.")
} | go | {
"resource": ""
} |
q16240 | Groups | train | func (res *GroupsListAPIResponse) Groups() ([]*Group, error) {
var groups []*Group
err := json.Unmarshal(res.RawGroups, &groups)
if err != nil {
return nil, err
}
return groups, nil
} | go | {
"resource": ""
} |
q16241 | FindGroup | train | func (sl *Slack) FindGroup(cb func(*Group) bool) (*Group, error) {
groups, err := sl.GroupsList()
if err != nil {
return nil, err
}
for _, group := range groups {
if cb(group) {
return group, nil
}
}
return nil, errors.New("No such group.")
} | go | {
"resource": ""
} |
q16242 | FindGroupByName | train | func (sl *Slack) FindGroupByName(name string) (*Group, error) {
return sl.FindGroup(func(group *Group) bool {
return group.Name == name
})
} | go | {
"resource": ""
} |
q16243 | FindUser | train | func (sl *Slack) FindUser(cb func(*User) bool) (*User, error) {
members, err := sl.UsersList()
if err != nil {
return nil, err
}
for _, member := range members {
if cb(member) {
return member, nil
}
}
return nil, errors.New("No such user.")
} | go | {
"resource": ""
} |
q16244 | FindUserByName | train | func (sl *Slack) FindUserByName(name string) (*User, error) {
return sl.FindUser(func(user *User) bool {
return user.Name == name
})
} | go | {
"resource": ""
} |
q16245 | Channels | train | func (res *ChannelsListAPIResponse) Channels() ([]*Channel, error) {
var chs []*Channel
err := json.Unmarshal(res.RawChannels, &chs)
if err != nil {
return nil, err
}
return chs, nil
} | go | {
"resource": ""
} |
q16246 | FindChannel | train | func (sl *Slack) FindChannel(cb func(*Channel) bool) (*Channel, error) {
channels, err := sl.ChannelsList()
if err != nil {
return nil, err
}
for _, channel := range channels {
if cb(channel) {
return channel, nil
}
}
return nil, errors.New("No such channel.")
} | go | {
"resource": ""
} |
q16247 | FindChannelByName | train | func (sl *Slack) FindChannelByName(name string) (*Channel, error) {
return sl.FindChannel(func(channel *Channel) bool {
return channel.Name == name
})
} | go | {
"resource": ""
} |
q16248 | Ims | train | func (res *ImListAPIResponse) Ims() ([]*Im, error) {
var im []*Im
err := json.Unmarshal(res.RawIms, &im)
if err != nil {
return nil, err
}
return im, nil
} | go | {
"resource": ""
} |
q16249 | FindIm | train | func (sl *Slack) FindIm(cb func(*Im) bool) (*Im, error) {
ims, err := sl.ImList()
if err != nil {
return nil, err
}
for _, im := range ims {
if cb(im) {
return im, nil
}
}
return nil, errors.New("No such im.")
} | go | {
"resource": ""
} |
q16250 | FindImByName | train | func (sl *Slack) FindImByName(name string) (*Im, error) {
user, err := sl.FindUserByName(name)
if err != nil {
return nil, err
}
id := user.Id
return sl.FindIm(func(im *Im) bool {
return im.User == id
})
} | go | {
"resource": ""
} |
q16251 | Add | train | func (z fermat) Add(x, y fermat) fermat {
if len(z) != len(x) {
panic("Add: len(z) != len(x)")
}
addVV(z, x, y) // there cannot be a carry here.
z.norm()
return z
} | go | {
"resource": ""
} |
q16252 | Sub | train | func (z fermat) Sub(x, y fermat) fermat {
if len(z) != len(x) {
panic("Add: len(z) != len(x)")
}
n := len(y) - 1
b := subVV(z[:n], x[:n], y[:n])
b += y[n]
// If b > 0, we need to subtract b<<n, which is the same as adding b.
z[n] = x[n]
if z[0] <= ^big.Word(0)-b {
z[0] += b
} else {
addVW(z, z, b)
}
z.... | go | {
"resource": ""
} |
q16253 | polyFromNat | train | func polyFromNat(x nat, k uint, m int) poly {
p := poly{k: k, m: m}
length := len(x)/m + 1
p.a = make([]nat, length)
for i := range p.a {
if len(x) < m {
p.a[i] = make(nat, m)
copy(p.a[i], x)
break
}
p.a[i] = x[:m]
x = x[m:]
}
return p
} | go | {
"resource": ""
} |
q16254 | Int | train | func (p *poly) Int() nat {
length := len(p.a)*p.m + 1
if na := len(p.a); na > 0 {
length += len(p.a[na-1])
}
n := make(nat, length)
m := p.m
np := n
for i := range p.a {
l := len(p.a[i])
c := addVV(np[:l], np[:l], p.a[i])
if np[l] < ^big.Word(0) {
np[l] += c
} else {
addVW(np[l:], np[l:], c)
}
... | go | {
"resource": ""
} |
q16255 | Mul | train | func (p *poly) Mul(q *poly) poly {
// extra=2 because:
// * some power of 2 is a K-th root of unity when n is a multiple of K/2.
// * 2 itself is a square (see fermat.ShiftHalf)
n := valueSize(p.k, p.m, 2)
pv, qv := p.Transform(n), q.Transform(n)
rv := pv.Mul(&qv)
r := rv.InvTransform()
r.m = p.m
return r
} | go | {
"resource": ""
} |
q16256 | InvNTransform | train | func (v *polValues) InvNTransform() poly {
k := v.k
n := v.n
θshift := (n * _W) >> k
// Perform an inverse Fourier transform to recover q.
qbits := make([]big.Word, (n+1)<<k)
q := make([]fermat, 1<<k)
for i := range q {
q[i] = fermat(qbits[i*(n+1) : (i+1)*(n+1)])
}
fourier(q, v.values, true, n, k)
// Divi... | go | {
"resource": ""
} |
q16257 | fourier | train | func fourier(dst []fermat, src []fermat, backward bool, n int, k uint) {
var rec func(dst, src []fermat, size uint)
tmp := make(fermat, n+1) // pre-allocate temporary variables.
tmp2 := make(fermat, n+1) // pre-allocate temporary variables.
// The recursion function of the FFT.
// The root of unity used in the t... | go | {
"resource": ""
} |
q16258 | Mul | train | func (p *polValues) Mul(q *polValues) (r polValues) {
n := p.n
r.k, r.n = p.k, p.n
r.values = make([]fermat, len(p.values))
bits := make([]big.Word, len(p.values)*(n+1))
buf := make(fermat, 8*n)
for i := range r.values {
r.values[i] = bits[i*(n+1) : (i+1)*(n+1)]
z := buf.Mul(p.values[i], q.values[i])
copy(r... | go | {
"resource": ""
} |
q16259 | Reset | train | func (l *Limiter) Reset(name string, period time.Duration) error {
secs := int64(period / time.Second)
slot := time.Now().Unix() / secs
name = allowName(name, slot)
return l.redis.Del(name).Err()
} | go | {
"resource": ""
} |
q16260 | ResetRate | train | func (l *Limiter) ResetRate(name string, rateLimit rate.Limit) error {
if rateLimit == 0 {
return nil
}
if rateLimit == rate.Inf {
return nil
}
_, period := limitPeriod(rateLimit)
slot := time.Now().UnixNano() / period.Nanoseconds()
name = allowRateName(name, period, slot)
return l.redis.Del(name).Err()
} | go | {
"resource": ""
} |
q16261 | AllowN | train | func (l *Limiter) AllowN(
name string, maxn int64, period time.Duration, n int64,
) (count int64, delay time.Duration, allow bool) {
secs := int64(period / time.Second)
utime := time.Now().Unix()
slot := utime / secs
delay = time.Duration((slot+1)*secs-utime) * time.Second
if l.Fallback != nil {
allow = l.Fall... | go | {
"resource": ""
} |
q16262 | AllowRate | train | func (l *Limiter) AllowRate(name string, rateLimit rate.Limit) (delay time.Duration, allow bool) {
if rateLimit == 0 {
return 0, false
}
if rateLimit == rate.Inf {
return 0, true
}
limit, period := limitPeriod(rateLimit)
now := time.Now()
slot := now.UnixNano() / period.Nanoseconds()
name = allowRateName(... | go | {
"resource": ""
} |
q16263 | StashOldBinary | train | func StashOldBinary(tag string, keep bool) (string, error) {
loc, err := exec.LookPath(util.OsExeFileName("ipfs"))
if err != nil {
return "", fmt.Errorf("could not find old binary: %s", err)
}
loc, err = filepath.Abs(loc)
if err != nil {
return "", fmt.Errorf("could not determine absolute path for old binary: ... | go | {
"resource": ""
} |
q16264 | checkVersionAbove | train | func checkVersionAbove(major, minor, micro uint) bool {
return (verMajor > major) ||
(verMajor == major && verMinor > minor) ||
(verMajor == major && verMinor == minor && verMicro >= micro)
} | go | {
"resource": ""
} |
q16265 | getApi | train | func getApi() (uint, error) {
api := C.seccomp_api_get()
if api == 0 {
return 0, fmt.Errorf("API level operations are not supported")
}
return uint(api), nil
} | go | {
"resource": ""
} |
q16266 | setApi | train | func setApi(api uint) error {
if retCode := C.seccomp_api_set(C.uint(api)); retCode != 0 {
if syscall.Errno(-1*retCode) == syscall.EOPNOTSUPP {
return fmt.Errorf("API level operations are not supported")
}
return fmt.Errorf("could not set API level: %v", retCode)
}
return nil
} | go | {
"resource": ""
} |
q16267 | getFilterAttr | train | func (f *ScmpFilter) getFilterAttr(attr scmpFilterAttr) (C.uint32_t, error) {
f.lock.Lock()
defer f.lock.Unlock()
if !f.valid {
return 0x0, errBadFilter
}
var attribute C.uint32_t
retCode := C.seccomp_attr_get(f.filterCtx, attr.toNative(), &attribute)
if retCode != 0 {
return 0x0, syscall.Errno(-1 * retCo... | go | {
"resource": ""
} |
q16268 | setFilterAttr | train | func (f *ScmpFilter) setFilterAttr(attr scmpFilterAttr, value C.uint32_t) error {
f.lock.Lock()
defer f.lock.Unlock()
if !f.valid {
return errBadFilter
}
retCode := C.seccomp_attr_set(f.filterCtx, attr.toNative(), value)
if retCode != 0 {
return syscall.Errno(-1 * retCode)
}
return nil
} | go | {
"resource": ""
} |
q16269 | addRuleWrapper | train | func (f *ScmpFilter) addRuleWrapper(call ScmpSyscall, action ScmpAction, exact bool, length C.uint, cond C.scmp_cast_t) error {
if length != 0 && cond == nil {
return fmt.Errorf("null conditions list, but length is nonzero")
}
var retCode C.int
if exact {
retCode = C.seccomp_rule_add_exact_array(f.filterCtx, a... | go | {
"resource": ""
} |
q16270 | addRuleGeneric | train | func (f *ScmpFilter) addRuleGeneric(call ScmpSyscall, action ScmpAction, exact bool, conds []ScmpCondition) error {
f.lock.Lock()
defer f.lock.Unlock()
if !f.valid {
return errBadFilter
}
if len(conds) == 0 {
if err := f.addRuleWrapper(call, action, exact, 0, nil); err != nil {
return err
}
} else {
... | go | {
"resource": ""
} |
q16271 | sanitizeArch | train | func sanitizeArch(in ScmpArch) error {
if in < archStart || in > archEnd {
return fmt.Errorf("unrecognized architecture %#x", uint(in))
}
if in.toNative() == C.C_ARCH_BAD {
return fmt.Errorf("architecture %v is not supported on this version of the library", in)
}
return nil
} | go | {
"resource": ""
} |
q16272 | toNative | train | func (a ScmpCompareOp) toNative() C.int {
switch a {
case CompareNotEqual:
return C.C_CMP_NE
case CompareLess:
return C.C_CMP_LT
case CompareLessOrEqual:
return C.C_CMP_LE
case CompareEqual:
return C.C_CMP_EQ
case CompareGreaterEqual:
return C.C_CMP_GE
case CompareGreater:
return C.C_CMP_GT
case Com... | go | {
"resource": ""
} |
q16273 | toNative | train | func (a ScmpAction) toNative() C.uint32_t {
switch a & 0xFFFF {
case ActKill:
return C.C_ACT_KILL
case ActTrap:
return C.C_ACT_TRAP
case ActErrno:
return C.C_ACT_ERRNO | (C.uint32_t(a) >> 16)
case ActTrace:
return C.C_ACT_TRACE | (C.uint32_t(a) >> 16)
case ActLog:
return C.C_ACT_LOG
case ActAllow:
re... | go | {
"resource": ""
} |
q16274 | toNative | train | func (a scmpFilterAttr) toNative() uint32 {
switch a {
case filterAttrActDefault:
return uint32(C.C_ATTRIBUTE_DEFAULT)
case filterAttrActBadArch:
return uint32(C.C_ATTRIBUTE_BADARCH)
case filterAttrNNP:
return uint32(C.C_ATTRIBUTE_NNP)
case filterAttrTsync:
return uint32(C.C_ATTRIBUTE_TSYNC)
case filterAt... | go | {
"resource": ""
} |
q16275 | GetArchFromString | train | func GetArchFromString(arch string) (ScmpArch, error) {
if err := ensureSupportedVersion(); err != nil {
return ArchInvalid, err
}
switch strings.ToLower(arch) {
case "x86":
return ArchX86, nil
case "amd64", "x86-64", "x86_64", "x64":
return ArchAMD64, nil
case "x32":
return ArchX32, nil
case "arm":
r... | go | {
"resource": ""
} |
q16276 | String | train | func (a ScmpArch) String() string {
switch a {
case ArchX86:
return "x86"
case ArchAMD64:
return "amd64"
case ArchX32:
return "x32"
case ArchARM:
return "arm"
case ArchARM64:
return "arm64"
case ArchMIPS:
return "mips"
case ArchMIPS64:
return "mips64"
case ArchMIPS64N32:
return "mips64n32"
cas... | go | {
"resource": ""
} |
q16277 | String | train | func (a ScmpCompareOp) String() string {
switch a {
case CompareNotEqual:
return "Not equal"
case CompareLess:
return "Less than"
case CompareLessOrEqual:
return "Less than or equal to"
case CompareEqual:
return "Equal"
case CompareGreaterEqual:
return "Greater than or equal to"
case CompareGreater:
... | go | {
"resource": ""
} |
q16278 | String | train | func (a ScmpAction) String() string {
switch a & 0xFFFF {
case ActKill:
return "Action: Kill Process"
case ActTrap:
return "Action: Send SIGSYS"
case ActErrno:
return fmt.Sprintf("Action: Return error code %d", (a >> 16))
case ActTrace:
return fmt.Sprintf("Action: Notify tracing processes with code %d",
... | go | {
"resource": ""
} |
q16279 | SetReturnCode | train | func (a ScmpAction) SetReturnCode(code int16) ScmpAction {
aTmp := a & 0x0000FFFF
if aTmp == ActErrno || aTmp == ActTrace {
return (aTmp | (ScmpAction(code)&0xFFFF)<<16)
}
return a
} | go | {
"resource": ""
} |
q16280 | GetNameByArch | train | func (s ScmpSyscall) GetNameByArch(arch ScmpArch) (string, error) {
if err := sanitizeArch(arch); err != nil {
return "", err
}
cString := C.seccomp_syscall_resolve_num_arch(arch.toNative(), C.int(s))
if cString == nil {
return "", fmt.Errorf("could not resolve syscall name for %#x", int32(s))
}
defer C.free... | go | {
"resource": ""
} |
q16281 | GetSyscallFromName | train | func GetSyscallFromName(name string) (ScmpSyscall, error) {
if err := ensureSupportedVersion(); err != nil {
return 0, err
}
cString := C.CString(name)
defer C.free(unsafe.Pointer(cString))
result := C.seccomp_syscall_resolve_name(cString)
if result == scmpError {
return 0, fmt.Errorf("could not resolve nam... | go | {
"resource": ""
} |
q16282 | GetSyscallFromNameByArch | train | func GetSyscallFromNameByArch(name string, arch ScmpArch) (ScmpSyscall, error) {
if err := ensureSupportedVersion(); err != nil {
return 0, err
}
if err := sanitizeArch(arch); err != nil {
return 0, err
}
cString := C.CString(name)
defer C.free(unsafe.Pointer(cString))
result := C.seccomp_syscall_resolve_n... | go | {
"resource": ""
} |
q16283 | GetNativeArch | train | func GetNativeArch() (ScmpArch, error) {
if err := ensureSupportedVersion(); err != nil {
return ArchInvalid, err
}
arch := C.seccomp_arch_native()
return archFromNative(arch)
} | go | {
"resource": ""
} |
q16284 | NewFilter | train | func NewFilter(defaultAction ScmpAction) (*ScmpFilter, error) {
if err := ensureSupportedVersion(); err != nil {
return nil, err
}
if err := sanitizeAction(defaultAction); err != nil {
return nil, err
}
fPtr := C.seccomp_init(defaultAction.toNative())
if fPtr == nil {
return nil, fmt.Errorf("could not cre... | go | {
"resource": ""
} |
q16285 | Reset | train | func (f *ScmpFilter) Reset(defaultAction ScmpAction) error {
f.lock.Lock()
defer f.lock.Unlock()
if err := sanitizeAction(defaultAction); err != nil {
return err
} else if !f.valid {
return errBadFilter
}
retCode := C.seccomp_reset(f.filterCtx, defaultAction.toNative())
if retCode != 0 {
return syscall.E... | go | {
"resource": ""
} |
q16286 | AddArch | train | func (f *ScmpFilter) AddArch(arch ScmpArch) error {
f.lock.Lock()
defer f.lock.Unlock()
if err := sanitizeArch(arch); err != nil {
return err
} else if !f.valid {
return errBadFilter
}
// Libseccomp returns -EEXIST if the specified architecture is already
// present. Succeed silently in this case, as it's ... | go | {
"resource": ""
} |
q16287 | Load | train | func (f *ScmpFilter) Load() error {
f.lock.Lock()
defer f.lock.Unlock()
if !f.valid {
return errBadFilter
}
if retCode := C.seccomp_load(f.filterCtx); retCode != 0 {
return syscall.Errno(-1 * retCode)
}
return nil
} | go | {
"resource": ""
} |
q16288 | GetDefaultAction | train | func (f *ScmpFilter) GetDefaultAction() (ScmpAction, error) {
action, err := f.getFilterAttr(filterAttrActDefault)
if err != nil {
return 0x0, err
}
return actionFromNative(action)
} | go | {
"resource": ""
} |
q16289 | GetBadArchAction | train | func (f *ScmpFilter) GetBadArchAction() (ScmpAction, error) {
action, err := f.getFilterAttr(filterAttrActBadArch)
if err != nil {
return 0x0, err
}
return actionFromNative(action)
} | go | {
"resource": ""
} |
q16290 | GetLogBit | train | func (f *ScmpFilter) GetLogBit() (bool, error) {
log, err := f.getFilterAttr(filterAttrLog)
if err != nil {
api, apiErr := getApi()
if (apiErr != nil && api == 0) || (apiErr == nil && api < 3) {
return false, fmt.Errorf("getting the log bit is only supported in libseccomp 2.4.0 and newer with API level 3 or hi... | go | {
"resource": ""
} |
q16291 | SetBadArchAction | train | func (f *ScmpFilter) SetBadArchAction(action ScmpAction) error {
if err := sanitizeAction(action); err != nil {
return err
}
return f.setFilterAttr(filterAttrActBadArch, action.toNative())
} | go | {
"resource": ""
} |
q16292 | SetNoNewPrivsBit | train | func (f *ScmpFilter) SetNoNewPrivsBit(state bool) error {
var toSet C.uint32_t = 0x0
if state {
toSet = 0x1
}
return f.setFilterAttr(filterAttrNNP, toSet)
} | go | {
"resource": ""
} |
q16293 | SetLogBit | train | func (f *ScmpFilter) SetLogBit(state bool) error {
var toSet C.uint32_t = 0x0
if state {
toSet = 0x1
}
err := f.setFilterAttr(filterAttrLog, toSet)
if err != nil {
api, apiErr := getApi()
if (apiErr != nil && api == 0) || (apiErr == nil && api < 3) {
return fmt.Errorf("setting the log bit is only suppor... | go | {
"resource": ""
} |
q16294 | AddRule | train | func (f *ScmpFilter) AddRule(call ScmpSyscall, action ScmpAction) error {
return f.addRuleGeneric(call, action, false, nil)
} | go | {
"resource": ""
} |
q16295 | AddRuleConditional | train | func (f *ScmpFilter) AddRuleConditional(call ScmpSyscall, action ScmpAction, conds []ScmpCondition) error {
return f.addRuleGeneric(call, action, false, conds)
} | go | {
"resource": ""
} |
q16296 | check | train | func check(remoteip, response string) (r RecaptchaResponse, err error) {
resp, err := http.PostForm(recaptchaServerName,
url.Values{"secret": {recaptchaPrivateKey}, "remoteip": {remoteip}, "response": {response}})
if err != nil {
log.Printf("Post error: %s\n", err)
return
}
defer resp.Body.Close()
body, err ... | go | {
"resource": ""
} |
q16297 | Confirm | train | func Confirm(remoteip, response string) (result bool, err error) {
resp, err := check(remoteip, response)
result = resp.Success
return
} | go | {
"resource": ""
} |
q16298 | DecorateWithBasicAuth | train | func DecorateWithBasicAuth(next http.HandlerFunc, credentials *BasicAuthCredentials) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
user, password, ok := r.BasicAuth()
w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
if !ok || !(credentials.Password == password && user =... | go | {
"resource": ""
} |
q16299 | proxyRequest | train | func proxyRequest(w http.ResponseWriter, originalReq *http.Request, proxyClient http.Client, resolver BaseURLResolver) {
ctx := originalReq.Context()
pathVars := mux.Vars(originalReq)
functionName := pathVars["name"]
if functionName == "" {
writeError(w, http.StatusBadRequest, errMissingFunctionName)
return
}... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.