[dependencies] Update golangci/golangci-lint-action action to v7

Co-authored-by: anytls <anytls>

common/dialer/default.go

@@ -341,16 +341,6 @@ func (d *DefaultDialer) ListenSerialInterfacePacket(ctx context.Context, destina
 }
 
 func (d *DefaultDialer) ListenPacketCompat(network, address string) (net.PacketConn, error) {
-	udpListener := d.udpListener
-	udpListener.Control = control.Append(udpListener.Control, func(network, address string, conn syscall.RawConn) error {
-		for _, wgControlFn := range WgControlFns {
-			err := wgControlFn(network, address, conn)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
 	return d.udpListener.ListenPacket(context.Background(), network, address)
 }
 

dns/client.go

@@ -268,10 +268,13 @@ func (c *Client) Lookup(ctx context.Context, transport adapter.DNSTransport, dom
 		return nil
 	})
 	err := group.Run(ctx)
-	if len(response4) == 0 && len(response6) == 0 {
+	if len(response4) > 0 || len(response6) > 0 {
+		return sortAddresses(response4, response6, options.Strategy), nil
+	} else if err != nil {
 		return nil, err
+	} else {
+		return nil, RcodeError(dns.RcodeNameError)
 	}
-	return sortAddresses(response4, response6, options.Strategy), nil
 }
 
 func (c *Client) ClearCache() {

dns/router.go

@@ -323,9 +323,6 @@ func (r *Router) Lookup(ctx context.Context, domain string, options adapter.DNSQ
 		err           error
 	)
 	printResult := func() {
-		if err == nil && len(responseAddrs) == 0 {
-			err = E.New("empty result")
-		}
 		if err != nil {
 			if errors.Is(err, ErrResponseRejectedCached) {
 				r.logger.DebugContext(ctx, "response rejected for ", domain, " (cached)")
@@ -334,15 +331,14 @@ func (r *Router) Lookup(ctx context.Context, domain string, options adapter.DNSQ
 			} else {
 				r.logger.ErrorContext(ctx, E.Cause(err, "lookup failed for ", domain))
 			}
-		}
+		} else if len(responseAddrs) == 0 {
-		if err != nil {
+			panic("unexpected empty result")
-			err = E.Cause(err, "lookup ", domain)
 		}
 	}
 	responseAddrs, cached = r.client.LookupCache(domain, options.Strategy)
 	if cached {
 		if len(responseAddrs) == 0 {
-			return nil, E.New("lookup ", domain, ": empty result (cached)")
+			return nil, RcodeNameError
 		}
 		return responseAddrs, nil
 	}

dns/transport/local/local.go

@@ -3,7 +3,6 @@ package local
 import (
 	"context"
 	"math/rand"
-	"net/netip"
 	"time"
 
 	"github.com/sagernet/sing-box/adapter"
@@ -91,9 +90,8 @@ func (t *Transport) exchangeParallel(ctx context.Context, systemConfig *dnsConfi
 	startRacer := func(ctx context.Context, fqdn string) {
 		response, err := t.tryOneName(ctx, systemConfig, fqdn, message)
 		if err == nil {
-			var addresses []netip.Addr
+			addresses, _ := dns.MessageToAddresses(response)
-			addresses, err = dns.MessageToAddresses(response)
+			if len(addresses) == 0 {
-			if err == nil && len(addresses) == 0 {
 				err = E.New(fqdn, ": empty result")
 			}
 		}

experimental/clashapi/server.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"runtime"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -49,6 +50,7 @@ type Server struct {
 	httpServer     *http.Server
 	trafficManager *trafficontrol.Manager
 	urlTestHistory adapter.URLTestHistoryStorage
+	uiUpdateAccess sync.Mutex
 	logDebug       bool
 
 	mode           string

experimental/clashapi/server_resources.go

@@ -37,6 +37,8 @@ func (s *Server) checkAndDownloadExternalUI() {
 }
 
 func (s *Server) downloadExternalUI() error {
+	s.uiUpdateAccess.Lock()
+	defer s.uiUpdateAccess.Unlock()
 	var downloadURL string
 	if s.externalUIDownloadURL != "" {
 		downloadURL = s.externalUIDownloadURL

option/outbound.go

@@ -83,6 +83,7 @@ type DialerOptions struct {
 	NetworkType         badoption.Listable[InterfaceType] `json:"network_type,omitempty"`
 	FallbackNetworkType badoption.Listable[InterfaceType] `json:"fallback_network_type,omitempty"`
 	FallbackDelay       badoption.Duration                `json:"fallback_delay,omitempty"`
+	IsWireGuardListener bool                              `json:"-"`
 
 	// Deprecated: migrated to domain resolver
 	DomainStrategy DomainStrategy `json:"domain_strategy,omitempty"`

protocol/wireguard/endpoint.go

@@ -45,8 +45,8 @@ func NewEndpoint(ctx context.Context, router adapter.Router, logger log.ContextL
 		logger:         logger,
 		localAddresses: options.Address,
 	}
-	if options.Detour != "" && options.ListenPort != 0 {
+	if options.Detour == "" {
-		return nil, E.New("`listen_port` is conflict with `detour`")
+		options.IsWireGuardListener = true
 	}
 	outboundDialer, err := dialer.NewWithOptions(dialer.Options{
 		Context: ctx,

protocol/wireguard/outbound.go

@@ -46,7 +46,9 @@ func NewOutbound(ctx context.Context, router adapter.Router, logger log.ContextL
 		logger:         logger,
 		localAddresses: options.LocalAddress,
 	}
-	if options.Detour != "" && options.GSO {
+	if options.Detour == "" {
+		options.IsWireGuardListener = true
+	} else if options.GSO {
 		return nil, E.New("gso is conflict with detour")
 	}
 	outboundDialer, err := dialer.NewWithOptions(dialer.Options{

route/conn.go

@@ -7,7 +7,6 @@ import (
 	"net"
 	"net/netip"
 	"os"
-	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -67,17 +66,7 @@ func (m *ConnectionManager) NewConnection(ctx context.Context, this N.Dialer, co
 		remoteConn, err = this.DialContext(ctx, N.NetworkTCP, metadata.Destination)
 	}
 	if err != nil {
-		var remoteString string
+		err = E.Cause(err, "open outbound connection")
-		if len(metadata.DestinationAddresses) > 0 {
-			remoteString = "[" + strings.Join(common.Map(metadata.DestinationAddresses, netip.Addr.String), ",") + "]"
-		} else {
-			remoteString = metadata.Destination.String()
-		}
-		var dialerString string
-		if outbound, isOutbound := this.(adapter.Outbound); isOutbound {
-			dialerString = " using outbound/" + outbound.Type() + "[" + outbound.Tag() + "]"
-		}
-		err = E.Cause(err, "open connection to ", remoteString, dialerString)
 		N.CloseOnHandshakeFailure(conn, onClose, err)
 		m.logger.ErrorContext(ctx, err)
 		return
@@ -144,19 +133,8 @@ func (m *ConnectionManager) NewPacketConnection(ctx context.Context, this N.Dial
 			remoteConn, err = this.DialContext(ctx, N.NetworkUDP, metadata.Destination)
 		}
 		if err != nil {
-			var remoteString string
-			if len(metadata.DestinationAddresses) > 0 {
-				remoteString = "[" + strings.Join(common.Map(metadata.DestinationAddresses, netip.Addr.String), ",") + "]"
-			} else {
-				remoteString = metadata.Destination.String()
-			}
-			var dialerString string
-			if outbound, isOutbound := this.(adapter.Outbound); isOutbound {
-				dialerString = " using outbound/" + outbound.Type() + "[" + outbound.Tag() + "]"
-			}
-			err = E.Cause(err, "open packet connection to ", remoteString, dialerString)
 			N.CloseOnHandshakeFailure(conn, onClose, err)
-			m.logger.ErrorContext(ctx, err)
+			m.logger.ErrorContext(ctx, "open outbound packet connection: ", err)
 			return
 		}
 		remotePacketConn = bufio.NewUnbindPacketConn(remoteConn)
@@ -171,13 +149,8 @@ func (m *ConnectionManager) NewPacketConnection(ctx context.Context, this N.Dial
 			remotePacketConn, err = this.ListenPacket(ctx, metadata.Destination)
 		}
 		if err != nil {
-			var dialerString string
-			if outbound, isOutbound := this.(adapter.Outbound); isOutbound {
-				dialerString = " using outbound/" + outbound.Type() + "[" + outbound.Tag() + "]"
-			}
-			err = E.Cause(err, "listen packet connection using ", dialerString)
 			N.CloseOnHandshakeFailure(conn, onClose, err)
-			m.logger.ErrorContext(ctx, err)
+			m.logger.ErrorContext(ctx, "listen outbound packet connection: ", err)
 			return
 		}
 	}

transport/wireguard/endpoint.go

@@ -141,7 +141,7 @@ func (e *Endpoint) Start(resolve bool) error {
 		return nil
 	}
 	var bind conn.Bind
-	wgListener, isWgListener := common.Cast[conn.Listener](e.options.Dialer)
+	wgListener, isWgListener := e.options.Dialer.(conn.Listener)
 	if isWgListener {
 		bind = conn.NewStdNetBind(wgListener)
 	} else {