more httpraw bug fixes (#160)

* more httpraw bug fixes * add http-linux example and add httpraw.Header.SetInt * finish http-linux example * fix CI vet
2026-08-14 11:53:43 +00:00 · 2026-07-18 12:11:37 -03:00
parent 347cef9ba5
commit 1a474154cb
6 changed files with 545 additions and 27 deletions
@@ -0,0 +1,96 @@
+//go:build !tinygo && linux
+
+package main
+
+import (
+	"net/netip"
+	"syscall"
+)
+
+// Conn wraps an accepted TCP connection from a raw Linux socket file descriptor.
+// It implements io.Reader/io.Writer/io.Closer over syscall.Read/Write/Close.
+type Conn struct {
+	fd     int
+	remote netip.AddrPort
+}
+
+// Read reads bytes from the connection into b.
+func (c *Conn) Read(b []byte) (int, error) {
+	if len(b) == 0 {
+		return 0, nil
+	}
+	n, err := syscall.Read(c.fd, b)
+	if err != nil {
+		return 0, err
+	}
+	if n == 0 {
+		return 0, syscall.ECONNRESET // Peer closed.
+	}
+	return n, nil
+}
+
+// Write writes b to the connection, looping until all bytes are sent.
+func (c *Conn) Write(b []byte) (int, error) {
+	total := 0
+	for total < len(b) {
+		n, err := syscall.Write(c.fd, b[total:])
+		if err != nil {
+			return total, err
+		}
+		total += n
+	}
+	return total, nil
+}
+
+// Close closes the underlying file descriptor.
+func (c *Conn) Close() error {
+	return syscall.Close(c.fd)
+}
+
+// RemoteAddr returns the peer address of the connection.
+func (c *Conn) RemoteAddr() netip.AddrPort { return c.remote }
+
+// Listener wraps a listening TCP socket bound to a local port.
+type Listener struct {
+	fd int
+}
+
+// Listen creates a listening TCP socket bound to port on all interfaces.
+func Listen(port uint16) (*Listener, error) {
+	fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
+	if err != nil {
+		return nil, err
+	}
+	// Allow quick rebind after restart.
+	if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+	addr := &syscall.SockaddrInet4{Port: int(port)}
+	if err = syscall.Bind(fd, addr); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+	if err = syscall.Listen(fd, syscall.SOMAXCONN); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+	return &Listener{fd: fd}, nil
+}
+
+// Accept blocks until an incoming connection arrives and returns it as a Conn.
+func (l *Listener) Accept(conn *Conn) error {
+	nfd, sa, err := syscall.Accept(l.fd)
+	if err != nil {
+		return err
+	}
+
+	conn.fd = nfd
+	if sa4, ok := sa.(*syscall.SockaddrInet4); ok {
+		conn.remote = netip.AddrPortFrom(netip.AddrFrom4(sa4.Addr), uint16(sa4.Port))
+	}
+	return nil
+}
+
+// Close closes the listening socket.
+func (l *Listener) Close() error { return syscall.Close(l.fd) }
@@ -0,0 +1,107 @@
+//go:build !tinygo && linux
+
+package main
+
+import (
+	"os"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	"github.com/soypat/lneto/http/httpraw"
+)
+
+const listenPort = 8080
+
+func main() {
+	if err := run(); err != nil {
+		println("Error: ", err)
+		os.Exit(1)
+	}
+	println("DONE")
+}
+
+func run() error {
+	ln, err := Listen(listenPort)
+	if err != nil {
+		return err
+	}
+	defer ln.Close()
+	println("listening on port", listenPort)
+	conn := new(Conn)
+	for {
+		err := ln.Accept(conn)
+		if err != nil {
+			return err
+		}
+		visits.Add(1)
+		if err := handle(conn); err != nil {
+			println("handle:", conn.RemoteAddr().String(), err.Error())
+		}
+		conn.Close()
+	}
+}
+
+const (
+	htmlHead = `<html><body bgcolor="#000080" text="#00FF00"><center>` +
+		`<marquee><font face="Comic Sans MS" size="5" color="#FFFF00">` +
+		`*** WELCOME TO MY HOMEPAGE ***</font></marquee>` +
+		`<h1><blink>YOU ARE VISITOR #`
+	htmlTail = `!</blink></h1>` +
+		`<font color="#FF00FF">Sign my guestbook!</font>` +
+		`<br><hr>Best viewed in Netscape Navigator</center></body></html>`
+)
+
+const maxHTTPHeader = 1024
+
+var (
+	hdr     httpraw.Header
+	httpbuf [maxHTTPHeader]byte
+	htmlbuf [512]byte
+	visits  atomic.Uint64
+)
+
+func handle(conn *Conn) error {
+	hdr.Reset(httpbuf[:0])
+	hdr.EnableBufferGrowth(false)    // Limit memory to buffer capacity.
+	const incomingIsResponse = false // We get HTTP requests from clients.
+	deadline := time.Now().Add(50 * time.Millisecond)
+	for time.Until(deadline) > 0 {
+		if _, err := hdr.ReadFromLimited(conn, maxHTTPHeader); err != nil {
+			return err
+		}
+		needmoredata, err := hdr.TryParse(incomingIsResponse)
+		if err != nil {
+			return err
+		}
+		if needmoredata {
+			continue
+		}
+		break
+	}
+	println("\n\n================\n\n", hdr.String())
+	if time.Since(deadline) > 0 {
+		print("DEADLINE EXCEED: ", hdr.BufferParsed(), "/", hdr.BufferReceived(), " bytes parsed/read\n")
+		return nil
+	}
+	// Prepare tacky HTML response.
+	n := copy(htmlbuf[:], htmlHead)
+	n += len(strconv.AppendUint(htmlbuf[n:n], visits.Load(), 10))
+	n += copy(htmlbuf[n:], htmlTail)
+	contentLen := n
+	hdr.Reset(httpbuf[:0])
+	hdr.SetProtocol("HTTP/1.1")
+	hdr.SetStatus("200", "OK")
+	hdr.Set("Content-Type", "text/html")
+	hdr.SetInt("Content-Length", int64(contentLen), 10)
+	// Here we do some buffer juggling. We use remaining space
+	// of HTTP Header buffer to write the response that will be written over the wire.
+	respbuf := httpbuf[hdr.BufferUsed():]
+	header, err := hdr.AppendResponse(respbuf[:0])
+	if err != nil {
+		return err
+	}
+	conn.Write(header)
+	_, err = conn.Write(htmlbuf[:contentLen])
+	return err
+}