From c40f8e36517d0c5ffef5fb37af4eb667c76def47 Mon Sep 17 00:00:00 2001 From: Bruno Dal Bo Date: Wed, 19 Oct 2022 18:26:36 -0700 Subject: [PATCH] Rename ErrNoRoute to ErrHostUnreachable ErrNoRoute gets translated to EHOSTUNREACH which causes some code paths to produce different errors unexpectedly. Rename the error so we can clean up some sites to return ENETUNREACH more clearly where needed. Updates #8105 PiperOrigin-RevId: 482355099 --- pkg/sentry/socket/netlink/route/protocol.go | 2 +- pkg/syserr/netstack.go | 4 +- pkg/syserr/syserr.go | 2 +- pkg/tcpip/adapters/gonet/gonet_test.go | 6 +-- pkg/tcpip/errors.go | 12 ++--- pkg/tcpip/link/muxed/injectable.go | 4 +- pkg/tcpip/link/rawfile/errors.go | 2 +- pkg/tcpip/network/internal/ip/errors.go | 8 ++-- pkg/tcpip/network/ipv4/ipv4.go | 16 ++++--- pkg/tcpip/network/ipv4/ipv4_test.go | 4 +- pkg/tcpip/network/ipv6/ipv6.go | 16 ++++--- pkg/tcpip/stack/ndp_test.go | 12 ++--- pkg/tcpip/stack/stack.go | 9 ++-- pkg/tcpip/stack/stack_test.go | 48 +++++++++---------- pkg/tcpip/stack/transport_test.go | 4 +- .../tests/integration/link_resolution_test.go | 8 ++-- .../integration/multicast_forward_test.go | 4 +- pkg/tcpip/tests/integration/route_test.go | 10 ++-- pkg/tcpip/transport/datagram_test.go | 14 +++--- pkg/tcpip/transport/icmp/endpoint.go | 2 +- .../transport/internal/network/endpoint.go | 6 +-- pkg/tcpip/transport/raw/endpoint.go | 2 +- pkg/tcpip/transport/tcp/endpoint.go | 4 +- .../transport/tcp/test/e2e/dual_stack_test.go | 2 +- pkg/tcpip/transport/tcp/test/e2e/tcp_test.go | 4 +- .../transport/testing/context/context.go | 2 +- pkg/tcpip/transport/udp/endpoint.go | 2 +- pkg/tcpip/transport/udp/udp_test.go | 2 +- 28 files changed, 109 insertions(+), 102 deletions(-) diff --git a/pkg/sentry/socket/netlink/route/protocol.go b/pkg/sentry/socket/netlink/route/protocol.go index d526acb73..7195a46f4 100644 --- a/pkg/sentry/socket/netlink/route/protocol.go +++ b/pkg/sentry/socket/netlink/route/protocol.go @@ -335,7 +335,7 @@ func fillRoute(routes []inet.Route, addr []byte) (inet.Route, *syserr.Error) { idx = idxDef } if idx == -1 { - return inet.Route{}, syserr.ErrNoRoute + return inet.Route{}, syserr.ErrHostUnreachable } route := routes[idx] diff --git a/pkg/syserr/netstack.go b/pkg/syserr/netstack.go index ab5d9e4dd..6f1797045 100644 --- a/pkg/syserr/netstack.go +++ b/pkg/syserr/netstack.go @@ -74,8 +74,8 @@ func TranslateNetstackError(err tcpip.Error) *Error { return ErrDuplicateNICID case *tcpip.ErrDuplicateAddress: return ErrDuplicateAddress - case *tcpip.ErrNoRoute: - return ErrNoRoute + case *tcpip.ErrHostUnreachable: + return ErrHostUnreachable case *tcpip.ErrAlreadyBound: return ErrAlreadyBound case *tcpip.ErrInvalidEndpointState: diff --git a/pkg/syserr/syserr.go b/pkg/syserr/syserr.go index ca50f1239..3657f5c35 100644 --- a/pkg/syserr/syserr.go +++ b/pkg/syserr/syserr.go @@ -210,7 +210,7 @@ var ( ErrTimedOut = newWithHost("connection timed out", errno.ETIMEDOUT, unix.ETIMEDOUT) ErrConnectionRefused = newWithHost("connection refused", errno.ECONNREFUSED, unix.ECONNREFUSED) ErrHostDown = newWithHost("host is down", errno.EHOSTDOWN, unix.EHOSTDOWN) - ErrNoRoute = newWithHost("no route to host", errno.EHOSTUNREACH, unix.EHOSTUNREACH) + ErrHostUnreachable = newWithHost("no route to host", errno.EHOSTUNREACH, unix.EHOSTUNREACH) ErrAlreadyInProgress = newWithHost("operation already in progress", errno.EALREADY, unix.EALREADY) ErrInProgress = newWithHost("operation now in progress", errno.EINPROGRESS, unix.EINPROGRESS) ErrStaleFileHandle = newWithHost("stale file handle", errno.ESTALE, unix.ESTALE) diff --git a/pkg/tcpip/adapters/gonet/gonet_test.go b/pkg/tcpip/adapters/gonet/gonet_test.go index e48bea4f9..ea2297117 100644 --- a/pkg/tcpip/adapters/gonet/gonet_test.go +++ b/pkg/tcpip/adapters/gonet/gonet_test.go @@ -737,11 +737,11 @@ func TestTCPDialError(t *testing.T) { switch _, err := DialTCP(s, addr, ipv4.ProtocolNumber); err := err.(type) { case *net.OpError: - if err.Err.Error() != (&tcpip.ErrNoRoute{}).String() { - t.Errorf("got DialTCP() = %s, want = %s", err, &tcpip.ErrNoRoute{}) + if err.Err.Error() != (&tcpip.ErrHostUnreachable{}).String() { + t.Errorf("got DialTCP() = %s, want = %s", err, &tcpip.ErrHostUnreachable{}) } default: - t.Errorf("got DialTCP(...) = %v, want %s", err, &tcpip.ErrNoRoute{}) + t.Errorf("got DialTCP(...) = %v, want %s", err, &tcpip.ErrHostUnreachable{}) } } diff --git a/pkg/tcpip/errors.go b/pkg/tcpip/errors.go index 2eb822822..ff0a7be4f 100644 --- a/pkg/tcpip/errors.go +++ b/pkg/tcpip/errors.go @@ -380,19 +380,19 @@ func (*ErrNoPortAvailable) IgnoreStats() bool { } func (*ErrNoPortAvailable) String() string { return "no ports are available" } -// ErrNoRoute indicates the operation is not able to find a route to the -// destination. +// ErrHostUnreachable indicates that a destination host could not be +// reached. // // +stateify savable -type ErrNoRoute struct{} +type ErrHostUnreachable struct{} -func (*ErrNoRoute) isError() {} +func (*ErrHostUnreachable) isError() {} // IgnoreStats implements Error. -func (*ErrNoRoute) IgnoreStats() bool { +func (*ErrHostUnreachable) IgnoreStats() bool { return false } -func (*ErrNoRoute) String() string { return "no route" } +func (*ErrHostUnreachable) String() string { return "no route to host" } // ErrNoSuchFile is used to indicate that ENOENT should be returned the to // calling application. diff --git a/pkg/tcpip/link/muxed/injectable.go b/pkg/tcpip/link/muxed/injectable.go index 0a6981ebb..5c421d0b5 100644 --- a/pkg/tcpip/link/muxed/injectable.go +++ b/pkg/tcpip/link/muxed/injectable.go @@ -93,7 +93,7 @@ func (m *InjectableEndpoint) WritePackets(pkts stack.PacketBufferList) (int, tcp for _, pkt := range pkts.AsSlice() { endpoint, ok := m.routes[pkt.EgressRoute.RemoteAddress] if !ok { - return i, &tcpip.ErrNoRoute{} + return i, &tcpip.ErrHostUnreachable{} } var tmpPkts stack.PacketBufferList @@ -115,7 +115,7 @@ func (m *InjectableEndpoint) WritePackets(pkts stack.PacketBufferList) (int, tcp func (m *InjectableEndpoint) InjectOutbound(dest tcpip.Address, packet *bufferv2.View) tcpip.Error { endpoint, ok := m.routes[dest] if !ok { - return &tcpip.ErrNoRoute{} + return &tcpip.ErrHostUnreachable{} } return endpoint.InjectOutbound(dest, packet) } diff --git a/pkg/tcpip/link/rawfile/errors.go b/pkg/tcpip/link/rawfile/errors.go index 7e21a78d4..e21b4bf28 100644 --- a/pkg/tcpip/link/rawfile/errors.go +++ b/pkg/tcpip/link/rawfile/errors.go @@ -34,7 +34,7 @@ func TranslateErrno(e unix.Errno) tcpip.Error { case unix.EEXIST: return &tcpip.ErrDuplicateAddress{} case unix.ENETUNREACH: - return &tcpip.ErrNoRoute{} + return &tcpip.ErrHostUnreachable{} case unix.EINVAL: return &tcpip.ErrInvalidEndpointState{} case unix.EALREADY: diff --git a/pkg/tcpip/network/internal/ip/errors.go b/pkg/tcpip/network/internal/ip/errors.go index 62f111750..5ff59fd59 100644 --- a/pkg/tcpip/network/internal/ip/errors.go +++ b/pkg/tcpip/network/internal/ip/errors.go @@ -58,12 +58,12 @@ func (*ErrLinkLocalDestinationAddress) isForwardingError() {} func (*ErrLinkLocalDestinationAddress) String() string { return "link local destination address" } -// ErrNoRoute indicates that a route for the received packet couldn't be found. -type ErrNoRoute struct{} +// ErrHostUnreachable indicates that the destinatino host could not be reached. +type ErrHostUnreachable struct{} -func (*ErrNoRoute) isForwardingError() {} +func (*ErrHostUnreachable) isForwardingError() {} -func (*ErrNoRoute) String() string { return "no route" } +func (*ErrHostUnreachable) String() string { return "no route to host" } // ErrMessageTooLong indicates the packet was too big for the outgoing MTU. // diff --git a/pkg/tcpip/network/ipv4/ipv4.go b/pkg/tcpip/network/ipv4/ipv4.go index c9c77fe26..447f44414 100644 --- a/pkg/tcpip/network/ipv4/ipv4.go +++ b/pkg/tcpip/network/ipv4/ipv4.go @@ -744,12 +744,14 @@ func (e *endpoint) forwardUnicastPacket(pkt stack.PacketBufferPtr) ip.Forwarding r, err := stk.FindRoute(0, "", dstAddr, ProtocolNumber, false /* multicastLoop */) switch err.(type) { case nil: - case *tcpip.ErrNoRoute, *tcpip.ErrNetworkUnreachable: + // TODO(https://gvisor.dev/issues/8105): We should not observe ErrHostUnreachable from route + // lookups. + case *tcpip.ErrHostUnreachable, *tcpip.ErrNetworkUnreachable: // We return the original error rather than the result of returning // the ICMP packet because the original error is more relevant to // the caller. _ = e.protocol.returnError(&icmpReasonNetworkUnreachable{}, pkt, false /* deliveredLocally */) - return &ip.ErrNoRoute{} + return &ip.ErrHostUnreachable{} default: return &ip.ErrOther{Err: err} } @@ -918,7 +920,7 @@ func (e *endpoint) forwardMulticastPacket(h header.IPv4, pkt stack.PacketBufferP default: panic(fmt.Sprintf("unexpected GetRouteResultState: %s", result.GetRouteResultState)) } - return &ip.ErrNoRoute{} + return &ip.ErrHostUnreachable{} } func (e *endpoint) updateOptionsForForwarding(pkt stack.PacketBufferPtr) ip.ForwardingError { @@ -1009,7 +1011,7 @@ func (e *endpoint) forwardMulticastPacketForOutgoingInterface(pkt stack.PacketBu if route == nil { // Failed to convert to a stack.Route. This likely means that the outgoing // endpoint no longer exists. - return &ip.ErrNoRoute{} + return &ip.ErrHostUnreachable{} } defer route.Release() @@ -1105,7 +1107,7 @@ func (e *endpoint) handleForwardingError(err ip.ForwardingError) { stats.Forwarding.LinkLocalDestination.Increment() case *ip.ErrTTLExceeded: stats.Forwarding.ExhaustedTTL.Increment() - case *ip.ErrNoRoute: + case *ip.ErrHostUnreachable: stats.Forwarding.Unrouteable.Increment() case *ip.ErrParameterProblem: stats.MalformedPacketsReceived.Increment() @@ -1583,7 +1585,7 @@ func (p *protocol) RemoveMulticastRoute(addresses stack.UnicastSourceAndMulticas } if removed := p.multicastRouteTable.RemoveInstalledRoute(addresses); !removed { - return &tcpip.ErrNoRoute{} + return &tcpip.ErrHostUnreachable{} } return nil @@ -1627,7 +1629,7 @@ func (p *protocol) MulticastRouteLastUsedTime(addresses stack.UnicastSourceAndMu timestamp, found := p.multicastRouteTable.GetLastUsedTimestamp(addresses) if !found { - return tcpip.MonotonicTime{}, &tcpip.ErrNoRoute{} + return tcpip.MonotonicTime{}, &tcpip.ErrHostUnreachable{} } return timestamp, nil diff --git a/pkg/tcpip/network/ipv4/ipv4_test.go b/pkg/tcpip/network/ipv4/ipv4_test.go index 5fb4f0677..26183e01a 100644 --- a/pkg/tcpip/network/ipv4/ipv4_test.go +++ b/pkg/tcpip/network/ipv4/ipv4_test.go @@ -118,8 +118,8 @@ func TestExcludeBroadcast(t *testing.T) { // Cannot connect using a broadcast address as the source. { err := ep.Connect(randomAddr) - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Errorf("got ep.Connect(...) = %v, want = %v", err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Errorf("got ep.Connect(...) = %v, want = %v", err, &tcpip.ErrHostUnreachable{}) } } diff --git a/pkg/tcpip/network/ipv6/ipv6.go b/pkg/tcpip/network/ipv6/ipv6.go index 190e28835..943d1e1c1 100644 --- a/pkg/tcpip/network/ipv6/ipv6.go +++ b/pkg/tcpip/network/ipv6/ipv6.go @@ -968,11 +968,13 @@ func (e *endpoint) forwardUnicastPacket(pkt stack.PacketBufferPtr) ip.Forwarding r, err := stk.FindRoute(0, "", dstAddr, ProtocolNumber, false /* multicastLoop */) switch err.(type) { case nil: - case *tcpip.ErrNoRoute, *tcpip.ErrNetworkUnreachable: + // TODO(https://gvisor.dev/issues/8105): We should not observe ErrHostUnreachable from route + // lookups. + case *tcpip.ErrHostUnreachable, *tcpip.ErrNetworkUnreachable: // We return the original error rather than the result of returning the // ICMP packet because the original error is more relevant to the caller. _ = e.protocol.returnError(&icmpReasonNetUnreachable{}, pkt, false /* deliveredLocally */) - return &ip.ErrNoRoute{} + return &ip.ErrHostUnreachable{} default: return &ip.ErrOther{Err: err} } @@ -1151,7 +1153,7 @@ func (e *endpoint) forwardMulticastPacket(h header.IPv6, pkt stack.PacketBufferP default: panic(fmt.Sprintf("unexpected GetRouteResultState: %s", result.GetRouteResultState)) } - return &ip.ErrNoRoute{} + return &ip.ErrHostUnreachable{} } // forwardValidatedMulticastPacket attempts to forward the pkt using the @@ -1211,7 +1213,7 @@ func (e *endpoint) forwardMulticastPacketForOutgoingInterface(pkt stack.PacketBu if route == nil { // Failed to convert to a stack.Route. This likely means that the outgoing // endpoint no longer exists. - return &ip.ErrNoRoute{} + return &ip.ErrHostUnreachable{} } defer route.Release() return e.forwardPacketWithRoute(route, pkt) @@ -1230,7 +1232,7 @@ func (e *endpoint) handleForwardingError(err ip.ForwardingError) { stats.Forwarding.LinkLocalDestination.Increment() case *ip.ErrTTLExceeded: stats.Forwarding.ExhaustedTTL.Increment() - case *ip.ErrNoRoute: + case *ip.ErrHostUnreachable: stats.Forwarding.Unrouteable.Increment() case *ip.ErrParameterProblem: stats.Forwarding.ExtensionHeaderProblem.Increment() @@ -2460,7 +2462,7 @@ func (p *protocol) RemoveMulticastRoute(addresses stack.UnicastSourceAndMulticas } if removed := p.multicastRouteTable.RemoveInstalledRoute(addresses); !removed { - return &tcpip.ErrNoRoute{} + return &tcpip.ErrHostUnreachable{} } return nil @@ -2476,7 +2478,7 @@ func (p *protocol) MulticastRouteLastUsedTime(addresses stack.UnicastSourceAndMu timestamp, found := p.multicastRouteTable.GetLastUsedTimestamp(addresses) if !found { - return tcpip.MonotonicTime{}, &tcpip.ErrNoRoute{} + return tcpip.MonotonicTime{}, &tcpip.ErrHostUnreachable{} } return timestamp, nil diff --git a/pkg/tcpip/stack/ndp_test.go b/pkg/tcpip/stack/ndp_test.go index 82fdb4246..cc06d5649 100644 --- a/pkg/tcpip/stack/ndp_test.go +++ b/pkg/tcpip/stack/ndp_test.go @@ -626,8 +626,8 @@ func TestDADResolve(t *testing.T) { // tentative address. { r, err := s.FindRoute(nicID, "", addr2, header.IPv6ProtocolNumber, false) - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Errorf("got FindRoute(%d, '', %s, %d, false) = (%+v, %v), want = (_, %s)", nicID, addr2, header.IPv6ProtocolNumber, r, err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Errorf("got FindRoute(%d, '', %s, %d, false) = (%+v, %v), want = (_, %s)", nicID, addr2, header.IPv6ProtocolNumber, r, err, &tcpip.ErrHostUnreachable{}) } if r != nil { r.Release() @@ -635,8 +635,8 @@ func TestDADResolve(t *testing.T) { } { r, err := s.FindRoute(nicID, addr1, addr2, header.IPv6ProtocolNumber, false) - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Errorf("got FindRoute(%d, %s, %s, %d, false) = (%+v, %v), want = (_, %s)", nicID, addr1, addr2, header.IPv6ProtocolNumber, r, err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Errorf("got FindRoute(%d, %s, %s, %d, false) = (%+v, %v), want = (_, %s)", nicID, addr1, addr2, header.IPv6ProtocolNumber, r, err, &tcpip.ErrHostUnreachable{}) } if r != nil { r.Release() @@ -3813,8 +3813,8 @@ func TestAutoGenAddrJobDeprecation(t *testing.T) { { err := ep.Connect(dstAddr) - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Errorf("got ep.Connect(%+v) = %s, want = %s", dstAddr, err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Errorf("got ep.Connect(%+v) = %s, want = %s", dstAddr, err, &tcpip.ErrHostUnreachable{}) } } } diff --git a/pkg/tcpip/stack/stack.go b/pkg/tcpip/stack/stack.go index 5b444a47e..7d2f80883 100644 --- a/pkg/tcpip/stack/stack.go +++ b/pkg/tcpip/stack/stack.go @@ -306,7 +306,7 @@ func (t *TransportEndpointInfo) AddrNetProtoLocked(addr tcpip.FullAddress, v6onl case netProto == t.NetProto: case netProto == header.IPv4ProtocolNumber && t.NetProto == header.IPv6ProtocolNumber: if v6only { - return tcpip.FullAddress{}, 0, &tcpip.ErrNoRoute{} + return tcpip.FullAddress{}, 0, &tcpip.ErrHostUnreachable{} } default: return tcpip.FullAddress{}, 0, &tcpip.ErrInvalidEndpointState{} @@ -1384,7 +1384,8 @@ func (s *Stack) FindRoute(id tcpip.NICID, localAddr, remoteAddr tcpip.Address, n } } - return nil, &tcpip.ErrNoRoute{} + // TODO(https://gvisor.dev/issues/8105): This should be ErrNetworkUnreachable. + return nil, &tcpip.ErrHostUnreachable{} } if id == 0 { @@ -1404,11 +1405,13 @@ func (s *Stack) FindRoute(id tcpip.NICID, localAddr, remoteAddr tcpip.Address, n } if needRoute { - return nil, &tcpip.ErrNoRoute{} + // TODO(https://gvisor.dev/issues/8105): This should be ErrNetworkUnreachable. + return nil, &tcpip.ErrHostUnreachable{} } if header.IsV6LoopbackAddress(remoteAddr) { return nil, &tcpip.ErrBadLocalAddress{} } + // TODO(https://gvisor.dev/issues/8105): This should be ErrNetworkUnreachable. return nil, &tcpip.ErrNetworkUnreachable{} } diff --git a/pkg/tcpip/stack/stack_test.go b/pkg/tcpip/stack/stack_test.go index 42dcd8506..2733fb68c 100644 --- a/pkg/tcpip/stack/stack_test.go +++ b/pkg/tcpip/stack/stack_test.go @@ -849,8 +849,8 @@ func testRoute(t *testing.T, s *stack.Stack, nic tcpip.NICID, srcAddr, dstAddr, func testNoRoute(t *testing.T, s *stack.Stack, nic tcpip.NICID, srcAddr, dstAddr tcpip.Address) { _, err := s.FindRoute(nic, srcAddr, dstAddr, fakeNetNumber, false /* multicastLoop */) - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Fatalf("FindRoute returned unexpected error, got = %v, want = %s", err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Fatalf("FindRoute returned unexpected error, got = %v, want = %s", err, &tcpip.ErrHostUnreachable{}) } } @@ -1378,7 +1378,7 @@ func TestAddressRemoval(t *testing.T) { t.Fatal("RemoveAddress failed:", err) } testFailingRecv(t, fakeNet, localAddrByte, ep, buf) - testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrHostUnreachable{}) // Check that removing the same address fails. err := s.RemoveAddress(1, localAddr) @@ -1438,7 +1438,7 @@ func TestAddressRemovalWithRouteHeld(t *testing.T) { } testFailingRecv(t, fakeNet, localAddrByte, ep, buf) testFailingSend(t, r, nil, &tcpip.ErrInvalidEndpointState{}) - testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrHostUnreachable{}) // Check that removing the same address fails. { @@ -1539,7 +1539,7 @@ func TestEndpointExpiration(t *testing.T) { // FIXME(b/139841518):Spoofing doesn't work if there is no primary address. // testSendTo(t, s, remoteAddr, ep, nil) } else { - testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrHostUnreachable{}) } // 2. Add Address, everything should work. @@ -1574,7 +1574,7 @@ func TestEndpointExpiration(t *testing.T) { // FIXME(b/139841518):Spoofing doesn't work if there is no primary address. // testSendTo(t, s, remoteAddr, ep, nil) } else { - testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrHostUnreachable{}) } // 4. Add Address back, everything should work again. @@ -1614,7 +1614,7 @@ func TestEndpointExpiration(t *testing.T) { testSendTo(t, s, remoteAddr, ep, nil) } else { testFailingSend(t, r, nil, &tcpip.ErrInvalidEndpointState{}) - testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrHostUnreachable{}) } // 7. Add Address back, everything should work again. @@ -1650,7 +1650,7 @@ func TestEndpointExpiration(t *testing.T) { // FIXME(b/139841518):Spoofing doesn't work if there is no primary address. // testSendTo(t, s, remoteAddr, ep, nil) } else { - testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, remoteAddr, nil, &tcpip.ErrHostUnreachable{}) } }) } @@ -1693,8 +1693,8 @@ func TestPromiscuousMode(t *testing.T) { // Check that we can't get a route as there is no local address. _, err := s.FindRoute(0, "", "\x02", fakeNetNumber, false /* multicastLoop */) - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Fatalf("FindRoute returned unexpected error: got = %v, want = %s", err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Fatalf("FindRoute returned unexpected error: got = %v, want = %s", err, &tcpip.ErrHostUnreachable{}) } // Set promiscuous mode to false, then check that packet can't be @@ -1914,7 +1914,7 @@ func TestSpoofingNoAddress(t *testing.T) { t.Errorf("FindRoute succeeded with route %+v when it should have failed", r) } // Sending a packet fails. - testFailingSendTo(t, s, dstAddr, nil, &tcpip.ErrNoRoute{}) + testFailingSendTo(t, s, dstAddr, nil, &tcpip.ErrHostUnreachable{}) // With address spoofing enabled, FindRoute permits any address to be used // as the source. @@ -2123,7 +2123,7 @@ func TestMulticastOrIPv6LinkLocalNeedsNoRoute(t *testing.T) { var want tcpip.Error = &tcpip.ErrNetworkUnreachable{} if tc.routeNeeded { - want = &tcpip.ErrNoRoute{} + want = &tcpip.ErrHostUnreachable{} } // If there is no endpoint, it won't work. @@ -2144,8 +2144,8 @@ func TestMulticastOrIPv6LinkLocalNeedsNoRoute(t *testing.T) { if r, err := s.FindRoute(1, anyAddr, tc.address, fakeNetNumber, false /* multicastLoop */); tc.routeNeeded { // Route table is empty but we need a route, this should cause an error. - if _, ok := err.(*tcpip.ErrNoRoute); !ok { - t.Fatalf("got FindRoute(1, %v, %v, %v) = %v, want = %v", anyAddr, tc.address, fakeNetNumber, err, &tcpip.ErrNoRoute{}) + if _, ok := err.(*tcpip.ErrHostUnreachable); !ok { + t.Fatalf("got FindRoute(1, %v, %v, %v) = %v, want = %v", anyAddr, tc.address, fakeNetNumber, err, &tcpip.ErrHostUnreachable{}) } } else { if err != nil { @@ -4521,7 +4521,7 @@ func TestFindRouteWithForwarding(t *testing.T) { forwardingEnabled: false, addrNIC: nicID1, localAddrWithPrefix: fakeNetCfg.nic2AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4530,7 +4530,7 @@ func TestFindRouteWithForwarding(t *testing.T) { forwardingEnabled: true, addrNIC: nicID1, localAddrWithPrefix: fakeNetCfg.nic2AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4539,7 +4539,7 @@ func TestFindRouteWithForwarding(t *testing.T) { forwardingEnabled: false, addrNIC: nicID1, localAddrWithPrefix: fakeNetCfg.nic1AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4575,7 +4575,7 @@ func TestFindRouteWithForwarding(t *testing.T) { forwardingEnabled: false, addrNIC: nicID2, localAddrWithPrefix: fakeNetCfg.nic1AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4584,7 +4584,7 @@ func TestFindRouteWithForwarding(t *testing.T) { forwardingEnabled: true, addrNIC: nicID2, localAddrWithPrefix: fakeNetCfg.nic1AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4608,7 +4608,7 @@ func TestFindRouteWithForwarding(t *testing.T) { netCfg: fakeNetCfg, forwardingEnabled: false, localAddrWithPrefix: fakeNetCfg.nic1AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4624,7 +4624,7 @@ func TestFindRouteWithForwarding(t *testing.T) { netCfg: ipv6LinkLocalNIC1WithGlobalRemote, forwardingEnabled: false, addrNIC: nicID1, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4632,7 +4632,7 @@ func TestFindRouteWithForwarding(t *testing.T) { netCfg: ipv6LinkLocalNIC1WithGlobalRemote, forwardingEnabled: true, addrNIC: nicID1, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4640,7 +4640,7 @@ func TestFindRouteWithForwarding(t *testing.T) { netCfg: ipv6LinkLocalNIC1WithGlobalRemote, forwardingEnabled: false, localAddrWithPrefix: ipv6LinkLocalNIC1WithGlobalRemote.nic1AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { @@ -4648,7 +4648,7 @@ func TestFindRouteWithForwarding(t *testing.T) { netCfg: ipv6LinkLocalNIC1WithGlobalRemote, forwardingEnabled: true, localAddrWithPrefix: ipv6LinkLocalNIC1WithGlobalRemote.nic1AddrWithPrefix, - findRouteErr: &tcpip.ErrNoRoute{}, + findRouteErr: &tcpip.ErrHostUnreachable{}, dependentOnForwarding: false, }, { diff --git a/pkg/tcpip/stack/transport_test.go b/pkg/tcpip/stack/transport_test.go index 61796c718..46f63ad8b 100644 --- a/pkg/tcpip/stack/transport_test.go +++ b/pkg/tcpip/stack/transport_test.go @@ -95,7 +95,7 @@ func (*fakeTransportEndpoint) Read(io.Writer, tcpip.ReadOptions) (tcpip.ReadResu func (f *fakeTransportEndpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, tcpip.Error) { if len(f.route.RemoteAddress()) == 0 { - return 0, &tcpip.ErrNoRoute{} + return 0, &tcpip.ErrHostUnreachable{} } v := make([]byte, p.Len()) @@ -146,7 +146,7 @@ func (f *fakeTransportEndpoint) Connect(addr tcpip.FullAddress) tcpip.Error { // Find the route. r, err := f.proto.stack.FindRoute(addr.NIC, "", addr.Addr, fakeNetNumber, false /* multicastLoop */) if err != nil { - return &tcpip.ErrNoRoute{} + return &tcpip.ErrHostUnreachable{} } // Try to register so that we can start receiving packets. diff --git a/pkg/tcpip/tests/integration/link_resolution_test.go b/pkg/tcpip/tests/integration/link_resolution_test.go index 7b2663c59..a0c6ae5e5 100644 --- a/pkg/tcpip/tests/integration/link_resolution_test.go +++ b/pkg/tcpip/tests/integration/link_resolution_test.go @@ -246,9 +246,9 @@ func TestTCPLinkResolutionFailure(t *testing.T) { name: "IPv4 without resolvable remote", netProto: ipv4.ProtocolNumber, remoteAddr: utils.Ipv4Addr3.AddressWithPrefix.Address, - expectedWriteErr: &tcpip.ErrNoRoute{}, + expectedWriteErr: &tcpip.ErrHostUnreachable{}, sockError: tcpip.SockError{ - Err: &tcpip.ErrNoRoute{}, + Err: &tcpip.ErrHostUnreachable{}, Dst: tcpip.FullAddress{ NIC: host1NICID, Addr: utils.Ipv4Addr3.AddressWithPrefix.Address, @@ -271,9 +271,9 @@ func TestTCPLinkResolutionFailure(t *testing.T) { name: "IPv6 without resolvable remote", netProto: ipv6.ProtocolNumber, remoteAddr: utils.Ipv6Addr3.AddressWithPrefix.Address, - expectedWriteErr: &tcpip.ErrNoRoute{}, + expectedWriteErr: &tcpip.ErrHostUnreachable{}, sockError: tcpip.SockError{ - Err: &tcpip.ErrNoRoute{}, + Err: &tcpip.ErrHostUnreachable{}, Dst: tcpip.FullAddress{ NIC: host1NICID, Addr: utils.Ipv6Addr3.AddressWithPrefix.Address, diff --git a/pkg/tcpip/tests/integration/multicast_forward_test.go b/pkg/tcpip/tests/integration/multicast_forward_test.go index 7662ec181..892823fe4 100644 --- a/pkg/tcpip/tests/integration/multicast_forward_test.go +++ b/pkg/tcpip/tests/integration/multicast_forward_test.go @@ -587,7 +587,7 @@ func TestMulticastRouteLastUsedTime(t *testing.T) { name: "no matching route", srcAddr: remoteUnicastAddr, dstAddr: otherMulticastAddr, - wantErr: &tcpip.ErrNoRoute{}, + wantErr: &tcpip.ErrHostUnreachable{}, }, { name: "multicast source", @@ -745,7 +745,7 @@ func TestRemoveMulticastRoute(t *testing.T) { name: "no matching route", srcAddr: remoteUnicastAddr, dstAddr: otherMulticastAddr, - wantErr: &tcpip.ErrNoRoute{}, + wantErr: &tcpip.ErrHostUnreachable{}, }, { name: "multicast source", diff --git a/pkg/tcpip/tests/integration/route_test.go b/pkg/tcpip/tests/integration/route_test.go index 97796eb75..db5f447df 100644 --- a/pkg/tcpip/tests/integration/route_test.go +++ b/pkg/tcpip/tests/integration/route_test.go @@ -131,7 +131,7 @@ func TestLocalPing(t *testing.T) { netProto: ipv4.ProtocolNumber, linkEndpoint: loopback.New, icmpBuf: ipv4ICMPBuf, - expectedConnectErr: &tcpip.ErrNoRoute{}, + expectedConnectErr: &tcpip.ErrHostUnreachable{}, checkLinkEndpoint: func(*testing.T, stack.LinkEndpoint) {}, }, { @@ -140,7 +140,7 @@ func TestLocalPing(t *testing.T) { netProto: ipv6.ProtocolNumber, linkEndpoint: loopback.New, icmpBuf: ipv6ICMPBuf, - expectedConnectErr: &tcpip.ErrNoRoute{}, + expectedConnectErr: &tcpip.ErrHostUnreachable{}, checkLinkEndpoint: func(*testing.T, stack.LinkEndpoint) {}, }, { @@ -149,7 +149,7 @@ func TestLocalPing(t *testing.T) { netProto: ipv4.ProtocolNumber, linkEndpoint: channelEP, icmpBuf: ipv4ICMPBuf, - expectedConnectErr: &tcpip.ErrNoRoute{}, + expectedConnectErr: &tcpip.ErrHostUnreachable{}, checkLinkEndpoint: channelEPCheck, }, { @@ -158,7 +158,7 @@ func TestLocalPing(t *testing.T) { netProto: ipv6.ProtocolNumber, linkEndpoint: channelEP, icmpBuf: ipv6ICMPBuf, - expectedConnectErr: &tcpip.ErrNoRoute{}, + expectedConnectErr: &tcpip.ErrHostUnreachable{}, checkLinkEndpoint: channelEPCheck, }, } @@ -281,7 +281,7 @@ func TestLocalUDP(t *testing.T) { { name: "Unassigned local address", addAddress: false, - expectedWriteErr: &tcpip.ErrNoRoute{}, + expectedWriteErr: &tcpip.ErrHostUnreachable{}, }, { name: "Assigned local address", diff --git a/pkg/tcpip/transport/datagram_test.go b/pkg/tcpip/transport/datagram_test.go index 135867369..2d280a6da 100644 --- a/pkg/tcpip/transport/datagram_test.go +++ b/pkg/tcpip/transport/datagram_test.go @@ -740,7 +740,7 @@ func TestIPv6PacketInfo(t *testing.T) { pktInfo: tcpip.IPv6PacketInfo{ NIC: nicID1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, { name: "Bind wildcard and NIC & SendTo with packet info NIC matching", @@ -773,7 +773,7 @@ func TestIPv6PacketInfo(t *testing.T) { pktInfo: tcpip.IPv6PacketInfo{ NIC: nicID1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, { name: "Bind specified & SendTo with packet info NIC not matching bound addr", @@ -857,7 +857,7 @@ func TestIPv6PacketInfo(t *testing.T) { pktInfo: tcpip.IPv6PacketInfo{ NIC: nicID1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, { name: "Bind wildcard & Connect with NIC then Send with packet info NIC matching", @@ -890,7 +890,7 @@ func TestIPv6PacketInfo(t *testing.T) { pktInfo: tcpip.IPv6PacketInfo{ NIC: nicID1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, { name: "Bind specified & Connect then Send with packet info NIC not matching but local addr specified", @@ -907,7 +907,7 @@ func TestIPv6PacketInfo(t *testing.T) { NIC: nicID1, Addr: ipv6Addr1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, // Connect @@ -950,7 +950,7 @@ func TestIPv6PacketInfo(t *testing.T) { pktInfo: tcpip.IPv6PacketInfo{ NIC: nicID1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, { name: "Connect then Send with packet info NIC not matching", @@ -962,7 +962,7 @@ func TestIPv6PacketInfo(t *testing.T) { pktInfo: tcpip.IPv6PacketInfo{ NIC: nicID1, }, - expectedErr: &tcpip.ErrNoRoute{}, + expectedErr: &tcpip.ErrHostUnreachable{}, }, // Connect and SendTo diff --git a/pkg/tcpip/transport/icmp/endpoint.go b/pkg/tcpip/transport/icmp/endpoint.go index 9a348b084..8c737d51f 100644 --- a/pkg/tcpip/transport/icmp/endpoint.go +++ b/pkg/tcpip/transport/icmp/endpoint.go @@ -300,7 +300,7 @@ func (e *endpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, tcp e.stats.WriteErrors.WriteClosed.Increment() case *tcpip.ErrInvalidEndpointState: e.stats.WriteErrors.InvalidEndpointState.Increment() - case *tcpip.ErrNoRoute, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: + case *tcpip.ErrHostUnreachable, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: // Errors indicating any problem with IP routing of the packet. e.stats.SendErrors.NoRoute.Increment() default: diff --git a/pkg/tcpip/transport/internal/network/endpoint.go b/pkg/tcpip/transport/internal/network/endpoint.go index 1a5fbc6a6..2f6acc781 100644 --- a/pkg/tcpip/transport/internal/network/endpoint.go +++ b/pkg/tcpip/transport/internal/network/endpoint.go @@ -447,7 +447,7 @@ func (e *Endpoint) AcquireContextForWrite(opts tcpip.WriteOptions) (WriteContext // interface (usually when using link-local addresses), make sure the // interface matches the specified local interface. if nicID != 0 && nicID != pktInfoNICID { - return WriteContext{}, &tcpip.ErrNoRoute{} + return WriteContext{}, &tcpip.ErrHostUnreachable{} } // If a local address is not specified, then we need to make sure the @@ -459,7 +459,7 @@ func (e *Endpoint) AcquireContextForWrite(opts tcpip.WriteOptions) (WriteContext // // The bound interface is usually only set for link-local addresses. if info.BindNICID != 0 && info.BindNICID != pktInfoNICID { - return WriteContext{}, &tcpip.ErrNoRoute{} + return WriteContext{}, &tcpip.ErrHostUnreachable{} } if len(info.ID.LocalAddress) != 0 && e.stack.CheckLocalAddress(pktInfoNICID, header.IPv6ProtocolNumber, info.ID.LocalAddress) == 0 { return WriteContext{}, &tcpip.ErrBadLocalAddress{} @@ -483,7 +483,7 @@ func (e *Endpoint) AcquireContextForWrite(opts tcpip.WriteOptions) (WriteContext } else { if info.BindNICID != 0 { if nicID != 0 && nicID != info.BindNICID { - return WriteContext{}, &tcpip.ErrNoRoute{} + return WriteContext{}, &tcpip.ErrHostUnreachable{} } nicID = info.BindNICID diff --git a/pkg/tcpip/transport/raw/endpoint.go b/pkg/tcpip/transport/raw/endpoint.go index c9ea3621d..64b588403 100644 --- a/pkg/tcpip/transport/raw/endpoint.go +++ b/pkg/tcpip/transport/raw/endpoint.go @@ -327,7 +327,7 @@ func (e *endpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, tcp e.stats.WriteErrors.WriteClosed.Increment() case *tcpip.ErrInvalidEndpointState: e.stats.WriteErrors.InvalidEndpointState.Increment() - case *tcpip.ErrNoRoute, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: + case *tcpip.ErrHostUnreachable, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: // Errors indicating any problem with IP routing of the packet. e.stats.SendErrors.NoRoute.Increment() default: diff --git a/pkg/tcpip/transport/tcp/endpoint.go b/pkg/tcpip/transport/tcp/endpoint.go index a4efb2486..613c6c43e 100644 --- a/pkg/tcpip/transport/tcp/endpoint.go +++ b/pkg/tcpip/transport/tcp/endpoint.go @@ -2385,7 +2385,7 @@ func (e *endpoint) connect(addr tcpip.FullAddress, handshake bool) tcpip.Error { } if nicID != 0 && nicID != e.boundNICID { - return &tcpip.ErrNoRoute{} + return &tcpip.ErrHostUnreachable{} } nicID = e.boundNICID @@ -2906,7 +2906,7 @@ func (e *endpoint) HandleError(transErr stack.TransportError, pkt stack.PacketBu case stack.PacketTooBigTransportError: handlePacketTooBig(transErr.Info()) case stack.DestinationHostUnreachableTransportError: - e.onICMPError(&tcpip.ErrNoRoute{}, transErr, pkt) + e.onICMPError(&tcpip.ErrHostUnreachable{}, transErr, pkt) case stack.DestinationNetworkUnreachableTransportError: e.onICMPError(&tcpip.ErrNetworkUnreachable{}, transErr, pkt) } diff --git a/pkg/tcpip/transport/tcp/test/e2e/dual_stack_test.go b/pkg/tcpip/transport/tcp/test/e2e/dual_stack_test.go index b2e618a21..c93d49f45 100644 --- a/pkg/tcpip/transport/tcp/test/e2e/dual_stack_test.go +++ b/pkg/tcpip/transport/tcp/test/e2e/dual_stack_test.go @@ -42,7 +42,7 @@ func TestV4MappedConnectOnV6Only(t *testing.T) { // Start connection attempt, it must fail. err := c.EP.Connect(tcpip.FullAddress{Addr: context.TestV4MappedAddr, Port: context.TestPort}) - if d := cmp.Diff(&tcpip.ErrNoRoute{}, err); d != "" { + if d := cmp.Diff(&tcpip.ErrHostUnreachable{}, err); d != "" { t.Fatalf("c.EP.Connect(...) mismatch (-want +got):\n%s", d) } } diff --git a/pkg/tcpip/transport/tcp/test/e2e/tcp_test.go b/pkg/tcpip/transport/tcp/test/e2e/tcp_test.go index 3cdcda86c..b5b06a741 100644 --- a/pkg/tcpip/transport/tcp/test/e2e/tcp_test.go +++ b/pkg/tcpip/transport/tcp/test/e2e/tcp_test.go @@ -188,7 +188,7 @@ func TestConnectICMPError(t *testing.T) { for { if err := wep.LastErrorLocked(); err != nil { - if d := cmp.Diff(&tcpip.ErrNoRoute{}, err); d != "" { + if d := cmp.Diff(&tcpip.ErrHostUnreachable{}, err); d != "" { t.Errorf("ep.LastErrorLocked() mismatch (-want +got):\n%s", d) } break @@ -261,7 +261,7 @@ func TestActiveFailedConnectionAttemptIncrement(t *testing.T) { { err := c.EP.Connect(tcpip.FullAddress{NIC: 2, Addr: context.TestAddr, Port: context.TestPort}) - if d := cmp.Diff(&tcpip.ErrNoRoute{}, err); d != "" { + if d := cmp.Diff(&tcpip.ErrHostUnreachable{}, err); d != "" { t.Errorf("c.EP.Connect(...) mismatch (-want +got):\n%s", d) } } diff --git a/pkg/tcpip/transport/testing/context/context.go b/pkg/tcpip/transport/testing/context/context.go index ee18b4619..708398279 100644 --- a/pkg/tcpip/transport/testing/context/context.go +++ b/pkg/tcpip/transport/testing/context/context.go @@ -221,7 +221,7 @@ func (c *Context) CheckEndpointWriteStats(incr uint64, want *tcpip.TransportEndp want.WriteErrors.WriteClosed.IncrementBy(incr) case *tcpip.ErrInvalidEndpointState: want.WriteErrors.InvalidEndpointState.IncrementBy(incr) - case *tcpip.ErrNoRoute, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: + case *tcpip.ErrHostUnreachable, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: want.SendErrors.NoRoute.IncrementBy(incr) default: want.SendErrors.SendToNetworkFailed.IncrementBy(incr) diff --git a/pkg/tcpip/transport/udp/endpoint.go b/pkg/tcpip/transport/udp/endpoint.go index 78783f582..ff75c5def 100644 --- a/pkg/tcpip/transport/udp/endpoint.go +++ b/pkg/tcpip/transport/udp/endpoint.go @@ -370,7 +370,7 @@ func (e *endpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, tcp e.stats.WriteErrors.WriteClosed.Increment() case *tcpip.ErrInvalidEndpointState: e.stats.WriteErrors.InvalidEndpointState.Increment() - case *tcpip.ErrNoRoute, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: + case *tcpip.ErrHostUnreachable, *tcpip.ErrBroadcastDisabled, *tcpip.ErrNetworkUnreachable: // Errors indicating any problem with IP routing of the packet. e.stats.SendErrors.NoRoute.Increment() default: diff --git a/pkg/tcpip/transport/udp/udp_test.go b/pkg/tcpip/transport/udp/udp_test.go index 53f486fcd..d92a3cfee 100644 --- a/pkg/tcpip/transport/udp/udp_test.go +++ b/pkg/tcpip/transport/udp/udp_test.go @@ -754,7 +754,7 @@ func TestV4WriteOnV6Only(t *testing.T) { c.CreateEndpointForFlow(context.UnicastV6Only, udp.ProtocolNumber) // Write to V4 mapped address. - testWriteOpSequenceFails(c, context.UnicastV4in6, writeOpSequence, &tcpip.ErrNoRoute{}) + testWriteOpSequenceFails(c, context.UnicastV4in6, writeOpSequence, &tcpip.ErrHostUnreachable{}) } }