id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
14,900 |
kataras/golog
|
logger.go
|
Log
|
func (l *Logger) Log(level Level, v ...interface{}) {
l.print(level, fmt.Sprint(v...), l.NewLine)
}
|
go
|
func (l *Logger) Log(level Level, v ...interface{}) {
l.print(level, fmt.Sprint(v...), l.NewLine)
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Log",
"(",
"level",
"Level",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"print",
"(",
"level",
",",
"fmt",
".",
"Sprint",
"(",
"v",
"...",
")",
",",
"l",
".",
"NewLine",
")",
"\n",
"}"
] |
// Log prints a leveled log message to the output.
// This method can be used to use custom log levels if needed.
// It adds a new line in the end.
|
[
"Log",
"prints",
"a",
"leveled",
"log",
"message",
"to",
"the",
"output",
".",
"This",
"method",
"can",
"be",
"used",
"to",
"use",
"custom",
"log",
"levels",
"if",
"needed",
".",
"It",
"adds",
"a",
"new",
"line",
"in",
"the",
"end",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L237-L239
|
14,901 |
kataras/golog
|
logger.go
|
Errorf
|
func (l *Logger) Errorf(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
l.Error(msg)
}
|
go
|
func (l *Logger) Errorf(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
l.Error(msg)
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Errorf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"l",
".",
"Error",
"(",
"msg",
")",
"\n",
"}"
] |
// Errorf will print only when logger's Level is error, warn, info or debug.
|
[
"Errorf",
"will",
"print",
"only",
"when",
"logger",
"s",
"Level",
"is",
"error",
"warn",
"info",
"or",
"debug",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L270-L273
|
14,902 |
kataras/golog
|
logger.go
|
Warnf
|
func (l *Logger) Warnf(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
l.Warn(msg)
}
|
go
|
func (l *Logger) Warnf(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
l.Warn(msg)
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Warnf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"l",
".",
"Warn",
"(",
"msg",
")",
"\n",
"}"
] |
// Warnf will print when logger's Level is warn, info or debug.
|
[
"Warnf",
"will",
"print",
"when",
"logger",
"s",
"Level",
"is",
"warn",
"info",
"or",
"debug",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L281-L284
|
14,903 |
kataras/golog
|
logger.go
|
Infof
|
func (l *Logger) Infof(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
l.Info(msg)
}
|
go
|
func (l *Logger) Infof(format string, args ...interface{}) {
msg := fmt.Sprintf(format, args...)
l.Info(msg)
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Infof",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"l",
".",
"Info",
"(",
"msg",
")",
"\n",
"}"
] |
// Infof will print when logger's Level is info or debug.
|
[
"Infof",
"will",
"print",
"when",
"logger",
"s",
"Level",
"is",
"info",
"or",
"debug",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L292-L295
|
14,904 |
kataras/golog
|
logger.go
|
Debugf
|
func (l *Logger) Debugf(format string, args ...interface{}) {
// On debug mode don't even try to fmt.Sprintf if it's not required,
// this can be used to allow `Debugf` to be called without even the `fmt.Sprintf`'s
// performance cost if the logger doesn't allow debug logging.
if l.Level >= DebugLevel {
msg := fmt.Sprintf(format, args...)
l.Debug(msg)
}
}
|
go
|
func (l *Logger) Debugf(format string, args ...interface{}) {
// On debug mode don't even try to fmt.Sprintf if it's not required,
// this can be used to allow `Debugf` to be called without even the `fmt.Sprintf`'s
// performance cost if the logger doesn't allow debug logging.
if l.Level >= DebugLevel {
msg := fmt.Sprintf(format, args...)
l.Debug(msg)
}
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Debugf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"// On debug mode don't even try to fmt.Sprintf if it's not required,",
"// this can be used to allow `Debugf` to be called without even the `fmt.Sprintf`'s",
"// performance cost if the logger doesn't allow debug logging.",
"if",
"l",
".",
"Level",
">=",
"DebugLevel",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"l",
".",
"Debug",
"(",
"msg",
")",
"\n",
"}",
"\n",
"}"
] |
// Debugf will print when logger's Level is debug.
|
[
"Debugf",
"will",
"print",
"when",
"logger",
"s",
"Level",
"is",
"debug",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L303-L311
|
14,905 |
kataras/golog
|
logger.go
|
Handle
|
func (l *Logger) Handle(handler Handler) {
l.mu.Lock()
l.handlers = append(l.handlers, handler)
l.mu.Unlock()
}
|
go
|
func (l *Logger) Handle(handler Handler) {
l.mu.Lock()
l.handlers = append(l.handlers, handler)
l.mu.Unlock()
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Handle",
"(",
"handler",
"Handler",
")",
"{",
"l",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"l",
".",
"handlers",
"=",
"append",
"(",
"l",
".",
"handlers",
",",
"handler",
")",
"\n",
"l",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Handle adds a log handler.
//
// Handlers can be used to intercept the message between a log value
// and the actual print operation, it's called
// when one of the print functions called.
// If it's return value is true then it means that the specific
// handler handled the log by itself therefore no need to
// proceed with the default behavior of printing the log
// to the specified logger's output.
//
// It stops on the handler which returns true firstly.
// The `Log` value holds the level of the print operation as well.
|
[
"Handle",
"adds",
"a",
"log",
"handler",
".",
"Handlers",
"can",
"be",
"used",
"to",
"intercept",
"the",
"message",
"between",
"a",
"log",
"value",
"and",
"the",
"actual",
"print",
"operation",
"it",
"s",
"called",
"when",
"one",
"of",
"the",
"print",
"functions",
"called",
".",
"If",
"it",
"s",
"return",
"value",
"is",
"true",
"then",
"it",
"means",
"that",
"the",
"specific",
"handler",
"handled",
"the",
"log",
"by",
"itself",
"therefore",
"no",
"need",
"to",
"proceed",
"with",
"the",
"default",
"behavior",
"of",
"printing",
"the",
"log",
"to",
"the",
"specified",
"logger",
"s",
"output",
".",
"It",
"stops",
"on",
"the",
"handler",
"which",
"returns",
"true",
"firstly",
".",
"The",
"Log",
"value",
"holds",
"the",
"level",
"of",
"the",
"print",
"operation",
"as",
"well",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L356-L360
|
14,906 |
kataras/golog
|
logger.go
|
Hijack
|
func (l *Logger) Hijack(hijacker func(ctx *pio.Ctx)) {
l.Printer.Hijack(hijacker)
}
|
go
|
func (l *Logger) Hijack(hijacker func(ctx *pio.Ctx)) {
l.Printer.Hijack(hijacker)
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Hijack",
"(",
"hijacker",
"func",
"(",
"ctx",
"*",
"pio",
".",
"Ctx",
")",
")",
"{",
"l",
".",
"Printer",
".",
"Hijack",
"(",
"hijacker",
")",
"\n",
"}"
] |
// Hijack adds a hijacker to the low-level logger's Printer.
// If you need to implement such as a low-level hijacker manually,
// then you have to make use of the pio library.
|
[
"Hijack",
"adds",
"a",
"hijacker",
"to",
"the",
"low",
"-",
"level",
"logger",
"s",
"Printer",
".",
"If",
"you",
"need",
"to",
"implement",
"such",
"as",
"a",
"low",
"-",
"level",
"hijacker",
"manually",
"then",
"you",
"have",
"to",
"make",
"use",
"of",
"the",
"pio",
"library",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L374-L376
|
14,907 |
kataras/golog
|
logger.go
|
Scan
|
func (l *Logger) Scan(r io.Reader) (cancel func()) {
l.once.Do(func() {
// add a marshaler once
// in order to handle []byte and string
// as its input.
// Because scan doesn't care about
// logging levels (because of the io.Reader)
// Note: We don't use the `pio.Text` built'n marshaler
// because we want to manage time log too.
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)
if formattedTime != "" {
line = append([]byte(formattedTime+" "), line...)
}
return line, nil
})
})
return l.Printer.Scan(r, true)
}
|
go
|
func (l *Logger) Scan(r io.Reader) (cancel func()) {
l.once.Do(func() {
// add a marshaler once
// in order to handle []byte and string
// as its input.
// Because scan doesn't care about
// logging levels (because of the io.Reader)
// Note: We don't use the `pio.Text` built'n marshaler
// because we want to manage time log too.
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)
if formattedTime != "" {
line = append([]byte(formattedTime+" "), line...)
}
return line, nil
})
})
return l.Printer.Scan(r, true)
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Scan",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"cancel",
"func",
"(",
")",
")",
"{",
"l",
".",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"// add a marshaler once",
"// in order to handle []byte and string",
"// as its input.",
"// Because scan doesn't care about",
"// logging levels (because of the io.Reader)",
"// Note: We don't use the `pio.Text` built'n marshaler",
"// because we want to manage time log too.",
"l",
".",
"Printer",
".",
"MarshalFunc",
"(",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"line",
"[",
"]",
"byte",
"\n",
"if",
"b",
",",
"ok",
":=",
"v",
".",
"(",
"[",
"]",
"byte",
")",
";",
"ok",
"{",
"line",
"=",
"b",
"\n",
"}",
"else",
"if",
"s",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
";",
"ok",
"{",
"line",
"=",
"[",
"]",
"byte",
"(",
"s",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"line",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"pio",
".",
"ErrMarshalNotResponsible",
"\n",
"}",
"\n\n",
"formattedTime",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Format",
"(",
"l",
".",
"TimeFormat",
")",
"\n",
"if",
"formattedTime",
"!=",
"\"",
"\"",
"{",
"line",
"=",
"append",
"(",
"[",
"]",
"byte",
"(",
"formattedTime",
"+",
"\"",
"\"",
")",
",",
"line",
"...",
")",
"\n",
"}",
"\n\n",
"return",
"line",
",",
"nil",
"\n",
"}",
")",
"\n",
"}",
")",
"\n\n",
"return",
"l",
".",
"Printer",
".",
"Scan",
"(",
"r",
",",
"true",
")",
"\n",
"}"
] |
// Scan scans everything from "r" and prints
// its new contents to the logger's Printer's Output,
// forever or until the returning "cancel" is fired, once.
|
[
"Scan",
"scans",
"everything",
"from",
"r",
"and",
"prints",
"its",
"new",
"contents",
"to",
"the",
"logger",
"s",
"Printer",
"s",
"Output",
"forever",
"or",
"until",
"the",
"returning",
"cancel",
"is",
"fired",
"once",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L381-L412
|
14,908 |
kataras/golog
|
logger.go
|
Clone
|
func (l *Logger) Clone() *Logger {
return &Logger{
Prefix: l.Prefix,
Level: l.Level,
TimeFormat: l.TimeFormat,
Printer: l.Printer,
handlers: l.handlers,
children: newLoggerMap(),
mu: sync.Mutex{},
once: sync.Once{},
}
}
|
go
|
func (l *Logger) Clone() *Logger {
return &Logger{
Prefix: l.Prefix,
Level: l.Level,
TimeFormat: l.TimeFormat,
Printer: l.Printer,
handlers: l.handlers,
children: newLoggerMap(),
mu: sync.Mutex{},
once: sync.Once{},
}
}
|
[
"func",
"(",
"l",
"*",
"Logger",
")",
"Clone",
"(",
")",
"*",
"Logger",
"{",
"return",
"&",
"Logger",
"{",
"Prefix",
":",
"l",
".",
"Prefix",
",",
"Level",
":",
"l",
".",
"Level",
",",
"TimeFormat",
":",
"l",
".",
"TimeFormat",
",",
"Printer",
":",
"l",
".",
"Printer",
",",
"handlers",
":",
"l",
".",
"handlers",
",",
"children",
":",
"newLoggerMap",
"(",
")",
",",
"mu",
":",
"sync",
".",
"Mutex",
"{",
"}",
",",
"once",
":",
"sync",
".",
"Once",
"{",
"}",
",",
"}",
"\n",
"}"
] |
// Clone returns a copy of this "l" Logger.
// This copy is returned as pointer as well.
|
[
"Clone",
"returns",
"a",
"copy",
"of",
"this",
"l",
"Logger",
".",
"This",
"copy",
"is",
"returned",
"as",
"pointer",
"as",
"well",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/logger.go#L416-L427
|
14,909 |
kataras/golog
|
log.go
|
FormatTime
|
func (l Log) FormatTime() string {
if l.Logger.TimeFormat == "" {
return ""
}
return l.Time.Format(l.Logger.TimeFormat)
}
|
go
|
func (l Log) FormatTime() string {
if l.Logger.TimeFormat == "" {
return ""
}
return l.Time.Format(l.Logger.TimeFormat)
}
|
[
"func",
"(",
"l",
"Log",
")",
"FormatTime",
"(",
")",
"string",
"{",
"if",
"l",
".",
"Logger",
".",
"TimeFormat",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"l",
".",
"Time",
".",
"Format",
"(",
"l",
".",
"Logger",
".",
"TimeFormat",
")",
"\n",
"}"
] |
// FormatTime returns the formatted `Time`.
|
[
"FormatTime",
"returns",
"the",
"formatted",
"Time",
"."
] |
03be101463868edc5a81f094fc68a5f6c1b5503a
|
https://github.com/kataras/golog/blob/03be101463868edc5a81f094fc68a5f6c1b5503a/log.go#L28-L33
|
14,910 |
tyler-smith/go-bip39
|
bip39.go
|
SetWordList
|
func SetWordList(list []string) {
wordList = list
wordMap = map[string]int{}
for i, v := range wordList {
wordMap[v] = i
}
}
|
go
|
func SetWordList(list []string) {
wordList = list
wordMap = map[string]int{}
for i, v := range wordList {
wordMap[v] = i
}
}
|
[
"func",
"SetWordList",
"(",
"list",
"[",
"]",
"string",
")",
"{",
"wordList",
"=",
"list",
"\n",
"wordMap",
"=",
"map",
"[",
"string",
"]",
"int",
"{",
"}",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"wordList",
"{",
"wordMap",
"[",
"v",
"]",
"=",
"i",
"\n",
"}",
"\n",
"}"
] |
// SetWordList sets the list of words to use for mnemonics. Currently the list
// that is set is used package-wide.
|
[
"SetWordList",
"sets",
"the",
"list",
"of",
"words",
"to",
"use",
"for",
"mnemonics",
".",
"Currently",
"the",
"list",
"that",
"is",
"set",
"is",
"used",
"package",
"-",
"wide",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L76-L82
|
14,911 |
tyler-smith/go-bip39
|
bip39.go
|
GetWordIndex
|
func GetWordIndex(word string) (int, bool) {
idx, ok := wordMap[word]
return idx, ok
}
|
go
|
func GetWordIndex(word string) (int, bool) {
idx, ok := wordMap[word]
return idx, ok
}
|
[
"func",
"GetWordIndex",
"(",
"word",
"string",
")",
"(",
"int",
",",
"bool",
")",
"{",
"idx",
",",
"ok",
":=",
"wordMap",
"[",
"word",
"]",
"\n",
"return",
"idx",
",",
"ok",
"\n",
"}"
] |
// GetWordIndex gets word index in wordMap.
|
[
"GetWordIndex",
"gets",
"word",
"index",
"in",
"wordMap",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L90-L93
|
14,912 |
tyler-smith/go-bip39
|
bip39.go
|
EntropyFromMnemonic
|
func EntropyFromMnemonic(mnemonic string) ([]byte, error) {
mnemonicSlice, isValid := splitMnemonicWords(mnemonic)
if !isValid {
return nil, ErrInvalidMnemonic
}
// Decode the words into a big.Int.
b := big.NewInt(0)
for _, v := range mnemonicSlice {
index, found := wordMap[v]
if found == false {
return nil, fmt.Errorf("word `%v` not found in reverse map", v)
}
var wordBytes [2]byte
binary.BigEndian.PutUint16(wordBytes[:], uint16(index))
b = b.Mul(b, shift11BitsMask)
b = b.Or(b, big.NewInt(0).SetBytes(wordBytes[:]))
}
// Build and add the checksum to the big.Int.
checksum := big.NewInt(0)
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
// bytes if necessary.
entropy := b.Bytes()
entropy = padByteSlice(entropy, len(mnemonicSlice)/3*4)
// Generate the checksum and compare with the one we got from the mneomnic.
entropyChecksumBytes := computeChecksum(entropy)
entropyChecksum := big.NewInt(int64(entropyChecksumBytes[0]))
if l := len(mnemonicSlice); l != 24 {
checksumShift := wordLengthChecksumShiftMapping[l]
entropyChecksum.Div(entropyChecksum, checksumShift)
}
if checksum.Cmp(entropyChecksum) != 0 {
return nil, ErrChecksumIncorrect
}
return entropy, nil
}
|
go
|
func EntropyFromMnemonic(mnemonic string) ([]byte, error) {
mnemonicSlice, isValid := splitMnemonicWords(mnemonic)
if !isValid {
return nil, ErrInvalidMnemonic
}
// Decode the words into a big.Int.
b := big.NewInt(0)
for _, v := range mnemonicSlice {
index, found := wordMap[v]
if found == false {
return nil, fmt.Errorf("word `%v` not found in reverse map", v)
}
var wordBytes [2]byte
binary.BigEndian.PutUint16(wordBytes[:], uint16(index))
b = b.Mul(b, shift11BitsMask)
b = b.Or(b, big.NewInt(0).SetBytes(wordBytes[:]))
}
// Build and add the checksum to the big.Int.
checksum := big.NewInt(0)
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
// bytes if necessary.
entropy := b.Bytes()
entropy = padByteSlice(entropy, len(mnemonicSlice)/3*4)
// Generate the checksum and compare with the one we got from the mneomnic.
entropyChecksumBytes := computeChecksum(entropy)
entropyChecksum := big.NewInt(int64(entropyChecksumBytes[0]))
if l := len(mnemonicSlice); l != 24 {
checksumShift := wordLengthChecksumShiftMapping[l]
entropyChecksum.Div(entropyChecksum, checksumShift)
}
if checksum.Cmp(entropyChecksum) != 0 {
return nil, ErrChecksumIncorrect
}
return entropy, nil
}
|
[
"func",
"EntropyFromMnemonic",
"(",
"mnemonic",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"mnemonicSlice",
",",
"isValid",
":=",
"splitMnemonicWords",
"(",
"mnemonic",
")",
"\n",
"if",
"!",
"isValid",
"{",
"return",
"nil",
",",
"ErrInvalidMnemonic",
"\n",
"}",
"\n\n",
"// Decode the words into a big.Int.",
"b",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"mnemonicSlice",
"{",
"index",
",",
"found",
":=",
"wordMap",
"[",
"v",
"]",
"\n",
"if",
"found",
"==",
"false",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}",
"\n",
"var",
"wordBytes",
"[",
"2",
"]",
"byte",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"wordBytes",
"[",
":",
"]",
",",
"uint16",
"(",
"index",
")",
")",
"\n",
"b",
"=",
"b",
".",
"Mul",
"(",
"b",
",",
"shift11BitsMask",
")",
"\n",
"b",
"=",
"b",
".",
"Or",
"(",
"b",
",",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"SetBytes",
"(",
"wordBytes",
"[",
":",
"]",
")",
")",
"\n",
"}",
"\n\n",
"// Build and add the checksum to the big.Int.",
"checksum",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"checksumMask",
":=",
"wordLengthChecksumMasksMapping",
"[",
"len",
"(",
"mnemonicSlice",
")",
"]",
"\n",
"checksum",
"=",
"checksum",
".",
"And",
"(",
"b",
",",
"checksumMask",
")",
"\n\n",
"b",
".",
"Div",
"(",
"b",
",",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Add",
"(",
"checksumMask",
",",
"bigOne",
")",
")",
"\n\n",
"// 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",
"// bytes if necessary.",
"entropy",
":=",
"b",
".",
"Bytes",
"(",
")",
"\n",
"entropy",
"=",
"padByteSlice",
"(",
"entropy",
",",
"len",
"(",
"mnemonicSlice",
")",
"/",
"3",
"*",
"4",
")",
"\n\n",
"// Generate the checksum and compare with the one we got from the mneomnic.",
"entropyChecksumBytes",
":=",
"computeChecksum",
"(",
"entropy",
")",
"\n",
"entropyChecksum",
":=",
"big",
".",
"NewInt",
"(",
"int64",
"(",
"entropyChecksumBytes",
"[",
"0",
"]",
")",
")",
"\n",
"if",
"l",
":=",
"len",
"(",
"mnemonicSlice",
")",
";",
"l",
"!=",
"24",
"{",
"checksumShift",
":=",
"wordLengthChecksumShiftMapping",
"[",
"l",
"]",
"\n",
"entropyChecksum",
".",
"Div",
"(",
"entropyChecksum",
",",
"checksumShift",
")",
"\n",
"}",
"\n\n",
"if",
"checksum",
".",
"Cmp",
"(",
"entropyChecksum",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"ErrChecksumIncorrect",
"\n",
"}",
"\n\n",
"return",
"entropy",
",",
"nil",
"\n",
"}"
] |
// EntropyFromMnemonic takes a mnemonic generated by this library,
// and returns the input entropy used to generate the given mnemonic.
// An error is returned if the given mnemonic is invalid.
|
[
"EntropyFromMnemonic",
"takes",
"a",
"mnemonic",
"generated",
"by",
"this",
"library",
"and",
"returns",
"the",
"input",
"entropy",
"used",
"to",
"generate",
"the",
"given",
"mnemonic",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"given",
"mnemonic",
"is",
"invalid",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L113-L158
|
14,913 |
tyler-smith/go-bip39
|
bip39.go
|
NewMnemonic
|
func NewMnemonic(entropy []byte) (string, error) {
// Compute some lengths for convenience.
entropyBitLength := len(entropy) * 8
checksumBitLength := entropyBitLength / 32
sentenceLength := (entropyBitLength + checksumBitLength) / 11
// Validate that the requested size is supported.
err := validateEntropyBitSize(entropyBitLength)
if err != nil {
return "", err
}
// Add checksum to entropy.
entropy = addChecksum(entropy)
// Break entropy up into sentenceLength chunks of 11 bits.
// For each word AND mask the rightmost 11 bits and find the word at that index.
// Then bitshift entropy 11 bits right and repeat.
// Add to the last empty slot so we can work with LSBs instead of MSB.
// Entropy as an int so we can bitmask without worrying about bytes slices.
entropyInt := new(big.Int).SetBytes(entropy)
// Slice to hold words in.
words := make([]string, sentenceLength)
// Throw away big.Int for AND masking.
word := big.NewInt(0)
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)
// Convert bytes to an index and add that word to the list.
words[i] = wordList[binary.BigEndian.Uint16(wordBytes)]
}
return strings.Join(words, " "), nil
}
|
go
|
func NewMnemonic(entropy []byte) (string, error) {
// Compute some lengths for convenience.
entropyBitLength := len(entropy) * 8
checksumBitLength := entropyBitLength / 32
sentenceLength := (entropyBitLength + checksumBitLength) / 11
// Validate that the requested size is supported.
err := validateEntropyBitSize(entropyBitLength)
if err != nil {
return "", err
}
// Add checksum to entropy.
entropy = addChecksum(entropy)
// Break entropy up into sentenceLength chunks of 11 bits.
// For each word AND mask the rightmost 11 bits and find the word at that index.
// Then bitshift entropy 11 bits right and repeat.
// Add to the last empty slot so we can work with LSBs instead of MSB.
// Entropy as an int so we can bitmask without worrying about bytes slices.
entropyInt := new(big.Int).SetBytes(entropy)
// Slice to hold words in.
words := make([]string, sentenceLength)
// Throw away big.Int for AND masking.
word := big.NewInt(0)
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)
// Convert bytes to an index and add that word to the list.
words[i] = wordList[binary.BigEndian.Uint16(wordBytes)]
}
return strings.Join(words, " "), nil
}
|
[
"func",
"NewMnemonic",
"(",
"entropy",
"[",
"]",
"byte",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Compute some lengths for convenience.",
"entropyBitLength",
":=",
"len",
"(",
"entropy",
")",
"*",
"8",
"\n",
"checksumBitLength",
":=",
"entropyBitLength",
"/",
"32",
"\n",
"sentenceLength",
":=",
"(",
"entropyBitLength",
"+",
"checksumBitLength",
")",
"/",
"11",
"\n\n",
"// Validate that the requested size is supported.",
"err",
":=",
"validateEntropyBitSize",
"(",
"entropyBitLength",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"// Add checksum to entropy.",
"entropy",
"=",
"addChecksum",
"(",
"entropy",
")",
"\n\n",
"// Break entropy up into sentenceLength chunks of 11 bits.",
"// For each word AND mask the rightmost 11 bits and find the word at that index.",
"// Then bitshift entropy 11 bits right and repeat.",
"// Add to the last empty slot so we can work with LSBs instead of MSB.",
"// Entropy as an int so we can bitmask without worrying about bytes slices.",
"entropyInt",
":=",
"new",
"(",
"big",
".",
"Int",
")",
".",
"SetBytes",
"(",
"entropy",
")",
"\n\n",
"// Slice to hold words in.",
"words",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"sentenceLength",
")",
"\n\n",
"// Throw away big.Int for AND masking.",
"word",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n\n",
"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",
")",
"\n",
"entropyInt",
".",
"Div",
"(",
"entropyInt",
",",
"shift11BitsMask",
")",
"\n\n",
"// Get the bytes representing the 11 bits as a 2 byte slice.",
"wordBytes",
":=",
"padByteSlice",
"(",
"word",
".",
"Bytes",
"(",
")",
",",
"2",
")",
"\n\n",
"// Convert bytes to an index and add that word to the list.",
"words",
"[",
"i",
"]",
"=",
"wordList",
"[",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"wordBytes",
")",
"]",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"words",
",",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] |
// NewMnemonic will return a string consisting of the mnemonic words for
// the given entropy.
// If the provide entropy is invalid, an error will be returned.
|
[
"NewMnemonic",
"will",
"return",
"a",
"string",
"consisting",
"of",
"the",
"mnemonic",
"words",
"for",
"the",
"given",
"entropy",
".",
"If",
"the",
"provide",
"entropy",
"is",
"invalid",
"an",
"error",
"will",
"be",
"returned",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L163-L205
|
14,914 |
tyler-smith/go-bip39
|
bip39.go
|
MnemonicToByteArray
|
func MnemonicToByteArray(mnemonic string, raw ...bool) ([]byte, error) {
var (
mnemonicSlice = strings.Split(mnemonic, " ")
entropyBitSize = len(mnemonicSlice) * 11
checksumBitSize = entropyBitSize % 32
fullByteSize = (entropyBitSize-checksumBitSize)/8 + 1
checksumByteSize = fullByteSize - (fullByteSize % 4)
)
// Pre validate that the mnemonic is well formed and only contains words that
// are present in the word list.
if !IsMnemonicValid(mnemonic) {
return nil, ErrInvalidMnemonic
}
// Convert word indices to a big.Int representing the entropy.
checksummedEntropy := big.NewInt(0)
modulo := big.NewInt(2048)
for _, v := range mnemonicSlice {
index := big.NewInt(int64(wordMap[v]))
checksummedEntropy.Mul(checksummedEntropy, modulo)
checksummedEntropy.Add(checksummedEntropy, index)
}
// Calculate the unchecksummed entropy so we can validate that the checksum is
// 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 := padByteSlice(checksummedEntropy.Bytes(), fullByteSize)
// Validate that the checksum is correct.
newChecksummedEntropyBytes := padByteSlice(addChecksum(rawEntropyBytes), fullByteSize)
if !compareByteSlices(checksummedEntropyBytes, newChecksummedEntropyBytes) {
return nil, ErrChecksumIncorrect
}
if len(raw) > 0 && raw[0] {
return rawEntropyBytes, nil
}
return checksummedEntropyBytes, nil
}
|
go
|
func MnemonicToByteArray(mnemonic string, raw ...bool) ([]byte, error) {
var (
mnemonicSlice = strings.Split(mnemonic, " ")
entropyBitSize = len(mnemonicSlice) * 11
checksumBitSize = entropyBitSize % 32
fullByteSize = (entropyBitSize-checksumBitSize)/8 + 1
checksumByteSize = fullByteSize - (fullByteSize % 4)
)
// Pre validate that the mnemonic is well formed and only contains words that
// are present in the word list.
if !IsMnemonicValid(mnemonic) {
return nil, ErrInvalidMnemonic
}
// Convert word indices to a big.Int representing the entropy.
checksummedEntropy := big.NewInt(0)
modulo := big.NewInt(2048)
for _, v := range mnemonicSlice {
index := big.NewInt(int64(wordMap[v]))
checksummedEntropy.Mul(checksummedEntropy, modulo)
checksummedEntropy.Add(checksummedEntropy, index)
}
// Calculate the unchecksummed entropy so we can validate that the checksum is
// 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 := padByteSlice(checksummedEntropy.Bytes(), fullByteSize)
// Validate that the checksum is correct.
newChecksummedEntropyBytes := padByteSlice(addChecksum(rawEntropyBytes), fullByteSize)
if !compareByteSlices(checksummedEntropyBytes, newChecksummedEntropyBytes) {
return nil, ErrChecksumIncorrect
}
if len(raw) > 0 && raw[0] {
return rawEntropyBytes, nil
}
return checksummedEntropyBytes, nil
}
|
[
"func",
"MnemonicToByteArray",
"(",
"mnemonic",
"string",
",",
"raw",
"...",
"bool",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"mnemonicSlice",
"=",
"strings",
".",
"Split",
"(",
"mnemonic",
",",
"\"",
"\"",
")",
"\n",
"entropyBitSize",
"=",
"len",
"(",
"mnemonicSlice",
")",
"*",
"11",
"\n",
"checksumBitSize",
"=",
"entropyBitSize",
"%",
"32",
"\n",
"fullByteSize",
"=",
"(",
"entropyBitSize",
"-",
"checksumBitSize",
")",
"/",
"8",
"+",
"1",
"\n",
"checksumByteSize",
"=",
"fullByteSize",
"-",
"(",
"fullByteSize",
"%",
"4",
")",
"\n",
")",
"\n\n",
"// Pre validate that the mnemonic is well formed and only contains words that",
"// are present in the word list.",
"if",
"!",
"IsMnemonicValid",
"(",
"mnemonic",
")",
"{",
"return",
"nil",
",",
"ErrInvalidMnemonic",
"\n",
"}",
"\n\n",
"// Convert word indices to a big.Int representing the entropy.",
"checksummedEntropy",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
"\n",
"modulo",
":=",
"big",
".",
"NewInt",
"(",
"2048",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"mnemonicSlice",
"{",
"index",
":=",
"big",
".",
"NewInt",
"(",
"int64",
"(",
"wordMap",
"[",
"v",
"]",
")",
")",
"\n",
"checksummedEntropy",
".",
"Mul",
"(",
"checksummedEntropy",
",",
"modulo",
")",
"\n",
"checksummedEntropy",
".",
"Add",
"(",
"checksummedEntropy",
",",
"index",
")",
"\n",
"}",
"\n\n",
"// Calculate the unchecksummed entropy so we can validate that the checksum is",
"// correct.",
"checksumModulo",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Exp",
"(",
"bigTwo",
",",
"big",
".",
"NewInt",
"(",
"int64",
"(",
"checksumBitSize",
")",
")",
",",
"nil",
")",
"\n",
"rawEntropy",
":=",
"big",
".",
"NewInt",
"(",
"0",
")",
".",
"Div",
"(",
"checksummedEntropy",
",",
"checksumModulo",
")",
"\n\n",
"// Convert big.Ints to byte padded byte slices.",
"rawEntropyBytes",
":=",
"padByteSlice",
"(",
"rawEntropy",
".",
"Bytes",
"(",
")",
",",
"checksumByteSize",
")",
"\n",
"checksummedEntropyBytes",
":=",
"padByteSlice",
"(",
"checksummedEntropy",
".",
"Bytes",
"(",
")",
",",
"fullByteSize",
")",
"\n\n",
"// Validate that the checksum is correct.",
"newChecksummedEntropyBytes",
":=",
"padByteSlice",
"(",
"addChecksum",
"(",
"rawEntropyBytes",
")",
",",
"fullByteSize",
")",
"\n",
"if",
"!",
"compareByteSlices",
"(",
"checksummedEntropyBytes",
",",
"newChecksummedEntropyBytes",
")",
"{",
"return",
"nil",
",",
"ErrChecksumIncorrect",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"raw",
")",
">",
"0",
"&&",
"raw",
"[",
"0",
"]",
"{",
"return",
"rawEntropyBytes",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"checksummedEntropyBytes",
",",
"nil",
"\n",
"}"
] |
// MnemonicToByteArray takes a mnemonic string and turns it into a byte array
// suitable for creating another mnemonic.
// An error is returned if the mnemonic is invalid.
|
[
"MnemonicToByteArray",
"takes",
"a",
"mnemonic",
"string",
"and",
"turns",
"it",
"into",
"a",
"byte",
"array",
"suitable",
"for",
"creating",
"another",
"mnemonic",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"mnemonic",
"is",
"invalid",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L210-L254
|
14,915 |
tyler-smith/go-bip39
|
bip39.go
|
NewSeedWithErrorChecking
|
func NewSeedWithErrorChecking(mnemonic string, password string) ([]byte, error) {
_, err := MnemonicToByteArray(mnemonic)
if err != nil {
return nil, err
}
return NewSeed(mnemonic, password), nil
}
|
go
|
func NewSeedWithErrorChecking(mnemonic string, password string) ([]byte, error) {
_, err := MnemonicToByteArray(mnemonic)
if err != nil {
return nil, err
}
return NewSeed(mnemonic, password), nil
}
|
[
"func",
"NewSeedWithErrorChecking",
"(",
"mnemonic",
"string",
",",
"password",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"MnemonicToByteArray",
"(",
"mnemonic",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewSeed",
"(",
"mnemonic",
",",
"password",
")",
",",
"nil",
"\n",
"}"
] |
// NewSeedWithErrorChecking creates a hashed seed output given the mnemonic string and a password.
// An error is returned if the mnemonic is not convertible to a byte array.
|
[
"NewSeedWithErrorChecking",
"creates",
"a",
"hashed",
"seed",
"output",
"given",
"the",
"mnemonic",
"string",
"and",
"a",
"password",
".",
"An",
"error",
"is",
"returned",
"if",
"the",
"mnemonic",
"is",
"not",
"convertible",
"to",
"a",
"byte",
"array",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L258-L264
|
14,916 |
tyler-smith/go-bip39
|
bip39.go
|
NewSeed
|
func NewSeed(mnemonic string, password string) []byte {
return pbkdf2.Key([]byte(mnemonic), []byte("mnemonic"+password), 2048, 64, sha512.New)
}
|
go
|
func NewSeed(mnemonic string, password string) []byte {
return pbkdf2.Key([]byte(mnemonic), []byte("mnemonic"+password), 2048, 64, sha512.New)
}
|
[
"func",
"NewSeed",
"(",
"mnemonic",
"string",
",",
"password",
"string",
")",
"[",
"]",
"byte",
"{",
"return",
"pbkdf2",
".",
"Key",
"(",
"[",
"]",
"byte",
"(",
"mnemonic",
")",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
"+",
"password",
")",
",",
"2048",
",",
"64",
",",
"sha512",
".",
"New",
")",
"\n",
"}"
] |
// NewSeed creates a hashed seed output given a provided string and password.
// No checking is performed to validate that the string provided is a valid mnemonic.
|
[
"NewSeed",
"creates",
"a",
"hashed",
"seed",
"output",
"given",
"a",
"provided",
"string",
"and",
"password",
".",
"No",
"checking",
"is",
"performed",
"to",
"validate",
"that",
"the",
"string",
"provided",
"is",
"a",
"valid",
"mnemonic",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L268-L270
|
14,917 |
tyler-smith/go-bip39
|
bip39.go
|
IsMnemonicValid
|
func IsMnemonicValid(mnemonic string) bool {
// Create a list of all the words in the mnemonic sentence
words := strings.Fields(mnemonic)
// Get word count
wordCount := len(words)
// The number 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
}
|
go
|
func IsMnemonicValid(mnemonic string) bool {
// Create a list of all the words in the mnemonic sentence
words := strings.Fields(mnemonic)
// Get word count
wordCount := len(words)
// The number 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
}
|
[
"func",
"IsMnemonicValid",
"(",
"mnemonic",
"string",
")",
"bool",
"{",
"// Create a list of all the words in the mnemonic sentence",
"words",
":=",
"strings",
".",
"Fields",
"(",
"mnemonic",
")",
"\n\n",
"// Get word count",
"wordCount",
":=",
"len",
"(",
"words",
")",
"\n\n",
"// The number of words should be 12, 15, 18, 21 or 24",
"if",
"wordCount",
"%",
"3",
"!=",
"0",
"||",
"wordCount",
"<",
"12",
"||",
"wordCount",
">",
"24",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// Check if all words belong in the wordlist",
"for",
"_",
",",
"word",
":=",
"range",
"words",
"{",
"if",
"_",
",",
"ok",
":=",
"wordMap",
"[",
"word",
"]",
";",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// IsMnemonicValid attempts to verify that the provided mnemonic is valid.
// Validity is determined by both the number of words being appropriate,
// and that all the words in the mnemonic are present in the word list.
|
[
"IsMnemonicValid",
"attempts",
"to",
"verify",
"that",
"the",
"provided",
"mnemonic",
"is",
"valid",
".",
"Validity",
"is",
"determined",
"by",
"both",
"the",
"number",
"of",
"words",
"being",
"appropriate",
"and",
"that",
"all",
"the",
"words",
"in",
"the",
"mnemonic",
"are",
"present",
"in",
"the",
"word",
"list",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L275-L295
|
14,918 |
tyler-smith/go-bip39
|
bip39.go
|
padByteSlice
|
func padByteSlice(slice []byte, length int) []byte {
offset := length - len(slice)
if offset <= 0 {
return slice
}
newSlice := make([]byte, length)
copy(newSlice[offset:], slice)
return newSlice
}
|
go
|
func padByteSlice(slice []byte, length int) []byte {
offset := length - len(slice)
if offset <= 0 {
return slice
}
newSlice := make([]byte, length)
copy(newSlice[offset:], slice)
return newSlice
}
|
[
"func",
"padByteSlice",
"(",
"slice",
"[",
"]",
"byte",
",",
"length",
"int",
")",
"[",
"]",
"byte",
"{",
"offset",
":=",
"length",
"-",
"len",
"(",
"slice",
")",
"\n",
"if",
"offset",
"<=",
"0",
"{",
"return",
"slice",
"\n",
"}",
"\n",
"newSlice",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"length",
")",
"\n",
"copy",
"(",
"newSlice",
"[",
"offset",
":",
"]",
",",
"slice",
")",
"\n",
"return",
"newSlice",
"\n",
"}"
] |
// padByteSlice returns a byte slice of the given size with contents of the
// given slice left padded and any empty spaces filled with 0's.
|
[
"padByteSlice",
"returns",
"a",
"byte",
"slice",
"of",
"the",
"given",
"size",
"with",
"contents",
"of",
"the",
"given",
"slice",
"left",
"padded",
"and",
"any",
"empty",
"spaces",
"filled",
"with",
"0",
"s",
"."
] |
dbb3b84ba2ef14e894f5e33d6c6e43641e665738
|
https://github.com/tyler-smith/go-bip39/blob/dbb3b84ba2ef14e894f5e33d6c6e43641e665738/bip39.go#L341-L349
|
14,919 |
nanopack/mist
|
clients/clients.go
|
New
|
func New(host, authtoken string) (*TCP, error) {
client := &TCP{
host: host,
messages: make(chan mist.Message),
token: authtoken,
}
return client, client.connect()
}
|
go
|
func New(host, authtoken string) (*TCP, error) {
client := &TCP{
host: host,
messages: make(chan mist.Message),
token: authtoken,
}
return client, client.connect()
}
|
[
"func",
"New",
"(",
"host",
",",
"authtoken",
"string",
")",
"(",
"*",
"TCP",
",",
"error",
")",
"{",
"client",
":=",
"&",
"TCP",
"{",
"host",
":",
"host",
",",
"messages",
":",
"make",
"(",
"chan",
"mist",
".",
"Message",
")",
",",
"token",
":",
"authtoken",
",",
"}",
"\n\n",
"return",
"client",
",",
"client",
".",
"connect",
"(",
")",
"\n",
"}"
] |
// New attempts to connect to a running mist server at the clients specified
// host and port.
|
[
"New",
"attempts",
"to",
"connect",
"to",
"a",
"running",
"mist",
"server",
"at",
"the",
"clients",
"specified",
"host",
"and",
"port",
"."
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/clients/clients.go#L28-L36
|
14,920 |
nanopack/mist
|
clients/clients.go
|
connect
|
func (c *TCP) connect() error {
// attempt to connect to the server
conn, err := net.Dial("tcp", c.host)
if err != nil {
return fmt.Errorf("Failed to dial '%s' - %s", c.host, err.Error())
}
// set the connection for the client
c.conn = conn
// create a new json encoder for the clients connection
c.encoder = json.NewEncoder(c.conn)
// if the client was created with a token, authentication is needed
if c.token != "" {
err = c.encoder.Encode(&mist.Message{Command: "auth", Data: c.token})
if err != nil {
return fmt.Errorf("Failed to send auth - %s", err.Error())
}
}
// ensure we are authorized/still connected (unauthorized clients get disconnected)
c.Ping()
decoder := json.NewDecoder(conn)
msg := mist.Message{}
if err := decoder.Decode(&msg); err != nil {
conn.Close()
close(c.messages)
return fmt.Errorf("Ping failed, possibly bad token, or can't read from mist - %s", err.Error())
}
// connection loop (blocking); continually read off the connection. Once something
// is read, check to see if it's a message the client understands to be one of
// its commands. If 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 client] Mist terminated connection unexpectedly")
default:
lumber.Error("[mist client] Failed to get message from mist - %s", err.Error())
}
conn.Close()
close(c.messages)
return
}
c.messages <- msg // read from this using the .Messages() function
lumber.Trace("[mist client] Received message - %#v", msg)
}
}()
return nil
}
|
go
|
func (c *TCP) connect() error {
// attempt to connect to the server
conn, err := net.Dial("tcp", c.host)
if err != nil {
return fmt.Errorf("Failed to dial '%s' - %s", c.host, err.Error())
}
// set the connection for the client
c.conn = conn
// create a new json encoder for the clients connection
c.encoder = json.NewEncoder(c.conn)
// if the client was created with a token, authentication is needed
if c.token != "" {
err = c.encoder.Encode(&mist.Message{Command: "auth", Data: c.token})
if err != nil {
return fmt.Errorf("Failed to send auth - %s", err.Error())
}
}
// ensure we are authorized/still connected (unauthorized clients get disconnected)
c.Ping()
decoder := json.NewDecoder(conn)
msg := mist.Message{}
if err := decoder.Decode(&msg); err != nil {
conn.Close()
close(c.messages)
return fmt.Errorf("Ping failed, possibly bad token, or can't read from mist - %s", err.Error())
}
// connection loop (blocking); continually read off the connection. Once something
// is read, check to see if it's a message the client understands to be one of
// its commands. If 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 client] Mist terminated connection unexpectedly")
default:
lumber.Error("[mist client] Failed to get message from mist - %s", err.Error())
}
conn.Close()
close(c.messages)
return
}
c.messages <- msg // read from this using the .Messages() function
lumber.Trace("[mist client] Received message - %#v", msg)
}
}()
return nil
}
|
[
"func",
"(",
"c",
"*",
"TCP",
")",
"connect",
"(",
")",
"error",
"{",
"// attempt to connect to the server",
"conn",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"c",
".",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
".",
"host",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// set the connection for the client",
"c",
".",
"conn",
"=",
"conn",
"\n\n",
"// create a new json encoder for the clients connection",
"c",
".",
"encoder",
"=",
"json",
".",
"NewEncoder",
"(",
"c",
".",
"conn",
")",
"\n\n",
"// if the client was created with a token, authentication is needed",
"if",
"c",
".",
"token",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"c",
".",
"encoder",
".",
"Encode",
"(",
"&",
"mist",
".",
"Message",
"{",
"Command",
":",
"\"",
"\"",
",",
"Data",
":",
"c",
".",
"token",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// ensure we are authorized/still connected (unauthorized clients get disconnected)",
"c",
".",
"Ping",
"(",
")",
"\n",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"conn",
")",
"\n",
"msg",
":=",
"mist",
".",
"Message",
"{",
"}",
"\n",
"if",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"&",
"msg",
")",
";",
"err",
"!=",
"nil",
"{",
"conn",
".",
"Close",
"(",
")",
"\n",
"close",
"(",
"c",
".",
"messages",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// connection loop (blocking); continually read off the connection. Once something",
"// is read, check to see if it's a message the client understands to be one of",
"// its commands. If so attempt to execute the command.",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"msg",
":=",
"mist",
".",
"Message",
"{",
"}",
"\n\n",
"// decode an array value (Message)",
"if",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"&",
"msg",
")",
";",
"err",
"!=",
"nil",
"{",
"switch",
"err",
"{",
"case",
"io",
".",
"EOF",
":",
"lumber",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"case",
"io",
".",
"ErrUnexpectedEOF",
":",
"lumber",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"lumber",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"close",
"(",
"c",
".",
"messages",
")",
"\n",
"return",
"\n",
"}",
"\n",
"c",
".",
"messages",
"<-",
"msg",
"// read from this using the .Messages() function",
"\n",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
",",
"msg",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// connect dials the remote mist server and handles any incoming responses back
// from mist
|
[
"connect",
"dials",
"the",
"remote",
"mist",
"server",
"and",
"handles",
"any",
"incoming",
"responses",
"back",
"from",
"mist"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/clients/clients.go#L40-L100
|
14,921 |
nanopack/mist
|
clients/clients.go
|
Ping
|
func (c *TCP) Ping() error {
return c.encoder.Encode(&mist.Message{Command: "ping"})
}
|
go
|
func (c *TCP) Ping() error {
return c.encoder.Encode(&mist.Message{Command: "ping"})
}
|
[
"func",
"(",
"c",
"*",
"TCP",
")",
"Ping",
"(",
")",
"error",
"{",
"return",
"c",
".",
"encoder",
".",
"Encode",
"(",
"&",
"mist",
".",
"Message",
"{",
"Command",
":",
"\"",
"\"",
"}",
")",
"\n",
"}"
] |
// Ping the server
|
[
"Ping",
"the",
"server"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/clients/clients.go#L103-L105
|
14,922 |
nanopack/mist
|
clients/clients.go
|
Subscribe
|
func (c *TCP) Subscribe(tags []string) error {
if len(tags) == 0 {
return fmt.Errorf("Unable to subscribe - missing tags")
}
return c.encoder.Encode(&mist.Message{Command: "subscribe", Tags: tags})
}
|
go
|
func (c *TCP) Subscribe(tags []string) error {
if len(tags) == 0 {
return fmt.Errorf("Unable to subscribe - missing tags")
}
return c.encoder.Encode(&mist.Message{Command: "subscribe", Tags: tags})
}
|
[
"func",
"(",
"c",
"*",
"TCP",
")",
"Subscribe",
"(",
"tags",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"tags",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"encoder",
".",
"Encode",
"(",
"&",
"mist",
".",
"Message",
"{",
"Command",
":",
"\"",
"\"",
",",
"Tags",
":",
"tags",
"}",
")",
"\n",
"}"
] |
// Subscribe takes the specified tags and tells the server to subscribe to updates
// on those tags, returning the tags and an error or nil
|
[
"Subscribe",
"takes",
"the",
"specified",
"tags",
"and",
"tells",
"the",
"server",
"to",
"subscribe",
"to",
"updates",
"on",
"those",
"tags",
"returning",
"the",
"tags",
"and",
"an",
"error",
"or",
"nil"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/clients/clients.go#L109-L116
|
14,923 |
nanopack/mist
|
clients/clients.go
|
Publish
|
func (c *TCP) Publish(tags []string, data string) error {
if len(tags) == 0 {
return fmt.Errorf("Unable to publish - missing tags")
}
if data == "" {
return fmt.Errorf("Unable to publish - missing data")
}
return c.encoder.Encode(&mist.Message{Command: "publish", Tags: tags, Data: data})
}
|
go
|
func (c *TCP) Publish(tags []string, data string) error {
if len(tags) == 0 {
return fmt.Errorf("Unable to publish - missing tags")
}
if data == "" {
return fmt.Errorf("Unable to publish - missing data")
}
return c.encoder.Encode(&mist.Message{Command: "publish", Tags: tags, Data: data})
}
|
[
"func",
"(",
"c",
"*",
"TCP",
")",
"Publish",
"(",
"tags",
"[",
"]",
"string",
",",
"data",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"tags",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"data",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"encoder",
".",
"Encode",
"(",
"&",
"mist",
".",
"Message",
"{",
"Command",
":",
"\"",
"\"",
",",
"Tags",
":",
"tags",
",",
"Data",
":",
"data",
"}",
")",
"\n",
"}"
] |
// Publish sends a message to the mist server to be published to all subscribed
// clients
|
[
"Publish",
"sends",
"a",
"message",
"to",
"the",
"mist",
"server",
"to",
"be",
"published",
"to",
"all",
"subscribed",
"clients"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/clients/clients.go#L131-L142
|
14,924 |
nanopack/mist
|
clients/clients.go
|
PublishAfter
|
func (c *TCP) PublishAfter(tags []string, data string, delay time.Duration) error {
go func() {
<-time.After(delay)
c.Publish(tags, data)
}()
return nil
}
|
go
|
func (c *TCP) PublishAfter(tags []string, data string, delay time.Duration) error {
go func() {
<-time.After(delay)
c.Publish(tags, data)
}()
return nil
}
|
[
"func",
"(",
"c",
"*",
"TCP",
")",
"PublishAfter",
"(",
"tags",
"[",
"]",
"string",
",",
"data",
"string",
",",
"delay",
"time",
".",
"Duration",
")",
"error",
"{",
"go",
"func",
"(",
")",
"{",
"<-",
"time",
".",
"After",
"(",
"delay",
")",
"\n",
"c",
".",
"Publish",
"(",
"tags",
",",
"data",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// PublishAfter sends a message to the mist server to be published to all subscribed
// clients after a specified delay
|
[
"PublishAfter",
"sends",
"a",
"message",
"to",
"the",
"mist",
"server",
"to",
"be",
"published",
"to",
"all",
"subscribed",
"clients",
"after",
"a",
"specified",
"delay"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/clients/clients.go#L146-L152
|
14,925 |
nanopack/mist
|
server/handlers.go
|
handleListAll
|
func handleListAll(proxy *mist.Proxy, msg mist.Message) error {
subscriptions := mist.Subscribers()
proxy.Pipe <- mist.Message{Command: "listall", Tags: msg.Tags, Data: subscriptions}
return nil
}
|
go
|
func handleListAll(proxy *mist.Proxy, msg mist.Message) error {
subscriptions := mist.Subscribers()
proxy.Pipe <- mist.Message{Command: "listall", Tags: msg.Tags, Data: subscriptions}
return nil
}
|
[
"func",
"handleListAll",
"(",
"proxy",
"*",
"mist",
".",
"Proxy",
",",
"msg",
"mist",
".",
"Message",
")",
"error",
"{",
"subscriptions",
":=",
"mist",
".",
"Subscribers",
"(",
")",
"\n",
"proxy",
".",
"Pipe",
"<-",
"mist",
".",
"Message",
"{",
"Command",
":",
"\"",
"\"",
",",
"Tags",
":",
"msg",
".",
"Tags",
",",
"Data",
":",
"subscriptions",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// handleListAll - listall related
|
[
"handleListAll",
"-",
"listall",
"related"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/server/handlers.go#L76-L80
|
14,926 |
nanopack/mist
|
server/handlers.go
|
handleWho
|
func handleWho(proxy *mist.Proxy, msg mist.Message) error {
who, max := mist.Who()
subscribers := fmt.Sprintf("Lifetime connections: %d\nSubscribers connected: %d", max, who)
proxy.Pipe <- mist.Message{Command: "who", Tags: msg.Tags, Data: subscribers}
return nil
}
|
go
|
func handleWho(proxy *mist.Proxy, msg mist.Message) error {
who, max := mist.Who()
subscribers := fmt.Sprintf("Lifetime connections: %d\nSubscribers connected: %d", max, who)
proxy.Pipe <- mist.Message{Command: "who", Tags: msg.Tags, Data: subscribers}
return nil
}
|
[
"func",
"handleWho",
"(",
"proxy",
"*",
"mist",
".",
"Proxy",
",",
"msg",
"mist",
".",
"Message",
")",
"error",
"{",
"who",
",",
"max",
":=",
"mist",
".",
"Who",
"(",
")",
"\n",
"subscribers",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"max",
",",
"who",
")",
"\n",
"proxy",
".",
"Pipe",
"<-",
"mist",
".",
"Message",
"{",
"Command",
":",
"\"",
"\"",
",",
"Tags",
":",
"msg",
".",
"Tags",
",",
"Data",
":",
"subscribers",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// handleWho - who related
|
[
"handleWho",
"-",
"who",
"related"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/server/handlers.go#L83-L88
|
14,927 |
nanopack/mist
|
auth/memory.go
|
findMemoryToken
|
func (a memory) findMemoryToken(token string) (mapset.Set, error) {
// look for existing token
entry, ok := a[token]
if !ok {
return nil, ErrTokenNotFound
}
return entry, nil
}
|
go
|
func (a memory) findMemoryToken(token string) (mapset.Set, error) {
// look for existing token
entry, ok := a[token]
if !ok {
return nil, ErrTokenNotFound
}
return entry, nil
}
|
[
"func",
"(",
"a",
"memory",
")",
"findMemoryToken",
"(",
"token",
"string",
")",
"(",
"mapset",
".",
"Set",
",",
"error",
")",
"{",
"// look for existing token",
"entry",
",",
"ok",
":=",
"a",
"[",
"token",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"ErrTokenNotFound",
"\n",
"}",
"\n\n",
"return",
"entry",
",",
"nil",
"\n",
"}"
] |
// findMemoryToken attempts to find the desired token within memory
|
[
"findMemoryToken",
"attempts",
"to",
"find",
"the",
"desired",
"token",
"within",
"memory"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/memory.go#L95-L104
|
14,928 |
nanopack/mist
|
core/proxy.go
|
List
|
func (p *Proxy) List() (data [][]string) {
lumber.Trace("Proxy listing subscriptions...")
p.RLock()
data = p.subscriptions.ToSlice()
p.RUnlock()
return
}
|
go
|
func (p *Proxy) List() (data [][]string) {
lumber.Trace("Proxy listing subscriptions...")
p.RLock()
data = p.subscriptions.ToSlice()
p.RUnlock()
return
}
|
[
"func",
"(",
"p",
"*",
"Proxy",
")",
"List",
"(",
")",
"(",
"data",
"[",
"]",
"[",
"]",
"string",
")",
"{",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
")",
"\n",
"p",
".",
"RLock",
"(",
")",
"\n",
"data",
"=",
"p",
".",
"subscriptions",
".",
"ToSlice",
"(",
")",
"\n",
"p",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"\n",
"}"
] |
// List returns a list of all current subscriptions
|
[
"List",
"returns",
"a",
"list",
"of",
"all",
"current",
"subscriptions"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/proxy.go#L134-L141
|
14,929 |
nanopack/mist
|
server/server.go
|
Register
|
func Register(name string, auth handleFunc) {
serversTex.Lock()
servers[name] = auth
serversTex.Unlock()
}
|
go
|
func Register(name string, auth handleFunc) {
serversTex.Lock()
servers[name] = auth
serversTex.Unlock()
}
|
[
"func",
"Register",
"(",
"name",
"string",
",",
"auth",
"handleFunc",
")",
"{",
"serversTex",
".",
"Lock",
"(",
")",
"\n",
"servers",
"[",
"name",
"]",
"=",
"auth",
"\n",
"serversTex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Register registers a new mist server
|
[
"Register",
"registers",
"a",
"new",
"mist",
"server"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/server/server.go#L29-L33
|
14,930 |
nanopack/mist
|
core/subscriptions.go
|
Add
|
func (node *Node) Add(keys []string) {
if len(keys) == 0 {
return
}
sort.Strings(keys)
node.add(keys)
}
|
go
|
func (node *Node) Add(keys []string) {
if len(keys) == 0 {
return
}
sort.Strings(keys)
node.add(keys)
}
|
[
"func",
"(",
"node",
"*",
"Node",
")",
"Add",
"(",
"keys",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n",
"node",
".",
"add",
"(",
"keys",
")",
"\n",
"}"
] |
// Add sorts the keys and then attempts to add them
|
[
"Add",
"sorts",
"the",
"keys",
"and",
"then",
"attempts",
"to",
"add",
"them"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/subscriptions.go#L34-L41
|
14,931 |
nanopack/mist
|
core/subscriptions.go
|
Remove
|
func (node *Node) Remove(keys []string) {
if len(keys) == 0 {
return
}
sort.Strings(keys)
node.remove(keys)
}
|
go
|
func (node *Node) Remove(keys []string) {
if len(keys) == 0 {
return
}
sort.Strings(keys)
node.remove(keys)
}
|
[
"func",
"(",
"node",
"*",
"Node",
")",
"Remove",
"(",
"keys",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n",
"node",
".",
"remove",
"(",
"keys",
")",
"\n",
"}"
] |
// Remove sorts the keys and then attempts to remove them
|
[
"Remove",
"sorts",
"the",
"keys",
"and",
"then",
"attempts",
"to",
"remove",
"them"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/subscriptions.go#L68-L76
|
14,932 |
nanopack/mist
|
core/subscriptions.go
|
Match
|
func (node *Node) Match(keys []string) bool {
sort.Strings(keys)
return node.match(keys)
}
|
go
|
func (node *Node) Match(keys []string) bool {
sort.Strings(keys)
return node.match(keys)
}
|
[
"func",
"(",
"node",
"*",
"Node",
")",
"Match",
"(",
"keys",
"[",
"]",
"string",
")",
"bool",
"{",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n",
"return",
"node",
".",
"match",
"(",
"keys",
")",
"\n",
"}"
] |
// Match sorts the keys and then attempts to find a match
|
[
"Match",
"sorts",
"the",
"keys",
"and",
"then",
"attempts",
"to",
"find",
"a",
"match"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/subscriptions.go#L107-L110
|
14,933 |
nanopack/mist
|
core/subscriptions.go
|
ToSlice
|
func (node *Node) ToSlice() (list [][]string) {
// iterate through each leaf appending it as a slice to the list of keys
for leaf := range node.leaves {
list = append(list, []string{leaf})
}
// iterate through each branch getting its list of branches and appending those
// to the list
for branch, node := range node.branches {
// get the current nodes slice of branches and leaves
nodeSlice := node.ToSlice()
// 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
}
|
go
|
func (node *Node) ToSlice() (list [][]string) {
// iterate through each leaf appending it as a slice to the list of keys
for leaf := range node.leaves {
list = append(list, []string{leaf})
}
// iterate through each branch getting its list of branches and appending those
// to the list
for branch, node := range node.branches {
// get the current nodes slice of branches and leaves
nodeSlice := node.ToSlice()
// 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
}
|
[
"func",
"(",
"node",
"*",
"Node",
")",
"ToSlice",
"(",
")",
"(",
"list",
"[",
"]",
"[",
"]",
"string",
")",
"{",
"// iterate through each leaf appending it as a slice to the list of keys",
"for",
"leaf",
":=",
"range",
"node",
".",
"leaves",
"{",
"list",
"=",
"append",
"(",
"list",
",",
"[",
"]",
"string",
"{",
"leaf",
"}",
")",
"\n",
"}",
"\n\n",
"// iterate through each branch getting its list of branches and appending those",
"// to the list",
"for",
"branch",
",",
"node",
":=",
"range",
"node",
".",
"branches",
"{",
"// get the current nodes slice of branches and leaves",
"nodeSlice",
":=",
"node",
".",
"ToSlice",
"(",
")",
"\n\n",
"// for each branch in the nodes list apppend the key to that key",
"for",
"_",
",",
"nodeKey",
":=",
"range",
"nodeSlice",
"{",
"list",
"=",
"append",
"(",
"list",
",",
"append",
"(",
"nodeKey",
",",
"branch",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// sort each list",
"for",
"_",
",",
"l",
":=",
"range",
"list",
"{",
"sort",
".",
"Strings",
"(",
"l",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// ToSlice recurses down an entire node returning a list of all branches and leaves
// as a slice of slices
|
[
"ToSlice",
"recurses",
"down",
"an",
"entire",
"node",
"returning",
"a",
"list",
"of",
"all",
"branches",
"and",
"leaves",
"as",
"a",
"slice",
"of",
"slices"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/subscriptions.go#L139-L164
|
14,934 |
nanopack/mist
|
auth/auth.go
|
Register
|
func Register(name string, auth handleFunc) {
authTex.Lock()
authenticators[name] = auth
authTex.Unlock()
}
|
go
|
func Register(name string, auth handleFunc) {
authTex.Lock()
authenticators[name] = auth
authTex.Unlock()
}
|
[
"func",
"Register",
"(",
"name",
"string",
",",
"auth",
"handleFunc",
")",
"{",
"authTex",
".",
"Lock",
"(",
")",
"\n",
"authenticators",
"[",
"name",
"]",
"=",
"auth",
"\n",
"authTex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Register registers a new mist authenticator
|
[
"Register",
"registers",
"a",
"new",
"mist",
"authenticator"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/auth.go#L41-L45
|
14,935 |
nanopack/mist
|
auth/postgresql.go
|
NewPostgres
|
func NewPostgres(url *url.URL) (Authenticator, error) {
host, port, err := net.SplitHostPort(url.Host)
db := url.Query().Get("db")
user := url.User.Username()
// pass, _ := url.User.Password()
pg := postgres(fmt.Sprintf("user=%s database=%s sslmode=disable host=%s port=%s", user, db, host, port))
// create the tables needed to support mist authentication
if _, err = pg.exec(`
CREATE TABLE IF NOT EXISTS tokens (
token text NOT NULL,
token_id SERIAL UNIQUE NOT NULL,
PRIMARY KEY (token)
)`); 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
}
|
go
|
func NewPostgres(url *url.URL) (Authenticator, error) {
host, port, err := net.SplitHostPort(url.Host)
db := url.Query().Get("db")
user := url.User.Username()
// pass, _ := url.User.Password()
pg := postgres(fmt.Sprintf("user=%s database=%s sslmode=disable host=%s port=%s", user, db, host, port))
// create the tables needed to support mist authentication
if _, err = pg.exec(`
CREATE TABLE IF NOT EXISTS tokens (
token text NOT NULL,
token_id SERIAL UNIQUE NOT NULL,
PRIMARY KEY (token)
)`); 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
}
|
[
"func",
"NewPostgres",
"(",
"url",
"*",
"url",
".",
"URL",
")",
"(",
"Authenticator",
",",
"error",
")",
"{",
"host",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"url",
".",
"Host",
")",
"\n",
"db",
":=",
"url",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"user",
":=",
"url",
".",
"User",
".",
"Username",
"(",
")",
"\n",
"// pass, _ := url.User.Password()",
"pg",
":=",
"postgres",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"user",
",",
"db",
",",
"host",
",",
"port",
")",
")",
"\n\n",
"// create the tables needed to support mist authentication",
"if",
"_",
",",
"err",
"=",
"pg",
".",
"exec",
"(",
"`\nCREATE TABLE IF NOT EXISTS tokens (\n\ttoken text NOT NULL,\n\ttoken_id SERIAL UNIQUE NOT NULL,\n\tPRIMARY KEY (token)\n)`",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"pg",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"pg",
".",
"exec",
"(",
"`\nCREATE TABLE IF NOT EXISTS tags (\n token_id integer NOT NULL REFERENCES tokens (token_id) ON DELETE CASCADE,\n tag text NOT NULL,\n PRIMARY KEY (token_id, tag)\n)`",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"pg",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"pg",
",",
"nil",
"\n",
"}"
] |
// NewPostgres creates a new "postgres" Authenticator
|
[
"NewPostgres",
"creates",
"a",
"new",
"postgres",
"Authenticator"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/postgresql.go#L24-L53
|
14,936 |
nanopack/mist
|
auth/postgresql.go
|
query
|
func (a postgres) query(query string, args ...interface{}) (*sql.Rows, error) {
client, err := a.connect()
if err != nil {
return nil, err
}
defer client.Close()
return client.Query(query, args...)
}
|
go
|
func (a postgres) query(query string, args ...interface{}) (*sql.Rows, error) {
client, err := a.connect()
if err != nil {
return nil, err
}
defer client.Close()
return client.Query(query, args...)
}
|
[
"func",
"(",
"a",
"postgres",
")",
"query",
"(",
"query",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"sql",
".",
"Rows",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"a",
".",
"connect",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n\n",
"return",
"client",
".",
"Query",
"(",
"query",
",",
"args",
"...",
")",
"\n",
"}"
] |
// this could really be optimized a lot. instead of opening a new conenction for
// each query, it should reuse connections
|
[
"this",
"could",
"really",
"be",
"optimized",
"a",
"lot",
".",
"instead",
"of",
"opening",
"a",
"new",
"conenction",
"for",
"each",
"query",
"it",
"should",
"reuse",
"connections"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/postgresql.go#L121-L129
|
14,937 |
nanopack/mist
|
auth/postgresql.go
|
exec
|
func (a postgres) exec(query string, args ...interface{}) (sql.Result, error) {
client, err := a.connect()
if err != nil {
return nil, err
}
defer client.Close()
return client.Exec(query, args...)
}
|
go
|
func (a postgres) exec(query string, args ...interface{}) (sql.Result, error) {
client, err := a.connect()
if err != nil {
return nil, err
}
defer client.Close()
return client.Exec(query, args...)
}
|
[
"func",
"(",
"a",
"postgres",
")",
"exec",
"(",
"query",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"sql",
".",
"Result",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"a",
".",
"connect",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n\n",
"return",
"client",
".",
"Exec",
"(",
"query",
",",
"args",
"...",
")",
"\n",
"}"
] |
// This could also be optimized a lot
|
[
"This",
"could",
"also",
"be",
"optimized",
"a",
"lot"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/postgresql.go#L132-L140
|
14,938 |
nanopack/mist
|
core/mist.go
|
Subscribers
|
func Subscribers() string {
subs := make(map[string]bool) // no duplicates
// get tags all clients subscribed to
for i := range subscribers {
s := subscribers[i].subscriptions.ToSlice()
for j := range s {
for k := range s[j] {
subs[s[j][k]] = true
}
}
}
// slice it
subSlice := []string{}
for k, _ := range subs {
subSlice = append(subSlice, k)
}
return strings.Join(subSlice, " ")
}
|
go
|
func Subscribers() string {
subs := make(map[string]bool) // no duplicates
// get tags all clients subscribed to
for i := range subscribers {
s := subscribers[i].subscriptions.ToSlice()
for j := range s {
for k := range s[j] {
subs[s[j][k]] = true
}
}
}
// slice it
subSlice := []string{}
for k, _ := range subs {
subSlice = append(subSlice, k)
}
return strings.Join(subSlice, " ")
}
|
[
"func",
"Subscribers",
"(",
")",
"string",
"{",
"subs",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"// no duplicates",
"\n\n",
"// get tags all clients subscribed to",
"for",
"i",
":=",
"range",
"subscribers",
"{",
"s",
":=",
"subscribers",
"[",
"i",
"]",
".",
"subscriptions",
".",
"ToSlice",
"(",
")",
"\n",
"for",
"j",
":=",
"range",
"s",
"{",
"for",
"k",
":=",
"range",
"s",
"[",
"j",
"]",
"{",
"subs",
"[",
"s",
"[",
"j",
"]",
"[",
"k",
"]",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// slice it",
"subSlice",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"k",
",",
"_",
":=",
"range",
"subs",
"{",
"subSlice",
"=",
"append",
"(",
"subSlice",
",",
"k",
")",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"subSlice",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Subscribers is listall related
|
[
"Subscribers",
"is",
"listall",
"related"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/mist.go#L34-L54
|
14,939 |
nanopack/mist
|
core/mist.go
|
Who
|
func Who() (int, int) {
// subs := make(map[string]bool) // no duplicates
subs := []string{}
// get tags all clients subscribed to
for i := range subscribers {
subs = append(subs, fmt.Sprint(subscribers[i].id))
}
return len(subs), int(uid)
}
|
go
|
func Who() (int, int) {
// subs := make(map[string]bool) // no duplicates
subs := []string{}
// get tags all clients subscribed to
for i := range subscribers {
subs = append(subs, fmt.Sprint(subscribers[i].id))
}
return len(subs), int(uid)
}
|
[
"func",
"Who",
"(",
")",
"(",
"int",
",",
"int",
")",
"{",
"// subs := make(map[string]bool) // no duplicates",
"subs",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"// get tags all clients subscribed to",
"for",
"i",
":=",
"range",
"subscribers",
"{",
"subs",
"=",
"append",
"(",
"subs",
",",
"fmt",
".",
"Sprint",
"(",
"subscribers",
"[",
"i",
"]",
".",
"id",
")",
")",
"\n",
"}",
"\n\n",
"return",
"len",
"(",
"subs",
")",
",",
"int",
"(",
"uid",
")",
"\n",
"}"
] |
// Who is who related
|
[
"Who",
"is",
"who",
"related"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/mist.go#L57-L67
|
14,940 |
nanopack/mist
|
core/mist.go
|
PublishAfter
|
func PublishAfter(tags []string, data string, delay time.Duration) error {
go func() {
<-time.After(delay)
if err := Publish(tags, data); err != nil {
// log this error and continue?
lumber.Error("Failed to PublishAfter - %s", err.Error())
}
}()
return nil
}
|
go
|
func PublishAfter(tags []string, data string, delay time.Duration) error {
go func() {
<-time.After(delay)
if err := Publish(tags, data); err != nil {
// log this error and continue?
lumber.Error("Failed to PublishAfter - %s", err.Error())
}
}()
return nil
}
|
[
"func",
"PublishAfter",
"(",
"tags",
"[",
"]",
"string",
",",
"data",
"string",
",",
"delay",
"time",
".",
"Duration",
")",
"error",
"{",
"go",
"func",
"(",
")",
"{",
"<-",
"time",
".",
"After",
"(",
"delay",
")",
"\n",
"if",
"err",
":=",
"Publish",
"(",
"tags",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"// log this error and continue?",
"lumber",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// PublishAfter publishes to ALL subscribers. Usefull in client applications
// who reuse the publish connection for subscribing
|
[
"PublishAfter",
"publishes",
"to",
"ALL",
"subscribers",
".",
"Usefull",
"in",
"client",
"applications",
"who",
"reuse",
"the",
"publish",
"connection",
"for",
"subscribing"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/mist.go#L81-L91
|
14,941 |
nanopack/mist
|
core/mist.go
|
publish
|
func publish(pid uint32, tags []string, data string) error {
if len(tags) == 0 {
return fmt.Errorf("Failed to publish. Missing tags")
}
// if there are no subscribers, the message goes nowhere
//
// this could be more optimized, but it might not be an issue unless thousands
// of clients are using mist.
go func() {
mutex.RLock()
for _, subscriber := range subscribers {
select {
case <-subscriber.done:
lumber.Trace("Subscriber done")
// do nothing?
default:
// dont send this message to the publisher who just sent it
if subscriber.id == pid {
lumber.Trace("Subscriber is publisher, skipping publish")
continue
}
// create message
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()
}()
return nil
}
|
go
|
func publish(pid uint32, tags []string, data string) error {
if len(tags) == 0 {
return fmt.Errorf("Failed to publish. Missing tags")
}
// if there are no subscribers, the message goes nowhere
//
// this could be more optimized, but it might not be an issue unless thousands
// of clients are using mist.
go func() {
mutex.RLock()
for _, subscriber := range subscribers {
select {
case <-subscriber.done:
lumber.Trace("Subscriber done")
// do nothing?
default:
// dont send this message to the publisher who just sent it
if subscriber.id == pid {
lumber.Trace("Subscriber is publisher, skipping publish")
continue
}
// create message
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()
}()
return nil
}
|
[
"func",
"publish",
"(",
"pid",
"uint32",
",",
"tags",
"[",
"]",
"string",
",",
"data",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"tags",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if there are no subscribers, the message goes nowhere",
"//",
"// this could be more optimized, but it might not be an issue unless thousands",
"// of clients are using mist.",
"go",
"func",
"(",
")",
"{",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"for",
"_",
",",
"subscriber",
":=",
"range",
"subscribers",
"{",
"select",
"{",
"case",
"<-",
"subscriber",
".",
"done",
":",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
")",
"\n",
"// do nothing?",
"default",
":",
"// dont send this message to the publisher who just sent it",
"if",
"subscriber",
".",
"id",
"==",
"pid",
"{",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// create message",
"msg",
":=",
"Message",
"{",
"Command",
":",
"\"",
"\"",
",",
"Tags",
":",
"tags",
",",
"Data",
":",
"data",
"}",
"\n\n",
"// 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",
"\n",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
")",
"\n",
"}",
"(",
"subscriber",
",",
"msg",
")",
"\n",
"}",
"\n",
"}",
"\n",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// publish publishes to all subscribers except the one who issued the publish
|
[
"publish",
"publishes",
"to",
"all",
"subscribers",
"except",
"the",
"one",
"who",
"issued",
"the",
"publish"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/mist.go#L94-L135
|
14,942 |
nanopack/mist
|
core/mist.go
|
subscribe
|
func subscribe(p *Proxy) {
lumber.Trace("Adding proxy to subscribers...")
mutex.Lock()
subscribers[p.id] = p
mutex.Unlock()
}
|
go
|
func subscribe(p *Proxy) {
lumber.Trace("Adding proxy to subscribers...")
mutex.Lock()
subscribers[p.id] = p
mutex.Unlock()
}
|
[
"func",
"subscribe",
"(",
"p",
"*",
"Proxy",
")",
"{",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
")",
"\n\n",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"subscribers",
"[",
"p",
".",
"id",
"]",
"=",
"p",
"\n",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// subscribe adds a proxy to the list of mist subscribers; we need this so that
// we can lock this process incase multiple proxies are subscribing at the same
// time
|
[
"subscribe",
"adds",
"a",
"proxy",
"to",
"the",
"list",
"of",
"mist",
"subscribers",
";",
"we",
"need",
"this",
"so",
"that",
"we",
"can",
"lock",
"this",
"process",
"incase",
"multiple",
"proxies",
"are",
"subscribing",
"at",
"the",
"same",
"time"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/mist.go#L140-L146
|
14,943 |
nanopack/mist
|
core/mist.go
|
unsubscribe
|
func unsubscribe(pid uint32) {
lumber.Trace("Removing proxy from subscribers...")
mutex.Lock()
delete(subscribers, pid)
mutex.Unlock()
}
|
go
|
func unsubscribe(pid uint32) {
lumber.Trace("Removing proxy from subscribers...")
mutex.Lock()
delete(subscribers, pid)
mutex.Unlock()
}
|
[
"func",
"unsubscribe",
"(",
"pid",
"uint32",
")",
"{",
"lumber",
".",
"Trace",
"(",
"\"",
"\"",
")",
"\n\n",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"subscribers",
",",
"pid",
")",
"\n",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// unsubscribe removes a proxy from the list of mist subscribers; we need this
// so that we can lock this process incase multiple proxies are unsubscribing at
// the same time
|
[
"unsubscribe",
"removes",
"a",
"proxy",
"from",
"the",
"list",
"of",
"mist",
"subscribers",
";",
"we",
"need",
"this",
"so",
"that",
"we",
"can",
"lock",
"this",
"process",
"incase",
"multiple",
"proxies",
"are",
"unsubscribing",
"at",
"the",
"same",
"time"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/core/mist.go#L151-L157
|
14,944 |
nanopack/mist
|
auth/scribble.go
|
NewScribble
|
func NewScribble(url *url.URL) (Authenticator, error) {
// get the desired location of the scribble database
dir := url.Query().Get("db")
// if no database location is provided, fail
if dir == "" {
return nil, fmt.Errorf("Missing database location in scheme (?db=)")
}
// 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
}
|
go
|
func NewScribble(url *url.URL) (Authenticator, error) {
// get the desired location of the scribble database
dir := url.Query().Get("db")
// if no database location is provided, fail
if dir == "" {
return nil, fmt.Errorf("Missing database location in scheme (?db=)")
}
// 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
}
|
[
"func",
"NewScribble",
"(",
"url",
"*",
"url",
".",
"URL",
")",
"(",
"Authenticator",
",",
"error",
")",
"{",
"// get the desired location of the scribble database",
"dir",
":=",
"url",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n\n",
"// if no database location is provided, fail",
"if",
"dir",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// create a new scribble database at the specified location",
"db",
",",
"err",
":=",
"scribbleDB",
".",
"New",
"(",
"dir",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"scribble",
"{",
"driver",
":",
"db",
"}",
",",
"nil",
"\n",
"}"
] |
// NewScribble creates a new "scribble" authenticator
|
[
"NewScribble",
"creates",
"a",
"new",
"scribble",
"authenticator"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/scribble.go#L30-L47
|
14,945 |
nanopack/mist
|
auth/scribble.go
|
findScribbleToken
|
func (a *scribble) findScribbleToken(token string) (entry scribbleToken, err error) {
// look for existing token
if err = a.driver.Read("tokens", token, &entry); err != nil {
return entry, err
}
return entry, nil
}
|
go
|
func (a *scribble) findScribbleToken(token string) (entry scribbleToken, err error) {
// look for existing token
if err = a.driver.Read("tokens", token, &entry); err != nil {
return entry, err
}
return entry, nil
}
|
[
"func",
"(",
"a",
"*",
"scribble",
")",
"findScribbleToken",
"(",
"token",
"string",
")",
"(",
"entry",
"scribbleToken",
",",
"err",
"error",
")",
"{",
"// look for existing token",
"if",
"err",
"=",
"a",
".",
"driver",
".",
"Read",
"(",
"\"",
"\"",
",",
"token",
",",
"&",
"entry",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"entry",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"entry",
",",
"nil",
"\n",
"}"
] |
// findScribbleToken attempts to find the desired token within "scribble"
|
[
"findScribbleToken",
"attempts",
"to",
"find",
"the",
"desired",
"token",
"within",
"scribble"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/auth/scribble.go#L129-L137
|
14,946 |
nanopack/mist
|
server/http.go
|
StartHTTP
|
func StartHTTP(uri string, errChan chan<- error) {
if err := newHTTP(uri); err != nil {
errChan <- fmt.Errorf("Unable to start mist http listener - %s", err.Error())
}
}
|
go
|
func StartHTTP(uri string, errChan chan<- error) {
if err := newHTTP(uri); err != nil {
errChan <- fmt.Errorf("Unable to start mist http listener - %s", err.Error())
}
}
|
[
"func",
"StartHTTP",
"(",
"uri",
"string",
",",
"errChan",
"chan",
"<-",
"error",
")",
"{",
"if",
"err",
":=",
"newHTTP",
"(",
"uri",
")",
";",
"err",
"!=",
"nil",
"{",
"errChan",
"<-",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// StartHTTP starts a mist server listening over HTTP
|
[
"StartHTTP",
"starts",
"a",
"mist",
"server",
"listening",
"over",
"HTTP"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/server/http.go#L23-L27
|
14,947 |
nanopack/mist
|
server/http.go
|
routes
|
func routes() *pat.Router {
Router.Get("/ping", func(rw http.ResponseWriter, req *http.Request) {
rw.Write([]byte("pong\n"))
})
// Router.Get("/list", handleRequest(list))
// Router.Get("/subscribe", handleRequest(subscribe))
// Router.Get("/unsubscribe", handleRequest(unsubscribe))
return Router
}
|
go
|
func routes() *pat.Router {
Router.Get("/ping", func(rw http.ResponseWriter, req *http.Request) {
rw.Write([]byte("pong\n"))
})
// Router.Get("/list", handleRequest(list))
// Router.Get("/subscribe", handleRequest(subscribe))
// Router.Get("/unsubscribe", handleRequest(unsubscribe))
return Router
}
|
[
"func",
"routes",
"(",
")",
"*",
"pat",
".",
"Router",
"{",
"Router",
".",
"Get",
"(",
"\"",
"\"",
",",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"rw",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\\n",
"\"",
")",
")",
"\n",
"}",
")",
"\n",
"// Router.Get(\"/list\", handleRequest(list))",
"// Router.Get(\"/subscribe\", handleRequest(subscribe))",
"// Router.Get(\"/unsubscribe\", handleRequest(unsubscribe))",
"return",
"Router",
"\n",
"}"
] |
// routes registers all api routes with the router
|
[
"routes",
"registers",
"all",
"api",
"routes",
"with",
"the",
"router"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/server/http.go#L42-L51
|
14,948 |
nanopack/mist
|
server/http.go
|
handleRequest
|
func handleRequest(fn func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
return func(rw http.ResponseWriter, req *http.Request) {
fn(rw, req)
}
}
|
go
|
func handleRequest(fn func(http.ResponseWriter, *http.Request)) http.HandlerFunc {
return func(rw http.ResponseWriter, req *http.Request) {
fn(rw, req)
}
}
|
[
"func",
"handleRequest",
"(",
"fn",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
")",
"http",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"fn",
"(",
"rw",
",",
"req",
")",
"\n",
"}",
"\n",
"}"
] |
// handleRequest is a wrapper for the actual route handler, simply to provide some
// debug output
|
[
"handleRequest",
"is",
"a",
"wrapper",
"for",
"the",
"actual",
"route",
"handler",
"simply",
"to",
"provide",
"some",
"debug",
"output"
] |
339c892519ed924d95ff289ecf0b7c7068879207
|
https://github.com/nanopack/mist/blob/339c892519ed924d95ff289ecf0b7c7068879207/server/http.go#L55-L59
|
14,949 |
apcera/gssapi
|
spnego/spnego_server.go
|
Negotiate
|
func (k KerberizedServer) Negotiate(cred *gssapi.CredId, inHeader, outHeader http.Header) (string, int, error) {
var challengeHeader, authHeader string
var challengeStatus int
if k.UseProxyAuthentication {
challengeHeader = "Proxy-Authenticate"
challengeStatus = http.StatusProxyAuthRequired
authHeader = "Proxy-Authorization"
} else {
challengeHeader = "WWW-Authenticate"
challengeStatus = http.StatusUnauthorized
authHeader = "Authorization"
}
negotiate, inputToken := CheckSPNEGONegotiate(k.Lib, inHeader, authHeader)
defer inputToken.Release()
// 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 "", challengeStatus, errors.New("SPNEGO: unauthorized")
}
// FIXME: GSS_S_CONTINUED_NEEDED handling?
ctx, srcName, _, outputToken, _, _, delegatedCredHandle, err :=
k.AcceptSecContext(k.GSS_C_NO_CONTEXT,
cred, inputToken, k.GSS_C_NO_CHANNEL_BINDINGS)
if err != nil {
return "", http.StatusBadRequest, err
}
delegatedCredHandle.Release()
ctx.DeleteSecContext()
outputToken.Release()
defer srcName.Release()
return srcName.String(), http.StatusOK, nil
}
|
go
|
func (k KerberizedServer) Negotiate(cred *gssapi.CredId, inHeader, outHeader http.Header) (string, int, error) {
var challengeHeader, authHeader string
var challengeStatus int
if k.UseProxyAuthentication {
challengeHeader = "Proxy-Authenticate"
challengeStatus = http.StatusProxyAuthRequired
authHeader = "Proxy-Authorization"
} else {
challengeHeader = "WWW-Authenticate"
challengeStatus = http.StatusUnauthorized
authHeader = "Authorization"
}
negotiate, inputToken := CheckSPNEGONegotiate(k.Lib, inHeader, authHeader)
defer inputToken.Release()
// 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 "", challengeStatus, errors.New("SPNEGO: unauthorized")
}
// FIXME: GSS_S_CONTINUED_NEEDED handling?
ctx, srcName, _, outputToken, _, _, delegatedCredHandle, err :=
k.AcceptSecContext(k.GSS_C_NO_CONTEXT,
cred, inputToken, k.GSS_C_NO_CHANNEL_BINDINGS)
if err != nil {
return "", http.StatusBadRequest, err
}
delegatedCredHandle.Release()
ctx.DeleteSecContext()
outputToken.Release()
defer srcName.Release()
return srcName.String(), http.StatusOK, nil
}
|
[
"func",
"(",
"k",
"KerberizedServer",
")",
"Negotiate",
"(",
"cred",
"*",
"gssapi",
".",
"CredId",
",",
"inHeader",
",",
"outHeader",
"http",
".",
"Header",
")",
"(",
"string",
",",
"int",
",",
"error",
")",
"{",
"var",
"challengeHeader",
",",
"authHeader",
"string",
"\n",
"var",
"challengeStatus",
"int",
"\n",
"if",
"k",
".",
"UseProxyAuthentication",
"{",
"challengeHeader",
"=",
"\"",
"\"",
"\n",
"challengeStatus",
"=",
"http",
".",
"StatusProxyAuthRequired",
"\n",
"authHeader",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"challengeHeader",
"=",
"\"",
"\"",
"\n",
"challengeStatus",
"=",
"http",
".",
"StatusUnauthorized",
"\n",
"authHeader",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"negotiate",
",",
"inputToken",
":=",
"CheckSPNEGONegotiate",
"(",
"k",
".",
"Lib",
",",
"inHeader",
",",
"authHeader",
")",
"\n",
"defer",
"inputToken",
".",
"Release",
"(",
")",
"\n\n",
"// 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",
")",
"\n",
"return",
"\"",
"\"",
",",
"challengeStatus",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// FIXME: GSS_S_CONTINUED_NEEDED handling?",
"ctx",
",",
"srcName",
",",
"_",
",",
"outputToken",
",",
"_",
",",
"_",
",",
"delegatedCredHandle",
",",
"err",
":=",
"k",
".",
"AcceptSecContext",
"(",
"k",
".",
"GSS_C_NO_CONTEXT",
",",
"cred",
",",
"inputToken",
",",
"k",
".",
"GSS_C_NO_CHANNEL_BINDINGS",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"http",
".",
"StatusBadRequest",
",",
"err",
"\n",
"}",
"\n",
"delegatedCredHandle",
".",
"Release",
"(",
")",
"\n",
"ctx",
".",
"DeleteSecContext",
"(",
")",
"\n",
"outputToken",
".",
"Release",
"(",
")",
"\n",
"defer",
"srcName",
".",
"Release",
"(",
")",
"\n\n",
"return",
"srcName",
".",
"String",
"(",
")",
",",
"http",
".",
"StatusOK",
",",
"nil",
"\n",
"}"
] |
// Negotiate handles the SPNEGO client-server negotiation. Negotiate will likely
// be invoked multiple times; a 200 or 400 response code are terminating
// conditions, whereas a 401 or 407 means that the client should respond to the
// challenge that we send.
|
[
"Negotiate",
"handles",
"the",
"SPNEGO",
"client",
"-",
"server",
"negotiation",
".",
"Negotiate",
"will",
"likely",
"be",
"invoked",
"multiple",
"times",
";",
"a",
"200",
"or",
"400",
"response",
"code",
"are",
"terminating",
"conditions",
"whereas",
"a",
"401",
"or",
"407",
"means",
"that",
"the",
"client",
"should",
"respond",
"to",
"the",
"challenge",
"that",
"we",
"send",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/spnego/spnego_server.go#L62-L99
|
14,950 |
apcera/gssapi
|
oid_set.go
|
MakeOIDSet
|
func (lib *Lib) MakeOIDSet(oids ...*OID) (s *OIDSet, err error) {
s = &OIDSet{
Lib: lib,
}
var min C.OM_uint32
maj := C.wrap_gss_create_empty_oid_set(s.Fp_gss_create_empty_oid_set,
&min, &s.C_gss_OID_set)
err = s.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
err = s.Add(oids...)
if err != nil {
return nil, err
}
return s, nil
}
|
go
|
func (lib *Lib) MakeOIDSet(oids ...*OID) (s *OIDSet, err error) {
s = &OIDSet{
Lib: lib,
}
var min C.OM_uint32
maj := C.wrap_gss_create_empty_oid_set(s.Fp_gss_create_empty_oid_set,
&min, &s.C_gss_OID_set)
err = s.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
err = s.Add(oids...)
if err != nil {
return nil, err
}
return s, nil
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"MakeOIDSet",
"(",
"oids",
"...",
"*",
"OID",
")",
"(",
"s",
"*",
"OIDSet",
",",
"err",
"error",
")",
"{",
"s",
"=",
"&",
"OIDSet",
"{",
"Lib",
":",
"lib",
",",
"}",
"\n\n",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_create_empty_oid_set",
"(",
"s",
".",
"Fp_gss_create_empty_oid_set",
",",
"&",
"min",
",",
"&",
"s",
".",
"C_gss_OID_set",
")",
"\n",
"err",
"=",
"s",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"s",
".",
"Add",
"(",
"oids",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] |
// MakeOIDSet makes an OIDSet prepopulated with the given OIDs.
|
[
"MakeOIDSet",
"makes",
"an",
"OIDSet",
"prepopulated",
"with",
"the",
"given",
"OIDs",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid_set.go#L84-L103
|
14,951 |
apcera/gssapi
|
oid_set.go
|
Release
|
func (s *OIDSet) Release() (err error) {
if s == nil || s.C_gss_OID_set == nil {
return nil
}
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)
}
|
go
|
func (s *OIDSet) Release() (err error) {
if s == nil || s.C_gss_OID_set == nil {
return nil
}
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)
}
|
[
"func",
"(",
"s",
"*",
"OIDSet",
")",
"Release",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"||",
"s",
".",
"C_gss_OID_set",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_release_oid_set",
"(",
"s",
".",
"Fp_gss_release_oid_set",
",",
"&",
"min",
",",
"&",
"s",
".",
"C_gss_OID_set",
")",
"\n",
"return",
"s",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"}"
] |
// Release frees all C memory associated with an OIDSet.
|
[
"Release",
"frees",
"all",
"C",
"memory",
"associated",
"with",
"an",
"OIDSet",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid_set.go#L106-L114
|
14,952 |
apcera/gssapi
|
oid_set.go
|
Add
|
func (s *OIDSet) Add(oids ...*OID) (err error) {
var min C.OM_uint32
for _, oid := range oids {
maj := C.wrap_gss_add_oid_set_member(s.Fp_gss_add_oid_set_member,
&min, oid.C_gss_OID, &s.C_gss_OID_set)
err = s.stashLastStatus(maj, min)
if err != nil {
return err
}
}
return nil
}
|
go
|
func (s *OIDSet) Add(oids ...*OID) (err error) {
var min C.OM_uint32
for _, oid := range oids {
maj := C.wrap_gss_add_oid_set_member(s.Fp_gss_add_oid_set_member,
&min, oid.C_gss_OID, &s.C_gss_OID_set)
err = s.stashLastStatus(maj, min)
if err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"OIDSet",
")",
"Add",
"(",
"oids",
"...",
"*",
"OID",
")",
"(",
"err",
"error",
")",
"{",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"for",
"_",
",",
"oid",
":=",
"range",
"oids",
"{",
"maj",
":=",
"C",
".",
"wrap_gss_add_oid_set_member",
"(",
"s",
".",
"Fp_gss_add_oid_set_member",
",",
"&",
"min",
",",
"oid",
".",
"C_gss_OID",
",",
"&",
"s",
".",
"C_gss_OID_set",
")",
"\n",
"err",
"=",
"s",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Add adds OIDs to an OIDSet.
|
[
"Add",
"adds",
"OIDs",
"to",
"an",
"OIDSet",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid_set.go#L117-L129
|
14,953 |
apcera/gssapi
|
oid_set.go
|
Length
|
func (s *OIDSet) Length() int {
if s == nil {
return 0
}
return int(s.C_gss_OID_set.count)
}
|
go
|
func (s *OIDSet) Length() int {
if s == nil {
return 0
}
return int(s.C_gss_OID_set.count)
}
|
[
"func",
"(",
"s",
"*",
"OIDSet",
")",
"Length",
"(",
")",
"int",
"{",
"if",
"s",
"==",
"nil",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"int",
"(",
"s",
".",
"C_gss_OID_set",
".",
"count",
")",
"\n",
"}"
] |
// Length returns the number of OIDs in a set.
|
[
"Length",
"returns",
"the",
"number",
"of",
"OIDs",
"in",
"a",
"set",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid_set.go#L153-L158
|
14,954 |
apcera/gssapi
|
oid_set.go
|
Get
|
func (s *OIDSet) Get(index int) (*OID, error) {
if s == nil || index < 0 || index >= int(s.C_gss_OID_set.count) {
return nil, fmt.Errorf("index %d out of bounds", index)
}
oid := s.NewOID()
oid.C_gss_OID = C.get_oid_set_member(s.C_gss_OID_set, C.int(index))
return oid, nil
}
|
go
|
func (s *OIDSet) Get(index int) (*OID, error) {
if s == nil || index < 0 || index >= int(s.C_gss_OID_set.count) {
return nil, fmt.Errorf("index %d out of bounds", index)
}
oid := s.NewOID()
oid.C_gss_OID = C.get_oid_set_member(s.C_gss_OID_set, C.int(index))
return oid, nil
}
|
[
"func",
"(",
"s",
"*",
"OIDSet",
")",
"Get",
"(",
"index",
"int",
")",
"(",
"*",
"OID",
",",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"||",
"index",
"<",
"0",
"||",
"index",
">=",
"int",
"(",
"s",
".",
"C_gss_OID_set",
".",
"count",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"index",
")",
"\n",
"}",
"\n",
"oid",
":=",
"s",
".",
"NewOID",
"(",
")",
"\n",
"oid",
".",
"C_gss_OID",
"=",
"C",
".",
"get_oid_set_member",
"(",
"s",
".",
"C_gss_OID_set",
",",
"C",
".",
"int",
"(",
"index",
")",
")",
"\n",
"return",
"oid",
",",
"nil",
"\n",
"}"
] |
// Get returns a specific OID from the set. The memory will be released when the
// set itself is released.
|
[
"Get",
"returns",
"a",
"specific",
"OID",
"from",
"the",
"set",
".",
"The",
"memory",
"will",
"be",
"released",
"when",
"the",
"set",
"itself",
"is",
"released",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid_set.go#L162-L169
|
14,955 |
apcera/gssapi
|
lib.go
|
Path
|
func (o *Options) Path() string {
switch {
case o.LibPath != "":
return o.LibPath
case o.LoadDefault == MIT:
return appendOSExt("libgssapi_krb5")
case o.LoadDefault == Heimdal:
return appendOSExt("libgssapi")
}
return ""
}
|
go
|
func (o *Options) Path() string {
switch {
case o.LibPath != "":
return o.LibPath
case o.LoadDefault == MIT:
return appendOSExt("libgssapi_krb5")
case o.LoadDefault == Heimdal:
return appendOSExt("libgssapi")
}
return ""
}
|
[
"func",
"(",
"o",
"*",
"Options",
")",
"Path",
"(",
")",
"string",
"{",
"switch",
"{",
"case",
"o",
".",
"LibPath",
"!=",
"\"",
"\"",
":",
"return",
"o",
".",
"LibPath",
"\n\n",
"case",
"o",
".",
"LoadDefault",
"==",
"MIT",
":",
"return",
"appendOSExt",
"(",
"\"",
"\"",
")",
"\n\n",
"case",
"o",
".",
"LoadDefault",
"==",
"Heimdal",
":",
"return",
"appendOSExt",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// Path returns the chosen gssapi library path that we're looking for.
|
[
"Path",
"returns",
"the",
"chosen",
"gssapi",
"library",
"path",
"that",
"we",
"re",
"looking",
"for",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/lib.go#L221-L233
|
14,956 |
apcera/gssapi
|
lib.go
|
Load
|
func Load(o *Options) (*Lib, error) {
if o == nil {
o = &Options{}
}
// We get the error in a separate call, so we need to lock OS thread
runtime.LockOSThread()
defer runtime.UnlockOSThread()
lib := &Lib{
Printers: o.Printers,
}
if o.Krb5Config != "" {
err := os.Setenv("KRB5_CONFIG", o.Krb5Config)
if err != nil {
return nil, err
}
}
if o.Krb5Ktname != "" {
err := os.Setenv("KRB5_KTNAME", o.Krb5Ktname)
if err != nil {
return nil, err
}
}
path := o.Path()
lib.Debug(fmt.Sprintf("Loading %q", path))
lib_cs := C.CString(path)
defer C.free(unsafe.Pointer(lib_cs))
// 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 != nil {
lib.Unload()
return nil, err
}
lib.initConstants()
return lib, nil
}
|
go
|
func Load(o *Options) (*Lib, error) {
if o == nil {
o = &Options{}
}
// We get the error in a separate call, so we need to lock OS thread
runtime.LockOSThread()
defer runtime.UnlockOSThread()
lib := &Lib{
Printers: o.Printers,
}
if o.Krb5Config != "" {
err := os.Setenv("KRB5_CONFIG", o.Krb5Config)
if err != nil {
return nil, err
}
}
if o.Krb5Ktname != "" {
err := os.Setenv("KRB5_KTNAME", o.Krb5Ktname)
if err != nil {
return nil, err
}
}
path := o.Path()
lib.Debug(fmt.Sprintf("Loading %q", path))
lib_cs := C.CString(path)
defer C.free(unsafe.Pointer(lib_cs))
// 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 != nil {
lib.Unload()
return nil, err
}
lib.initConstants()
return lib, nil
}
|
[
"func",
"Load",
"(",
"o",
"*",
"Options",
")",
"(",
"*",
"Lib",
",",
"error",
")",
"{",
"if",
"o",
"==",
"nil",
"{",
"o",
"=",
"&",
"Options",
"{",
"}",
"\n",
"}",
"\n\n",
"// We get the error in a separate call, so we need to lock OS thread",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"lib",
":=",
"&",
"Lib",
"{",
"Printers",
":",
"o",
".",
"Printers",
",",
"}",
"\n\n",
"if",
"o",
".",
"Krb5Config",
"!=",
"\"",
"\"",
"{",
"err",
":=",
"os",
".",
"Setenv",
"(",
"\"",
"\"",
",",
"o",
".",
"Krb5Config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"o",
".",
"Krb5Ktname",
"!=",
"\"",
"\"",
"{",
"err",
":=",
"os",
".",
"Setenv",
"(",
"\"",
"\"",
",",
"o",
".",
"Krb5Ktname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"path",
":=",
"o",
".",
"Path",
"(",
")",
"\n",
"lib",
".",
"Debug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"path",
")",
")",
"\n",
"lib_cs",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"lib_cs",
")",
")",
"\n\n",
"// 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",
")",
"\n",
"if",
"lib",
".",
"handle",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"C",
".",
"GoString",
"(",
"C",
".",
"dlerror",
"(",
")",
")",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"lib",
".",
"populateFunctions",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"lib",
".",
"Unload",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"lib",
".",
"initConstants",
"(",
")",
"\n\n",
"return",
"lib",
",",
"nil",
"\n",
"}"
] |
// Load attempts to load a dynamically-linked gssapi library from the path
// specified by the supplied Options.
|
[
"Load",
"attempts",
"to",
"load",
"a",
"dynamically",
"-",
"linked",
"gssapi",
"library",
"from",
"the",
"path",
"specified",
"by",
"the",
"supplied",
"Options",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/lib.go#L237-L285
|
14,957 |
apcera/gssapi
|
lib.go
|
Unload
|
func (lib *Lib) Unload() error {
if lib == nil || lib.handle == nil {
return nil
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
i := C.dlclose(lib.handle)
if i == -1 {
return fmt.Errorf("%s", C.GoString(C.dlerror()))
}
lib.handle = nil
return nil
}
|
go
|
func (lib *Lib) Unload() error {
if lib == nil || lib.handle == nil {
return nil
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
i := C.dlclose(lib.handle)
if i == -1 {
return fmt.Errorf("%s", C.GoString(C.dlerror()))
}
lib.handle = nil
return nil
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"Unload",
"(",
")",
"error",
"{",
"if",
"lib",
"==",
"nil",
"||",
"lib",
".",
"handle",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"i",
":=",
"C",
".",
"dlclose",
"(",
"lib",
".",
"handle",
")",
"\n",
"if",
"i",
"==",
"-",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"C",
".",
"GoString",
"(",
"C",
".",
"dlerror",
"(",
")",
")",
")",
"\n",
"}",
"\n\n",
"lib",
".",
"handle",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Unload closes the handle to the dynamically-linked gssapi library.
|
[
"Unload",
"closes",
"the",
"handle",
"to",
"the",
"dynamically",
"-",
"linked",
"gssapi",
"library",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/lib.go#L288-L303
|
14,958 |
apcera/gssapi
|
lib.go
|
populateFunctions
|
func (lib *Lib) populateFunctions() error {
libT := reflect.TypeOf(lib.ftable)
functionsV := reflect.ValueOf(lib).Elem().FieldByName("ftable")
n := libT.NumField()
for i := 0; i < n; i++ {
// Get the field name, and make sure it's an Fp_.
f := libT.FieldByIndex([]int{i})
if !strings.HasPrefix(f.Name, fpPrefix) {
return fmt.Errorf(
"Unexpected: field %q does not start with %q",
f.Name, fpPrefix)
}
// Resolve the symbol.
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
}
|
go
|
func (lib *Lib) populateFunctions() error {
libT := reflect.TypeOf(lib.ftable)
functionsV := reflect.ValueOf(lib).Elem().FieldByName("ftable")
n := libT.NumField()
for i := 0; i < n; i++ {
// Get the field name, and make sure it's an Fp_.
f := libT.FieldByIndex([]int{i})
if !strings.HasPrefix(f.Name, fpPrefix) {
return fmt.Errorf(
"Unexpected: field %q does not start with %q",
f.Name, fpPrefix)
}
// Resolve the symbol.
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
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"populateFunctions",
"(",
")",
"error",
"{",
"libT",
":=",
"reflect",
".",
"TypeOf",
"(",
"lib",
".",
"ftable",
")",
"\n",
"functionsV",
":=",
"reflect",
".",
"ValueOf",
"(",
"lib",
")",
".",
"Elem",
"(",
")",
".",
"FieldByName",
"(",
"\"",
"\"",
")",
"\n\n",
"n",
":=",
"libT",
".",
"NumField",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"// Get the field name, and make sure it's an Fp_.",
"f",
":=",
"libT",
".",
"FieldByIndex",
"(",
"[",
"]",
"int",
"{",
"i",
"}",
")",
"\n\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"f",
".",
"Name",
",",
"fpPrefix",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
"Name",
",",
"fpPrefix",
")",
"\n",
"}",
"\n\n",
"// Resolve the symbol.",
"cfname",
":=",
"C",
".",
"CString",
"(",
"f",
".",
"Name",
"[",
"len",
"(",
"fpPrefix",
")",
":",
"]",
")",
"\n",
"v",
":=",
"C",
".",
"dlsym",
"(",
"lib",
".",
"handle",
",",
"cfname",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cfname",
")",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"C",
".",
"GoString",
"(",
"C",
".",
"dlerror",
"(",
")",
")",
")",
"\n",
"}",
"\n\n",
"// Save the value into the struct",
"functionsV",
".",
"FieldByIndex",
"(",
"[",
"]",
"int",
"{",
"i",
"}",
")",
".",
"SetPointer",
"(",
"v",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// populateFunctions ranges over the library's ftable, initializing each
// function inside. Assumes that the caller executes runtime.LockOSThread.
|
[
"populateFunctions",
"ranges",
"over",
"the",
"library",
"s",
"ftable",
"initializing",
"each",
"function",
"inside",
".",
"Assumes",
"that",
"the",
"caller",
"executes",
"runtime",
".",
"LockOSThread",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/lib.go#L318-L346
|
14,959 |
apcera/gssapi
|
lib.go
|
initConstants
|
func (lib *Lib) initConstants() {
lib.GSS_C_NO_BUFFER = &Buffer{
Lib: lib,
// C_gss_buffer_t: C.GSS_C_NO_BUFFER, already nil
// alloc: allocNone, already 0
}
lib.GSS_C_NO_OID = lib.NewOID()
lib.GSS_C_NO_OID_SET = lib.NewOIDSet()
lib.GSS_C_NO_CONTEXT = lib.NewCtxId()
lib.GSS_C_NO_CREDENTIAL = lib.NewCredId()
lib.GSS_C_NT_USER_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_USER_NAME}
lib.GSS_C_NT_MACHINE_UID_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_MACHINE_UID_NAME}
lib.GSS_C_NT_STRING_UID_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_MACHINE_UID_NAME}
lib.GSS_C_NT_HOSTBASED_SERVICE_X = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_HOSTBASED_SERVICE_X}
lib.GSS_C_NT_HOSTBASED_SERVICE = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_HOSTBASED_SERVICE}
lib.GSS_C_NT_ANONYMOUS = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_ANONYMOUS}
lib.GSS_C_NT_EXPORT_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_EXPORT_NAME}
lib.GSS_KRB5_NT_PRINCIPAL_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_KRB5_NT_PRINCIPAL_NAME}
lib.GSS_KRB5_NT_PRINCIPAL = &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: C._GSS_MECH_SPNEGO}
lib.GSS_MECH_IAKERB = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_IAKERB}
lib.GSS_MECH_NTLMSSP = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_NTLMSSP}
}
|
go
|
func (lib *Lib) initConstants() {
lib.GSS_C_NO_BUFFER = &Buffer{
Lib: lib,
// C_gss_buffer_t: C.GSS_C_NO_BUFFER, already nil
// alloc: allocNone, already 0
}
lib.GSS_C_NO_OID = lib.NewOID()
lib.GSS_C_NO_OID_SET = lib.NewOIDSet()
lib.GSS_C_NO_CONTEXT = lib.NewCtxId()
lib.GSS_C_NO_CREDENTIAL = lib.NewCredId()
lib.GSS_C_NT_USER_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_USER_NAME}
lib.GSS_C_NT_MACHINE_UID_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_MACHINE_UID_NAME}
lib.GSS_C_NT_STRING_UID_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_MACHINE_UID_NAME}
lib.GSS_C_NT_HOSTBASED_SERVICE_X = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_HOSTBASED_SERVICE_X}
lib.GSS_C_NT_HOSTBASED_SERVICE = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_HOSTBASED_SERVICE}
lib.GSS_C_NT_ANONYMOUS = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_ANONYMOUS}
lib.GSS_C_NT_EXPORT_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_C_NT_EXPORT_NAME}
lib.GSS_KRB5_NT_PRINCIPAL_NAME = &OID{Lib: lib, C_gss_OID: C._GSS_KRB5_NT_PRINCIPAL_NAME}
lib.GSS_KRB5_NT_PRINCIPAL = &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: C._GSS_MECH_SPNEGO}
lib.GSS_MECH_IAKERB = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_IAKERB}
lib.GSS_MECH_NTLMSSP = &OID{Lib: lib, C_gss_OID: C._GSS_MECH_NTLMSSP}
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"initConstants",
"(",
")",
"{",
"lib",
".",
"GSS_C_NO_BUFFER",
"=",
"&",
"Buffer",
"{",
"Lib",
":",
"lib",
",",
"// C_gss_buffer_t: C.GSS_C_NO_BUFFER, already nil",
"// alloc: allocNone, already 0",
"}",
"\n",
"lib",
".",
"GSS_C_NO_OID",
"=",
"lib",
".",
"NewOID",
"(",
")",
"\n",
"lib",
".",
"GSS_C_NO_OID_SET",
"=",
"lib",
".",
"NewOIDSet",
"(",
")",
"\n",
"lib",
".",
"GSS_C_NO_CONTEXT",
"=",
"lib",
".",
"NewCtxId",
"(",
")",
"\n",
"lib",
".",
"GSS_C_NO_CREDENTIAL",
"=",
"lib",
".",
"NewCredId",
"(",
")",
"\n\n",
"lib",
".",
"GSS_C_NT_USER_NAME",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_USER_NAME",
"}",
"\n",
"lib",
".",
"GSS_C_NT_MACHINE_UID_NAME",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_MACHINE_UID_NAME",
"}",
"\n",
"lib",
".",
"GSS_C_NT_STRING_UID_NAME",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_MACHINE_UID_NAME",
"}",
"\n",
"lib",
".",
"GSS_C_NT_HOSTBASED_SERVICE_X",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_HOSTBASED_SERVICE_X",
"}",
"\n",
"lib",
".",
"GSS_C_NT_HOSTBASED_SERVICE",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_HOSTBASED_SERVICE",
"}",
"\n",
"lib",
".",
"GSS_C_NT_ANONYMOUS",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_ANONYMOUS",
"}",
"\n",
"lib",
".",
"GSS_C_NT_EXPORT_NAME",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_C_NT_EXPORT_NAME",
"}",
"\n\n",
"lib",
".",
"GSS_KRB5_NT_PRINCIPAL_NAME",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_KRB5_NT_PRINCIPAL_NAME",
"}",
"\n",
"lib",
".",
"GSS_KRB5_NT_PRINCIPAL",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_KRB5_NT_PRINCIPAL",
"}",
"\n\n",
"lib",
".",
"GSS_MECH_KRB5",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_MECH_KRB5",
"}",
"\n",
"lib",
".",
"GSS_MECH_KRB5_LEGACY",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_MECH_KRB5_LEGACY",
"}",
"\n",
"lib",
".",
"GSS_MECH_KRB5_OLD",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_MECH_KRB5_OLD",
"}",
"\n",
"lib",
".",
"GSS_MECH_SPNEGO",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_MECH_SPNEGO",
"}",
"\n",
"lib",
".",
"GSS_MECH_IAKERB",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_MECH_IAKERB",
"}",
"\n",
"lib",
".",
"GSS_MECH_NTLMSSP",
"=",
"&",
"OID",
"{",
"Lib",
":",
"lib",
",",
"C_gss_OID",
":",
"C",
".",
"_GSS_MECH_NTLMSSP",
"}",
"\n",
"}"
] |
// initConstants sets the initial values of a library's set of 'constants'.
|
[
"initConstants",
"sets",
"the",
"initial",
"values",
"of",
"a",
"library",
"s",
"set",
"of",
"constants",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/lib.go#L349-L377
|
14,960 |
apcera/gssapi
|
lib.go
|
Print
|
func (lib *Lib) Print(level Severity, a ...interface{}) {
if lib == nil || lib.Printers == nil || level >= Severity(len(lib.Printers)) {
return
}
lib.Printers[level].Print(a...)
}
|
go
|
func (lib *Lib) Print(level Severity, a ...interface{}) {
if lib == nil || lib.Printers == nil || level >= Severity(len(lib.Printers)) {
return
}
lib.Printers[level].Print(a...)
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"Print",
"(",
"level",
"Severity",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"lib",
"==",
"nil",
"||",
"lib",
".",
"Printers",
"==",
"nil",
"||",
"level",
">=",
"Severity",
"(",
"len",
"(",
"lib",
".",
"Printers",
")",
")",
"{",
"return",
"\n",
"}",
"\n",
"lib",
".",
"Printers",
"[",
"level",
"]",
".",
"Print",
"(",
"a",
"...",
")",
"\n",
"}"
] |
// Print outputs a log line to the specified severity.
|
[
"Print",
"outputs",
"a",
"log",
"line",
"to",
"the",
"specified",
"severity",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/lib.go#L380-L385
|
14,961 |
apcera/gssapi
|
credential.go
|
Release
|
func (c *CredId) Release() error {
if c == nil || c.C_gss_cred_id_t == nil {
return nil
}
min := C.OM_uint32(0)
maj := C.wrap_gss_release_cred(c.Fp_gss_release_cred,
&min,
&c.C_gss_cred_id_t)
return c.stashLastStatus(maj, min)
}
|
go
|
func (c *CredId) Release() error {
if c == nil || c.C_gss_cred_id_t == nil {
return nil
}
min := C.OM_uint32(0)
maj := C.wrap_gss_release_cred(c.Fp_gss_release_cred,
&min,
&c.C_gss_cred_id_t)
return c.stashLastStatus(maj, min)
}
|
[
"func",
"(",
"c",
"*",
"CredId",
")",
"Release",
"(",
")",
"error",
"{",
"if",
"c",
"==",
"nil",
"||",
"c",
".",
"C_gss_cred_id_t",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"min",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_release_cred",
"(",
"c",
".",
"Fp_gss_release_cred",
",",
"&",
"min",
",",
"&",
"c",
".",
"C_gss_cred_id_t",
")",
"\n\n",
"return",
"c",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"}"
] |
// Release frees a credential.
|
[
"Release",
"frees",
"a",
"credential",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/credential.go#L296-L307
|
14,962 |
apcera/gssapi
|
buffer.go
|
MakeBufferBytes
|
func (lib *Lib) MakeBufferBytes(data []byte) (*Buffer, error) {
if len(data) == 0 {
return lib.GSS_C_NO_BUFFER, nil
}
// have to allocate the memory in C land and copy
b, err := lib.MakeBuffer(allocMalloc)
if 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
}
|
go
|
func (lib *Lib) MakeBufferBytes(data []byte) (*Buffer, error) {
if len(data) == 0 {
return lib.GSS_C_NO_BUFFER, nil
}
// have to allocate the memory in C land and copy
b, err := lib.MakeBuffer(allocMalloc)
if 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
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"MakeBufferBytes",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"Buffer",
",",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"lib",
".",
"GSS_C_NO_BUFFER",
",",
"nil",
"\n",
"}",
"\n\n",
"// have to allocate the memory in C land and copy",
"b",
",",
"err",
":=",
"lib",
".",
"MakeBuffer",
"(",
"allocMalloc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"l",
":=",
"C",
".",
"size_t",
"(",
"len",
"(",
"data",
")",
")",
"\n",
"c",
":=",
"C",
".",
"malloc",
"(",
"l",
")",
"\n",
"if",
"b",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMallocFailed",
"\n",
"}",
"\n",
"C",
".",
"memmove",
"(",
"c",
",",
"(",
"unsafe",
".",
"Pointer",
")",
"(",
"&",
"data",
"[",
"0",
"]",
")",
",",
"l",
")",
"\n\n",
"b",
".",
"C_gss_buffer_t",
".",
"length",
"=",
"l",
"\n",
"b",
".",
"C_gss_buffer_t",
".",
"value",
"=",
"c",
"\n",
"b",
".",
"alloc",
"=",
"allocMalloc",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] |
// MakeBufferBytes makes a Buffer encapsulating a byte slice.
|
[
"MakeBufferBytes",
"makes",
"a",
"Buffer",
"encapsulating",
"a",
"byte",
"slice",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L82-L105
|
14,963 |
apcera/gssapi
|
buffer.go
|
MakeBufferString
|
func (lib *Lib) MakeBufferString(content string) (*Buffer, error) {
return lib.MakeBufferBytes([]byte(content))
}
|
go
|
func (lib *Lib) MakeBufferString(content string) (*Buffer, error) {
return lib.MakeBufferBytes([]byte(content))
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"MakeBufferString",
"(",
"content",
"string",
")",
"(",
"*",
"Buffer",
",",
"error",
")",
"{",
"return",
"lib",
".",
"MakeBufferBytes",
"(",
"[",
"]",
"byte",
"(",
"content",
")",
")",
"\n",
"}"
] |
// MakeBufferString makes a Buffer encapsulating the contents of a string.
|
[
"MakeBufferString",
"makes",
"a",
"Buffer",
"encapsulating",
"the",
"contents",
"of",
"a",
"string",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L108-L110
|
14,964 |
apcera/gssapi
|
buffer.go
|
Release
|
func (b *Buffer) Release() error {
if b == nil || b.C_gss_buffer_t == nil {
return nil
}
defer func() {
C.free(unsafe.Pointer(b.C_gss_buffer_t))
b.C_gss_buffer_t = nil
b.alloc = allocNone
}()
// free the value as needed
switch {
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 err
}
}
return nil
}
|
go
|
func (b *Buffer) Release() error {
if b == nil || b.C_gss_buffer_t == nil {
return nil
}
defer func() {
C.free(unsafe.Pointer(b.C_gss_buffer_t))
b.C_gss_buffer_t = nil
b.alloc = allocNone
}()
// free the value as needed
switch {
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 err
}
}
return nil
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"Release",
"(",
")",
"error",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"b",
".",
"C_gss_buffer_t",
")",
")",
"\n",
"b",
".",
"C_gss_buffer_t",
"=",
"nil",
"\n",
"b",
".",
"alloc",
"=",
"allocNone",
"\n",
"}",
"(",
")",
"\n\n",
"// free the value as needed",
"switch",
"{",
"case",
"b",
".",
"C_gss_buffer_t",
".",
"value",
"==",
"nil",
":",
"// do nothing",
"case",
"b",
".",
"alloc",
"==",
"allocMalloc",
":",
"C",
".",
"free",
"(",
"b",
".",
"C_gss_buffer_t",
".",
"value",
")",
"\n\n",
"case",
"b",
".",
"alloc",
"==",
"allocGSSAPI",
":",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_release_buffer",
"(",
"b",
".",
"Fp_gss_release_buffer",
",",
"&",
"min",
",",
"b",
".",
"C_gss_buffer_t",
")",
"\n",
"err",
":=",
"b",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Release safely frees the contents of a Buffer.
|
[
"Release",
"safely",
"frees",
"the",
"contents",
"of",
"a",
"Buffer",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L113-L142
|
14,965 |
apcera/gssapi
|
buffer.go
|
Length
|
func (b *Buffer) Length() int {
if b == nil || b.C_gss_buffer_t == nil || b.C_gss_buffer_t.length == 0 {
return 0
}
return int(b.C_gss_buffer_t.length)
}
|
go
|
func (b *Buffer) Length() int {
if b == nil || b.C_gss_buffer_t == nil || b.C_gss_buffer_t.length == 0 {
return 0
}
return int(b.C_gss_buffer_t.length)
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"Length",
"(",
")",
"int",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
".",
"length",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"int",
"(",
"b",
".",
"C_gss_buffer_t",
".",
"length",
")",
"\n",
"}"
] |
// Length returns the number of bytes in the Buffer.
|
[
"Length",
"returns",
"the",
"number",
"of",
"bytes",
"in",
"the",
"Buffer",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L145-L150
|
14,966 |
apcera/gssapi
|
buffer.go
|
Bytes
|
func (b *Buffer) Bytes() []byte {
if b == nil || b.C_gss_buffer_t == nil || b.C_gss_buffer_t.length == 0 {
return make([]byte, 0)
}
return C.GoBytes(b.C_gss_buffer_t.value, C.int(b.C_gss_buffer_t.length))
}
|
go
|
func (b *Buffer) Bytes() []byte {
if b == nil || b.C_gss_buffer_t == nil || b.C_gss_buffer_t.length == 0 {
return make([]byte, 0)
}
return C.GoBytes(b.C_gss_buffer_t.value, C.int(b.C_gss_buffer_t.length))
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"Bytes",
"(",
")",
"[",
"]",
"byte",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
".",
"length",
"==",
"0",
"{",
"return",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
")",
"\n",
"}",
"\n",
"return",
"C",
".",
"GoBytes",
"(",
"b",
".",
"C_gss_buffer_t",
".",
"value",
",",
"C",
".",
"int",
"(",
"b",
".",
"C_gss_buffer_t",
".",
"length",
")",
")",
"\n",
"}"
] |
// Bytes returns the contents of a Buffer as a byte slice.
|
[
"Bytes",
"returns",
"the",
"contents",
"of",
"a",
"Buffer",
"as",
"a",
"byte",
"slice",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L153-L158
|
14,967 |
apcera/gssapi
|
buffer.go
|
String
|
func (b *Buffer) String() string {
if b == nil || b.C_gss_buffer_t == nil || b.C_gss_buffer_t.length == 0 {
return ""
}
return C.GoStringN((*C.char)(b.C_gss_buffer_t.value), C.int(b.C_gss_buffer_t.length))
}
|
go
|
func (b *Buffer) String() string {
if b == nil || b.C_gss_buffer_t == nil || b.C_gss_buffer_t.length == 0 {
return ""
}
return C.GoStringN((*C.char)(b.C_gss_buffer_t.value), C.int(b.C_gss_buffer_t.length))
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"String",
"(",
")",
"string",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
"==",
"nil",
"||",
"b",
".",
"C_gss_buffer_t",
".",
"length",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"C",
".",
"GoStringN",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"b",
".",
"C_gss_buffer_t",
".",
"value",
")",
",",
"C",
".",
"int",
"(",
"b",
".",
"C_gss_buffer_t",
".",
"length",
")",
")",
"\n",
"}"
] |
// String returns the contents of a Buffer as a string.
|
[
"String",
"returns",
"the",
"contents",
"of",
"a",
"Buffer",
"as",
"a",
"string",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L161-L166
|
14,968 |
apcera/gssapi
|
buffer.go
|
Equal
|
func (b *Buffer) Equal(other *Buffer) bool {
isEqual := C.wrap_gss_buffer_equal(b.C_gss_buffer_t, other.C_gss_buffer_t)
return isEqual != 0
}
|
go
|
func (b *Buffer) Equal(other *Buffer) bool {
isEqual := C.wrap_gss_buffer_equal(b.C_gss_buffer_t, other.C_gss_buffer_t)
return isEqual != 0
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"Equal",
"(",
"other",
"*",
"Buffer",
")",
"bool",
"{",
"isEqual",
":=",
"C",
".",
"wrap_gss_buffer_equal",
"(",
"b",
".",
"C_gss_buffer_t",
",",
"other",
".",
"C_gss_buffer_t",
")",
"\n",
"return",
"isEqual",
"!=",
"0",
"\n",
"}"
] |
// Equal determines if a Buffer receiver is equivalent to the supplied Buffer.
|
[
"Equal",
"determines",
"if",
"a",
"Buffer",
"receiver",
"is",
"equivalent",
"to",
"the",
"supplied",
"Buffer",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/buffer.go#L189-L192
|
14,969 |
apcera/gssapi
|
oid.go
|
MakeOIDBytes
|
func (lib *Lib) MakeOIDBytes(data []byte) (*OID, error) {
oid := lib.NewOID()
s := C.malloc(C.gss_OID_size) // s for struct
if s == nil {
return nil, ErrMallocFailed
}
C.memset(s, 0, C.gss_OID_size)
l := C.size_t(len(data))
e := C.malloc(l) // c for contents
if e == nil {
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
C.helper_gss_OID_desc_set_elements(oid.C_gss_OID, C.OM_uint32(l), e)
return oid, nil
}
|
go
|
func (lib *Lib) MakeOIDBytes(data []byte) (*OID, error) {
oid := lib.NewOID()
s := C.malloc(C.gss_OID_size) // s for struct
if s == nil {
return nil, ErrMallocFailed
}
C.memset(s, 0, C.gss_OID_size)
l := C.size_t(len(data))
e := C.malloc(l) // c for contents
if e == nil {
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
C.helper_gss_OID_desc_set_elements(oid.C_gss_OID, C.OM_uint32(l), e)
return oid, nil
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"MakeOIDBytes",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"OID",
",",
"error",
")",
"{",
"oid",
":=",
"lib",
".",
"NewOID",
"(",
")",
"\n\n",
"s",
":=",
"C",
".",
"malloc",
"(",
"C",
".",
"gss_OID_size",
")",
"// s for struct",
"\n",
"if",
"s",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMallocFailed",
"\n",
"}",
"\n",
"C",
".",
"memset",
"(",
"s",
",",
"0",
",",
"C",
".",
"gss_OID_size",
")",
"\n\n",
"l",
":=",
"C",
".",
"size_t",
"(",
"len",
"(",
"data",
")",
")",
"\n",
"e",
":=",
"C",
".",
"malloc",
"(",
"l",
")",
"// c for contents",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMallocFailed",
"\n",
"}",
"\n",
"C",
".",
"memmove",
"(",
"e",
",",
"(",
"unsafe",
".",
"Pointer",
")",
"(",
"&",
"data",
"[",
"0",
"]",
")",
",",
"l",
")",
"\n\n",
"oid",
".",
"C_gss_OID",
"=",
"C",
".",
"gss_OID",
"(",
"s",
")",
"\n",
"oid",
".",
"alloc",
"=",
"allocMalloc",
"\n\n",
"// 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",
"C",
".",
"helper_gss_OID_desc_set_elements",
"(",
"oid",
".",
"C_gss_OID",
",",
"C",
".",
"OM_uint32",
"(",
"l",
")",
",",
"e",
")",
"\n\n",
"return",
"oid",
",",
"nil",
"\n",
"}"
] |
// MakeOIDBytes makes an OID encapsulating a byte slice. Note that it does not
// duplicate the data, but rather it points to it directly.
|
[
"MakeOIDBytes",
"makes",
"an",
"OID",
"encapsulating",
"a",
"byte",
"slice",
".",
"Note",
"that",
"it",
"does",
"not",
"duplicate",
"the",
"data",
"but",
"rather",
"it",
"points",
"to",
"it",
"directly",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid.go#L49-L75
|
14,970 |
apcera/gssapi
|
oid.go
|
MakeOIDString
|
func (lib *Lib) MakeOIDString(data string) (*OID, error) {
return lib.MakeOIDBytes([]byte(data))
}
|
go
|
func (lib *Lib) MakeOIDString(data string) (*OID, error) {
return lib.MakeOIDBytes([]byte(data))
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"MakeOIDString",
"(",
"data",
"string",
")",
"(",
"*",
"OID",
",",
"error",
")",
"{",
"return",
"lib",
".",
"MakeOIDBytes",
"(",
"[",
"]",
"byte",
"(",
"data",
")",
")",
"\n",
"}"
] |
// MakeOIDString makes an OID from a string.
|
[
"MakeOIDString",
"makes",
"an",
"OID",
"from",
"a",
"string",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid.go#L78-L80
|
14,971 |
apcera/gssapi
|
oid.go
|
Release
|
func (oid *OID) Release() error {
if oid == nil || oid.C_gss_OID == nil {
return nil
}
switch oid.alloc {
case allocMalloc:
// same as with get and set, use a C helper to free(oid.C_gss_OID.elements)
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
}
|
go
|
func (oid *OID) Release() error {
if oid == nil || oid.C_gss_OID == nil {
return nil
}
switch oid.alloc {
case allocMalloc:
// same as with get and set, use a C helper to free(oid.C_gss_OID.elements)
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
}
|
[
"func",
"(",
"oid",
"*",
"OID",
")",
"Release",
"(",
")",
"error",
"{",
"if",
"oid",
"==",
"nil",
"||",
"oid",
".",
"C_gss_OID",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"switch",
"oid",
".",
"alloc",
"{",
"case",
"allocMalloc",
":",
"// same as with get and set, use a C helper to free(oid.C_gss_OID.elements)",
"C",
".",
"helper_gss_OID_desc_free_elements",
"(",
"oid",
".",
"C_gss_OID",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"oid",
".",
"C_gss_OID",
")",
")",
"\n",
"oid",
".",
"C_gss_OID",
"=",
"nil",
"\n",
"oid",
".",
"alloc",
"=",
"allocNone",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Release safely frees the contents of an OID if it's allocated with malloc by
// MakeOIDBytes.
|
[
"Release",
"safely",
"frees",
"the",
"contents",
"of",
"an",
"OID",
"if",
"it",
"s",
"allocated",
"with",
"malloc",
"by",
"MakeOIDBytes",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid.go#L84-L99
|
14,972 |
apcera/gssapi
|
oid.go
|
Bytes
|
func (oid OID) Bytes() []byte {
var l C.OM_uint32
var p *C.char
C.helper_gss_OID_desc_get_elements(oid.C_gss_OID, &l, &p)
return C.GoBytes(unsafe.Pointer(p), C.int(l))
}
|
go
|
func (oid OID) Bytes() []byte {
var l C.OM_uint32
var p *C.char
C.helper_gss_OID_desc_get_elements(oid.C_gss_OID, &l, &p)
return C.GoBytes(unsafe.Pointer(p), C.int(l))
}
|
[
"func",
"(",
"oid",
"OID",
")",
"Bytes",
"(",
")",
"[",
"]",
"byte",
"{",
"var",
"l",
"C",
".",
"OM_uint32",
"\n",
"var",
"p",
"*",
"C",
".",
"char",
"\n\n",
"C",
".",
"helper_gss_OID_desc_get_elements",
"(",
"oid",
".",
"C_gss_OID",
",",
"&",
"l",
",",
"&",
"p",
")",
"\n\n",
"return",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
")",
",",
"C",
".",
"int",
"(",
"l",
")",
")",
"\n",
"}"
] |
// Bytes displays the bytes of an OID.
|
[
"Bytes",
"displays",
"the",
"bytes",
"of",
"an",
"OID",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid.go#L102-L109
|
14,973 |
apcera/gssapi
|
oid.go
|
String
|
func (oid *OID) String() string {
var l C.OM_uint32
var p *C.char
C.helper_gss_OID_desc_get_elements(oid.C_gss_OID, &l, &p)
return fmt.Sprintf(`%x`, C.GoStringN(p, C.int(l)))
}
|
go
|
func (oid *OID) String() string {
var l C.OM_uint32
var p *C.char
C.helper_gss_OID_desc_get_elements(oid.C_gss_OID, &l, &p)
return fmt.Sprintf(`%x`, C.GoStringN(p, C.int(l)))
}
|
[
"func",
"(",
"oid",
"*",
"OID",
")",
"String",
"(",
")",
"string",
"{",
"var",
"l",
"C",
".",
"OM_uint32",
"\n",
"var",
"p",
"*",
"C",
".",
"char",
"\n\n",
"C",
".",
"helper_gss_OID_desc_get_elements",
"(",
"oid",
".",
"C_gss_OID",
",",
"&",
"l",
",",
"&",
"p",
")",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"`%x`",
",",
"C",
".",
"GoStringN",
"(",
"p",
",",
"C",
".",
"int",
"(",
"l",
")",
")",
")",
"\n",
"}"
] |
// String displays a string representation of an OID.
|
[
"String",
"displays",
"a",
"string",
"representation",
"of",
"an",
"OID",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid.go#L112-L119
|
14,974 |
apcera/gssapi
|
oid.go
|
DebugString
|
func (oid *OID) DebugString() string {
switch {
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_USER_NAME.Bytes()):
return "GSS_C_NT_USER_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_MACHINE_UID_NAME.Bytes()):
return "GSS_C_NT_MACHINE_UID_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_STRING_UID_NAME.Bytes()):
return "GSS_C_NT_STRING_UID_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_HOSTBASED_SERVICE_X.Bytes()):
return "GSS_C_NT_HOSTBASED_SERVICE_X"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_HOSTBASED_SERVICE.Bytes()):
return "GSS_C_NT_HOSTBASED_SERVICE"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_ANONYMOUS.Bytes()):
return "GSS_C_NT_ANONYMOUS"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_EXPORT_NAME.Bytes()):
return "GSS_C_NT_EXPORT_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_KRB5_NT_PRINCIPAL_NAME.Bytes()):
return "GSS_KRB5_NT_PRINCIPAL_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_KRB5_NT_PRINCIPAL.Bytes()):
return "GSS_KRB5_NT_PRINCIPAL"
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_KRB5.Bytes()):
return "GSS_MECH_KRB5"
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_MECH_IAKERB.Bytes()):
return "GSS_MECH_IAKERB"
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_NTLMSSP.Bytes()):
return "GSS_MECH_NTLMSSP"
}
return oid.String()
}
|
go
|
func (oid *OID) DebugString() string {
switch {
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_USER_NAME.Bytes()):
return "GSS_C_NT_USER_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_MACHINE_UID_NAME.Bytes()):
return "GSS_C_NT_MACHINE_UID_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_STRING_UID_NAME.Bytes()):
return "GSS_C_NT_STRING_UID_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_HOSTBASED_SERVICE_X.Bytes()):
return "GSS_C_NT_HOSTBASED_SERVICE_X"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_HOSTBASED_SERVICE.Bytes()):
return "GSS_C_NT_HOSTBASED_SERVICE"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_ANONYMOUS.Bytes()):
return "GSS_C_NT_ANONYMOUS"
case bytes.Equal(oid.Bytes(), oid.GSS_C_NT_EXPORT_NAME.Bytes()):
return "GSS_C_NT_EXPORT_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_KRB5_NT_PRINCIPAL_NAME.Bytes()):
return "GSS_KRB5_NT_PRINCIPAL_NAME"
case bytes.Equal(oid.Bytes(), oid.GSS_KRB5_NT_PRINCIPAL.Bytes()):
return "GSS_KRB5_NT_PRINCIPAL"
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_KRB5.Bytes()):
return "GSS_MECH_KRB5"
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_MECH_IAKERB.Bytes()):
return "GSS_MECH_IAKERB"
case bytes.Equal(oid.Bytes(), oid.GSS_MECH_NTLMSSP.Bytes()):
return "GSS_MECH_NTLMSSP"
}
return oid.String()
}
|
[
"func",
"(",
"oid",
"*",
"OID",
")",
"DebugString",
"(",
")",
"string",
"{",
"switch",
"{",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_USER_NAME",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_MACHINE_UID_NAME",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_STRING_UID_NAME",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_HOSTBASED_SERVICE_X",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_HOSTBASED_SERVICE",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_ANONYMOUS",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_C_NT_EXPORT_NAME",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_KRB5_NT_PRINCIPAL_NAME",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_KRB5_NT_PRINCIPAL",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_MECH_KRB5",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_MECH_KRB5_LEGACY",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_MECH_KRB5_OLD",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_MECH_SPNEGO",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_MECH_IAKERB",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"case",
"bytes",
".",
"Equal",
"(",
"oid",
".",
"Bytes",
"(",
")",
",",
"oid",
".",
"GSS_MECH_NTLMSSP",
".",
"Bytes",
"(",
")",
")",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"oid",
".",
"String",
"(",
")",
"\n",
"}"
] |
// Returns a symbolic name for a known OID, or the string. Note that this
// function is intended for debugging and is not at all performant.
|
[
"Returns",
"a",
"symbolic",
"name",
"for",
"a",
"known",
"OID",
"or",
"the",
"string",
".",
"Note",
"that",
"this",
"function",
"is",
"intended",
"for",
"debugging",
"and",
"is",
"not",
"at",
"all",
"performant",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/oid.go#L123-L158
|
14,975 |
apcera/gssapi
|
context.go
|
AcceptSecContext
|
func (lib *Lib) AcceptSecContext(
ctxIn *CtxId, acceptorCredHandle *CredId, inputToken *Buffer,
inputChanBindings ChannelBindings) (
ctxOut *CtxId, srcName *Name, actualMechType *OID, outputToken *Buffer,
retFlags uint32, timeRec time.Duration, delegatedCredHandle *CredId,
err error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// prepare the inputs
C_acceptorCredHandle := C.gss_cred_id_t(nil)
if acceptorCredHandle != nil {
C_acceptorCredHandle = acceptorCredHandle.C_gss_cred_id_t
}
C_inputToken := C.gss_buffer_t(nil)
if inputToken != nil {
C_inputToken = inputToken.C_gss_buffer_t
}
// prepare the outputs
if ctxIn != nil {
ctxCopy := *ctxIn
ctxOut = &ctxCopy
} else {
ctxOut = lib.GSS_C_NO_CONTEXT
}
min := C.OM_uint32(0)
srcName = lib.NewName()
actualMechType = lib.NewOID()
outputToken, err = lib.MakeBuffer(allocGSSAPI)
if err != nil {
return nil, nil, nil, nil, 0, 0, nil, err
}
flags := C.OM_uint32(0)
timerec := C.OM_uint32(0)
delegatedCredHandle = lib.NewCredId()
maj := C.wrap_gss_accept_sec_context(lib.Fp_gss_accept_sec_context,
&min,
&ctxOut.C_gss_ctx_id_t, // used 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.Err("AcceptSecContext: ", err)
return nil, nil, nil, nil, 0, 0, nil, err
}
if MajorStatus(maj).ContinueNeeded() {
err = ErrContinueNeeded
}
return ctxOut, srcName, actualMechType, outputToken, uint32(flags),
time.Duration(timerec) * time.Second, delegatedCredHandle, err
}
|
go
|
func (lib *Lib) AcceptSecContext(
ctxIn *CtxId, acceptorCredHandle *CredId, inputToken *Buffer,
inputChanBindings ChannelBindings) (
ctxOut *CtxId, srcName *Name, actualMechType *OID, outputToken *Buffer,
retFlags uint32, timeRec time.Duration, delegatedCredHandle *CredId,
err error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// prepare the inputs
C_acceptorCredHandle := C.gss_cred_id_t(nil)
if acceptorCredHandle != nil {
C_acceptorCredHandle = acceptorCredHandle.C_gss_cred_id_t
}
C_inputToken := C.gss_buffer_t(nil)
if inputToken != nil {
C_inputToken = inputToken.C_gss_buffer_t
}
// prepare the outputs
if ctxIn != nil {
ctxCopy := *ctxIn
ctxOut = &ctxCopy
} else {
ctxOut = lib.GSS_C_NO_CONTEXT
}
min := C.OM_uint32(0)
srcName = lib.NewName()
actualMechType = lib.NewOID()
outputToken, err = lib.MakeBuffer(allocGSSAPI)
if err != nil {
return nil, nil, nil, nil, 0, 0, nil, err
}
flags := C.OM_uint32(0)
timerec := C.OM_uint32(0)
delegatedCredHandle = lib.NewCredId()
maj := C.wrap_gss_accept_sec_context(lib.Fp_gss_accept_sec_context,
&min,
&ctxOut.C_gss_ctx_id_t, // used 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.Err("AcceptSecContext: ", err)
return nil, nil, nil, nil, 0, 0, nil, err
}
if MajorStatus(maj).ContinueNeeded() {
err = ErrContinueNeeded
}
return ctxOut, srcName, actualMechType, outputToken, uint32(flags),
time.Duration(timerec) * time.Second, delegatedCredHandle, err
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"AcceptSecContext",
"(",
"ctxIn",
"*",
"CtxId",
",",
"acceptorCredHandle",
"*",
"CredId",
",",
"inputToken",
"*",
"Buffer",
",",
"inputChanBindings",
"ChannelBindings",
")",
"(",
"ctxOut",
"*",
"CtxId",
",",
"srcName",
"*",
"Name",
",",
"actualMechType",
"*",
"OID",
",",
"outputToken",
"*",
"Buffer",
",",
"retFlags",
"uint32",
",",
"timeRec",
"time",
".",
"Duration",
",",
"delegatedCredHandle",
"*",
"CredId",
",",
"err",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"// prepare the inputs",
"C_acceptorCredHandle",
":=",
"C",
".",
"gss_cred_id_t",
"(",
"nil",
")",
"\n",
"if",
"acceptorCredHandle",
"!=",
"nil",
"{",
"C_acceptorCredHandle",
"=",
"acceptorCredHandle",
".",
"C_gss_cred_id_t",
"\n",
"}",
"\n\n",
"C_inputToken",
":=",
"C",
".",
"gss_buffer_t",
"(",
"nil",
")",
"\n",
"if",
"inputToken",
"!=",
"nil",
"{",
"C_inputToken",
"=",
"inputToken",
".",
"C_gss_buffer_t",
"\n",
"}",
"\n\n",
"// prepare the outputs",
"if",
"ctxIn",
"!=",
"nil",
"{",
"ctxCopy",
":=",
"*",
"ctxIn",
"\n",
"ctxOut",
"=",
"&",
"ctxCopy",
"\n",
"}",
"else",
"{",
"ctxOut",
"=",
"lib",
".",
"GSS_C_NO_CONTEXT",
"\n",
"}",
"\n\n",
"min",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"srcName",
"=",
"lib",
".",
"NewName",
"(",
")",
"\n",
"actualMechType",
"=",
"lib",
".",
"NewOID",
"(",
")",
"\n",
"outputToken",
",",
"err",
"=",
"lib",
".",
"MakeBuffer",
"(",
"allocGSSAPI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"0",
",",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"flags",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"timerec",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"delegatedCredHandle",
"=",
"lib",
".",
"NewCredId",
"(",
")",
"\n\n",
"maj",
":=",
"C",
".",
"wrap_gss_accept_sec_context",
"(",
"lib",
".",
"Fp_gss_accept_sec_context",
",",
"&",
"min",
",",
"&",
"ctxOut",
".",
"C_gss_ctx_id_t",
",",
"// used 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",
")",
"\n\n",
"err",
"=",
"lib",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"lib",
".",
"Err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"nil",
",",
"0",
",",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"MajorStatus",
"(",
"maj",
")",
".",
"ContinueNeeded",
"(",
")",
"{",
"err",
"=",
"ErrContinueNeeded",
"\n",
"}",
"\n\n",
"return",
"ctxOut",
",",
"srcName",
",",
"actualMechType",
",",
"outputToken",
",",
"uint32",
"(",
"flags",
")",
",",
"time",
".",
"Duration",
"(",
"timerec",
")",
"*",
"time",
".",
"Second",
",",
"delegatedCredHandle",
",",
"err",
"\n",
"}"
] |
// AcceptSecContext accepts an initialized security context. Usually called by
// the server. May return ErrContinueNeeded if the client is to make another
// iteration of exchanging token with the service
|
[
"AcceptSecContext",
"accepts",
"an",
"initialized",
"security",
"context",
".",
"Usually",
"called",
"by",
"the",
"server",
".",
"May",
"return",
"ErrContinueNeeded",
"if",
"the",
"client",
"is",
"to",
"make",
"another",
"iteration",
"of",
"exchanging",
"token",
"with",
"the",
"service"
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/context.go#L240-L305
|
14,976 |
apcera/gssapi
|
context.go
|
InquireContext
|
func (ctx *CtxId) InquireContext() (
srcName *Name, targetName *Name, lifetimeRec time.Duration, mechType *OID,
ctxFlags uint64, locallyInitiated bool, open bool, err error) {
min := C.OM_uint32(0)
srcName = ctx.NewName()
targetName = ctx.NewName()
rec := C.OM_uint32(0)
mechType = ctx.NewOID()
flags := C.OM_uint32(0)
li := C.int(0)
opn := C.int(0)
maj := C.wrap_gss_inquire_context(ctx.Fp_gss_inquire_context,
&min,
ctx.C_gss_ctx_id_t,
&srcName.C_gss_name_t,
&targetName.C_gss_name_t,
&rec,
&mechType.C_gss_OID,
&flags,
&li,
&opn)
err = ctx.stashLastStatus(maj, min)
if err != 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, locallyInitiated, open, nil
}
|
go
|
func (ctx *CtxId) InquireContext() (
srcName *Name, targetName *Name, lifetimeRec time.Duration, mechType *OID,
ctxFlags uint64, locallyInitiated bool, open bool, err error) {
min := C.OM_uint32(0)
srcName = ctx.NewName()
targetName = ctx.NewName()
rec := C.OM_uint32(0)
mechType = ctx.NewOID()
flags := C.OM_uint32(0)
li := C.int(0)
opn := C.int(0)
maj := C.wrap_gss_inquire_context(ctx.Fp_gss_inquire_context,
&min,
ctx.C_gss_ctx_id_t,
&srcName.C_gss_name_t,
&targetName.C_gss_name_t,
&rec,
&mechType.C_gss_OID,
&flags,
&li,
&opn)
err = ctx.stashLastStatus(maj, min)
if err != 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, locallyInitiated, open, nil
}
|
[
"func",
"(",
"ctx",
"*",
"CtxId",
")",
"InquireContext",
"(",
")",
"(",
"srcName",
"*",
"Name",
",",
"targetName",
"*",
"Name",
",",
"lifetimeRec",
"time",
".",
"Duration",
",",
"mechType",
"*",
"OID",
",",
"ctxFlags",
"uint64",
",",
"locallyInitiated",
"bool",
",",
"open",
"bool",
",",
"err",
"error",
")",
"{",
"min",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"srcName",
"=",
"ctx",
".",
"NewName",
"(",
")",
"\n",
"targetName",
"=",
"ctx",
".",
"NewName",
"(",
")",
"\n",
"rec",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"mechType",
"=",
"ctx",
".",
"NewOID",
"(",
")",
"\n",
"flags",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"li",
":=",
"C",
".",
"int",
"(",
"0",
")",
"\n",
"opn",
":=",
"C",
".",
"int",
"(",
"0",
")",
"\n\n",
"maj",
":=",
"C",
".",
"wrap_gss_inquire_context",
"(",
"ctx",
".",
"Fp_gss_inquire_context",
",",
"&",
"min",
",",
"ctx",
".",
"C_gss_ctx_id_t",
",",
"&",
"srcName",
".",
"C_gss_name_t",
",",
"&",
"targetName",
".",
"C_gss_name_t",
",",
"&",
"rec",
",",
"&",
"mechType",
".",
"C_gss_OID",
",",
"&",
"flags",
",",
"&",
"li",
",",
"&",
"opn",
")",
"\n\n",
"err",
"=",
"ctx",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ctx",
".",
"Err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"0",
",",
"nil",
",",
"0",
",",
"false",
",",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"lifetimeRec",
"=",
"time",
".",
"Duration",
"(",
"rec",
")",
"*",
"time",
".",
"Second",
"\n",
"ctxFlags",
"=",
"uint64",
"(",
"flags",
")",
"\n\n",
"if",
"li",
"!=",
"0",
"{",
"locallyInitiated",
"=",
"true",
"\n",
"}",
"\n",
"if",
"opn",
"!=",
"0",
"{",
"open",
"=",
"true",
"\n",
"}",
"\n\n",
"return",
"srcName",
",",
"targetName",
",",
"lifetimeRec",
",",
"mechType",
",",
"ctxFlags",
",",
"locallyInitiated",
",",
"open",
",",
"nil",
"\n",
"}"
] |
// InquireContext returns fields about a security context.
|
[
"InquireContext",
"returns",
"fields",
"about",
"a",
"security",
"context",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/context.go#L331-L372
|
14,977 |
apcera/gssapi
|
spnego/spnego_transport.go
|
AddSPNEGONegotiate
|
func AddSPNEGONegotiate(h http.Header, name string, token *gssapi.Buffer) {
if name == "" {
return
}
v := negotiateScheme
if token.Length() != 0 {
data := token.Bytes()
v = v + " " + base64.StdEncoding.EncodeToString(data)
}
h.Set(name, v)
}
|
go
|
func AddSPNEGONegotiate(h http.Header, name string, token *gssapi.Buffer) {
if name == "" {
return
}
v := negotiateScheme
if token.Length() != 0 {
data := token.Bytes()
v = v + " " + base64.StdEncoding.EncodeToString(data)
}
h.Set(name, v)
}
|
[
"func",
"AddSPNEGONegotiate",
"(",
"h",
"http",
".",
"Header",
",",
"name",
"string",
",",
"token",
"*",
"gssapi",
".",
"Buffer",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n\n",
"v",
":=",
"negotiateScheme",
"\n",
"if",
"token",
".",
"Length",
"(",
")",
"!=",
"0",
"{",
"data",
":=",
"token",
".",
"Bytes",
"(",
")",
"\n",
"v",
"=",
"v",
"+",
"\"",
"\"",
"+",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"data",
")",
"\n",
"}",
"\n",
"h",
".",
"Set",
"(",
"name",
",",
"v",
")",
"\n",
"}"
] |
// AddSPNEGONegotiate adds a Negotiate header with the value of a serialized
// token to an http header.
|
[
"AddSPNEGONegotiate",
"adds",
"a",
"Negotiate",
"header",
"with",
"the",
"value",
"of",
"a",
"serialized",
"token",
"to",
"an",
"http",
"header",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/spnego/spnego_transport.go#L18-L29
|
14,978 |
apcera/gssapi
|
spnego/spnego_transport.go
|
CheckSPNEGONegotiate
|
func CheckSPNEGONegotiate(lib *gssapi.Lib, h http.Header, name string) (bool, *gssapi.Buffer) {
var err error
defer func() {
if err != nil {
lib.Debug(fmt.Sprintf("CheckSPNEGONegotiate: %v", err))
}
}()
for _, header := range h[http.CanonicalHeaderKey(name)] {
if len(header) < len(negotiateScheme) {
continue
}
if !strings.EqualFold(header[:len(negotiateScheme)], negotiateScheme) {
continue
}
// Remove the "Negotiate" prefix
normalizedToken := header[len(negotiateScheme):]
// Trim leading and trailing whitespace
normalizedToken = strings.TrimSpace(normalizedToken)
// Remove internal whitespace (some servers insert whitespace every 76 chars)
normalizedToken = strings.Replace(normalizedToken, " ", "", -1)
// 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
}
if len(tbytes) == 0 {
return true, nil
}
token, err := lib.MakeBufferBytes(tbytes)
if err != nil {
continue
}
return true, token
}
return false, nil
}
|
go
|
func CheckSPNEGONegotiate(lib *gssapi.Lib, h http.Header, name string) (bool, *gssapi.Buffer) {
var err error
defer func() {
if err != nil {
lib.Debug(fmt.Sprintf("CheckSPNEGONegotiate: %v", err))
}
}()
for _, header := range h[http.CanonicalHeaderKey(name)] {
if len(header) < len(negotiateScheme) {
continue
}
if !strings.EqualFold(header[:len(negotiateScheme)], negotiateScheme) {
continue
}
// Remove the "Negotiate" prefix
normalizedToken := header[len(negotiateScheme):]
// Trim leading and trailing whitespace
normalizedToken = strings.TrimSpace(normalizedToken)
// Remove internal whitespace (some servers insert whitespace every 76 chars)
normalizedToken = strings.Replace(normalizedToken, " ", "", -1)
// 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
}
if len(tbytes) == 0 {
return true, nil
}
token, err := lib.MakeBufferBytes(tbytes)
if err != nil {
continue
}
return true, token
}
return false, nil
}
|
[
"func",
"CheckSPNEGONegotiate",
"(",
"lib",
"*",
"gssapi",
".",
"Lib",
",",
"h",
"http",
".",
"Header",
",",
"name",
"string",
")",
"(",
"bool",
",",
"*",
"gssapi",
".",
"Buffer",
")",
"{",
"var",
"err",
"error",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"lib",
".",
"Debug",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"_",
",",
"header",
":=",
"range",
"h",
"[",
"http",
".",
"CanonicalHeaderKey",
"(",
"name",
")",
"]",
"{",
"if",
"len",
"(",
"header",
")",
"<",
"len",
"(",
"negotiateScheme",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"EqualFold",
"(",
"header",
"[",
":",
"len",
"(",
"negotiateScheme",
")",
"]",
",",
"negotiateScheme",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"// Remove the \"Negotiate\" prefix",
"normalizedToken",
":=",
"header",
"[",
"len",
"(",
"negotiateScheme",
")",
":",
"]",
"\n",
"// Trim leading and trailing whitespace",
"normalizedToken",
"=",
"strings",
".",
"TrimSpace",
"(",
"normalizedToken",
")",
"\n",
"// Remove internal whitespace (some servers insert whitespace every 76 chars)",
"normalizedToken",
"=",
"strings",
".",
"Replace",
"(",
"normalizedToken",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"// 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",
")",
"\n",
"}",
"\n\n",
"tbytes",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"normalizedToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"tbytes",
")",
"==",
"0",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"token",
",",
"err",
":=",
"lib",
".",
"MakeBufferBytes",
"(",
"tbytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"true",
",",
"token",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] |
// CheckSPNEGONegotiate checks for the presence of a Negotiate header. If
// present, we return a gssapi Token created from the header value sent to us.
|
[
"CheckSPNEGONegotiate",
"checks",
"for",
"the",
"presence",
"of",
"a",
"Negotiate",
"header",
".",
"If",
"present",
"we",
"return",
"a",
"gssapi",
"Token",
"created",
"from",
"the",
"header",
"value",
"sent",
"to",
"us",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/spnego/spnego_transport.go#L33-L77
|
14,979 |
apcera/gssapi
|
name.go
|
Release
|
func (n *Name) Release() error {
if n == nil || n.C_gss_name_t == nil {
return nil
}
var min C.OM_uint32
maj := 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
}
|
go
|
func (n *Name) Release() error {
if n == nil || n.C_gss_name_t == nil {
return nil
}
var min C.OM_uint32
maj := 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
}
|
[
"func",
"(",
"n",
"*",
"Name",
")",
"Release",
"(",
")",
"error",
"{",
"if",
"n",
"==",
"nil",
"||",
"n",
".",
"C_gss_name_t",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_release_name",
"(",
"n",
".",
"Fp_gss_release_name",
",",
"&",
"min",
",",
"&",
"n",
".",
"C_gss_name_t",
")",
"\n",
"err",
":=",
"n",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"n",
".",
"C_gss_name_t",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Release frees the memory associated with an internal representation of the
// name.
|
[
"Release",
"frees",
"the",
"memory",
"associated",
"with",
"an",
"internal",
"representation",
"of",
"the",
"name",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/name.go#L146-L158
|
14,980 |
apcera/gssapi
|
name.go
|
Display
|
func (n Name) Display() (name string, oid *OID, err error) {
var min C.OM_uint32
b, err := n.MakeBuffer(allocGSSAPI)
if err != nil {
return "", nil, err
}
defer b.Release()
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
}
|
go
|
func (n Name) Display() (name string, oid *OID, err error) {
var min C.OM_uint32
b, err := n.MakeBuffer(allocGSSAPI)
if err != nil {
return "", nil, err
}
defer b.Release()
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
}
|
[
"func",
"(",
"n",
"Name",
")",
"Display",
"(",
")",
"(",
"name",
"string",
",",
"oid",
"*",
"OID",
",",
"err",
"error",
")",
"{",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"b",
",",
"err",
":=",
"n",
".",
"MakeBuffer",
"(",
"allocGSSAPI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"b",
".",
"Release",
"(",
")",
"\n\n",
"oid",
"=",
"n",
".",
"NewOID",
"(",
")",
"\n\n",
"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",
")",
"\n\n",
"err",
"=",
"n",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"oid",
".",
"Release",
"(",
")",
"\n",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"b",
".",
"String",
"(",
")",
",",
"oid",
",",
"err",
"\n",
"}"
] |
// Display "allows an application to obtain a textual representation of an
// opaque internal-form name for display purposes"
|
[
"Display",
"allows",
"an",
"application",
"to",
"obtain",
"a",
"textual",
"representation",
"of",
"an",
"opaque",
"internal",
"-",
"form",
"name",
"for",
"display",
"purposes"
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/name.go#L177-L197
|
14,981 |
apcera/gssapi
|
name.go
|
Canonicalize
|
func (n Name) Canonicalize(mech_type *OID) (canonical *Name, err error) {
canonical = &Name{
Lib: n.Lib,
}
var min C.OM_uint32
maj := C.wrap_gss_canonicalize_name(n.Fp_gss_canonicalize_name, &min,
n.C_gss_name_t, mech_type.C_gss_OID, &canonical.C_gss_name_t)
err = n.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return canonical, nil
}
|
go
|
func (n Name) Canonicalize(mech_type *OID) (canonical *Name, err error) {
canonical = &Name{
Lib: n.Lib,
}
var min C.OM_uint32
maj := C.wrap_gss_canonicalize_name(n.Fp_gss_canonicalize_name, &min,
n.C_gss_name_t, mech_type.C_gss_OID, &canonical.C_gss_name_t)
err = n.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return canonical, nil
}
|
[
"func",
"(",
"n",
"Name",
")",
"Canonicalize",
"(",
"mech_type",
"*",
"OID",
")",
"(",
"canonical",
"*",
"Name",
",",
"err",
"error",
")",
"{",
"canonical",
"=",
"&",
"Name",
"{",
"Lib",
":",
"n",
".",
"Lib",
",",
"}",
"\n\n",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_canonicalize_name",
"(",
"n",
".",
"Fp_gss_canonicalize_name",
",",
"&",
"min",
",",
"n",
".",
"C_gss_name_t",
",",
"mech_type",
".",
"C_gss_OID",
",",
"&",
"canonical",
".",
"C_gss_name_t",
")",
"\n",
"err",
"=",
"n",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"canonical",
",",
"nil",
"\n",
"}"
] |
// Canonicalize returns a copy of this name, canonicalized for the specified
// mechanism
|
[
"Canonicalize",
"returns",
"a",
"copy",
"of",
"this",
"name",
"canonicalized",
"for",
"the",
"specified",
"mechanism"
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/name.go#L207-L221
|
14,982 |
apcera/gssapi
|
name.go
|
InquireMechs
|
func (n *Name) InquireMechs() (oids *OIDSet, err error) {
oidset := n.NewOIDSet()
if err != nil {
return nil, err
}
var min C.OM_uint32
maj := C.wrap_gss_inquire_mechs_for_name(n.Fp_gss_inquire_mechs_for_name, &min,
n.C_gss_name_t, &oidset.C_gss_OID_set)
err = n.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return oidset, nil
}
|
go
|
func (n *Name) InquireMechs() (oids *OIDSet, err error) {
oidset := n.NewOIDSet()
if err != nil {
return nil, err
}
var min C.OM_uint32
maj := C.wrap_gss_inquire_mechs_for_name(n.Fp_gss_inquire_mechs_for_name, &min,
n.C_gss_name_t, &oidset.C_gss_OID_set)
err = n.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return oidset, nil
}
|
[
"func",
"(",
"n",
"*",
"Name",
")",
"InquireMechs",
"(",
")",
"(",
"oids",
"*",
"OIDSet",
",",
"err",
"error",
")",
"{",
"oidset",
":=",
"n",
".",
"NewOIDSet",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_inquire_mechs_for_name",
"(",
"n",
".",
"Fp_gss_inquire_mechs_for_name",
",",
"&",
"min",
",",
"n",
".",
"C_gss_name_t",
",",
"&",
"oidset",
".",
"C_gss_OID_set",
")",
"\n",
"err",
"=",
"n",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"oidset",
",",
"nil",
"\n",
"}"
] |
// InquireMechs returns the set of mechanisms supported by the GSS-API
// implementation that may be able to process the specified name
|
[
"InquireMechs",
"returns",
"the",
"set",
"of",
"mechanisms",
"supported",
"by",
"the",
"GSS",
"-",
"API",
"implementation",
"that",
"may",
"be",
"able",
"to",
"process",
"the",
"specified",
"name"
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/name.go#L262-L277
|
14,983 |
apcera/gssapi
|
name.go
|
InquireNamesForMechs
|
func (lib *Lib) InquireNamesForMechs(mech *OID) (name_types *OIDSet, err error) {
oidset := lib.NewOIDSet()
if err != nil {
return nil, err
}
var min C.OM_uint32
maj := C.wrap_gss_inquire_names_for_mech(lib.Fp_gss_inquire_mechs_for_name, &min,
mech.C_gss_OID, &oidset.C_gss_OID_set)
err = lib.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return oidset, nil
}
|
go
|
func (lib *Lib) InquireNamesForMechs(mech *OID) (name_types *OIDSet, err error) {
oidset := lib.NewOIDSet()
if err != nil {
return nil, err
}
var min C.OM_uint32
maj := C.wrap_gss_inquire_names_for_mech(lib.Fp_gss_inquire_mechs_for_name, &min,
mech.C_gss_OID, &oidset.C_gss_OID_set)
err = lib.stashLastStatus(maj, min)
if err != nil {
return nil, err
}
return oidset, nil
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"InquireNamesForMechs",
"(",
"mech",
"*",
"OID",
")",
"(",
"name_types",
"*",
"OIDSet",
",",
"err",
"error",
")",
"{",
"oidset",
":=",
"lib",
".",
"NewOIDSet",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"min",
"C",
".",
"OM_uint32",
"\n",
"maj",
":=",
"C",
".",
"wrap_gss_inquire_names_for_mech",
"(",
"lib",
".",
"Fp_gss_inquire_mechs_for_name",
",",
"&",
"min",
",",
"mech",
".",
"C_gss_OID",
",",
"&",
"oidset",
".",
"C_gss_OID_set",
")",
"\n",
"err",
"=",
"lib",
".",
"stashLastStatus",
"(",
"maj",
",",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"oidset",
",",
"nil",
"\n",
"}"
] |
// InquireNameForMech returns the set of name types supported by
// the specified mechanism
|
[
"InquireNameForMech",
"returns",
"the",
"set",
"of",
"name",
"types",
"supported",
"by",
"the",
"specified",
"mechanism"
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/name.go#L281-L296
|
14,984 |
apcera/gssapi
|
status.go
|
MakeError
|
func (lib *Lib) MakeError(major, minor C.OM_uint32) *Error {
return &Error{
Lib: lib,
Major: MajorStatus(major),
Minor: minor,
}
}
|
go
|
func (lib *Lib) MakeError(major, minor C.OM_uint32) *Error {
return &Error{
Lib: lib,
Major: MajorStatus(major),
Minor: minor,
}
}
|
[
"func",
"(",
"lib",
"*",
"Lib",
")",
"MakeError",
"(",
"major",
",",
"minor",
"C",
".",
"OM_uint32",
")",
"*",
"Error",
"{",
"return",
"&",
"Error",
"{",
"Lib",
":",
"lib",
",",
"Major",
":",
"MajorStatus",
"(",
"major",
")",
",",
"Minor",
":",
"minor",
",",
"}",
"\n",
"}"
] |
// MakeError creates a golang Error object from a gssapi major & minor status.
|
[
"MakeError",
"creates",
"a",
"golang",
"Error",
"object",
"from",
"a",
"gssapi",
"major",
"&",
"minor",
"status",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/status.go#L174-L180
|
14,985 |
apcera/gssapi
|
status.go
|
Error
|
func (e *Error) Error() string {
messages := []string{}
nOther := 0
context := C.OM_uint32(0)
inquiry := C.OM_uint32(0)
code_type := 0
first := true
if e.Major.RoutineError() == GSS_S_FAILURE {
inquiry = e.Minor
code_type = GSS_C_MECH_CODE
} else {
inquiry = C.OM_uint32(e.Major)
code_type = GSS_C_GSS_CODE
}
for first || context != C.OM_uint32(0) {
first = false
min := C.OM_uint32(0)
b, err := e.MakeBuffer(allocGSSAPI)
if err != nil {
break
}
// TODO: store a mech_type at the lib level? Or context? For now GSS_C_NO_OID...
maj := C.wrap_gss_display_status(
e.Fp_gss_display_status,
&min,
inquiry,
C.int(code_type),
nil,
&context,
b.C_gss_buffer_t)
err = 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")
}
|
go
|
func (e *Error) Error() string {
messages := []string{}
nOther := 0
context := C.OM_uint32(0)
inquiry := C.OM_uint32(0)
code_type := 0
first := true
if e.Major.RoutineError() == GSS_S_FAILURE {
inquiry = e.Minor
code_type = GSS_C_MECH_CODE
} else {
inquiry = C.OM_uint32(e.Major)
code_type = GSS_C_GSS_CODE
}
for first || context != C.OM_uint32(0) {
first = false
min := C.OM_uint32(0)
b, err := e.MakeBuffer(allocGSSAPI)
if err != nil {
break
}
// TODO: store a mech_type at the lib level? Or context? For now GSS_C_NO_OID...
maj := C.wrap_gss_display_status(
e.Fp_gss_display_status,
&min,
inquiry,
C.int(code_type),
nil,
&context,
b.C_gss_buffer_t)
err = 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")
}
|
[
"func",
"(",
"e",
"*",
"Error",
")",
"Error",
"(",
")",
"string",
"{",
"messages",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"nOther",
":=",
"0",
"\n",
"context",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"inquiry",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n",
"code_type",
":=",
"0",
"\n",
"first",
":=",
"true",
"\n\n",
"if",
"e",
".",
"Major",
".",
"RoutineError",
"(",
")",
"==",
"GSS_S_FAILURE",
"{",
"inquiry",
"=",
"e",
".",
"Minor",
"\n",
"code_type",
"=",
"GSS_C_MECH_CODE",
"\n",
"}",
"else",
"{",
"inquiry",
"=",
"C",
".",
"OM_uint32",
"(",
"e",
".",
"Major",
")",
"\n",
"code_type",
"=",
"GSS_C_GSS_CODE",
"\n",
"}",
"\n\n",
"for",
"first",
"||",
"context",
"!=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"{",
"first",
"=",
"false",
"\n",
"min",
":=",
"C",
".",
"OM_uint32",
"(",
"0",
")",
"\n\n",
"b",
",",
"err",
":=",
"e",
".",
"MakeBuffer",
"(",
"allocGSSAPI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"// TODO: store a mech_type at the lib level? Or context? For now GSS_C_NO_OID...",
"maj",
":=",
"C",
".",
"wrap_gss_display_status",
"(",
"e",
".",
"Fp_gss_display_status",
",",
"&",
"min",
",",
"inquiry",
",",
"C",
".",
"int",
"(",
"code_type",
")",
",",
"nil",
",",
"&",
"context",
",",
"b",
".",
"C_gss_buffer_t",
")",
"\n\n",
"err",
"=",
"e",
".",
"MakeError",
"(",
"maj",
",",
"min",
")",
".",
"GoError",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"nOther",
"=",
"nOther",
"+",
"1",
"\n",
"}",
"\n",
"messages",
"=",
"append",
"(",
"messages",
",",
"b",
".",
"String",
"(",
")",
")",
"\n",
"b",
".",
"Release",
"(",
")",
"\n",
"}",
"\n",
"if",
"nOther",
">",
"0",
"{",
"messages",
"=",
"append",
"(",
"messages",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"nOther",
")",
")",
"\n",
"}",
"\n",
"messages",
"=",
"append",
"(",
"messages",
",",
"\"",
"\"",
")",
"\n",
"return",
"strings",
".",
"Join",
"(",
"messages",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] |
// Error returns a string representation of an Error object.
|
[
"Error",
"returns",
"a",
"string",
"representation",
"of",
"an",
"Error",
"object",
"."
] |
5fb4217df13b8e6878046fe1e5c10e560e1b86dc
|
https://github.com/apcera/gssapi/blob/5fb4217df13b8e6878046fe1e5c10e560e1b86dc/status.go#L200-L247
|
14,986 |
bradleyjkemp/memviz
|
memviz.go
|
Map
|
func Map(w io.Writer, is ...interface{}) {
var iVals []reflect.Value
for _, i := range is {
iVal := reflect.ValueOf(i)
if !iVal.CanAddr() {
if iVal.Kind() != reflect.Ptr && iVal.Kind() != reflect.Interface {
fmt.Fprint(w, "error: cannot map unaddressable value")
return
}
iVal = iVal.Elem()
}
iVals = append(iVals, iVal)
}
m := &mapper{
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, "}")
}
|
go
|
func Map(w io.Writer, is ...interface{}) {
var iVals []reflect.Value
for _, i := range is {
iVal := reflect.ValueOf(i)
if !iVal.CanAddr() {
if iVal.Kind() != reflect.Ptr && iVal.Kind() != reflect.Interface {
fmt.Fprint(w, "error: cannot map unaddressable value")
return
}
iVal = iVal.Elem()
}
iVals = append(iVals, iVal)
}
m := &mapper{
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, "}")
}
|
[
"func",
"Map",
"(",
"w",
"io",
".",
"Writer",
",",
"is",
"...",
"interface",
"{",
"}",
")",
"{",
"var",
"iVals",
"[",
"]",
"reflect",
".",
"Value",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"is",
"{",
"iVal",
":=",
"reflect",
".",
"ValueOf",
"(",
"i",
")",
"\n",
"if",
"!",
"iVal",
".",
"CanAddr",
"(",
")",
"{",
"if",
"iVal",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"&&",
"iVal",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Interface",
"{",
"fmt",
".",
"Fprint",
"(",
"w",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"iVal",
"=",
"iVal",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"iVals",
"=",
"append",
"(",
"iVals",
",",
"iVal",
")",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"mapper",
"{",
"w",
",",
"map",
"[",
"nodeKey",
"]",
"nodeID",
"{",
"nilKey",
":",
"0",
"}",
",",
"map",
"[",
"nodeKey",
"]",
"string",
"{",
"nilKey",
":",
"\"",
"\"",
"}",
",",
"2",
",",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"w",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"w",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"iVal",
":=",
"range",
"iVals",
"{",
"m",
".",
"mapValue",
"(",
"iVal",
",",
"0",
",",
"false",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"w",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Map prints out a Graphviz digraph of the given datastructure to the given io.Writer
|
[
"Map",
"prints",
"out",
"a",
"Graphviz",
"digraph",
"of",
"the",
"given",
"datastructure",
"to",
"the",
"given",
"io",
".",
"Writer"
] |
4dc768b3c2246ec3ee2c15642ffc2d8ce8fa4d9d
|
https://github.com/bradleyjkemp/memviz/blob/4dc768b3c2246ec3ee2c15642ffc2d8ce8fa4d9d/memviz.go#L32-L60
|
14,987 |
antchfx/xpath
|
parse.go
|
newOperatorNode
|
func newOperatorNode(op string, left, right node) node {
return &operatorNode{nodeType: nodeOperator, Op: op, Left: left, Right: right}
}
|
go
|
func newOperatorNode(op string, left, right node) node {
return &operatorNode{nodeType: nodeOperator, Op: op, Left: left, Right: right}
}
|
[
"func",
"newOperatorNode",
"(",
"op",
"string",
",",
"left",
",",
"right",
"node",
")",
"node",
"{",
"return",
"&",
"operatorNode",
"{",
"nodeType",
":",
"nodeOperator",
",",
"Op",
":",
"op",
",",
"Left",
":",
"left",
",",
"Right",
":",
"right",
"}",
"\n",
"}"
] |
// newOperatorNode returns new operator node OperatorNode.
|
[
"newOperatorNode",
"returns",
"new",
"operator",
"node",
"OperatorNode",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L76-L78
|
14,988 |
antchfx/xpath
|
parse.go
|
newAxisNode
|
func newAxisNode(axeTyp, localName, prefix, prop string, n node) node {
return &axisNode{
nodeType: nodeAxis,
LocalName: localName,
Prefix: prefix,
AxeType: axeTyp,
Prop: prop,
Input: n,
}
}
|
go
|
func newAxisNode(axeTyp, localName, prefix, prop string, n node) node {
return &axisNode{
nodeType: nodeAxis,
LocalName: localName,
Prefix: prefix,
AxeType: axeTyp,
Prop: prop,
Input: n,
}
}
|
[
"func",
"newAxisNode",
"(",
"axeTyp",
",",
"localName",
",",
"prefix",
",",
"prop",
"string",
",",
"n",
"node",
")",
"node",
"{",
"return",
"&",
"axisNode",
"{",
"nodeType",
":",
"nodeAxis",
",",
"LocalName",
":",
"localName",
",",
"Prefix",
":",
"prefix",
",",
"AxeType",
":",
"axeTyp",
",",
"Prop",
":",
"prop",
",",
"Input",
":",
"n",
",",
"}",
"\n",
"}"
] |
// newAxisNode returns new axis node AxisNode.
|
[
"newAxisNode",
"returns",
"new",
"axis",
"node",
"AxisNode",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L86-L95
|
14,989 |
antchfx/xpath
|
parse.go
|
newVariableNode
|
func newVariableNode(prefix, name string) node {
return &variableNode{nodeType: nodeVariable, Name: name, Prefix: prefix}
}
|
go
|
func newVariableNode(prefix, name string) node {
return &variableNode{nodeType: nodeVariable, Name: name, Prefix: prefix}
}
|
[
"func",
"newVariableNode",
"(",
"prefix",
",",
"name",
"string",
")",
"node",
"{",
"return",
"&",
"variableNode",
"{",
"nodeType",
":",
"nodeVariable",
",",
"Name",
":",
"name",
",",
"Prefix",
":",
"prefix",
"}",
"\n",
"}"
] |
// newVariableNode returns new variable node VariableNode.
|
[
"newVariableNode",
"returns",
"new",
"variable",
"node",
"VariableNode",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L98-L100
|
14,990 |
antchfx/xpath
|
parse.go
|
newFilterNode
|
func newFilterNode(n, m node) node {
return &filterNode{nodeType: nodeFilter, Input: n, Condition: m}
}
|
go
|
func newFilterNode(n, m node) node {
return &filterNode{nodeType: nodeFilter, Input: n, Condition: m}
}
|
[
"func",
"newFilterNode",
"(",
"n",
",",
"m",
"node",
")",
"node",
"{",
"return",
"&",
"filterNode",
"{",
"nodeType",
":",
"nodeFilter",
",",
"Input",
":",
"n",
",",
"Condition",
":",
"m",
"}",
"\n",
"}"
] |
// newFilterNode returns a new filter node FilterNode.
|
[
"newFilterNode",
"returns",
"a",
"new",
"filter",
"node",
"FilterNode",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L103-L105
|
14,991 |
antchfx/xpath
|
parse.go
|
newFunctionNode
|
func newFunctionNode(name, prefix string, args []node) node {
return &functionNode{nodeType: nodeFunction, Prefix: prefix, FuncName: name, Args: args}
}
|
go
|
func newFunctionNode(name, prefix string, args []node) node {
return &functionNode{nodeType: nodeFunction, Prefix: prefix, FuncName: name, Args: args}
}
|
[
"func",
"newFunctionNode",
"(",
"name",
",",
"prefix",
"string",
",",
"args",
"[",
"]",
"node",
")",
"node",
"{",
"return",
"&",
"functionNode",
"{",
"nodeType",
":",
"nodeFunction",
",",
"Prefix",
":",
"prefix",
",",
"FuncName",
":",
"name",
",",
"Args",
":",
"args",
"}",
"\n",
"}"
] |
// newFunctionNode returns function call node.
|
[
"newFunctionNode",
"returns",
"function",
"call",
"node",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L113-L115
|
14,992 |
antchfx/xpath
|
parse.go
|
parseExpression
|
func (p *parser) parseExpression(n node) node {
if p.d = p.d + 1; p.d > 200 {
panic("the xpath query is too complex(depth > 200)")
}
n = p.parseOrExpr(n)
p.d--
return n
}
|
go
|
func (p *parser) parseExpression(n node) node {
if p.d = p.d + 1; p.d > 200 {
panic("the xpath query is too complex(depth > 200)")
}
n = p.parseOrExpr(n)
p.d--
return n
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseExpression",
"(",
"n",
"node",
")",
"node",
"{",
"if",
"p",
".",
"d",
"=",
"p",
".",
"d",
"+",
"1",
";",
"p",
".",
"d",
">",
"200",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"n",
"=",
"p",
".",
"parseOrExpr",
"(",
"n",
")",
"\n",
"p",
".",
"d",
"--",
"\n",
"return",
"n",
"\n",
"}"
] |
// parseExpression parsing the expression with input node n.
|
[
"parseExpression",
"parsing",
"the",
"expression",
"with",
"input",
"node",
"n",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L155-L162
|
14,993 |
antchfx/xpath
|
parse.go
|
parse
|
func parse(expr string) node {
r := &scanner{text: expr}
r.nextChar()
r.nextItem()
p := &parser{r: r}
return p.parseExpression(nil)
}
|
go
|
func parse(expr string) node {
r := &scanner{text: expr}
r.nextChar()
r.nextItem()
p := &parser{r: r}
return p.parseExpression(nil)
}
|
[
"func",
"parse",
"(",
"expr",
"string",
")",
"node",
"{",
"r",
":=",
"&",
"scanner",
"{",
"text",
":",
"expr",
"}",
"\n",
"r",
".",
"nextChar",
"(",
")",
"\n",
"r",
".",
"nextItem",
"(",
")",
"\n",
"p",
":=",
"&",
"parser",
"{",
"r",
":",
"r",
"}",
"\n",
"return",
"p",
".",
"parseExpression",
"(",
"nil",
")",
"\n",
"}"
] |
// Parse parsing the XPath express string expr and returns a tree node.
|
[
"Parse",
"parsing",
"the",
"XPath",
"express",
"string",
"expr",
"and",
"returns",
"a",
"tree",
"node",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/parse.go#L526-L532
|
14,994 |
antchfx/xpath
|
operator.go
|
cmpNumberNumberF
|
func cmpNumberNumberF(op string, a, b float64) bool {
switch op {
case "=":
return a == b
case ">":
return a > b
case "<":
return a < b
case ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
}
|
go
|
func cmpNumberNumberF(op string, a, b float64) bool {
switch op {
case "=":
return a == b
case ">":
return a > b
case "<":
return a < b
case ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
}
|
[
"func",
"cmpNumberNumberF",
"(",
"op",
"string",
",",
"a",
",",
"b",
"float64",
")",
"bool",
"{",
"switch",
"op",
"{",
"case",
"\"",
"\"",
":",
"return",
"a",
"==",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
">",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
"<",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
">=",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
"<=",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
"!=",
"b",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// number vs number
|
[
"number",
"vs",
"number"
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/operator.go#L48-L64
|
14,995 |
antchfx/xpath
|
operator.go
|
cmpStringStringF
|
func cmpStringStringF(op string, a, b string) bool {
switch op {
case "=":
return a == b
case ">":
return a > b
case "<":
return a < b
case ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
}
|
go
|
func cmpStringStringF(op string, a, b string) bool {
switch op {
case "=":
return a == b
case ">":
return a > b
case "<":
return a < b
case ">=":
return a >= b
case "<=":
return a <= b
case "!=":
return a != b
}
return false
}
|
[
"func",
"cmpStringStringF",
"(",
"op",
"string",
",",
"a",
",",
"b",
"string",
")",
"bool",
"{",
"switch",
"op",
"{",
"case",
"\"",
"\"",
":",
"return",
"a",
"==",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
">",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
"<",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
">=",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
"<=",
"b",
"\n",
"case",
"\"",
"\"",
":",
"return",
"a",
"!=",
"b",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// string vs string
|
[
"string",
"vs",
"string"
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/operator.go#L67-L83
|
14,996 |
antchfx/xpath
|
operator.go
|
eqFunc
|
func eqFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "=", m, n)
}
|
go
|
func eqFunc(t iterator, m, n interface{}) interface{} {
t1 := getValueType(m)
t2 := getValueType(n)
return logicalFuncs[t1][t2](t, "=", m, n)
}
|
[
"func",
"eqFunc",
"(",
"t",
"iterator",
",",
"m",
",",
"n",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"t1",
":=",
"getValueType",
"(",
"m",
")",
"\n",
"t2",
":=",
"getValueType",
"(",
"n",
")",
"\n",
"return",
"logicalFuncs",
"[",
"t1",
"]",
"[",
"t2",
"]",
"(",
"t",
",",
"\"",
"\"",
",",
"m",
",",
"n",
")",
"\n",
"}"
] |
// eqFunc is an `=` operator.
|
[
"eqFunc",
"is",
"an",
"=",
"operator",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/operator.go#L207-L211
|
14,997 |
antchfx/xpath
|
build.go
|
axisPredicate
|
func axisPredicate(root *axisNode) func(NodeNavigator) bool {
// get current axix node type.
typ := ElementNode
switch root.AxeType {
case "attribute":
typ = AttributeNode
case "self", "parent":
typ = allNode
default:
switch root.Prop {
case "comment":
typ = CommentNode
case "text":
typ = TextNode
// case "processing-instruction":
// typ = ProcessingInstructionNode
case "node":
typ = allNode
}
}
nametest := root.LocalName != "" || root.Prefix != ""
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
}
|
go
|
func axisPredicate(root *axisNode) func(NodeNavigator) bool {
// get current axix node type.
typ := ElementNode
switch root.AxeType {
case "attribute":
typ = AttributeNode
case "self", "parent":
typ = allNode
default:
switch root.Prop {
case "comment":
typ = CommentNode
case "text":
typ = TextNode
// case "processing-instruction":
// typ = ProcessingInstructionNode
case "node":
typ = allNode
}
}
nametest := root.LocalName != "" || root.Prefix != ""
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
}
|
[
"func",
"axisPredicate",
"(",
"root",
"*",
"axisNode",
")",
"func",
"(",
"NodeNavigator",
")",
"bool",
"{",
"// get current axix node type.",
"typ",
":=",
"ElementNode",
"\n",
"switch",
"root",
".",
"AxeType",
"{",
"case",
"\"",
"\"",
":",
"typ",
"=",
"AttributeNode",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"typ",
"=",
"allNode",
"\n",
"default",
":",
"switch",
"root",
".",
"Prop",
"{",
"case",
"\"",
"\"",
":",
"typ",
"=",
"CommentNode",
"\n",
"case",
"\"",
"\"",
":",
"typ",
"=",
"TextNode",
"\n",
"//\tcase \"processing-instruction\":",
"//\ttyp = ProcessingInstructionNode",
"case",
"\"",
"\"",
":",
"typ",
"=",
"allNode",
"\n",
"}",
"\n",
"}",
"\n",
"nametest",
":=",
"root",
".",
"LocalName",
"!=",
"\"",
"\"",
"||",
"root",
".",
"Prefix",
"!=",
"\"",
"\"",
"\n",
"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",
"\n",
"}",
"\n",
"}",
"else",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"predicate",
"\n",
"}"
] |
// axisPredicate creates a predicate to predicating for this axis node.
|
[
"axisPredicate",
"creates",
"a",
"predicate",
"to",
"predicating",
"for",
"this",
"axis",
"node",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/build.go#L23-L58
|
14,998 |
antchfx/xpath
|
build.go
|
processFilterNode
|
func (b *builder) processFilterNode(root *filterNode) (query, error) {
b.flag |= filterFlag
qyInput, err := b.processNode(root.Input)
if err != nil {
return nil, err
}
qyCond, err := b.processNode(root.Condition)
if err != nil {
return nil, err
}
qyOutput := &filterQuery{Input: qyInput, Predicate: qyCond}
return qyOutput, nil
}
|
go
|
func (b *builder) processFilterNode(root *filterNode) (query, error) {
b.flag |= filterFlag
qyInput, err := b.processNode(root.Input)
if err != nil {
return nil, err
}
qyCond, err := b.processNode(root.Condition)
if err != nil {
return nil, err
}
qyOutput := &filterQuery{Input: qyInput, Predicate: qyCond}
return qyOutput, nil
}
|
[
"func",
"(",
"b",
"*",
"builder",
")",
"processFilterNode",
"(",
"root",
"*",
"filterNode",
")",
"(",
"query",
",",
"error",
")",
"{",
"b",
".",
"flag",
"|=",
"filterFlag",
"\n\n",
"qyInput",
",",
"err",
":=",
"b",
".",
"processNode",
"(",
"root",
".",
"Input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"qyCond",
",",
"err",
":=",
"b",
".",
"processNode",
"(",
"root",
".",
"Condition",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"qyOutput",
":=",
"&",
"filterQuery",
"{",
"Input",
":",
"qyInput",
",",
"Predicate",
":",
"qyCond",
"}",
"\n",
"return",
"qyOutput",
",",
"nil",
"\n",
"}"
] |
// processFilterNode builds query for the XPath filter predicate.
|
[
"processFilterNode",
"builds",
"query",
"for",
"the",
"XPath",
"filter",
"predicate",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/build.go#L137-L150
|
14,999 |
antchfx/xpath
|
build.go
|
build
|
func build(expr string) (q query, err error) {
defer func() {
if e := recover(); e != nil {
switch x := e.(type) {
case string:
err = errors.New(x)
case error:
err = x
default:
err = errors.New("unknown panic")
}
}
}()
root := parse(expr)
b := &builder{}
return b.processNode(root)
}
|
go
|
func build(expr string) (q query, err error) {
defer func() {
if e := recover(); e != nil {
switch x := e.(type) {
case string:
err = errors.New(x)
case error:
err = x
default:
err = errors.New("unknown panic")
}
}
}()
root := parse(expr)
b := &builder{}
return b.processNode(root)
}
|
[
"func",
"build",
"(",
"expr",
"string",
")",
"(",
"q",
"query",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"e",
":=",
"recover",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"switch",
"x",
":=",
"e",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"err",
"=",
"errors",
".",
"New",
"(",
"x",
")",
"\n",
"case",
"error",
":",
"err",
"=",
"x",
"\n",
"default",
":",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"root",
":=",
"parse",
"(",
"expr",
")",
"\n",
"b",
":=",
"&",
"builder",
"{",
"}",
"\n",
"return",
"b",
".",
"processNode",
"(",
"root",
")",
"\n",
"}"
] |
// build builds a specified XPath expressions expr.
|
[
"build",
"builds",
"a",
"specified",
"XPath",
"expressions",
"expr",
"."
] |
ce1d48779e67a1ddfb380995fe532b2e0015919c
|
https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/build.go#L467-L483
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.