id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c14900 | {
l.print(level, fmt.Sprint(v...), l.NewLine)
} | |
c14901 | fmt.Sprintf(format, args...)
l.Error(msg)
} | |
c14902 | fmt.Sprintf(format, args...)
l.Warn(msg)
} | |
c14903 | fmt.Sprintf(format, args...)
l.Info(msg)
} | |
c14904 | doesn't allow debug logging.
if l.Level >= DebugLevel {
msg := fmt.Sprintf(format, args...)
l.Debug(msg)
}
} | |
c14905 |
l.handlers = append(l.handlers, handler)
l.mu.Unlock()
} | |
c14906 | *pio.Ctx)) {
l.Printer.Hijack(hijacker)
} | |
c14907 | l.Printer.MarshalFunc(func(v interface{}) ([]byte, error) {
var line []byte
if b, ok := v.([]byte); ok {
line = b
} else if s, ok := v.(string); ok {
line = []byte(s)
}
if len(line) == 0 {
return nil, pio.ErrMarshalNotResponsible
}
formattedTime := time.Now().Format(l.TimeFormat)
... | |
c14908 |
Printer: l.Printer,
handlers: l.handlers,
children: newLoggerMap(),
mu: sync.Mutex{},
once: sync.Once{},
}
} | |
c14909 |
return l.Time.Format(l.Logger.TimeFormat)
} | |
c14910 | = map[string]int{}
for i, v := range wordList {
wordMap[v] = i
}
} | |
c14911 | ok := wordMap[word]
return idx, ok
} | |
c14912 |
checksumMask := wordLengthChecksumMasksMapping[len(mnemonicSlice)]
checksum = checksum.And(b, checksumMask)
b.Div(b, big.NewInt(0).Add(checksumMask, bigOne))
// The entropy is the underlying bytes of the big.Int. Any upper bytes of
// all 0's are not returned so we pad the beginning of the slice with empty
// ... | |
c14913 |
for i := sentenceLength - 1; i >= 0; i-- {
// Get 11 right most bits and bitshift 11 to the right for next time.
word.And(entropyInt, last11BitsMask)
entropyInt.Div(entropyInt, shift11BitsMask)
// Get the bytes representing the 11 bits as a 2 byte slice.
wordBytes := padByteSlice(word.Bytes(), 2)
// Co... | |
c14914 | // correct.
checksumModulo := big.NewInt(0).Exp(bigTwo, big.NewInt(int64(checksumBitSize)), nil)
rawEntropy := big.NewInt(0).Div(checksummedEntropy, checksumModulo)
// Convert big.Ints to byte padded byte slices.
rawEntropyBytes := padByteSlice(rawEntropy.Bytes(), checksumByteSize)
checksummedEntropyBytes := pad... | |
c14915 | nil {
return nil, err
}
return NewSeed(mnemonic, password), nil
} | |
c14916 | pbkdf2.Key([]byte(mnemonic), []byte("mnemonic"+password), 2048, 64, sha512.New)
} | |
c14917 | of words should be 12, 15, 18, 21 or 24
if wordCount%3 != 0 || wordCount < 12 || wordCount > 24 {
return false
}
// Check if all words belong in the wordlist
for _, word := range words {
if _, ok := wordMap[word]; !ok {
return false
}
}
return true
} | |
c14918 | if offset <= 0 {
return slice
}
newSlice := make([]byte, length)
copy(newSlice[offset:], slice)
return newSlice
} | |
c14919 | mist.Message),
token: authtoken,
}
return client, client.connect()
} | |
c14920 | so attempt to execute the command.
go func() {
for {
msg := mist.Message{}
// decode an array value (Message)
if err := decoder.Decode(&msg); err != nil {
switch err {
case io.EOF:
lumber.Debug("[mist client] Mist terminated connection")
case io.ErrUnexpectedEOF:
lumber.Debug("[mist... | |
c14921 | c.encoder.Encode(&mist.Message{Command: "ping"})
} | |
c14922 | return c.encoder.Encode(&mist.Message{Command: "subscribe", Tags: tags})
} | |
c14923 | missing data")
}
return c.encoder.Encode(&mist.Message{Command: "publish", Tags: tags, Data: data})
} | |
c14924 | error {
go func() {
<-time.After(delay)
c.Publish(tags, data)
}()
return nil
} | |
c14925 | mist.Message{Command: "listall", Tags: msg.Tags, Data: subscriptions}
return nil
} | |
c14926 | <- mist.Message{Command: "who", Tags: msg.Tags, Data: subscribers}
return nil
} | |
c14927 | if !ok {
return nil, ErrTokenNotFound
}
return entry, nil
} | |
c14928 | listing subscriptions...")
p.RLock()
data = p.subscriptions.ToSlice()
p.RUnlock()
return
} | |
c14929 | servers[name] = auth
serversTex.Unlock()
} | |
c14930 |
sort.Strings(keys)
node.add(keys)
} | |
c14931 |
sort.Strings(keys)
node.remove(keys)
} | |
c14932 | bool {
sort.Strings(keys)
return node.match(keys)
} | |
c14933 | for each branch in the nodes list apppend the key to that key
for _, nodeKey := range nodeSlice {
list = append(list, append(nodeKey, branch))
}
}
// sort each list
for _, l := range list {
sort.Strings(l)
}
return
} | |
c14934 |
authTex.Lock()
authenticators[name] = auth
authTex.Unlock()
} | |
c14935 | err != nil {
return pg, err
}
if _, err = pg.exec(`
CREATE TABLE IF NOT EXISTS tags (
token_id integer NOT NULL REFERENCES tokens (token_id) ON DELETE CASCADE,
tag text NOT NULL,
PRIMARY KEY (token_id, tag)
)`); err != nil {
return pg, err
}
return pg, nil
} | |
c14936 | := a.connect()
if err != nil {
return nil, err
}
defer client.Close()
return client.Query(query, args...)
} | |
c14937 | := a.connect()
if err != nil {
return nil, err
}
defer client.Close()
return client.Exec(query, args...)
} | |
c14938 | slice it
subSlice := []string{}
for k, _ := range subs {
subSlice = append(subSlice, k)
}
return strings.Join(subSlice, " ")
} | |
c14939 | all clients subscribed to
for i := range subscribers {
subs = append(subs, fmt.Sprint(subscribers[i].id))
}
return len(subs), int(uid)
} | |
c14940 | and continue?
lumber.Error("Failed to PublishAfter - %s", err.Error())
}
}()
return nil
} | |
c14941 |
msg := Message{Command: "publish", Tags: tags, Data: data}
// we don't want this operation blocking the range of other subscribers
// waiting to get messages
go func(p *Proxy, msg Message) {
p.check <- msg
lumber.Trace("Published message")
}(subscriber, msg)
}
}
mutex.RUnlock()
}... | |
c14942 | mutex.Lock()
subscribers[p.id] = p
mutex.Unlock()
} | |
c14943 | mutex.Lock()
delete(subscribers, pid)
mutex.Unlock()
} | |
c14944 | }
// create a new scribble database at the specified location
db, err := scribbleDB.New(dir, nil)
if err != nil {
return nil, err
}
return &scribble{driver: db}, nil
} | |
c14945 | token, &entry); err != nil {
return entry, err
}
return entry, nil
} | |
c14946 | to start mist http listener - %s", err.Error())
}
} | |
c14947 | handleRequest(subscribe))
// Router.Get("/unsubscribe", handleRequest(unsubscribe))
return Router
} | |
c14948 | func(rw http.ResponseWriter, req *http.Request) {
fn(rw, req)
}
} | |
c14949 |
// Here, challenge the client to initiate the security context. The first
// request a client has made will often be unauthenticated, so we return a
// 401, which the client handles.
if !negotiate || inputToken.Length() == 0 {
AddSPNEGONegotiate(outHeader, challengeHeader, inputToken)
return "", challengeStatu... | |
c14950 |
if err != nil {
return nil, err
}
err = s.Add(oids...)
if err != nil {
return nil, err
}
return s, nil
} | |
c14951 |
var min C.OM_uint32
maj := C.wrap_gss_release_oid_set(s.Fp_gss_release_oid_set, &min, &s.C_gss_OID_set)
return s.stashLastStatus(maj, min)
} | |
c14952 | oid.C_gss_OID, &s.C_gss_OID_set)
err = s.stashLastStatus(maj, min)
if err != nil {
return err
}
}
return nil
} | |
c14953 | return int(s.C_gss_OID_set.count)
} | |
c14954 | oid.C_gss_OID = C.get_oid_set_member(s.C_gss_OID_set, C.int(index))
return oid, nil
} | |
c14955 | o.LoadDefault == Heimdal:
return appendOSExt("libgssapi")
}
return ""
} | |
c14956 |
// we don't use RTLD_FIRST, it might be the case that the GSSAPI lib
// delegates symbols to other libs it links against (eg, Kerberos)
lib.handle = C.dlopen(lib_cs, C.RTLD_NOW|C.RTLD_LOCAL)
if lib.handle == nil {
return nil, fmt.Errorf("%s", C.GoString(C.dlerror()))
}
err := lib.populateFunctions()
if err !... | |
c14957 | defer runtime.UnlockOSThread()
i := C.dlclose(lib.handle)
if i == -1 {
return fmt.Errorf("%s", C.GoString(C.dlerror()))
}
lib.handle = nil
return nil
} | |
c14958 | cfname := C.CString(f.Name[len(fpPrefix):])
v := C.dlsym(lib.handle, cfname)
C.free(unsafe.Pointer(cfname))
if v == nil {
return fmt.Errorf("%s", C.GoString(C.dlerror()))
}
// Save the value into the struct
functionsV.FieldByIndex([]int{i}).SetPointer(v)
}
return nil
} | |
c14959 | = &OID{Lib: lib, C_gss_OID: C._GSS_KRB5_NT_PRINCIPAL}
lib.GSS_MECH_KRB5 = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_KRB5}
lib.GSS_MECH_KRB5_LEGACY = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_KRB5_LEGACY}
lib.GSS_MECH_KRB5_OLD = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_KRB5_OLD}
lib.GSS_MECH_SPNEGO = &OID{Lib: lib, C_gss_OID... | |
c14960 | level >= Severity(len(lib.Printers)) {
return
}
lib.Printers[level].Print(a...)
} | |
c14961 | := C.wrap_gss_release_cred(c.Fp_gss_release_cred,
&min,
&c.C_gss_cred_id_t)
return c.stashLastStatus(maj, min)
} | |
c14962 | err != nil {
return nil, err
}
l := C.size_t(len(data))
c := C.malloc(l)
if b == nil {
return nil, ErrMallocFailed
}
C.memmove(c, (unsafe.Pointer)(&data[0]), l)
b.C_gss_buffer_t.length = l
b.C_gss_buffer_t.value = c
b.alloc = allocMalloc
return b, nil
} | |
c14963 | return lib.MakeBufferBytes([]byte(content))
} | |
c14964 |
case b.C_gss_buffer_t.value == nil:
// do nothing
case b.alloc == allocMalloc:
C.free(b.C_gss_buffer_t.value)
case b.alloc == allocGSSAPI:
var min C.OM_uint32
maj := C.wrap_gss_release_buffer(b.Fp_gss_release_buffer, &min, b.C_gss_buffer_t)
err := b.stashLastStatus(maj, min)
if err != nil {
return ... | |
c14965 | return 0
}
return int(b.C_gss_buffer_t.length)
} | |
c14966 | }
return C.GoBytes(b.C_gss_buffer_t.value, C.int(b.C_gss_buffer_t.length))
} | |
c14967 |
return C.GoStringN((*C.char)(b.C_gss_buffer_t.value), C.int(b.C_gss_buffer_t.length))
} | |
c14968 | other.C_gss_buffer_t)
return isEqual != 0
} | |
c14969 |
return nil, ErrMallocFailed
}
C.memmove(e, (unsafe.Pointer)(&data[0]), l)
oid.C_gss_OID = C.gss_OID(s)
oid.alloc = allocMalloc
// because of the alignment issues I can't access o.oid's fields from go,
// so invoking a C function to do the same as:
// oid.C_gss_OID.length = l
// oid.C_gss_OID.elements = c
... | |
c14970 | return lib.MakeOIDBytes([]byte(data))
} | |
c14971 |
C.helper_gss_OID_desc_free_elements(oid.C_gss_OID)
C.free(unsafe.Pointer(oid.C_gss_OID))
oid.C_gss_OID = nil
oid.alloc = allocNone
}
return nil
} | |
c14972 | &l, &p)
return C.GoBytes(unsafe.Pointer(p), C.int(l))
} | |
c14973 |
return fmt.Sprintf(`%x`, C.GoStringN(p, C.int(l)))
} | |
c14974 |
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_KRB5_LEGACY.Bytes()):
return "GSS_MECH_KRB5_LEGACY"
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_KRB5_OLD.Bytes()):
return "GSS_MECH_KRB5_OLD"
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_SPNEGO.Bytes()):
return "GSS_MECH_SPNEGO"
case bytes.Equal(oid.Bytes(), oid.GSS_ME... | |
c14975 | as both in and out param
C_acceptorCredHandle,
C_inputToken,
C.gss_channel_bindings_t(inputChanBindings),
&srcName.C_gss_name_t,
&actualMechType.C_gss_OID,
outputToken.C_gss_buffer_t,
&flags,
&timerec,
&delegatedCredHandle.C_gss_cred_id_t)
err = lib.stashLastStatus(maj, min)
if err != nil {
lib.... | |
c14976 | != nil {
ctx.Err("InquireContext: ", err)
return nil, nil, 0, nil, 0, false, false, err
}
lifetimeRec = time.Duration(rec) * time.Second
ctxFlags = uint64(flags)
if li != 0 {
locallyInitiated = true
}
if opn != 0 {
open = true
}
return srcName, targetName, lifetimeRec, mechType, ctxFlags, locallyIni... | |
c14977 |
v = v + " " + base64.StdEncoding.EncodeToString(data)
}
h.Set(name, v)
} | |
c14978 | // Pad to a multiple of 4 chars for base64 (some servers strip trailing padding)
if unpaddedChars := len(normalizedToken) % 4; unpaddedChars != 0 {
normalizedToken += strings.Repeat("=", 4-unpaddedChars)
}
tbytes, err := base64.StdEncoding.DecodeString(normalizedToken)
if err != nil {
continue
}
i... | |
c14979 | := C.wrap_gss_release_name(n.Fp_gss_release_name, &min, &n.C_gss_name_t)
err := n.stashLastStatus(maj, min)
if err == nil {
n.C_gss_name_t = nil
}
return err
} | |
c14980 |
oid = n.NewOID()
maj := C.wrap_gss_display_name(n.Fp_gss_display_name, &min,
n.C_gss_name_t, b.C_gss_buffer_t, &oid.C_gss_OID)
err = n.stashLastStatus(maj, min)
if err != nil {
oid.Release()
return "", nil, err
}
return b.String(), oid, err
} | |
c14981 | mech_type.C_gss_OID, &canonical.C_gss_name_t)
err = n.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return canonical, nil
} | |
c14982 | n.C_gss_name_t, &oidset.C_gss_OID_set)
err = n.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return oidset, nil
} | |
c14983 | &oidset.C_gss_OID_set)
err = lib.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return oidset, nil
} | |
c14984 | lib,
Major: MajorStatus(major),
Minor: minor,
}
} | |
c14985 | e.MakeError(maj, min).GoError()
if err != nil {
nOther = nOther + 1
}
messages = append(messages, b.String())
b.Release()
}
if nOther > 0 {
messages = append(messages, fmt.Sprintf("additionally, %d conversions failed", nOther))
}
messages = append(messages, "")
return strings.Join(messages, "\n")
} | |
c14986 | w,
map[nodeKey]nodeID{nilKey: 0},
map[nodeKey]string{nilKey: "nil"},
2,
}
fmt.Fprintln(w, "digraph structs {")
fmt.Fprintln(w, " node [shape=Mrecord];")
for _, iVal := range iVals {
m.mapValue(iVal, 0, false)
}
fmt.Fprintln(w, "}")
} | |
c14987 |
return &operatorNode{nodeType: nodeOperator, Op: op, Left: left, Right: right}
} | |
c14988 | nodeType: nodeAxis,
LocalName: localName,
Prefix: prefix,
AxeType: axeTyp,
Prop: prop,
Input: n,
}
} | |
c14989 | nodeVariable, Name: name, Prefix: prefix}
} | |
c14990 | &filterNode{nodeType: nodeFilter, Input: n, Condition: m}
} | |
c14991 | Prefix: prefix, FuncName: name, Args: args}
} | |
c14992 | too complex(depth > 200)")
}
n = p.parseOrExpr(n)
p.d--
return n
} | |
c14993 |
r.nextChar()
r.nextItem()
p := &parser{r: r}
return p.parseExpression(nil)
} | |
c14994 | ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
} | |
c14995 | ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
} | |
c14996 | := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "=", m, n)
} | |
c14997 | ""
predicate := func(n NodeNavigator) bool {
if typ == n.NodeType() || typ == allNode || typ == TextNode {
if nametest {
if root.LocalName == n.LocalName() && root.Prefix == n.Prefix() {
return true
}
} else {
return true
}
}
return false
}
return predicate
} | |
c14998 | if err != nil {
return nil, err
}
qyOutput := &filterQuery{Input: qyInput, Predicate: qyCond}
return qyOutput, nil
} | |
c14999 | = x
default:
err = errors.New("unknown panic")
}
}
}()
root := parse(expr)
b := &builder{}
return b.processNode(root)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.