fix metadata

cmd/gost/cmd.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/go-gost/gost/pkg/config"
+	"github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 )
 
@@ -67,7 +68,11 @@ func buildConfigFromCmd(services, nodes stringList) (*config.Config, error) {
 		}
 		service.Name = fmt.Sprintf("service-%d", i)
 		if chain != nil {
-			service.Handler.Chain = chain.Name
+			if service.Listener.Type == "rtcp" || service.Listener.Type == "rudp" {
+				service.Listener.Chain = chain.Name
+			} else {
+				service.Handler.Chain = chain.Name
+			}
 		}
 		cfg.Services = append(cfg.Services, service)
 	}
@@ -125,37 +130,30 @@ func buildServiceConfig(url *url.URL) (*config.ServiceConfig, error) {
 		auths = append(auths, auth)
 	}
 
-	md := make(map[string]interface{})
+	md := metadata.MapMetadata{}
 	for k, v := range url.Query() {
 		if len(v) > 0 {
 			md[k] = v[0]
 		}
 	}
-	if sauth := md["auth"]; sauth != nil {
-		if sa, _ := sauth.(string); sa != "" {
-			au, err := parseAuthFromCmd(sa)
-			if err != nil {
-				return nil, err
-			}
-			auths = append(auths, au)
-		}
-	}
-	delete(md, "auth")
 
