soypat/lneto
1
0
Fork 0
mirror of https://github.com/soypat/lneto.git synced 2026-08-12 10:53:44 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

add TCPConn type

Browse Source
This commit is contained in:
soypat
2025-04-04 19:16:26 -03:00
parent afc1ec6408
commit 39d5e4290e
9 changed files with 713 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/stack/main.go
+2 -64
View File
@@ -1,17 +1,13 @@
package main
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"log/slog"
"net"
"net/http"
"net/netip"
"net/url"
"os"
"time"
@@ -19,6 +15,7 @@ import (
"github.com/soypat/lneto/arp"
"github.com/soypat/lneto/ethernet"
"github.com/soypat/lneto/internal"
"github.com/soypat/lneto/internal/ltesto"
"github.com/soypat/lneto/ipv4"
"github.com/soypat/lneto/ipv6"
"github.com/soypat/lneto/tcp"
@@ -57,7 +54,7 @@ func main() {
log.Fatal(err)
}
tap := NewHTTPTap("http://127.0.0.1:7070")
tap := ltesto.NewHTTPTapClient("http://127.0.0.1:7070")
defer tap.Close()
fmt.Println("hosting server at ", addrPort.String())
@@ -520,65 +517,6 @@ func addHandler(handlers []handler, h Handler, remoteAddr []byte, lport uint16)
return handlers
}
func NewHTTPTap(baseURL string) *HTTPTap {
var h HTTPTap
h.sendurl = baseURL + "/send"
h.recvurl = baseURL + "/recv"
_, err := url.Parse(h.sendurl)
if err != nil {
panic(err)
}
var data [2048]byte
var n int = -1
for n != 0 {
n, _ = h.Read(data[:]) // Empty remote data.
}
return &h
}
type TAPNop struct{}
func (h *TAPNop) Read(b []byte) (int, error) { return 0, nil }
func (h *TAPNop) Write(b []byte) (int, error) { return 0, nil }
func (h *TAPNop) Close() error { return nil }
type HTTPTap struct {
c http.Client
recvurl string
sendurl string
}
func (h *HTTPTap) Read(b []byte) (int, error) {
resp, err := h.c.Get(h.recvurl)
if err != nil {
return 0, err
} else if resp.StatusCode != 200 {
return 0, errors.New(resp.Status + " for " + h.recvurl)
}
var data []byte
err = json.NewDecoder(resp.Body).Decode(&data)
if err != nil {
return 0, err
} else if len(b) < len(data) {
return 0, fmt.Errorf("got too large packet %d for buffer %d", len(data), len(b))
}
copy(b, data)
return len(data), nil
}
func (h *HTTPTap) Write(b []byte) (int, error) {
data, _ := json.Marshal(b)
resp, err := h.c.Post(h.sendurl, "application/json", bytes.NewReader(data))
if err != nil {
return 0, err
} else if resp.StatusCode != 200 {
return 0, errors.New(resp.Status + " for " + h.sendurl)
}
return len(b), nil
}
func (h *HTTPTap) Close() error { return nil }
func tcpChecksum(ipFrame []byte, tcpPayload int) uint16 {
version := ipFrame[0] >> 4
var tfrm tcp.Frame
examples/stackbasic/main.go
+278
View File
@@ -0,0 +1,278 @@
package main
import (
"errors"
"fmt"
"io"
"log"
"log/slog"
"net"
"net/netip"
"os"
"time"
"github.com/soypat/lneto"
"github.com/soypat/lneto/arp"
"github.com/soypat/lneto/ethernet"
"github.com/soypat/lneto/internal"
"github.com/soypat/lneto/internal/ltesto"
"github.com/soypat/lneto/internet"
)
const (
mtu = 2048
iface = "192.168.10.1/24"
stackIP = "192.168.10.2"
stackPort = 80
iss = 100
)
var stackHWAddr = [6]byte{0xc0, 0xff, 0xee, 0x00, 0xde, 0xad}
func main() {
ip := netip.MustParseAddr(stackIP)
iface := netip.MustParsePrefix(iface)
if !iface.Contains(ip) {
log.Fatal("interface does not contain stack address")
}
addrPort := netip.AddrPortFrom(ip, stackPort)
slogger := logger{slog.Default()}
lStack, handler, err := NewEthernetTCPStack(stackHWAddr, addrPort, slogger)
if err != nil {
log.Fatal(err)
}
logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
Level: slog.LevelDebug,
}))
handler.SetLoggers(logger, logger)
err = handler.OpenListen(addrPort.Port(), iss)
if err != nil {
log.Fatal(err)
}
tap := ltesto.NewHTTPTapClient("http://127.0.0.1:7070")
defer tap.Close()
fmt.Println("hosting server at ", addrPort.String())
var buf [mtu]byte
for {
nread, err := tap.Read(buf[:])
if err != nil {
slogger.error("tap-err", slog.String("err", err.Error()))
log.Fatal(err)
} else if nread > 0 {
err = lStack.RecvEth(buf[:nread])
if err != nil {
slogger.error("recv", slog.String("err", err.Error()), slog.Int("plen", nread))
} else {
slogger.info("recv", slog.Int("plen", nread))
}
}
nw, err := lStack.HandleEth(buf[:])
if err != nil {
slogger.error("handle", slog.String("err", err.Error()))
} else if nw > 0 {
_, err = tap.Write(buf[:nw])
if err != nil {
log.Fatal(err)
} else {
slogger.info("write", slog.Int("plen", nw))
}
}
if nread == 0 && nw == 0 {
time.Sleep(5 * time.Millisecond)
}
}
}
func NewEthernetTCPStack(mac [6]byte, ip netip.AddrPort, slogger logger) (*LinkStack, *internet.TCPConn, error) {
var err error
lStack := LinkStack{
logger: slogger,
mac: mac,
mtu: mtu,
}
var ipStack internet.StackBasic
addr := ip.Addr()
addr4 := addr.As4()
_ = addr4
ipStack.SetAddr(addr)
lStack.Register(handler{
raddr: nil, //addr4[:],
recv: func(b []byte, i int) error {
return ipStack.Recv(b[i:])
},
handle: func(b []byte, i int) (int, error) {
return ipStack.Handle(b[i:])
},
proto: uint32(lneto.IPProtoIPv4),
lport: 0,
})
var conn internet.TCPConn
err = conn.Configure(&internet.TCPConnConfig{
RxBuf: make([]byte, mtu),
TxBuf: make([]byte, mtu),
TxPacketQueueSize: 3,
Logger: slog.Default(),
})
if err != nil {
return nil, nil, err
}
err = conn.OpenListen(ip.Port(), 100)
if err != nil {
return nil, nil, err
}
err = ipStack.RegisterTCPConn(&conn)
if err != nil {
return nil, nil, err
}
proto := ethernet.TypeIPv4
if ip.Addr().Is6() {
proto = ethernet.TypeIPv6
}
arphandler, err := arp.NewHandler(arp.HandlerConfig{
HardwareAddr: mac[:],
ProtocolAddr: ip.Addr().AsSlice(),
MaxQueries: 1,
MaxPending: 1,
HardwareType: 1,
ProtocolType: proto,
})
if err != nil {
return nil, nil, err
}
arpStack := ARPStack{
handler: *arphandler,
}
err = lStack.Register(ipStack, mac)
if err != nil {
return nil, nil, err
}
return &lStack, &conn, nil
}
type handler struct {
raddr []byte
recv func([]byte, int) error
handle func([]byte, int) (int, error)
proto uint32
lport uint16
}
type LinkStack struct {
handlers []handler
logger
mac [6]byte
mtu uint16
}
func (ls *LinkStack) Register(h handler) error {
proto := h.proto
for i := range ls.handlers {
if proto == ls.handlers[i].proto {
return errors.New("protocol already registered")
}
}
ls.handlers = append(ls.handlers, h)
return nil
}
func (ls *LinkStack) RecvEth(ethFrame []byte) (err error) {
efrm, err := ethernet.NewFrame(ethFrame)
if err != nil {
return err
}
etype := efrm.EtherTypeOrSize()
dstaddr := efrm.DestinationHardwareAddr()
if !efrm.IsBroadcast() && ls.mac != *dstaddr {
return fmt.Errorf("incoming %s mismatch hwaddr %s", etype.String(), net.HardwareAddr(dstaddr[:]).String())
}
var vld lneto.Validator
efrm.ValidateSize(&vld)
if err := vld.Err(); err != nil {
return err
}
for i := range ls.handlers {
h := &ls.handlers[i]
if h.proto == uint32(etype) {
return h.recv(efrm.Payload(), 0)
}
}
return nil
}
func (ls *LinkStack) HandleEth(dst []byte) (n int, err error) {
if len(dst) < int(ls.mtu) {
return 0, io.ErrShortBuffer
}
for i := range ls.handlers {
h := &ls.handlers[i]
n, err = h.handle(dst[:ls.mtu], 14)
if err != nil {
ls.error("handling", slog.String("proto", ethernet.Type(h.proto).String()), slog.String("err", err.Error()))
continue
}
if n > 0 {
// Found packet
efrm, _ := ethernet.NewFrame(dst[:14])
copy(efrm.DestinationHardwareAddr()[:], h.raddr)
*efrm.SourceHardwareAddr() = ls.mac
efrm.SetEtherType(ethernet.Type(h.proto))
return n + 14, nil
}
}
return 0, err
}
type ARPStack struct {
handler arp.Handler
}
func (as *ARPStack) Protocol() uint32 { return uint32(ethernet.TypeARP) }
func (as *ARPStack) Recv(EtherFrame []byte, arpOff int) error {
afrm, _ := arp.NewFrame(EtherFrame[arpOff:])
slog.Info("recv", slog.String("in", afrm.String()))
return as.handler.Recv(EtherFrame[arpOff:])
}
func (as *ARPStack) Handle(EtherFrame []byte, arpOff int) (int, error) {
n, err := as.handler.Send(EtherFrame[arpOff:])
if err != nil || n == 0 {
return 0, err
}
afrm, _ := arp.NewFrame(EtherFrame[arpOff:])
hwaddr, _ := afrm.Target()
efrm, _ := ethernet.NewFrame(EtherFrame)
copy(efrm.DestinationHardwareAddr()[:], hwaddr)
slog.Info("handle", slog.String("out", afrm.String()))
return n, err
}
type logger struct {
log *slog.Logger
}
func (l logger) error(msg string, attrs ...slog.Attr) {
internal.LogAttrs(l.log, slog.LevelError, msg, attrs...)
}
func (l logger) info(msg string, attrs ...slog.Attr) {
internal.LogAttrs(l.log, slog.LevelInfo, msg, attrs...)
}
func (l logger) warn(msg string, attrs ...slog.Attr) {
internal.LogAttrs(l.log, slog.LevelWarn, msg, attrs...)
}
func (l logger) debug(msg string, attrs ...slog.Attr) {
internal.LogAttrs(l.log, slog.LevelDebug, msg, attrs...)
}
func (l logger) trace(msg string, attrs ...slog.Attr) {
internal.LogAttrs(l.log, internal.LevelTrace, msg, attrs...)
}
examples/tap/main.go
+14 -84
View File
@@ -1,15 +1,15 @@
package main
import (
"encoding/json"
"errors"
"fmt"
"log"
"log/slog"
"net/http"
"net/netip"
"time"
"github.com/soypat/lneto/internal"
"github.com/soypat/lneto/internal/ltesto"
)
func main() {
@@ -23,102 +23,32 @@ func main() {
func run() error {
var (
flagNet = "192.168.10.1/24"
flagiface = "tap0"
flagMTU = 1500
flagNet = "192.168.10.1/24"
flagiface = "tap0"
flagMTU = 1500
flagPacketQueueSize = 2048
)
slogger := slog.Default()
ip, err := netip.ParsePrefix(flagNet)
if err != nil {
return err
}
tap, err := internal.NewTap(flagiface, ip)
sv, err := ltesto.NewHTTPTapServer(flagiface, ip, flagMTU, flagPacketQueueSize, flagPacketQueueSize)
if err != nil {
return err
}
defer tap.Close()
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.
}
})
defer sv.Close()
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[:])
result, err := sv.HandleTap()
if err != nil {
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))
}
slog.Error("handletap:error", slog.String("err", err.Error()), slog.Any("result", result))
}
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))
}
if result.Failed {
return errors.New("tap failed, exit program")
} else if result.ReceivedSize == 0 && result.SentSize == 0 {
time.Sleep(200 * time.Millisecond) // No data exchanged, sleep a bit to not hog CPU.
}
}
}
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
}