puma-plus-core 0.1.0

data/go/internal/wire/wire.go

@@ -0,0 +1,401 @@
+// Package wire implements the puma-plus frame protocol spoken between the Go
+// server and Ruby worker processes over unix sockets.
+//
+// See docs/PROTOCOL.md for the normative specification. gem/lib/puma_plus/wire.rb
+// is the mirror implementation; golden_test.go enforces that the two agree byte
+// for byte.
+package wire
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+)
+
+// Frame types on data connections.
+const (
+	TypeHello     uint8 = 0x01
+	TypeRequest   uint8 = 0x02
+	TypeBodyChunk uint8 = 0x03
+	TypeBodyEnd   uint8 = 0x04
+	TypeResponse  uint8 = 0x05
+	TypeRespChunk uint8 = 0x06
+	TypeRespEnd   uint8 = 0x07
+	TypeHijack    uint8 = 0x08
+	TypeGoaway    uint8 = 0x09
+)
+
+// Frame types on WebSocket control connections (role "ws"). These carry
+// outbound commands from Ruby, which may be issued from any thread at any time
+// -- not only while handling a message.
+const (
+	TypeWSSend        uint8 = 0x50
+	TypeWSPublish     uint8 = 0x51
+	TypeWSSubscribe   uint8 = 0x52
+	TypeWSUnsubscribe uint8 = 0x53
+	TypeWSClose       uint8 = 0x54
+	TypeWSQuery       uint8 = 0x55
+	TypeWSQueryReply  uint8 = 0x56
+
+	// WebTransport-only commands. Kept distinct from their reliable
+	// counterparts rather than being a flag, because best-effort delivery is a
+	// different contract and should look different at the call site.
+	TypeWSDatagram        uint8 = 0x57
+	TypeWSPublishDatagram uint8 = 0x58
+	TypeWSOpenStream      uint8 = 0x59
+)
+
+// WebSocket opcodes as carried in the env, mirroring RFC 6455.
+const (
+	WSText   = "text"
+	WSBinary = "binary"
+)
+
+// Frame types on control connections.
+const (
+	TypeWorkerStatus uint8 = 0x40
+	TypeSetSlots     uint8 = 0x41
+	TypeQuiesce      uint8 = 0x42
+	TypeShutdown     uint8 = 0x43
+	TypePing         uint8 = 0x44
+	TypePong         uint8 = 0x45
+)
+
+// body_mode values in the REQUEST fixed meta.
+const (
+	BodyNone   uint8 = 0
+	BodyInline uint8 = 1
+	BodyStream uint8 = 2
+)
+
+// http_version values in the REQUEST fixed meta.
+const (
+	HTTP10 uint8 = 10
+	HTTP11 uint8 = 11
+	HTTP2  uint8 = 20
+	HTTP3  uint8 = 30
+)
+
+const (
+	// Version is the protocol version advertised in HELLO.
+	Version = "1"
+
+	// HeaderSize is the fixed frame header: u8 type, u24 reserved, u32 length.
+	HeaderSize = 8
+
+	// MaxPayload bounds a single frame's payload. A peer announcing more than
+	// this is corrupt or hostile; we close rather than attempt the allocation.
+	MaxPayload = 16 << 20
+
+	// ChunkTarget is the payload size body/response chunk frames aim for.
+	ChunkTarget = 64 << 10
+
+	// InlineBodyMax is the largest request body carried inside a REQUEST frame.
+	// Above this, Go switches the request to BodyStream.
+	InlineBodyMax = 64 << 10
+
+	// RequestMetaSize is the fixed meta preceding a REQUEST frame's env blob.
+	RequestMetaSize = 26
+
+	// RespEndMetaSize is the fixed meta preceding a RESP_END frame's trailers.
+	RespEndMetaSize = 32
+)
+
+var (
+	// ErrPayloadTooLarge means the peer announced a frame beyond MaxPayload.
+	ErrPayloadTooLarge = errors.New("wire: payload exceeds maximum")
+
+	// ErrTruncated means a payload ended in the middle of a field.
+	ErrTruncated = errors.New("wire: truncated payload")
+)
+
+// TypeName renders a frame type for logs and errors.
+func TypeName(t uint8) string {
+	switch t {
+	case TypeHello:
+		return "HELLO"
+	case TypeRequest:
+		return "REQUEST"
+	case TypeBodyChunk:
+		return "BODY_CHUNK"
+	case TypeBodyEnd:
+		return "BODY_END"
+	case TypeResponse:
+		return "RESPONSE"
+	case TypeRespChunk:
+		return "RESP_CHUNK"
+	case TypeRespEnd:
+		return "RESP_END"
+	case TypeHijack:
+		return "HIJACK"
+	case TypeGoaway:
+		return "GOAWAY"
+	case TypeWorkerStatus:
+		return "WORKER_STATUS"
+	case TypeSetSlots:
+		return "SET_SLOTS"
+	case TypeQuiesce:
+		return "QUIESCE"
+	case TypeShutdown:
+		return "SHUTDOWN"
+	case TypePing:
+		return "PING"
+	case TypePong:
+		return "PONG"
+	case TypeWSSend:
+		return "WS_SEND"
+	case TypeWSPublish:
+		return "WS_PUBLISH"
+	case TypeWSSubscribe:
+		return "WS_SUBSCRIBE"
+	case TypeWSUnsubscribe:
+		return "WS_UNSUBSCRIBE"
+	case TypeWSClose:
+		return "WS_CLOSE"
+	case TypeWSQuery:
+		return "WS_QUERY"
+	case TypeWSQueryReply:
+		return "WS_QUERY_REPLY"
+	case TypeWSDatagram:
+		return "WS_DATAGRAM"
+	case TypeWSPublishDatagram:
+		return "WS_PUBLISH_DATAGRAM"
+	case TypeWSOpenStream:
+		return "WS_OPEN_STREAM"
+	default:
+		return fmt.Sprintf("UNKNOWN(0x%02x)", t)
+	}
+}
+
+// Pair is one entry in a kv blob. Duplicate keys are permitted and meaningful in
+// header blobs, where they encode Rack 3 array-valued headers in wire order, so
+// a kv blob is an ordered slice rather than a map.
+type Pair struct {
+	Key   []byte
+	Value []byte
+}
+
+// AppendHeader appends an 8-byte frame header for a payload of n bytes.
+// The reserved u24 is written as zero.
+func AppendHeader(dst []byte, t uint8, n int) []byte {
+	return append(dst, t, 0, 0, 0,
+		byte(n>>24), byte(n>>16), byte(n>>8), byte(n))
+}
+
+// AppendKV appends a kv blob: u32 count, then count × (u16 klen, k, u32 vlen, v).
+func AppendKV(dst []byte, pairs []Pair) []byte {
+	dst = binary.BigEndian.AppendUint32(dst, uint32(len(pairs)))
+	for _, p := range pairs {
+		dst = binary.BigEndian.AppendUint16(dst, uint16(len(p.Key)))
+		dst = append(dst, p.Key...)
+		dst = binary.BigEndian.AppendUint32(dst, uint32(len(p.Value)))
+		dst = append(dst, p.Value...)
+	}
+	return dst
+}
+
+// KVSize returns the encoded byte length of a kv blob, for pre-sizing buffers.
+func KVSize(pairs []Pair) int {
+	n := 4
+	for _, p := range pairs {
+		n += 2 + len(p.Key) + 4 + len(p.Value)
+	}
+	return n
+}
+
+// DecodeKV parses a kv blob from the front of buf, returning the pairs and the
+// remaining bytes. Keys and values are subslices of buf, not copies: callers that
+// retain them past the lifetime of buf must copy. For the request hot path that
+// aliasing is the point, since the whole env is byteslices of one payload.
+func DecodeKV(buf []byte) ([]Pair, []byte, error) {
+	if len(buf) < 4 {
+		return nil, nil, ErrTruncated
+	}
+	count := binary.BigEndian.Uint32(buf)
+	buf = buf[4:]
+
+	// A count field is 4 bytes and the smallest possible pair is 6, so a count
+	// larger than the remaining bytes can never be satisfied. Checking here stops
+	// a corrupt length from driving a huge allocation before we read anything.
+	if uint64(count) > uint64(len(buf)) {
+		return nil, nil, ErrTruncated
+	}
+
+	pairs := make([]Pair, 0, count)
+	for i := uint32(0); i < count; i++ {
+		if len(buf) < 2 {
+			return nil, nil, ErrTruncated
+		}
+		kl := int(binary.BigEndian.Uint16(buf))
+		buf = buf[2:]
+		if len(buf) < kl {
+			return nil, nil, ErrTruncated
+		}
+		key := buf[:kl]
+		buf = buf[kl:]
+
+		if len(buf) < 4 {
+			return nil, nil, ErrTruncated
+		}
+		vl := int(binary.BigEndian.Uint32(buf))
+		buf = buf[4:]
+		if vl < 0 || len(buf) < vl {
+			return nil, nil, ErrTruncated
+		}
+		val := buf[:vl]
+		buf = buf[vl:]
+
+		pairs = append(pairs, Pair{Key: key, Value: val})
+	}
+	return pairs, buf, nil
+}
+
+// RequestMeta is the fixed 26-byte struct at the head of a REQUEST payload.
+type RequestMeta struct {
+	// QueueNs is T3-T2b: nanoseconds the request spent runnable but unserved.
+	// This is the product's headline metric, measured entirely inside Go.
+	QueueNs uint64
+	// RunnableWallUs is unix wall microseconds at T2b, used only to synthesize
+	// X-Request-Start for APM gems.
+	RunnableWallUs uint64
+	// BodyWaitNs is T2-T2b: time spent waiting on the client to send the body.
+	BodyWaitNs  uint64
+	HTTPVersion uint8
+	BodyMode    uint8
+}
+
+// AppendRequestMeta appends the fixed 26-byte REQUEST meta.
+func AppendRequestMeta(dst []byte, m RequestMeta) []byte {
+	dst = binary.BigEndian.AppendUint64(dst, m.QueueNs)
+	dst = binary.BigEndian.AppendUint64(dst, m.RunnableWallUs)
+	dst = binary.BigEndian.AppendUint64(dst, m.BodyWaitNs)
+	return append(dst, m.HTTPVersion, m.BodyMode)
+}
+
+// DecodeRequestMeta parses the fixed meta, returning it and the remaining bytes.
+func DecodeRequestMeta(buf []byte) (RequestMeta, []byte, error) {
+	if len(buf) < RequestMetaSize {
+		return RequestMeta{}, nil, ErrTruncated
+	}
+	return RequestMeta{
+		QueueNs:        binary.BigEndian.Uint64(buf[0:]),
+		RunnableWallUs: binary.BigEndian.Uint64(buf[8:]),
+		BodyWaitNs:     binary.BigEndian.Uint64(buf[16:]),
+		HTTPVersion:    buf[24],
+		BodyMode:       buf[25],
+	}, buf[RequestMetaSize:], nil
+}
+
+// RespEndMeta is the fixed 24-byte struct at the head of a RESP_END payload.
+// These are piggybacked on the response so per-request timing costs no extra
+// frame and no extra syscall.
+type RespEndMeta struct {
+	// ServiceNs is wall time inside app.call.
+	ServiceNs uint64
+	// CPUNs is the CLOCK_THREAD_CPUTIME_ID delta across app.call. The controller
+	// derives io_fraction = 1 - CPUNs/ServiceNs from it.
+	CPUNs uint64
+	// BodyReadNs is time blocked reading a streamed request body, subtracted from
+	// service time so a slow uploader cannot inflate it.
+	BodyReadNs uint64
+	// GVLWaitNs is the worker PROCESS's cumulative nanoseconds spent waiting for
+	// the GVL, across all its threads, as of this response. A counter, not a
+	// per-request delta -- Go differences it between observations.
+	//
+	// Cumulative rather than per-request because a per-request delta measures the
+	// wrong window and understates the contention by an order of magnitude. A
+	// worker thread spends most of its GVL wait BEFORE it can start measuring:
+	// it wakes from a blocking socket read, becomes runnable, and queues for the
+	// GVL -- all before the request handler runs and captures a starting value.
+	// Measured on a 6-thread worker under pure CPU load, the per-request delta
+	// reported a 0.03 GVL fraction where the true figure was near 0.80. A
+	// controller acting on 0.03 would conclude threads were fine, which is
+	// exactly the mistake this measurement exists to prevent.
+	//
+	// Zero when the optional native extension is absent, which is why the
+	// controller distinguishes "unknown" from "no contention".
+	GVLWaitNs uint64
+}
+
+// AppendRespEndMeta appends the fixed 24-byte RESP_END meta.
+func AppendRespEndMeta(dst []byte, m RespEndMeta) []byte {
+	dst = binary.BigEndian.AppendUint64(dst, m.ServiceNs)
+	dst = binary.BigEndian.AppendUint64(dst, m.CPUNs)
+	dst = binary.BigEndian.AppendUint64(dst, m.BodyReadNs)
+	return binary.BigEndian.AppendUint64(dst, m.GVLWaitNs)
+}
+
+// DecodeRespEndMeta parses the fixed meta, returning it and the remaining bytes.
+func DecodeRespEndMeta(buf []byte) (RespEndMeta, []byte, error) {
+	if len(buf) < RespEndMetaSize {
+		return RespEndMeta{}, nil, ErrTruncated
+	}
+	return RespEndMeta{
+		ServiceNs:  binary.BigEndian.Uint64(buf[0:]),
+		CPUNs:      binary.BigEndian.Uint64(buf[8:]),
+		BodyReadNs: binary.BigEndian.Uint64(buf[16:]),
+		GVLWaitNs:  binary.BigEndian.Uint64(buf[24:]),
+	}, buf[RespEndMetaSize:], nil
+}
+
+// Reader reads frames from a connection, reusing one buffer across frames so the
+// steady-state hot path does not allocate.
+type Reader struct {
+	r   io.Reader
+	hdr [HeaderSize]byte
+	buf []byte
+}
+
+// NewReader wraps r. The caller is responsible for any buffering underneath;
+// Reader issues one ReadFull for the header and one for the payload.
+func NewReader(r io.Reader) *Reader { return &Reader{r: r} }
+
+// ReadFrame reads the next frame. The returned payload aliases an internal buffer
+// that the next ReadFrame call will overwrite — copy anything you retain.
+func (fr *Reader) ReadFrame() (uint8, []byte, error) {
+	if _, err := io.ReadFull(fr.r, fr.hdr[:]); err != nil {
+		return 0, nil, err
+	}
+	t := fr.hdr[0]
+	// hdr[1:4] is the reserved u24. Per spec we ignore its value rather than
+	// rejecting non-zero, so it can later become a stream id.
+	n := int(binary.BigEndian.Uint32(fr.hdr[4:]))
+	if n > MaxPayload {
+		return 0, nil, fmt.Errorf("%w: %s announced %d bytes", ErrPayloadTooLarge, TypeName(t), n)
+	}
+	if n == 0 {
+		return t, nil, nil
+	}
+	if cap(fr.buf) < n {
+		fr.buf = make([]byte, n)
+	}
+	fr.buf = fr.buf[:n]
+	if _, err := io.ReadFull(fr.r, fr.buf); err != nil {
+		// A short payload after a good header means the peer died mid-frame.
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+		return 0, nil, err
+	}
+	return t, fr.buf, nil
+}
+
+// Writer writes frames to a connection, reusing one buffer so header and payload
+// go out in a single write syscall.
+type Writer struct {
+	w   io.Writer
+	buf []byte
+}
+
+// NewWriter wraps w.
+func NewWriter(w io.Writer) *Writer { return &Writer{w: w} }
+
+// WriteFrame writes one frame. Header and payload are combined into a single
+// write, so a frame never appears interleaved on the wire.
+func (fw *Writer) WriteFrame(t uint8, payload []byte) error {
+	fw.buf = AppendHeader(fw.buf[:0], t, len(payload))
+	fw.buf = append(fw.buf, payload...)
+	_, err := fw.w.Write(fw.buf)
+	return err
+}

