netstack/seamless: snoop on newly swapped fdbased endpoint

Author: ignoramous

intra/netstack/seamless.go

@@ -68,15 +68,15 @@ type SeamlessEndpoint interface {
 }
 
 type magiclink struct {
-	e *core.Volatile[stack.LinkEndpoint]
+	e *core.Volatile[SeamlessEndpoint]
 	d *core.Volatile[stack.NetworkDispatcher]
-	FdSwapper
+	s io.WriteCloser
 }
 
 var _ stack.LinkEndpoint = (*magiclink)(nil)
 var _ stack.NetworkDispatcher = (*magiclink)(nil)
 var _ stack.GSOEndpoint = (*magiclink)(nil)
-var _ FdSwapper = (*magiclink)(nil)
+var _ SeamlessEndpoint = (*magiclink)(nil)
 
 // ref: github.com/google/gvisor/blob/91f58d2cc/pkg/tcpip/sample/tun_tcp_echo/main.go#L102
 func NewEndpoint(dev, mtu int, sink io.WriteCloser) (ep SeamlessEndpoint, err error) {
@@ -105,13 +105,14 @@ func snoop(ep SeamlessEndpoint, sink io.WriteCloser) (SeamlessEndpoint, error) {
 		return ep, nil
 	}
 	// TODO: MTU instead of SnapLen? Must match pcapsink.begin()
-	if link, err := NewSnoopyEndpoint(ep, sink); err != nil {
+	link, err := newSnoopyEndpoint(ep, sink, true /*write header*/)
+	if err != nil {
 		return nil, err
-	} else {
-		v := core.NewVolatile[stack.LinkEndpoint](link)
-		d := core.NewZeroVolatile[stack.NetworkDispatcher]()
-		return &magiclink{v, d, ep}, nil
 	}
+
+	v := core.NewVolatile[SeamlessEndpoint](link)
+	d := core.NewZeroVolatile[stack.NetworkDispatcher]()
+	return &magiclink{v, d, sink}, nil
 }
 
 func Pcap2Stdout(y bool) (ok bool) {
@@ -152,13 +153,14 @@ func PcapModes() string {
 	return strings.Join(modes, ",")
 }
 
-// Swap implements FdSwapper.
+// Swap implements SeamlessEndpoint.
 func (l *magiclink) Swap(fd int) error {
-	if l.FdSwapper == nil {
+	e := l.e.Load()
+	if e == nil {
 		return errNoFdSwapper
 	}
 
-	err := l.FdSwapper.Swap(fd)
+	err := e.Swap(fd)
 	if errors.Is(err, errNeedsNewEndpoint) {
 		umtu := uint32(l.MTU())
 		opt := Options{
@@ -172,7 +174,13 @@ func (l *magiclink) Swap(fd int) error {
 			return err
 		}
 
-		if old := l.e.Swap(ep); old != nil {
+		link, err := newSnoopyEndpoint(ep, l.s, false /*write header*/)
+		if err != nil {
+			log.E("netstack: magic(%d); err %v", fd, err)
+			return err
+		}
+
+		if old := l.e.Swap(link); old != nil {
 			core.Go("magic."+strconv.Itoa(fd), old.Close)
 		}
 
@@ -188,6 +196,24 @@ func (l *magiclink) Swap(fd int) error {
 	return err
 }
 
+// Dispose implements SeamlessEndpoint.
+func (l *magiclink) Dispose() error {
+	if e := l.e.Load(); e != nil {
+		l.e.Store(nil) // clear the endpoint
+		return e.Dispose()
+	}
+	log.W("netstack: magic: dispose; no endpoint")
+	return nil
+}
+
+// Stat implements SeamlessEndpoint.
+func (l *magiclink) Stat() EpStat {
+	if e := l.e.Load(); e != nil {
+		return e.Stat()
+	}
+	return EpStat{}
+}
+
 func (l *magiclink) MTU() uint32 {
 	if e := l.e.Load(); e != nil {
 		return e.MTU()

intra/netstack/snooper.go

@@ -50,11 +50,28 @@ type SnoopyEndpoint struct {
 	writer     io.Writer
 	maxPCAPLen uint32
 	logPrefix  string
+	fdSwapper  FdSwapper
+}
+
+// Dispose implements SeamlessEndpoint.
+func (e *SnoopyEndpoint) Dispose() error {
+	return e.fdSwapper.Dispose()
+}
+
+// Stat implements SeamlessEndpoint.
+func (e *SnoopyEndpoint) Stat() EpStat {
+	return e.fdSwapper.Stat()
+}
+
+// Swap implements SeamlessEndpoint.
+func (e *SnoopyEndpoint) Swap(fd int) error {
+	return e.fdSwapper.Swap(fd)
 }
 
 var _ stack.GSOEndpoint = (*SnoopyEndpoint)(nil)
 var _ stack.LinkEndpoint = (*SnoopyEndpoint)(nil)
 var _ stack.NetworkDispatcher = (*SnoopyEndpoint)(nil)
+var _ SeamlessEndpoint = (*SnoopyEndpoint)(nil)
 
 // A Direction indicates whether the packing is being sent or received.
 type Direction int
@@ -101,20 +118,23 @@ func WritePCAPHeader(w io.Writer) error {
 	})
 }
 
-// NewSnoopyEndpoint creates a new snoop link-layer endpoint. It wraps around
+// newSnoopyEndpoint creates a new snoop link-layer endpoint. It wraps around
 // another endpoint and logs packets as they traverse the endpoint.
 //
 // Each packet is written to writer in the pcap format in a single Write call
 // without synchronization. A snoop created with this function will not emit
 // packets using the standard log package.
-func NewSnoopyEndpoint(lower stack.LinkEndpoint, writer io.Writer) (*SnoopyEndpoint, error) {
-	if err := WritePCAPHeader(writer); err != nil {
-		return nil, err
+func newSnoopyEndpoint(lower SeamlessEndpoint, w io.Writer, writeheader bool) (*SnoopyEndpoint, error) {
+	if writeheader {
+		if err := WritePCAPHeader(w); err != nil {
+			return nil, err
+		}
 	}
 	s := &SnoopyEndpoint{
-		writer:     writer,
+		writer:     w,
 		maxPCAPLen: SnapLen,
 		logPrefix:  "",
+		fdSwapper:  lower,
 	}
 	s.Endpoint.Init(lower, s)
 	return s, nil