Reduce heap allocations (#42)

* pcap: reuse Frame memory

* slog: reduce heap allocations of addresses; also prevent heap alloc of dhcp options in pcap

* dns: heapless improvement; add StackAsync buffer for more heapless operation; start thinking of errors

* reuse function for reclaiming frames among all protocols for lower memory usage

* remove extraneous code

internal/slices.go

@@ -46,3 +46,22 @@ func SliceReuse[T any](buf *[]T, n int) {
 		*buf = (*buf)[:0]
 	}
 }
+
+// SliceReclaim extends the slice length by one and returns a pointer to
+// the new last element. The returned element is not zeroed, so callers
+// can reuse any existing allocations it may hold from prior use.
+//
+// Beware: as the name implies SliceReclaim reuses previously held memory
+// so it is up to caller to ensure the reclaimed data is coherent by zeroing out
+// the needed fields and reusing the previously held slices or pointers responsibly.
+func SliceReclaim[T any](ptr *[]T) *T {
+	b := *ptr
+	n := len(b)
+	if n == cap(b) {
+		var z T
+		*ptr = append(b, z)
+	} else {
+		*ptr = b[:n+1]
+	}
+	return &(*ptr)[n]
+}

internal/slogattr.go

@@ -0,0 +1,22 @@
+package internal
+
+import (
+	"encoding/binary"
+	"log/slog"
+)
+
+// SlogAddr4 returns a slog.Attr for a 4-byte IPv4 address
+// packed into a uint64 without allocating a string.
+func SlogAddr4(key string, addr *[4]byte) slog.Attr {
+	u64Addr := uint64(binary.BigEndian.Uint32(addr[:]))
+	return slog.Uint64(key, u64Addr)
+}
+
+// SlogAddr6 returns a slog.Attr for a 6-byte hardware (MAC) address
+// packed into a uint64 without allocating a string.
+func SlogAddr6(key string, addr *[6]byte) slog.Attr {
+	var buf [8]byte
+	copy(buf[2:], addr[:])
+	u64Addr := binary.BigEndian.Uint64(buf[:])
+	return slog.Uint64(key, u64Addr)
+}