From 9475799615c667eb46fe6271fe0def0dd10e2419 Mon Sep 17 00:00:00 2001 From: Clash-Mini Date: Wed, 5 Jan 2022 00:33:42 +0800 Subject: [PATCH] make tun config compatible with premium --- Makefile | 23 +++++++-- config/config.go | 57 ++++++++++++--------- constant/metadata.go | 9 ++++ hub/executor/executor.go | 59 ++++++++++++---------- hub/route/rules.go | 2 +- listener/listener.go | 2 +- listener/tun/ipstack/gvisor/tun.go | 14 +++--- listener/tun/ipstack/gvisor/tundns.go | 72 ++++++++++++++------------- listener/tun/ipstack/stack_adapter.go | 2 +- listener/tun/ipstack/system/tun.go | 26 +++++----- tunnel/tunnel.go | 35 +++++++++---- 11 files changed, 180 insertions(+), 121 deletions(-) diff --git a/Makefile b/Makefile index c47bc1b1..f547164e 100644 --- a/Makefile +++ b/Makefile @@ -15,15 +15,27 @@ GOBUILDOP=CGO_ENABLED=0 go build -trimpath -ldflags '-X "github.com/Dreamacro/cl PLATFORM_LIST = \ darwin-amd64 \ darwin-arm64 \ - linux-arm64 \ linux-amd64 \ - linux-arm64-AutoIptables\ - linux-amd64-AutoIptables + linux-armv5 \ + linux-armv6 \ + linux-armv7 \ + linux-armv8 \ + linux-mips64 \ + linux-mips64le \ + linux-mips-softfloat \ + linux-mips-hardfloat \ + linux-mipsle-softfloat \ + linux-mipsle-hardfloat \ + freebsd-386 \ + freebsd-amd64 \ + freebsd-arm64 WINDOWS_ARCH_LIST = \ windows-386 \ - windows-amd64 + windows-amd64 \ + windows-arm64 \ + windows-arm32v7 all: linux-arm64-AutoIptables linux-amd64-AutoIptables linux-arm64 linux-amd64 darwin-amd64 darwin-arm64 windows-amd64 windows-386 # Most used @@ -109,6 +121,9 @@ windows-386: windows-amd64: GOARCH=amd64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe +windows-arm64: + GOARCH=arm64 GOOS=windows $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe + windows-arm32v7: GOARCH=arm GOOS=windows GOARM=7 $(GOBUILD) -o $(BINDIR)/$(NAME)-$@.exe diff --git a/config/config.go b/config/config.go index 92d5e0b0..f077dcf3 100644 --- a/config/config.go +++ b/config/config.go @@ -48,7 +48,6 @@ type Inbound struct { RedirPort int `json:"redir-port"` TProxyPort int `json:"tproxy-port"` MixedPort int `json:"mixed-port"` - Tun Tun `json:"tun"` Authentication []string `json:"authentication"` AllowLan bool `json:"allow-lan"` BindAddress string `json:"bind-address"` @@ -99,10 +98,11 @@ type Profile struct { // Tun config type Tun struct { - Enable bool `yaml:"enable" json:"enable"` - Stack string `yaml:"stack" json:"stack"` - DNSListen string `yaml:"dns-listen" json:"dns-listen"` - AutoRoute bool `yaml:"auto-route" json:"auto-route"` + Enable bool `yaml:"enable" json:"enable"` + Stack string `yaml:"stack" json:"stack"` + DnsHijack []string `yaml:"dns-hijack" json:"dns-hijack"` + AutoRoute bool `yaml:"auto-route" json:"auto-route"` + AutoDetectInterface bool `yaml:"auto-detect-interface" json:"auto-detect-interface"` } // Script config @@ -207,10 +207,11 @@ func UnmarshalRawConfig(buf []byte) (*RawConfig, error) { Proxy: []map[string]interface{}{}, ProxyGroup: []map[string]interface{}{}, Tun: Tun{ - Enable: false, - Stack: "gvisor", - DNSListen: "0.0.0.0:53", - AutoRoute: true, + Enable: false, + Stack: "gvisor", + DnsHijack: []string{"192.18.0.2:53"}, + AutoRoute: true, + AutoDetectInterface: true, }, DNS: RawDNS{ Enable: false, @@ -225,6 +226,17 @@ func UnmarshalRawConfig(buf []byte) (*RawConfig, error) { DefaultNameserver: []string{ "114.114.114.114", "223.5.5.5", + "8.8.8.8", + "1.0.0.1", + }, + NameServer: []string{ + "https://8.8.8.8/dns-query", + "https://1.0.0.1/dns-query", + }, + FakeIPFilter: []string{ + "dns.msftnsci.com", + "www.msftnsci.com", + "www.msftconnecttest.com", }, }, Profile: Profile{ @@ -254,7 +266,7 @@ func ParseRawConfig(rawCfg *RawConfig) (*Config, error) { return nil, err } config.General = general - //TODO 暂未使用 + config.Tun = &rawCfg.Tun proxies, providers, err := parseProxies(rawCfg) @@ -312,7 +324,6 @@ func parseGeneral(cfg *RawConfig) (*General, error) { RedirPort: cfg.RedirPort, TProxyPort: cfg.TProxyPort, MixedPort: cfg.MixedPort, - Tun: cfg.Tun, AllowLan: cfg.AllowLan, BindAddress: cfg.BindAddress, }, @@ -332,7 +343,7 @@ func parseGeneral(cfg *RawConfig) (*General, error) { func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[string]providerTypes.ProxyProvider, err error) { proxies = make(map[string]C.Proxy) providersMap = make(map[string]providerTypes.ProxyProvider) - proxyList := []string{} + var proxyList []string _proxiesList := list.New() _groupsList := list.New() proxiesConfig := cfg.Proxy @@ -421,7 +432,7 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[ } } - ps := []C.Proxy{} + var ps []C.Proxy for _, v := range proxyList { ps = append(ps, proxies[v]) } @@ -502,14 +513,14 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin R.SetRuleProvider(rp) } - for _, provider := range ruleProviders { - log.Infoln("Start initial provider %s", (*provider).Name()) - if err := (*provider).Initial(); err != nil { - return nil, nil, fmt.Errorf("initial rule provider %s error: %w", (*provider).Name(), err) + for _, ruleProvider := range ruleProviders { + log.Infoln("Start initial provider %s", (*ruleProvider).Name()) + if err := (*ruleProvider).Initial(); err != nil { + return nil, nil, fmt.Errorf("initial rule provider %s error: %w", (*ruleProvider).Name(), err) } } - rules := []C.Rule{} + var rules []C.Rule rulesConfig := cfg.Rule mode := cfg.Mode @@ -519,7 +530,7 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin var ( payload string target string - params = []string{} + params []string ruleName = strings.ToUpper(rule[0]) ) @@ -607,7 +618,7 @@ func hostWithDefaultPort(host string, defPort string) (string, error) { } func parseNameServer(servers []string) ([]dns.NameServer, error) { - nameservers := []dns.NameServer{} + var nameservers []dns.NameServer for idx, server := range servers { // parse without scheme .e.g 8.8.8.8:53 @@ -675,7 +686,7 @@ func parseNameServerPolicy(nsPolicy map[string]string) (map[string]dns.NameServe } func parseFallbackIPCIDR(ips []string) ([]*net.IPNet, error) { - ipNets := []*net.IPNet{} + var ipNets []*net.IPNet for idx, ip := range ips { _, ipnet, err := net.ParseCIDR(ip) @@ -689,7 +700,7 @@ func parseFallbackIPCIDR(ips []string) ([]*net.IPNet, error) { } func parseFallbackGeoSite(countries []string, rules []C.Rule) ([]*router.DomainMatcher, error) { - sites := []*router.DomainMatcher{} + var sites []*router.DomainMatcher for _, country := range countries { found := false @@ -784,7 +795,7 @@ func parseDNS(rawCfg *RawConfig, hosts *trie.DomainTrie, rules []C.Rule) (*DNS, if net.ParseIP(fb.Addr) != nil { continue } - host.Insert(fb.Addr, true) + _ = host.Insert(fb.Addr, true) } } diff --git a/constant/metadata.go b/constant/metadata.go index 8487fe5e..f14b93f3 100644 --- a/constant/metadata.go +++ b/constant/metadata.go @@ -2,6 +2,7 @@ package constant import ( "encoding/json" + "fmt" "net" "strconv" ) @@ -89,6 +90,14 @@ func (m *Metadata) SourceAddress() string { return net.JoinHostPort(m.SrcIP.String(), m.SrcPort) } +func (m *Metadata) SourceDetail() string { + if m.Process != "" { + return fmt.Sprintf("%s(%s)", m.SourceAddress(), m.Process) + } else { + return fmt.Sprintf("%s", m.SourceAddress()) + } +} + func (m *Metadata) Resolved() bool { return m.DstIP != nil } diff --git a/hub/executor/executor.go b/hub/executor/executor.go index bfe907e4..ae1892bd 100644 --- a/hub/executor/executor.go +++ b/hub/executor/executor.go @@ -78,9 +78,10 @@ func ApplyConfig(cfg *config.Config, force bool) { updateRules(cfg.Rules, cfg.RuleProviders) updateHosts(cfg.Hosts) updateProfile(cfg) - updateIPTables(cfg.DNS, cfg.General) - updateDNS(cfg.DNS, cfg.General) + updateIPTables(cfg.DNS, cfg.General, cfg.Tun) + updateDNS(cfg.DNS, cfg.Tun) updateGeneral(cfg.General, force) + updateTun(cfg.General, cfg.Tun) updateExperimental(cfg) } @@ -98,7 +99,6 @@ func GetGeneral() *config.General { RedirPort: ports.RedirPort, TProxyPort: ports.TProxyPort, MixedPort: ports.MixedPort, - Tun: P.Tun(), Authentication: authenticator, AllowLan: P.AllowLan(), BindAddress: P.BindAddress(), @@ -113,8 +113,8 @@ func GetGeneral() *config.General { func updateExperimental(c *config.Config) {} -func updateDNS(c *config.DNS, general *config.General) { - if !c.Enable && !general.Tun.Enable { +func updateDNS(c *config.DNS, Tun *config.Tun) { + if !c.Enable && !Tun.Enable { resolver.DefaultResolver = nil resolver.MainResolver = nil resolver.DefaultHostMapper = nil @@ -152,7 +152,7 @@ func updateDNS(c *config.DNS, general *config.General) { resolver.DefaultResolver = r resolver.MainResolver = mr resolver.DefaultHostMapper = m - if general.Tun.Enable && !strings.EqualFold(general.Tun.Stack, "gvisor") { + if Tun.Enable && !strings.EqualFold(Tun.Stack, "gVisor") { resolver.DefaultLocalServer = dns.NewLocalServer(r, m) } else { resolver.DefaultLocalServer = nil @@ -179,20 +179,6 @@ func updateGeneral(general *config.General, force bool) { tunnel.SetMode(general.Mode) resolver.DisableIPv6 = !general.IPv6 adapter.UnifiedDelay.Store(general.UnifiedDelay) - - if (general.Tun.Enable || general.TProxyPort != 0) && general.Interface == "" { - autoDetectInterfaceName, err := dev.GetAutoDetectInterface() - if err == nil { - if autoDetectInterfaceName != "" && autoDetectInterfaceName != "" { - general.Interface = autoDetectInterfaceName - } else { - log.Debugln("Auto detect interface name is empty.") - } - } else { - log.Debugln("Can not find auto detect interface. %s", err.Error()) - } - } - dialer.DefaultInterface.Store(general.Interface) log.Infoln("Use interface name: %s", general.Interface) @@ -219,12 +205,33 @@ func updateGeneral(general *config.General, force bool) { P.ReCreateTProxy(general.TProxyPort, tcpIn, udpIn) P.ReCreateMixed(general.MixedPort, tcpIn, udpIn) - if err := P.ReCreateTun(general.Tun, tcpIn, udpIn); err != nil { - log.Errorln("Start Tun interface error: %s", err.Error()) - os.Exit(2) + log.SetLevel(general.LogLevel) +} + +func updateTun(General *config.General, Tun *config.Tun) { + if Tun == nil { + return } - log.SetLevel(general.LogLevel) + if (Tun.Enable || General.TProxyPort != 0) && General.Interface == "" { + autoDetectInterfaceName, err := dev.GetAutoDetectInterface() + if err == nil { + if autoDetectInterfaceName != "" && autoDetectInterfaceName != "" { + General.Interface = autoDetectInterfaceName + } else { + log.Debugln("Auto detect interface name is empty.") + } + } else { + log.Debugln("Can not find auto detect interface. %s", err.Error()) + } + } + + tcpIn := tunnel.TCPIn() + udpIn := tunnel.UDPIn() + + if err := P.ReCreateTun(*Tun, tcpIn, udpIn); err != nil { + log.Errorln("Start Tun interface error: %s", err.Error()) + } } func updateUsers(users []auth.AuthUser) { @@ -270,9 +277,9 @@ func patchSelectGroup(proxies map[string]C.Proxy) { } } -func updateIPTables(dns *config.DNS, general *config.General) { +func updateIPTables(dns *config.DNS, general *config.General, tun *config.Tun) { AutoIptables := C.AutoIptables - if runtime.GOOS != "linux" || dns.Listen == "" || general.TProxyPort == 0 || general.Tun.Enable || AutoIptables != "Enable" { + if runtime.GOOS != "linux" || dns.Listen == "" || general.TProxyPort == 0 || tun.Enable || AutoIptables != "Enable" { return } diff --git a/hub/route/rules.go b/hub/route/rules.go index ea819b68..52615abc 100644 --- a/hub/route/rules.go +++ b/hub/route/rules.go @@ -23,7 +23,6 @@ type Rule struct { func getRules(w http.ResponseWriter, r *http.Request) { rawRules := tunnel.Rules() - rules := []Rule{} for _, rule := range rawRules { rules = append(rules, Rule{ @@ -31,6 +30,7 @@ func getRules(w http.ResponseWriter, r *http.Request) { Payload: rule.Payload(), Proxy: rule.Adapter(), }) + } render.JSON(w, r, render.M{ diff --git a/listener/listener.go b/listener/listener.go index 1961dd5b..11e02e27 100644 --- a/listener/listener.go +++ b/listener/listener.go @@ -71,7 +71,7 @@ func Tun() config.Tun { return config.Tun{ Enable: true, Stack: tunAdapter.Stack(), - DNSListen: tunAdapter.DNSListen(), + DnsHijack: tunAdapter.DnsHijack(), AutoRoute: tunAdapter.AutoRoute(), } } diff --git a/listener/tun/ipstack/gvisor/tun.go b/listener/tun/ipstack/gvisor/tun.go index 5e89969d..e550739d 100644 --- a/listener/tun/ipstack/gvisor/tun.go +++ b/listener/tun/ipstack/gvisor/tun.go @@ -34,10 +34,10 @@ import ( const nicID tcpip.NICID = 1 type gvisorAdapter struct { - device dev.TunDevice - ipstack *stack.Stack - dnsserver *DNSServer - udpIn chan<- *inbound.PacketAdapter + device dev.TunDevice + ipstack *stack.Stack + dnsServers []*DNSServer + udpIn chan<- *inbound.PacketAdapter stackName string autoRoute bool @@ -113,7 +113,7 @@ func NewAdapter(device dev.TunDevice, conf config.Tun, tcpIn chan<- C.ConnContex ipstack.SetTransportProtocolHandler(udp.ProtocolNumber, adapter.udpHandlePacket) if resolver.DefaultResolver != nil { - err = adapter.ReCreateDNSServer(resolver.DefaultResolver.(*dns.Resolver), resolver.DefaultHostMapper.(*dns.ResolverEnhancer), conf.DNSListen) + err = adapter.ReCreateDNSServer(resolver.DefaultResolver.(*dns.Resolver), resolver.DefaultHostMapper.(*dns.ResolverEnhancer), conf.DnsHijack) if err != nil { return nil, err } @@ -132,9 +132,7 @@ func (t *gvisorAdapter) AutoRoute() bool { // Close close the TunAdapter func (t *gvisorAdapter) Close() { - if t.dnsserver != nil { - t.dnsserver.Stop() - } + t.StopAllDNSServer() if t.ipstack != nil { t.ipstack.Close() } diff --git a/listener/tun/ipstack/gvisor/tundns.go b/listener/tun/ipstack/gvisor/tundns.go index 1bb9e766..5724aa70 100644 --- a/listener/tun/ipstack/gvisor/tundns.go +++ b/listener/tun/ipstack/gvisor/tundns.go @@ -241,51 +241,55 @@ func (s *DNSServer) Stop() { s.NICID) } -// DNSListen return the listening address of DNS Server -func (t *gvisorAdapter) DNSListen() string { - if t.dnsserver != nil { - id := t.dnsserver.udpEndpointID - return fmt.Sprintf("%s:%d", id.LocalAddress.String(), id.LocalPort) +// DnsHijack return the listening address of DNS Server +func (t *gvisorAdapter) DnsHijack() []string { + results := make([]string, len(t.dnsServers)) + for i, dnsServer := range t.dnsServers { + id := dnsServer.udpEndpointID + results[i] = fmt.Sprintf("%s:%d", id.LocalAddress.String(), id.LocalPort) } - return "" + + return results } -// Stop stop the DNS Server on tun -func (t *gvisorAdapter) ReCreateDNSServer(resolver *dns.Resolver, mapper *dns.ResolverEnhancer, addr string) error { - if addr == "" && t.dnsserver == nil { - return nil +func (t *gvisorAdapter) StopAllDNSServer() { + for _, dnsServer := range t.dnsServers { + dnsServer.Stop() } + log.Debugln("tun DNS server stoped") + t.dnsServers = nil +} - if addr == t.DNSListen() && t.dnsserver != nil && t.dnsserver.resolver == resolver { - return nil - } - - if t.dnsserver != nil { - t.dnsserver.Stop() - t.dnsserver = nil - log.Debugln("tun DNS server stoped") - } - - var err error - _, port, err := net.SplitHostPort(addr) - if port == "0" || port == "" || err != nil { - return nil - } +// ReCreateDNSServer recreate the DNS Server on tun +func (t *gvisorAdapter) ReCreateDNSServer(resolver *dns.Resolver, mapper *dns.ResolverEnhancer, addrs []string) error { + t.StopAllDNSServer() if resolver == nil { return fmt.Errorf("failed to create DNS server on tun: resolver not provided") } - udpAddr, err := net.ResolveUDPAddr("udp", addr) - if err != nil { - return err + if len(addrs) == 0 { + return fmt.Errorf("failed to create DNS server on tun: len(addrs) == 0") + } + for _, addr := range addrs { + var err error + _, port, err := net.SplitHostPort(addr) + if port == "0" || port == "" || err != nil { + return nil + } + + udpAddr, err := net.ResolveUDPAddr("udp", addr) + if err != nil { + return err + } + + server, err := CreateDNSServer(t.ipstack, resolver, mapper, udpAddr.IP, udpAddr.Port, nicID) + if err != nil { + return err + } + t.dnsServers = append(t.dnsServers, server) + log.Infoln("Tun DNS server listening at: %s, fake ip enabled: %v", addr, mapper.FakeIPEnabled()) } - server, err := CreateDNSServer(t.ipstack, resolver, mapper, udpAddr.IP, udpAddr.Port, nicID) - if err != nil { - return err - } - t.dnsserver = server - log.Infoln("Tun DNS server listening at: %s, fake ip enabled: %v", addr, mapper.FakeIPEnabled()) return nil } diff --git a/listener/tun/ipstack/stack_adapter.go b/listener/tun/ipstack/stack_adapter.go index 333c3ca5..1f4cc28f 100644 --- a/listener/tun/ipstack/stack_adapter.go +++ b/listener/tun/ipstack/stack_adapter.go @@ -4,6 +4,6 @@ package ipstack type TunAdapter interface { Close() Stack() string - DNSListen() string + DnsHijack() []string AutoRoute() bool } diff --git a/listener/tun/ipstack/system/tun.go b/listener/tun/ipstack/system/tun.go index fbfb8cb1..ede3f34a 100644 --- a/listener/tun/ipstack/system/tun.go +++ b/listener/tun/ipstack/system/tun.go @@ -17,26 +17,26 @@ import ( ) type systemAdapter struct { - device dev.TunDevice - tun *tun2socket.Tun2Socket - lock sync.Mutex - stackName string - dnsListen string - autoRoute bool + device dev.TunDevice + tun *tun2socket.Tun2Socket + lock sync.Mutex + stackName string + dnsHackjack []string + autoRoute bool } func NewAdapter(device dev.TunDevice, conf config.Tun, mtu int, gateway, mirror string, onStop func(), tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) (ipstack.TunAdapter, error) { adapter := &systemAdapter{ - device: device, - stackName: conf.Stack, - dnsListen: conf.DNSListen, - autoRoute: conf.AutoRoute, + device: device, + stackName: conf.Stack, + dnsHackjack: conf.DnsHijack, + autoRoute: conf.AutoRoute, } adapter.lock.Lock() defer adapter.lock.Unlock() - dnsHost, dnsPort, err := net.SplitHostPort(conf.DNSListen) + dnsHost, dnsPort, err := net.SplitHostPort(conf.DnsHijack[0]) if err != nil { return nil, err } @@ -91,8 +91,8 @@ func (t *systemAdapter) AutoRoute() bool { return t.autoRoute } -func (t *systemAdapter) DNSListen() string { - return t.dnsListen +func (t *systemAdapter) DnsHijack() []string { + return t.dnsHackjack } func (t *systemAdapter) Close() { diff --git a/tunnel/tunnel.go b/tunnel/tunnel.go index f99addc1..0f4b1206 100644 --- a/tunnel/tunnel.go +++ b/tunnel/tunnel.go @@ -242,17 +242,24 @@ func handleUDPConn(packet *inbound.PacketAdapter) { pCtx.InjectPacketConn(rawPc) pc := statistic.NewUDPTracker(rawPc, statistic.DefaultManager, metadata, rule) + var ruleDetail string + if rule.Payload() != "" { + ruleDetail = fmt.Sprintf("%s(%s)", rule.RuleType().String(), rule.Payload()) + } else { + ruleDetail = rule.RuleType().String() + } + switch true { case rule != nil: - log.Infoln("[UDP] %s(%s) --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), rawPc.Chains().String()) + log.Infoln("[UDP] %s --> %s match %s using %s", metadata.SourceDetail(), metadata.RemoteAddress(), ruleDetail, rawPc.Chains().String()) case mode == Script: - log.Infoln("[UDP] %s --> %s using SCRIPT %s", metadata.SourceAddress(), metadata.RemoteAddress(), rawPc.Chains().String()) + log.Infoln("[UDP] %s --> %s using SCRIPT %s", metadata.SourceDetail(), metadata.RemoteAddress(), rawPc.Chains().String()) case mode == Global: - log.Infoln("[UDP] %s(%s) --> %s using GLOBAL", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress()) + log.Infoln("[UDP] %s --> %s using GLOBAL", metadata.SourceDetail(), metadata.RemoteAddress()) case mode == Direct: - log.Infoln("[UDP] %s(%s) --> %s using DIRECT", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress()) + log.Infoln("[UDP] %s --> %s using DIRECT", metadata.SourceDetail(), metadata.RemoteAddress()) default: - log.Infoln("[UDP] %s(%s) --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress()) + log.Infoln("[UDP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceDetail(), metadata.RemoteAddress()) } go handleUDPToLocal(packet.UDPPacket, pc, key, fAddr) @@ -296,17 +303,25 @@ func handleTCPConn(connCtx C.ConnContext) { remoteConn = statistic.NewTCPTracker(remoteConn, statistic.DefaultManager, metadata, rule) defer remoteConn.Close() + var ruleDetail string + + if rule.Payload() != "" { + ruleDetail = fmt.Sprintf("%s(%s)", rule.RuleType().String(), rule.Payload()) + } else { + ruleDetail = rule.RuleType().String() + } + switch true { case rule != nil: - log.Infoln("[TCP] %s(%s) --> %s match %s(%s) using %s", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress(), rule.RuleType().String(), rule.Payload(), remoteConn.Chains().String()) + log.Infoln("[TCP] %s --> %s match %s using %s", metadata.SourceDetail(), metadata.RemoteAddress(), ruleDetail, remoteConn.Chains().String()) case mode == Script: - log.Infoln("[TCP] %s(%s) --> %s using SCRIPT %s", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress(), remoteConn.Chains().String()) + log.Infoln("[TCP] %s --> %s using SCRIPT %s", metadata.SourceDetail(), metadata.RemoteAddress(), remoteConn.Chains().String()) case mode == Global: - log.Infoln("[TCP] %s(%s) --> %s using GLOBAL", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress()) + log.Infoln("[TCP] %s --> %s using GLOBAL", metadata.SourceDetail(), metadata.RemoteAddress()) case mode == Direct: - log.Infoln("[TCP] %s(%s) --> %s using DIRECT", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress()) + log.Infoln("[TCP] %s --> %s using DIRECT", metadata.SourceDetail(), metadata.RemoteAddress()) default: - log.Infoln("[TCP] %s(%s) --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.Process, metadata.RemoteAddress()) + log.Infoln("[TCP] %s --> %s doesn't match any rule using DIRECT", metadata.SourceAddress(), metadata.RemoteAddress()) } handleSocket(connCtx, remoteConn)