Don't pass route info and net proto to write fns

...as the packet buffer already holds that information.

Updates #3810.
Fixes #6537.

PiperOrigin-RevId: 421898143

pkg/tcpip/link/channel/channel.go

@@ -240,7 +240,7 @@ func (e *Endpoint) LinkAddress() tcpip.LinkAddress {
 }
 
 // WritePackets stores outbound packets into the channel.
-func (e *Endpoint) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, _ tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *Endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	n := 0
 	for pkt := pkts.Front(); pkt != nil; pkt = pkt.Next() {
 		if !e.q.Write(pkt) {

pkg/tcpip/link/ethernet/ethernet.go

@@ -81,14 +81,14 @@ func (e *Endpoint) Capabilities() stack.LinkEndpointCapabilities {
 }
 
 // WritePackets implements stack.LinkEndpoint.
-func (e *Endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, proto tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *Endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	linkAddr := e.LinkAddress()
 
 	for pkt := pkts.Front(); pkt != nil; pkt = pkt.Next() {
 		e.AddHeader(linkAddr, pkt.EgressRoute.RemoteLinkAddress, pkt.NetworkProtocolNumber, pkt)
 	}
 
-	return e.Endpoint.WritePackets(r, pkts, proto)
+	return e.Endpoint.WritePackets(pkts)
 }
 
 // MaxHeaderLength implements stack.LinkEndpoint.

pkg/tcpip/link/ethernet/ethernet_test.go

@@ -140,10 +140,10 @@ func TestWritePacketsAddHeader(t *testing.T) {
 
 		var pkts stack.PacketBufferList
 		pkts.PushFront(pkt)
-		if n, err := e.WritePackets(stack.RouteInfo{}, pkts, 0 /* protocol */); err != nil {
-			t.Fatalf("e.WritePackets({}, _, 0): %s", err)
+		if n, err := e.WritePackets(pkts); err != nil {
+			t.Fatalf("e.WritePackets(_): %s", err)
 		} else if n != 1 {
-			t.Fatalf("got e.WritePackets({}, _, 0) = %d, want = 1", n)
+			t.Fatalf("got e.WritePackets(_) = %d, want = 1", n)
 		}
 	}
 

pkg/tcpip/link/fdbased/endpoint.go

@@ -668,7 +668,7 @@ func (e *endpoint) sendBatch(batchFD int, pkts []*stack.PacketBuffer) (int, tcpi
 //  - pkt.EgressRoute
 //  - pkt.GSOOptions
 //  - pkt.NetworkProtocolNumber
-func (e *endpoint) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, _ tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	// Preallocate to avoid repeated reallocation as we append to batch.
 	// batchSz is 47 because when SWGSO is in use then a single 65KB TCP
 	// segment can get split into 46 segments of 1420 bytes and a single 216

pkg/tcpip/link/fdbased/endpoint_test.go

@@ -224,8 +224,8 @@ func testWritePacket(t *testing.T, plen int, eth bool, gsoMaxSize uint32, hash u
 	}
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	if _, err := c.ep.WritePackets(r, pkts, proto); err != nil {
-		t.Fatalf("WritePacket failed: %v", err)
+	if _, err := c.ep.WritePackets(pkts); err != nil {
+		t.Fatalf("WritePackets failed: %s", err)
 	}
 
 	// Read from the corresponding FD, then compare with what we wrote.
@@ -345,8 +345,8 @@ func TestPreserveSrcAddress(t *testing.T) {
 	pkt.EgressRoute = r
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	if _, err := c.ep.WritePackets(r, pkts, proto); err != nil {
-		t.Fatalf("WritePacket failed: %v", err)
+	if _, err := c.ep.WritePackets(pkts); err != nil {
+		t.Fatalf("WritePackets failed: %s", err)
 	}
 
 	// Read from the FD, then compare with what we wrote.

pkg/tcpip/link/loopback/loopback.go

@@ -75,7 +75,7 @@ func (*endpoint) LinkAddress() tcpip.LinkAddress {
 func (*endpoint) Wait() {}
 
 // WritePackets implements stack.LinkEndpoint.WritePackets.
-func (e *endpoint) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, _ tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	n := 0
 	for p := pkts.Front(); p != nil; p = p.Next() {
 		if err := e.WriteRawPacket(p); err != nil {

pkg/tcpip/link/muxed/injectable.go

@@ -86,13 +86,30 @@ func (m *InjectableEndpoint) InjectInbound(protocol tcpip.NetworkProtocolNumber,
 
 // WritePackets writes outbound packets to the appropriate
 // LinkInjectableEndpoint based on the RemoteAddress. HandleLocal only works if
-// r.RemoteAddress has a route registered in this endpoint.
-func (m *InjectableEndpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
-	endpoint, ok := m.routes[r.RemoteAddress]
-	if !ok {
-		return 0, &tcpip.ErrNoRoute{}
+// pkt.EgressRoute.RemoteAddress has a route registered in this endpoint.
+func (m *InjectableEndpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
+	i := 0
+	for pkt := pkts.Front(); pkt != nil; {
+		nextPkt := pkt.Next()
+
+		endpoint, ok := m.routes[pkt.EgressRoute.RemoteAddress]
+		if !ok {
+			return i, &tcpip.ErrNoRoute{}
+		}
+
+		var tmpPkts stack.PacketBufferList
+		tmpPkts.PushFront(pkt)
+
+		n, err := endpoint.WritePackets(tmpPkts)
+		if err != nil {
+			return i, err
+		}
+
+		i += n
+		pkt = nextPkt
 	}
-	return endpoint.WritePackets(r, pkts, protocol)
+
+	return i, nil
 }
 
 // InjectOutbound writes outbound packets to the appropriate

pkg/tcpip/link/muxed/injectable_test.go

@@ -51,12 +51,12 @@ func TestInjectableEndpointDispatch(t *testing.T) {
 		Data:               buffer.NewViewFromBytes([]byte{0xFB}).ToVectorisedView(),
 	})
 	pkt.TransportHeader().Push(1)[0] = 0xFA
-	var packetRoute stack.RouteInfo
-	packetRoute.RemoteAddress = dstIP
+	pkt.EgressRoute.RemoteAddress = dstIP
+	pkt.NetworkProtocolNumber = ipv4.ProtocolNumber
 
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	if _, err := endpoint.WritePackets(packetRoute, pkts, ipv4.ProtocolNumber); err != nil {
+	if _, err := endpoint.WritePackets(pkts); err != nil {
 		t.Fatalf("Unable to write packets: %s", err)
 	}
 
@@ -78,12 +78,12 @@ func TestInjectableEndpointDispatchHdrOnly(t *testing.T) {
 		Data:               buffer.NewView(0).ToVectorisedView(),
 	})
 	pkt.TransportHeader().Push(1)[0] = 0xFA
-	var packetRoute stack.RouteInfo
-	packetRoute.RemoteAddress = dstIP
+	pkt.EgressRoute.RemoteAddress = dstIP
+	pkt.NetworkProtocolNumber = ipv4.ProtocolNumber
 
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	if _, err := endpoint.WritePackets(packetRoute, pkts, ipv4.ProtocolNumber); err != nil {
+	if _, err := endpoint.WritePackets(pkts); err != nil {
 		t.Fatalf("Unable to write packets: %s", err)
 	}
 	buf := make([]byte, 6500)

pkg/tcpip/link/nested/nested.go

@@ -103,8 +103,8 @@ func (e *Endpoint) LinkAddress() tcpip.LinkAddress {
 }
 
 // WritePackets implements stack.LinkEndpoint.
-func (e *Endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
-	return e.child.WritePackets(r, pkts, protocol)
+func (e *Endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
+	return e.child.WritePackets(pkts)
 }
 
 // Wait implements stack.LinkEndpoint.

pkg/tcpip/link/pipe/pipe.go

@@ -48,7 +48,7 @@ type Endpoint struct {
 	mtu        uint32
 }
 
-func (e *Endpoint) deliverPackets(r stack.RouteInfo, proto tcpip.NetworkProtocolNumber, pkts stack.PacketBufferList) {
+func (e *Endpoint) deliverPackets(pkts stack.PacketBufferList) {
 	if !e.linked.IsAttached() {
 		return
 	}
@@ -65,15 +65,16 @@ func (e *Endpoint) deliverPackets(r stack.RouteInfo, proto tcpip.NetworkProtocol
 		newPkt := stack.NewPacketBuffer(stack.PacketBufferOptions{
 			Data: buffer.NewVectorisedView(pkt.Size(), pkt.Views()),
 		})
-		e.linked.dispatcher.DeliverNetworkPacket(r.LocalLinkAddress /* remote */, r.RemoteLinkAddress /* local */, proto, newPkt)
+		r := pkt.EgressRoute
+		e.linked.dispatcher.DeliverNetworkPacket(r.LocalLinkAddress /* remote */, r.RemoteLinkAddress /* local */, pkt.NetworkProtocolNumber, newPkt)
 		newPkt.DecRef()
 	}
 }
 
 // WritePackets implements stack.LinkEndpoint.
-func (e *Endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, proto tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *Endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	n := pkts.Len()
-	e.deliverPackets(r, proto, pkts)
+	e.deliverPackets(pkts)
 	return n, nil
 }
 
@@ -123,6 +124,6 @@ func (*Endpoint) AddHeader(_, _ tcpip.LinkAddress, _ tcpip.NetworkProtocolNumber
 func (e *Endpoint) WriteRawPacket(pkt *stack.PacketBuffer) tcpip.Error {
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	_, err := e.WritePackets(stack.RouteInfo{}, pkts, 0)
+	_, err := e.WritePackets(pkts)
 	return err
 }

pkg/tcpip/link/qdisc/fifo/fifo.go

@@ -96,15 +96,14 @@ func (qd *queueDispatcher) dispatchLoop() {
 			if pkt == nil {
 				break
 			}
+
 			qd.queue.Remove(pkt)
 			qd.used--
 			batch.PushBack(pkt)
 		}
 		qd.mu.Unlock()
 
-		// We pass a protocol of zero here because each packet carries its
-		// NetworkProtocol.
-		_, _ = qd.lower.WritePackets(stack.RouteInfo{}, batch, 0 /* protocol */)
+		_, _ = qd.lower.WritePackets(batch)
 		batch.DecRef()
 		batch.Reset()
 	}
@@ -116,7 +115,7 @@ func (qd *queueDispatcher) dispatchLoop() {
 //  - pkt.EgressRoute
 //  - pkt.GSOOptions
 //  - pkt.NetworkProtocolNumber
-func (d *discipline) WritePacket(_ stack.RouteInfo, _ tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
+func (d *discipline) WritePacket(pkt *stack.PacketBuffer) tcpip.Error {
 	qd := &d.dispatchers[int(pkt.Hash)%len(d.dispatchers)]
 	qd.mu.Lock()
 	haveSpace := qd.used < qd.limit

pkg/tcpip/link/qdisc/fifo/qdisc_test.go

@@ -31,7 +31,7 @@ var _ stack.LinkWriter = (*discardWriter)(nil)
 type discardWriter struct {
 }
 
-func (*discardWriter) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, _ tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (*discardWriter) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	return pkts.Len(), nil
 }
 
@@ -43,9 +43,6 @@ func TestFastSimultaneousWrites(t *testing.T) {
 
 	v := make(buffer.View, 1)
 
-	prot := tcpip.NetworkProtocolNumber(0)
-	r := stack.RouteInfo{}
-
 	// Simulate many simultaneous writes from various goroutines, similar to TCP's sendTCPBatch().
 	nWriters := 100
 	nWrites := 100
@@ -60,7 +57,7 @@ func TestFastSimultaneousWrites(t *testing.T) {
 					Data: v.ToVectorisedView(),
 				})
 				pkt.Hash = rand.Uint32()
-				linkEP.WritePacket(r, prot, pkt)
+				linkEP.WritePacket(pkt)
 				pkt.DecRef()
 			}
 		}()

pkg/tcpip/link/sharedmem/sharedmem.go

@@ -364,7 +364,7 @@ func (e *endpoint) writePacketLocked(r stack.RouteInfo, protocol tcpip.NetworkPr
 }
 
 // WritePackets implements stack.LinkEndpoint.WritePackets.
-func (e *endpoint) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	n := 0
 	var err tcpip.Error
 	e.mu.Lock()

pkg/tcpip/link/sharedmem/sharedmem_server.go

@@ -274,7 +274,7 @@ func (e *serverEndpoint) WritePacket(_ stack.RouteInfo, _ tcpip.NetworkProtocolN
 }
 
 // WritePackets implements stack.LinkEndpoint.WritePackets.
-func (e *serverEndpoint) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *serverEndpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	n := 0
 	var err tcpip.Error
 	e.mu.Lock()

pkg/tcpip/link/sharedmem/sharedmem_test.go

@@ -235,7 +235,7 @@ func TestSimpleSend(t *testing.T) {
 			pkt.NetworkProtocolNumber = proto
 			var pkts stack.PacketBufferList
 			pkts.PushBack(pkt)
-			if _, err := c.ep.WritePackets(r, pkts, proto); err != nil {
+			if _, err := c.ep.WritePackets(pkts); err != nil {
 				t.Fatalf("WritePackets failed: %s", err)
 			}
 
@@ -311,7 +311,7 @@ func TestPreserveSrcAddressInSend(t *testing.T) {
 
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	if _, err := c.ep.WritePackets(r, pkts, proto); err != nil {
+	if _, err := c.ep.WritePackets(pkts); err != nil {
 		t.Fatalf("WritePackets failed: %s", err)
 	}
 
@@ -366,10 +366,12 @@ func TestFillTxQueue(t *testing.T) {
 			ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 			Data:               buf.ToVectorisedView(),
 		})
+		pkt.EgressRoute = r
+		pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 
 		var pkts stack.PacketBufferList
 		pkts.PushBack(pkt)
-		if _, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber); err != nil {
+		if _, err := c.ep.WritePackets(pkts); err != nil {
 			t.Fatalf("WritePackets failed unexpectedly: %s", err)
 		}
 
@@ -387,9 +389,12 @@ func TestFillTxQueue(t *testing.T) {
 		ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 		Data:               buf.ToVectorisedView(),
 	})
+	pkt.EgressRoute = r
+	pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
+
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	_, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber)
+	_, err := c.ep.WritePackets(pkts)
 	if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
 		t.Fatalf("got WritePackets(...) = %s, want %s", err, &tcpip.ErrWouldBlock{})
 	}
@@ -420,8 +425,10 @@ func TestFillTxQueueAfterBadCompletion(t *testing.T) {
 				Data:               buf.ToVectorisedView(),
 			})
 			pkts.PushBack(pkt)
+			pkt.EgressRoute = r
+			pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 		}
-		if _, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber); err != nil {
+		if _, err := c.ep.WritePackets(pkts); err != nil {
 			t.Fatalf("WritePackets failed unexpectedly: %s", err)
 		}
 	}
@@ -444,9 +451,11 @@ func TestFillTxQueueAfterBadCompletion(t *testing.T) {
 			ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 			Data:               buf.ToVectorisedView(),
 		})
+		pkt.EgressRoute = r
+		pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 		var pkts stack.PacketBufferList
 		pkts.PushBack(pkt)
-		if _, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber); err != nil {
+		if _, err := c.ep.WritePackets(pkts); err != nil {
 			t.Fatalf("WritePackets failed unexpectedly: %s", err)
 		}
 
@@ -464,9 +473,11 @@ func TestFillTxQueueAfterBadCompletion(t *testing.T) {
 		ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 		Data:               buf.ToVectorisedView(),
 	})
+	pkt.EgressRoute = r
+	pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	_, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber)
+	_, err := c.ep.WritePackets(pkts)
 	if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
 		t.Fatalf("got WritePackets(...) = %s, want %s", err, &tcpip.ErrWouldBlock{})
 	}
@@ -492,9 +503,11 @@ func TestFillTxMemory(t *testing.T) {
 			ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 			Data:               buf.ToVectorisedView(),
 		})
+		pkt.EgressRoute = r
+		pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 		var pkts stack.PacketBufferList
 		pkts.PushBack(pkt)
-		if _, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber); err != nil {
+		if _, err := c.ep.WritePackets(pkts); err != nil {
 			t.Fatalf("WritePackets failed unexpectedly: %s", err)
 		}
 
@@ -513,9 +526,11 @@ func TestFillTxMemory(t *testing.T) {
 		ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 		Data:               buf.ToVectorisedView(),
 	})
+	pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
+	pkt.EgressRoute = r
 	var pkts stack.PacketBufferList
 	pkts.PushBack(pkt)
-	_, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber)
+	_, err := c.ep.WritePackets(pkts)
 	if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
 		t.Fatalf("got WritePackets(...) = %s, want %s", err, &tcpip.ErrWouldBlock{})
 	}
@@ -543,8 +558,10 @@ func TestFillTxMemoryWithMultiBuffer(t *testing.T) {
 			Data:               buf.ToVectorisedView(),
 		})
 		var pkts stack.PacketBufferList
+		pkt.EgressRoute = r
+		pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 		pkts.PushBack(pkt)
-		if _, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber); err != nil {
+		if _, err := c.ep.WritePackets(pkts); err != nil {
 			t.Fatalf("WritePackets failed unexpectedly: %s", err)
 		}
 
@@ -560,8 +577,10 @@ func TestFillTxMemoryWithMultiBuffer(t *testing.T) {
 			ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 			Data:               buffer.NewView(bufferSize).ToVectorisedView(),
 		})
+		pkt.EgressRoute = r
+		pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 		pkts.PushBack(pkt)
-		_, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber)
+		_, err := c.ep.WritePackets(pkts)
 		if _, ok := err.(*tcpip.ErrWouldBlock); !ok {
 			t.Fatalf("got WritePackets(...) = %s, want %s", err, &tcpip.ErrWouldBlock{})
 		}
@@ -574,8 +593,10 @@ func TestFillTxMemoryWithMultiBuffer(t *testing.T) {
 			ReserveHeaderBytes: int(c.ep.MaxHeaderLength()),
 			Data:               buf.ToVectorisedView(),
 		})
