add query handling

2026-08-11 18:33:46 +00:00 · 2026-07-25 22:45:59 -03:00
parent 99f848f93f
commit d83da243a0
6 changed files with 447 additions and 7 deletions
@@ -3,6 +3,8 @@ package httphi
 import (
 	"io"
 	"testing"
+
+	"github.com/soypat/lneto/internal"
 )

 // benchConn replays a fixed request and discards the response. It allocates
@@ -48,17 +50,23 @@ func benchExchange(b *testing.B, conn conn) *Exchange {

 // BenchmarkHandle measures a whole exchange: read, parse, mux and respond.
 func BenchmarkHandle(b *testing.B) {
+	expect := []byte("123")
+	buf := make([]byte, 64)
 	for _, bb := range []struct {
 		name    string
 		request string
 		handler HandlerFunc
 	}{
 		{
-			name:    "GETWithHeaders",
-			request: "GET / HTTP/1.1\r\nHost: tinygo.org\r\nUser-Agent: bench\r\nAccept: */*\r\nConnection: close\r\n\r\n",
+			name:    "GETWithHeadersAndQuery",
+			request: "GET /?abc=123 HTTP/1.1\r\nHost: tinygo.org\r\nUser-Agent: bench\r\nAccept: */*\r\nConnection: close\r\n\r\n",
 			handler: func(ex *Exchange) {
 				ex.SetHeader("Content-Type", "text/plain")
 				ex.SetHeaderInt("Content-Length", int64(len(benchBody)), 10)
+				data, present := ex.AppendQuery(buf[:0], "abc", true)
+				if !present || !internal.BytesEqual(data, expect) {
+					panic("invalid result")
+				}
 				ex.Write(benchBody)
 			},
 		},
@@ -78,7 +86,7 @@ func BenchmarkHandle(b *testing.B) {
 			b.ReportAllocs()
 			b.SetBytes(int64(len(bb.request)))
 			b.ResetTimer()
-			for b.Loop() {
+			for i := 0; i < b.N; i++ {
 				conn.rewind()
 				exch.Release()
 				exch.Acquire(conn)
@@ -190,7 +190,8 @@ func TestHandleRequestFields(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			var gotMethod, gotURI, gotHost string
 			var sm MuxSlice
-			sm.Handle(test.wantURI, func(ex *Exchange) {
+			route, _, _ := strings.Cut(test.wantURI, "?") // Mux matches on path.
+			sm.Handle(route, func(ex *Exchange) {
 				gotMethod = string(ex.RequestMethod())
 				gotURI = string(ex.RequestURI())
 				gotHost = string(ex.RequestHeader("Host"))
@@ -453,3 +454,100 @@ func TestExchangeSetHeaderIntNoAlloc(t *testing.T) {
 		t.Errorf("SetHeaderInt allocated %v times, want 0", allocs)
 	}
 }
+
+// The Mux matches on the request path: a query string must not defeat routing.
+func TestHandleMuxOnPath(t *testing.T) {
+	var sm MuxSlice
+	var gotPath, gotQuery string
+	sm.Handle("GET /search", func(ex *Exchange) {
+		gotPath = string(ex.RequestPath())
+		ex.ForEachQueryRaw(func(rawkey, rawval []byte) bool {
+			gotQuery += string(rawkey) + "=" + string(rawval) + ";"
+			return true
+		})
+		ex.WriteHeader(200)
+	})
+	conn := serve(t, "GET /search?q=go&n=1 HTTP/1.1\r\nHost: h\r\n\r\n", &sm)
+
+	if gotPath != "/search" {
+		t.Errorf("want path %q, got %q", "/search", gotPath)
+	}
+	if gotQuery != "q=go;n=1;" {
+		t.Errorf("want query %q, got %q", "q=go;n=1;", gotQuery)
+	}
+	if got := conn.ViewWritten(); !strings.HasPrefix(got, "HTTP/1.1 200 OK\r\n") {
+		t.Errorf("want the handler to have run, got %q", got)
+	}
+}
+
+func TestExchangeAppendQuery(t *testing.T) {
+	for _, test := range []struct {
+		uri         string
+		key         string
+		decoded     bool
+		want        string
+		wantPresent bool
+	}{
+		{uri: "/x?q=go", key: "q", want: "go", wantPresent: true},
+		{uri: "/x?q=go&n=1", key: "n", want: "1", wantPresent: true},
+		{uri: "/x?a=1&a=2", key: "a", want: "1", wantPresent: true},  // First match wins.
+		{uri: "/x?q=go", key: "nope", want: "", wantPresent: false},  // Absent.
+		{uri: "/x", key: "q", want: "", wantPresent: false},          // No query at all.
+		{uri: "/x?debug&q=go", key: "debug", want: "", wantPresent: true}, // Flag: present, no value.
+		{uri: "/x?q=", key: "q", want: "", wantPresent: true},             // Present, empty.
+		// Decoding is opt-in and applies to the value only.
+		{uri: "/x?q=hello%20world", key: "q", want: "hello%20world", wantPresent: true},
+		{uri: "/x?q=hello%20world", key: "q", decoded: true, want: "hello world", wantPresent: true},
+		{uri: "/x?q=a+b", key: "q", want: "a+b", wantPresent: true},
+		{uri: "/x?q=a+b", key: "q", decoded: true, want: "a b", wantPresent: true},
+		// Keys are matched decoded: "a b" cannot appear raw.
+		{uri: "/x?a%20b=c", key: "a b", want: "c", wantPresent: true},
+		{uri: "/x?a+b=c", key: "a b", want: "c", wantPresent: true},
+		// Malformed escapes: a bad key is skipped, a bad value is not returned.
+		{uri: "/x?%zz=1&q=go", key: "q", want: "go", wantPresent: true},
+		{uri: "/x?q=%zz", key: "q", decoded: true, want: "", wantPresent: false},
+		{uri: "/x?q=%zz", key: "q", want: "%zz", wantPresent: true}, // Undecoded, passed through.
+	} {
+		var sm MuxSlice
+		var got string
+		var present bool
+		sm.Handle("/x", func(ex *Exchange) {
+			var value []byte
+			value, present = ex.AppendQuery(nil, test.key, test.decoded)
+			got = string(value)
+		})
+		serve(t, "GET "+test.uri+" HTTP/1.1\r\nHost: h\r\n\r\n", &sm)
+
+		if present != test.wantPresent {
+			t.Errorf("%s key %q decoded=%v: want present=%v, got %v", test.uri, test.key, test.decoded, test.wantPresent, present)
+		}
+		if got != test.want {
+			t.Errorf("%s key %q decoded=%v: want %q, got %q", test.uri, test.key, test.decoded, test.want, got)
+		}
+	}
+}
+
+// AppendQuery appends to dst, leaving what was already there untouched, and
+// does not allocate when dst has the capacity.
+func TestExchangeAppendQueryReusesBuffer(t *testing.T) {
+	var sm MuxSlice
+	var got string
+	var allocs float64
+	dst := make([]byte, 0, 64)
+	sm.Handle("/x", func(ex *Exchange) {
+		var value []byte
+		allocs = testing.AllocsPerRun(50, func() {
+			value, _ = ex.AppendQuery(dst[:len("prefix:")], "q", true)
+		})
+		got = string(value) // Conversion allocates, keep it out of the measurement.
+	})
+	copy(dst[:cap(dst)], "prefix:")
+	serve(t, "GET /x?q=hello%20world HTTP/1.1\r\nHost: h\r\n\r\n", &sm)
+
+	if got != "prefix:hello world" {
+		t.Errorf("want %q, got %q", "prefix:hello world", got)
+	}
+	if allocs != 0 {
+		t.Errorf("AppendQuery allocated %v times into a buffer with capacity, want 0", allocs)
+	}
+}
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"io"
 	"log/slog"
+	"slices"
 	"strconv"
 	"sync"
 	"sync/atomic"
@@ -215,10 +216,10 @@ func Handle(exch *Exchange, mux Mux, backoff lneto.BackoffStrategy) error {
 		exch.WriteHeader(int(StatusBadRequest))
 		return errNoRequestProto
 	}
-	// Mux URI.
-	uri := reqhdr.RequestURI()
+	// Mux on the request path: the query string is the handler's business.
+	path := reqhdr.RequestPath()
 	meth := reqhdr.Method()
-	handler := mux.LookupHandler(MethodFromBytes(meth), uri)
+	handler := mux.LookupHandler(MethodFromBytes(meth), path)
 	if handler != nil {
 		handler(exch)
 		exch.FlushHeader()
@@ -589,6 +590,68 @@ func (exch *Exchange) RequestURI() []byte {
 	return exch.RequestHeaderRaw().RequestURI()
 }

+// RequestPath returns the request URI up to the query string. This is what the
+// [Mux] matches on, i.e: "/search" for a request to "/search?q=go".
+func (exch *Exchange) RequestPath() []byte {
+	return exch.RequestHeaderRaw().RequestPath()
+}
+
+// ForEachQueryRaw iterates over the request's query string key-value pairs as
+// they appear on the wire. See [httpraw.Header.ForEachQuery].
+func (exch *Exchange) ForEachQueryRaw(fn func(rawkey, rawval []byte) bool) {
+	exch.RequestHeaderRaw().ForEachQuery(fn)
+}
+
+// AppendQuery appends the value of the first query parameter matching key to
+// dst and reports whether the parameter was present. A parameter with no value
+// ("?debug") and one with an empty value ("?debug=") are both present with
+// nothing appended.
+//
+// Keys are matched decoded, so key "a b" finds "a%20b" and "a+b". Values are
+// appended raw unless decoded is set, in which case percent escapes and '+' are
+// decoded. A parameter whose value fails to decode is reported absent, and a
+// parameter whose key fails to decode is skipped.
+//
+// dst doubles as scratch space for decoding candidate keys, so AppendQuery only
+// allocates when dst lacks the capacity to hold the longest key it inspects.
+func (exch *Exchange) AppendQuery(dst []byte, key string, decoded bool) (valueAppended []byte, present bool) {
+	const plusAsSpace = true // Query strings are form encoded, unlike paths.
+	base := len(dst)
+	valueAppended = dst
+	exch.ForEachQueryRaw(func(rawkey, rawval []byte) bool {
+		if b2s(rawkey) != key {
+			// Key may be encoded: decode it over dst's free space and compare.
+			// A decoded key cannot appear raw, so this cannot alias a real key.
+			valueAppended = slices.Grow(valueAppended, len(rawkey))
+			scratch := valueAppended[base : base+len(rawkey)]
+			n, err := httpraw.CopyDecodedPercentURL(scratch, rawkey, plusAsSpace)
+			if err != nil || b2s(scratch[:n]) != key {
+				return true // Malformed or different key, keep looking.
+			}
+		}
+		present = true
+		if len(rawval) == 0 {
+			return false
+		}
+		valueAppended = slices.Grow(valueAppended, len(rawval))
+		if !decoded {
+			valueAppended = append(valueAppended[:base], rawval...)
+			return false
+		}
+		n, err := httpraw.CopyDecodedPercentURL(valueAppended[base:base+len(rawval)], rawval, plusAsSpace)
+		if err != nil {
+			present = false // Malformed value, do not hand back half a decode.
+			return false
+		}
+		valueAppended = valueAppended[:base+n]
+		return false
+	})
+	if !present {
+		valueAppended = valueAppended[:base]
+	}
+	return valueAppended, present
+}
+
 func (exch *Exchange) RequestMethod() []byte {
 	return exch.RequestHeaderRaw().Method()
 }
@@ -0,0 +1,145 @@
+package httphi
+
+import "testing"
+
+// Scratch benchmarks isolating query handling. Delete after diagnosis.
+
+const scratchRequest = "GET /?abc=123 HTTP/1.1\r\nHost: tinygo.org\r\nUser-Agent: bench\r\nAccept: */*\r\nConnection: close\r\n\r\n"
+
+func scratchExchange(b *testing.B) (*Exchange, *benchConn, *MuxSlice) {
+	b.Helper()
+	conn := &benchConn{request: scratchRequest}
+	exch := benchExchange(b, conn)
+	mux := new(MuxSlice)
+	return exch, conn, mux
+}
+
+// A: whole exchange, handler writes body only. No query touched.
+func BenchmarkScratchBodyOnly(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	mux.Handle("GET /", func(ex *Exchange) { ex.Write(benchBody) })
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+}
+
+// B: same plus header writes. Isolates SetHeader/SetHeaderInt.
+func BenchmarkScratchHeaders(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	mux.Handle("GET /", func(ex *Exchange) {
+		ex.SetHeader("Content-Type", "text/plain")
+		ex.SetHeaderInt("Content-Length", int64(len(benchBody)), 10)
+		ex.Write(benchBody)
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+}
+
+// C: iteration only, closure captures one counter.
+func BenchmarkScratchForEachQuery(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	var seen int
+	mux.Handle("GET /", func(ex *Exchange) {
+		ex.ForEachQueryRaw(func(rawkey, rawval []byte) bool {
+			seen += len(rawkey)
+			return true
+		})
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+	_ = seen
+}
+
+// C2: closure that reassigns a captured slice, exactly AppendQuery's shape.
+func BenchmarkScratchClosureSlice(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	buf := make([]byte, 64)
+	mux.Handle("GET /", func(ex *Exchange) {
+		out := buf[:0]
+		found := false
+		ex.ForEachQueryRaw(func(rawkey, rawval []byte) bool {
+			if b2s(rawkey) != "abc" {
+				return true
+			}
+			out = append(out, rawval...)
+			found = true
+			return false
+		})
+		_ = found
+		_ = out
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+}
+
+// C3: same but the captured slice is only read, never reassigned.
+func BenchmarkScratchClosureNoReassign(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	buf := make([]byte, 64)
+	mux.Handle("GET /", func(ex *Exchange) {
+		n := 0
+		ex.ForEachQueryRaw(func(rawkey, rawval []byte) bool {
+			n += copy(buf, rawval)
+			return false
+		})
+		_ = n
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+}
+
+// D: AppendQuery raw, into a buffer with capacity.
+func BenchmarkScratchAppendQueryRaw(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	buf := make([]byte, 64)
+	mux.Handle("GET /", func(ex *Exchange) {
+		ex.AppendQuery(buf[:0], "abc", false)
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+}
+
+// E: AppendQuery decoded.
+func BenchmarkScratchAppendQueryDecoded(b *testing.B) {
+	exch, conn, mux := scratchExchange(b)
+	buf := make([]byte, 64)
+	mux.Handle("GET /", func(ex *Exchange) {
+		ex.AppendQuery(buf[:0], "abc", true)
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		conn.rewind()
+		exch.Release()
+		exch.Acquire(conn)
+		Handle(exch, mux, nopBackoff)
+	}
+}