-	var tlsConfig *config.TLSConfig
+	if sa := metadata.GetString(md, "auth"); sa != "" {
-	if certs := md["cert"]; certs != nil {
+		au, err := parseAuthFromCmd(sa)
-		cert, _ := certs.(string)
+		if err != nil {
-		key, _ := md["key"].(string)
+			return nil, err
-		ca, _ := md["ca"].(string)
-		tlsConfig = &config.TLSConfig{
-			Cert: cert,
-			Key:  key,
-			CA:   ca,
 		}
+		auths = append(auths, au)
 	}
-	delete(md, "cert")
+	md.Del("auth")
-	delete(md, "key")
+
-	delete(md, "ca")
+	tlsConfig := &config.TLSConfig{
+		Cert: metadata.GetString(md, "cert"),
+		Key:  metadata.GetString(md, "key"),
+		CA:   metadata.GetString(md, "ca"),
+	}
+	md.Del("cert")
+	md.Del("key")
+	md.Del("ca")
 
 	svc.Handler = &config.HandlerConfig{
 		Type:     handler,
@@ -205,45 +203,33 @@ func buildNodeConfig(url *url.URL) (*config.NodeConfig, error) {
 		auth.Password, _ = url.User.Password()
 	}
 
-	md := make(map[string]interface{})
+	md := metadata.MapMetadata{}
 	for k, v := range url.Query() {
 		if len(v) > 0 {
 			md[k] = v[0]
 		}
 	}
-	md["serverName"] = url.Host
 
-	if sauth := md["auth"]; sauth != nil && auth == nil {
+	if sauth := metadata.GetString(md, "auth"); sauth != "" && auth == nil {
-		if sa, _ := sauth.(string); sa != "" {
+		au, err := parseAuthFromCmd(sauth)
-			au, err := parseAuthFromCmd(sa)
+		if err != nil {
-			if err != nil {
+			return nil, err
-				return nil, err
-			}
-			auth = au
 		}
+		auth = au
 	}
-	delete(md, "auth")
+	md.Del("auth")
 
-	var tlsConfig *config.TLSConfig
+	tlsConfig := &config.TLSConfig{
-	if certs := md["cert"]; certs != nil {
+		CA:         metadata.GetString(md, "ca"),
-		cert, _ := certs.(string)
+		Secure:     metadata.GetBool(md, "secure"),
-		key, _ := md["key"].(string)
+		ServerName: metadata.GetString(md, "serverName"),
-		ca, _ := md["ca"].(string)
-		secure, _ := md["secure"].(bool)
-		serverName, _ := md["serverName"].(string)
-		tlsConfig = &config.TLSConfig{
-			Cert:       cert,
-			Key:        key,
-			CA:         ca,
-			Secure:     secure,
-			ServerName: serverName,
-		}
 	}
-	delete(md, "cert")
+	if tlsConfig.ServerName == "" {
-	delete(md, "key")
+		tlsConfig.ServerName = url.Hostname()
-	delete(md, "ca")
+	}
-	delete(md, "secure")
+	md.Del("ca")
-	delete(md, "serverName")
+	md.Del("secure")
+	md.Del("serverName")
 
 	node.Connector = &config.ConnectorConfig{
 		Type:     connector,

cmd/gost/config.go

@@ -56,8 +56,15 @@ func buildService(cfg *config.Config) (services []*service.Service) {
 	}
 
 	for _, svc := range cfg.Services {
-		if svc.Listener == nil || svc.Handler == nil {
+		if svc.Listener == nil {
-			continue
+			svc.Listener = &config.ListenerConfig{
+				Type: "tcp",
+			}
+		}
+		if svc.Handler == nil {
+			svc.Handler = &config.HandlerConfig{
+				Type: "auto",
+			}
 		}
 		serviceLogger := log.WithFields(map[string]interface{}{
 			"kind":     "service",
@@ -89,10 +96,6 @@ func buildService(cfg *config.Config) (services []*service.Service) {
 			listener.LoggerOption(listenerLogger),
 		)
 
-		if chainable, ok := ln.(chain.Chainable); ok {
-			chainable.WithChain(chains[svc.Listener.Chain])
-		}
-
 		if svc.Listener.Metadata == nil {
 			svc.Listener.Metadata = make(map[string]interface{})
 		}
@@ -292,9 +295,9 @@ func logFromConfig(cfg *config.LogConfig) logger.Logger {
 	switch cfg.Output {
 	case "none":
 		return logger.Nop()
-	case "stdout", "":
+	case "stdout":
 		out = os.Stdout
-	case "stderr":
+	case "stderr", "":
 		out = os.Stderr
 	default:
 		f, err := os.OpenFile(cfg.Output, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)

pkg/chain/chain.go

@@ -1,9 +1,5 @@
 package chain
 
-type Chainable interface {
-	WithChain(chain *Chain)
-}
-
 type Chain struct {
 	groups []*NodeGroup
 }

pkg/config/config.go

@@ -31,11 +31,11 @@ type ProfilingConfig struct {
 }
 
 type TLSConfig struct {
-	Cert       string
+	Cert       string `yaml:",omitempty"`
-	Key        string
+	Key        string `yaml:",omitempty"`
 	CA         string `yaml:",omitempty"`
 	Secure     bool   `yaml:",omitempty"`
-	ServerName string `yaml:",omitempty"`
+	ServerName string `yaml:"serverName,omitempty"`
 }
 
 type AuthConfig struct {
@@ -59,7 +59,7 @@ type NameserverConfig struct {
 	Addr     string
 	Chain    string
 	Prefer   string
-	ClientIP string
+	ClientIP string `yaml:"clientIP"`
 	Hostname string
 	TTL      time.Duration
 	Timeout  time.Duration

pkg/listener/dns/metadata.go

@@ -20,14 +20,17 @@ type metadata struct {
 
 func (l *dnsListener) parseMetadata(md mdata.Metadata) (err error) {
 	const (
+		backlog        = "backlog"
 		mode           = "mode"
 		readBufferSize = "readBufferSize"
-
+		readTimeout    = "readTimeout"
-		backlog = "backlog"
+		writeTimeout   = "writeTimeout"
 	)
 
 	l.md.mode = mdata.GetString(md, mode)
 	l.md.readBufferSize = mdata.GetInt(md, readBufferSize)
+	l.md.readTimeout = mdata.GetDuration(md, readTimeout)
+	l.md.writeTimeout = mdata.GetDuration(md, writeTimeout)
 
 	l.md.backlog = mdata.GetInt(md, backlog)
 	if l.md.backlog <= 0 {

pkg/listener/http2/metadata.go

@@ -1,9 +1,6 @@
 package http2
 
 import (
-	"net/http"
-	"time"
-
 	mdata "github.com/go-gost/gost/pkg/metadata"
 )
 
@@ -12,24 +9,12 @@ const (
 )
 
 type metadata struct {
-	path              string
+	backlog int
-	handshakeTimeout  time.Duration
-	readHeaderTimeout time.Duration
-	readBufferSize    int
-	writeBufferSize   int
-	enableCompression bool
-	responseHeader    http.Header
-	backlog           int
 }
 
 func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
 	const (
-		path              = "path"
+		backlog = "backlog"
-		handshakeTimeout  = "handshakeTimeout"
-		readHeaderTimeout = "readHeaderTimeout"
-		readBufferSize    = "readBufferSize"
-		writeBufferSize   = "writeBufferSize"
-		backlog           = "backlog"
 	)
 
 	l.md.backlog = mdata.GetInt(md, backlog)

pkg/listener/option.go

@@ -4,6 +4,7 @@ import (
 	"crypto/tls"
 	"net/url"
 
+	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/logger"
 )
 
@@ -11,6 +12,7 @@ type Options struct {
 	Addr      string
 	Auths     []*url.Userinfo
 	TLSConfig *tls.Config
+	Chain     *chain.Chain
 	Logger    logger.Logger
 }
 
@@ -34,6 +36,12 @@ func TLSConfigOption(tlsConfig *tls.Config) Option {
 	}
 }
 
+func ChainOption(chain *chain.Chain) Option {
+	return func(opts *Options) {
+		opts.Chain = chain
+	}
+}
+
 func LoggerOption(logger logger.Logger) Option {
 	return func(opts *Options) {
 		opts.Logger = logger

pkg/listener/rtcp/listener.go

@@ -17,47 +17,42 @@ func init() {
 }
 
 type rtcpListener struct {
-	addr   string
+	laddr   net.Addr
-	laddr  net.Addr
+	ln      net.Listener
-	chain  *chain.Chain
+	md      metadata
-	ln     net.Listener
+	router  *chain.Router
-	md     metadata
+	logger  logger.Logger
-	router *chain.Router
+	closed  chan struct{}
-	logger logger.Logger
+	options listener.Options
-	closed chan struct{}
 }
 
 func NewListener(opts ...listener.Option) listener.Listener {
-	options := &listener.Options{}
+	options := listener.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 	return &rtcpListener{
-		addr:   options.Addr,
+		closed:  make(chan struct{}),
-		closed: make(chan struct{}),
+		logger:  options.Logger,
-		router: &chain.Router{
+		options: options,
-			Logger: options.Logger,
-		},
-		logger: options.Logger,
 	}
 }
 
-// implements chain.Chainable interface
-func (l *rtcpListener) WithChain(chain *chain.Chain) {
-	l.router.Chain = chain
-}
-
 func (l *rtcpListener) Init(md md.Metadata) (err error) {
 	if err = l.parseMetadata(md); err != nil {
 		return
 	}
 
-	laddr, err := net.ResolveTCPAddr("tcp", l.addr)
+	laddr, err := net.ResolveTCPAddr("tcp", l.options.Addr)
 	if err != nil {
 		return
 	}
 
 	l.laddr = laddr
+	l.router = &chain.Router{
+		Chain:  l.options.Chain,
+		Logger: l.logger,
+	}
 
 	return
 }

pkg/listener/rtcp/metadata.go

@@ -12,24 +12,8 @@ const (
 )
 
 type metadata struct {
-	enableMux  bool
-	backlog    int
-	retryCount int
 }
 
 func (l *rtcpListener) parseMetadata(md mdata.Metadata) (err error) {
-	const (
-		enableMux  = "mux"
-		backlog    = "backlog"
-		retryCount = "retry"
-	)
-
-	l.md.enableMux = mdata.GetBool(md, enableMux)
-	l.md.retryCount = mdata.GetInt(md, retryCount)
-
-	l.md.backlog = mdata.GetInt(md, backlog)
-	if l.md.backlog <= 0 {
-		l.md.backlog = defaultBacklog
-	}
 	return
 }

pkg/listener/rudp/listener.go

@@ -17,47 +17,42 @@ func init() {
 }
 
 type rudpListener struct {
-	addr   string
+	laddr   *net.UDPAddr
-	laddr  *net.UDPAddr
+	ln      net.Listener
-	chain  *chain.Chain
+	router  *chain.Router
-	ln     net.Listener
+	closed  chan struct{}
-	md     metadata
+	logger  logger.Logger
-	router *chain.Router
+	md      metadata
-	logger logger.Logger
+	options listener.Options
-	closed chan struct{}
 }
 
 func NewListener(opts ...listener.Option) listener.Listener {
-	options := &listener.Options{}
+	options := listener.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 	return &rudpListener{
-		addr:   options.Addr,
+		closed:  make(chan struct{}),
-		closed: make(chan struct{}),
+		logger:  options.Logger,
-		router: &chain.Router{
+		options: options,
-			Logger: options.Logger,
-		},
-		logger: options.Logger,
 	}
 }
 
-// implements chain.Chainable interface
-func (l *rudpListener) WithChain(chain *chain.Chain) {
-	l.router.Chain = chain
-}
-
 func (l *rudpListener) Init(md md.Metadata) (err error) {
 	if err = l.parseMetadata(md); err != nil {
 		return
 	}
 
-	laddr, err := net.ResolveUDPAddr("udp", l.addr)
+	laddr, err := net.ResolveUDPAddr("udp", l.options.Addr)
 	if err != nil {
 		return
 	}
 
 	l.laddr = laddr
+	l.router = &chain.Router{
+		Chain:  l.options.Chain,
+		Logger: l.logger,
+	}
 
 	return
 }

pkg/listener/tun/listener.go

@@ -15,22 +15,22 @@ func init() {
 }
 
 type tunListener struct {
-	saddr  string
+	addr    net.Addr
-	addr   net.Addr
+	cqueue  chan net.Conn
-	cqueue chan net.Conn
+	closed  chan struct{}
-	closed chan struct{}
+	logger  logger.Logger
-	logger logger.Logger
+	md      metadata
-	md     metadata
+	options listener.Options
 }
 
 func NewListener(opts ...listener.Option) listener.Listener {
-	options := &listener.Options{}
+	options := listener.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 	return &tunListener{
-		saddr:  options.Addr,
+		logger:  options.Logger,
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -39,7 +39,7 @@ func (l *tunListener) Init(md md.Metadata) (err error) {
 		return
 	}
 
-	l.addr, err = net.ResolveUDPAddr("udp", l.saddr)
+	l.addr, err = net.ResolveUDPAddr("udp", l.options.Addr)
 	if err != nil {
 		return
 	}

pkg/metadata/metadata.go

@@ -30,6 +30,10 @@ func (m MapMetadata) Get(key string) interface{} {
 	return nil
 }
 
+func (m MapMetadata) Del(key string) {
+	delete(m, key)
+}
+
 func GetBool(md Metadata, key string) (v bool) {
 	if md == nil || !md.IsExists(key) {
 		return