Inbound rule support

adapter/inbound.go

@@ -1,8 +1,6 @@
 package adapter
 
 import (
-	"net/netip"
-
 	M "github.com/sagernet/sing/common/metadata"
 )
 
@@ -13,10 +11,10 @@ type Inbound interface {
 }
 
 type InboundContext struct {
-	Source      netip.AddrPort
-	Destination M.Socksaddr
 	Inbound     string
 	Network     string
-	Protocol    string
+	Source      M.Socksaddr
+	Destination M.Socksaddr
 	Domain      string
+	Protocol    string
 }

adapter/inbound/builder.go

@@ -0,0 +1,35 @@
+package inbound
+
+import (
+	"context"
+
+	"github.com/sagernet/sing-box/adapter"
+	C "github.com/sagernet/sing-box/constant"
+	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
+	F "github.com/sagernet/sing/common/format"
+)
+
+func New(ctx context.Context, router adapter.Router, logger log.Logger, index int, options option.Inbound) (adapter.Inbound, error) {
+	var tag string
+	if options.Tag != "" {
+		tag = options.Tag
+	} else {
+		tag = F.ToString(index)
+	}
+	inboundLogger := logger.WithPrefix(F.ToString("inbound/", options.Type, "[", tag, "]: "))
+	switch options.Type {
+	case C.TypeDirect:
+		return NewDirect(ctx, router, inboundLogger, options.Tag, options.DirectOptions), nil
+	case C.TypeSocks:
+		return NewSocks(ctx, router, inboundLogger, options.Tag, options.SocksOptions), nil
+	case C.TypeHTTP:
+		return NewHTTP(ctx, router, inboundLogger, options.Tag, options.HTTPOptions), nil
+	case C.TypeMixed:
+		return NewMixed(ctx, router, inboundLogger, options.Tag, options.MixedOptions), nil
+	case C.TypeShadowsocks:
+		return NewShadowsocks(ctx, router, inboundLogger, options.Tag, options.ShadowsocksOptions)
+	default:
+		panic(F.ToString("unknown inbound type: ", options.Type))
+	}
+}

adapter/inbound/default.go

