netstack: Refactor tcpip.Endpoint.Read

Read now takes a destination io.Writer, count, options. Keeping the method name
Read, in contrast to the Write method.

This enables:
* direct transfer of views under VV
* zero copy

It also eliminates the need for sentry to keep a slice of view because
userspace had requested a read that is smaller than the view returned, removing
the complexity there.

Read/Peek/ReadPacket are now consolidated together and some duplicate code is
removed.

PiperOrigin-RevId: 350636322

2 files changed, 38 insertions, 16 deletions

diff --git a/pkg/tcpip/network/ipv4/ipv4_test.go b/pkg/tcpip/network/ipv4/ipv4_test.go
index ef62fe6fc..1c4919b1e 100644
--- a/pkg/tcpip/network/ipv4/ipv4_test.go
+++ b/pkg/tcpip/network/ipv4/ipv4_test.go
@@ -15,9 +15,11 @@
 package ipv4_test
 
 import (
+	"bytes"
 	"context"
 	"encoding/hex"
 	"fmt"
+	"io/ioutil"
 	"math"
 	"net"
 	"testing"
@@ -2408,18 +2410,26 @@ func TestReceiveFragments(t *testing.T) {
 				t.Errorf("got UDP Rx Packets = %d, want = %d", got, want)
 			}
 
+			const rcvSize = 65536 // Account for reassembled packets.
 			for i, expectedPayload := range test.expectedPayloads {
-				gotPayload, _, err := ep.Read(nil)
+				var buf bytes.Buffer
+				result, err := ep.Read(&buf, rcvSize, tcpip.ReadOptions{})
 				if err != nil {
-					t.Fatalf("(i=%d) Read(nil): %s", i, err)
+					t.Fatalf("(i=%d) Read: %s", i, err)
 				}
-				if diff := cmp.Diff(buffer.View(expectedPayload), gotPayload); diff != "" {
+				if diff := cmp.Diff(tcpip.ReadResult{
+					Count: len(expectedPayload),
+					Total: len(expectedPayload),
+				}, result, checker.IgnoreCmpPath("ControlMessages")); diff != "" {
+					t.Errorf("(i=%d) ep.Read: unexpected result (-want +got):\n%s", i, diff)
+				}
+				if diff := cmp.Diff(expectedPayload, buf.Bytes()); diff != "" {
 					t.Errorf("(i=%d) got UDP payload mismatch (-want +got):\n%s", i, diff)
 				}
 			}
 
-			if gotPayload, _, err := ep.Read(nil); err != tcpip.ErrWouldBlock {
-				t.Fatalf("(last) got Read(nil) = (%x, _, %v), want = (_, _, %s)", gotPayload, err, tcpip.ErrWouldBlock)
+			if res, err := ep.Read(ioutil.Discard, rcvSize, tcpip.ReadOptions{}); err != tcpip.ErrWouldBlock {
+				t.Fatalf("(last) got Read = (%v, %v), want = (_, %s)", res, err, tcpip.ErrWouldBlock)
 			}
 		})
 	}
diff --git a/pkg/tcpip/network/ipv6/ipv6_test.go b/pkg/tcpip/network/ipv6/ipv6_test.go
index 5f07d3af8..360025b20 100644
--- a/pkg/tcpip/network/ipv6/ipv6_test.go
+++ b/pkg/tcpip/network/ipv6/ipv6_test.go
@@ -15,8 +15,10 @@
 package ipv6
 
 import (
+	"bytes"
 	"encoding/hex"
 	"fmt"
+	"io/ioutil"
 	"math"
 	"net"
 	"testing"
@@ -844,13 +846,14 @@ func TestReceiveIPv6ExtHdrs(t *testing.T) {
 		},
 	}
 
+	const mtu = header.IPv6MinimumMTU
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			s := stack.New(stack.Options{
 				NetworkProtocols:   []stack.NetworkProtocolFactory{NewProtocol},
 				TransportProtocols: []stack.TransportProtocolFactory{udp.NewProtocol},
 			})
-			e := channel.New(1, header.IPv6MinimumMTU, linkAddr1)
+			e := channel.New(1, mtu, linkAddr1)
 			if err := s.CreateNIC(nicID, e); err != nil {
 				t.Fatalf("CreateNIC(%d, _) = %s", nicID, err)
 			}
@@ -979,17 +982,24 @@ func TestReceiveIPv6ExtHdrs(t *testing.T) {
 			if got := stats.Value(); got != 1 {
 				t.Errorf("got UDP Rx Packets = %d, want = 1", got)
 			}
-			gotPayload, _, err := ep.Read(nil)
+			var buf bytes.Buffer
+			result, err := ep.Read(&buf, mtu, tcpip.ReadOptions{})
 			if err != nil {
-				t.Fatalf("Read(nil): %s", err)
+				t.Fatalf("Read: %s", err)
+			}
+			if diff := cmp.Diff(tcpip.ReadResult{
+				Count: len(udpPayload),
+				Total: len(udpPayload),
+			}, result, checker.IgnoreCmpPath("ControlMessages")); diff != "" {
+				t.Errorf("Read: unexpected result (-want +got):\n%s", diff)
 			}
-			if diff := cmp.Diff(buffer.View(udpPayload), gotPayload); diff != "" {
+			if diff := cmp.Diff(udpPayload, buf.Bytes()); diff != "" {
 				t.Errorf("got UDP payload mismatch (-want +got):\n%s", diff)
 			}
 
 			// Should not have any more UDP packets.
-			if gotPayload, _, err := ep.Read(nil); err != tcpip.ErrWouldBlock {
-				t.Fatalf("got Read(nil) = (%x, _, %v), want = (_, _, %s)", gotPayload, err, tcpip.ErrWouldBlock)
+			if res, err := ep.Read(ioutil.Discard, mtu, tcpip.ReadOptions{}); err != tcpip.ErrWouldBlock {
+				t.Fatalf("got Read = (%v, %v), want = (_, %s)", res, err, tcpip.ErrWouldBlock)
 			}
 		})
 	}
@@ -1969,18 +1979,20 @@ func TestReceiveIPv6Fragments(t *testing.T) {
 				t.Errorf("got UDP Rx Packets = %d, want = %d", got, want)
 			}
 
+			const rcvSize = 65536 // Account for reassembled packets.
 			for i, p := range test.expectedPayloads {
-				gotPayload, _, err := ep.Read(nil)
+				var buf bytes.Buffer
+				_, err := ep.Read(&buf, rcvSize, tcpip.ReadOptions{})
 				if err != nil {
-					t.Fatalf("(i=%d) Read(nil): %s", i, err)
+					t.Fatalf("(i=%d) Read: %s", i, err)
 				}
-				if diff := cmp.Diff(buffer.View(p), gotPayload); diff != "" {
+				if diff := cmp.Diff(p, buf.Bytes()); diff != "" {
 					t.Errorf("(i=%d) got UDP payload mismatch (-want +got):\n%s", i, diff)
 				}
 			}
 
-			if gotPayload, _, err := ep.Read(nil); err != tcpip.ErrWouldBlock {
-				t.Fatalf("(last) got Read(nil) = (%x, _, %v), want = (_, _, %s)", gotPayload, err, tcpip.ErrWouldBlock)
+			if res, err := ep.Read(ioutil.Discard, rcvSize, tcpip.ReadOptions{}); err != tcpip.ErrWouldBlock {
+				t.Fatalf("(last) got Read = (%v, %v), want = (_, %s)", res, err, tcpip.ErrWouldBlock)
 			}
 		})
 	}