lint

addr.go

@@ -26,8 +26,7 @@ func parseAddrFromIface(in net.Addr, ifcName string) (netip.Addr, int, NetworkTy
 	if err != nil {
 		return netip.Addr{}, 0, 0, err
 	}
-	switch in.(type) {
-	case *net.IPNet:
+	if _, ok := in.(*net.IPNet); ok {
 		// net.IPNet does not have a Zone but we provide it from the interface
 		addr = addrWithOptionalZone(addr, ifcName)
 	}
@@ -73,14 +72,30 @@ func parseAddr(in net.Addr) (netip.Addr, int, NetworkType, error) {
 		}
 		return ipAddr, addr.Port, nt, nil
 	default:
-		return netip.Addr{}, 0, 0, fmt.Errorf("do not know how to parse address type %T", in)
+		return netip.Addr{}, 0, 0, addrParseError{in}
 	}
 }
 
+type addrParseError struct {
+	addr net.Addr
+}
+
+func (e addrParseError) Error() string {
+	return fmt.Sprintf("do not know how to parse address type %T", e.addr)
+}
+
+type ipConvertError struct {
+	ip []byte
+}
+
+func (e ipConvertError) Error() string {
+	return fmt.Sprintf("failed to convert IP '%s' to netip.Addr", e.ip)
+}
+
 func ipAddrToNetIP(ip []byte, zone string) (netip.Addr, error) {
 	netIPAddr, ok := netip.AddrFromSlice(ip)
 	if !ok {
-		return netip.Addr{}, fmt.Errorf("failed to convert IP '%s' to netip.Addr", ip)
+		return netip.Addr{}, ipConvertError{ip}
 	}
 	// we'd rather have an IPv4-mapped IPv6 become IPv4 so that it is usable.
 	netIPAddr = netIPAddr.Unmap()

mdns.go

@@ -83,9 +83,8 @@ func createMulticastDNS(
 			// If ICE fails to start MulticastDNS server just warn the user and continue
 			log.Errorf("Failed to enable mDNS over IPv4: (%s)", mdns4Err)
 			return nil, MulticastDNSModeDisabled, nil
-		} else {
-			pktConnV4 = ipv4.NewPacketConn(l)
 		}
+		pktConnV4 = ipv4.NewPacketConn(l)
 	}
 
 	var pktConnV6 *ipv6.PacketConn
@@ -96,18 +95,16 @@ func createMulticastDNS(
 		if mdns6Err != nil {
 			log.Errorf("Failed to enable mDNS over IPv6: (%s)", mdns6Err)
 			return nil, MulticastDNSModeDisabled, nil
-		} else {
-			pktConnV6 = ipv6.NewPacketConn(l)
 		}
+		pktConnV6 = ipv6.NewPacketConn(l)
 	}
 
 	if mdns4Err != nil && mdns6Err != nil {
 		// If ICE fails to start MulticastDNS server just warn the user and continue
 		log.Errorf("Failed to enable mDNS, continuing in mDNS disabled mode")
+		//nolint:nilerr
 		return nil, MulticastDNSModeDisabled, nil
-
 	}