data/go/vendor/github.com/dunglas/httpsfv/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2020 Kévin Dunglas. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/go/vendor/github.com/dunglas/httpsfv/README.md

@@ -0,0 +1,25 @@
+# httpsfv: Structured Field Values for HTTP in Go
+
+This [Go (golang)](https://golang.org) library implements parsing and serialization for [Structured Field Values for HTTP (RFC 9651 and 8941)](https://httpwg.org/specs/rfc9651.html).
+
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/dunglas/httpsfv)](https://pkg.go.dev/github.com/dunglas/httpsfv)
+![CI](https://github.com/dunglas/httpsfv/workflows/CI/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/github/dunglas/httpsfv/badge.svg?branch=master)](https://coveralls.io/github/dunglas/httpsfv?branch=master)
+[![Go Report Card](https://goreportcard.com/badge/github.com/dunglas/httpsfv)](https://goreportcard.com/report/github.com/dunglas/httpsfv)
+
+## Features
+
+* Fully implementing the RFC
+* Compliant with [the official test suite](https://github.com/httpwg/structured-field-tests)
+* Unit and fuzz tested
+* Strongly-typed
+* Fast (see [the benchmark](httpwg_test.go))
+* No dependencies
+
+## Docs
+
+[Browse the documentation on Go.dev](https://pkg.go.dev/github.com/dunglas/httpsfv).
+
+## Credits
+
+Created by [Kévin Dunglas](https://dunglas.fr). Sponsored by [Les-Tilleuls.coop](https://les-tilleuls.coop).

data/go/vendor/github.com/dunglas/httpsfv/bareitem.go

@@ -0,0 +1,115 @@
+package httpsfv
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+)
+
+// ErrInvalidBareItem is returned when a bare item is invalid.
+var ErrInvalidBareItem = errors.New(
+	"invalid bare item type (allowed types are bool, string, int64, float64, []byte, time.Time and Token)",
+)
+
+// assertBareItem asserts that v is a valid bare item
+// according to https://httpwg.org/specs/rfc9651.html#item.
+//
+// v can be either:
+//
+// * an integer (Section 3.3.1.)
+// * a decimal (Section 3.3.2.)
+// * a string (Section 3.3.3.)
+// * a token (Section 3.3.4.)
+// * a byte sequence (Section 3.3.5.)
+// * a boolean (Section 3.3.6.)
+// * a date (Section 3.3.7.)
+// * a display string (Section 3.3.8.)
+func assertBareItem(v interface{}) {
+	switch v.(type) {
+	case bool,
+		string,
+		int,
+		int8,
+		int16,
+		int32,
+		int64,
+		uint,
+		uint8,
+		uint16,
+		uint32,
+		uint64,
+		float32,
+		float64,
+		[]byte,
+		time.Time,
+		Token,
+		DisplayString:
+		return
+	default:
+		panic(fmt.Errorf("%w: got %s", ErrInvalidBareItem, reflect.TypeOf(v)))
+	}
+}
+
+// marshalBareItem serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-bare-item.
+func marshalBareItem(b *strings.Builder, v interface{}) error {
+	switch v := v.(type) {
+	case bool:
+		return marshalBoolean(b, v)
+	case string:
+		return marshalString(b, v)
+	case int64:
+		return marshalInteger(b, v)
+	case int, int8, int16, int32:
+		return marshalInteger(b, reflect.ValueOf(v).Int())
+	case uint, uint8, uint16, uint32, uint64:
+		// Casting an uint64 to an int64 is possible because the maximum allowed value is 999,999,999,999,999
+		return marshalInteger(b, int64(reflect.ValueOf(v).Uint()))
+	case float32, float64:
+		return marshalDecimal(b, v.(float64))
+	case []byte:
+		return marshalBinary(b, v)
+	case time.Time:
+		return marshalDate(b, v)
+	case Token:
+		return v.marshalSFV(b)
+	case DisplayString:
+		return v.marshalSFV(b)
+	default:
+		panic(ErrInvalidBareItem)
+	}
+}
+
+// parseBareItem parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-bare-item.
+func parseBareItem(s *scanner) (interface{}, error) {
+	if s.eof() {
+		return nil, &UnmarshalError{s.off, ErrUnexpectedEndOfString}
+	}
+
+	c := s.data[s.off]
+	switch c {
+	case '"':
+		return parseString(s)
+	case '?':
+		return parseBoolean(s)
+	case '*':
+		return parseToken(s)
+	case ':':
+		return parseBinary(s)
+	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		return parseNumber(s)
+	case '@':
+		return parseDate(s)
+	case '%':
+		return parseDisplayString(s)
+	default:
+		if isAlpha(c) {
+			return parseToken(s)
+		}
+
+		return nil, &UnmarshalError{s.off, ErrUnrecognizedCharacter}
+	}
+}

data/go/vendor/github.com/dunglas/httpsfv/binary.go

@@ -0,0 +1,59 @@
+package httpsfv
+
+import (
+	"encoding/base64"
+	"errors"
+	"strings"
+)
+
+// ErrInvalidBinaryFormat is returned when the binary format is invalid.
+var ErrInvalidBinaryFormat = errors.New("invalid binary format")
+
+// marshalBinary serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-binary.
+func marshalBinary(b *strings.Builder, bs []byte) error {
+	if err := b.WriteByte(':'); err != nil {
+		return err
+	}
+
+	buf := make([]byte, base64.StdEncoding.EncodedLen(len(bs)))
+	base64.StdEncoding.Encode(buf, bs)
+
+	if _, err := b.Write(buf); err != nil {
+		return err
+	}
+
+	return b.WriteByte(':')
+}
+
+// parseBinary parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-binary.
+func parseBinary(s *scanner) ([]byte, error) {
+	if s.eof() || s.data[s.off] != ':' {
+		return nil, &UnmarshalError{s.off, ErrInvalidBinaryFormat}
+	}
+	s.off++
+
+	start := s.off
+
+	for !s.eof() {
+		c := s.data[s.off]
+		if c == ':' {
+			// base64decode
+			decoded, err := base64.StdEncoding.DecodeString(s.data[start:s.off])
+			if err != nil {
+				return nil, &UnmarshalError{s.off, err}
+			}
+			s.off++
+
+			return decoded, nil
+		}
+
+		if !isAlpha(c) && !isDigit(c) && c != '+' && c != '/' && c != '=' {
+			return nil, &UnmarshalError{s.off, ErrInvalidBinaryFormat}
+		}
+		s.off++
+	}
+
+	return nil, &UnmarshalError{s.off, ErrInvalidBinaryFormat}
+}

data/go/vendor/github.com/dunglas/httpsfv/boolean.go

@@ -0,0 +1,49 @@
+package httpsfv
+
+import (
+	"errors"
+	"io"
+)
+
+// ErrInvalidBooleanFormat is returned when a boolean format is invalid.
+var ErrInvalidBooleanFormat = errors.New("invalid boolean format")
+
+// marshalBoolean serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-boolean.
+func marshalBoolean(bd io.StringWriter, b bool) error {
+	if b {
+		_, err := bd.WriteString("?1")
+
+		return err
+	}
+
+	_, err := bd.WriteString("?0")
+
+	return err
+}
+
+// parseBoolean parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-boolean.
+func parseBoolean(s *scanner) (bool, error) {
+	if s.eof() || s.data[s.off] != '?' {
+		return false, &UnmarshalError{s.off, ErrInvalidBooleanFormat}
+	}
+	s.off++
+
+	if s.eof() {
+		return false, &UnmarshalError{s.off, ErrInvalidBooleanFormat}
+	}
+
+	switch s.data[s.off] {
+	case '0':
+		s.off++
+
+		return false, nil
+	case '1':
+		s.off++
+
+		return true, nil
+	}
+
+	return false, &UnmarshalError{s.off, ErrInvalidBooleanFormat}
+}