Change tcpip.Error to an interface

This makes it possible to add data to types that implement tcpip.Error.
ErrBadLinkEndpoint is removed as it is unused.

PiperOrigin-RevId: 354437314

5 files changed, 84 insertions, 56 deletions

diff --git a/pkg/tcpip/tests/integration/forward_test.go b/pkg/tcpip/tests/integration/forward_test.go
index 2b5832c62..38e1881c7 100644
--- a/pkg/tcpip/tests/integration/forward_test.go
+++ b/pkg/tcpip/tests/integration/forward_test.go
@@ -340,7 +340,7 @@ func TestForwarding(t *testing.T) {
 	subTests := []struct {
 		name               string
 		proto              tcpip.TransportProtocolNumber
-		expectedConnectErr *tcpip.Error
+		expectedConnectErr tcpip.Error
 		setupServerSide    func(t *testing.T, ep tcpip.Endpoint, ch <-chan struct{}, clientAddr tcpip.FullAddress) (tcpip.Endpoint, chan struct{})
 		needRemoteAddr     bool
 	}{
@@ -361,7 +361,7 @@ func TestForwarding(t *testing.T) {
 		{
 			name:               "TCP",
 			proto:              tcp.ProtocolNumber,
-			expectedConnectErr: tcpip.ErrConnectStarted,
+			expectedConnectErr: &tcpip.ErrConnectStarted{},
 			setupServerSide: func(t *testing.T, ep tcpip.Endpoint, ch <-chan struct{}, clientAddr tcpip.FullAddress) (tcpip.Endpoint, chan struct{}) {
 				t.Helper()
 
@@ -371,7 +371,7 @@ func TestForwarding(t *testing.T) {
 				var addr tcpip.FullAddress
 				for {
 					newEP, wq, err := ep.Accept(&addr)
-					if err == tcpip.ErrWouldBlock {
+					if _, ok := err.(*tcpip.ErrWouldBlock); ok {
 						<-ch
 						continue
 					}
@@ -420,8 +420,11 @@ func TestForwarding(t *testing.T) {
 						t.Fatalf("epsAndAddrs.clientEP.Bind(%#v): %s", clientAddr, err)
 					}
 
-					if err := epsAndAddrs.clientEP.Connect(serverAddr); err != subTest.expectedConnectErr {
-						t.Fatalf("got epsAndAddrs.clientEP.Connect(%#v) = %s, want = %s", serverAddr, err, subTest.expectedConnectErr)
+					{
+						err := epsAndAddrs.clientEP.Connect(serverAddr)
+						if diff := cmp.Diff(subTest.expectedConnectErr, err); diff != "" {
+							t.Fatalf("unexpected error from epsAndAddrs.clientEP.Connect(%#v), (-want, +got):\n%s", serverAddr, diff)
+						}
 					}
 					if addr, err := epsAndAddrs.clientEP.GetLocalAddress(); err != nil {
 						t.Fatalf("epsAndAddrs.clientEP.GetLocalAddress(): %s", err)
diff --git a/pkg/tcpip/tests/integration/link_resolution_test.go b/pkg/tcpip/tests/integration/link_resolution_test.go
index 3c25d1e0c..7069352f2 100644
--- a/pkg/tcpip/tests/integration/link_resolution_test.go
+++ b/pkg/tcpip/tests/integration/link_resolution_test.go
@@ -257,7 +257,7 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 		name             string
 		netProto         tcpip.NetworkProtocolNumber
 		remoteAddr       tcpip.Address
-		expectedWriteErr *tcpip.Error
+		expectedWriteErr tcpip.Error
 		sockError        tcpip.SockError
 	}{
 		{
@@ -276,9 +276,9 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 			name:             "IPv4 without resolvable remote",
 			netProto:         ipv4.ProtocolNumber,
 			remoteAddr:       ipv4Addr3.AddressWithPrefix.Address,
-			expectedWriteErr: tcpip.ErrNoRoute,
+			expectedWriteErr: &tcpip.ErrNoRoute{},
 			sockError: tcpip.SockError{
-				Err:       tcpip.ErrNoRoute,
+				Err:       &tcpip.ErrNoRoute{},
 				ErrType:   byte(header.ICMPv4DstUnreachable),
 				ErrCode:   byte(header.ICMPv4HostUnreachable),
 				ErrOrigin: tcpip.SockExtErrorOriginICMP,
@@ -298,9 +298,9 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 			name:             "IPv6 without resolvable remote",
 			netProto:         ipv6.ProtocolNumber,
 			remoteAddr:       ipv6Addr3.AddressWithPrefix.Address,
-			expectedWriteErr: tcpip.ErrNoRoute,
+			expectedWriteErr: &tcpip.ErrNoRoute{},
 			sockError: tcpip.SockError{
-				Err:       tcpip.ErrNoRoute,
+				Err:       &tcpip.ErrNoRoute{},
 				ErrType:   byte(header.ICMPv6DstUnreachable),
 				ErrCode:   byte(header.ICMPv6AddressUnreachable),
 				ErrOrigin: tcpip.SockExtErrorOriginICMP6,
@@ -357,18 +357,24 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 
 			remoteAddr := listenerAddr
 			remoteAddr.Addr = test.remoteAddr
-			if err := clientEP.Connect(remoteAddr); err != tcpip.ErrConnectStarted {
-				t.Fatalf("got clientEP.Connect(%#v) = %s, want = %s", remoteAddr, err, tcpip.ErrConnectStarted)
+			{
+				err := clientEP.Connect(remoteAddr)
+				if _, ok := err.(*tcpip.ErrConnectStarted); !ok {
+					t.Fatalf("got clientEP.Connect(%#v) = %s, want = %s", remoteAddr, err, &tcpip.ErrConnectStarted{})
+				}
 			}
 
 			// Wait for an error due to link resolution failing, or the endpoint to be
 			// writable.
 			<-ch
-			var r bytes.Reader
-			r.Reset([]byte{0})
-			var wOpts tcpip.WriteOptions
-			if n, err := clientEP.Write(&r, wOpts); err != test.expectedWriteErr {
-				t.Errorf("got clientEP.Write(_, %#v) = (%d, %s), want = (_, %s)", wOpts, n, err, test.expectedWriteErr)
+			{
+				var r bytes.Reader
+				r.Reset([]byte{0})
+				var wOpts tcpip.WriteOptions
+				_, err := clientEP.Write(&r, wOpts)
+				if diff := cmp.Diff(test.expectedWriteErr, err); diff != "" {
+					t.Errorf("unexpected error from clientEP.Write(_, %#v), (-want, +got):\n%s", wOpts, diff)
+				}
 			}
 
 			if test.expectedWriteErr == nil {
@@ -382,7 +388,7 @@ func TestTCPLinkResolutionFailure(t *testing.T) {
 
 			sockErrCmpOpts := []cmp.Option{
 				cmpopts.IgnoreUnexported(tcpip.SockError{}),
-				cmp.Comparer(func(a, b *tcpip.Error) bool {
+				cmp.Comparer(func(a, b tcpip.Error) bool {
 					// tcpip.Error holds an unexported field but the errors netstack uses
 					// are pre defined so we can simply compare pointers.
 					return a == b
@@ -455,10 +461,11 @@ func TestGetLinkAddress(t *testing.T) {
 					host1Stack, _ := setupStack(t, stackOpts, host1NICID, host2NICID)
 
 					ch := make(chan stack.LinkResolutionResult, 1)
-					if err := host1Stack.GetLinkAddress(host1NICID, test.remoteAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
+					err := host1Stack.GetLinkAddress(host1NICID, test.remoteAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
 						ch <- r
-					}); err != tcpip.ErrWouldBlock {
-						t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", host1NICID, test.remoteAddr, test.netProto, err, tcpip.ErrWouldBlock)
+					})
+					if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+						t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", host1NICID, test.remoteAddr, test.netProto, err, &tcpip.ErrWouldBlock{})
 					}
 					wantRes := stack.LinkResolutionResult{Success: test.expectedOk}
 					if test.expectedOk {
@@ -572,10 +579,11 @@ func TestRouteResolvedFields(t *testing.T) {
 						wantUnresolvedRouteInfo := wantRouteInfo
 						wantUnresolvedRouteInfo.RemoteLinkAddress = ""
 
-						if err := r.ResolvedFields(func(r stack.ResolvedFieldsResult) {
+						err := r.ResolvedFields(func(r stack.ResolvedFieldsResult) {
 							ch <- r
-						}); err != tcpip.ErrWouldBlock {
-							t.Errorf("got r.ResolvedFields(_) = %s, want = %s", err, tcpip.ErrWouldBlock)
+						})
+						if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+							t.Errorf("got r.ResolvedFields(_) = %s, want = %s", err, &tcpip.ErrWouldBlock{})
 						}
 						if diff := cmp.Diff(stack.ResolvedFieldsResult{RouteInfo: wantRouteInfo, Success: test.expectedSuccess}, <-ch, cmp.AllowUnexported(stack.RouteInfo{})); diff != "" {
 							t.Errorf("route resolve result mismatch (-want +got):\n%s", diff)
@@ -618,7 +626,7 @@ func TestWritePacketsLinkResolution(t *testing.T) {
 		name             string
 		netProto         tcpip.NetworkProtocolNumber
 		remoteAddr       tcpip.Address
-		expectedWriteErr *tcpip.Error
+		expectedWriteErr tcpip.Error
 	}{
 		{
 			name:             "IPv4",
@@ -705,7 +713,7 @@ func TestWritePacketsLinkResolution(t *testing.T) {
 				var rOpts tcpip.ReadOptions
 				res, err := serverEP.Read(&writer, rOpts)
 				if err != nil {
-					if err == tcpip.ErrWouldBlock {
+					if _, ok := err.(*tcpip.ErrWouldBlock); ok {
 						// Should not have anymore bytes to read after we read the sent
 						// number of bytes.
 						if count == len(data) {
@@ -1034,10 +1042,11 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			// Add a reachable dynamic entry to our neighbor table for the remote.
 			{
 				ch := make(chan stack.LinkResolutionResult, 1)
-				if err := host1Stack.GetLinkAddress(host1NICID, test.neighborAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
+				err := host1Stack.GetLinkAddress(host1NICID, test.neighborAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
 					ch <- r
-				}); err != tcpip.ErrWouldBlock {
-					t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", host1NICID, test.neighborAddr, test.netProto, err, tcpip.ErrWouldBlock)
+				})
+				if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+					t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", host1NICID, test.neighborAddr, test.netProto, err, &tcpip.ErrWouldBlock{})
 				}
 				if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: linkAddr2, Success: true}, <-ch); diff != "" {
 					t.Fatalf("link resolution mismatch (-want +got):\n%s", diff)
@@ -1088,8 +1097,11 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
 			if err := listenerEP.Listen(1); err != nil {
 				t.Fatalf("listenerEP.Listen(1): %s", err)
 			}
-			if err := clientEP.Connect(listenerAddr); err != tcpip.ErrConnectStarted {
-				t.Fatalf("got clientEP.Connect(%#v) = %s, want = %s", listenerAddr, err, tcpip.ErrConnectStarted)
+			{
+				err := clientEP.Connect(listenerAddr)
+				if _, ok := err.(*tcpip.ErrConnectStarted); !ok {
+					t.Fatalf("got clientEP.Connect(%#v) = %s, want = %s", listenerAddr, err, &tcpip.ErrConnectStarted{})
+				}
 			}
 
 			// Wait for the TCP handshake to complete then make sure the neighbor is
diff --git a/pkg/tcpip/tests/integration/loopback_test.go b/pkg/tcpip/tests/integration/loopback_test.go
index 761283b66..ab67762ef 100644
--- a/pkg/tcpip/tests/integration/loopback_test.go
+++ b/pkg/tcpip/tests/integration/loopback_test.go
@@ -37,7 +37,7 @@ var _ ipv6.NDPDispatcher = (*ndpDispatcher)(nil)
 
 type ndpDispatcher struct{}
 
-func (*ndpDispatcher) OnDuplicateAddressDetectionStatus(tcpip.NICID, tcpip.Address, bool, *tcpip.Error) {
+func (*ndpDispatcher) OnDuplicateAddressDetectionStatus(tcpip.NICID, tcpip.Address, bool, tcpip.Error) {
 }
 
 func (*ndpDispatcher) OnDefaultRouterDiscovered(tcpip.NICID, tcpip.Address) bool {
@@ -262,8 +262,8 @@ func TestLoopbackAcceptAllInSubnetUDP(t *testing.T) {
 				if diff := cmp.Diff(data, buf.Bytes()); diff != "" {
 					t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
 				}
-			} else if err != tcpip.ErrWouldBlock {
-				t.Fatalf("got rep.Read = (%v, %s) [with data %x], want = (_, %s)", res, err, buf.Bytes(), tcpip.ErrWouldBlock)
+			} else if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+				t.Fatalf("got rep.Read = (%v, %s) [with data %x], want = (_, %s)", res, err, buf.Bytes(), &tcpip.ErrWouldBlock{})
 			}
 		})
 	}
@@ -322,11 +322,14 @@ func TestLoopbackSubnetLifetimeBoundToAddr(t *testing.T) {
 	if err := s.RemoveAddress(nicID, protoAddr.AddressWithPrefix.Address); err != nil {
 		t.Fatalf("s.RemoveAddress(%d, %s): %s", nicID, protoAddr.AddressWithPrefix.Address, err)
 	}
-	if err := r.WritePacket(nil /* gso */, params, stack.NewPacketBuffer(stack.PacketBufferOptions{
-		ReserveHeaderBytes: int(r.MaxHeaderLength()),
-		Data:               data.ToVectorisedView(),
-	})); err != tcpip.ErrInvalidEndpointState {
-		t.Fatalf("got r.WritePacket(nil, %#v, _) = %s, want = %s", params, err, tcpip.ErrInvalidEndpointState)
+	{
+		err := r.WritePacket(nil /* gso */, params, stack.NewPacketBuffer(stack.PacketBufferOptions{
+			ReserveHeaderBytes: int(r.MaxHeaderLength()),
+			Data:               data.ToVectorisedView(),
+		}))
+		if _, ok := err.(*tcpip.ErrInvalidEndpointState); !ok {
+			t.Fatalf("got r.WritePacket(nil, %#v, _) = %s, want = %s", params, err, &tcpip.ErrInvalidEndpointState{})
+		}
 	}
 }
 
@@ -470,13 +473,17 @@ func TestLoopbackAcceptAllInSubnetTCP(t *testing.T) {
 				Addr: test.dstAddr,
 				Port: localPort,
 			}
-			if err := connectingEndpoint.Connect(connectAddr); err != tcpip.ErrConnectStarted {
-				t.Fatalf("connectingEndpoint.Connect(%#v): %s", connectAddr, err)
+			{
+				err := connectingEndpoint.Connect(connectAddr)
+				if _, ok := err.(*tcpip.ErrConnectStarted); !ok {
+					t.Fatalf("connectingEndpoint.Connect(%#v): %s", connectAddr, err)
+				}
 			}
 
 			if !test.expectAccept {
-				if _, _, err := listeningEndpoint.Accept(nil); err != tcpip.ErrWouldBlock {
-					t.Fatalf("got listeningEndpoint.Accept(nil) = %s, want = %s", err, tcpip.ErrWouldBlock)
+				_, _, err := listeningEndpoint.Accept(nil)
+				if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+					t.Fatalf("got listeningEndpoint.Accept(nil) = %s, want = %s", err, &tcpip.ErrWouldBlock{})
 				}
 				return
 			}
diff --git a/pkg/tcpip/tests/integration/multicast_broadcast_test.go b/pkg/tcpip/tests/integration/multicast_broadcast_test.go
index 9cc12fa58..d685fdd36 100644
--- a/pkg/tcpip/tests/integration/multicast_broadcast_test.go
+++ b/pkg/tcpip/tests/integration/multicast_broadcast_test.go
@@ -479,8 +479,8 @@ func TestIncomingMulticastAndBroadcast(t *testing.T) {
 				if diff := cmp.Diff(data, buf.Bytes()); diff != "" {
 					t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
 				}
-			} else if err != tcpip.ErrWouldBlock {
-				t.Fatalf("got Read = (%v, %s) [with data %x], want = (_, %s)", res, err, buf.Bytes(), tcpip.ErrWouldBlock)
+			} else if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+				t.Fatalf("got Read = (%v, %s) [with data %x], want = (_, %s)", res, err, buf.Bytes(), &tcpip.ErrWouldBlock{})
 			}
 		})
 	}
@@ -761,8 +761,11 @@ func TestUDPAddRemoveMembershipSocketOption(t *testing.T) {
 					if err := ep.SetSockOpt(&removeOpt); err != nil {
 						t.Fatalf("ep.SetSockOpt(&%#v): %s", removeOpt, err)
 					}
-					if _, err := ep.Read(&buf, tcpip.ReadOptions{}); err != tcpip.ErrWouldBlock {
-						t.Fatalf("got ep.Read = (_, %s), want = (_, %s)", err, tcpip.ErrWouldBlock)
+					{
+						_, err := ep.Read(&buf, tcpip.ReadOptions{})
+						if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
+							t.Fatalf("got ep.Read = (_, %s), want = (_, %s)", err, &tcpip.ErrWouldBlock{})
+						}
 					}
 				})
 			}
diff --git a/pkg/tcpip/tests/integration/route_test.go b/pkg/tcpip/tests/integration/route_test.go
index 35ee7437a..9654c9527 100644
--- a/pkg/tcpip/tests/integration/route_test.go
+++ b/pkg/tcpip/tests/integration/route_test.go
@@ -81,7 +81,7 @@ func TestLocalPing(t *testing.T) {
 		linkEndpoint       func() stack.LinkEndpoint
 		localAddr          tcpip.Address
 		icmpBuf            func(*testing.T) buffer.View
-		expectedConnectErr *tcpip.Error
+		expectedConnectErr tcpip.Error
 		checkLinkEndpoint  func(t *testing.T, e stack.LinkEndpoint)
 	}{
 		{
@@ -126,7 +126,7 @@ func TestLocalPing(t *testing.T) {
 			netProto:           ipv4.ProtocolNumber,
 			linkEndpoint:       loopback.New,
 			icmpBuf:            ipv4ICMPBuf,
-			expectedConnectErr: tcpip.ErrNoRoute,
+			expectedConnectErr: &tcpip.ErrNoRoute{},
 			checkLinkEndpoint:  func(*testing.T, stack.LinkEndpoint) {},
 		},
 		{
@@ -135,7 +135,7 @@ func TestLocalPing(t *testing.T) {
 			netProto:           ipv6.ProtocolNumber,
 			linkEndpoint:       loopback.New,
 			icmpBuf:            ipv6ICMPBuf,
-			expectedConnectErr: tcpip.ErrNoRoute,
+			expectedConnectErr: &tcpip.ErrNoRoute{},
 			checkLinkEndpoint:  func(*testing.T, stack.LinkEndpoint) {},
 		},
 		{
@@ -144,7 +144,7 @@ func TestLocalPing(t *testing.T) {
 			netProto:           ipv4.ProtocolNumber,
 			linkEndpoint:       channelEP,
 			icmpBuf:            ipv4ICMPBuf,
-			expectedConnectErr: tcpip.ErrNoRoute,
+			expectedConnectErr: &tcpip.ErrNoRoute{},
 			checkLinkEndpoint:  channelEPCheck,
 		},
 		{
@@ -153,7 +153,7 @@ func TestLocalPing(t *testing.T) {
 			netProto:           ipv6.ProtocolNumber,
 			linkEndpoint:       channelEP,
 			icmpBuf:            ipv6ICMPBuf,
-			expectedConnectErr: tcpip.ErrNoRoute,
+			expectedConnectErr: &tcpip.ErrNoRoute{},
 			checkLinkEndpoint:  channelEPCheck,
 		},
 	}
@@ -186,8 +186,11 @@ func TestLocalPing(t *testing.T) {
 			defer ep.Close()
 
 			connAddr := tcpip.FullAddress{Addr: test.localAddr}
-			if err := ep.Connect(connAddr); err != test.expectedConnectErr {
-				t.Fatalf("got ep.Connect(%#v) = %s, want = %s", connAddr, err, test.expectedConnectErr)
+			{
+				err := ep.Connect(connAddr)
+				if diff := cmp.Diff(test.expectedConnectErr, err); diff != "" {
+					t.Fatalf("unexpected error from ep.Connect(%#v), (-want, +got):\n%s", connAddr, diff)
+				}
 			}
 
 			if test.expectedConnectErr != nil {
@@ -263,12 +266,12 @@ func TestLocalUDP(t *testing.T) {
 	subTests := []struct {
 		name             string
 		addAddress       bool
-		expectedWriteErr *tcpip.Error
+		expectedWriteErr tcpip.Error
 	}{
 		{
 			name:             "Unassigned local address",
 			addAddress:       false,
-			expectedWriteErr: tcpip.ErrNoRoute,
+			expectedWriteErr: &tcpip.ErrNoRoute{},
 		},
 		{
 			name:             "Assigned local address",