go
/
gvisor
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Plumb link address request errors up to requester 

Prevent the situation where callers to (*stack).GetLinkAddress provide
incorrect arguments and are unable to observe this condition.

Updates #5583.

PiperOrigin-RevId: 360481557
This commit is contained in:
Tamir Duberstein 2021-03-02 11:55:45 -08:00 committed by gVisor bot
parent 865ca64ee8
commit 6bc27946a6
9 changed files with 94 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/tcpip/stack/neighbor_cache.go
View File

@ -140,7 +140,7 @@ func (n *neighborCache) entry(remoteAddr, localAddr tcpip.Address, onResolve fun
// a node continues sending packets to that neighbor using the cached
// link-layer address."
if onResolve != nil {
onResolve(LinkResolutionResult{LinkAddress: entry.mu.neigh.LinkAddr, Success: true})
onResolve(LinkResolutionResult{LinkAddress: entry.mu.neigh.LinkAddr, Err: nil})
}
return entry.mu.neigh, nil, nil
case Unknown, Incomplete, Unreachable:

18
pkg/tcpip/stack/neighbor_cache_test.go
View File

@ -1162,7 +1162,7 @@ func TestNeighborCacheKeepFrequentlyUsed(t *testing.T) {
t.Fatalf("linkRes.entries.entry(%d) not found", i)
}
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Success: true}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Err: nil}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1218,7 +1218,7 @@ func TestNeighborCacheKeepFrequentlyUsed(t *testing.T) {
}
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Success: true}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Err: nil}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1379,7 +1379,7 @@ func TestNeighborCacheReplace(t *testing.T) {
}
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Success: true}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Err: nil}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1485,7 +1485,7 @@ func TestNeighborCacheResolutionFailed(t *testing.T) {
// First, sanity check that resolution is working
{
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Success: true}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Err: nil}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1519,7 +1519,7 @@ func TestNeighborCacheResolutionFailed(t *testing.T) {
entry.Addr += "2"
{
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{Success: false}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{Err: &tcpip.ErrTimeout{}}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1559,7 +1559,7 @@ func TestNeighborCacheResolutionTimeout(t *testing.T) {
}
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{Success: false}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{Err: &tcpip.ErrTimeout{}}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1593,7 +1593,7 @@ func TestNeighborCacheRetryResolution(t *testing.T) {
// Perform address resolution with a faulty link, which will fail.
{
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{Success: false}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{Err: &tcpip.ErrTimeout{}}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1625,7 +1625,7 @@ func TestNeighborCacheRetryResolution(t *testing.T) {
linkRes.dropReplies = false
{
incompleteEntry, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Success: true}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Err: nil}, r); diff != "" {
t.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})
@ -1678,7 +1678,7 @@ func BenchmarkCacheClear(b *testing.B) {
}
_, ch, err := linkRes.neigh.entry(entry.Addr, "", func(r LinkResolutionResult) {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Success: true}, r); diff != "" {
if diff := cmp.Diff(LinkResolutionResult{LinkAddress: entry.LinkAddr, Err: nil}, r); diff != "" {
b.Fatalf("got link resolution result mismatch (-want +got):\n%s", diff)
}
})

37
pkg/tcpip/stack/neighbor_entry.go
View File

@ -157,8 +157,8 @@ func newStaticNeighborEntry(cache *neighborCache, addr tcpip.Address, linkAddr t
// the link address if resolution completed successfully.
//
// Precondition: e.mu MUST be locked.
func (e *neighborEntry) notifyCompletionLocked(succeeded bool) {
res := LinkResolutionResult{LinkAddress: e.mu.neigh.LinkAddr, Success: succeeded}
func (e *neighborEntry) notifyCompletionLocked(err tcpip.Error) {
res := LinkResolutionResult{LinkAddress: e.mu.neigh.LinkAddr, Err: err}
for _, callback := range e.mu.onResolve {
callback(res)
}
@ -173,7 +173,7 @@ func (e *neighborEntry) notifyCompletionLocked(succeeded bool) {
// is resolved (which ends up obtaining the entry's lock) while holding the
// link resolution queue's lock. Dequeuing packets in a new goroutine avoids
// a lock ordering violation.
go e.cache.nic.linkResQueue.dequeue(ch, e.mu.neigh.LinkAddr, succeeded)
go e.cache.nic.linkResQueue.dequeue(ch, e.mu.neigh.LinkAddr, err)
}
}
@ -227,7 +227,13 @@ func (e *neighborEntry) removeLocked() {
e.mu.neigh.UpdatedAtNanos = e.cache.nic.stack.clock.NowNanoseconds()
e.dispatchRemoveEventLocked()
e.cancelTimerLocked()
e.notifyCompletionLocked(false /* succeeded */)
// TODO(https://gvisor.dev/issues/5583): test the case where this function is
// called during resolution; that can happen in at least these scenarios:
//
// - manual address removal during resolution
//
// - neighbor cache eviction during resolution
e.notifyCompletionLocked(&tcpip.ErrAborted{})
}
// setStateLocked transitions the entry to the specified state immediately.
@ -302,9 +308,8 @@ func (e *neighborEntry) setStateLocked(next NeighborState) {
e.mu.timer = timer{
done: &done,
timer: e.cache.nic.stack.Clock().AfterFunc(0, func() {
var err tcpip.Error
timedoutResolution := remaining == 0
if !timedoutResolution {
var err tcpip.Error = &tcpip.ErrTimeout{}
if remaining != 0 {
err = e.cache.linkRes.LinkAddressRequest(addr, "" /* localAddr */, linkAddr)
}
@ -316,8 +321,9 @@ func (e *neighborEntry) setStateLocked(next NeighborState) {
return
}
if timedoutResolution || err != nil {
if err != nil {
e.setStateLocked(Unreachable)
e.notifyCompletionLocked(err)
e.dispatchChangeEventLocked()
return
}
@ -328,7 +334,6 @@ func (e *neighborEntry) setStateLocked(next NeighborState) {
}
case Unreachable:
e.notifyCompletionLocked(false /* succeeded */)
case Unknown, Stale, Static:
// Do nothing
@ -374,9 +379,8 @@ func (e *neighborEntry) handlePacketQueuedLocked(localAddr tcpip.Address) {
e.mu.timer = timer{
done: &done,
timer: e.cache.nic.stack.Clock().AfterFunc(0, func() {
var err tcpip.Error
timedoutResolution := remaining == 0
if !timedoutResolution {
var err tcpip.Error = &tcpip.ErrTimeout{}
if remaining != 0 {
// As per RFC 4861 section 7.2.2:
//
// If the source address of the packet prompting the solicitation is
@ -395,8 +399,9 @@ func (e *neighborEntry) handlePacketQueuedLocked(localAddr tcpip.Address) {
return
}
if timedoutResolution || err != nil {
if err != nil {
e.setStateLocked(Unreachable)
e.notifyCompletionLocked(err)
e.dispatchChangeEventLocked()
return
}
@ -442,7 +447,7 @@ func (e *neighborEntry) handleProbeLocked(remoteLinkAddr tcpip.LinkAddress) {
// - RFC 4861 section 7.2.3
e.mu.neigh.LinkAddr = remoteLinkAddr
e.setStateLocked(Stale)
e.notifyCompletionLocked(true /* succeeded */)
e.notifyCompletionLocked(nil)
e.dispatchChangeEventLocked()
case Reachable, Delay, Probe:
@ -504,7 +509,7 @@ func (e *neighborEntry) handleConfirmationLocked(linkAddr tcpip.LinkAddress, fla
}
e.dispatchChangeEventLocked()
e.mu.isRouter = flags.IsRouter
e.notifyCompletionLocked(true /* succeeded */)
e.notifyCompletionLocked(nil)
// "Note that the Override flag is ignored if the entry is in the
// INCOMPLETE state." - RFC 4861 section 7.2.5
@ -539,7 +544,7 @@ func (e *neighborEntry) handleConfirmationLocked(linkAddr tcpip.LinkAddress, fla
wasReachable := e.mu.neigh.State == Reachable
// Set state to Reachable again to refresh timers.
e.setStateLocked(Reachable)
e.notifyCompletionLocked(true /* succeeded */)
e.notifyCompletionLocked(nil)
if !wasReachable {
e.dispatchChangeEventLocked()
}

2
pkg/tcpip/stack/nic.go
View File

@ -613,7 +613,7 @@ func (n *nic) getLinkAddress(addr, localAddr tcpip.Address, protocol tcpip.Netwo
}
if linkAddr, ok := linkRes.resolver.ResolveStaticAddress(addr); ok {
onResolve(LinkResolutionResult{LinkAddress: linkAddr, Success: true})
onResolve(LinkResolutionResult{LinkAddress: linkAddr, Err: nil})
return nil
}

12
pkg/tcpip/stack/pending_packets.go
View File

@ -91,9 +91,9 @@ func (f *packetsPendingLinkResolution) init(nic *nic) {
// dequeue any pending packets associated with ch.
//
// If success is true, packets will be written and sent to the given remote link
// If err is nil, packets will be written and sent to the given remote link
// address.
func (f *packetsPendingLinkResolution) dequeue(ch <-chan struct{}, linkAddr tcpip.LinkAddress, success bool) {
func (f *packetsPendingLinkResolution) dequeue(ch <-chan struct{}, linkAddr tcpip.LinkAddress, err tcpip.Error) {
f.mu.Lock()
packets, ok := f.mu.packets[ch]
delete(f.mu.packets, ch)
@ -110,7 +110,7 @@ func (f *packetsPendingLinkResolution) dequeue(ch <-chan struct{}, linkAddr tcpi
f.mu.Unlock()
if ok {
f.dequeuePackets(packets, linkAddr, success)
f.dequeuePackets(packets, linkAddr, err)
}
}
@ -176,7 +176,7 @@ func (f *packetsPendingLinkResolution) enqueue(r *Route, gso *GSO, proto tcpip.N
if len(cancelledPackets) != 0 {
// Dequeue the pending packets in a new goroutine to not hold up the current
// goroutine as handing link resolution failures may be a costly operation.
go f.dequeuePackets(cancelledPackets, "" /* linkAddr */, false /* success */)
go f.dequeuePackets(cancelledPackets, "" /* linkAddr */, &tcpip.ErrAborted{})
}
return pkt.len(), nil
@ -207,9 +207,9 @@ func (f *packetsPendingLinkResolution) newCancelChannelLocked(newCH <-chan struc
return packets
}
func (f *packetsPendingLinkResolution) dequeuePackets(packets []pendingPacket, linkAddr tcpip.LinkAddress, success bool) {
func (f *packetsPendingLinkResolution) dequeuePackets(packets []pendingPacket, linkAddr tcpip.LinkAddress, err tcpip.Error) {
for _, p := range packets {
if success {
if err == nil {
p.routeInfo.RemoteLinkAddress = linkAddr
_, _ = f.nic.writePacketBuffer(p.routeInfo, p.gso, p.proto, p.pkt)
} else {

8
pkg/tcpip/stack/route.go
View File

@ -318,7 +318,7 @@ func (r *Route) ResolveWith(addr tcpip.LinkAddress) {
// ResolvedFieldsResult is the result of a route resolution attempt.
type ResolvedFieldsResult struct {
RouteInfo RouteInfo
Success bool
Err tcpip.Error
}
// ResolvedFields attempts to resolve the remote link address if it is not
@ -349,7 +349,7 @@ func (r *Route) resolvedFields(afterResolve func(ResolvedFieldsResult)) (RouteIn
r.mu.RUnlock()
if !resolutionRequired {
if afterResolve != nil {
afterResolve(ResolvedFieldsResult{RouteInfo: fields, Success: true})
afterResolve(ResolvedFieldsResult{RouteInfo: fields, Err: nil})
}
return fields, nil, nil
}
@ -364,11 +364,11 @@ func (r *Route) resolvedFields(afterResolve func(ResolvedFieldsResult)) (RouteIn
afterResolveFields := fields
linkAddr, ch, err := r.linkRes.getNeighborLinkAddress(r.nextHop(), linkAddressResolutionRequestLocalAddr, func(r LinkResolutionResult) {
if afterResolve != nil {
if r.Success {
if r.Err == nil {
afterResolveFields.RemoteLinkAddress = r.LinkAddress
}
afterResolve(ResolvedFieldsResult{RouteInfo: afterResolveFields, Success: r.Success})
afterResolve(ResolvedFieldsResult{RouteInfo: afterResolveFields, Err: r.Err})
}
})
if err == nil {

2
pkg/tcpip/stack/stack.go
View File

@ -1542,7 +1542,7 @@ func (s *Stack) SetSpoofing(nicID tcpip.NICID, enable bool) tcpip.Error {
// LinkResolutionResult is the result of a link address resolution attempt.
type LinkResolutionResult struct {
LinkAddress tcpip.LinkAddress
Success bool
Err tcpip.Error
}
// GetLinkAddress finds the link address corresponding to a network address.

2
pkg/tcpip/stack/stack_test.go
View File

@ -4455,7 +4455,7 @@ func TestStaticGetLinkAddress(t *testing.T) {
t.Fatalf("s.GetLinkAddress(%d, %s, '', %d, _): %s", nicID, test.addr, test.proto, err)
}
if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: test.expectedLinkAddr, Success: true}, <-ch); diff != "" {
if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: test.expectedLinkAddr, Err: nil}, <-ch); diff != "" {
t.Fatalf("link resolution result mismatch (-want +got):\n%s", diff)
}
})

86
pkg/tcpip/tests/integration/link_resolution_test.go
View File

@ -402,34 +402,48 @@ func TestGetLinkAddress(t *testing.T) {
)
tests := []struct {
name string
netProto tcpip.NetworkProtocolNumber
remoteAddr tcpip.Address
expectedOk bool
name string
netProto tcpip.NetworkProtocolNumber
remoteAddr, localAddr tcpip.Address
expectedErr tcpip.Error
}{
{
name: "IPv4 resolvable",
netProto: ipv4.ProtocolNumber,
remoteAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
expectedOk: true,
name: "IPv4 resolvable",
netProto: ipv4.ProtocolNumber,
remoteAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
expectedErr: nil,
},
{
name: "IPv6 resolvable",
netProto: ipv6.ProtocolNumber,
remoteAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
expectedOk: true,
name: "IPv6 resolvable",
netProto: ipv6.ProtocolNumber,
remoteAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
expectedErr: nil,
},
{
name: "IPv4 not resolvable",
netProto: ipv4.ProtocolNumber,
remoteAddr: utils.Ipv4Addr3.AddressWithPrefix.Address,
expectedOk: false,
name: "IPv4 not resolvable",
netProto: ipv4.ProtocolNumber,
remoteAddr: utils.Ipv4Addr3.AddressWithPrefix.Address,
expectedErr: &tcpip.ErrTimeout{},
},
{
name: "IPv6 not resolvable",
netProto: ipv6.ProtocolNumber,
remoteAddr: utils.Ipv6Addr3.AddressWithPrefix.Address,
expectedOk: false,
name: "IPv6 not resolvable",
netProto: ipv6.ProtocolNumber,
remoteAddr: utils.Ipv6Addr3.AddressWithPrefix.Address,
expectedErr: &tcpip.ErrTimeout{},
},
{
name: "IPv4 bad local address",
netProto: ipv4.ProtocolNumber,
remoteAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
localAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
expectedErr: &tcpip.ErrBadLocalAddress{},
},
{
name: "IPv6 bad local address",
netProto: ipv6.ProtocolNumber,
remoteAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
localAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
expectedErr: &tcpip.ErrBadLocalAddress{},
},
}
@ -442,14 +456,14 @@ func TestGetLinkAddress(t *testing.T) {
host1Stack, _ := setupStack(t, stackOpts, host1NICID, host2NICID)
ch := make(chan stack.LinkResolutionResult, 1)
err := host1Stack.GetLinkAddress(host1NICID, test.remoteAddr, "", test.netProto, func(r stack.LinkResolutionResult) {
err := host1Stack.GetLinkAddress(host1NICID, test.remoteAddr, test.localAddr, test.netProto, func(r stack.LinkResolutionResult) {
ch <- r
})
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 {
wantRes := stack.LinkResolutionResult{Err: test.expectedErr}
if test.expectedErr == nil {
wantRes.LinkAddress = utils.LinkAddr2
}
if diff := cmp.Diff(wantRes, <-ch); diff != "" {
@ -471,7 +485,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr tcpip.Address
remoteAddr tcpip.Address
immediatelyResolvable bool
expectedSuccess bool
expectedErr tcpip.Error
expectedLinkAddr tcpip.LinkAddress
}{
{
@ -480,7 +494,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr: utils.Ipv4Addr1.AddressWithPrefix.Address,
remoteAddr: header.IPv4AllSystems,
immediatelyResolvable: true,
expectedSuccess: true,
expectedErr: nil,
expectedLinkAddr: header.EthernetAddressFromMulticastIPv4Address(header.IPv4AllSystems),
},
{
@ -489,7 +503,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr: utils.Ipv6Addr1.AddressWithPrefix.Address,
remoteAddr: header.IPv6AllNodesMulticastAddress,
immediatelyResolvable: true,
expectedSuccess: true,
expectedErr: nil,
expectedLinkAddr: header.EthernetAddressFromMulticastIPv6Address(header.IPv6AllNodesMulticastAddress),
},
{
@ -498,7 +512,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr: utils.Ipv4Addr1.AddressWithPrefix.Address,
remoteAddr: utils.Ipv4Addr2.AddressWithPrefix.Address,
immediatelyResolvable: false,
expectedSuccess: true,
expectedErr: nil,
expectedLinkAddr: utils.LinkAddr2,
},
{
@ -507,7 +521,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr: utils.Ipv6Addr1.AddressWithPrefix.Address,
remoteAddr: utils.Ipv6Addr2.AddressWithPrefix.Address,
immediatelyResolvable: false,
expectedSuccess: true,
expectedErr: nil,
expectedLinkAddr: utils.LinkAddr2,
},
{
@ -516,7 +530,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr: utils.Ipv4Addr1.AddressWithPrefix.Address,
remoteAddr: utils.Ipv4Addr3.AddressWithPrefix.Address,
immediatelyResolvable: false,
expectedSuccess: false,
expectedErr: &tcpip.ErrTimeout{},
},
{
name: "IPv6 not resolvable",
@ -524,7 +538,7 @@ func TestRouteResolvedFields(t *testing.T) {
localAddr: utils.Ipv6Addr1.AddressWithPrefix.Address,
remoteAddr: utils.Ipv6Addr3.AddressWithPrefix.Address,
immediatelyResolvable: false,
expectedSuccess: false,
expectedErr: &tcpip.ErrTimeout{},
},
}
@ -535,9 +549,9 @@ func TestRouteResolvedFields(t *testing.T) {
}
host1Stack, _ := setupStack(t, stackOpts, host1NICID, host2NICID)
r, err := host1Stack.FindRoute(host1NICID, "", test.remoteAddr, test.netProto, false /* multicastLoop */)
r, err := host1Stack.FindRoute(host1NICID, test.localAddr, test.remoteAddr, test.netProto, false /* multicastLoop */)
if err != nil {
t.Fatalf("host1Stack.FindRoute(%d, '', %s, %d, false): %s", host1NICID, test.remoteAddr, test.netProto, err)
t.Fatalf("host1Stack.FindRoute(%d, %s, %s, %d, false): %s", host1NICID, test.localAddr, test.remoteAddr, test.netProto, err)
}
defer r.Release()
@ -561,11 +575,11 @@ func TestRouteResolvedFields(t *testing.T) {
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 != "" {
if diff := cmp.Diff(stack.ResolvedFieldsResult{RouteInfo: wantRouteInfo, Err: test.expectedErr}, <-ch, cmp.AllowUnexported(stack.RouteInfo{})); diff != "" {
t.Errorf("route resolve result mismatch (-want +got):\n%s", diff)
}
if !test.expectedSuccess {
if test.expectedErr != nil {
return
}
@ -580,7 +594,7 @@ func TestRouteResolvedFields(t *testing.T) {
}
select {
case routeResolveRes := <-ch:
if diff := cmp.Diff(stack.ResolvedFieldsResult{RouteInfo: wantRouteInfo, Success: true}, routeResolveRes, cmp.AllowUnexported(stack.RouteInfo{})); diff != "" {
if diff := cmp.Diff(stack.ResolvedFieldsResult{RouteInfo: wantRouteInfo, Err: nil}, routeResolveRes, cmp.AllowUnexported(stack.RouteInfo{})); diff != "" {
t.Errorf("route resolve result from resolved route mismatch (-want +got):\n%s", diff)
}
default:
@ -1021,7 +1035,7 @@ func TestTCPConfirmNeighborReachability(t *testing.T) {
if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
t.Fatalf("got host1Stack.GetLinkAddress(%d, %s, '', %d, _) = %s, want = %s", utils.Host1NICID, test.neighborAddr, test.netProto, err, &tcpip.ErrWouldBlock{})
}
if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: utils.LinkAddr2, Success: true}, <-ch); diff != "" {
if diff := cmp.Diff(stack.LinkResolutionResult{LinkAddress: utils.LinkAddr2, Err: nil}, <-ch); diff != "" {
t.Fatalf("link resolution mismatch (-want +got):\n%s", diff)
}
}