implement sophisticated TAP interface to be able to debug stack on linux

examples/tap/main.go

@@ -1,11 +1,13 @@
 package main
 
 import (
+	"encoding/json"
+	"errors"
 	"fmt"
 	"log"
+	"log/slog"
+	"net/http"
 	"net/netip"
-	"os"
-	"time"
 
 	"github.com/soypat/lneto/internal"
 )
@@ -20,23 +22,103 @@ func main() {
 }
 
 func run() error {
-	ip := netip.MustParsePrefix("192.168.10.1/24")
-	tap, err := internal.NewTap("tap0", ip)
+	var (
+		flagNet   = "192.168.10.1/24"
+		flagiface = "tap0"
+		flagMTU   = 1500
+	)
+	slogger := slog.Default()
+	ip, err := netip.ParsePrefix(flagNet)
+	if err != nil {
+		return err
+	}
+	tap, err := internal.NewTap(flagiface, ip)
 	if err != nil {
 		return err
 	}
 	defer tap.Close()
-	var buf [2048]byte
-	pkt := 0
+	s := stack{
+		out: make(chan []byte, 256),
+		in:  make(chan []byte, 2048),
+	}
+	sv := http.NewServeMux()
+	sv.HandleFunc("/send", func(w http.ResponseWriter, r *http.Request) {
+		var data []byte
+		err := json.NewDecoder(r.Body).Decode(&data)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		} else {
+			select {
+			case s.out <- data:
+				slog.Info("http-send", slog.Int("plen", len(data)))
+			default:
+				http.Error(w, "outgoing packet queue full", http.StatusInternalServerError)
+			}
+		}
+	})
+	sv.HandleFunc("/recv", func(w http.ResponseWriter, r *http.Request) {
+		select {
+		case data := <-s.in:
+			json.NewEncoder(w).Encode(data)
+			slog.Info("http-recv", slog.Int("plen", len(data)))
+		default:
+			json.NewEncoder(w).Encode("") // send empty string.
+		}
+	})
+	fmt.Println("listening on http://127.0.0.1:7070/recv  and  http://127.0.0.1:7070/send")
+	go http.ListenAndServe(":7070", sv)
+
+	buf := make([]byte, flagMTU)
 	for {
 		n, err := tap.Read(buf[:])
 		if err != nil {
-			return err
-		} else if n == 0 {
-			time.Sleep(250 * time.Millisecond)
-			continue
+			log.Fatal(err)
+		} else if n > 0 {
+			err = s.recv(buf[:n])
+			if err != nil {
+				slogger.Error("recv", slog.String("err", err.Error()), slog.Int("plen", n))
+			} else {
+				slogger.Info("recv", slog.Int("plen", n))
+			}
+		}
+		n, err = s.handle(buf[:])
+		if err != nil {
+			slogger.Error("handle", slog.String("err", err.Error()))
+		} else if n > 0 {
+			_, err = tap.Write(buf[:n])
+			if err != nil {
+				log.Fatal(err)
+			} else {
+				slogger.Info("write", slog.Int("plen", n))
+			}
 		}
-		pkt++
-		fmt.Fprintf(os.Stdout, "rx%d (%d): %q\n\n", pkt, n, buf[:n])
 	}
 }
+
+type stack struct {
+	out chan []byte
+	in  chan []byte
+}
+
+func (s *stack) recv(b []byte) (err error) {
+	bcopy := append([]byte{}, b...)
+RETRY:
+	select {
+	case s.in <- bcopy:
+	default:
+		err = errors.New("receive queue packet full, dropping packet")
+		<-s.in
+		goto RETRY
+	}
+	return err
+}
+
+func (s *stack) handle(b []byte) (n int, _ error) {
+	select {
+	case incoming := <-s.out:
+		n = copy(b, incoming)
+	default:
+		// pass if no data available.
+	}
+	return n, nil
+}