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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
go-xorm/xorm | session_cols.go | UseBool | func (session *Session) UseBool(columns ...string) *Session {
session.statement.UseBool(columns...)
return session
} | go | func (session *Session) UseBool(columns ...string) *Session {
session.statement.UseBool(columns...)
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"UseBool",
"(",
"columns",
"...",
"string",
")",
"*",
"Session",
"{",
"session",
".",
"statement",
".",
"UseBool",
"(",
"columns",
"...",
")",
"\n",
"return",
"session",
"\n",
"}"
] | // UseBool automatically retrieve condition according struct, but
// if struct has bool field, it will ignore them. So use UseBool
// to tell system to do not ignore them.
// If no parameters, it will use all the bool field of struct, or
// it will use parameters's columns | [
"UseBool",
"automatically",
"retrieve",
"condition",
"according",
"struct",
"but",
"if",
"struct",
"has",
"bool",
"field",
"it",
"will",
"ignore",
"them",
".",
"So",
"use",
"UseBool",
"to",
"tell",
"system",
"to",
"do",
"not",
"ignore",
"them",
".",
"If",
"no",
"parameters",
"it",
"will",
"use",
"all",
"the",
"bool",
"field",
"of",
"struct",
"or",
"it",
"will",
"use",
"parameters",
"s",
"columns"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_cols.go#L169-L172 | train |
go-xorm/xorm | session_cols.go | Omit | func (session *Session) Omit(columns ...string) *Session {
session.statement.Omit(columns...)
return session
} | go | func (session *Session) Omit(columns ...string) *Session {
session.statement.Omit(columns...)
return session
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"Omit",
"(",
"columns",
"...",
"string",
")",
"*",
"Session",
"{",
"session",
".",
"statement",
".",
"Omit",
"(",
"columns",
"...",
")",
"\n",
"return",
"session",
"\n",
"}"
] | // Omit Only not use the parameters as select or update columns | [
"Omit",
"Only",
"not",
"use",
"the",
"parameters",
"as",
"select",
"or",
"update",
"columns"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_cols.go#L183-L186 | train |
go-xorm/xorm | engine_group.go | NewEngineGroup | func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolicy) (*EngineGroup, error) {
var eg EngineGroup
if len(policies) > 0 {
eg.policy = policies[0]
} else {
eg.policy = RoundRobinPolicy()
}
driverName, ok1 := args1.(string)
conns, ok2 := args2.([]string)
if ok1 && ok2 {
engines := make([]*Engine, len(conns))
for i, conn := range conns {
engine, err := NewEngine(driverName, conn)
if err != nil {
return nil, err
}
engine.engineGroup = &eg
engines[i] = engine
}
eg.Engine = engines[0]
eg.slaves = engines[1:]
return &eg, nil
}
master, ok3 := args1.(*Engine)
slaves, ok4 := args2.([]*Engine)
if ok3 && ok4 {
master.engineGroup = &eg
for i := 0; i < len(slaves); i++ {
slaves[i].engineGroup = &eg
}
eg.Engine = master
eg.slaves = slaves
return &eg, nil
}
return nil, ErrParamsType
} | go | func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolicy) (*EngineGroup, error) {
var eg EngineGroup
if len(policies) > 0 {
eg.policy = policies[0]
} else {
eg.policy = RoundRobinPolicy()
}
driverName, ok1 := args1.(string)
conns, ok2 := args2.([]string)
if ok1 && ok2 {
engines := make([]*Engine, len(conns))
for i, conn := range conns {
engine, err := NewEngine(driverName, conn)
if err != nil {
return nil, err
}
engine.engineGroup = &eg
engines[i] = engine
}
eg.Engine = engines[0]
eg.slaves = engines[1:]
return &eg, nil
}
master, ok3 := args1.(*Engine)
slaves, ok4 := args2.([]*Engine)
if ok3 && ok4 {
master.engineGroup = &eg
for i := 0; i < len(slaves); i++ {
slaves[i].engineGroup = &eg
}
eg.Engine = master
eg.slaves = slaves
return &eg, nil
}
return nil, ErrParamsType
} | [
"func",
"NewEngineGroup",
"(",
"args1",
"interface",
"{",
"}",
",",
"args2",
"interface",
"{",
"}",
",",
"policies",
"...",
"GroupPolicy",
")",
"(",
"*",
"EngineGroup",
",",
"error",
")",
"{",
"var",
"eg",
"EngineGroup",
"\n",
"if",
"len",
"(",
"policies",
")",
">",
"0",
"{",
"eg",
".",
"policy",
"=",
"policies",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"eg",
".",
"policy",
"=",
"RoundRobinPolicy",
"(",
")",
"\n",
"}",
"\n\n",
"driverName",
",",
"ok1",
":=",
"args1",
".",
"(",
"string",
")",
"\n",
"conns",
",",
"ok2",
":=",
"args2",
".",
"(",
"[",
"]",
"string",
")",
"\n",
"if",
"ok1",
"&&",
"ok2",
"{",
"engines",
":=",
"make",
"(",
"[",
"]",
"*",
"Engine",
",",
"len",
"(",
"conns",
")",
")",
"\n",
"for",
"i",
",",
"conn",
":=",
"range",
"conns",
"{",
"engine",
",",
"err",
":=",
"NewEngine",
"(",
"driverName",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"engine",
".",
"engineGroup",
"=",
"&",
"eg",
"\n",
"engines",
"[",
"i",
"]",
"=",
"engine",
"\n",
"}",
"\n\n",
"eg",
".",
"Engine",
"=",
"engines",
"[",
"0",
"]",
"\n",
"eg",
".",
"slaves",
"=",
"engines",
"[",
"1",
":",
"]",
"\n",
"return",
"&",
"eg",
",",
"nil",
"\n",
"}",
"\n\n",
"master",
",",
"ok3",
":=",
"args1",
".",
"(",
"*",
"Engine",
")",
"\n",
"slaves",
",",
"ok4",
":=",
"args2",
".",
"(",
"[",
"]",
"*",
"Engine",
")",
"\n",
"if",
"ok3",
"&&",
"ok4",
"{",
"master",
".",
"engineGroup",
"=",
"&",
"eg",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"slaves",
")",
";",
"i",
"++",
"{",
"slaves",
"[",
"i",
"]",
".",
"engineGroup",
"=",
"&",
"eg",
"\n",
"}",
"\n",
"eg",
".",
"Engine",
"=",
"master",
"\n",
"eg",
".",
"slaves",
"=",
"slaves",
"\n",
"return",
"&",
"eg",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrParamsType",
"\n",
"}"
] | // NewEngineGroup creates a new engine group | [
"NewEngineGroup",
"creates",
"a",
"new",
"engine",
"group"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L22-L60 | train |
go-xorm/xorm | engine_group.go | Close | func (eg *EngineGroup) Close() error {
err := eg.Engine.Close()
if err != nil {
return err
}
for i := 0; i < len(eg.slaves); i++ {
err := eg.slaves[i].Close()
if err != nil {
return err
}
}
return nil
} | go | func (eg *EngineGroup) Close() error {
err := eg.Engine.Close()
if err != nil {
return err
}
for i := 0; i < len(eg.slaves); i++ {
err := eg.slaves[i].Close()
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"Close",
"(",
")",
"error",
"{",
"err",
":=",
"eg",
".",
"Engine",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"eg",
".",
"slaves",
")",
";",
"i",
"++",
"{",
"err",
":=",
"eg",
".",
"slaves",
"[",
"i",
"]",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close the engine | [
"Close",
"the",
"engine"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L63-L76 | train |
go-xorm/xorm | engine_group.go | Context | func (eg *EngineGroup) Context(ctx context.Context) *Session {
sess := eg.NewSession()
sess.isAutoClose = true
return sess.Context(ctx)
} | go | func (eg *EngineGroup) Context(ctx context.Context) *Session {
sess := eg.NewSession()
sess.isAutoClose = true
return sess.Context(ctx)
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"Context",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"Session",
"{",
"sess",
":=",
"eg",
".",
"NewSession",
"(",
")",
"\n",
"sess",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"sess",
".",
"Context",
"(",
"ctx",
")",
"\n",
"}"
] | // Context returned a group session | [
"Context",
"returned",
"a",
"group",
"session"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L79-L83 | train |
go-xorm/xorm | engine_group.go | NewSession | func (eg *EngineGroup) NewSession() *Session {
sess := eg.Engine.NewSession()
sess.sessionType = groupSession
return sess
} | go | func (eg *EngineGroup) NewSession() *Session {
sess := eg.Engine.NewSession()
sess.sessionType = groupSession
return sess
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"NewSession",
"(",
")",
"*",
"Session",
"{",
"sess",
":=",
"eg",
".",
"Engine",
".",
"NewSession",
"(",
")",
"\n",
"sess",
".",
"sessionType",
"=",
"groupSession",
"\n",
"return",
"sess",
"\n",
"}"
] | // NewSession returned a group session | [
"NewSession",
"returned",
"a",
"group",
"session"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L86-L90 | train |
go-xorm/xorm | engine_group.go | SetColumnMapper | func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) {
eg.Engine.ColumnMapper = mapper
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].ColumnMapper = mapper
}
} | go | func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) {
eg.Engine.ColumnMapper = mapper
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].ColumnMapper = mapper
}
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"SetColumnMapper",
"(",
"mapper",
"core",
".",
"IMapper",
")",
"{",
"eg",
".",
"Engine",
".",
"ColumnMapper",
"=",
"mapper",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"eg",
".",
"slaves",
")",
";",
"i",
"++",
"{",
"eg",
".",
"slaves",
"[",
"i",
"]",
".",
"ColumnMapper",
"=",
"mapper",
"\n",
"}",
"\n",
"}"
] | // SetColumnMapper set the column name mapping rule | [
"SetColumnMapper",
"set",
"the",
"column",
"name",
"mapping",
"rule"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L112-L117 | train |
go-xorm/xorm | engine_group.go | SetDefaultCacher | func (eg *EngineGroup) SetDefaultCacher(cacher core.Cacher) {
eg.Engine.SetDefaultCacher(cacher)
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].SetDefaultCacher(cacher)
}
} | go | func (eg *EngineGroup) SetDefaultCacher(cacher core.Cacher) {
eg.Engine.SetDefaultCacher(cacher)
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].SetDefaultCacher(cacher)
}
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"SetDefaultCacher",
"(",
"cacher",
"core",
".",
"Cacher",
")",
"{",
"eg",
".",
"Engine",
".",
"SetDefaultCacher",
"(",
"cacher",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"eg",
".",
"slaves",
")",
";",
"i",
"++",
"{",
"eg",
".",
"slaves",
"[",
"i",
"]",
".",
"SetDefaultCacher",
"(",
"cacher",
")",
"\n",
"}",
"\n",
"}"
] | // SetDefaultCacher set the default cacher | [
"SetDefaultCacher",
"set",
"the",
"default",
"cacher"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L128-L133 | train |
go-xorm/xorm | engine_group.go | SetMaxIdleConns | func (eg *EngineGroup) SetMaxIdleConns(conns int) {
eg.Engine.db.SetMaxIdleConns(conns)
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].db.SetMaxIdleConns(conns)
}
} | go | func (eg *EngineGroup) SetMaxIdleConns(conns int) {
eg.Engine.db.SetMaxIdleConns(conns)
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].db.SetMaxIdleConns(conns)
}
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"SetMaxIdleConns",
"(",
"conns",
"int",
")",
"{",
"eg",
".",
"Engine",
".",
"db",
".",
"SetMaxIdleConns",
"(",
"conns",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"eg",
".",
"slaves",
")",
";",
"i",
"++",
"{",
"eg",
".",
"slaves",
"[",
"i",
"]",
".",
"db",
".",
"SetMaxIdleConns",
"(",
"conns",
")",
"\n",
"}",
"\n",
"}"
] | // SetMaxIdleConns set the max idle connections on pool, default is 2 | [
"SetMaxIdleConns",
"set",
"the",
"max",
"idle",
"connections",
"on",
"pool",
"default",
"is",
"2"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L160-L165 | train |
go-xorm/xorm | engine_group.go | SetPolicy | func (eg *EngineGroup) SetPolicy(policy GroupPolicy) *EngineGroup {
eg.policy = policy
return eg
} | go | func (eg *EngineGroup) SetPolicy(policy GroupPolicy) *EngineGroup {
eg.policy = policy
return eg
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"SetPolicy",
"(",
"policy",
"GroupPolicy",
")",
"*",
"EngineGroup",
"{",
"eg",
".",
"policy",
"=",
"policy",
"\n",
"return",
"eg",
"\n",
"}"
] | // SetPolicy set the group policy | [
"SetPolicy",
"set",
"the",
"group",
"policy"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L176-L179 | train |
go-xorm/xorm | engine_group.go | SetTableMapper | func (eg *EngineGroup) SetTableMapper(mapper core.IMapper) {
eg.Engine.TableMapper = mapper
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].TableMapper = mapper
}
} | go | func (eg *EngineGroup) SetTableMapper(mapper core.IMapper) {
eg.Engine.TableMapper = mapper
for i := 0; i < len(eg.slaves); i++ {
eg.slaves[i].TableMapper = mapper
}
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"SetTableMapper",
"(",
"mapper",
"core",
".",
"IMapper",
")",
"{",
"eg",
".",
"Engine",
".",
"TableMapper",
"=",
"mapper",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"eg",
".",
"slaves",
")",
";",
"i",
"++",
"{",
"eg",
".",
"slaves",
"[",
"i",
"]",
".",
"TableMapper",
"=",
"mapper",
"\n",
"}",
"\n",
"}"
] | // SetTableMapper set the table name mapping rule | [
"SetTableMapper",
"set",
"the",
"table",
"name",
"mapping",
"rule"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L182-L187 | train |
go-xorm/xorm | engine_group.go | Slave | func (eg *EngineGroup) Slave() *Engine {
switch len(eg.slaves) {
case 0:
return eg.Engine
case 1:
return eg.slaves[0]
}
return eg.policy.Slave(eg)
} | go | func (eg *EngineGroup) Slave() *Engine {
switch len(eg.slaves) {
case 0:
return eg.Engine
case 1:
return eg.slaves[0]
}
return eg.policy.Slave(eg)
} | [
"func",
"(",
"eg",
"*",
"EngineGroup",
")",
"Slave",
"(",
")",
"*",
"Engine",
"{",
"switch",
"len",
"(",
"eg",
".",
"slaves",
")",
"{",
"case",
"0",
":",
"return",
"eg",
".",
"Engine",
"\n",
"case",
"1",
":",
"return",
"eg",
".",
"slaves",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"eg",
".",
"policy",
".",
"Slave",
"(",
"eg",
")",
"\n",
"}"
] | // Slave returns one of the physical databases which is a slave according the policy | [
"Slave",
"returns",
"one",
"of",
"the",
"physical",
"databases",
"which",
"is",
"a",
"slave",
"according",
"the",
"policy"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L206-L214 | train |
ginuerzh/gost | resolver.go | Init | func (ns *NameServer) Init() error {
timeout := ns.Timeout
if timeout <= 0 {
timeout = DefaultResolverTimeout
}
switch strings.ToLower(ns.Protocol) {
case "tcp":
ns.exchanger = &dnsExchanger{
endpoint: ns.Addr,
client: &dns.Client{
Net: "tcp",
Timeout: timeout,
},
}
case "tls":
cfg := &tls.Config{
ServerName: ns.Hostname,
}
if cfg.ServerName == "" {
cfg.InsecureSkipVerify = true
}
ns.exchanger = &dnsExchanger{
endpoint: ns.Addr,
client: &dns.Client{
Net: "tcp-tls",
Timeout: timeout,
TLSConfig: cfg,
},
}
case "https":
u, err := url.Parse(ns.Addr)
if err != nil {
return err
}
cfg := &tls.Config{ServerName: u.Hostname()}
transport := &http.Transport{
TLSClientConfig: cfg,
DisableCompression: true,
MaxIdleConns: 1,
}
http2.ConfigureTransport(transport)
ns.exchanger = &dohExchanger{
endpoint: u,
client: &http.Client{
Transport: transport,
Timeout: timeout,
},
}
case "udp":
fallthrough
default:
ns.exchanger = &dnsExchanger{
endpoint: ns.Addr,
client: &dns.Client{
Net: "udp",
Timeout: timeout,
},
}
}
return nil
} | go | func (ns *NameServer) Init() error {
timeout := ns.Timeout
if timeout <= 0 {
timeout = DefaultResolverTimeout
}
switch strings.ToLower(ns.Protocol) {
case "tcp":
ns.exchanger = &dnsExchanger{
endpoint: ns.Addr,
client: &dns.Client{
Net: "tcp",
Timeout: timeout,
},
}
case "tls":
cfg := &tls.Config{
ServerName: ns.Hostname,
}
if cfg.ServerName == "" {
cfg.InsecureSkipVerify = true
}
ns.exchanger = &dnsExchanger{
endpoint: ns.Addr,
client: &dns.Client{
Net: "tcp-tls",
Timeout: timeout,
TLSConfig: cfg,
},
}
case "https":
u, err := url.Parse(ns.Addr)
if err != nil {
return err
}
cfg := &tls.Config{ServerName: u.Hostname()}
transport := &http.Transport{
TLSClientConfig: cfg,
DisableCompression: true,
MaxIdleConns: 1,
}
http2.ConfigureTransport(transport)
ns.exchanger = &dohExchanger{
endpoint: u,
client: &http.Client{
Transport: transport,
Timeout: timeout,
},
}
case "udp":
fallthrough
default:
ns.exchanger = &dnsExchanger{
endpoint: ns.Addr,
client: &dns.Client{
Net: "udp",
Timeout: timeout,
},
}
}
return nil
} | [
"func",
"(",
"ns",
"*",
"NameServer",
")",
"Init",
"(",
")",
"error",
"{",
"timeout",
":=",
"ns",
".",
"Timeout",
"\n",
"if",
"timeout",
"<=",
"0",
"{",
"timeout",
"=",
"DefaultResolverTimeout",
"\n",
"}",
"\n\n",
"switch",
"strings",
".",
"ToLower",
"(",
"ns",
".",
"Protocol",
")",
"{",
"case",
"\"",
"\"",
":",
"ns",
".",
"exchanger",
"=",
"&",
"dnsExchanger",
"{",
"endpoint",
":",
"ns",
".",
"Addr",
",",
"client",
":",
"&",
"dns",
".",
"Client",
"{",
"Net",
":",
"\"",
"\"",
",",
"Timeout",
":",
"timeout",
",",
"}",
",",
"}",
"\n",
"case",
"\"",
"\"",
":",
"cfg",
":=",
"&",
"tls",
".",
"Config",
"{",
"ServerName",
":",
"ns",
".",
"Hostname",
",",
"}",
"\n",
"if",
"cfg",
".",
"ServerName",
"==",
"\"",
"\"",
"{",
"cfg",
".",
"InsecureSkipVerify",
"=",
"true",
"\n",
"}",
"\n\n",
"ns",
".",
"exchanger",
"=",
"&",
"dnsExchanger",
"{",
"endpoint",
":",
"ns",
".",
"Addr",
",",
"client",
":",
"&",
"dns",
".",
"Client",
"{",
"Net",
":",
"\"",
"\"",
",",
"Timeout",
":",
"timeout",
",",
"TLSConfig",
":",
"cfg",
",",
"}",
",",
"}",
"\n",
"case",
"\"",
"\"",
":",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"ns",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"cfg",
":=",
"&",
"tls",
".",
"Config",
"{",
"ServerName",
":",
"u",
".",
"Hostname",
"(",
")",
"}",
"\n",
"transport",
":=",
"&",
"http",
".",
"Transport",
"{",
"TLSClientConfig",
":",
"cfg",
",",
"DisableCompression",
":",
"true",
",",
"MaxIdleConns",
":",
"1",
",",
"}",
"\n",
"http2",
".",
"ConfigureTransport",
"(",
"transport",
")",
"\n\n",
"ns",
".",
"exchanger",
"=",
"&",
"dohExchanger",
"{",
"endpoint",
":",
"u",
",",
"client",
":",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"transport",
",",
"Timeout",
":",
"timeout",
",",
"}",
",",
"}",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"default",
":",
"ns",
".",
"exchanger",
"=",
"&",
"dnsExchanger",
"{",
"endpoint",
":",
"ns",
".",
"Addr",
",",
"client",
":",
"&",
"dns",
".",
"Client",
"{",
"Net",
":",
"\"",
"\"",
",",
"Timeout",
":",
"timeout",
",",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Init initializes the name server. | [
"Init",
"initializes",
"the",
"name",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/resolver.go#L53-L117 | train |
ginuerzh/gost | resolver.go | NewResolver | func NewResolver(ttl time.Duration, servers ...NameServer) ReloadResolver {
r := newResolver(ttl, servers...)
return r
} | go | func NewResolver(ttl time.Duration, servers ...NameServer) ReloadResolver {
r := newResolver(ttl, servers...)
return r
} | [
"func",
"NewResolver",
"(",
"ttl",
"time",
".",
"Duration",
",",
"servers",
"...",
"NameServer",
")",
"ReloadResolver",
"{",
"r",
":=",
"newResolver",
"(",
"ttl",
",",
"servers",
"...",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // NewResolver create a new Resolver with the given name servers and resolution timeout. | [
"NewResolver",
"create",
"a",
"new",
"Resolver",
"with",
"the",
"given",
"name",
"servers",
"and",
"resolution",
"timeout",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/resolver.go#L142-L145 | train |
ginuerzh/gost | reload.go | PeriodReload | func PeriodReload(r Reloader, configFile string) error {
if r == nil || configFile == "" {
return nil
}
var lastMod time.Time
for {
if r.Period() < 0 {
log.Log("[reload] stopped:", configFile)
return nil
}
f, err := os.Open(configFile)
if err != nil {
return err
}
mt := lastMod
if finfo, err := f.Stat(); err == nil {
mt = finfo.ModTime()
}
if !lastMod.IsZero() && !mt.Equal(lastMod) {
log.Log("[reload]", configFile)
if err := r.Reload(f); err != nil {
log.Logf("[reload] %s: %s", configFile, err)
}
}
f.Close()
lastMod = mt
period := r.Period()
if period == 0 {
log.Log("[reload] disabled:", configFile)
return nil
}
if period < time.Second {
period = time.Second
}
<-time.After(period)
}
} | go | func PeriodReload(r Reloader, configFile string) error {
if r == nil || configFile == "" {
return nil
}
var lastMod time.Time
for {
if r.Period() < 0 {
log.Log("[reload] stopped:", configFile)
return nil
}
f, err := os.Open(configFile)
if err != nil {
return err
}
mt := lastMod
if finfo, err := f.Stat(); err == nil {
mt = finfo.ModTime()
}
if !lastMod.IsZero() && !mt.Equal(lastMod) {
log.Log("[reload]", configFile)
if err := r.Reload(f); err != nil {
log.Logf("[reload] %s: %s", configFile, err)
}
}
f.Close()
lastMod = mt
period := r.Period()
if period == 0 {
log.Log("[reload] disabled:", configFile)
return nil
}
if period < time.Second {
period = time.Second
}
<-time.After(period)
}
} | [
"func",
"PeriodReload",
"(",
"r",
"Reloader",
",",
"configFile",
"string",
")",
"error",
"{",
"if",
"r",
"==",
"nil",
"||",
"configFile",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"lastMod",
"time",
".",
"Time",
"\n",
"for",
"{",
"if",
"r",
".",
"Period",
"(",
")",
"<",
"0",
"{",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"configFile",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"configFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"mt",
":=",
"lastMod",
"\n",
"if",
"finfo",
",",
"err",
":=",
"f",
".",
"Stat",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"mt",
"=",
"finfo",
".",
"ModTime",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"lastMod",
".",
"IsZero",
"(",
")",
"&&",
"!",
"mt",
".",
"Equal",
"(",
"lastMod",
")",
"{",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"configFile",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"Reload",
"(",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Logf",
"(",
"\"",
"\"",
",",
"configFile",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"f",
".",
"Close",
"(",
")",
"\n",
"lastMod",
"=",
"mt",
"\n\n",
"period",
":=",
"r",
".",
"Period",
"(",
")",
"\n",
"if",
"period",
"==",
"0",
"{",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"configFile",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"period",
"<",
"time",
".",
"Second",
"{",
"period",
"=",
"time",
".",
"Second",
"\n",
"}",
"\n",
"<-",
"time",
".",
"After",
"(",
"period",
")",
"\n",
"}",
"\n",
"}"
] | // PeriodReload reloads the config configFile periodically according to the period of the Reloader r. | [
"PeriodReload",
"reloads",
"the",
"config",
"configFile",
"periodically",
"according",
"to",
"the",
"period",
"of",
"the",
"Reloader",
"r",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/reload.go#L24-L65 | train |
ginuerzh/gost | http2.go | HTTP2Transporter | func HTTP2Transporter(config *tls.Config) Transporter {
if config == nil {
config = &tls.Config{InsecureSkipVerify: true}
}
return &http2Transporter{
clients: make(map[string]*http.Client),
tlsConfig: config,
}
} | go | func HTTP2Transporter(config *tls.Config) Transporter {
if config == nil {
config = &tls.Config{InsecureSkipVerify: true}
}
return &http2Transporter{
clients: make(map[string]*http.Client),
tlsConfig: config,
}
} | [
"func",
"HTTP2Transporter",
"(",
"config",
"*",
"tls",
".",
"Config",
")",
"Transporter",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"tls",
".",
"Config",
"{",
"InsecureSkipVerify",
":",
"true",
"}",
"\n",
"}",
"\n",
"return",
"&",
"http2Transporter",
"{",
"clients",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"http",
".",
"Client",
")",
",",
"tlsConfig",
":",
"config",
",",
"}",
"\n",
"}"
] | // HTTP2Transporter creates a Transporter that is used by HTTP2 h2 proxy client. | [
"HTTP2Transporter",
"creates",
"a",
"Transporter",
"that",
"is",
"used",
"by",
"HTTP2",
"h2",
"proxy",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http2.go#L109-L117 | train |
ginuerzh/gost | http2.go | H2Transporter | func H2Transporter(config *tls.Config) Transporter {
if config == nil {
config = &tls.Config{InsecureSkipVerify: true}
}
return &h2Transporter{
clients: make(map[string]*http.Client),
tlsConfig: config,
}
} | go | func H2Transporter(config *tls.Config) Transporter {
if config == nil {
config = &tls.Config{InsecureSkipVerify: true}
}
return &h2Transporter{
clients: make(map[string]*http.Client),
tlsConfig: config,
}
} | [
"func",
"H2Transporter",
"(",
"config",
"*",
"tls",
".",
"Config",
")",
"Transporter",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"tls",
".",
"Config",
"{",
"InsecureSkipVerify",
":",
"true",
"}",
"\n",
"}",
"\n",
"return",
"&",
"h2Transporter",
"{",
"clients",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"http",
".",
"Client",
")",
",",
"tlsConfig",
":",
"config",
",",
"}",
"\n",
"}"
] | // H2Transporter creates a Transporter that is used by HTTP2 h2 tunnel client. | [
"H2Transporter",
"creates",
"a",
"Transporter",
"that",
"is",
"used",
"by",
"HTTP2",
"h2",
"tunnel",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http2.go#L182-L190 | train |
ginuerzh/gost | http2.go | HTTP2Handler | func HTTP2Handler(opts ...HandlerOption) Handler {
h := &http2Handler{}
h.Init(opts...)
return h
} | go | func HTTP2Handler(opts ...HandlerOption) Handler {
h := &http2Handler{}
h.Init(opts...)
return h
} | [
"func",
"HTTP2Handler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"http2Handler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // HTTP2Handler creates a server Handler for HTTP2 proxy server. | [
"HTTP2Handler",
"creates",
"a",
"server",
"Handler",
"for",
"HTTP2",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http2.go#L290-L295 | train |
ginuerzh/gost | http2.go | HTTP2Listener | func HTTP2Listener(addr string, config *tls.Config) (Listener, error) {
l := &http2Listener{
connChan: make(chan *http2ServerConn, 1024),
errChan: make(chan error, 1),
}
if config == nil {
config = DefaultTLSConfig
}
server := &http.Server{
Addr: addr,
Handler: http.HandlerFunc(l.handleFunc),
TLSConfig: config,
}
if err := http2.ConfigureServer(server, nil); err != nil {
return nil, err
}
l.server = server
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l.addr = ln.Addr()
ln = tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config)
go func() {
err := server.Serve(ln)
if err != nil {
log.Log("[http2]", err)
}
}()
return l, nil
} | go | func HTTP2Listener(addr string, config *tls.Config) (Listener, error) {
l := &http2Listener{
connChan: make(chan *http2ServerConn, 1024),
errChan: make(chan error, 1),
}
if config == nil {
config = DefaultTLSConfig
}
server := &http.Server{
Addr: addr,
Handler: http.HandlerFunc(l.handleFunc),
TLSConfig: config,
}
if err := http2.ConfigureServer(server, nil); err != nil {
return nil, err
}
l.server = server
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l.addr = ln.Addr()
ln = tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config)
go func() {
err := server.Serve(ln)
if err != nil {
log.Log("[http2]", err)
}
}()
return l, nil
} | [
"func",
"HTTP2Listener",
"(",
"addr",
"string",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"l",
":=",
"&",
"http2Listener",
"{",
"connChan",
":",
"make",
"(",
"chan",
"*",
"http2ServerConn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n",
"server",
":=",
"&",
"http",
".",
"Server",
"{",
"Addr",
":",
"addr",
",",
"Handler",
":",
"http",
".",
"HandlerFunc",
"(",
"l",
".",
"handleFunc",
")",
",",
"TLSConfig",
":",
"config",
",",
"}",
"\n",
"if",
"err",
":=",
"http2",
".",
"ConfigureServer",
"(",
"server",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
".",
"server",
"=",
"server",
"\n\n",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
".",
"addr",
"=",
"ln",
".",
"Addr",
"(",
")",
"\n\n",
"ln",
"=",
"tls",
".",
"NewListener",
"(",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"config",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"err",
":=",
"server",
".",
"Serve",
"(",
"ln",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // HTTP2Listener creates a Listener for HTTP2 proxy server. | [
"HTTP2Listener",
"creates",
"a",
"Listener",
"for",
"HTTP2",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http2.go#L561-L594 | train |
ginuerzh/gost | http2.go | H2Listener | func H2Listener(addr string, config *tls.Config) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
if config == nil {
config = DefaultTLSConfig
}
l := &h2Listener{
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
server: &http2.Server{
// MaxConcurrentStreams: 1000,
PermitProhibitedCipherSuites: true,
IdleTimeout: 5 * time.Minute,
},
tlsConfig: config,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | go | func H2Listener(addr string, config *tls.Config) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
if config == nil {
config = DefaultTLSConfig
}
l := &h2Listener{
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
server: &http2.Server{
// MaxConcurrentStreams: 1000,
PermitProhibitedCipherSuites: true,
IdleTimeout: 5 * time.Minute,
},
tlsConfig: config,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | [
"func",
"H2Listener",
"(",
"addr",
"string",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n\n",
"l",
":=",
"&",
"h2Listener",
"{",
"Listener",
":",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"server",
":",
"&",
"http2",
".",
"Server",
"{",
"// MaxConcurrentStreams: 1000,",
"PermitProhibitedCipherSuites",
":",
"true",
",",
"IdleTimeout",
":",
"5",
"*",
"time",
".",
"Minute",
",",
"}",
",",
"tlsConfig",
":",
"config",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // H2Listener creates a Listener for HTTP2 h2 tunnel server. | [
"H2Listener",
"creates",
"a",
"Listener",
"for",
"HTTP2",
"h2",
"tunnel",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http2.go#L647-L670 | train |
ginuerzh/gost | http2.go | H2CListener | func H2CListener(addr string) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l := &h2Listener{
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
server: &http2.Server{
// MaxConcurrentStreams: 1000,
},
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | go | func H2CListener(addr string) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l := &h2Listener{
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
server: &http2.Server{
// MaxConcurrentStreams: 1000,
},
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | [
"func",
"H2CListener",
"(",
"addr",
"string",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
":=",
"&",
"h2Listener",
"{",
"Listener",
":",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"server",
":",
"&",
"http2",
".",
"Server",
"{",
"// MaxConcurrentStreams: 1000,",
"}",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // H2CListener creates a Listener for HTTP2 h2c tunnel server. | [
"H2CListener",
"creates",
"a",
"Listener",
"for",
"HTTP2",
"h2c",
"tunnel",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http2.go#L673-L689 | train |
ginuerzh/gost | ss.go | ShadowHandler | func ShadowHandler(opts ...HandlerOption) Handler {
h := &shadowHandler{}
h.Init(opts...)
return h
} | go | func ShadowHandler(opts ...HandlerOption) Handler {
h := &shadowHandler{}
h.Init(opts...)
return h
} | [
"func",
"ShadowHandler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"shadowHandler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // ShadowHandler creates a server Handler for shadowsocks proxy server. | [
"ShadowHandler",
"creates",
"a",
"server",
"Handler",
"for",
"shadowsocks",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ss.go#L77-L82 | train |
ginuerzh/gost | ss.go | getRequest | func (h *shadowHandler) getRequest(r io.Reader) (host string, err error) {
// buf size should at least have the same size with the largest possible
// request size (when addrType is 3, domain name has at most 256 bytes)
// 1(addrType) + 1(lenByte) + 256(max length address) + 2(port)
buf := make([]byte, smallBufferSize)
// read till we get possible domain length field
if _, err = io.ReadFull(r, buf[:idType+1]); err != nil {
return
}
var reqStart, reqEnd int
addrType := buf[idType]
switch addrType & ss.AddrMask {
case typeIPv4:
reqStart, reqEnd = idIP0, idIP0+lenIPv4
case typeIPv6:
reqStart, reqEnd = idIP0, idIP0+lenIPv6
case typeDm:
if _, err = io.ReadFull(r, buf[idType+1:idDmLen+1]); err != nil {
return
}
reqStart, reqEnd = idDm0, idDm0+int(buf[idDmLen])+lenDmBase
default:
err = fmt.Errorf("addr type %d not supported", addrType&ss.AddrMask)
return
}
if _, err = io.ReadFull(r, buf[reqStart:reqEnd]); err != nil {
return
}
// Return string for typeIP is not most efficient, but browsers (Chrome,
// Safari, Firefox) all seems using typeDm exclusively. So this is not a
// big problem.
switch addrType & ss.AddrMask {
case typeIPv4:
host = net.IP(buf[idIP0 : idIP0+net.IPv4len]).String()
case typeIPv6:
host = net.IP(buf[idIP0 : idIP0+net.IPv6len]).String()
case typeDm:
host = string(buf[idDm0 : idDm0+int(buf[idDmLen])])
}
// parse port
port := binary.BigEndian.Uint16(buf[reqEnd-2 : reqEnd])
host = net.JoinHostPort(host, strconv.Itoa(int(port)))
return
} | go | func (h *shadowHandler) getRequest(r io.Reader) (host string, err error) {
// buf size should at least have the same size with the largest possible
// request size (when addrType is 3, domain name has at most 256 bytes)
// 1(addrType) + 1(lenByte) + 256(max length address) + 2(port)
buf := make([]byte, smallBufferSize)
// read till we get possible domain length field
if _, err = io.ReadFull(r, buf[:idType+1]); err != nil {
return
}
var reqStart, reqEnd int
addrType := buf[idType]
switch addrType & ss.AddrMask {
case typeIPv4:
reqStart, reqEnd = idIP0, idIP0+lenIPv4
case typeIPv6:
reqStart, reqEnd = idIP0, idIP0+lenIPv6
case typeDm:
if _, err = io.ReadFull(r, buf[idType+1:idDmLen+1]); err != nil {
return
}
reqStart, reqEnd = idDm0, idDm0+int(buf[idDmLen])+lenDmBase
default:
err = fmt.Errorf("addr type %d not supported", addrType&ss.AddrMask)
return
}
if _, err = io.ReadFull(r, buf[reqStart:reqEnd]); err != nil {
return
}
// Return string for typeIP is not most efficient, but browsers (Chrome,
// Safari, Firefox) all seems using typeDm exclusively. So this is not a
// big problem.
switch addrType & ss.AddrMask {
case typeIPv4:
host = net.IP(buf[idIP0 : idIP0+net.IPv4len]).String()
case typeIPv6:
host = net.IP(buf[idIP0 : idIP0+net.IPv6len]).String()
case typeDm:
host = string(buf[idDm0 : idDm0+int(buf[idDmLen])])
}
// parse port
port := binary.BigEndian.Uint16(buf[reqEnd-2 : reqEnd])
host = net.JoinHostPort(host, strconv.Itoa(int(port)))
return
} | [
"func",
"(",
"h",
"*",
"shadowHandler",
")",
"getRequest",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"host",
"string",
",",
"err",
"error",
")",
"{",
"// buf size should at least have the same size with the largest possible",
"// request size (when addrType is 3, domain name has at most 256 bytes)",
"// 1(addrType) + 1(lenByte) + 256(max length address) + 2(port)",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"smallBufferSize",
")",
"\n\n",
"// read till we get possible domain length field",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"buf",
"[",
":",
"idType",
"+",
"1",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"var",
"reqStart",
",",
"reqEnd",
"int",
"\n",
"addrType",
":=",
"buf",
"[",
"idType",
"]",
"\n",
"switch",
"addrType",
"&",
"ss",
".",
"AddrMask",
"{",
"case",
"typeIPv4",
":",
"reqStart",
",",
"reqEnd",
"=",
"idIP0",
",",
"idIP0",
"+",
"lenIPv4",
"\n",
"case",
"typeIPv6",
":",
"reqStart",
",",
"reqEnd",
"=",
"idIP0",
",",
"idIP0",
"+",
"lenIPv6",
"\n",
"case",
"typeDm",
":",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"buf",
"[",
"idType",
"+",
"1",
":",
"idDmLen",
"+",
"1",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"reqStart",
",",
"reqEnd",
"=",
"idDm0",
",",
"idDm0",
"+",
"int",
"(",
"buf",
"[",
"idDmLen",
"]",
")",
"+",
"lenDmBase",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"addrType",
"&",
"ss",
".",
"AddrMask",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"buf",
"[",
"reqStart",
":",
"reqEnd",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// Return string for typeIP is not most efficient, but browsers (Chrome,",
"// Safari, Firefox) all seems using typeDm exclusively. So this is not a",
"// big problem.",
"switch",
"addrType",
"&",
"ss",
".",
"AddrMask",
"{",
"case",
"typeIPv4",
":",
"host",
"=",
"net",
".",
"IP",
"(",
"buf",
"[",
"idIP0",
":",
"idIP0",
"+",
"net",
".",
"IPv4len",
"]",
")",
".",
"String",
"(",
")",
"\n",
"case",
"typeIPv6",
":",
"host",
"=",
"net",
".",
"IP",
"(",
"buf",
"[",
"idIP0",
":",
"idIP0",
"+",
"net",
".",
"IPv6len",
"]",
")",
".",
"String",
"(",
")",
"\n",
"case",
"typeDm",
":",
"host",
"=",
"string",
"(",
"buf",
"[",
"idDm0",
":",
"idDm0",
"+",
"int",
"(",
"buf",
"[",
"idDmLen",
"]",
")",
"]",
")",
"\n",
"}",
"\n",
"// parse port",
"port",
":=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"buf",
"[",
"reqEnd",
"-",
"2",
":",
"reqEnd",
"]",
")",
"\n",
"host",
"=",
"net",
".",
"JoinHostPort",
"(",
"host",
",",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"port",
")",
")",
")",
"\n",
"return",
"\n",
"}"
] | // This function is copied from shadowsocks library with some modification. | [
"This",
"function",
"is",
"copied",
"from",
"shadowsocks",
"library",
"with",
"some",
"modification",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ss.go#L202-L249 | train |
ginuerzh/gost | ss.go | ShadowUDPListener | func ShadowUDPListener(addr string, cipher *url.Userinfo, ttl time.Duration) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenUDP("udp", laddr)
if err != nil {
return nil, err
}
var method, password string
if cipher != nil {
method = cipher.Username()
password, _ = cipher.Password()
}
cp, err := ss.NewCipher(method, password)
if err != nil {
ln.Close()
return nil, err
}
l := &shadowUDPListener{
ln: ss.NewSecurePacketConn(ln, cp, false),
conns: make(map[string]*udpServerConn),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
ttl: ttl,
}
go l.listenLoop()
return l, nil
} | go | func ShadowUDPListener(addr string, cipher *url.Userinfo, ttl time.Duration) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenUDP("udp", laddr)
if err != nil {
return nil, err
}
var method, password string
if cipher != nil {
method = cipher.Username()
password, _ = cipher.Password()
}
cp, err := ss.NewCipher(method, password)
if err != nil {
ln.Close()
return nil, err
}
l := &shadowUDPListener{
ln: ss.NewSecurePacketConn(ln, cp, false),
conns: make(map[string]*udpServerConn),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
ttl: ttl,
}
go l.listenLoop()
return l, nil
} | [
"func",
"ShadowUDPListener",
"(",
"addr",
"string",
",",
"cipher",
"*",
"url",
".",
"Userinfo",
",",
"ttl",
"time",
".",
"Duration",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"laddr",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"laddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"method",
",",
"password",
"string",
"\n",
"if",
"cipher",
"!=",
"nil",
"{",
"method",
"=",
"cipher",
".",
"Username",
"(",
")",
"\n",
"password",
",",
"_",
"=",
"cipher",
".",
"Password",
"(",
")",
"\n",
"}",
"\n",
"cp",
",",
"err",
":=",
"ss",
".",
"NewCipher",
"(",
"method",
",",
"password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ln",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
":=",
"&",
"shadowUDPListener",
"{",
"ln",
":",
"ss",
".",
"NewSecurePacketConn",
"(",
"ln",
",",
"cp",
",",
"false",
")",
",",
"conns",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"udpServerConn",
")",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"ttl",
":",
"ttl",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // ShadowUDPListener creates a Listener for shadowsocks UDP relay server. | [
"ShadowUDPListener",
"creates",
"a",
"Listener",
"for",
"shadowsocks",
"UDP",
"relay",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ss.go#L309-L338 | train |
ginuerzh/gost | ss.go | ShadowUDPdHandler | func ShadowUDPdHandler(opts ...HandlerOption) Handler {
h := &shadowUDPdHandler{}
h.Init(opts...)
return h
} | go | func ShadowUDPdHandler(opts ...HandlerOption) Handler {
h := &shadowUDPdHandler{}
h.Init(opts...)
return h
} | [
"func",
"ShadowUDPdHandler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"shadowUDPdHandler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // ShadowUDPdHandler creates a server Handler for shadowsocks UDP relay server. | [
"ShadowUDPdHandler",
"creates",
"a",
"server",
"Handler",
"for",
"shadowsocks",
"UDP",
"relay",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ss.go#L402-L407 | train |
ginuerzh/gost | forward.go | UDPDirectForwardListener | func UDPDirectForwardListener(addr string, ttl time.Duration) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenUDP("udp", laddr)
if err != nil {
return nil, err
}
l := &udpDirectForwardListener{
ln: ln,
conns: make(map[string]*udpServerConn),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
ttl: ttl,
}
go l.listenLoop()
return l, nil
} | go | func UDPDirectForwardListener(addr string, ttl time.Duration) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenUDP("udp", laddr)
if err != nil {
return nil, err
}
l := &udpDirectForwardListener{
ln: ln,
conns: make(map[string]*udpServerConn),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
ttl: ttl,
}
go l.listenLoop()
return l, nil
} | [
"func",
"UDPDirectForwardListener",
"(",
"addr",
"string",
",",
"ttl",
"time",
".",
"Duration",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"laddr",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"laddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
":=",
"&",
"udpDirectForwardListener",
"{",
"ln",
":",
"ln",
",",
"conns",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"udpServerConn",
")",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"ttl",
":",
"ttl",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // UDPDirectForwardListener creates a Listener for UDP port forwarding server. | [
"UDPDirectForwardListener",
"creates",
"a",
"Listener",
"for",
"UDP",
"port",
"forwarding",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/forward.go#L396-L414 | train |
ginuerzh/gost | forward.go | TCPRemoteForwardListener | func TCPRemoteForwardListener(addr string, chain *Chain) (Listener, error) {
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
ln := &tcpRemoteForwardListener{
addr: laddr,
chain: chain,
connChan: make(chan net.Conn, 1024),
closed: make(chan struct{}),
errChan: make(chan error),
}
if !ln.isChainValid() {
ln.ln, err = net.Listen("tcp", ln.addr.String())
return ln, err
}
go ln.listenLoop()
return ln, err
} | go | func TCPRemoteForwardListener(addr string, chain *Chain) (Listener, error) {
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
ln := &tcpRemoteForwardListener{
addr: laddr,
chain: chain,
connChan: make(chan net.Conn, 1024),
closed: make(chan struct{}),
errChan: make(chan error),
}
if !ln.isChainValid() {
ln.ln, err = net.Listen("tcp", ln.addr.String())
return ln, err
}
go ln.listenLoop()
return ln, err
} | [
"func",
"TCPRemoteForwardListener",
"(",
"addr",
"string",
",",
"chain",
"*",
"Chain",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"laddr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ln",
":=",
"&",
"tcpRemoteForwardListener",
"{",
"addr",
":",
"laddr",
",",
"chain",
":",
"chain",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"closed",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
")",
",",
"}",
"\n\n",
"if",
"!",
"ln",
".",
"isChainValid",
"(",
")",
"{",
"ln",
".",
"ln",
",",
"err",
"=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"ln",
".",
"addr",
".",
"String",
"(",
")",
")",
"\n",
"return",
"ln",
",",
"err",
"\n",
"}",
"\n\n",
"go",
"ln",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"ln",
",",
"err",
"\n",
"}"
] | // TCPRemoteForwardListener creates a Listener for TCP remote port forwarding server. | [
"TCPRemoteForwardListener",
"creates",
"a",
"Listener",
"for",
"TCP",
"remote",
"port",
"forwarding",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/forward.go#L644-L666 | train |
ginuerzh/gost | forward.go | UDPRemoteForwardListener | func UDPRemoteForwardListener(addr string, chain *Chain, ttl time.Duration) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
ln := &udpRemoteForwardListener{
addr: laddr,
chain: chain,
conns: make(map[string]*udpServerConn),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
ttl: ttl,
closed: make(chan struct{}),
}
go ln.listenLoop()
err = <-ln.errChan
return ln, err
} | go | func UDPRemoteForwardListener(addr string, chain *Chain, ttl time.Duration) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
ln := &udpRemoteForwardListener{
addr: laddr,
chain: chain,
conns: make(map[string]*udpServerConn),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
ttl: ttl,
closed: make(chan struct{}),
}
go ln.listenLoop()
err = <-ln.errChan
return ln, err
} | [
"func",
"UDPRemoteForwardListener",
"(",
"addr",
"string",
",",
"chain",
"*",
"Chain",
",",
"ttl",
"time",
".",
"Duration",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"laddr",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ln",
":=",
"&",
"udpRemoteForwardListener",
"{",
"addr",
":",
"laddr",
",",
"chain",
":",
"chain",
",",
"conns",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"udpServerConn",
")",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"ttl",
":",
"ttl",
",",
"closed",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n\n",
"go",
"ln",
".",
"listenLoop",
"(",
")",
"\n\n",
"err",
"=",
"<-",
"ln",
".",
"errChan",
"\n\n",
"return",
"ln",
",",
"err",
"\n",
"}"
] | // UDPRemoteForwardListener creates a Listener for UDP remote port forwarding server. | [
"UDPRemoteForwardListener",
"creates",
"a",
"Listener",
"for",
"UDP",
"remote",
"port",
"forwarding",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/forward.go#L902-L923 | train |
ginuerzh/gost | cmd/gost/cfg.go | tlsConfig | func tlsConfig(certFile, keyFile string) (*tls.Config, error) {
if certFile == "" {
certFile = defaultCertFile
}
if keyFile == "" {
keyFile = defaultKeyFile
}
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return nil, err
}
return &tls.Config{Certificates: []tls.Certificate{cert}}, nil
} | go | func tlsConfig(certFile, keyFile string) (*tls.Config, error) {
if certFile == "" {
certFile = defaultCertFile
}
if keyFile == "" {
keyFile = defaultKeyFile
}
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return nil, err
}
return &tls.Config{Certificates: []tls.Certificate{cert}}, nil
} | [
"func",
"tlsConfig",
"(",
"certFile",
",",
"keyFile",
"string",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"if",
"certFile",
"==",
"\"",
"\"",
"{",
"certFile",
"=",
"defaultCertFile",
"\n",
"}",
"\n",
"if",
"keyFile",
"==",
"\"",
"\"",
"{",
"keyFile",
"=",
"defaultKeyFile",
"\n",
"}",
"\n",
"cert",
",",
"err",
":=",
"tls",
".",
"LoadX509KeyPair",
"(",
"certFile",
",",
"keyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"tls",
".",
"Config",
"{",
"Certificates",
":",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"cert",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // Load the certificate from cert and key files, will use the default certificate if the provided info are invalid. | [
"Load",
"the",
"certificate",
"from",
"cert",
"and",
"key",
"files",
"will",
"use",
"the",
"default",
"certificate",
"if",
"the",
"provided",
"info",
"are",
"invalid",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/cmd/gost/cfg.go#L47-L59 | train |
ginuerzh/gost | selector.go | Apply | func (s *RoundStrategy) Apply(nodes []Node) Node {
if len(nodes) == 0 {
return Node{}
}
n := atomic.AddUint64(&s.counter, 1) - 1
return nodes[int(n%uint64(len(nodes)))]
} | go | func (s *RoundStrategy) Apply(nodes []Node) Node {
if len(nodes) == 0 {
return Node{}
}
n := atomic.AddUint64(&s.counter, 1) - 1
return nodes[int(n%uint64(len(nodes)))]
} | [
"func",
"(",
"s",
"*",
"RoundStrategy",
")",
"Apply",
"(",
"nodes",
"[",
"]",
"Node",
")",
"Node",
"{",
"if",
"len",
"(",
"nodes",
")",
"==",
"0",
"{",
"return",
"Node",
"{",
"}",
"\n",
"}",
"\n\n",
"n",
":=",
"atomic",
".",
"AddUint64",
"(",
"&",
"s",
".",
"counter",
",",
"1",
")",
"-",
"1",
"\n",
"return",
"nodes",
"[",
"int",
"(",
"n",
"%",
"uint64",
"(",
"len",
"(",
"nodes",
")",
")",
")",
"]",
"\n",
"}"
] | // Apply applies the round-robin strategy for the nodes. | [
"Apply",
"applies",
"the",
"round",
"-",
"robin",
"strategy",
"for",
"the",
"nodes",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/selector.go#L94-L101 | train |
ginuerzh/gost | selector.go | Apply | func (s *RandomStrategy) Apply(nodes []Node) Node {
s.once.Do(func() {
seed := s.Seed
if seed == 0 {
seed = time.Now().UnixNano()
}
s.rand = rand.New(rand.NewSource(seed))
})
if len(nodes) == 0 {
return Node{}
}
s.mux.Lock()
r := s.rand.Int()
s.mux.Unlock()
return nodes[r%len(nodes)]
} | go | func (s *RandomStrategy) Apply(nodes []Node) Node {
s.once.Do(func() {
seed := s.Seed
if seed == 0 {
seed = time.Now().UnixNano()
}
s.rand = rand.New(rand.NewSource(seed))
})
if len(nodes) == 0 {
return Node{}
}
s.mux.Lock()
r := s.rand.Int()
s.mux.Unlock()
return nodes[r%len(nodes)]
} | [
"func",
"(",
"s",
"*",
"RandomStrategy",
")",
"Apply",
"(",
"nodes",
"[",
"]",
"Node",
")",
"Node",
"{",
"s",
".",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"seed",
":=",
"s",
".",
"Seed",
"\n",
"if",
"seed",
"==",
"0",
"{",
"seed",
"=",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
"\n",
"}",
"\n",
"s",
".",
"rand",
"=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"seed",
")",
")",
"\n",
"}",
")",
"\n",
"if",
"len",
"(",
"nodes",
")",
"==",
"0",
"{",
"return",
"Node",
"{",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"r",
":=",
"s",
".",
"rand",
".",
"Int",
"(",
")",
"\n",
"s",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"nodes",
"[",
"r",
"%",
"len",
"(",
"nodes",
")",
"]",
"\n",
"}"
] | // Apply applies the random strategy for the nodes. | [
"Apply",
"applies",
"the",
"random",
"strategy",
"for",
"the",
"nodes",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/selector.go#L117-L134 | train |
ginuerzh/gost | selector.go | Apply | func (s *FIFOStrategy) Apply(nodes []Node) Node {
if len(nodes) == 0 {
return Node{}
}
return nodes[0]
} | go | func (s *FIFOStrategy) Apply(nodes []Node) Node {
if len(nodes) == 0 {
return Node{}
}
return nodes[0]
} | [
"func",
"(",
"s",
"*",
"FIFOStrategy",
")",
"Apply",
"(",
"nodes",
"[",
"]",
"Node",
")",
"Node",
"{",
"if",
"len",
"(",
"nodes",
")",
"==",
"0",
"{",
"return",
"Node",
"{",
"}",
"\n",
"}",
"\n",
"return",
"nodes",
"[",
"0",
"]",
"\n",
"}"
] | // Apply applies the fifo strategy for the nodes. | [
"Apply",
"applies",
"the",
"fifo",
"strategy",
"for",
"the",
"nodes",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/selector.go#L146-L151 | train |
ginuerzh/gost | selector.go | Filter | func (f *FailFilter) Filter(nodes []Node) []Node {
if len(nodes) <= 1 || f.MaxFails <= 0 {
return nodes
}
nl := []Node{}
for i := range nodes {
marker := &failMarker{}
if nil != nodes[i].marker {
marker = nodes[i].marker.Clone()
}
// log.Logf("%s: %d/%d %v/%v", nodes[i], marker.failCount, f.MaxFails, marker.failTime, f.FailTimeout)
if marker.failCount < uint32(f.MaxFails) ||
time.Since(time.Unix(marker.failTime, 0)) >= f.FailTimeout {
nl = append(nl, nodes[i])
}
}
return nl
} | go | func (f *FailFilter) Filter(nodes []Node) []Node {
if len(nodes) <= 1 || f.MaxFails <= 0 {
return nodes
}
nl := []Node{}
for i := range nodes {
marker := &failMarker{}
if nil != nodes[i].marker {
marker = nodes[i].marker.Clone()
}
// log.Logf("%s: %d/%d %v/%v", nodes[i], marker.failCount, f.MaxFails, marker.failTime, f.FailTimeout)
if marker.failCount < uint32(f.MaxFails) ||
time.Since(time.Unix(marker.failTime, 0)) >= f.FailTimeout {
nl = append(nl, nodes[i])
}
}
return nl
} | [
"func",
"(",
"f",
"*",
"FailFilter",
")",
"Filter",
"(",
"nodes",
"[",
"]",
"Node",
")",
"[",
"]",
"Node",
"{",
"if",
"len",
"(",
"nodes",
")",
"<=",
"1",
"||",
"f",
".",
"MaxFails",
"<=",
"0",
"{",
"return",
"nodes",
"\n",
"}",
"\n",
"nl",
":=",
"[",
"]",
"Node",
"{",
"}",
"\n",
"for",
"i",
":=",
"range",
"nodes",
"{",
"marker",
":=",
"&",
"failMarker",
"{",
"}",
"\n",
"if",
"nil",
"!=",
"nodes",
"[",
"i",
"]",
".",
"marker",
"{",
"marker",
"=",
"nodes",
"[",
"i",
"]",
".",
"marker",
".",
"Clone",
"(",
")",
"\n",
"}",
"\n",
"// log.Logf(\"%s: %d/%d %v/%v\", nodes[i], marker.failCount, f.MaxFails, marker.failTime, f.FailTimeout)",
"if",
"marker",
".",
"failCount",
"<",
"uint32",
"(",
"f",
".",
"MaxFails",
")",
"||",
"time",
".",
"Since",
"(",
"time",
".",
"Unix",
"(",
"marker",
".",
"failTime",
",",
"0",
")",
")",
">=",
"f",
".",
"FailTimeout",
"{",
"nl",
"=",
"append",
"(",
"nl",
",",
"nodes",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nl",
"\n",
"}"
] | // Filter filters nodes. | [
"Filter",
"filters",
"nodes",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/selector.go#L171-L188 | train |
ginuerzh/gost | handler.go | UsersHandlerOption | func UsersHandlerOption(users ...*url.Userinfo) HandlerOption {
return func(opts *HandlerOptions) {
opts.Users = users
kvs := make(map[string]string)
for _, u := range users {
if u != nil {
kvs[u.Username()], _ = u.Password()
}
}
if len(kvs) > 0 {
opts.Authenticator = NewLocalAuthenticator(kvs)
}
}
} | go | func UsersHandlerOption(users ...*url.Userinfo) HandlerOption {
return func(opts *HandlerOptions) {
opts.Users = users
kvs := make(map[string]string)
for _, u := range users {
if u != nil {
kvs[u.Username()], _ = u.Password()
}
}
if len(kvs) > 0 {
opts.Authenticator = NewLocalAuthenticator(kvs)
}
}
} | [
"func",
"UsersHandlerOption",
"(",
"users",
"...",
"*",
"url",
".",
"Userinfo",
")",
"HandlerOption",
"{",
"return",
"func",
"(",
"opts",
"*",
"HandlerOptions",
")",
"{",
"opts",
".",
"Users",
"=",
"users",
"\n\n",
"kvs",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"u",
":=",
"range",
"users",
"{",
"if",
"u",
"!=",
"nil",
"{",
"kvs",
"[",
"u",
".",
"Username",
"(",
")",
"]",
",",
"_",
"=",
"u",
".",
"Password",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"kvs",
")",
">",
"0",
"{",
"opts",
".",
"Authenticator",
"=",
"NewLocalAuthenticator",
"(",
"kvs",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // UsersHandlerOption sets the Users option of HandlerOptions. | [
"UsersHandlerOption",
"sets",
"the",
"Users",
"option",
"of",
"HandlerOptions",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/handler.go#L59-L73 | train |
ginuerzh/gost | handler.go | TLSConfigHandlerOption | func TLSConfigHandlerOption(config *tls.Config) HandlerOption {
return func(opts *HandlerOptions) {
opts.TLSConfig = config
}
} | go | func TLSConfigHandlerOption(config *tls.Config) HandlerOption {
return func(opts *HandlerOptions) {
opts.TLSConfig = config
}
} | [
"func",
"TLSConfigHandlerOption",
"(",
"config",
"*",
"tls",
".",
"Config",
")",
"HandlerOption",
"{",
"return",
"func",
"(",
"opts",
"*",
"HandlerOptions",
")",
"{",
"opts",
".",
"TLSConfig",
"=",
"config",
"\n",
"}",
"\n",
"}"
] | // TLSConfigHandlerOption sets the TLSConfig option of HandlerOptions. | [
"TLSConfigHandlerOption",
"sets",
"the",
"TLSConfig",
"option",
"of",
"HandlerOptions",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/handler.go#L83-L87 | train |
ginuerzh/gost | handler.go | TimeoutHandlerOption | func TimeoutHandlerOption(timeout time.Duration) HandlerOption {
return func(opts *HandlerOptions) {
opts.Timeout = timeout
}
} | go | func TimeoutHandlerOption(timeout time.Duration) HandlerOption {
return func(opts *HandlerOptions) {
opts.Timeout = timeout
}
} | [
"func",
"TimeoutHandlerOption",
"(",
"timeout",
"time",
".",
"Duration",
")",
"HandlerOption",
"{",
"return",
"func",
"(",
"opts",
"*",
"HandlerOptions",
")",
"{",
"opts",
".",
"Timeout",
"=",
"timeout",
"\n",
"}",
"\n",
"}"
] | // TimeoutHandlerOption sets the timeout option of HandlerOptions. | [
"TimeoutHandlerOption",
"sets",
"the",
"timeout",
"option",
"of",
"HandlerOptions",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/handler.go#L125-L129 | train |
ginuerzh/gost | handler.go | AutoHandler | func AutoHandler(opts ...HandlerOption) Handler {
h := &autoHandler{}
h.Init(opts...)
return h
} | go | func AutoHandler(opts ...HandlerOption) Handler {
h := &autoHandler{}
h.Init(opts...)
return h
} | [
"func",
"AutoHandler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"autoHandler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n",
"return",
"h",
"\n",
"}"
] | // AutoHandler creates a server Handler for auto proxy server. | [
"AutoHandler",
"creates",
"a",
"server",
"Handler",
"for",
"auto",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/handler.go#L171-L175 | train |
ginuerzh/gost | log.go | Logf | func (l *LogLogger) Logf(format string, v ...interface{}) {
log.Output(3, fmt.Sprintf(format, v...))
} | go | func (l *LogLogger) Logf(format string, v ...interface{}) {
log.Output(3, fmt.Sprintf(format, v...))
} | [
"func",
"(",
"l",
"*",
"LogLogger",
")",
"Logf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"log",
".",
"Output",
"(",
"3",
",",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Logf uses the standard log library log.Output | [
"Logf",
"uses",
"the",
"standard",
"log",
"library",
"log",
".",
"Output"
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/log.go#L22-L24 | train |
ginuerzh/gost | ssh.go | SSHForwardHandler | func SSHForwardHandler(opts ...HandlerOption) Handler {
h := &sshForwardHandler{}
h.Init(opts...)
return h
} | go | func SSHForwardHandler(opts ...HandlerOption) Handler {
h := &sshForwardHandler{}
h.Init(opts...)
return h
} | [
"func",
"SSHForwardHandler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"sshForwardHandler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // SSHForwardHandler creates a server Handler for SSH port forwarding server. | [
"SSHForwardHandler",
"creates",
"a",
"server",
"Handler",
"for",
"SSH",
"port",
"forwarding",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ssh.go#L451-L456 | train |
ginuerzh/gost | ssh.go | SSHTunnelListener | func SSHTunnelListener(addr string, config *SSHConfig) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
if config == nil {
config = &SSHConfig{}
}
sshConfig := &ssh.ServerConfig{}
sshConfig.PasswordCallback = defaultSSHPasswordCallback(config.Authenticator)
if config.Authenticator == nil {
sshConfig.NoClientAuth = true
}
tlsConfig := config.TLSConfig
if tlsConfig == nil {
tlsConfig = DefaultTLSConfig
}
signer, err := ssh.NewSignerFromKey(tlsConfig.Certificates[0].PrivateKey)
if err != nil {
ln.Close()
return nil, err
}
sshConfig.AddHostKey(signer)
l := &sshTunnelListener{
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
config: sshConfig,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | go | func SSHTunnelListener(addr string, config *SSHConfig) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
if config == nil {
config = &SSHConfig{}
}
sshConfig := &ssh.ServerConfig{}
sshConfig.PasswordCallback = defaultSSHPasswordCallback(config.Authenticator)
if config.Authenticator == nil {
sshConfig.NoClientAuth = true
}
tlsConfig := config.TLSConfig
if tlsConfig == nil {
tlsConfig = DefaultTLSConfig
}
signer, err := ssh.NewSignerFromKey(tlsConfig.Certificates[0].PrivateKey)
if err != nil {
ln.Close()
return nil, err
}
sshConfig.AddHostKey(signer)
l := &sshTunnelListener{
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
config: sshConfig,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | [
"func",
"SSHTunnelListener",
"(",
"addr",
"string",
",",
"config",
"*",
"SSHConfig",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"SSHConfig",
"{",
"}",
"\n",
"}",
"\n\n",
"sshConfig",
":=",
"&",
"ssh",
".",
"ServerConfig",
"{",
"}",
"\n",
"sshConfig",
".",
"PasswordCallback",
"=",
"defaultSSHPasswordCallback",
"(",
"config",
".",
"Authenticator",
")",
"\n",
"if",
"config",
".",
"Authenticator",
"==",
"nil",
"{",
"sshConfig",
".",
"NoClientAuth",
"=",
"true",
"\n",
"}",
"\n",
"tlsConfig",
":=",
"config",
".",
"TLSConfig",
"\n",
"if",
"tlsConfig",
"==",
"nil",
"{",
"tlsConfig",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n\n",
"signer",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"tlsConfig",
".",
"Certificates",
"[",
"0",
"]",
".",
"PrivateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ln",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n\n",
"}",
"\n",
"sshConfig",
".",
"AddHostKey",
"(",
"signer",
")",
"\n\n",
"l",
":=",
"&",
"sshTunnelListener",
"{",
"Listener",
":",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"config",
":",
"sshConfig",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // SSHTunnelListener creates a Listener for SSH tunnel server. | [
"SSHTunnelListener",
"creates",
"a",
"Listener",
"for",
"SSH",
"tunnel",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ssh.go#L679-L717 | train |
ginuerzh/gost | quic.go | QUICTransporter | func QUICTransporter(config *QUICConfig) Transporter {
if config == nil {
config = &QUICConfig{}
}
return &quicTransporter{
config: config,
sessions: make(map[string]*quicSession),
}
} | go | func QUICTransporter(config *QUICConfig) Transporter {
if config == nil {
config = &QUICConfig{}
}
return &quicTransporter{
config: config,
sessions: make(map[string]*quicSession),
}
} | [
"func",
"QUICTransporter",
"(",
"config",
"*",
"QUICConfig",
")",
"Transporter",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"QUICConfig",
"{",
"}",
"\n",
"}",
"\n",
"return",
"&",
"quicTransporter",
"{",
"config",
":",
"config",
",",
"sessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"quicSession",
")",
",",
"}",
"\n",
"}"
] | // QUICTransporter creates a Transporter that is used by QUIC proxy client. | [
"QUICTransporter",
"creates",
"a",
"Transporter",
"that",
"is",
"used",
"by",
"QUIC",
"proxy",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/quic.go#L46-L54 | train |
ginuerzh/gost | quic.go | QUICListener | func QUICListener(addr string, config *QUICConfig) (Listener, error) {
if config == nil {
config = &QUICConfig{}
}
quicConfig := &quic.Config{
HandshakeTimeout: config.Timeout,
KeepAlive: config.KeepAlive,
IdleTimeout: config.IdleTimeout,
}
tlsConfig := config.TLSConfig
if tlsConfig == nil {
tlsConfig = DefaultTLSConfig
}
var conn net.PacketConn
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
lconn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return nil, err
}
conn = lconn
if config.Key != nil {
conn = &quicCipherConn{UDPConn: lconn, key: config.Key}
}
ln, err := quic.Listen(conn, tlsConfig, quicConfig)
if err != nil {
return nil, err
}
l := &quicListener{
ln: ln,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | go | func QUICListener(addr string, config *QUICConfig) (Listener, error) {
if config == nil {
config = &QUICConfig{}
}
quicConfig := &quic.Config{
HandshakeTimeout: config.Timeout,
KeepAlive: config.KeepAlive,
IdleTimeout: config.IdleTimeout,
}
tlsConfig := config.TLSConfig
if tlsConfig == nil {
tlsConfig = DefaultTLSConfig
}
var conn net.PacketConn
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
lconn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return nil, err
}
conn = lconn
if config.Key != nil {
conn = &quicCipherConn{UDPConn: lconn, key: config.Key}
}
ln, err := quic.Listen(conn, tlsConfig, quicConfig)
if err != nil {
return nil, err
}
l := &quicListener{
ln: ln,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | [
"func",
"QUICListener",
"(",
"addr",
"string",
",",
"config",
"*",
"QUICConfig",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"QUICConfig",
"{",
"}",
"\n",
"}",
"\n",
"quicConfig",
":=",
"&",
"quic",
".",
"Config",
"{",
"HandshakeTimeout",
":",
"config",
".",
"Timeout",
",",
"KeepAlive",
":",
"config",
".",
"KeepAlive",
",",
"IdleTimeout",
":",
"config",
".",
"IdleTimeout",
",",
"}",
"\n\n",
"tlsConfig",
":=",
"config",
".",
"TLSConfig",
"\n",
"if",
"tlsConfig",
"==",
"nil",
"{",
"tlsConfig",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n\n",
"var",
"conn",
"net",
".",
"PacketConn",
"\n\n",
"udpAddr",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"lconn",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"udpAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"conn",
"=",
"lconn",
"\n\n",
"if",
"config",
".",
"Key",
"!=",
"nil",
"{",
"conn",
"=",
"&",
"quicCipherConn",
"{",
"UDPConn",
":",
"lconn",
",",
"key",
":",
"config",
".",
"Key",
"}",
"\n",
"}",
"\n\n",
"ln",
",",
"err",
":=",
"quic",
".",
"Listen",
"(",
"conn",
",",
"tlsConfig",
",",
"quicConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"l",
":=",
"&",
"quicListener",
"{",
"ln",
":",
"ln",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // QUICListener creates a Listener for QUIC proxy server. | [
"QUICListener",
"creates",
"a",
"Listener",
"for",
"QUIC",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/quic.go#L178-L222 | train |
ginuerzh/gost | ws.go | MWSTransporter | func MWSTransporter(opts *WSOptions) Transporter {
return &mwsTransporter{
options: opts,
sessions: make(map[string]*muxSession),
}
} | go | func MWSTransporter(opts *WSOptions) Transporter {
return &mwsTransporter{
options: opts,
sessions: make(map[string]*muxSession),
}
} | [
"func",
"MWSTransporter",
"(",
"opts",
"*",
"WSOptions",
")",
"Transporter",
"{",
"return",
"&",
"mwsTransporter",
"{",
"options",
":",
"opts",
",",
"sessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"muxSession",
")",
",",
"}",
"\n",
"}"
] | // MWSTransporter creates a Transporter that is used by multiplex-websocket proxy client. | [
"MWSTransporter",
"creates",
"a",
"Transporter",
"that",
"is",
"used",
"by",
"multiplex",
"-",
"websocket",
"proxy",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ws.go#L77-L82 | train |
ginuerzh/gost | ws.go | MWSSTransporter | func MWSSTransporter(opts *WSOptions) Transporter {
return &mwssTransporter{
options: opts,
sessions: make(map[string]*muxSession),
}
} | go | func MWSSTransporter(opts *WSOptions) Transporter {
return &mwssTransporter{
options: opts,
sessions: make(map[string]*muxSession),
}
} | [
"func",
"MWSSTransporter",
"(",
"opts",
"*",
"WSOptions",
")",
"Transporter",
"{",
"return",
"&",
"mwssTransporter",
"{",
"options",
":",
"opts",
",",
"sessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"muxSession",
")",
",",
"}",
"\n",
"}"
] | // MWSSTransporter creates a Transporter that is used by multiplex-websocket secure proxy client. | [
"MWSSTransporter",
"creates",
"a",
"Transporter",
"that",
"is",
"used",
"by",
"multiplex",
"-",
"websocket",
"secure",
"proxy",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ws.go#L234-L239 | train |
ginuerzh/gost | ws.go | WSSListener | func WSSListener(addr string, tlsConfig *tls.Config, options *WSOptions) (Listener, error) {
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
if options == nil {
options = &WSOptions{}
}
l := &wssListener{
wsListener: &wsListener{
upgrader: &websocket.Upgrader{
ReadBufferSize: options.ReadBufferSize,
WriteBufferSize: options.WriteBufferSize,
CheckOrigin: func(r *http.Request) bool { return true },
EnableCompression: options.EnableCompression,
},
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
},
}
if tlsConfig == nil {
tlsConfig = DefaultTLSConfig
}
path := options.Path
if path == "" {
path = defaultWSPath
}
mux := http.NewServeMux()
mux.Handle(path, http.HandlerFunc(l.upgrade))
l.srv = &http.Server{
Addr: addr,
TLSConfig: tlsConfig,
Handler: mux,
ReadHeaderTimeout: 30 * time.Second,
}
ln, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
return nil, err
}
l.addr = ln.Addr()
go func() {
err := l.srv.Serve(tls.NewListener(tcpKeepAliveListener{ln}, tlsConfig))
if err != nil {
l.errChan <- err
}
close(l.errChan)
}()
select {
case err := <-l.errChan:
return nil, err
default:
}
return l, nil
} | go | func WSSListener(addr string, tlsConfig *tls.Config, options *WSOptions) (Listener, error) {
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
if options == nil {
options = &WSOptions{}
}
l := &wssListener{
wsListener: &wsListener{
upgrader: &websocket.Upgrader{
ReadBufferSize: options.ReadBufferSize,
WriteBufferSize: options.WriteBufferSize,
CheckOrigin: func(r *http.Request) bool { return true },
EnableCompression: options.EnableCompression,
},
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
},
}
if tlsConfig == nil {
tlsConfig = DefaultTLSConfig
}
path := options.Path
if path == "" {
path = defaultWSPath
}
mux := http.NewServeMux()
mux.Handle(path, http.HandlerFunc(l.upgrade))
l.srv = &http.Server{
Addr: addr,
TLSConfig: tlsConfig,
Handler: mux,
ReadHeaderTimeout: 30 * time.Second,
}
ln, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
return nil, err
}
l.addr = ln.Addr()
go func() {
err := l.srv.Serve(tls.NewListener(tcpKeepAliveListener{ln}, tlsConfig))
if err != nil {
l.errChan <- err
}
close(l.errChan)
}()
select {
case err := <-l.errChan:
return nil, err
default:
}
return l, nil
} | [
"func",
"WSSListener",
"(",
"addr",
"string",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
",",
"options",
"*",
"WSOptions",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"tcpAddr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"options",
"==",
"nil",
"{",
"options",
"=",
"&",
"WSOptions",
"{",
"}",
"\n",
"}",
"\n",
"l",
":=",
"&",
"wssListener",
"{",
"wsListener",
":",
"&",
"wsListener",
"{",
"upgrader",
":",
"&",
"websocket",
".",
"Upgrader",
"{",
"ReadBufferSize",
":",
"options",
".",
"ReadBufferSize",
",",
"WriteBufferSize",
":",
"options",
".",
"WriteBufferSize",
",",
"CheckOrigin",
":",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"return",
"true",
"}",
",",
"EnableCompression",
":",
"options",
".",
"EnableCompression",
",",
"}",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
",",
"}",
"\n\n",
"if",
"tlsConfig",
"==",
"nil",
"{",
"tlsConfig",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n\n",
"path",
":=",
"options",
".",
"Path",
"\n",
"if",
"path",
"==",
"\"",
"\"",
"{",
"path",
"=",
"defaultWSPath",
"\n",
"}",
"\n\n",
"mux",
":=",
"http",
".",
"NewServeMux",
"(",
")",
"\n",
"mux",
".",
"Handle",
"(",
"path",
",",
"http",
".",
"HandlerFunc",
"(",
"l",
".",
"upgrade",
")",
")",
"\n",
"l",
".",
"srv",
"=",
"&",
"http",
".",
"Server",
"{",
"Addr",
":",
"addr",
",",
"TLSConfig",
":",
"tlsConfig",
",",
"Handler",
":",
"mux",
",",
"ReadHeaderTimeout",
":",
"30",
"*",
"time",
".",
"Second",
",",
"}",
"\n\n",
"ln",
",",
"err",
":=",
"net",
".",
"ListenTCP",
"(",
"\"",
"\"",
",",
"tcpAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
".",
"addr",
"=",
"ln",
".",
"Addr",
"(",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"err",
":=",
"l",
".",
"srv",
".",
"Serve",
"(",
"tls",
".",
"NewListener",
"(",
"tcpKeepAliveListener",
"{",
"ln",
"}",
",",
"tlsConfig",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"l",
".",
"errChan",
"<-",
"err",
"\n",
"}",
"\n",
"close",
"(",
"l",
".",
"errChan",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"l",
".",
"errChan",
":",
"return",
"nil",
",",
"err",
"\n",
"default",
":",
"}",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // WSSListener creates a Listener for websocket secure proxy server. | [
"WSSListener",
"creates",
"a",
"Listener",
"for",
"websocket",
"secure",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/ws.go#L575-L634 | train |
ginuerzh/gost | gost.go | GenCertificate | func GenCertificate() (cert tls.Certificate, err error) {
rawCert, rawKey, err := generateKeyPair()
if err != nil {
return
}
return tls.X509KeyPair(rawCert, rawKey)
} | go | func GenCertificate() (cert tls.Certificate, err error) {
rawCert, rawKey, err := generateKeyPair()
if err != nil {
return
}
return tls.X509KeyPair(rawCert, rawKey)
} | [
"func",
"GenCertificate",
"(",
")",
"(",
"cert",
"tls",
".",
"Certificate",
",",
"err",
"error",
")",
"{",
"rawCert",
",",
"rawKey",
",",
"err",
":=",
"generateKeyPair",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"return",
"tls",
".",
"X509KeyPair",
"(",
"rawCert",
",",
"rawKey",
")",
"\n",
"}"
] | // GenCertificate generates a random TLS certificate. | [
"GenCertificate",
"generates",
"a",
"random",
"TLS",
"certificate",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/gost.go#L87-L93 | train |
ginuerzh/gost | gost.go | splitLine | func splitLine(line string) []string {
if line == "" {
return nil
}
if n := strings.IndexByte(line, '#'); n >= 0 {
line = line[:n]
}
line = strings.Replace(line, "\t", " ", -1)
line = strings.TrimSpace(line)
var ss []string
for _, s := range strings.Split(line, " ") {
if s = strings.TrimSpace(s); s != "" {
ss = append(ss, s)
}
}
return ss
} | go | func splitLine(line string) []string {
if line == "" {
return nil
}
if n := strings.IndexByte(line, '#'); n >= 0 {
line = line[:n]
}
line = strings.Replace(line, "\t", " ", -1)
line = strings.TrimSpace(line)
var ss []string
for _, s := range strings.Split(line, " ") {
if s = strings.TrimSpace(s); s != "" {
ss = append(ss, s)
}
}
return ss
} | [
"func",
"splitLine",
"(",
"line",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"line",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"n",
":=",
"strings",
".",
"IndexByte",
"(",
"line",
",",
"'#'",
")",
";",
"n",
">=",
"0",
"{",
"line",
"=",
"line",
"[",
":",
"n",
"]",
"\n",
"}",
"\n",
"line",
"=",
"strings",
".",
"Replace",
"(",
"line",
",",
"\"",
"\\t",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"line",
"=",
"strings",
".",
"TrimSpace",
"(",
"line",
")",
"\n\n",
"var",
"ss",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"strings",
".",
"Split",
"(",
"line",
",",
"\"",
"\"",
")",
"{",
"if",
"s",
"=",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
";",
"s",
"!=",
"\"",
"\"",
"{",
"ss",
"=",
"append",
"(",
"ss",
",",
"s",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ss",
"\n",
"}"
] | // splitLine splits a line text by white space, mainly used by config parser. | [
"splitLine",
"splits",
"a",
"line",
"text",
"by",
"white",
"space",
"mainly",
"used",
"by",
"config",
"parser",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/gost.go#L185-L202 | train |
ginuerzh/gost | server.go | Init | func (s *Server) Init(opts ...ServerOption) {
if s.options == nil {
s.options = &ServerOptions{}
}
for _, opt := range opts {
opt(s.options)
}
} | go | func (s *Server) Init(opts ...ServerOption) {
if s.options == nil {
s.options = &ServerOptions{}
}
for _, opt := range opts {
opt(s.options)
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Init",
"(",
"opts",
"...",
"ServerOption",
")",
"{",
"if",
"s",
".",
"options",
"==",
"nil",
"{",
"s",
".",
"options",
"=",
"&",
"ServerOptions",
"{",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"s",
".",
"options",
")",
"\n",
"}",
"\n",
"}"
] | // Init intializes server with given options. | [
"Init",
"intializes",
"server",
"with",
"given",
"options",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/server.go#L24-L31 | train |
ginuerzh/gost | server.go | Serve | func (s *Server) Serve(h Handler, opts ...ServerOption) error {
s.Init(opts...)
if s.Listener == nil {
ln, err := TCPListener("")
if err != nil {
return err
}
s.Listener = ln
}
if h == nil {
h = s.Handler
}
if h == nil {
h = HTTPHandler()
}
l := s.Listener
var tempDelay time.Duration
for {
conn, e := l.Accept()
if e != nil {
if ne, ok := e.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
log.Logf("server: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
tempDelay = 0
/*
if s.options.Bypass.Contains(conn.RemoteAddr().String()) {
log.Log("[bypass]", conn.RemoteAddr())
conn.Close()
continue
}
*/
go h.Handle(conn)
}
} | go | func (s *Server) Serve(h Handler, opts ...ServerOption) error {
s.Init(opts...)
if s.Listener == nil {
ln, err := TCPListener("")
if err != nil {
return err
}
s.Listener = ln
}
if h == nil {
h = s.Handler
}
if h == nil {
h = HTTPHandler()
}
l := s.Listener
var tempDelay time.Duration
for {
conn, e := l.Accept()
if e != nil {
if ne, ok := e.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
log.Logf("server: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
tempDelay = 0
/*
if s.options.Bypass.Contains(conn.RemoteAddr().String()) {
log.Log("[bypass]", conn.RemoteAddr())
conn.Close()
continue
}
*/
go h.Handle(conn)
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Serve",
"(",
"h",
"Handler",
",",
"opts",
"...",
"ServerOption",
")",
"error",
"{",
"s",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"if",
"s",
".",
"Listener",
"==",
"nil",
"{",
"ln",
",",
"err",
":=",
"TCPListener",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"Listener",
"=",
"ln",
"\n",
"}",
"\n\n",
"if",
"h",
"==",
"nil",
"{",
"h",
"=",
"s",
".",
"Handler",
"\n",
"}",
"\n",
"if",
"h",
"==",
"nil",
"{",
"h",
"=",
"HTTPHandler",
"(",
")",
"\n",
"}",
"\n\n",
"l",
":=",
"s",
".",
"Listener",
"\n",
"var",
"tempDelay",
"time",
".",
"Duration",
"\n",
"for",
"{",
"conn",
",",
"e",
":=",
"l",
".",
"Accept",
"(",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"if",
"ne",
",",
"ok",
":=",
"e",
".",
"(",
"net",
".",
"Error",
")",
";",
"ok",
"&&",
"ne",
".",
"Temporary",
"(",
")",
"{",
"if",
"tempDelay",
"==",
"0",
"{",
"tempDelay",
"=",
"5",
"*",
"time",
".",
"Millisecond",
"\n",
"}",
"else",
"{",
"tempDelay",
"*=",
"2",
"\n",
"}",
"\n",
"if",
"max",
":=",
"1",
"*",
"time",
".",
"Second",
";",
"tempDelay",
">",
"max",
"{",
"tempDelay",
"=",
"max",
"\n",
"}",
"\n",
"log",
".",
"Logf",
"(",
"\"",
"\"",
",",
"e",
",",
"tempDelay",
")",
"\n",
"time",
".",
"Sleep",
"(",
"tempDelay",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"e",
"\n",
"}",
"\n",
"tempDelay",
"=",
"0",
"\n\n",
"/*\n\t\t\tif s.options.Bypass.Contains(conn.RemoteAddr().String()) {\n\t\t\t\tlog.Log(\"[bypass]\", conn.RemoteAddr())\n\t\t\t\tconn.Close()\n\t\t\t\tcontinue\n\t\t\t}\n\t\t*/",
"go",
"h",
".",
"Handle",
"(",
"conn",
")",
"\n",
"}",
"\n",
"}"
] | // Serve serves as a proxy server. | [
"Serve",
"serves",
"as",
"a",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/server.go#L44-L94 | train |
ginuerzh/gost | server.go | TCPListener | func TCPListener(addr string) (Listener, error) {
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenTCP("tcp", laddr)
if err != nil {
return nil, err
}
return &tcpListener{Listener: tcpKeepAliveListener{ln}}, nil
} | go | func TCPListener(addr string) (Listener, error) {
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenTCP("tcp", laddr)
if err != nil {
return nil, err
}
return &tcpListener{Listener: tcpKeepAliveListener{ln}}, nil
} | [
"func",
"TCPListener",
"(",
"addr",
"string",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"laddr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"net",
".",
"ListenTCP",
"(",
"\"",
"\"",
",",
"laddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"tcpListener",
"{",
"Listener",
":",
"tcpKeepAliveListener",
"{",
"ln",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // TCPListener creates a Listener for TCP proxy server. | [
"TCPListener",
"creates",
"a",
"Listener",
"for",
"TCP",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/server.go#L118-L128 | train |
ginuerzh/gost | sni.go | SNIHandler | func SNIHandler(opts ...HandlerOption) Handler {
h := &sniHandler{}
h.Init(opts...)
return h
} | go | func SNIHandler(opts ...HandlerOption) Handler {
h := &sniHandler{}
h.Init(opts...)
return h
} | [
"func",
"SNIHandler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"sniHandler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // SNIHandler creates a server Handler for SNI proxy server. | [
"SNIHandler",
"creates",
"a",
"server",
"Handler",
"for",
"SNI",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/sni.go#L41-L46 | train |
ginuerzh/gost | kcp.go | Init | func (c *KCPConfig) Init() {
switch c.Mode {
case "normal":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 0, 40, 2, 1
case "fast":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 0, 30, 2, 1
case "fast2":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 1, 20, 2, 1
case "fast3":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 1, 10, 2, 1
}
} | go | func (c *KCPConfig) Init() {
switch c.Mode {
case "normal":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 0, 40, 2, 1
case "fast":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 0, 30, 2, 1
case "fast2":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 1, 20, 2, 1
case "fast3":
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 1, 10, 2, 1
}
} | [
"func",
"(",
"c",
"*",
"KCPConfig",
")",
"Init",
"(",
")",
"{",
"switch",
"c",
".",
"Mode",
"{",
"case",
"\"",
"\"",
":",
"c",
".",
"NoDelay",
",",
"c",
".",
"Interval",
",",
"c",
".",
"Resend",
",",
"c",
".",
"NoCongestion",
"=",
"0",
",",
"40",
",",
"2",
",",
"1",
"\n",
"case",
"\"",
"\"",
":",
"c",
".",
"NoDelay",
",",
"c",
".",
"Interval",
",",
"c",
".",
"Resend",
",",
"c",
".",
"NoCongestion",
"=",
"0",
",",
"30",
",",
"2",
",",
"1",
"\n",
"case",
"\"",
"\"",
":",
"c",
".",
"NoDelay",
",",
"c",
".",
"Interval",
",",
"c",
".",
"Resend",
",",
"c",
".",
"NoCongestion",
"=",
"1",
",",
"20",
",",
"2",
",",
"1",
"\n",
"case",
"\"",
"\"",
":",
"c",
".",
"NoDelay",
",",
"c",
".",
"Interval",
",",
"c",
".",
"Resend",
",",
"c",
".",
"NoCongestion",
"=",
"1",
",",
"10",
",",
"2",
",",
"1",
"\n",
"}",
"\n",
"}"
] | // Init initializes the KCP config. | [
"Init",
"initializes",
"the",
"KCP",
"config",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/kcp.go#L52-L63 | train |
ginuerzh/gost | kcp.go | KCPTransporter | func KCPTransporter(config *KCPConfig) Transporter {
if config == nil {
config = &KCPConfig{}
*config = DefaultKCPConfig
}
config.Init()
go snmpLogger(config.SnmpLog, config.SnmpPeriod)
if config.Signal {
go kcpSigHandler()
}
return &kcpTransporter{
config: config,
sessions: make(map[string]*muxSession),
}
} | go | func KCPTransporter(config *KCPConfig) Transporter {
if config == nil {
config = &KCPConfig{}
*config = DefaultKCPConfig
}
config.Init()
go snmpLogger(config.SnmpLog, config.SnmpPeriod)
if config.Signal {
go kcpSigHandler()
}
return &kcpTransporter{
config: config,
sessions: make(map[string]*muxSession),
}
} | [
"func",
"KCPTransporter",
"(",
"config",
"*",
"KCPConfig",
")",
"Transporter",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"KCPConfig",
"{",
"}",
"\n",
"*",
"config",
"=",
"DefaultKCPConfig",
"\n",
"}",
"\n",
"config",
".",
"Init",
"(",
")",
"\n\n",
"go",
"snmpLogger",
"(",
"config",
".",
"SnmpLog",
",",
"config",
".",
"SnmpPeriod",
")",
"\n",
"if",
"config",
".",
"Signal",
"{",
"go",
"kcpSigHandler",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"kcpTransporter",
"{",
"config",
":",
"config",
",",
"sessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"muxSession",
")",
",",
"}",
"\n",
"}"
] | // KCPTransporter creates a Transporter that is used by KCP proxy client. | [
"KCPTransporter",
"creates",
"a",
"Transporter",
"that",
"is",
"used",
"by",
"KCP",
"proxy",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/kcp.go#L98-L114 | train |
ginuerzh/gost | kcp.go | KCPListener | func KCPListener(addr string, config *KCPConfig) (Listener, error) {
if config == nil {
config = &KCPConfig{}
*config = DefaultKCPConfig
}
config.Init()
ln, err := kcp.ListenWithOptions(addr,
blockCrypt(config.Key, config.Crypt, KCPSalt), config.DataShard, config.ParityShard)
if err != nil {
return nil, err
}
// if err = ln.SetDSCP(config.DSCP); err != nil {
// log.Log("[kcp]", err)
// }
if err = ln.SetReadBuffer(config.SockBuf); err != nil {
log.Log("[kcp]", err)
}
if err = ln.SetWriteBuffer(config.SockBuf); err != nil {
log.Log("[kcp]", err)
}
go snmpLogger(config.SnmpLog, config.SnmpPeriod)
if config.Signal {
go kcpSigHandler()
}
l := &kcpListener{
config: config,
ln: ln,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | go | func KCPListener(addr string, config *KCPConfig) (Listener, error) {
if config == nil {
config = &KCPConfig{}
*config = DefaultKCPConfig
}
config.Init()
ln, err := kcp.ListenWithOptions(addr,
blockCrypt(config.Key, config.Crypt, KCPSalt), config.DataShard, config.ParityShard)
if err != nil {
return nil, err
}
// if err = ln.SetDSCP(config.DSCP); err != nil {
// log.Log("[kcp]", err)
// }
if err = ln.SetReadBuffer(config.SockBuf); err != nil {
log.Log("[kcp]", err)
}
if err = ln.SetWriteBuffer(config.SockBuf); err != nil {
log.Log("[kcp]", err)
}
go snmpLogger(config.SnmpLog, config.SnmpPeriod)
if config.Signal {
go kcpSigHandler()
}
l := &kcpListener{
config: config,
ln: ln,
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | [
"func",
"KCPListener",
"(",
"addr",
"string",
",",
"config",
"*",
"KCPConfig",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"KCPConfig",
"{",
"}",
"\n",
"*",
"config",
"=",
"DefaultKCPConfig",
"\n",
"}",
"\n",
"config",
".",
"Init",
"(",
")",
"\n\n",
"ln",
",",
"err",
":=",
"kcp",
".",
"ListenWithOptions",
"(",
"addr",
",",
"blockCrypt",
"(",
"config",
".",
"Key",
",",
"config",
".",
"Crypt",
",",
"KCPSalt",
")",
",",
"config",
".",
"DataShard",
",",
"config",
".",
"ParityShard",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// if err = ln.SetDSCP(config.DSCP); err != nil {",
"// \tlog.Log(\"[kcp]\", err)",
"// }",
"if",
"err",
"=",
"ln",
".",
"SetReadBuffer",
"(",
"config",
".",
"SockBuf",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"ln",
".",
"SetWriteBuffer",
"(",
"config",
".",
"SockBuf",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"go",
"snmpLogger",
"(",
"config",
".",
"SnmpLog",
",",
"config",
".",
"SnmpPeriod",
")",
"\n",
"if",
"config",
".",
"Signal",
"{",
"go",
"kcpSigHandler",
"(",
")",
"\n",
"}",
"\n\n",
"l",
":=",
"&",
"kcpListener",
"{",
"config",
":",
"config",
",",
"ln",
":",
"ln",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // KCPListener creates a Listener for KCP proxy server. | [
"KCPListener",
"creates",
"a",
"Listener",
"for",
"KCP",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/kcp.go#L243-L279 | train |
ginuerzh/gost | socks.go | SOCKS5MuxBindTransporter | func SOCKS5MuxBindTransporter(bindAddr string) Transporter {
return &socks5MuxBindTransporter{
bindAddr: bindAddr,
sessions: make(map[string]*muxSession),
}
} | go | func SOCKS5MuxBindTransporter(bindAddr string) Transporter {
return &socks5MuxBindTransporter{
bindAddr: bindAddr,
sessions: make(map[string]*muxSession),
}
} | [
"func",
"SOCKS5MuxBindTransporter",
"(",
"bindAddr",
"string",
")",
"Transporter",
"{",
"return",
"&",
"socks5MuxBindTransporter",
"{",
"bindAddr",
":",
"bindAddr",
",",
"sessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"muxSession",
")",
",",
"}",
"\n",
"}"
] | // SOCKS5MuxBindTransporter creates a Transporter for SOCKS5 multiplex bind client. | [
"SOCKS5MuxBindTransporter",
"creates",
"a",
"Transporter",
"for",
"SOCKS5",
"multiplex",
"bind",
"client",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/socks.go#L356-L361 | train |
ginuerzh/gost | socks.go | SOCKS5Handler | func SOCKS5Handler(opts ...HandlerOption) Handler {
h := &socks5Handler{}
h.Init(opts...)
return h
} | go | func SOCKS5Handler(opts ...HandlerOption) Handler {
h := &socks5Handler{}
h.Init(opts...)
return h
} | [
"func",
"SOCKS5Handler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"socks5Handler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n\n",
"return",
"h",
"\n",
"}"
] | // SOCKS5Handler creates a server Handler for SOCKS5 proxy server. | [
"SOCKS5Handler",
"creates",
"a",
"server",
"Handler",
"for",
"SOCKS5",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/socks.go#L761-L766 | train |
ginuerzh/gost | socks.go | Handshake | func (c *socks5BindConn) Handshake() (err error) {
c.handshakeMux.Lock()
defer c.handshakeMux.Unlock()
if c.handshaked {
return nil
}
c.handshaked = true
rep, err := gosocks5.ReadReply(c.Conn)
if err != nil {
return fmt.Errorf("bind: read reply %v", err)
}
if rep.Rep != gosocks5.Succeeded {
return fmt.Errorf("bind: peer connect failure")
}
c.raddr, err = net.ResolveTCPAddr("tcp", rep.Addr.String())
return
} | go | func (c *socks5BindConn) Handshake() (err error) {
c.handshakeMux.Lock()
defer c.handshakeMux.Unlock()
if c.handshaked {
return nil
}
c.handshaked = true
rep, err := gosocks5.ReadReply(c.Conn)
if err != nil {
return fmt.Errorf("bind: read reply %v", err)
}
if rep.Rep != gosocks5.Succeeded {
return fmt.Errorf("bind: peer connect failure")
}
c.raddr, err = net.ResolveTCPAddr("tcp", rep.Addr.String())
return
} | [
"func",
"(",
"c",
"*",
"socks5BindConn",
")",
"Handshake",
"(",
")",
"(",
"err",
"error",
")",
"{",
"c",
".",
"handshakeMux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"handshakeMux",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"c",
".",
"handshaked",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"c",
".",
"handshaked",
"=",
"true",
"\n\n",
"rep",
",",
"err",
":=",
"gosocks5",
".",
"ReadReply",
"(",
"c",
".",
"Conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"rep",
".",
"Rep",
"!=",
"gosocks5",
".",
"Succeeded",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
".",
"raddr",
",",
"err",
"=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"rep",
".",
"Addr",
".",
"String",
"(",
")",
")",
"\n",
"return",
"\n",
"}"
] | // Handshake waits for a peer to connect to the bind port. | [
"Handshake",
"waits",
"for",
"a",
"peer",
"to",
"connect",
"to",
"the",
"bind",
"port",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/socks.go#L1891-L1910 | train |
ginuerzh/gost | node.go | Clone | func (node *Node) Clone() Node {
nd := *node
if node.marker != nil {
nd.marker = node.marker.Clone()
}
return nd
} | go | func (node *Node) Clone() Node {
nd := *node
if node.marker != nil {
nd.marker = node.marker.Clone()
}
return nd
} | [
"func",
"(",
"node",
"*",
"Node",
")",
"Clone",
"(",
")",
"Node",
"{",
"nd",
":=",
"*",
"node",
"\n",
"if",
"node",
".",
"marker",
"!=",
"nil",
"{",
"nd",
".",
"marker",
"=",
"node",
".",
"marker",
".",
"Clone",
"(",
")",
"\n",
"}",
"\n",
"return",
"nd",
"\n",
"}"
] | // Clone clones the node, it will prevent data race. | [
"Clone",
"clones",
"the",
"node",
"it",
"will",
"prevent",
"data",
"race",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L118-L124 | train |
ginuerzh/gost | node.go | Get | func (node *Node) Get(key string) string {
return node.Values.Get(key)
} | go | func (node *Node) Get(key string) string {
return node.Values.Get(key)
} | [
"func",
"(",
"node",
"*",
"Node",
")",
"Get",
"(",
"key",
"string",
")",
"string",
"{",
"return",
"node",
".",
"Values",
".",
"Get",
"(",
"key",
")",
"\n",
"}"
] | // Get returns node parameter specified by key. | [
"Get",
"returns",
"node",
"parameter",
"specified",
"by",
"key",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L127-L129 | train |
ginuerzh/gost | node.go | GetBool | func (node *Node) GetBool(key string) bool {
b, _ := strconv.ParseBool(node.Values.Get(key))
return b
} | go | func (node *Node) GetBool(key string) bool {
b, _ := strconv.ParseBool(node.Values.Get(key))
return b
} | [
"func",
"(",
"node",
"*",
"Node",
")",
"GetBool",
"(",
"key",
"string",
")",
"bool",
"{",
"b",
",",
"_",
":=",
"strconv",
".",
"ParseBool",
"(",
"node",
".",
"Values",
".",
"Get",
"(",
"key",
")",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // GetBool likes Get, but convert parameter value to bool. | [
"GetBool",
"likes",
"Get",
"but",
"convert",
"parameter",
"value",
"to",
"bool",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L132-L135 | train |
ginuerzh/gost | node.go | GetInt | func (node *Node) GetInt(key string) int {
n, _ := strconv.Atoi(node.Values.Get(key))
return n
} | go | func (node *Node) GetInt(key string) int {
n, _ := strconv.Atoi(node.Values.Get(key))
return n
} | [
"func",
"(",
"node",
"*",
"Node",
")",
"GetInt",
"(",
"key",
"string",
")",
"int",
"{",
"n",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"node",
".",
"Values",
".",
"Get",
"(",
"key",
")",
")",
"\n",
"return",
"n",
"\n",
"}"
] | // GetInt likes Get, but convert parameter value to int. | [
"GetInt",
"likes",
"Get",
"but",
"convert",
"parameter",
"value",
"to",
"int",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L138-L141 | train |
ginuerzh/gost | node.go | AddNode | func (group *NodeGroup) AddNode(node ...Node) {
if group == nil {
return
}
group.mux.Lock()
defer group.mux.Unlock()
group.nodes = append(group.nodes, node...)
} | go | func (group *NodeGroup) AddNode(node ...Node) {
if group == nil {
return
}
group.mux.Lock()
defer group.mux.Unlock()
group.nodes = append(group.nodes, node...)
} | [
"func",
"(",
"group",
"*",
"NodeGroup",
")",
"AddNode",
"(",
"node",
"...",
"Node",
")",
"{",
"if",
"group",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"group",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"group",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n\n",
"group",
".",
"nodes",
"=",
"append",
"(",
"group",
".",
"nodes",
",",
"node",
"...",
")",
"\n",
"}"
] | // AddNode appends node or node list into group node. | [
"AddNode",
"appends",
"node",
"or",
"node",
"list",
"into",
"group",
"node",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L168-L176 | train |
ginuerzh/gost | node.go | SetNodes | func (group *NodeGroup) SetNodes(nodes ...Node) []Node {
if group == nil {
return nil
}
group.mux.Lock()
defer group.mux.Unlock()
old := group.nodes
group.nodes = nodes
return old
} | go | func (group *NodeGroup) SetNodes(nodes ...Node) []Node {
if group == nil {
return nil
}
group.mux.Lock()
defer group.mux.Unlock()
old := group.nodes
group.nodes = nodes
return old
} | [
"func",
"(",
"group",
"*",
"NodeGroup",
")",
"SetNodes",
"(",
"nodes",
"...",
"Node",
")",
"[",
"]",
"Node",
"{",
"if",
"group",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"group",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"group",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n\n",
"old",
":=",
"group",
".",
"nodes",
"\n",
"group",
".",
"nodes",
"=",
"nodes",
"\n",
"return",
"old",
"\n",
"}"
] | // SetNodes replaces the group nodes to the specified nodes,
// and returns the previous nodes. | [
"SetNodes",
"replaces",
"the",
"group",
"nodes",
"to",
"the",
"specified",
"nodes",
"and",
"returns",
"the",
"previous",
"nodes",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L180-L191 | train |
ginuerzh/gost | node.go | SetSelector | func (group *NodeGroup) SetSelector(selector NodeSelector, opts ...SelectOption) {
if group == nil {
return
}
group.mux.Lock()
defer group.mux.Unlock()
group.selector = selector
group.selectorOptions = opts
} | go | func (group *NodeGroup) SetSelector(selector NodeSelector, opts ...SelectOption) {
if group == nil {
return
}
group.mux.Lock()
defer group.mux.Unlock()
group.selector = selector
group.selectorOptions = opts
} | [
"func",
"(",
"group",
"*",
"NodeGroup",
")",
"SetSelector",
"(",
"selector",
"NodeSelector",
",",
"opts",
"...",
"SelectOption",
")",
"{",
"if",
"group",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"group",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"group",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n\n",
"group",
".",
"selector",
"=",
"selector",
"\n",
"group",
".",
"selectorOptions",
"=",
"opts",
"\n",
"}"
] | // SetSelector sets node selector with options for the group. | [
"SetSelector",
"sets",
"node",
"selector",
"with",
"options",
"for",
"the",
"group",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L194-L203 | train |
ginuerzh/gost | node.go | Nodes | func (group *NodeGroup) Nodes() []Node {
if group == nil {
return nil
}
group.mux.RLock()
defer group.mux.RUnlock()
return group.nodes
} | go | func (group *NodeGroup) Nodes() []Node {
if group == nil {
return nil
}
group.mux.RLock()
defer group.mux.RUnlock()
return group.nodes
} | [
"func",
"(",
"group",
"*",
"NodeGroup",
")",
"Nodes",
"(",
")",
"[",
"]",
"Node",
"{",
"if",
"group",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"group",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"group",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"group",
".",
"nodes",
"\n",
"}"
] | // Nodes returns the node list in the group | [
"Nodes",
"returns",
"the",
"node",
"list",
"in",
"the",
"group"
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L206-L215 | train |
ginuerzh/gost | node.go | GetNode | func (group *NodeGroup) GetNode(i int) Node {
group.mux.RLock()
defer group.mux.RUnlock()
if i < 0 || group == nil || len(group.nodes) <= i {
return Node{}
}
return group.nodes[i]
} | go | func (group *NodeGroup) GetNode(i int) Node {
group.mux.RLock()
defer group.mux.RUnlock()
if i < 0 || group == nil || len(group.nodes) <= i {
return Node{}
}
return group.nodes[i]
} | [
"func",
"(",
"group",
"*",
"NodeGroup",
")",
"GetNode",
"(",
"i",
"int",
")",
"Node",
"{",
"group",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"group",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"i",
"<",
"0",
"||",
"group",
"==",
"nil",
"||",
"len",
"(",
"group",
".",
"nodes",
")",
"<=",
"i",
"{",
"return",
"Node",
"{",
"}",
"\n",
"}",
"\n",
"return",
"group",
".",
"nodes",
"[",
"i",
"]",
"\n",
"}"
] | // GetNode returns the node specified by index in the group. | [
"GetNode",
"returns",
"the",
"node",
"specified",
"by",
"index",
"in",
"the",
"group",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L218-L226 | train |
ginuerzh/gost | node.go | Next | func (group *NodeGroup) Next() (node Node, err error) {
if group == nil {
return
}
group.mux.RLock()
defer group.mux.RUnlock()
selector := group.selector
if selector == nil {
selector = &defaultSelector{}
}
// select node from node group
node, err = selector.Select(group.nodes, group.selectorOptions...)
if err != nil {
return
}
return
} | go | func (group *NodeGroup) Next() (node Node, err error) {
if group == nil {
return
}
group.mux.RLock()
defer group.mux.RUnlock()
selector := group.selector
if selector == nil {
selector = &defaultSelector{}
}
// select node from node group
node, err = selector.Select(group.nodes, group.selectorOptions...)
if err != nil {
return
}
return
} | [
"func",
"(",
"group",
"*",
"NodeGroup",
")",
"Next",
"(",
")",
"(",
"node",
"Node",
",",
"err",
"error",
")",
"{",
"if",
"group",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"group",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"group",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"selector",
":=",
"group",
".",
"selector",
"\n",
"if",
"selector",
"==",
"nil",
"{",
"selector",
"=",
"&",
"defaultSelector",
"{",
"}",
"\n",
"}",
"\n\n",
"// select node from node group",
"node",
",",
"err",
"=",
"selector",
".",
"Select",
"(",
"group",
".",
"nodes",
",",
"group",
".",
"selectorOptions",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // Next selects a node from group.
// It also selects IP if the IP list exists. | [
"Next",
"selects",
"a",
"node",
"from",
"group",
".",
"It",
"also",
"selects",
"IP",
"if",
"the",
"IP",
"list",
"exists",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/node.go#L230-L250 | train |
ginuerzh/gost | chain.go | NewChain | func NewChain(nodes ...Node) *Chain {
chain := &Chain{}
for _, node := range nodes {
chain.nodeGroups = append(chain.nodeGroups, NewNodeGroup(node))
}
return chain
} | go | func NewChain(nodes ...Node) *Chain {
chain := &Chain{}
for _, node := range nodes {
chain.nodeGroups = append(chain.nodeGroups, NewNodeGroup(node))
}
return chain
} | [
"func",
"NewChain",
"(",
"nodes",
"...",
"Node",
")",
"*",
"Chain",
"{",
"chain",
":=",
"&",
"Chain",
"{",
"}",
"\n",
"for",
"_",
",",
"node",
":=",
"range",
"nodes",
"{",
"chain",
".",
"nodeGroups",
"=",
"append",
"(",
"chain",
".",
"nodeGroups",
",",
"NewNodeGroup",
"(",
"node",
")",
")",
"\n",
"}",
"\n",
"return",
"chain",
"\n",
"}"
] | // NewChain creates a proxy chain with a list of proxy nodes.
// It creates the node groups automatically, one group per node. | [
"NewChain",
"creates",
"a",
"proxy",
"chain",
"with",
"a",
"list",
"of",
"proxy",
"nodes",
".",
"It",
"creates",
"the",
"node",
"groups",
"automatically",
"one",
"group",
"per",
"node",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L26-L32 | train |
ginuerzh/gost | chain.go | newRoute | func newRoute(nodes ...Node) *Chain {
chain := NewChain(nodes...)
chain.isRoute = true
return chain
} | go | func newRoute(nodes ...Node) *Chain {
chain := NewChain(nodes...)
chain.isRoute = true
return chain
} | [
"func",
"newRoute",
"(",
"nodes",
"...",
"Node",
")",
"*",
"Chain",
"{",
"chain",
":=",
"NewChain",
"(",
"nodes",
"...",
")",
"\n",
"chain",
".",
"isRoute",
"=",
"true",
"\n",
"return",
"chain",
"\n",
"}"
] | // newRoute creates a chain route.
// a chain route is the final route after node selection. | [
"newRoute",
"creates",
"a",
"chain",
"route",
".",
"a",
"chain",
"route",
"is",
"the",
"final",
"route",
"after",
"node",
"selection",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L36-L40 | train |
ginuerzh/gost | chain.go | Nodes | func (c *Chain) Nodes() (nodes []Node) {
for _, group := range c.nodeGroups {
if ns := group.Nodes(); len(ns) > 0 {
nodes = append(nodes, ns[0])
}
}
return
} | go | func (c *Chain) Nodes() (nodes []Node) {
for _, group := range c.nodeGroups {
if ns := group.Nodes(); len(ns) > 0 {
nodes = append(nodes, ns[0])
}
}
return
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"Nodes",
"(",
")",
"(",
"nodes",
"[",
"]",
"Node",
")",
"{",
"for",
"_",
",",
"group",
":=",
"range",
"c",
".",
"nodeGroups",
"{",
"if",
"ns",
":=",
"group",
".",
"Nodes",
"(",
")",
";",
"len",
"(",
"ns",
")",
">",
"0",
"{",
"nodes",
"=",
"append",
"(",
"nodes",
",",
"ns",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Nodes returns the proxy nodes that the chain holds.
// The first node in each group will be returned. | [
"Nodes",
"returns",
"the",
"proxy",
"nodes",
"that",
"the",
"chain",
"holds",
".",
"The",
"first",
"node",
"in",
"each",
"group",
"will",
"be",
"returned",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L44-L51 | train |
ginuerzh/gost | chain.go | LastNode | func (c *Chain) LastNode() Node {
if c.IsEmpty() {
return Node{}
}
group := c.nodeGroups[len(c.nodeGroups)-1]
return group.GetNode(0)
} | go | func (c *Chain) LastNode() Node {
if c.IsEmpty() {
return Node{}
}
group := c.nodeGroups[len(c.nodeGroups)-1]
return group.GetNode(0)
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"LastNode",
"(",
")",
"Node",
"{",
"if",
"c",
".",
"IsEmpty",
"(",
")",
"{",
"return",
"Node",
"{",
"}",
"\n",
"}",
"\n",
"group",
":=",
"c",
".",
"nodeGroups",
"[",
"len",
"(",
"c",
".",
"nodeGroups",
")",
"-",
"1",
"]",
"\n",
"return",
"group",
".",
"GetNode",
"(",
"0",
")",
"\n",
"}"
] | // LastNode returns the last node of the node list.
// If the chain is empty, an empty node will be returned.
// If the last node is a node group, the first node in the group will be returned. | [
"LastNode",
"returns",
"the",
"last",
"node",
"of",
"the",
"node",
"list",
".",
"If",
"the",
"chain",
"is",
"empty",
"an",
"empty",
"node",
"will",
"be",
"returned",
".",
"If",
"the",
"last",
"node",
"is",
"a",
"node",
"group",
"the",
"first",
"node",
"in",
"the",
"group",
"will",
"be",
"returned",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L61-L67 | train |
ginuerzh/gost | chain.go | LastNodeGroup | func (c *Chain) LastNodeGroup() *NodeGroup {
if c.IsEmpty() {
return nil
}
return c.nodeGroups[len(c.nodeGroups)-1]
} | go | func (c *Chain) LastNodeGroup() *NodeGroup {
if c.IsEmpty() {
return nil
}
return c.nodeGroups[len(c.nodeGroups)-1]
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"LastNodeGroup",
"(",
")",
"*",
"NodeGroup",
"{",
"if",
"c",
".",
"IsEmpty",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"c",
".",
"nodeGroups",
"[",
"len",
"(",
"c",
".",
"nodeGroups",
")",
"-",
"1",
"]",
"\n",
"}"
] | // LastNodeGroup returns the last group of the group list. | [
"LastNodeGroup",
"returns",
"the",
"last",
"group",
"of",
"the",
"group",
"list",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L70-L75 | train |
ginuerzh/gost | chain.go | Dial | func (c *Chain) Dial(addr string, opts ...ChainOption) (conn net.Conn, err error) {
options := &ChainOptions{}
for _, opt := range opts {
opt(options)
}
retries := 1
if c != nil && c.Retries > 0 {
retries = c.Retries
}
if options.Retries > 0 {
retries = options.Retries
}
for i := 0; i < retries; i++ {
conn, err = c.dialWithOptions(addr, options)
if err == nil {
break
}
}
return
} | go | func (c *Chain) Dial(addr string, opts ...ChainOption) (conn net.Conn, err error) {
options := &ChainOptions{}
for _, opt := range opts {
opt(options)
}
retries := 1
if c != nil && c.Retries > 0 {
retries = c.Retries
}
if options.Retries > 0 {
retries = options.Retries
}
for i := 0; i < retries; i++ {
conn, err = c.dialWithOptions(addr, options)
if err == nil {
break
}
}
return
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"Dial",
"(",
"addr",
"string",
",",
"opts",
"...",
"ChainOption",
")",
"(",
"conn",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"options",
":=",
"&",
"ChainOptions",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"options",
")",
"\n",
"}",
"\n\n",
"retries",
":=",
"1",
"\n",
"if",
"c",
"!=",
"nil",
"&&",
"c",
".",
"Retries",
">",
"0",
"{",
"retries",
"=",
"c",
".",
"Retries",
"\n",
"}",
"\n",
"if",
"options",
".",
"Retries",
">",
"0",
"{",
"retries",
"=",
"options",
".",
"Retries",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"retries",
";",
"i",
"++",
"{",
"conn",
",",
"err",
"=",
"c",
".",
"dialWithOptions",
"(",
"addr",
",",
"options",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Dial connects to the target address addr through the chain.
// If the chain is empty, it will use the net.Dial directly. | [
"Dial",
"connects",
"to",
"the",
"target",
"address",
"addr",
"through",
"the",
"chain",
".",
"If",
"the",
"chain",
"is",
"empty",
"it",
"will",
"use",
"the",
"net",
".",
"Dial",
"directly",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L105-L126 | train |
ginuerzh/gost | chain.go | Conn | func (c *Chain) Conn(opts ...ChainOption) (conn net.Conn, err error) {
options := &ChainOptions{}
for _, opt := range opts {
opt(options)
}
retries := 1
if c != nil && c.Retries > 0 {
retries = c.Retries
}
if options.Retries > 0 {
retries = options.Retries
}
for i := 0; i < retries; i++ {
var route *Chain
route, err = c.selectRoute()
if err != nil {
continue
}
conn, err = route.getConn()
if err == nil {
break
}
}
return
} | go | func (c *Chain) Conn(opts ...ChainOption) (conn net.Conn, err error) {
options := &ChainOptions{}
for _, opt := range opts {
opt(options)
}
retries := 1
if c != nil && c.Retries > 0 {
retries = c.Retries
}
if options.Retries > 0 {
retries = options.Retries
}
for i := 0; i < retries; i++ {
var route *Chain
route, err = c.selectRoute()
if err != nil {
continue
}
conn, err = route.getConn()
if err == nil {
break
}
}
return
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"Conn",
"(",
"opts",
"...",
"ChainOption",
")",
"(",
"conn",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"options",
":=",
"&",
"ChainOptions",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"options",
")",
"\n",
"}",
"\n\n",
"retries",
":=",
"1",
"\n",
"if",
"c",
"!=",
"nil",
"&&",
"c",
".",
"Retries",
">",
"0",
"{",
"retries",
"=",
"c",
".",
"Retries",
"\n",
"}",
"\n",
"if",
"options",
".",
"Retries",
">",
"0",
"{",
"retries",
"=",
"options",
".",
"Retries",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"retries",
";",
"i",
"++",
"{",
"var",
"route",
"*",
"Chain",
"\n",
"route",
",",
"err",
"=",
"c",
".",
"selectRoute",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"conn",
",",
"err",
"=",
"route",
".",
"getConn",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Conn obtains a handshaked connection to the last node of the chain. | [
"Conn",
"obtains",
"a",
"handshaked",
"connection",
"to",
"the",
"last",
"node",
"of",
"the",
"chain",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L183-L209 | train |
ginuerzh/gost | chain.go | getConn | func (c *Chain) getConn() (conn net.Conn, err error) {
if c.IsEmpty() {
err = ErrEmptyChain
return
}
nodes := c.Nodes()
node := nodes[0]
cn, err := node.Client.Dial(node.Addr, node.DialOptions...)
if err != nil {
node.MarkDead()
return
}
cn, err = node.Client.Handshake(cn, node.HandshakeOptions...)
if err != nil {
node.MarkDead()
return
}
node.ResetDead()
preNode := node
for _, node := range nodes[1:] {
var cc net.Conn
cc, err = preNode.Client.Connect(cn, node.Addr)
if err != nil {
cn.Close()
node.MarkDead()
return
}
cc, err = node.Client.Handshake(cc, node.HandshakeOptions...)
if err != nil {
cn.Close()
node.MarkDead()
return
}
node.ResetDead()
cn = cc
preNode = node
}
conn = cn
return
} | go | func (c *Chain) getConn() (conn net.Conn, err error) {
if c.IsEmpty() {
err = ErrEmptyChain
return
}
nodes := c.Nodes()
node := nodes[0]
cn, err := node.Client.Dial(node.Addr, node.DialOptions...)
if err != nil {
node.MarkDead()
return
}
cn, err = node.Client.Handshake(cn, node.HandshakeOptions...)
if err != nil {
node.MarkDead()
return
}
node.ResetDead()
preNode := node
for _, node := range nodes[1:] {
var cc net.Conn
cc, err = preNode.Client.Connect(cn, node.Addr)
if err != nil {
cn.Close()
node.MarkDead()
return
}
cc, err = node.Client.Handshake(cc, node.HandshakeOptions...)
if err != nil {
cn.Close()
node.MarkDead()
return
}
node.ResetDead()
cn = cc
preNode = node
}
conn = cn
return
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"getConn",
"(",
")",
"(",
"conn",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"if",
"c",
".",
"IsEmpty",
"(",
")",
"{",
"err",
"=",
"ErrEmptyChain",
"\n",
"return",
"\n",
"}",
"\n",
"nodes",
":=",
"c",
".",
"Nodes",
"(",
")",
"\n",
"node",
":=",
"nodes",
"[",
"0",
"]",
"\n\n",
"cn",
",",
"err",
":=",
"node",
".",
"Client",
".",
"Dial",
"(",
"node",
".",
"Addr",
",",
"node",
".",
"DialOptions",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"node",
".",
"MarkDead",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"cn",
",",
"err",
"=",
"node",
".",
"Client",
".",
"Handshake",
"(",
"cn",
",",
"node",
".",
"HandshakeOptions",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"node",
".",
"MarkDead",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"node",
".",
"ResetDead",
"(",
")",
"\n\n",
"preNode",
":=",
"node",
"\n",
"for",
"_",
",",
"node",
":=",
"range",
"nodes",
"[",
"1",
":",
"]",
"{",
"var",
"cc",
"net",
".",
"Conn",
"\n",
"cc",
",",
"err",
"=",
"preNode",
".",
"Client",
".",
"Connect",
"(",
"cn",
",",
"node",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cn",
".",
"Close",
"(",
")",
"\n",
"node",
".",
"MarkDead",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"cc",
",",
"err",
"=",
"node",
".",
"Client",
".",
"Handshake",
"(",
"cc",
",",
"node",
".",
"HandshakeOptions",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cn",
".",
"Close",
"(",
")",
"\n",
"node",
".",
"MarkDead",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"node",
".",
"ResetDead",
"(",
")",
"\n\n",
"cn",
"=",
"cc",
"\n",
"preNode",
"=",
"node",
"\n",
"}",
"\n\n",
"conn",
"=",
"cn",
"\n",
"return",
"\n",
"}"
] | // getConn obtains a connection to the last node of the chain. | [
"getConn",
"obtains",
"a",
"connection",
"to",
"the",
"last",
"node",
"of",
"the",
"chain",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L212-L256 | train |
ginuerzh/gost | chain.go | selectRouteFor | func (c *Chain) selectRouteFor(addr string) (route *Chain, err error) {
if c.IsEmpty() {
return newRoute(), nil
}
if c.isRoute {
return c, nil
}
route = newRoute()
var nl []Node
for _, group := range c.nodeGroups {
var node Node
node, err = group.Next()
if err != nil {
return
}
if node.Bypass.Contains(addr) {
break
}
if node.Client.Transporter.Multiplex() {
node.DialOptions = append(node.DialOptions,
ChainDialOption(route),
)
route = newRoute() // cutoff the chain for multiplex node.
}
route.AddNode(node)
nl = append(nl, node)
}
route.route = nl
return
} | go | func (c *Chain) selectRouteFor(addr string) (route *Chain, err error) {
if c.IsEmpty() {
return newRoute(), nil
}
if c.isRoute {
return c, nil
}
route = newRoute()
var nl []Node
for _, group := range c.nodeGroups {
var node Node
node, err = group.Next()
if err != nil {
return
}
if node.Bypass.Contains(addr) {
break
}
if node.Client.Transporter.Multiplex() {
node.DialOptions = append(node.DialOptions,
ChainDialOption(route),
)
route = newRoute() // cutoff the chain for multiplex node.
}
route.AddNode(node)
nl = append(nl, node)
}
route.route = nl
return
} | [
"func",
"(",
"c",
"*",
"Chain",
")",
"selectRouteFor",
"(",
"addr",
"string",
")",
"(",
"route",
"*",
"Chain",
",",
"err",
"error",
")",
"{",
"if",
"c",
".",
"IsEmpty",
"(",
")",
"{",
"return",
"newRoute",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"if",
"c",
".",
"isRoute",
"{",
"return",
"c",
",",
"nil",
"\n",
"}",
"\n\n",
"route",
"=",
"newRoute",
"(",
")",
"\n",
"var",
"nl",
"[",
"]",
"Node",
"\n\n",
"for",
"_",
",",
"group",
":=",
"range",
"c",
".",
"nodeGroups",
"{",
"var",
"node",
"Node",
"\n",
"node",
",",
"err",
"=",
"group",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"node",
".",
"Bypass",
".",
"Contains",
"(",
"addr",
")",
"{",
"break",
"\n",
"}",
"\n\n",
"if",
"node",
".",
"Client",
".",
"Transporter",
".",
"Multiplex",
"(",
")",
"{",
"node",
".",
"DialOptions",
"=",
"append",
"(",
"node",
".",
"DialOptions",
",",
"ChainDialOption",
"(",
"route",
")",
",",
")",
"\n",
"route",
"=",
"newRoute",
"(",
")",
"// cutoff the chain for multiplex node.",
"\n",
"}",
"\n\n",
"route",
".",
"AddNode",
"(",
"node",
")",
"\n",
"nl",
"=",
"append",
"(",
"nl",
",",
"node",
")",
"\n",
"}",
"\n\n",
"route",
".",
"route",
"=",
"nl",
"\n\n",
"return",
"\n",
"}"
] | // selectRouteFor selects route with bypass testing. | [
"selectRouteFor",
"selects",
"route",
"with",
"bypass",
"testing",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L263-L299 | train |
ginuerzh/gost | chain.go | TimeoutChainOption | func TimeoutChainOption(timeout time.Duration) ChainOption {
return func(opts *ChainOptions) {
opts.Timeout = timeout
}
} | go | func TimeoutChainOption(timeout time.Duration) ChainOption {
return func(opts *ChainOptions) {
opts.Timeout = timeout
}
} | [
"func",
"TimeoutChainOption",
"(",
"timeout",
"time",
".",
"Duration",
")",
"ChainOption",
"{",
"return",
"func",
"(",
"opts",
"*",
"ChainOptions",
")",
"{",
"opts",
".",
"Timeout",
"=",
"timeout",
"\n",
"}",
"\n",
"}"
] | // TimeoutChainOption specifies the timeout used by Chain.Dial. | [
"TimeoutChainOption",
"specifies",
"the",
"timeout",
"used",
"by",
"Chain",
".",
"Dial",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L320-L324 | train |
ginuerzh/gost | http.go | HTTPHandler | func HTTPHandler(opts ...HandlerOption) Handler {
h := &httpHandler{}
h.Init(opts...)
return h
} | go | func HTTPHandler(opts ...HandlerOption) Handler {
h := &httpHandler{}
h.Init(opts...)
return h
} | [
"func",
"HTTPHandler",
"(",
"opts",
"...",
"HandlerOption",
")",
"Handler",
"{",
"h",
":=",
"&",
"httpHandler",
"{",
"}",
"\n",
"h",
".",
"Init",
"(",
"opts",
"...",
")",
"\n",
"return",
"h",
"\n",
"}"
] | // HTTPHandler creates a server Handler for HTTP proxy server. | [
"HTTPHandler",
"creates",
"a",
"server",
"Handler",
"for",
"HTTP",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/http.go#L98-L102 | train |
ginuerzh/gost | tls.go | TLSListener | func TLSListener(addr string, config *tls.Config) (Listener, error) {
if config == nil {
config = DefaultTLSConfig
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
ln = tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config)
return &tlsListener{ln}, nil
} | go | func TLSListener(addr string, config *tls.Config) (Listener, error) {
if config == nil {
config = DefaultTLSConfig
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
ln = tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config)
return &tlsListener{ln}, nil
} | [
"func",
"TLSListener",
"(",
"addr",
"string",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ln",
"=",
"tls",
".",
"NewListener",
"(",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"config",
")",
"\n",
"return",
"&",
"tlsListener",
"{",
"ln",
"}",
",",
"nil",
"\n",
"}"
] | // TLSListener creates a Listener for TLS proxy server. | [
"TLSListener",
"creates",
"a",
"Listener",
"for",
"TLS",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/tls.go#L157-L168 | train |
ginuerzh/gost | tls.go | MTLSListener | func MTLSListener(addr string, config *tls.Config) (Listener, error) {
if config == nil {
config = DefaultTLSConfig
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l := &mtlsListener{
ln: tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | go | func MTLSListener(addr string, config *tls.Config) (Listener, error) {
if config == nil {
config = DefaultTLSConfig
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l := &mtlsListener{
ln: tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config),
connChan: make(chan net.Conn, 1024),
errChan: make(chan error, 1),
}
go l.listenLoop()
return l, nil
} | [
"func",
"MTLSListener",
"(",
"addr",
"string",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"DefaultTLSConfig",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"l",
":=",
"&",
"mtlsListener",
"{",
"ln",
":",
"tls",
".",
"NewListener",
"(",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"config",
")",
",",
"connChan",
":",
"make",
"(",
"chan",
"net",
".",
"Conn",
",",
"1024",
")",
",",
"errChan",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"go",
"l",
".",
"listenLoop",
"(",
")",
"\n\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // MTLSListener creates a Listener for multiplex-TLS proxy server. | [
"MTLSListener",
"creates",
"a",
"Listener",
"for",
"multiplex",
"-",
"TLS",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/tls.go#L177-L194 | train |
ginuerzh/gost | hosts.go | NewHost | func NewHost(ip net.IP, hostname string, aliases ...string) Host {
return Host{
IP: ip,
Hostname: hostname,
Aliases: aliases,
}
} | go | func NewHost(ip net.IP, hostname string, aliases ...string) Host {
return Host{
IP: ip,
Hostname: hostname,
Aliases: aliases,
}
} | [
"func",
"NewHost",
"(",
"ip",
"net",
".",
"IP",
",",
"hostname",
"string",
",",
"aliases",
"...",
"string",
")",
"Host",
"{",
"return",
"Host",
"{",
"IP",
":",
"ip",
",",
"Hostname",
":",
"hostname",
",",
"Aliases",
":",
"aliases",
",",
"}",
"\n",
"}"
] | // NewHost creates a Host. | [
"NewHost",
"creates",
"a",
"Host",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/hosts.go#L21-L27 | train |
ginuerzh/gost | hosts.go | Lookup | func (h *Hosts) Lookup(host string) (ip net.IP) {
if h == nil || host == "" {
return
}
h.mux.RLock()
defer h.mux.RUnlock()
for _, h := range h.hosts {
if h.Hostname == host {
ip = h.IP
break
}
for _, alias := range h.Aliases {
if alias == host {
ip = h.IP
break
}
}
}
if ip != nil && Debug {
log.Logf("[hosts] hit: %s %s", host, ip.String())
}
return
} | go | func (h *Hosts) Lookup(host string) (ip net.IP) {
if h == nil || host == "" {
return
}
h.mux.RLock()
defer h.mux.RUnlock()
for _, h := range h.hosts {
if h.Hostname == host {
ip = h.IP
break
}
for _, alias := range h.Aliases {
if alias == host {
ip = h.IP
break
}
}
}
if ip != nil && Debug {
log.Logf("[hosts] hit: %s %s", host, ip.String())
}
return
} | [
"func",
"(",
"h",
"*",
"Hosts",
")",
"Lookup",
"(",
"host",
"string",
")",
"(",
"ip",
"net",
".",
"IP",
")",
"{",
"if",
"h",
"==",
"nil",
"||",
"host",
"==",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n\n",
"h",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"h",
":=",
"range",
"h",
".",
"hosts",
"{",
"if",
"h",
".",
"Hostname",
"==",
"host",
"{",
"ip",
"=",
"h",
".",
"IP",
"\n",
"break",
"\n",
"}",
"\n",
"for",
"_",
",",
"alias",
":=",
"range",
"h",
".",
"Aliases",
"{",
"if",
"alias",
"==",
"host",
"{",
"ip",
"=",
"h",
".",
"IP",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"ip",
"!=",
"nil",
"&&",
"Debug",
"{",
"log",
".",
"Logf",
"(",
"\"",
"\"",
",",
"host",
",",
"ip",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Lookup searches the IP address corresponds to the given host from the host table. | [
"Lookup",
"searches",
"the",
"IP",
"address",
"corresponds",
"to",
"the",
"given",
"host",
"from",
"the",
"host",
"table",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/hosts.go#L58-L82 | train |
ginuerzh/gost | hosts.go | Reload | func (h *Hosts) Reload(r io.Reader) error {
var period time.Duration
var hosts []Host
if r == nil || h.Stopped() {
return nil
}
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
ss := splitLine(line)
if len(ss) < 2 {
continue // invalid lines are ignored
}
switch ss[0] {
case "reload": // reload option
period, _ = time.ParseDuration(ss[1])
default:
ip := net.ParseIP(ss[0])
if ip == nil {
break // invalid IP addresses are ignored
}
host := Host{
IP: ip,
Hostname: ss[1],
}
if len(ss) > 2 {
host.Aliases = ss[2:]
}
hosts = append(hosts, host)
}
}
if err := scanner.Err(); err != nil {
return err
}
h.mux.Lock()
h.period = period
h.hosts = hosts
h.mux.Unlock()
return nil
} | go | func (h *Hosts) Reload(r io.Reader) error {
var period time.Duration
var hosts []Host
if r == nil || h.Stopped() {
return nil
}
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
ss := splitLine(line)
if len(ss) < 2 {
continue // invalid lines are ignored
}
switch ss[0] {
case "reload": // reload option
period, _ = time.ParseDuration(ss[1])
default:
ip := net.ParseIP(ss[0])
if ip == nil {
break // invalid IP addresses are ignored
}
host := Host{
IP: ip,
Hostname: ss[1],
}
if len(ss) > 2 {
host.Aliases = ss[2:]
}
hosts = append(hosts, host)
}
}
if err := scanner.Err(); err != nil {
return err
}
h.mux.Lock()
h.period = period
h.hosts = hosts
h.mux.Unlock()
return nil
} | [
"func",
"(",
"h",
"*",
"Hosts",
")",
"Reload",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"var",
"period",
"time",
".",
"Duration",
"\n",
"var",
"hosts",
"[",
"]",
"Host",
"\n\n",
"if",
"r",
"==",
"nil",
"||",
"h",
".",
"Stopped",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"r",
")",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"line",
":=",
"scanner",
".",
"Text",
"(",
")",
"\n",
"ss",
":=",
"splitLine",
"(",
"line",
")",
"\n",
"if",
"len",
"(",
"ss",
")",
"<",
"2",
"{",
"continue",
"// invalid lines are ignored",
"\n",
"}",
"\n\n",
"switch",
"ss",
"[",
"0",
"]",
"{",
"case",
"\"",
"\"",
":",
"// reload option",
"period",
",",
"_",
"=",
"time",
".",
"ParseDuration",
"(",
"ss",
"[",
"1",
"]",
")",
"\n",
"default",
":",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"ss",
"[",
"0",
"]",
")",
"\n",
"if",
"ip",
"==",
"nil",
"{",
"break",
"// invalid IP addresses are ignored",
"\n",
"}",
"\n",
"host",
":=",
"Host",
"{",
"IP",
":",
"ip",
",",
"Hostname",
":",
"ss",
"[",
"1",
"]",
",",
"}",
"\n",
"if",
"len",
"(",
"ss",
")",
">",
"2",
"{",
"host",
".",
"Aliases",
"=",
"ss",
"[",
"2",
":",
"]",
"\n",
"}",
"\n",
"hosts",
"=",
"append",
"(",
"hosts",
",",
"host",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"scanner",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"h",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"h",
".",
"period",
"=",
"period",
"\n",
"h",
".",
"hosts",
"=",
"hosts",
"\n",
"h",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Reload parses config from r, then live reloads the hosts. | [
"Reload",
"parses",
"config",
"from",
"r",
"then",
"live",
"reloads",
"the",
"hosts",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/hosts.go#L85-L129 | train |
ginuerzh/gost | hosts.go | Period | func (h *Hosts) Period() time.Duration {
if h.Stopped() {
return -1
}
h.mux.RLock()
defer h.mux.RUnlock()
return h.period
} | go | func (h *Hosts) Period() time.Duration {
if h.Stopped() {
return -1
}
h.mux.RLock()
defer h.mux.RUnlock()
return h.period
} | [
"func",
"(",
"h",
"*",
"Hosts",
")",
"Period",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"h",
".",
"Stopped",
"(",
")",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n\n",
"h",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"h",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"h",
".",
"period",
"\n",
"}"
] | // Period returns the reload period | [
"Period",
"returns",
"the",
"reload",
"period"
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/hosts.go#L132-L141 | train |
ginuerzh/gost | auth.go | NewLocalAuthenticator | func NewLocalAuthenticator(kvs map[string]string) *LocalAuthenticator {
return &LocalAuthenticator{
kvs: kvs,
stopped: make(chan struct{}),
}
} | go | func NewLocalAuthenticator(kvs map[string]string) *LocalAuthenticator {
return &LocalAuthenticator{
kvs: kvs,
stopped: make(chan struct{}),
}
} | [
"func",
"NewLocalAuthenticator",
"(",
"kvs",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"LocalAuthenticator",
"{",
"return",
"&",
"LocalAuthenticator",
"{",
"kvs",
":",
"kvs",
",",
"stopped",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // NewLocalAuthenticator creates an Authenticator that authenticates client by local infos. | [
"NewLocalAuthenticator",
"creates",
"an",
"Authenticator",
"that",
"authenticates",
"client",
"by",
"local",
"infos",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/auth.go#L25-L30 | train |
ginuerzh/gost | auth.go | Authenticate | func (au *LocalAuthenticator) Authenticate(user, password string) bool {
if au == nil {
return true
}
au.mux.RLock()
defer au.mux.RUnlock()
if len(au.kvs) == 0 {
return true
}
v, ok := au.kvs[user]
return ok && (v == "" || password == v)
} | go | func (au *LocalAuthenticator) Authenticate(user, password string) bool {
if au == nil {
return true
}
au.mux.RLock()
defer au.mux.RUnlock()
if len(au.kvs) == 0 {
return true
}
v, ok := au.kvs[user]
return ok && (v == "" || password == v)
} | [
"func",
"(",
"au",
"*",
"LocalAuthenticator",
")",
"Authenticate",
"(",
"user",
",",
"password",
"string",
")",
"bool",
"{",
"if",
"au",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"au",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"au",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"len",
"(",
"au",
".",
"kvs",
")",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"v",
",",
"ok",
":=",
"au",
".",
"kvs",
"[",
"user",
"]",
"\n",
"return",
"ok",
"&&",
"(",
"v",
"==",
"\"",
"\"",
"||",
"password",
"==",
"v",
")",
"\n",
"}"
] | // Authenticate checks the validity of the provided user-password pair. | [
"Authenticate",
"checks",
"the",
"validity",
"of",
"the",
"provided",
"user",
"-",
"password",
"pair",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/auth.go#L33-L47 | train |
ginuerzh/gost | auth.go | Add | func (au *LocalAuthenticator) Add(k, v string) {
au.mux.Lock()
defer au.mux.Unlock()
if au.kvs == nil {
au.kvs = make(map[string]string)
}
au.kvs[k] = v
} | go | func (au *LocalAuthenticator) Add(k, v string) {
au.mux.Lock()
defer au.mux.Unlock()
if au.kvs == nil {
au.kvs = make(map[string]string)
}
au.kvs[k] = v
} | [
"func",
"(",
"au",
"*",
"LocalAuthenticator",
")",
"Add",
"(",
"k",
",",
"v",
"string",
")",
"{",
"au",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"au",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n",
"if",
"au",
".",
"kvs",
"==",
"nil",
"{",
"au",
".",
"kvs",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"}",
"\n",
"au",
".",
"kvs",
"[",
"k",
"]",
"=",
"v",
"\n",
"}"
] | // Add adds a key-value pair to the Authenticator. | [
"Add",
"adds",
"a",
"key",
"-",
"value",
"pair",
"to",
"the",
"Authenticator",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/auth.go#L50-L57 | train |
ginuerzh/gost | bypass.go | NewBypass | func NewBypass(reversed bool, matchers ...Matcher) *Bypass {
return &Bypass{
matchers: matchers,
reversed: reversed,
stopped: make(chan struct{}),
}
} | go | func NewBypass(reversed bool, matchers ...Matcher) *Bypass {
return &Bypass{
matchers: matchers,
reversed: reversed,
stopped: make(chan struct{}),
}
} | [
"func",
"NewBypass",
"(",
"reversed",
"bool",
",",
"matchers",
"...",
"Matcher",
")",
"*",
"Bypass",
"{",
"return",
"&",
"Bypass",
"{",
"matchers",
":",
"matchers",
",",
"reversed",
":",
"reversed",
",",
"stopped",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // NewBypass creates and initializes a new Bypass using matchers as its match rules.
// The rules will be reversed if the reversed is true. | [
"NewBypass",
"creates",
"and",
"initializes",
"a",
"new",
"Bypass",
"using",
"matchers",
"as",
"its",
"match",
"rules",
".",
"The",
"rules",
"will",
"be",
"reversed",
"if",
"the",
"reversed",
"is",
"true",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/bypass.go#L133-L139 | train |
ginuerzh/gost | bypass.go | NewBypassPatterns | func NewBypassPatterns(reversed bool, patterns ...string) *Bypass {
var matchers []Matcher
for _, pattern := range patterns {
if m := NewMatcher(pattern); m != nil {
matchers = append(matchers, m)
}
}
bp := NewBypass(reversed)
bp.AddMatchers(matchers...)
return bp
} | go | func NewBypassPatterns(reversed bool, patterns ...string) *Bypass {
var matchers []Matcher
for _, pattern := range patterns {
if m := NewMatcher(pattern); m != nil {
matchers = append(matchers, m)
}
}
bp := NewBypass(reversed)
bp.AddMatchers(matchers...)
return bp
} | [
"func",
"NewBypassPatterns",
"(",
"reversed",
"bool",
",",
"patterns",
"...",
"string",
")",
"*",
"Bypass",
"{",
"var",
"matchers",
"[",
"]",
"Matcher",
"\n",
"for",
"_",
",",
"pattern",
":=",
"range",
"patterns",
"{",
"if",
"m",
":=",
"NewMatcher",
"(",
"pattern",
")",
";",
"m",
"!=",
"nil",
"{",
"matchers",
"=",
"append",
"(",
"matchers",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"bp",
":=",
"NewBypass",
"(",
"reversed",
")",
"\n",
"bp",
".",
"AddMatchers",
"(",
"matchers",
"...",
")",
"\n",
"return",
"bp",
"\n",
"}"
] | // NewBypassPatterns creates and initializes a new Bypass using matcher patterns as its match rules.
// The rules will be reversed if the reverse is true. | [
"NewBypassPatterns",
"creates",
"and",
"initializes",
"a",
"new",
"Bypass",
"using",
"matcher",
"patterns",
"as",
"its",
"match",
"rules",
".",
"The",
"rules",
"will",
"be",
"reversed",
"if",
"the",
"reverse",
"is",
"true",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/bypass.go#L143-L153 | train |
ginuerzh/gost | bypass.go | Contains | func (bp *Bypass) Contains(addr string) bool {
if bp == nil || addr == "" {
return false
}
// try to strip the port
if host, port, _ := net.SplitHostPort(addr); host != "" && port != "" {
if p, _ := strconv.Atoi(port); p > 0 { // port is valid
addr = host
}
}
bp.mux.RLock()
defer bp.mux.RUnlock()
if len(bp.matchers) == 0 {
return false
}
var matched bool
for _, matcher := range bp.matchers {
if matcher == nil {
continue
}
if matcher.Match(addr) {
matched = true
break
}
}
return !bp.reversed && matched ||
bp.reversed && !matched
} | go | func (bp *Bypass) Contains(addr string) bool {
if bp == nil || addr == "" {
return false
}
// try to strip the port
if host, port, _ := net.SplitHostPort(addr); host != "" && port != "" {
if p, _ := strconv.Atoi(port); p > 0 { // port is valid
addr = host
}
}
bp.mux.RLock()
defer bp.mux.RUnlock()
if len(bp.matchers) == 0 {
return false
}
var matched bool
for _, matcher := range bp.matchers {
if matcher == nil {
continue
}
if matcher.Match(addr) {
matched = true
break
}
}
return !bp.reversed && matched ||
bp.reversed && !matched
} | [
"func",
"(",
"bp",
"*",
"Bypass",
")",
"Contains",
"(",
"addr",
"string",
")",
"bool",
"{",
"if",
"bp",
"==",
"nil",
"||",
"addr",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// try to strip the port",
"if",
"host",
",",
"port",
",",
"_",
":=",
"net",
".",
"SplitHostPort",
"(",
"addr",
")",
";",
"host",
"!=",
"\"",
"\"",
"&&",
"port",
"!=",
"\"",
"\"",
"{",
"if",
"p",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"port",
")",
";",
"p",
">",
"0",
"{",
"// port is valid",
"addr",
"=",
"host",
"\n",
"}",
"\n",
"}",
"\n\n",
"bp",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"bp",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"len",
"(",
"bp",
".",
"matchers",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"var",
"matched",
"bool",
"\n",
"for",
"_",
",",
"matcher",
":=",
"range",
"bp",
".",
"matchers",
"{",
"if",
"matcher",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"matcher",
".",
"Match",
"(",
"addr",
")",
"{",
"matched",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"!",
"bp",
".",
"reversed",
"&&",
"matched",
"||",
"bp",
".",
"reversed",
"&&",
"!",
"matched",
"\n",
"}"
] | // Contains reports whether the bypass includes addr. | [
"Contains",
"reports",
"whether",
"the",
"bypass",
"includes",
"addr",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/bypass.go#L156-L187 | train |
ginuerzh/gost | bypass.go | AddMatchers | func (bp *Bypass) AddMatchers(matchers ...Matcher) {
bp.mux.Lock()
defer bp.mux.Unlock()
bp.matchers = append(bp.matchers, matchers...)
} | go | func (bp *Bypass) AddMatchers(matchers ...Matcher) {
bp.mux.Lock()
defer bp.mux.Unlock()
bp.matchers = append(bp.matchers, matchers...)
} | [
"func",
"(",
"bp",
"*",
"Bypass",
")",
"AddMatchers",
"(",
"matchers",
"...",
"Matcher",
")",
"{",
"bp",
".",
"mux",
".",
"Lock",
"(",
")",
"\n",
"defer",
"bp",
".",
"mux",
".",
"Unlock",
"(",
")",
"\n\n",
"bp",
".",
"matchers",
"=",
"append",
"(",
"bp",
".",
"matchers",
",",
"matchers",
"...",
")",
"\n",
"}"
] | // AddMatchers appends matchers to the bypass matcher list. | [
"AddMatchers",
"appends",
"matchers",
"to",
"the",
"bypass",
"matcher",
"list",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/bypass.go#L190-L195 | train |
ginuerzh/gost | bypass.go | Matchers | func (bp *Bypass) Matchers() []Matcher {
bp.mux.RLock()
defer bp.mux.RUnlock()
return bp.matchers
} | go | func (bp *Bypass) Matchers() []Matcher {
bp.mux.RLock()
defer bp.mux.RUnlock()
return bp.matchers
} | [
"func",
"(",
"bp",
"*",
"Bypass",
")",
"Matchers",
"(",
")",
"[",
"]",
"Matcher",
"{",
"bp",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"bp",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"bp",
".",
"matchers",
"\n",
"}"
] | // Matchers return the bypass matcher list. | [
"Matchers",
"return",
"the",
"bypass",
"matcher",
"list",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/bypass.go#L198-L203 | train |
ginuerzh/gost | bypass.go | Reversed | func (bp *Bypass) Reversed() bool {
bp.mux.RLock()
defer bp.mux.RUnlock()
return bp.reversed
} | go | func (bp *Bypass) Reversed() bool {
bp.mux.RLock()
defer bp.mux.RUnlock()
return bp.reversed
} | [
"func",
"(",
"bp",
"*",
"Bypass",
")",
"Reversed",
"(",
")",
"bool",
"{",
"bp",
".",
"mux",
".",
"RLock",
"(",
")",
"\n",
"defer",
"bp",
".",
"mux",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"bp",
".",
"reversed",
"\n",
"}"
] | // Reversed reports whether the rules of the bypass are reversed. | [
"Reversed",
"reports",
"whether",
"the",
"rules",
"of",
"the",
"bypass",
"are",
"reversed",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/bypass.go#L206-L211 | train |
ginuerzh/gost | obfs.go | ObfsHTTPListener | func ObfsHTTPListener(addr string) (Listener, error) {
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenTCP("tcp", laddr)
if err != nil {
return nil, err
}
return &obfsHTTPListener{Listener: tcpKeepAliveListener{ln}}, nil
} | go | func ObfsHTTPListener(addr string) (Listener, error) {
laddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
return nil, err
}
ln, err := net.ListenTCP("tcp", laddr)
if err != nil {
return nil, err
}
return &obfsHTTPListener{Listener: tcpKeepAliveListener{ln}}, nil
} | [
"func",
"ObfsHTTPListener",
"(",
"addr",
"string",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"laddr",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ln",
",",
"err",
":=",
"net",
".",
"ListenTCP",
"(",
"\"",
"\"",
",",
"laddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"obfsHTTPListener",
"{",
"Listener",
":",
"tcpKeepAliveListener",
"{",
"ln",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // ObfsHTTPListener creates a Listener for HTTP obfuscating tunnel server. | [
"ObfsHTTPListener",
"creates",
"a",
"Listener",
"for",
"HTTP",
"obfuscating",
"tunnel",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/obfs.go#L47-L57 | train |
ginuerzh/gost | obfs.go | Obfs4Init | func Obfs4Init(node Node, isServeNode bool) error {
if _, ok := obfs4Map[node.Addr]; ok {
return fmt.Errorf("obfs4 context already inited")
}
t := new(obfs4.Transport)
stateDir := node.Values.Get("state-dir")
if stateDir == "" {
stateDir = "."
}
ptArgs := pt.Args(node.Values)
if !isServeNode {
cf, err := t.ClientFactory(stateDir)
if err != nil {
return err
}
cargs, err := cf.ParseArgs(&ptArgs)
if err != nil {
return err
}
obfs4Map[node.Addr] = obfs4Context{cf: cf, cargs: cargs}
} else {
sf, err := t.ServerFactory(stateDir, &ptArgs)
if err != nil {
return err
}
sargs := sf.Args()
obfs4Map[node.Addr] = obfs4Context{sf: sf, sargs: sargs}
log.Log("[obfs4] server inited:", obfs4ServerURL(node))
}
return nil
} | go | func Obfs4Init(node Node, isServeNode bool) error {
if _, ok := obfs4Map[node.Addr]; ok {
return fmt.Errorf("obfs4 context already inited")
}
t := new(obfs4.Transport)
stateDir := node.Values.Get("state-dir")
if stateDir == "" {
stateDir = "."
}
ptArgs := pt.Args(node.Values)
if !isServeNode {
cf, err := t.ClientFactory(stateDir)
if err != nil {
return err
}
cargs, err := cf.ParseArgs(&ptArgs)
if err != nil {
return err
}
obfs4Map[node.Addr] = obfs4Context{cf: cf, cargs: cargs}
} else {
sf, err := t.ServerFactory(stateDir, &ptArgs)
if err != nil {
return err
}
sargs := sf.Args()
obfs4Map[node.Addr] = obfs4Context{sf: sf, sargs: sargs}
log.Log("[obfs4] server inited:", obfs4ServerURL(node))
}
return nil
} | [
"func",
"Obfs4Init",
"(",
"node",
"Node",
",",
"isServeNode",
"bool",
")",
"error",
"{",
"if",
"_",
",",
"ok",
":=",
"obfs4Map",
"[",
"node",
".",
"Addr",
"]",
";",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"t",
":=",
"new",
"(",
"obfs4",
".",
"Transport",
")",
"\n\n",
"stateDir",
":=",
"node",
".",
"Values",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"stateDir",
"==",
"\"",
"\"",
"{",
"stateDir",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"ptArgs",
":=",
"pt",
".",
"Args",
"(",
"node",
".",
"Values",
")",
"\n\n",
"if",
"!",
"isServeNode",
"{",
"cf",
",",
"err",
":=",
"t",
".",
"ClientFactory",
"(",
"stateDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"cargs",
",",
"err",
":=",
"cf",
".",
"ParseArgs",
"(",
"&",
"ptArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"obfs4Map",
"[",
"node",
".",
"Addr",
"]",
"=",
"obfs4Context",
"{",
"cf",
":",
"cf",
",",
"cargs",
":",
"cargs",
"}",
"\n",
"}",
"else",
"{",
"sf",
",",
"err",
":=",
"t",
".",
"ServerFactory",
"(",
"stateDir",
",",
"&",
"ptArgs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"sargs",
":=",
"sf",
".",
"Args",
"(",
")",
"\n\n",
"obfs4Map",
"[",
"node",
".",
"Addr",
"]",
"=",
"obfs4Context",
"{",
"sf",
":",
"sf",
",",
"sargs",
":",
"sargs",
"}",
"\n\n",
"log",
".",
"Log",
"(",
"\"",
"\"",
",",
"obfs4ServerURL",
"(",
"node",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Obfs4Init initializes the obfs client or server based on isServeNode | [
"Obfs4Init",
"initializes",
"the",
"obfs",
"client",
"or",
"server",
"based",
"on",
"isServeNode"
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/obfs.go#L262-L302 | train |
ginuerzh/gost | obfs.go | Obfs4Listener | func Obfs4Listener(addr string) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l := &obfs4Listener{
addr: addr,
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
}
return l, nil
} | go | func Obfs4Listener(addr string) (Listener, error) {
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
l := &obfs4Listener{
addr: addr,
Listener: tcpKeepAliveListener{ln.(*net.TCPListener)},
}
return l, nil
} | [
"func",
"Obfs4Listener",
"(",
"addr",
"string",
")",
"(",
"Listener",
",",
"error",
")",
"{",
"ln",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
":=",
"&",
"obfs4Listener",
"{",
"addr",
":",
"addr",
",",
"Listener",
":",
"tcpKeepAliveListener",
"{",
"ln",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
"}",
",",
"}",
"\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] | // Obfs4Listener creates a Listener for obfs4 server. | [
"Obfs4Listener",
"creates",
"a",
"Listener",
"for",
"obfs4",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/obfs.go#L379-L389 | train |
ginuerzh/gost | client.go | Dial | func (c *Client) Dial(addr string, options ...DialOption) (net.Conn, error) {
return c.Transporter.Dial(addr, options...)
} | go | func (c *Client) Dial(addr string, options ...DialOption) (net.Conn, error) {
return c.Transporter.Dial(addr, options...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Dial",
"(",
"addr",
"string",
",",
"options",
"...",
"DialOption",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"c",
".",
"Transporter",
".",
"Dial",
"(",
"addr",
",",
"options",
"...",
")",
"\n",
"}"
] | // Dial connects to the target address. | [
"Dial",
"connects",
"to",
"the",
"target",
"address",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/client.go#L22-L24 | train |
ginuerzh/gost | client.go | Handshake | func (c *Client) Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error) {
return c.Transporter.Handshake(conn, options...)
} | go | func (c *Client) Handshake(conn net.Conn, options ...HandshakeOption) (net.Conn, error) {
return c.Transporter.Handshake(conn, options...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Handshake",
"(",
"conn",
"net",
".",
"Conn",
",",
"options",
"...",
"HandshakeOption",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"c",
".",
"Transporter",
".",
"Handshake",
"(",
"conn",
",",
"options",
"...",
")",
"\n",
"}"
] | // Handshake performs a handshake with the proxy over connection conn. | [
"Handshake",
"performs",
"a",
"handshake",
"with",
"the",
"proxy",
"over",
"connection",
"conn",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/client.go#L27-L29 | train |
ginuerzh/gost | client.go | Connect | func (c *Client) Connect(conn net.Conn, addr string, options ...ConnectOption) (net.Conn, error) {
return c.Connector.Connect(conn, addr, options...)
} | go | func (c *Client) Connect(conn net.Conn, addr string, options ...ConnectOption) (net.Conn, error) {
return c.Connector.Connect(conn, addr, options...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Connect",
"(",
"conn",
"net",
".",
"Conn",
",",
"addr",
"string",
",",
"options",
"...",
"ConnectOption",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"c",
".",
"Connector",
".",
"Connect",
"(",
"conn",
",",
"addr",
",",
"options",
"...",
")",
"\n",
"}"
] | // Connect connects to the address addr via the proxy over connection conn. | [
"Connect",
"connects",
"to",
"the",
"address",
"addr",
"via",
"the",
"proxy",
"over",
"connection",
"conn",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/client.go#L32-L34 | train |
ginuerzh/gost | client.go | Dial | func Dial(addr string, options ...DialOption) (net.Conn, error) {
return DefaultClient.Dial(addr, options...)
} | go | func Dial(addr string, options ...DialOption) (net.Conn, error) {
return DefaultClient.Dial(addr, options...)
} | [
"func",
"Dial",
"(",
"addr",
"string",
",",
"options",
"...",
"DialOption",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"DefaultClient",
".",
"Dial",
"(",
"addr",
",",
"options",
"...",
")",
"\n",
"}"
] | // Dial connects to the address addr via the DefaultClient. | [
"Dial",
"connects",
"to",
"the",
"address",
"addr",
"via",
"the",
"DefaultClient",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/client.go#L40-L42 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.