-
 	var ifcs []net.Interface
 	if interfaces != nil {
 		ifcs = make([]net.Interface, 0, len(ifcs))

mdns_test.go

@@ -31,7 +31,6 @@ func TestMulticastDNSOnlyConnection(t *testing.T) {
 		{Name: "UDP46", NetworkTypes: []NetworkType{NetworkTypeUDP4, NetworkTypeUDP6}},
 	} {
 		t.Run(tc.Name, func(t *testing.T) {
-
 			cfg := &AgentConfig{
 				NetworkTypes:     tc.NetworkTypes,
 				CandidateTypes:   []CandidateType{CandidateTypeHost},
@@ -76,7 +75,6 @@ func TestMulticastDNSMixedConnection(t *testing.T) {
 		{Name: "UDP46", NetworkTypes: []NetworkType{NetworkTypeUDP4, NetworkTypeUDP6}},
 	} {
 		t.Run(tc.Name, func(t *testing.T) {
-
 			aAgent, err := NewAgent(&AgentConfig{
 				NetworkTypes:     tc.NetworkTypes,
 				CandidateTypes:   []CandidateType{CandidateTypeHost},
@@ -123,7 +121,6 @@ func TestMulticastDNSStaticHostName(t *testing.T) {
 		{Name: "UDP46", NetworkTypes: []NetworkType{NetworkTypeUDP4, NetworkTypeUDP6}},
 	} {
 		t.Run(tc.Name, func(t *testing.T) {
-
 			_, err := NewAgent(&AgentConfig{
 				NetworkTypes:         tc.NetworkTypes,
 				CandidateTypes:       []CandidateType{CandidateTypeHost},

net.go

@@ -36,13 +36,14 @@ func isZeros(ip net.IP) bool {
 	return true
 }
 
+//nolint:gocognit
 func localInterfaces(
 	n transport.Net,
 	interfaceFilter func(string) bool,
 	ipFilter func(net.IP) bool,
 	networkTypes []NetworkType,
 	includeLoopback bool,
-) ([]*transport.Interface, []netip.Addr, error) { //nolint:gocognit
+) ([]*transport.Interface, []netip.Addr, error) {
 	ipAddrs := []netip.Addr{}
 	ifaces, err := n.Interfaces()
 	if err != nil {

tcp_mux.go

@@ -279,7 +279,6 @@ func (m *TCPMuxDefault) handleConn(conn net.Conn) {
 			m.params.Logger.Warnf("Failed to create packetConn for STUN message from %s to %s", conn.RemoteAddr(), conn.LocalAddr())
 			return
 		}
-	} else {
 	}
 	m.mu.Unlock()
 

tcp_mux_multi_test.go

@@ -7,7 +7,6 @@
 package ice
 
 import (
-	"fmt"
 	"io"
 	"net"
 	"net/netip"
@@ -132,7 +131,7 @@ func TestMultiTCPMux_NoDeadlockWhenClosingUnusedPacketConn(t *testing.T) {
 func mustAddr(ip net.IP) netip.Addr {
 	addr, ok := netip.AddrFromSlice(ip)
 	if !ok {
-		panic(fmt.Errorf("failed to convert ip '%s' to netip.Addr", ip))
+		panic(ipConvertError{ip})
 	}
 	return addr
 }

tcp_mux_test.go

@@ -62,7 +62,8 @@ func TestTCPMux_Recv(t *testing.T) {
 			n, err := writeStreamingPacket(conn, msg.Raw)
 			require.NoError(t, err, "error writing TCP STUN packet")
 
-			listenerAddr := listener.Addr().(*net.TCPAddr)
+			listenerAddr, ok := listener.Addr().(*net.TCPAddr)
+			require.True(t, ok)
 			ipAddr, err := ipAddrToNetIP(listenerAddr.IP, listenerAddr.Zone)
 			require.NoError(t, err, "error getting listener ipAddr")
 
@@ -115,7 +116,8 @@ func TestTCPMux_NoDeadlockWhenClosingUnusedPacketConn(t *testing.T) {
 		_ = tcpMux.Close()
 	}()
 
-	listenerAddr := listener.Addr().(*net.TCPAddr)
+	listenerAddr, ok := listener.Addr().(*net.TCPAddr)
+	require.True(t, ok)
 	ipAddr, err := ipAddrToNetIP(listenerAddr.IP, listenerAddr.Zone)
 	require.NoError(t, err, "error getting listener ipAddr")
 
@@ -239,7 +241,8 @@ func TestTCPMux_NoLeakForConnectionFromStun(t *testing.T) {
 		// wait for the connection to be created
 		time.Sleep(100 * time.Millisecond)
 
-		listenerAddr := listener.Addr().(*net.TCPAddr)
+		listenerAddr, ok := listener.Addr().(*net.TCPAddr)
+		require.True(t, ok)
 		ipAddr, err := ipAddrToNetIP(listenerAddr.IP, listenerAddr.Zone)
 		require.NoError(t, err, "error getting listener ipAddr")
 

transport_test.go

@@ -178,7 +178,7 @@ func gatherAndExchangeCandidates(aAgent, bAgent *Agent) {
 	check(err)
 
 	for _, c := range candidates {
-		if addr, err := netip.ParseAddr(c.Address()); err == nil {
+		if addr, parseErr := netip.ParseAddr(c.Address()); parseErr == nil {
 			if shouldFilterLocationTrackedIP(addr) {
 				panic(addr)
 			}

udp_mux_test.go

@@ -61,11 +61,11 @@ func TestUDPMux(t *testing.T) {
 	if ipv6Available(t) {
 		addr6 := getLocalIPAddress(t, NetworkTypeUDP6)
 
-		conn6Unspecified, err := net.ListenUDP(udp, &net.UDPAddr{
+		conn6Unspecified, listenEerr := net.ListenUDP(udp, &net.UDPAddr{
 			IP:   addr6.AsSlice(),
 			Zone: addr6.Zone(),
 		})
-		if err != nil {
+		if listenEerr != nil {
 			t.Log("IPv6 is not supported on this machine")
 		}