id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
160,200 | 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",
... | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_cols.go#L169-L172 |
160,201 | 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 |
160,202 | 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... | // 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 |
160,203 | 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",
"... | // Close the engine | [
"Close",
"the",
"engine"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L63-L76 |
160,204 | 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",
".",
"Cont... | // Context returned a group session | [
"Context",
"returned",
"a",
"group",
"session"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L79-L83 |
160,205 | 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 |
160,206 | 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",
")... | // 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 |
160,207 | 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",
".",
"sl... | // SetDefaultCacher set the default cacher | [
"SetDefaultCacher",
"set",
"the",
"default",
"cacher"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group.go#L128-L133 |
160,208 | 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",
... | // 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 |
160,209 | 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 |
160,210 | 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",
")",... | // 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 |
160,211 | 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",
"[",
... | // 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 |
160,212 | 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",
"... | // Init initializes the name server. | [
"Init",
"initializes",
"the",
"name",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/resolver.go#L53-L117 |
160,213 | 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 |
160,214 | 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",
"... | // 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 |
160,215 | 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",
"&",
"htt... | // 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 |
160,216 | 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",
"&",
"h2Tran... | // 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 |
160,217 | 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 |
160,218 | 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",
")"... | // 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 |
160,219 | 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",
... | // 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 |
160,220 | 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",
... | // 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 |
160,221 | 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 |
160,222 | 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 na... | // 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 |
160,223 | 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",
"(",
"\"",
"\"",... | // 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 |
160,224 | 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 |
160,225 | 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",... | // 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 |
160,226 | 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",
"!=",
... | // 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 |
160,227 | 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",
"(",
"\"",
"\"",
",",
"ad... | // 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 |
160,228 | 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",
"==",
"\"",
"\... | // 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 |
160,229 | 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",
"(",
"... | // 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 |
160,230 | 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",
"=",... | // 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 |
160,231 | 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 |
160,232 | 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",
"... | // Filter filters nodes. | [
"Filter",
"filters",
"nodes",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/selector.go#L171-L188 |
160,233 | 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",
"[",
... | // 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 |
160,234 | 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 |
160,235 | 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 |
160,236 | 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 |
160,237 | 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 |
160,238 | 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 |
160,239 | 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",
"{",... | // 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 |
160,240 | 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",
",",
"ses... | // 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 |
160,241 | 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",
":=",
"&",
"qu... | // 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 |
160,242 | 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 |
160,243 | 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 |
160,244 | 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",
"(",
"\"",
"\"",
",",
... | // 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 |
160,245 | 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",
"retur... | // GenCertificate generates a random TLS certificate. | [
"GenCertificate",
"generates",
"a",
"random",
"TLS",
"certificate",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/gost.go#L87-L93 |
160,246 | 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",
"{... | // 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 |
160,247 | 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",
":=",
"r... | // Init intializes server with given options. | [
"Init",
"intializes",
"server",
"with",
"given",
"options",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/server.go#L24-L31 |
160,248 | 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",
":=",
... | // Serve serves as a proxy server. | [
"Serve",
"serves",
"as",
"a",
"proxy",
"server",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/server.go#L44-L94 |
160,249 | 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"... | // 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 |
160,250 | 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 |
160,251 | 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",
",",
"... | // Init initializes the KCP config. | [
"Init",
"initializes",
"the",
"KCP",
"config",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/kcp.go#L52-L63 |
160,252 | 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",
"(",
... | // 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 |
160,253 | 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"... | // 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 |
160,254 | 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",
")",
",",
"}",... | // 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 |
160,255 | 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 |
160,256 | 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",
".",
"handshak... | // 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 |
160,257 | 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",
"re... | // 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 |
160,258 | 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 |
160,259 | 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 |
160,260 | 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 |
160,261 | 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... | // 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 |
160,262 | 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",
"gro... | // 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 |
160,263 | 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",
"... | // 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 |
160,264 | 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",
".",
"R... | // 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 |
160,265 | 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",
"=... | // 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 |
160,266 | 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",
... | // 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 |
160,267 | 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",
... | // 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 |
160,268 | 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 |
160,269 | 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",
... | // 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 |
160,270 | 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",
")",
... | // 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",
... | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L61-L67 |
160,271 | 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",
")",
"-"... | // 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 |
160,272 | 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",
"_",
",",
"op... | // 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 |
160,273 | 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",
"opt... | // 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 |
160,274 | 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"... | // 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 |
160,275 | 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",
... | // selectRouteFor selects route with bypass testing. | [
"selectRouteFor",
"selects",
"route",
"with",
"bypass",
"testing",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/chain.go#L263-L299 |
160,276 | 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 |
160,277 | 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 |
160,278 | 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",... | // 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 |
160,279 | 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"... | // 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 |
160,280 | 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 |
160,281 | 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",
"(",
... | // 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 |
160,282 | 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",
"(",
"... | // 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 |
160,283 | 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",
... | // Period returns the reload period | [
"Period",
"returns",
"the",
"reload",
"period"
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/hosts.go#L132-L141 |
160,284 | 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",
"{",
"}",
")",
",",
"}... | // 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 |
160,285 | 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",
... | // 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 |
160,286 | 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",
"{... | // 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 |
160,287 | 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",
"{"... | // 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 |
160,288 | 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",
"(",... | // 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 |
160,289 | 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",
","... | // 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 |
160,290 | 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",
"(... | // 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 |
160,291 | 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 |
160,292 | 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 |
160,293 | 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",
",",
... | // 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 |
160,294 | 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... | // 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 |
160,295 | 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",... | // 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 |
160,296 | 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",
"...",
")",... | // Dial connects to the target address. | [
"Dial",
"connects",
"to",
"the",
"target",
"address",
"."
] | 49f2ee612a5ecd7a07d6731cf241a91a702885b7 | https://github.com/ginuerzh/gost/blob/49f2ee612a5ecd7a07d6731cf241a91a702885b7/client.go#L22-L24 |
160,297 | 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",
",",... | // 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 |
160,298 | 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",
... | // 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 |
160,299 | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.