@@ -10,9 +10,9 @@ import (
 
 	"github.com/database64128/tfo-go"
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common"
 	"github.com/sagernet/sing/common/buf"
 	E "github.com/sagernet/sing/common/exceptions"
@@ -29,7 +29,7 @@ type myInboundAdapter struct {
 	router         adapter.Router
 	logger         log.Logger
 	tag            string
-	listenOptions  config.ListenOptions
+	listenOptions  option.ListenOptions
 	connHandler    adapter.ConnectionHandler
 	packetHandler  adapter.PacketHandler
 	packetUpstream any
@@ -101,7 +101,7 @@ func (a *myInboundAdapter) Close() error {
 }
 
 func (a *myInboundAdapter) upstreamHandler(metadata adapter.InboundContext) adapter.UpstreamHandlerAdapter {
-	return adapter.NewUpstreamHandler(metadata, a.newConnection, a.newPacketConnection, a)
+	return adapter.NewUpstreamHandler(metadata, a.newConnection, a.streamPacketConnection, a)
 }
 
 func (a *myInboundAdapter) upstreamContextHandler() adapter.UpstreamHandlerAdapter {
@@ -113,7 +113,14 @@ func (a *myInboundAdapter) newConnection(ctx context.Context, conn net.Conn, met
 	return a.router.RouteConnection(ctx, conn, metadata)
 }
 
+func (a *myInboundAdapter) streamPacketConnection(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext) error {
+	a.logger.WithContext(ctx).Info("inbound packet connection to ", metadata.Destination)
+	return a.router.RoutePacketConnection(ctx, conn, metadata)
+}
+
 func (a *myInboundAdapter) newPacketConnection(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext) error {
+	ctx = log.ContextWithID(ctx)
+	a.logger.WithContext(ctx).Info("inbound packet connection from ", metadata.Source)
 	a.logger.WithContext(ctx).Info("inbound packet connection to ", metadata.Destination)
 	return a.router.RoutePacketConnection(ctx, conn, metadata)
 }
@@ -125,16 +132,16 @@ func (a *myInboundAdapter) loopTCPIn() {
 		if err != nil {
 			return
 		}
-		var metadata adapter.InboundContext
-		metadata.Inbound = a.tag
-		metadata.Source = M.AddrPortFromNet(conn.RemoteAddr())
 		go func() {
-			metadata.Network = "tcp"
 			ctx := log.ContextWithID(a.ctx)
-			a.logger.WithContext(ctx).Info("inbound connection from ", conn.RemoteAddr())
+			var metadata adapter.InboundContext
+			metadata.Inbound = a.tag
+			metadata.Network = "tcp"
+			metadata.Source = M.SocksaddrFromNet(conn.RemoteAddr())
+			a.logger.WithContext(ctx).Info("inbound connection from ", metadata.Source)
 			hErr := a.connHandler.NewConnection(ctx, conn, metadata)
 			if hErr != nil {
-				a.NewError(ctx, E.Cause(hErr, "process connection from ", conn.RemoteAddr()))
+				a.NewError(ctx, E.Cause(hErr, "process connection from ", metadata.Source))
 			}
 		}()
 	}
@@ -149,9 +156,6 @@ func (a *myInboundAdapter) loopUDPIn() {
 	buffer.IncRef()
 	defer buffer.DecRef()
 	packetService := (*myInboundPacketAdapter)(a)
-	var metadata adapter.InboundContext
-	metadata.Inbound = a.tag
-	metadata.Network = "udp"
 	for {
 		buffer.Reset()
 		n, addr, err := a.udpConn.ReadFromUDPAddrPort(buffer.FreeBytes())
@@ -159,10 +163,13 @@ func (a *myInboundAdapter) loopUDPIn() {
 			return
 		}
 		buffer.Truncate(n)
-		metadata.Source = addr
+		var metadata adapter.InboundContext
+		metadata.Inbound = a.tag
+		metadata.Network = "udp"
+		metadata.Source = M.SocksaddrFromNetIP(addr)
 		err = a.packetHandler.NewPacket(a.ctx, packetService, buffer, metadata)
 		if err != nil {
-			a.newError(E.Cause(err, "process packet from ", addr))
+			a.newError(E.Cause(err, "process packet from ", metadata.Source))
 		}
 	}
 }
@@ -170,9 +177,6 @@ func (a *myInboundAdapter) loopUDPIn() {
 func (a *myInboundAdapter) loopUDPInThreadSafe() {
 	defer close(a.packetOutboundClosed)
 	packetService := (*myInboundPacketAdapter)(a)
-	var metadata adapter.InboundContext
-	metadata.Inbound = a.tag
-	metadata.Network = "udp"
 	for {
 		buffer := buf.NewPacket()
 		n, addr, err := a.udpConn.ReadFromUDPAddrPort(buffer.FreeBytes())
@@ -180,11 +184,14 @@ func (a *myInboundAdapter) loopUDPInThreadSafe() {
 			return
 		}
 		buffer.Truncate(n)
-		metadata.Source = addr
+		var metadata adapter.InboundContext
+		metadata.Inbound = a.tag
+		metadata.Network = "udp"
+		metadata.Source = M.SocksaddrFromNetIP(addr)
 		err = a.packetHandler.NewPacket(a.ctx, packetService, buffer, metadata)
 		if err != nil {
 			buffer.Release()
-			a.newError(E.Cause(err, "process packet from ", addr))
+			a.newError(E.Cause(err, "process packet from ", metadata.Source))
 		}
 	}
 }
@@ -212,7 +219,7 @@ func (a *myInboundAdapter) loopUDPOut() {
 }
 
 func (a *myInboundAdapter) newError(err error) {
-	a.logger.Warn(err)
+	a.logger.Error(err)
 }
 
 func (a *myInboundAdapter) NewError(ctx context.Context, err error) {

adapter/inbound/direct.go

@@ -6,9 +6,9 @@ import (
 	"net/netip"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common/buf"
 	M "github.com/sagernet/sing/common/metadata"
 	N "github.com/sagernet/sing/common/network"
@@ -24,7 +24,7 @@ type Direct struct {
 	overrideDestination M.Socksaddr
 }
 
-func NewDirect(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *config.DirectInboundOptions) *Direct {
+func NewDirect(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *option.DirectInboundOptions) *Direct {
 	inbound := &Direct{
 		myInboundAdapter: myInboundAdapter{
 			protocol:      C.TypeDirect,
@@ -54,13 +54,13 @@ func NewDirect(ctx context.Context, router adapter.Router, logger log.Logger, ta
 
 func (d *Direct) NewConnection(ctx context.Context, conn net.Conn, metadata adapter.InboundContext) error {
 	switch d.overrideOption {
-	case 0:
-		metadata.Destination = d.overrideDestination
 	case 1:
+		metadata.Destination = d.overrideDestination
+	case 2:
 		destination := d.overrideDestination
 		destination.Port = metadata.Destination.Port
 		metadata.Destination = destination
-	case 2:
+	case 3:
 		metadata.Destination.Port = d.overrideDestination.Port
 	}
 	d.logger.WithContext(ctx).Info("inbound connection to ", metadata.Destination)
@@ -69,18 +69,18 @@ func (d *Direct) NewConnection(ctx context.Context, conn net.Conn, metadata adap
 
 func (d *Direct) NewPacket(ctx context.Context, conn N.PacketConn, buffer *buf.Buffer, metadata adapter.InboundContext) error {
 	switch d.overrideOption {
-	case 0:
-		metadata.Destination = d.overrideDestination
 	case 1:
+		metadata.Destination = d.overrideDestination
+	case 2:
 		destination := d.overrideDestination
 		destination.Port = metadata.Destination.Port
 		metadata.Destination = destination
-	case 2:
+	case 3:
 		metadata.Destination.Port = d.overrideDestination.Port
 	}
 	var upstreamMetadata M.Metadata
-	upstreamMetadata.Source = M.SocksaddrFromNetIP(metadata.Source)
+	upstreamMetadata.Source = metadata.Source
 	upstreamMetadata.Destination = metadata.Destination
-	d.udpNat.NewPacketDirect(&adapter.MetadataContext{Context: ctx, Metadata: metadata}, metadata.Source, conn, buffer, upstreamMetadata)
+	d.udpNat.NewPacketDirect(&adapter.MetadataContext{Context: log.ContextWithID(ctx), Metadata: metadata}, metadata.Source.AddrPort(), conn, buffer, upstreamMetadata)
 	return nil
 }

adapter/inbound/http.go

@@ -6,9 +6,9 @@ import (
 	"net"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common/auth"
 	M "github.com/sagernet/sing/common/metadata"
 	"github.com/sagernet/sing/protocol/http"
@@ -21,7 +21,7 @@ type HTTP struct {
 	authenticator auth.Authenticator
 }
 
-func NewHTTP(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *config.SimpleInboundOptions) *HTTP {
+func NewHTTP(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *option.SimpleInboundOptions) *HTTP {
 	inbound := &HTTP{
 		myInboundAdapter{
 			protocol:      C.TypeHTTP,

adapter/inbound/mixed.go

@@ -6,9 +6,9 @@ import (
 	"net"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common/auth"
 	"github.com/sagernet/sing/common/buf"
 	"github.com/sagernet/sing/common/bufio"
@@ -27,7 +27,7 @@ type Mixed struct {
 	authenticator auth.Authenticator
 }
 
-func NewMixed(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *config.SimpleInboundOptions) *Mixed {
+func NewMixed(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *option.SimpleInboundOptions) *Mixed {
 	inbound := &Mixed{
 		myInboundAdapter{
 			protocol:      C.TypeMixed,

adapter/inbound/shadowsocks.go

@@ -5,9 +5,9 @@ import (
 	"net"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing-shadowsocks"
 	"github.com/sagernet/sing-shadowsocks/shadowaead"
 	"github.com/sagernet/sing-shadowsocks/shadowaead_2022"
@@ -25,7 +25,7 @@ type Shadowsocks struct {
 	service shadowsocks.Service
 }
 
-func NewShadowsocks(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *config.ShadowsocksInboundOptions) (*Shadowsocks, error) {
+func NewShadowsocks(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *option.ShadowsocksInboundOptions) (*Shadowsocks, error) {
 	inbound := &Shadowsocks{
 		myInboundAdapter: myInboundAdapter{
 			protocol:      C.TypeShadowsocks,
@@ -39,7 +39,6 @@ func NewShadowsocks(ctx context.Context, router adapter.Router, logger log.Logge
 	}
 	inbound.connHandler = inbound
 	inbound.packetHandler = inbound
-	inbound.packetUpstream = true
 	var udpTimeout int64
 	if options.UDPTimeout != 0 {
 		udpTimeout = options.UDPTimeout
@@ -57,17 +56,19 @@ func NewShadowsocks(ctx context.Context, router adapter.Router, logger log.Logge
 	default:
 		err = E.New("shadowsocks: unsupported method: ", options.Method)
 	}
+	inbound.packetUpstream = inbound.service
 	return inbound, err
 }
 
 func (h *Shadowsocks) NewConnection(ctx context.Context, conn net.Conn, metadata adapter.InboundContext) error {
 	return h.service.NewConnection(&adapter.MetadataContext{Context: ctx, Metadata: metadata}, conn, M.Metadata{
-		Source: M.SocksaddrFromNetIP(metadata.Source),
+		Source: metadata.Source,
 	})
 }
 
 func (h *Shadowsocks) NewPacket(ctx context.Context, conn N.PacketConn, buffer *buf.Buffer, metadata adapter.InboundContext) error {
+	h.logger.Trace("inbound packet from ", metadata.Source)
 	return h.service.NewPacket(&adapter.MetadataContext{Context: ctx, Metadata: metadata}, conn, buffer, M.Metadata{
-		Source: M.SocksaddrFromNetIP(metadata.Source),
+		Source: metadata.Source,
 	})
 }

adapter/inbound/socks.go

@@ -5,9 +5,9 @@ import (
 	"net"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common/auth"
 	M "github.com/sagernet/sing/common/metadata"
 	"github.com/sagernet/sing/protocol/socks"
@@ -20,7 +20,7 @@ type Socks struct {
 	authenticator auth.Authenticator
 }
 
-func NewSocks(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *config.SimpleInboundOptions) *Socks {
+func NewSocks(ctx context.Context, router adapter.Router, logger log.Logger, tag string, options *option.SimpleInboundOptions) *Socks {
 	inbound := &Socks{
 		myInboundAdapter{
 			protocol:      C.TypeSocks,

adapter/outbound/builder.go

@@ -0,0 +1,27 @@
+package outbound
+
+import (
+	"github.com/sagernet/sing-box/adapter"
+	C "github.com/sagernet/sing-box/constant"
+	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
+	F "github.com/sagernet/sing/common/format"
+)
+
+func New(router adapter.Router, logger log.Logger, index int, options option.Outbound) (adapter.Outbound, error) {
+	var tag string
+	if options.Tag != "" {
+		tag = options.Tag
+	} else {
+		tag = F.ToString(index)
+	}
+	outboundLogger := logger.WithPrefix(F.ToString("outbound/", options.Type, "[", tag, "]: "))
+	switch options.Type {
+	case C.TypeDirect:
+		return NewDirect(router, outboundLogger, options.Tag, options.DirectOptions), nil
+	case C.TypeShadowsocks:
+		return NewShadowsocks(router, outboundLogger, options.Tag, options.ShadowsocksOptions)
+	default:
+		panic(F.ToString("unknown outbound type: ", options.Type))
+	}
+}

adapter/outbound/default.go

@@ -9,8 +9,8 @@ import (
 
 	"github.com/database64128/tfo-go"
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common"
 	"github.com/sagernet/sing/common/buf"
 	"github.com/sagernet/sing/common/bufio"
@@ -48,7 +48,7 @@ func (d *defaultDialer) ListenPacket(ctx context.Context) (net.PacketConn, error
 	return d.ListenConfig.ListenPacket(ctx, "udp", "")
 }
 
-func newDialer(options config.DialerOptions) N.Dialer {
+func newDialer(options option.DialerOptions) N.Dialer {
 	var dialer net.Dialer
 	var listener net.ListenConfig
 	if options.BindInterface != "" {
@@ -70,13 +70,13 @@ func newDialer(options config.DialerOptions) N.Dialer {
 
 type lazyDialer struct {
 	router   adapter.Router
-	options  config.DialerOptions
+	options  option.DialerOptions
 	dialer   N.Dialer
 	initOnce sync.Once
 	initErr  error
 }
 
-func NewDialer(router adapter.Router, options config.DialerOptions) N.Dialer {
+func NewDialer(router adapter.Router, options option.DialerOptions) N.Dialer {
 	if options.Detour == "" {
 		return newDialer(options)
 	}

adapter/outbound/direct.go

@@ -5,9 +5,9 @@ import (
 	"net"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common/bufio"
 	M "github.com/sagernet/sing/common/metadata"
 	N "github.com/sagernet/sing/common/network"
@@ -21,7 +21,7 @@ type Direct struct {
 	overrideDestination M.Socksaddr
 }
 
-func NewDirect(router adapter.Router, logger log.Logger, tag string, options *config.DirectOutboundOptions) *Direct {
+func NewDirect(router adapter.Router, logger log.Logger, tag string, options *option.DirectOutboundOptions) *Direct {
 	outbound := &Direct{
 		myOutboundAdapter: myOutboundAdapter{
 			protocol: C.TypeDirect,
@@ -45,26 +45,26 @@ func NewDirect(router adapter.Router, logger log.Logger, tag string, options *co
 
 func (d *Direct) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
 	switch d.overrideOption {
-	case 0:
-		destination = d.overrideDestination
 	case 1:
+		destination = d.overrideDestination
+	case 2:
 		newDestination := d.overrideDestination
 		newDestination.Port = destination.Port
 		destination = newDestination
-	case 2:
+	case 3:
 		destination.Port = d.overrideDestination.Port
 	}
 	switch network {
 	case C.NetworkTCP:
-		d.logger.WithContext(ctx).Debug("outbound connection to ", destination)
+		d.logger.WithContext(ctx).Info("outbound connection to ", destination)
 	case C.NetworkUDP:
-		d.logger.WithContext(ctx).Debug("outbound packet connection to ", destination)
+		d.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
 	}
 	return d.dialer.DialContext(ctx, network, destination)
 }
 
 func (d *Direct) ListenPacket(ctx context.Context) (net.PacketConn, error) {
-	d.logger.WithContext(ctx).Debug("outbound packet connection")
+	d.logger.WithContext(ctx).Info("outbound packet connection")
 	return d.dialer.ListenPacket(ctx)
 }
 

adapter/outbound/shadowsocks.go

@@ -5,9 +5,9 @@ import (
 	"net"
 
 	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/config"
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing-shadowsocks"
 	"github.com/sagernet/sing-shadowsocks/shadowimpl"
 	"github.com/sagernet/sing/common/bufio"
@@ -24,7 +24,7 @@ type Shadowsocks struct {
 	serverAddr M.Socksaddr
 }
 
-func NewShadowsocks(router adapter.Router, logger log.Logger, tag string, options *config.ShadowsocksOutboundOptions) (*Shadowsocks, error) {
+func NewShadowsocks(router adapter.Router, logger log.Logger, tag string, options *option.ShadowsocksOutboundOptions) (*Shadowsocks, error) {
 	outbound := &Shadowsocks{
 		myOutboundAdapter: myOutboundAdapter{
 			protocol: C.TypeDirect,
@@ -66,14 +66,14 @@ func (o *Shadowsocks) NewPacketConnection(ctx context.Context, conn N.PacketConn
 func (o *Shadowsocks) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
 	switch network {
 	case C.NetworkTCP:
-		o.logger.WithContext(ctx).Debug("outbound connection to ", destination)
+		o.logger.WithContext(ctx).Info("outbound connection to ", destination)
 		outConn, err := o.dialer.DialContext(ctx, "tcp", o.serverAddr)
 		if err != nil {
 			return nil, err
 		}
 		return o.method.DialEarlyConn(outConn, destination), nil
 	case C.NetworkUDP:
-		o.logger.WithContext(ctx).Debug("outbound packet connection to ", destination)
+		o.logger.WithContext(ctx).Info("outbound packet connection to ", destination)
 		outConn, err := o.dialer.DialContext(ctx, "udp", o.serverAddr)
 		if err != nil {
 			return nil, err
@@ -85,7 +85,7 @@ func (o *Shadowsocks) DialContext(ctx context.Context, network string, destinati
 }
 
 func (o *Shadowsocks) ListenPacket(ctx context.Context) (net.PacketConn, error) {
-	o.logger.WithContext(ctx).Debug("outbound packet connection to ", o.serverAddr)
+	o.logger.WithContext(ctx).Info("outbound packet connection to ", o.serverAddr)
 	outConn, err := o.dialer.ListenPacket(ctx)
 	if err != nil {
 		return nil, err

adapter/route/router.go

@@ -4,8 +4,12 @@ import (
 	"context"
 	"net"
 
+	"github.com/oschwald/geoip2-golang"
 	"github.com/sagernet/sing-box/adapter"
+	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/option"
+	"github.com/sagernet/sing/common"
 	N "github.com/sagernet/sing/common/network"
 )
 
@@ -15,24 +19,18 @@ type Router struct {
 	logger          log.Logger
 	defaultOutbound adapter.Outbound
 	outboundByTag   map[string]adapter.Outbound
+
+	rules     []adapter.Rule
+	geoReader *geoip2.Reader
 }
 
 func NewRouter(logger log.Logger) *Router {
 	return &Router{
-		logger:        logger,
+		logger:        logger.WithPrefix("router: "),
 		outboundByTag: make(map[string]adapter.Outbound),
 	}
 }
 
-func (r *Router) AddOutbound(outbound adapter.Outbound) {
-	if outbound.Tag() != "" {
-		r.outboundByTag[outbound.Tag()] = outbound
-	}
-	if r.defaultOutbound == nil {
-		r.defaultOutbound = outbound
-	}
-}
-
 func (r *Router) DefaultOutbound() adapter.Outbound {
 	if r.defaultOutbound == nil {
 		panic("missing default outbound")
@@ -46,13 +44,60 @@ func (r *Router) Outbound(tag string) (adapter.Outbound, bool) {
 }
 
 func (r *Router) RouteConnection(ctx context.Context, conn net.Conn, metadata adapter.InboundContext) error {
-	r.logger.WithContext(ctx).Debug("no match")
-	r.logger.WithContext(ctx).Debug("route connection to default outbound")
+	for _, rule := range r.rules {
+		if rule.Match(metadata) {
+			r.logger.WithContext(ctx).Info("match ", rule.String())
+			if outbound, loaded := r.Outbound(rule.Outbound()); loaded {
+				return outbound.NewConnection(ctx, conn, metadata.Destination)
+			}
+			r.logger.WithContext(ctx).Error("outbound ", rule.Outbound(), " not found")
+		}
+	}
+	r.logger.WithContext(ctx).Info("no match => ", r.defaultOutbound.Tag())
 	return r.defaultOutbound.NewConnection(ctx, conn, metadata.Destination)
 }
 
 func (r *Router) RoutePacketConnection(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext) error {
-	r.logger.WithContext(ctx).Debug("no match")
-	r.logger.WithContext(ctx).Debug("route packet connection to default outbound")
+	for _, rule := range r.rules {
+		if rule.Match(metadata) {
+			r.logger.WithContext(ctx).Info("match ", rule.String())
+			if outbound, loaded := r.Outbound(rule.Outbound()); loaded {
+				return outbound.NewPacketConnection(ctx, conn, metadata.Destination)
+			}
+			r.logger.WithContext(ctx).Error("outbound ", rule.Outbound(), " not found")
+		}
+	}
+	r.logger.WithContext(ctx).Info("no match => ", r.defaultOutbound.Tag())
 	return r.defaultOutbound.NewPacketConnection(ctx, conn, metadata.Destination)
 }
+
+func (r *Router) Close() error {
+	return common.Close(
+		common.PtrOrNil(r.geoReader),
+	)
+}
+
+func (r *Router) UpdateOutbounds(outbounds []adapter.Outbound) {
+	var defaultOutbound adapter.Outbound
+	outboundByTag := make(map[string]adapter.Outbound)
+	if len(outbounds) > 0 {
+		defaultOutbound = outbounds[0]
+	}
+	for _, outbound := range outbounds {
+		outboundByTag[outbound.Tag()] = outbound
+	}
+	r.defaultOutbound = defaultOutbound
+	r.outboundByTag = outboundByTag
+}
+
+func (r *Router) UpdateRules(options []option.Rule) error {
+	rules := make([]adapter.Rule, 0, len(options))
+	for i, rule := range options {
+		switch rule.Type {
+		case "", C.RuleTypeDefault:
+			rules = append(rules, NewDefaultRule(i, rule.DefaultOptions))
+		}
+	}
+	r.rules = rules
+	return nil
+}

adapter/route/rule.go

@@ -0,0 +1,55 @@
+package route
+
+import (
+	"github.com/sagernet/sing-box/adapter"
+	"github.com/sagernet/sing-box/option"
+	F "github.com/sagernet/sing/common/format"
+)
+
+var _ adapter.Rule = (*DefaultRule)(nil)
+
+type DefaultRule struct {
+	index    int
+	outbound string
+	items    []RuleItem
+}
+
+type RuleItem interface {
+	Match(metadata adapter.InboundContext) bool
+	String() string
+}
+
+func NewDefaultRule(index int, options option.DefaultRule) *DefaultRule {
+	rule := &DefaultRule{
+		index:    index,
+		outbound: options.Outbound,
+	}
+	if len(options.Inbound) > 0 {
+		rule.items = append(rule.items, NewInboundRule(options.Inbound))
+	}
+	return rule
+}
+
+func (r *DefaultRule) Match(metadata adapter.InboundContext) bool {
+	for _, item := range r.items {
+		if item.Match(metadata) {
+			return true
+		}
+	}
+	return false
+}
+
+func (r *DefaultRule) Outbound() string {
+	return r.outbound
+}
+
+func (r *DefaultRule) String() string {
+	var description string
+	description = F.ToString("[", r.index, "]")
+	for _, item := range r.items {
+		description += " "
+		description += item.String()
+	}
+	description += " => " + r.outbound
+	return description
+}

adapter/route/rule_inbound.go

@@ -0,0 +1,35 @@
+package route
+
+import (
+	"strings"
+
+	"github.com/sagernet/sing-box/adapter"
+	F "github.com/sagernet/sing/common/format"
+)
+
+var _ RuleItem = (*InboundRule)(nil)
+
+type InboundRule struct {
+	inbounds   []string
+	inboundMap map[string]bool
+}
+
+func NewInboundRule(inbounds []string) RuleItem {
+	rule := &InboundRule{inbounds, make(map[string]bool)}
+	for _, inbound := range inbounds {
+		rule.inboundMap[inbound] = true
+	}
+	return rule
+}
+
+func (r *InboundRule) Match(metadata adapter.InboundContext) bool {
+	return r.inboundMap[metadata.Inbound]
+}
+
+func (r *InboundRule) String() string {
+	if len(r.inbounds) == 1 {
+		return F.ToString("inbound=", r.inbounds[0])
+	} else {
+		return F.ToString("inbound=[", strings.Join(r.inbounds, " "), "]")
+	}
+}

adapter/router.go

@@ -12,4 +12,11 @@ type Router interface {
 	Outbound(tag string) (Outbound, bool)
 	RouteConnection(ctx context.Context, conn net.Conn, metadata InboundContext) error
 	RoutePacketConnection(ctx context.Context, conn N.PacketConn, metadata InboundContext) error
+	Close() error
+}
+
+type Rule interface {
+	Match(metadata InboundContext) bool
+	Outbound() string
+	String() string
 }