+		pkt.EgressRoute = r
+		pkt.NetworkProtocolNumber = header.IPv4ProtocolNumber
 		pkts.PushBack(pkt)
-		if _, err := c.ep.WritePackets(r, pkts, header.IPv4ProtocolNumber); err != nil {
+		if _, err := c.ep.WritePackets(pkts); err != nil {
 			t.Fatalf("WritePackets failed unexpectedly: %s", err)
 		}
 	}

pkg/tcpip/link/sniffer/sniffer.go

@@ -164,11 +164,11 @@ func (e *endpoint) dumpPacket(dir direction, protocol tcpip.NetworkProtocolNumbe
 // WritePackets implements the stack.LinkEndpoint interface. It is called by
 // higher-level protocols to write packets; it just logs the packet and
 // forwards the request to the lower endpoint.
-func (e *endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	for pkt := pkts.Front(); pkt != nil; pkt = pkt.Next() {
 		e.dumpPacket(directionSend, pkt.NetworkProtocolNumber, pkt)
 	}
-	return e.Endpoint.WritePackets(r, pkts, protocol)
+	return e.Endpoint.WritePackets(pkts)
 }
 
 func logPacket(prefix string, dir direction, protocol tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) {

pkg/tcpip/link/waitable/waitable.go

@@ -99,12 +99,12 @@ func (e *Endpoint) LinkAddress() tcpip.LinkAddress {
 // WritePackets implements stack.LinkEndpoint.WritePackets. It is called by
 // higher-level protocols to write packets. It only forwards packets to the
 // lower endpoint if Wait or WaitWrite haven't been called.
-func (e *Endpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *Endpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	if !e.writeGate.Enter() {
 		return pkts.Len(), nil
 	}
 
-	n, err := e.lower.WritePackets(r, pkts, protocol)
+	n, err := e.lower.WritePackets(pkts)
 	e.writeGate.Leave()
 	return n, err
 }

pkg/tcpip/link/waitable/waitable_test.go

@@ -72,7 +72,7 @@ func (e *countedEndpoint) LinkAddress() tcpip.LinkAddress {
 }
 
 // WritePackets implements stack.LinkEndpoint.WritePackets.
-func (e *countedEndpoint) WritePackets(_ stack.RouteInfo, pkts stack.PacketBufferList, _ tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *countedEndpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	e.writeCount += pkts.Len()
 	return pkts.Len(), nil
 }
@@ -102,7 +102,11 @@ func TestWaitWrite(t *testing.T) {
 		var pkts stack.PacketBufferList
 		pkts.PushBack(stack.NewPacketBuffer(stack.PacketBufferOptions{}))
 		// Write and check that it goes through.
-		wep.WritePackets(stack.RouteInfo{}, pkts, 0)
+		if n, err := wep.WritePackets(pkts); err != nil {
+			t.Fatalf("WritePackets(_): %s", err)
+		} else if n != 1 {
+			t.Fatalf("got WritePackets(_) = %d, want = 1", n)
+		}
 		if want := 1; ep.writeCount != want {
 			t.Fatalf("Unexpected writeCount: got=%v, want=%v", ep.writeCount, want)
 		}
@@ -112,7 +116,11 @@ func TestWaitWrite(t *testing.T) {
 		pkts.PushBack(stack.NewPacketBuffer(stack.PacketBufferOptions{}))
 		// Wait on dispatches, then try to write. It must go through.
 		wep.WaitDispatch()
-		wep.WritePackets(stack.RouteInfo{}, pkts, 0)
+		if n, err := wep.WritePackets(pkts); err != nil {
+			t.Fatalf("WritePackets(_): %s", err)
+		} else if n != 1 {
+			t.Fatalf("got WritePackets(_) = %d, want = 1", n)
+		}
 		if want := 2; ep.writeCount != want {
 			t.Fatalf("Unexpected writeCount: got=%v, want=%v", ep.writeCount, want)
 		}
@@ -123,7 +131,11 @@ func TestWaitWrite(t *testing.T) {
 		pkts.PushBack(stack.NewPacketBuffer(stack.PacketBufferOptions{}))
 		// Wait on writes, then try to write. It must not go through.
 		wep.WaitWrite()
-		wep.WritePackets(stack.RouteInfo{}, pkts, 0)
+		if n, err := wep.WritePackets(pkts); err != nil {
+			t.Fatalf("WritePackets(_): %s", err)
+		} else if n != 1 {
+			t.Fatalf("got WritePackets(_) = %d, want = 1", n)
+		}
 		if want := 2; ep.writeCount != want {
 			t.Fatalf("Unexpected writeCount: got=%v, want=%v", ep.writeCount, want)
 		}

pkg/tcpip/network/arp/arp.go

@@ -218,7 +218,7 @@ func (e *endpoint) HandlePacket(pkt *stack.PacketBuffer) {
 		//
 		//   Send the packet to the (new) target hardware address on the same
 		//   hardware on which the request was received.
-		if err := e.nic.WritePacketToRemote(tcpip.LinkAddress(origSender), ProtocolNumber, respPkt); err != nil {
+		if err := e.nic.WritePacketToRemote(tcpip.LinkAddress(origSender), respPkt); err != nil {
 			stats.outgoingRepliesDropped.Increment()
 		} else {
 			stats.outgoingRepliesSent.Increment()
@@ -351,7 +351,7 @@ func (e *endpoint) sendARPRequest(localAddr, targetAddr tcpip.Address, remoteLin
 	}
 
 	stats := e.stats.arp
-	if err := e.nic.WritePacketToRemote(remoteLinkAddr, ProtocolNumber, pkt); err != nil {
+	if err := e.nic.WritePacketToRemote(remoteLinkAddr, pkt); err != nil {
 		stats.outgoingRequestsDropped.Increment()
 		return err
 	}

pkg/tcpip/network/arp/arp_test.go

@@ -420,12 +420,12 @@ type testLinkEndpoint struct {
 	writeErr tcpip.Error
 }
 
-func (t *testLinkEndpoint) WritePackets(r stack.RouteInfo, pkts stack.PacketBufferList, protocol tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (t *testLinkEndpoint) WritePackets(pkts stack.PacketBufferList) (int, tcpip.Error) {
 	if t.writeErr != nil {
 		return 0, t.writeErr
 	}
 
-	return t.LinkEndpoint.WritePackets(r, pkts, protocol)
+	return t.LinkEndpoint.WritePackets(pkts)
 }
 
 func TestLinkAddressRequest(t *testing.T) {