From f8f81a47b6648a3f1bf347da479eeedebe7b8196 Mon Sep 17 00:00:00 2001 From: Eric Daniels Date: Tue, 26 Mar 2024 10:55:12 -0400 Subject: [PATCH] lint --- addr.go | 23 +++++++++++++++++++---- mdns.go | 9 +++------ mdns_test.go | 3 --- net.go | 3 ++- tcp_mux.go | 1 - tcp_mux_multi_test.go | 3 +-- tcp_mux_test.go | 9 ++++++--- transport_test.go | 2 +- udp_mux_test.go | 4 ++-- 9 files changed, 34 insertions(+), 23 deletions(-) diff --git a/addr.go b/addr.go index 18e3b877..fb40061d 100644 --- a/addr.go +++ b/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() diff --git a/mdns.go b/mdns.go index 1308d2a7..2c10a327 100644 --- a/mdns.go +++ b/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)) diff --git a/mdns_test.go b/mdns_test.go index 04fdf916..4405c72f 100644 --- a/mdns_test.go +++ b/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}, diff --git a/net.go b/net.go index 7261a1d9..6e740a70 100644 --- a/net.go +++ b/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 { diff --git a/tcp_mux.go b/tcp_mux.go index 1501557f..a24344a9 100644 --- a/tcp_mux.go +++ b/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() diff --git a/tcp_mux_multi_test.go b/tcp_mux_multi_test.go index 038f09ec..f8355a67 100644 --- a/tcp_mux_multi_test.go +++ b/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 } diff --git a/tcp_mux_test.go b/tcp_mux_test.go index 77d5a3f0..c5262864 100644 --- a/tcp_mux_test.go +++ b/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") diff --git a/transport_test.go b/transport_test.go index fe648855..c7907a17 100644 --- a/transport_test.go +++ b/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) } diff --git a/udp_mux_test.go b/udp_mux_test.go index bc8d36b0..8b64f651 100644 --- a/udp_mux_test.go +++ b/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") }