httpmsg

func AddHeader ¶

func AddHeader(message []byte, name, value string) ([]byte, error)

AddHeader adds a new header to an HTTP message.

Algorithm:

1. Find header end position (before separator)
2. Write message up to that position
3. Write new header bytes
4. Write CRLF
5. Write rest of message from that position onward
6. Return new message

Parameters:

• message: Original HTTP message
• name: Header name
• value: Header value

Returns:

• Modified HTTP message with new header
• Error if message is malformed

Example:

request := []byte("GET / HTTP/1.1\r\n\r\n")
modified, _ := AddHeader(request, "Host", "example.com")
// Returns: "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"

func AddHeaderIfNotExists ¶

func AddHeaderIfNotExists(request []byte, name, value string) ([]byte, error)

AddHeaderIfNotExists adds a header only if it doesn't already exist.

Algorithm:

1. Check if header exists
2. If not exists, add header
3. If exists, return unchanged

Parameters:

• request: HTTP request bytes
• name: Header name
• value: Header value

Returns:

• Modified request (unchanged if header exists)
• Error if request malformed

Example:

modified, _ := AddHeaderIfNotExists(request, "Accept", "application/json")

func AddMultipleParameters ¶

func AddMultipleParameters(request []byte, params []*Param) ([]byte, error)

AddMultipleParameters adds multiple parameters at once. Provides batch add operation.

Parameters:

• request: HTTP request bytes
• params: Parameters to add

Returns:

• Modified request with all parameters added
• Error if request malformed

Example:

params := []*Param{BuildParameter("a", "1", ParamURL), BuildParameter("b", "2", ParamURL)}
modified, _ := AddMultipleParameters(request, params)

func AddOrReplaceHeader ¶

func AddOrReplaceHeader(request []byte, name, value string) ([]byte, error)

AddOrReplaceHeader adds header if not exists, replaces if exists.

Algorithm:

1. Check if header exists
2. If exists, replace; if not, add

Parameters:

• request: HTTP request bytes
• name: Header name
• value: Header value

Returns:

• Modified request with header set
• Error if request malformed

Example:

modified, _ := AddOrReplaceHeader(request, "Authorization", "Bearer token")

func AddParameter ¶

func AddParameter(request []byte, param *Param) ([]byte, error)

AddParameter adds a parameter to an HTTP request.

Algorithm:

1. Analyze request to get current parameters and structure
2. Determine where to add parameter based on type
3. For ParamURL: Add to query string
4. For ParamBody: Add to request body (URL-encoded or multipart)
5. For ParamCookie: Add to Cookie header
6. Rebuild request with new parameter
7. Update Content-Length if body changed

Parameters:

• request: Original HTTP request
• param: Parameter to add (with Name(), Value(), Type())

Returns:

• Modified request with parameter added
• Error if request is malformed or parameter type unsupported

Example:

param := BuildParameter("token", "xyz", ParamURL)
modified, _ := AddParameter(request, param)

func AppendBody ¶

func AppendBody(request []byte, data []byte) ([]byte, error)

AppendBody appends data to the existing request body. Provides body append operation.

Algorithm:

1. Get current body
2. Append new data
3. Set combined body

Parameters:

• request: HTTP request bytes
• data: Data to append

Returns:

• Modified request with appended body
• Error if request malformed

Example:

modified, _ := AppendBody(request, []byte("&extra=data"))

func AppendBodyParameter ¶

func AppendBodyParameter(request []byte, name, value string) ([]byte, error)

AppendBodyParameter adds a body parameter without removing existing ones. Provides append operation.

Parameters:

• request: HTTP request bytes
• name: Parameter name
• value: Parameter value

Returns:

• Modified request with appended parameter
• Error if request malformed

Example:

modified, _ := AppendBodyParameter(request, "debug", "true")

func AppendToHeader ¶

func AppendToHeader(request []byte, name, appendValue string) ([]byte, error)

AppendToHeader appends a value to an existing header. If header doesn't exist, returns request unchanged.

Algorithm:

1. Find header offsets using GetHeaderOffsets
2. If header not found, return unchanged
3. Insert append value at the end of header value
4. Return modified request

Parameters:

• request: HTTP request bytes
• name: Header name to append to
• appendValue: Value to append (e.g., ", text/html")

Returns:

• Modified request with appended header value
• Error if request malformed

Example:

req, _ := AppendToHeader(request, "Accept", ", text/html")
// "Accept: text/plain" → "Accept: text/plain, text/html"

func AppendToPath ¶

func AppendToPath(request []byte, segment string) ([]byte, error)

AppendToPath appends a segment to path (before query string).

Algorithm:

1. Get current path without query
2. Get query string if present
3. Append segment to path
4. Reattach query string
5. Return modified request

Parameters:

• request: HTTP request bytes
• segment: Path segment to append (e.g., "/extra")

Returns:

• Modified request with appended path
• Error if request malformed

Example:

req, _ := AppendToPath(request, "/extra")
// "/api?id=1" → "/api/extra?id=1"

func AppendURLParameter ¶

func AppendURLParameter(request []byte, name, value string) ([]byte, error)

AppendURLParameter adds a URL parameter without removing existing ones. Provides append operation.

Algorithm:

1. Get current query string
2. URL-encode new parameter
3. Append with '&' separator if query exists
4. Call SetQueryString

Parameters:

• request: HTTP request bytes
• name: Parameter name
• value: Parameter value

Returns:

• Modified request with appended parameter
• Error if request malformed

Example:

modified, _ := AppendURLParameter(request, "debug", "true")
// For "?id=123" creates "?id=123&debug=true"

func Base64Decode ¶

func Base64Decode(s string) ([]byte, error)

Base64Decode decodes a Base64-encoded string.

Example:

Base64Decode("aGVsbG8=")         // Returns []byte("hello"), nil
Base64Decode("aGVsbG8gd29ybGQ=") // Returns []byte("hello world"), nil
Base64Decode("invalid!")         // Returns nil, error

Parameters:

• s: Base64-encoded string to decode

Returns:

• Decoded bytes
• Error if decoding fails

func Base64DecodeBytes ¶

func Base64DecodeBytes(data []byte) ([]byte, error)

Base64DecodeBytes decodes Base64-encoded bytes.

Example:

Base64DecodeBytes([]byte("aGVsbG8="))         // Returns []byte("hello"), nil
Base64DecodeBytes([]byte("aGVsbG8gd29ybGQ=")) // Returns []byte("hello world"), nil

Parameters:

• data: Base64-encoded byte array to decode

Returns:

• Decoded bytes
• Error if decoding fails

func Base64Encode ¶

func Base64Encode(s string) string

Base64Encode encodes a string to Base64.

Example:

Base64Encode("hello")      // Returns "aGVsbG8="
Base64Encode("hello world") // Returns "aGVsbG8gd29ybGQ="

Parameters:

• s: String to encode

Returns:

• Base64-encoded string

func Base64EncodeBytes ¶

func Base64EncodeBytes(data []byte) string

Base64EncodeBytes encodes bytes to Base64 string.

Example:

Base64EncodeBytes([]byte("hello"))      // Returns "aGVsbG8="
Base64EncodeBytes([]byte{0x01, 0x02})   // Returns "AQI="

Parameters:

• data: Byte array to encode

Returns:

• Base64-encoded string

func BuildHttpMessage ¶

func BuildHttpMessage(headers []string, body []byte) []byte

BuildHttpMessage builds an HTTP message from headers and body.

Algorithm:

1. Write each header line followed by CRLF
2. Write additional CRLF to separate headers from body
3. Append body bytes if present
4. Return complete message as byte array

Parameters:

• headers: List of HTTP headers (including request/status line as first element)
• body: Message body bytes (can be nil for no body)

Returns:

• Complete HTTP message as byte array

Example:

headers := []string{"GET / HTTP/1.1", "Host: example.com"}
body := []byte("test data")
message := BuildHttpMessage(headers, body)
// Returns: "GET / HTTP/1.1\r\nHost: example.com\r\n\r\ntest data"

func BuildHttpRequest ¶

func BuildHttpRequest(urlStr string) ([]byte, error)

BuildHttpRequest builds a basic HTTP GET request for a URL.

Parameters:

• urlStr: Complete URL string (e.g., "http://example.com:8080/path")

Returns:

• HTTP GET request bytes
• Error if URL parsing fails

Example:

request, _ := BuildHttpRequest("http://example.com/api")
// Returns: "GET /api HTTP/1.1\r\nHost: example.com\r\n\r\n"

func BuildRawResponse ¶

func BuildRawResponse(statusCode int, headers map[string]string, body string) []byte

BuildRawResponse creates raw HTTP response bytes from components. This is useful for building responses from parsed data (e.g., parquet records).

func BuildRequestWithPayloads ¶

func BuildRequestWithPayloads(request []byte, payloads PayloadMap) ([][]byte, error)

BuildRequestWithPayloads injects custom payloads into multiple params simultaneously. Each insertion point applies its own encoding automatically based on parameter type.

If conflicting IPs exist (e.g., nested IP and its parent both in payloads), automatically splits into multiple requests - one per non-conflicting group.

func BuildRequestWithSamePayload ¶

func BuildRequestWithSamePayload(request []byte, insertionPoints []InsertionPoint, payload []byte) ([][]byte, error)

BuildRequestWithSamePayload injects the same payload into all insertion points.

func ByteArrayEquals ¶

func ByteArrayEquals(a, b []byte) bool

ByteArrayEquals compares two byte arrays for equality.

Example:

a := []byte("hello")
b := []byte("hello")
c := []byte("world")
ByteArrayEquals(a, b) // true
ByteArrayEquals(a, c) // false

Parameters:

• a: First byte array
• b: Second byte array

Returns:

• true if arrays are equal, false otherwise

func ByteArrayEqualsCaseInsensitive ¶

func ByteArrayEqualsCaseInsensitive(a, b []byte) bool

ByteArrayEqualsCaseInsensitive compares two byte arrays (case-insensitive).

Algorithm: 1. Check if both arrays are null 2. Check if lengths differ 3. Loop through arrays comparing each byte (lowercased) 4. Return true if all bytes match, false otherwise

Example:

a := []byte("Hello")
b := []byte("HELLO")
c := []byte("world")
ByteArrayEqualsCaseInsensitive(a, b) // true
ByteArrayEqualsCaseInsensitive(a, c) // false

Parameters:

• a: First byte array
• b: Second byte array

Returns:

• true if arrays are equal (ignoring case), false otherwise

func ByteArrayStartsWith ¶

func ByteArrayStartsWith(haystack, needle []byte, caseSensitive bool, offset int) bool

ByteArrayStartsWith checks if haystack starts with needle at given offset.

Example:

data := []byte("Hello World")
ByteArrayStartsWith(data, []byte("Hello"), true, 0)  // true
ByteArrayStartsWith(data, []byte("World"), true, 6)  // true
ByteArrayStartsWith(data, []byte("world"), false, 6) // true (case-insensitive)

Parameters:

• haystack: Data to search in
• needle: Pattern to match
• caseSensitive: Whether comparison is case-sensitive
• offset: Position in haystack to start comparison

Returns:

• true if haystack starts with needle at offset

func BytesToHexString ¶

func BytesToHexString(data []byte) string

BytesToHexString converts bytes to hex string (space-separated).

Algorithm:

1. Loop through bytes
2. Convert each byte to 2-digit hex
3. Join with spaces

Parameters:

• data: Byte array to convert

Returns:

• Hex string with space separators (e.g., "48 65 6c 6c 6f")

Example:

hex := BytesToHexString([]byte("Hello"))  // "48 65 6c 6c 6f"

func BytesToString ¶

func BytesToString(b []byte) string

BytesToString converts byte array to string.

Note: For proper UTF-8 handling, use string(b) directly in production code.

Example:

BytesToString([]byte{104, 101, 108, 108, 111})   // Returns "hello"
BytesToString([]byte{})                           // Returns ""

Parameters:

• b: Byte array to convert

Returns:

• String

func ClearBody ¶

func ClearBody(request []byte) ([]byte, error)

ClearBody removes the body from an HTTP request. Provides body removal.

Algorithm:

1. Set body to empty byte array
2. Remove Content-Length and Content-Type headers

Parameters:

• request: HTTP request bytes

Returns:

• Modified request without body
• Error if request malformed

Example:

modified, _ := ClearBody(request)

func ClearQueryString ¶

func ClearQueryString(request []byte) ([]byte, error)

ClearQueryString removes all query parameters from a request. Provides query removal.

Algorithm:

1. Get path without query using GetPathOnly
2. Set path to path-only value

Parameters:

• request: HTTP request bytes

Returns:

• Modified request without query string
• Error if request malformed

Example:

modified, _ := ClearQueryString(request)
// Changes "/api?id=123&name=test" to "/api"

func CloneRequest ¶

func CloneRequest(request []byte) []byte

CloneRequest creates a deep copy of a request.

Parameters:

• request: HTTP request bytes

Returns:

• Cloned request

Example:

clone := CloneRequest(request)

func CompressBytes ¶

func CompressBytes(input []byte) []byte

CompressBytes is a convenience function for simple gzip compression.

func ContainsBytes ¶

func ContainsBytes(data, pattern []byte) bool

ContainsBytes checks if data contains the pattern.

Algorithm:

1. Use IndexOfBytes to find first occurrence
2. Return true if found (index != -1)

Parameters:

• data: Byte array to search in
• pattern: Byte pattern to find

Returns:

• true if pattern is found in data
• false if pattern is nil or empty

Example:

found := ContainsBytes(data, []byte("test"))  // true if "test" found

func ConvertToHTTP1 ¶

func ConvertToHTTP1(request []byte) []byte

ConvertToHTTP1 converts HTTP/2 request to HTTP/1.1.

Algorithm:

1. Find "HTTP/2" in request line
2. Replace with "HTTP/1.1"
3. Return modified request

Parameters:

• request: HTTP request bytes (may be HTTP/2)

Returns:

• Request converted to HTTP/1.1

Example:

req := ConvertToHTTP1(request)  // "HTTP/2" → "HTTP/1.1"

func CountMatches ¶

func CountMatches(data, pattern []byte) int

CountMatches counts occurrences of pattern in data.

Algorithm:

1. Start from position 0
2. Find each occurrence using IndexOfBytes
3. Move past each match and continue searching
4. Return total count

Parameters:

• data: Byte array to search in
• pattern: Byte pattern to count

Returns:

• Number of occurrences of pattern in data

Example:

count := CountMatches(data, []byte("ab"))  // counts all "ab" occurrences

func DecodePathValue ¶

func DecodePathValue(encoded string) string

DecodePathValue decodes URL-encoded path segments (RFC 3986). Unlike DecodeQueryValue, this does NOT convert '+' to space. Use for path segments; use DecodeQueryValue for query/body/cookie params.

RFC 3986 path encoding differs from query string encoding:

• Path: '+' is a literal character (no space conversion)
• Query: '+' represents space (form-encoding convention)

Algorithm:

1. Loop through string character by character
2. When '%' found, decode next 2 hex characters
3. '+' is kept as literal (NOT converted to space)
4. Otherwise, copy character as-is

Example:

DecodePathValue("api/v1%2B2")     // Returns "api/v1+2" (+ stays literal)
DecodePathValue("hello%20world") // Returns "hello world"
DecodePathValue("user%2Fadmin")  // Returns "user/admin"

Parameters:

• encoded: URL-encoded path segment

Returns:

• Decoded string

func DecodeQueryValue ¶

func DecodeQueryValue(encoded string) string

DecodeQueryValue decodes URL-encoded value using loop-based parsing. Handles %XX hex sequences and '+' to space conversion. NO REGEX, NO url.QueryUnescape per requirements.

Algorithm:

1. Loop through string character by character
2. When '%' found, decode next 2 hex characters
3. When '+' found, convert to space
4. Otherwise, copy character as-is

Example:

encoded := "John%20Doe+Smith"
decoded := DecodeQueryValue(encoded)
// Returns "John Doe Smith"

encoded := "hello%2Bworld"
decoded := DecodeQueryValue(encoded)
// Returns "hello+world"

Parameters:

• encoded: URL-encoded string

Returns:

• Decoded string

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	// Example 1: Percent encoding
	encoded1 := "John%20Doe"
	decoded1 := httpmsg.DecodeQueryValue(encoded1)
	fmt.Printf("Decoded: %s\n", decoded1)

	// Example 2: Plus encoding
	encoded2 := "hello+world"
	decoded2 := httpmsg.DecodeQueryValue(encoded2)
	fmt.Printf("Decoded: %s\n", decoded2)

	// Example 3: Mixed encoding
	encoded3 := "search+term%3A+golang%2Bpython"
	decoded3 := httpmsg.DecodeQueryValue(encoded3)
	fmt.Printf("Decoded: %s\n", decoded3)

}

Output:
Decoded: John Doe
Decoded: hello world
Decoded: search term: golang+python

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	examples := []string{
		"hello%2Bworld",   // Plus sign
		"a%3Db%26c%3Dd",   // Equals and ampersand
		"100%25+complete", // Percent sign
	}

	for _, encoded := range examples {
		decoded := httpmsg.DecodeQueryValue(encoded)
		fmt.Printf("%s -> %s\n", encoded, decoded)
	}

}

Output:
hello%2Bworld -> hello+world
a%3Db%26c%3Dd -> a=b&c=d
100%25+complete -> 100% complete

func DecompressBytes ¶

func DecompressBytes(input []byte) []byte

DecompressBytes is a convenience function for simple gzip decompression.

func DefaultUserAgent ¶

func DefaultUserAgent() string

DefaultUserAgent returns the effective User-Agent for the next outgoing request. The VIGOLIUM_DEFAULT_UA environment variable (when present) takes precedence over the configured selector; the selector is then resolved: "preset" -> the self-identifying Vigolium string, "random"/"" -> a rotating browser string (a fresh pick per call), any other value -> that literal. {version} is expanded throughout.

func EncodeBytesAbove7F ¶

func EncodeBytesAbove7F(input string) string

EncodeBytesAbove7F URL-encodes bytes with value > 0x7F.

Algorithm:

1. Loop through input bytes
2. If byte > 0x7F, encode as %XX
3. Otherwise keep as-is

Parameters:

• input: String that may contain high bytes

Returns:

• String with high bytes URL-encoded

Example:

encoded := EncodeBytesAbove7F("hello\x80world")
// Returns "hello%80world"

func EncodePathValue ¶

func EncodePathValue(decoded string) string

EncodePathValue encodes a string for safe use in URL path segments (RFC 3986). Unlike EncodeQueryValue, this encodes space as '%20' (not '+'). Use for path segments; use EncodeQueryValue for query/body/cookie params.

RFC 3986 path encoding differs from query string encoding:

• Path: space → %20 (percent encoding only)
• Query: space → + (form-encoding convention)

Algorithm:

1. Loop through string byte by byte
2. Encode unreserved characters as-is: A-Z, a-z, 0-9, -, _, ., ~
3. Encode everything else (including space and +) as %XX

Example:

EncodePathValue("hello world")   // Returns "hello%20world"
EncodePathValue("v1+2")          // Returns "v1%2B2"
EncodePathValue("user/admin")    // Returns "user%2Fadmin"

Parameters:

• decoded: String to encode

Returns:

• URL-encoded string for path segment

func EncodePathValueBytes ¶

func EncodePathValueBytes(src []byte) []byte

EncodePathValueBytes is the []byte-native form of EncodePathValue, avoiding the []byte→string→[]byte round trips on the path-parameter fuzzing hot path. Returns nil for empty input.

func EncodeQueryValue ¶

func EncodeQueryValue(decoded string) string

EncodeQueryValue encodes a string for safe use in URL query parameters. Uses loop-based encoding (NO REGEX, NO url.QueryEscape per requirements).

Algorithm:

1. Loop through string byte by byte
2. Encode unreserved characters as-is: A-Z, a-z, 0-9, -, _, ., ~
3. Encode space as '+'
4. Encode everything else as %XX hex sequence

Example:

EncodeQueryValue("John Doe")      // Returns "John+Doe"
EncodeQueryValue("hello+world")   // Returns "hello%2Bworld"
EncodeQueryValue("a=b&c=d")       // Returns "a%3Db%26c%3Dd"

Parameters:

• decoded: String to encode

Returns:

• URL-encoded string

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	// Example 1: Space to plus
	decoded1 := "John Doe"
	encoded1 := httpmsg.EncodeQueryValue(decoded1)
	fmt.Printf("Encoded: %s\n", encoded1)

	// Example 2: Special characters
	decoded2 := "hello+world"
	encoded2 := httpmsg.EncodeQueryValue(decoded2)
	fmt.Printf("Encoded: %s\n", encoded2)

	// Example 3: Equals and ampersand
	decoded3 := "a=b&c=d"
	encoded3 := httpmsg.EncodeQueryValue(decoded3)
	fmt.Printf("Encoded: %s\n", encoded3)

}

Output:
Encoded: John+Doe
Encoded: hello%2Bworld
Encoded: a%3Db%26c%3Dd

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	original := "Hello World & Friends!"

	// Encode
	encoded := httpmsg.EncodeQueryValue(original)
	fmt.Printf("Original: %s\n", original)
	fmt.Printf("Encoded:  %s\n", encoded)

	// Decode
	decoded := httpmsg.DecodeQueryValue(encoded)
	fmt.Printf("Decoded:  %s\n", decoded)
	fmt.Printf("Match:    %t\n", original == decoded)

}

Output:
Original: Hello World & Friends!
Encoded:  Hello+World+%26+Friends%21
Decoded:  Hello World & Friends!
Match:    true

func EncodeQueryValueBytes ¶

func EncodeQueryValueBytes(src []byte) []byte

EncodeQueryValueBytes is the []byte-native form of EncodeQueryValue. It avoids the []byte→string→[]byte round trips the string form forces on the insertion-point fuzzing hot path (encodePayload). Returns nil for empty input.

func EnsureURLScheme ¶ added in v0.4.8

func EnsureURLScheme(target, defaultScheme string) string

EnsureURLScheme prefixes a schemeless target with defaultScheme so callers all hand the rest of the pipeline the same absolute URL. A target that already names a scheme is returned untouched, whatever that scheme is.

It exists because "does this target have a scheme" has three different answers scattered around the tree, and only one of them is right. The HTTP phases never had to ask: urlutil.ParseAbsoluteURL accepts a bare host and GetRawRequestFromURL defaults the service protocol to http, so `-t example.com` or a -T file of bare hostnames sweeps fine under probe, discovery and known-issue-scan. The browser phase does have to ask -- spitolas parses its seed with net/url, where "example.com" is a path with no host ("target URL must have a host") and "example.com:8443" is worse still ("first path segment in URL cannot contain colon") -- so spidering hard-failed per target on the exact host lists the other phases scanned, and because it reports a failed crawl as a completed one with 0 records, `scan --only spidering --soft-fail` exited 0 with an empty export.

The default scheme is the caller's to choose because it is not the same everywhere: scan targets take http, so the normalized form stays byte-identical to the request the HTTP path already built for them (a host that only answers on 443 redirects there on the first hop), while a shim translating a tool that documents bare domains takes https.

func EnsureURLSchemeTracked ¶ added in v0.4.9

func EnsureURLSchemeTracked(target, defaultScheme string) (string, bool)

EnsureURLSchemeTracked is EnsureURLScheme plus whether the scheme was SUPPLIED by this call rather than typed by the operator.

The distinction is not cosmetic. "http" is a guess for a schemeless target, and a phase that can test the guess (the probe sweep, which connects before it requests) must be able to tell a guess from an instruction: an operator who typed `http://host` means http even if only 443 answers, while one who typed `host` meant "whatever this host speaks". Normalization happens early and in more than one place, so without recording the answer here the information is gone by the time any phase could act on it.

func EqualsCaseInsensitive ¶

func EqualsCaseInsensitive(a, b string) bool

EqualsCaseInsensitive compares two strings case-insensitively. Loop-based implementation (NO regex or library functions).

Parameters:

• a, b: Strings to compare

Returns:

• true if equal (case-insensitive), false otherwise

Logic:

1. Check length first (fast path)
2. Loop through each character
3. Convert to lowercase and compare

func EqualsIgnoreCase ¶

func EqualsIgnoreCase(a, b string) bool

EqualsIgnoreCase compares two strings case-insensitively.

func EstimateRetainedBytes ¶

func EstimateRetainedBytes(points []InsertionPoint) int

EstimateRetainedBytes approximates the heap retained by a set of insertion points produced by one CreateAllInsertionPoints call.

Byte buffers are counted once per distinct backing array. That is the whole point of the function: insertion points from a single call deliberately share their base request and parent-value buffers (see sharedBaseRequest and newEncodedInsertionPointShared), so summing len(baseRequest) per point would overstate retention by the child count — reproducing, in the estimate, exactly the quadratic blowup the sharing removed.

The result is an estimate for budgeting, not an exact measurement: it attributes shared Params per-point and ignores allocator overhead. It is intended to be stable and cheap (one pass, no allocation beyond the seen-set), not precise.

func ExtractAllHeaders ¶

func ExtractAllHeaders(data []byte) ([]string, []int, int, error)

ExtractAllHeaders is a convenience function that extracts headers from an HTTP request/response, automatically finding the header section.

Parameters:

• data: Complete HTTP request/response bytes

Returns:

• headers: List of header lines including request/status line
• headerOffsets: Byte offset where each header starts
• bodyStart: Position where body begins (after headers)
• error: Any parsing error

Logic:

1. Find header/body separator
2. Extract headers from start to separator
3. Return headers and body position

Example:

request := []byte("GET / HTTP/1.1\r\nHost: example.com\r\n\r\nBODY")
headers, offsets, bodyStart, _ := ExtractAllHeaders(request)
// headers = ["GET / HTTP/1.1", "Host: example.com"]
// offsets = [0, 16]
// bodyStart = 38

func ExtractBoundary ¶

func ExtractBoundary(contentType string) string

ExtractBoundary extracts the boundary string from a Content-Type header value.

Algorithm:

1. Search for "boundary=" in Content-Type header
2. Extract everything after "boundary="
3. Trim whitespace
4. Return boundary string

Example:

contentType := "multipart/form-data; boundary=----WebKitFormBoundary1234"
boundary := ExtractBoundary(contentType)
// Returns: "----WebKitFormBoundary1234"

Parameters:

• contentType: Content-Type header value

Returns:

• Boundary string, or empty string if not found

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	contentType := "multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW"
	boundary := httpmsg.ExtractBoundary(contentType)

	fmt.Println(boundary)
}

Output:
----WebKitFormBoundary7MA4YWxkTrZu0gW

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	contentType := "multipart/form-data; boundary=  ----WebKit  "
	boundary := httpmsg.ExtractBoundary(contentType)

	fmt.Printf("Boundary: '%s'\n", boundary)
}

Output:
Boundary: '----WebKit'

func ExtractHeaders ¶

func ExtractHeaders(request []byte, startOffset, endOffset int) ([]string, []int, error)

ExtractHeaders extracts HTTP headers from byte slice.

Parameters:

• request: HTTP request/response bytes
• startOffset: Starting position to parse from
• endOffset: Ending position (typically body start or end of data)

Returns:

• headers: List of header lines including request/status line
• headerOffsets: Byte offset where each header starts
• error: Any parsing error

Logic:

1. Loop through bytes from startOffset to endOffset
2. Find CRLF (\r\n) line terminators
3. Extract line between terminators
4. Skip empty lines
5. Track offset of each non-empty line
6. Return headers and their offsets

Example:

request := []byte("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
headers, offsets, _ := ExtractHeaders(request, 0, 36)
// headers = ["GET / HTTP/1.1", "Host: example.com"]
// offsets = [0, 16]

func ExtractURLFromRequest ¶

func ExtractURLFromRequest(request []byte) ([]byte, int, int, error)

ExtractURLFromRequest extracts URL from HTTP request line. Returns URL bytes and their start/end positions.

Parameters:

• request: HTTP request bytes

Returns:

• url: URL bytes (between first and second space)
• urlStart: Position where URL starts
• urlEnd: Position where URL ends
• error: Any parsing error

Algorithm:

1. Skip leading whitespace
2. Skip HTTP method (until first space)
3. Skip whitespace after method
4. Extract URL (until next space)
5. Return URL bytes and positions

Example:

request := []byte("GET /api/users?id=123 HTTP/1.1\r\n...")
url, start, end, _ := ExtractURLFromRequest(request)
// url = []byte("/api/users?id=123")
// start = 4, end = 21

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	request := []byte("GET /api/users?id=123 HTTP/1.1\r\nHost: example.com\r\n\r\n")

	urlBytes, start, end, err := httpmsg.ExtractURLFromRequest(request)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("URL: %s\n", string(urlBytes))
	fmt.Printf("Start: %d\n", start)
	fmt.Printf("End: %d\n", end)

}

Output:
URL: /api/users?id=123
Start: 4
End: 21

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	request := []byte("POST /api/create HTTP/1.1\r\nHost: api.example.com\r\nContent-Type: application/json\r\n\r\n{}")

	urlBytes, _, _, err := httpmsg.ExtractURLFromRequest(request)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("URL: %s\n", string(urlBytes))

}

Output:
URL: /api/create

func FilterString ¶

func FilterString(input, safeChars string) string

FilterString keeps only characters in safeChars.

Algorithm:

1. Loop through input characters
2. Check if character is in safeChars
3. Keep only matching characters

Parameters:

• input: String to filter
• safeChars: String containing allowed characters

Returns:

• Filtered string containing only safe characters

Example:

filtered := FilterString("abc123!@#", "abcdefghijklmnopqrstuvwxyz")
// Returns "abc"

func FindBodyEnd ¶

func FindBodyEnd(request []byte, startOffset int) int

FindBodyEnd finds the offset where the HTTP body ends (before trailing separators). This searches backwards from the end to find trailing CRLF CRLF or LF LF sequences.

Algorithm:

1. Search backwards for CRLF CRLF or LF LF
2. Return offset BEFORE the separator (end of actual body content)
3. If not found, return startOffset

Example:

response := []byte("HTTP/1.1 200 OK\r\n\r\nBODY\r\n\r\n")
bodyStart := FindBodyOffset(response)  // Returns 19
bodyEnd := FindBodyEnd(response, bodyStart)  // Returns 23 (before trailing \r\n\r\n)

Parameters:

• request: HTTP request or response bytes
• startOffset: Position to start searching from (typically body start)

Returns:

• Offset where body ends (before trailing separator)
• If no trailing separator, returns len(request)

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	response := []byte("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nBODY DATA\r\n\r\n")

	bodyStart := httpmsg.FindBodyOffset(response)
	bodyEnd := httpmsg.FindBodyEnd(response, bodyStart)

	fmt.Printf("Body starts at: %d\n", bodyStart)
	fmt.Printf("Body ends at: %d\n", bodyEnd)
	fmt.Printf("Body content: %s\n", string(response[bodyStart:bodyEnd]))

}

Output:
Body starts at: 44
Body ends at: 53
Body content: BODY DATA

func FindBodyOffset ¶

func FindBodyOffset(request []byte) int

FindBodyOffset finds the offset where the HTTP body starts in a request or response. This is the position immediately after the header/body separator.

Algorithm:

1. Search for CRLF CRLF sequence (0x0D 0x0A 0x0D 0x0A)
2. If not found, search for LF LF sequence (0x0A 0x0A)
3. If found, return offset AFTER the separator (body start position)
4. Handle edge case: check last 2 bytes for LF LF if main loop didn't find it
5. If no separator found, return length of data (no body)

Example:

request := []byte("GET / HTTP/1.1\r\nHost: example.com\r\n\r\nBODY")
offset := FindBodyOffset(request)
// Returns 38 (position where "BODY" starts)

Parameters:

• request: HTTP request or response bytes

Returns:

• Offset where body starts (after the separator)
• If no separator found, returns len(request)

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	request := []byte("GET / HTTP/1.1\r\nHost: example.com\r\nUser-Agent: test\r\n\r\nBODY DATA")

	offset := httpmsg.FindBodyOffset(request)
	fmt.Printf("Body starts at offset: %d\n", offset)
	fmt.Printf("Body content: %s\n", string(request[offset:]))

}

Output:
Body starts at offset: 55
Body content: BODY DATA

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	// HTTP request with body
	request := []byte("POST /api/data HTTP/1.1\r\n" +
		"Host: example.com\r\n" +
		"Content-Type: application/json\r\n" +
		"Content-Length: 18\r\n" +
		"\r\n" +
		"{\"key\":\"value\"}")

	// Find where body starts
	bodyOffset := httpmsg.FindBodyOffset(request)

	// Extract headers (everything before body)
	headers := httpmsg.SliceBytes(request, 0, bodyOffset-4) // -4 to exclude \r\n\r\n
	fmt.Printf("Headers length: %d bytes\n", len(headers))

	// Extract body
	body := httpmsg.SliceBytes(request, bodyOffset, len(request))
	fmt.Printf("Body: %s\n", string(body))

	// Find Content-Type in headers
	ctIdx := httpmsg.IndexOfBytes(headers, []byte("Content-Type:"), 0)
	if ctIdx != -1 {
		fmt.Println("Content-Type header found")
	}

}

Output:
Headers length: 94 bytes
Body: {"key":"value"}
Content-Type header found

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	request := []byte("GET / HTTP/1.1\nHost: example.com\nUser-Agent: test\n\nBODY DATA")

	offset := httpmsg.FindBodyOffset(request)
	fmt.Printf("Body starts at offset: %d\n", offset)
	fmt.Printf("Body content: %s\n", string(request[offset:]))

}

Output:
Body starts at offset: 51
Body content: BODY DATA

func FindCharIndex ¶

func FindCharIndex(s string, c byte) int

FindCharIndex finds first occurrence of character in string. Loop-based helper (no strings.Index).

Parameters:

• s: String to search
• c: Character byte to find

Returns:

• Index of first occurrence, or -1 if not found

func FindColonIndex ¶

func FindColonIndex(header string) int

FindColonIndex finds the first colon in a header line. Helper function for header parsing.

Parameters:

• header: Header line (e.g., "Content-Type: text/html")

Returns:

• Index of first colon, or -1 if not found

Logic:

• Loop through string looking for ':' character
• Return index when found
• Return -1 if not found

func FindHeaderBodySeparator ¶

func FindHeaderBodySeparator(data []byte, startOffset int) int

FindHeaderBodySeparator finds the position where headers end and body begins. Looks for double line terminator: \r\n\r\n or \n\n

Parameters:

• data: HTTP request/response bytes
• startOffset: Position to start searching from

Returns:

• Position after the double line terminator (start of body)
• Returns -1 if not found

Logic:

1. Search for CRLFCRLF (\r\n\r\n) sequence
2. Also search for LFLF (\n\n) sequence
3. Return position after separator
4. Handle edge case near end of data

Example:

request := []byte("GET / HTTP/1.1\r\nHost: example.com\r\n\r\nBODY")
bodyStart := FindHeaderBodySeparator(request, 0)
// bodyStart = 38 (position after \r\n\r\n)

func FindHostEnd ¶

func FindHostEnd(url []byte, hostStart int) int

FindHostEnd finds the end position of the host:port portion. Loop until '/', '?', '#', or end of string.

Parameters:

• url: URL bytes
• hostStart: Position where host begins

Returns:

• Position where host:port ends

Algorithm:

1. Loop from hostStart until path/query/fragment delimiter
2. Check for '/', '?', '#'
3. Return position of delimiter or end of string

Example:

url := []byte("example.com:8080/path")
end := FindHostEnd(url, 0)
// Returns 16 (position of '/')

func FindHttpHeader ¶

func FindHttpHeader(headers []HttpHeader, name string) (string, bool)

FindHttpHeader searches for a header by name (case-insensitive) in a slice of headers. Returns the value and true if found, empty string and false otherwise.

func FindLineEnd ¶

func FindLineEnd(data []byte, start, end int) int

FindLineEnd finds the position of the next line terminator. Helper function for header parsing.

Parameters:

• data: Byte slice to search
• start: Starting position
• end: Ending position

Returns:

• Position of CR or LF, or end if not found

Logic:

• Loop through bytes looking for 0x0D (CR) or 0x0A (LF)
• Return position when found
• Return end if no terminator found

func FindPathEnd ¶

func FindPathEnd(url []byte, pathStart int) int

FindPathEnd finds the end position of the path (before '?' or '#'). Loop until query or fragment delimiter.

Parameters:

• url: URL bytes
• pathStart: Position where path begins

Returns:

• Position where path ends (before '?' or '#')

Algorithm:

1. Loop from pathStart looking for '?' or '#'
2. Return position of delimiter
3. Return length if no delimiter found

Example:

url := []byte("/api/users?id=123#section")
end := FindPathEnd(url, 0)
// Returns 10 (position of '?')

func FindProtocolEnd ¶

func FindProtocolEnd(url []byte) int

FindProtocolEnd finds the end position of the protocol (before ://). Loop-based implementation (no regex).

Parameters:

• url: URL bytes to search

Returns:

• Position of ':' in "://", or -1 if not found

Algorithm:

1. Loop through bytes looking for "://" sequence
2. Return position of ':' when found
3. Return -1 if not found

Example:

url := []byte("http://example.com")
pos := FindProtocolEnd(url)
// Returns 4 (position of ':' in "http:")

func FindQueryEnd ¶

func FindQueryEnd(url []byte, queryStart int) int

FindQueryEnd finds the end position of the query string (before '#'). Loop until fragment delimiter.

Parameters:

• url: URL bytes
• queryStart: Position where query begins (after '?')

Returns:

• Position where query ends (before '#')

Algorithm:

1. Loop from queryStart looking for '#'
2. Also check for newline (byte 10) or space as terminators
3. Return position of delimiter
4. Return length if no delimiter found

Example:

url := []byte("id=123&name=test#section")
end := FindQueryEnd(url, 0)
// Returns 16 (position of '#')

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	url := []byte("http://example.com/path?foo=bar#anchor")

	start := httpmsg.FindQueryStart(url)
	// FindQueryEnd expects queryStart to be AFTER the '?', so we add 1
	end := httpmsg.FindQueryEnd(url, start+1)

	if start != -1 && end != -1 {
		fmt.Printf("Query string: %s\n", url[start+1:end])
	}

}

Output:
Query string: foo=bar

func FindQueryStart ¶

func FindQueryStart(url []byte) int

FindQueryStart finds the position of the '?' character in a URL. Uses simple loop-based search (NO REGEX per requirements). Note: For full query string bounds detection, use findQueryBounds instead.

Algorithm:

1. Loop through byte array
2. Return position when '?' (63) found
3. Return -1 if not found

Example:

url := []byte("http://example.com/path?foo=bar")
pos := FindQueryStart(url)
// Returns 23 (position of '?')

Parameters:

• url: URL byte array

Returns:

• Position of '?' character, or -1 if not found

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	url := []byte("http://example.com/path?foo=bar&name=value")

	pos := httpmsg.FindQueryStart(url)
	if pos != -1 {
		fmt.Printf("Query string starts at position: %d\n", pos)
		fmt.Printf("Query string: %s\n", url[pos:])
	}

}

Output:
Query string starts at position: 23
Query string: ?foo=bar&name=value

func FindQueryStringBounds ¶

func FindQueryStringBounds(urlPath []byte) (queryStart int, queryEnd int)

FindQueryStringBounds finds the start and end of query string in URL path. Returns indices of '?' and '#' delimiters.

Parameters:

• urlPath: URL path bytes (may contain query)

Returns:

• queryStart: Position of '?' (or -1 if not found)
• queryEnd: Position of '#' or end of string

Algorithm:

1. Loop through bytes looking for '?'
2. When found, mark start position
3. Continue looking for '#' or whitespace
4. Return [start, end] or nil if no query

Example:

path := []byte("/api/users?id=123#section")
start, end := FindQueryStringBounds(path)
// start = 10, end = 17

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	path := []byte("/api/users?id=123&status=active#results")

	start, end := httpmsg.FindQueryStringBounds(path)

	fmt.Printf("Query starts at: %d\n", start)
	fmt.Printf("Query ends at: %d\n", end)
	fmt.Printf("Query string: %s\n", string(path[start+1:end]))

}

Output:
Query starts at: 10
Query ends at: 31
Query string: id=123&status=active

func FlattenCookiesForHost ¶

func FlattenCookiesForHost(host string, cookies []*http.Cookie) string

FlattenCookiesForHost filters browser-harvested cookies down to those that apply to host and joins them into a Cookie header value ("a=1; b=2"). Cookies for unrelated domains are dropped so a session stays scoped to the host it was harvested from, as are expired ones. For a duplicated name the BROADEST (shortest) path wins: the result is one static header for the whole host, so the cookie most likely to apply to an arbitrary path is the right one to keep — previously it was whichever the browser happened to list first.

This is the attribute-losing flattening; it stays because a flat header is what several callers still want (and what CarriedSession.CookieHeader is). Per-request evaluation belongs in CarriedSession.CookieHeaderFor.

func GetAllCookies ¶

func GetAllCookies(request []byte) (map[string]string, error)

GetAllCookies returns all cookies as a map.

Parameters:

• request: HTTP request bytes

Returns:

• Map of cookie name → value
• Error if request malformed

Example:

cookies, _ := GetAllCookies(request)

func GetAllHeaderValues ¶

func GetAllHeaderValues(request []byte, name string) ([]string, error)

GetAllHeaderValues returns all values for a header (for multi-value headers).

Algorithm:

1. Extract all headers
2. Loop through and collect all matching header values
3. Return as slice

Parameters:

• request: HTTP request bytes
• name: Header name (case-insensitive)

Returns:

• Slice of all values for the header
• Error if request malformed

Example:

setCookies, _ := GetAllHeaderValues(request, "Set-Cookie")

func GetBody ¶

func GetBody(request []byte) ([]byte, error)

GetBody extracts the body portion from an HTTP request. Provides direct body access.

Algorithm:

1. Find body offset using FindBodyOffset
2. Return bytes from offset to end

Parameters:

• request: HTTP request bytes

Returns:

• Body bytes (empty if no body)
• Error if request malformed

Example:

body, _ := GetBody(request)
// Returns body portion as []byte

func GetBodyBytes ¶

func GetBodyBytes(request []byte, bodyOffset int) []byte

GetBodyBytes extracts the body portion of an HTTP request as a byte slice. Helper function for working with request bodies.

Parameters:

• request: Complete HTTP request bytes
• bodyOffset: Byte offset where body starts

Returns:

• Byte slice containing the body data
• Empty slice if bodyOffset is invalid

Example:

request := []byte("POST / HTTP/1.1\r\n\r\nname=value")
bodyOffset := FindBodyOffset(request)
body := GetBodyBytes(request, bodyOffset)
// body = []byte("name=value")

func GetBodyOffset ¶

func GetBodyOffset(request []byte) (int, error)

GetBodyOffset returns the offset where the body starts.

Parameters:

• request: HTTP request bytes

Returns:

• Body offset (-1 if no body)
• Error if request malformed

Example:

offset, _ := GetBodyOffset(request)

func GetBodyParametersMap ¶

func GetBodyParametersMap(request []byte) (map[string]string, error)

GetBodyParametersMap returns all body parameters as a map. Provides map-based body parameter access.

Parameters:

• request: HTTP request bytes

Returns:

• Map of parameter name → value
• Error if request malformed

Example:

params, _ := GetBodyParametersMap(request)

func GetBodySize ¶

func GetBodySize(request []byte) (int, error)

GetBodySize returns the size of the request body. Provides body size calculation.

Algorithm:

1. Find body offset
2. Calculate total length - offset

Parameters:

• request: HTTP request bytes

Returns:

• Body size in bytes
• Error if request malformed

Example:

size, _ := GetBodySize(request)

func GetBodyString ¶

func GetBodyString(request []byte) (string, error)

GetBodyString extracts the body as a string. Provides string body access.

Algorithm:

1. Get body bytes using GetBody
2. Convert to string

Parameters:

• request: HTTP request bytes

Returns:

• Body as string
• Error if request malformed

Example:

bodyStr, _ := GetBodyString(request)

func GetContentType ¶

func GetContentType(request []byte) (string, error)

GetContentType extracts the Content-Type header value.

Algorithm:

1. Call GetHeaderValue for "Content-Type"

Parameters:

• request: HTTP request bytes

Returns:

• Content-Type value
• Error if request malformed

Example:

contentType, _ := GetContentType(request)

func GetCookie ¶

func GetCookie(request []byte, name string) (string, error)

GetCookie extracts a single cookie value by name.

Parameters:

• request: HTTP request bytes
• name: Cookie name

Returns:

• Cookie value
• Error if request malformed

Example:

sessionId, _ := GetCookie(request, "JSESSIONID")

func GetDefaultPort ¶

func GetDefaultPort(protocol string) int

GetDefaultPort returns the default port for a protocol.

Parameters:

• protocol: Protocol string ("http", "https", etc.)

Returns:

• Default port (80 for http, 443 for https)
• -1 if protocol is unknown

Algorithm:

1. Convert protocol to lowercase using loop
2. Check for known protocols
3. Return corresponding default port

Example:

port := GetDefaultPort("HTTP")
// Returns 80

port := GetDefaultPort("https")
// Returns 443

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	fmt.Printf("HTTP default port: %d\n", httpmsg.GetDefaultPort("http"))
	fmt.Printf("HTTPS default port: %d\n", httpmsg.GetDefaultPort("https"))
	fmt.Printf("WS default port: %d\n", httpmsg.GetDefaultPort("ws"))
	fmt.Printf("WSS default port: %d\n", httpmsg.GetDefaultPort("wss"))

}

Output:
HTTP default port: 80
HTTPS default port: 443
WS default port: 80
WSS default port: 443

func GetExtension ¶

func GetExtension(request []byte) (string, error)

GetExtension extracts file extension from request path.

Algorithm:

1. Get path without query string
2. Find last '.' in path
3. Find last '/' in path
4. If '.' exists and is after last '/', return extension (including '.')
5. Return empty string if no extension

Parameters:

• request: HTTP request bytes

Returns:

• File extension including dot (e.g., ".json", ".html")
• Empty string if no extension found

Example:

ext, _ := GetExtension(request)  // "/api/file.json?x=1" → ".json"
ext, _ := GetExtension(request)  // "/api/users" → ""

func GetHTTPVersion ¶

func GetHTTPVersion(request []byte) (string, error)

GetHTTPVersion extracts the HTTP version from a request. Provides direct version access.

Algorithm:

1. Extract first header line (request line)
2. Parse using parseRequestLineString
3. Return version portion

Parameters:

• request: HTTP request bytes

Returns:

• HTTP version (e.g., "HTTP/1.1")
• Error if request malformed

Example:

version, _ := GetHTTPVersion(request)
// Returns: "HTTP/1.1"

func GetHeaderOffsets ¶

func GetHeaderOffsets(request []byte, name string) []int

GetHeaderOffsets returns [lineStart, valueStart, valueEnd] offsets for a header.

Algorithm:

1. Search through headers line by line
2. Find header with matching name (case-insensitive)
3. Return offsets: [lineStart, valueStart, valueEnd] - lineStart: Position where header line begins - valueStart: Position where header value begins (after ": ") - valueEnd: Position where header value ends (before CRLF)
4. Return nil if header not found

Parameters:

• request: HTTP request bytes
• name: Header name to find (case-insensitive)

Returns:

• []int{lineStart, valueStart, valueEnd} or nil if not found

Example:

offsets := GetHeaderOffsets(request, "Host")
// For "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
// offsets = [16, 22, 33] (line at 16, value "example.com" from 22 to 33)

func GetHeaderValue ¶

func GetHeaderValue(request []byte, name string) (string, error)

GetHeaderValue extracts a header value directly from request bytes.

Algorithm:

1. Extract headers using ExtractAllHeaders
2. Use GetHeader to find value

Parameters:

• request: HTTP request bytes
• name: Header name (case-insensitive)

Returns:

• Header value (empty string if not found)
• Error if request malformed

Example:

contentType, _ := GetHeaderValue(request, "Content-Type")

func GetHeaders ¶

func GetHeaders(message []byte) string

GetHeaders extracts all headers as string (excluding request/status line).

Algorithm:

1. Find end of first line (request/status line)
2. Find body offset
3. Extract headers between these positions

Parameters:

• message: HTTP request or response bytes

Returns:

• Headers as string (e.g., "Host: example.com\r\nAccept: */*\r\n")

Example:

headers := GetHeaders(request)  // "Host: example.com\r\nAccept: */*\r\n"

func GetHeadersByPrefix ¶

func GetHeadersByPrefix(request []byte, prefix string) ([]string, error)

GetHeadersByPrefix returns all headers matching a prefix. Useful for getting all X-* headers, etc.

Algorithm:

1. Extract all headers
2. Loop through and collect headers starting with prefix
3. Return as slice (full "Name: Value" format)

Parameters:

• request: HTTP request bytes
• prefix: Header name prefix (case-insensitive)

Returns:

• Slice of matching headers in "Name: Value" format
• Error if request malformed

Example:

customHeaders, _ := GetHeadersByPrefix(request, "X-")

func GetHeadersBytes ¶

func GetHeadersBytes(message []byte) []byte

GetHeadersBytes extracts all headers as bytes (excluding request/status line). Returns the raw header bytes between first line and body.

Algorithm:

1. Find end of first line (request/status line)
2. Find body offset (header/body separator)
3. Extract bytes between these positions (excluding separator)

Parameters:

• message: HTTP request or response bytes

Returns:

• Header bytes (empty if no headers)

Example:

headers := GetHeadersBytes(request)

func GetHeadersSize ¶

func GetHeadersSize(request []byte) (int, error)

GetHeadersSize returns the size of headers (including request line).

Parameters:

• request: HTTP request bytes

Returns:

• Headers size in bytes
• Error if request malformed

Example:

size, _ := GetHeadersSize(request)

func GetHost ¶

func GetHost(request []byte) (string, error)

GetHost extracts the Host header value.

Algorithm:

1. Call GetHeaderValue for "Host"

Parameters:

• request: HTTP request bytes

Returns:

• Host value
• Error if request malformed

Example:

host, _ := GetHost(request)

func GetMatches ¶

func GetMatches(data, pattern []byte, limit int) [][2]int

GetMatches returns all [start, end] positions of pattern in data.

Algorithm:

1. Start from position 0
2. Find each occurrence using IndexOfBytes
3. Record [start, end] for each match
4. Continue until no more matches or limit reached
5. Return all positions

Parameters:

• data: Byte array to search in
• pattern: Byte pattern to find
• limit: Maximum matches to find (-1 for unlimited)

Returns:

• Slice of [2]int{start, end} positions for each match

Example:

matches := GetMatches(data, []byte("ab"), -1)
// For "abcab", returns [][2]int{{0, 2}, {3, 5}}

func GetMethod ¶

func GetMethod(request []byte) (string, error)

GetMethod extracts the HTTP method from a request. Provides direct method access.

Algorithm:

1. Extract first header line (request line)
2. Parse using parseRequestLineString
3. Return method portion

Parameters:

• request: HTTP request bytes

Returns:

• HTTP method (e.g., "GET", "POST")
• Error if request malformed

Example:

method, _ := GetMethod(request)
// Returns: "GET"

func GetNestedResponse ¶

func GetNestedResponse(response []byte) []byte

GetNestedResponse extracts nested HTTP response from body. Useful for HTTP request smuggling detection.

Algorithm:

1. Find body offset of outer response
2. Search for "HTTP/" in body (start of nested response)
3. Return nested response bytes

Parameters:

• response: HTTP response bytes

Returns:

• Nested response bytes, or nil if not found

Example:

nested := GetNestedResponse(response)
// If body contains "HTTP/1.1 200 OK...", returns that response

func GetParameter ¶

func GetParameter(request []byte, name string, paramType ParamType) (string, error)

GetParameter extracts a single parameter value by name and type. Provides direct parameter access without AnalyzeRequest.

Algorithm:

1. Call AnalyzeRequest to get all parameters
2. Find parameter by name and type
3. Return value

Parameters:

• request: HTTP request bytes
• name: Parameter name
• paramType: Parameter type (ParamURL, ParamBody, ParamCookie)

Returns:

• Parameter value (decoded)
• Error if request malformed

Example:

value, _ := GetParameter(request, "id", ParamURL)

func GetParameterOrDefault ¶

func GetParameterOrDefault(request []byte, name string, paramType ParamType, defaultVal string) string

GetParameterOrDefault returns parameter value or default if not found. Provides parameter access with fallback.

Parameters:

• request: HTTP request bytes
• name: Parameter name
• paramType: Parameter type
• defaultVal: Default value if parameter not found

Returns:

• Parameter value or default

Example:

limit := GetParameterOrDefault(request, "limit", ParamURL, "10")

func GetPath ¶

func GetPath(request []byte) (string, error)

GetPath extracts the full path (including query string) from a request. Provides direct path access.

Algorithm:

1. Extract first header line (request line)
2. Parse using parseRequestLineString
3. Return path portion (includes query if present)

Parameters:

• request: HTTP request bytes

Returns:

• Full path with query (e.g., "/api/users?id=123")
• Error if request malformed

Example:

path, _ := GetPath(request)
// Returns: "/api/users?id=123"

func GetPathOnly ¶

func GetPathOnly(request []byte) (string, error)

GetPathOnly extracts the path without query string from a request. Provides path-only access.

Algorithm:

1. Get full path using GetPath
2. Find '?' character
3. Return substring before '?'

Parameters:

• request: HTTP request bytes

Returns:

• Path without query (e.g., "/api/users")
• Error if request malformed

Example:

pathOnly, _ := GetPathOnly(request)
// For "/api/users?id=123" returns: "/api/users"

func GetQueryString ¶

func GetQueryString(request []byte) (string, error)

GetQueryString extracts the query string portion from a request path. Provides direct query access.

Algorithm:

1. Get full path using GetPath
2. Find '?' character
3. Return substring after '?'

Parameters:

• request: HTTP request bytes

Returns:

• Query string without '?' (e.g., "id=123&name=test")
• Error if request malformed

Example:

query, _ := GetQueryString(request)
// For "/api?id=123" returns: "id=123"

func GetRequestBuffer ¶

func GetRequestBuffer(n int) []byte

GetRequestBuffer returns a pooled buffer of at least size n. Caller must call PutRequestBuffer when done.

func GetRequestSize ¶

func GetRequestSize(request []byte) int

GetRequestSize returns the total size of the request.

Parameters:

• request: HTTP request bytes

Returns:

• Request size in bytes

Example:

size := GetRequestSize(request)

func GetStartType ¶

func GetStartType(response []byte) string

GetStartType detects content type from response body start.

Algorithm:

1. Find body offset
2. Skip leading whitespace
3. Check for known content patterns
4. Return type identifier

Parameters:

• response: HTTP response bytes

Returns:

• Content type string: "[blank]", "<html", "<head", "text", etc.

Example:

startType := GetStartType(response)  // "<html>..." → "<html"
startType := GetStartType(response)  // "{..." → "json"

func GetStatusCode ¶

func GetStatusCode(response []byte) int16

GetStatusCode extracts status code from response (shortcut for AnalyzeResponse).

Algorithm:

1. Find first space (after HTTP version)
2. Find second space (after status code)
3. Parse status code between the two spaces

Parameters:

• response: HTTP response bytes

Returns:

• Status code as int16 (e.g., 200, 404, 500)
• Returns 0 if not a valid response

Example:

code := GetStatusCode(response)  // "HTTP/1.1 404 Not Found" → 404

func GetURLFromRequest ¶

func GetURLFromRequest(scheme string, request []byte) string

GetURLFromRequest constructs a full URL string from a raw HTTP request. Requires the scheme (http/https) since it's not present in raw HTTP request.

Algorithm:

1. Extract path with query string from request line
2. Extract Host header value
3. Combine scheme + host + path

Parameters:

• scheme: URL scheme ("http" or "https")
• request: Raw HTTP request bytes

Returns:

• Full URL string (e.g., "https://example.com/api?id=123")
• Empty string if request is malformed

Example:

url := GetURLFromRequest("https", []byte("GET /api?id=123 HTTP/1.1\r\nHost: example.com\r\n\r\n"))
// Returns: "https://example.com/api?id=123"

func GetURLFromService ¶

func GetURLFromService(request []byte, httpService *Service) (*urlutil.URL, error)

GetURLFromService constructs a complete URL from raw request bytes and Service. Extracts path from raw bytes using GetPath(), then combines with Service data.

Algorithm:

1. Extract path with query string from raw request
2. Get scheme, host, port from Service
3. Construct URL string: scheme://host:port/path
4. Parse into urlutil.URL to populate all fields

Parameters:

• request: Raw HTTP request bytes
• httpService: HTTP service containing host, port, protocol

Returns:

• Constructed urlutil.URL with scheme, host, port, path, and query params
• Error if request malformed or httpService nil

Example:

url, err := GetURLFromService(rawRequest, httpService)
// For raw request "GET /api/users?id=123 HTTP/1.1" and httpService with https://example.com:8443
// Returns: https://example.com:8443/api/users?id=123

func GetURLParameter ¶

func GetURLParameter(request []byte, name string) (string, error)

GetURLParameter extracts a single URL parameter value by name. Provides direct parameter access without AnalyzeRequest.

Algorithm:

1. Get query string
2. Use ParseQueryString to parse into parameters
3. Find parameter by name
4. Return decoded value

Parameters:

• request: HTTP request bytes
• name: Parameter name to find

Returns:

• Parameter value (decoded)
• Error if request malformed

Example:

value, _ := GetURLParameter(request, "id")
// For "?id=123&name=test" returns: "123"

func GetURLParametersMap ¶

func GetURLParametersMap(request []byte) (map[string]string, error)

GetURLParametersMap returns all URL parameters as a map. Provides map-based parameter access.

Algorithm:

1. Get query string
2. Parse using ParseQueryString
3. Convert to map (last value wins if duplicates)

Parameters:

• request: HTTP request bytes

Returns:

• Map of parameter name → value
• Error if request malformed

Example:

params, _ := GetURLParametersMap(request)
// For "?id=123&name=test" returns: {"id": "123", "name": "test"}

func HasBody ¶

func HasBody(request []byte) (bool, error)

HasBody checks if the request contains a body. Provides body existence check.

Algorithm:

1. Find body offset
2. Check if offset is valid and body size > 0

Parameters:

• request: HTTP request bytes

Returns:

• true if body exists and has content
• Error if request malformed

Example:

hasBody, _ := HasBody(request)

func HasCookie ¶

func HasCookie(request []byte, name string) (bool, error)

HasCookie checks if a cookie exists.

Parameters:

• request: HTTP request bytes
• name: Cookie name

Returns:

• true if cookie exists
• Error if request malformed

Example:

hasSess, _ := HasCookie(request, "session")

func HasHeader ¶

func HasHeader(request []byte, name string) (bool, error)

HasHeader checks if a header exists in the request.

Algorithm:

1. Get header value
2. Return true if not empty

Parameters:

• request: HTTP request bytes
• name: Header name (case-insensitive)

Returns:

• true if header exists
• Error if request malformed

Example:

hasAuth, _ := HasHeader(request, "Authorization")

func HasParameter ¶

func HasParameter(request []byte, name string, paramType ParamType) (bool, error)

HasParameter checks if a parameter exists. Provides parameter existence check.

Parameters:

• request: HTTP request bytes
• name: Parameter name
• paramType: Parameter type

Returns:

• true if parameter exists
• Error if request malformed

Example:

exists, _ := HasParameter(request, "debug", ParamURL)

func HasURLEncodedBody ¶

func HasURLEncodedBody(headers []string) bool

HasURLEncodedBody checks if an HTTP request has a URL-encoded body. Examines Content-Type header for application/x-www-form-urlencoded.

Algorithm:

1. Extract Content-Type header from headers list
2. Parse MIME type (before semicolon)
3. Compare against "application/x-www-form-urlencoded" (case-insensitive)

Example:

headers := []string{
	"POST / HTTP/1.1",
	"Content-Type: application/x-www-form-urlencoded",
	"Content-Length: 10",
}
hasURLEncoded := HasURLEncodedBody(headers)
// hasURLEncoded = true

Parameters:

• headers: List of HTTP header lines (from ExtractHeaders or ExtractAllHeaders)

Returns:

• true if Content-Type is application/x-www-form-urlencoded
• false otherwise

func HasURLParameter ¶

func HasURLParameter(request []byte, name string) (bool, error)

HasURLParameter checks if a URL parameter exists. Provides parameter existence check.

Algorithm:

1. Get URL parameter value
2. Return true if found (even if empty value)

Parameters:

• request: HTTP request bytes
• name: Parameter name to check

Returns:

• true if parameter exists
• Error if request malformed

Example:

exists, _ := HasURLParameter(request, "id")

func Header ¶

func Header(headers []string, name string) string

GetHeader retrieves header value by name (case-insensitive).

Parameters:

• headers: List of header lines from ExtractHeaders
• name: Header name to search for (e.g., "Content-Type")

Returns:

• Header value (trimmed), or empty string if not found

Logic:

1. Loop through headers, skipping request/status line
2. Parse each header as "Name: Value"
3. Compare name case-insensitively
4. Return trimmed value

Example:

headers := []string{"GET / HTTP/1.1", "Host: example.com", "Content-Type: text/html"}
value := Header(headers, "content-type")
// value = "text/html"

func HeadersToStrings ¶

func HeadersToStrings(headers []HttpHeader) []string

HeadersToStrings converts HttpHeader slice to string slice. Useful for rebuilding raw HTTP messages.

func HexCharToValue ¶

func HexCharToValue(ch byte) int

HexCharToValue converts a hexadecimal character to its numeric value. Uses switch/case logic (NO REGEX per requirements).

Algorithm:

1. Check if character is '0'-'9': return value 0-9
2. Check if character is 'a'-'f': return value 10-15
3. Check if character is 'A'-'F': return value 10-15
4. Otherwise return -1 (invalid hex)

Example:

HexCharToValue('3')  // Returns 3
HexCharToValue('A')  // Returns 10
HexCharToValue('f')  // Returns 15
HexCharToValue('G')  // Returns -1 (invalid)

Parameters:

• ch: Character to convert

Returns:

• Numeric value (0-15), or -1 if invalid hex character

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	chars := []byte{'0', '9', 'A', 'F', 'a', 'f', 'G'}

	for _, ch := range chars {
		value := httpmsg.HexCharToValue(ch)
		if value != -1 {
			fmt.Printf("'%c' = %d\n", ch, value)
		} else {
			fmt.Printf("'%c' = invalid\n", ch)
		}
	}

}

Output:
'0' = 0
'9' = 9
'A' = 10
'F' = 15
'a' = 10
'f' = 15
'G' = invalid

func HostnameFromURL ¶

func HostnameFromURL(raw string) string

HostnameFromURL parses a URL string and returns its lowercased, port-stripped hostname, or "" when it has no host. Used to scope carried sessions to the exact host they were harvested from.

func HttpHeadersContain ¶

func HttpHeadersContain(headers []HttpHeader, name string) bool

HttpHeadersContain checks if headers contain a header with the given name (case-insensitive).

func IndexOf ¶

func IndexOf(haystack, needle []byte, caseSensitive bool, start, end int) int

IndexOf finds the first occurrence of a pattern in data. Uses loop-based search with optional case-insensitive comparison.

Example:

data := []byte("Hello World")
pos := IndexOf(data, []byte("World"), true, 0, len(data))
// Returns 6

pos := IndexOf(data, []byte("world"), false, 0, len(data))
// Returns 6 (case-insensitive)

Parameters:

• haystack: Data to search in (cannot be null)
• needle: Pattern to find (cannot be null)
• caseSensitive: Whether search is case-sensitive
• start: Start position (must be >= 0)
• end: End position (must be >= start and <= len(haystack))

Returns:

• Position of first match, or -1 if not found
• Returns -1 if inputs are invalid

func IndexOfByte ¶

func IndexOfByte(data []byte, target byte, startOffset int) int

IndexOfByte finds the first occurrence of a target byte starting from startOffset.

Algorithm:

1. Loop from startOffset to end of array
2. Compare each byte with target
3. Return index of first match
4. Return -1 if not found

Example:

data := []byte("hello")
idx := IndexOfByte(data, 'l', 0)  // Returns 2 (first 'l')
idx := IndexOfByte(data, 'l', 3)  // Returns 3 (second 'l')
idx := IndexOfByte(data, 'x', 0)  // Returns -1 (not found)

Parameters:

• data: Byte array to search in
• target: Byte to find
• startOffset: Position to start searching from

Returns:

• Index of first occurrence, or -1 if not found

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	data := []byte("hello world")

	// Find first 'o'
	idx1 := httpmsg.IndexOfByte(data, 'o', 0)
	fmt.Printf("First 'o' at index: %d\n", idx1)

	// Find second 'o' (start searching after first)
	idx2 := httpmsg.IndexOfByte(data, 'o', idx1+1)
	fmt.Printf("Second 'o' at index: %d\n", idx2)

	// Not found
	idx3 := httpmsg.IndexOfByte(data, 'x', 0)
	fmt.Printf("'x' found at: %d\n", idx3)

}

Output:
First 'o' at index: 4
Second 'o' at index: 7
'x' found at: -1

func IndexOfByteInRange ¶

func IndexOfByteInRange(haystack []byte, target byte, caseSensitive bool, start, end int) int

IndexOfByteInRange finds a byte within a range.

Example:

data := []byte("Hello World")
IndexOfByteInRange(data, 'W', true, 0, len(data))  // 6
IndexOfByteInRange(data, 'w', false, 0, len(data)) // 6 (case-insensitive)

Parameters:

• haystack: Data to search in
• target: Byte to find
• caseSensitive: Whether search is case-sensitive
• start: Start position
• end: End position

Returns:

• Index of first match, or -1 if not found

func IndexOfBytes ¶

func IndexOfBytes(data []byte, target []byte, startOffset int) int

IndexOfBytes finds the first occurrence of a target byte sequence starting from startOffset.

Algorithm:

1. Loop from startOffset to end
2. For each position, check if target sequence matches
3. Use nested loop for multi-byte matching
4. Return index of first match
5. Return -1 if not found

Example:

data := []byte("hello world")
idx := IndexOfBytes(data, []byte("wor"), 0)  // Returns 6
idx := IndexOfBytes(data, []byte("xyz"), 0)  // Returns -1

Parameters:

• data: Byte array to search in
• target: Byte sequence to find
• startOffset: Position to start searching from

Returns:

• Index of first occurrence, or -1 if not found

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	data := []byte("The quick brown fox jumps over the lazy dog")

	// Find "quick"
	idx1 := httpmsg.IndexOfBytes(data, []byte("quick"), 0)
	fmt.Printf("'quick' found at: %d\n", idx1)

	// Find "the" (case sensitive)
	idx2 := httpmsg.IndexOfBytes(data, []byte("the"), 0)
	fmt.Printf("'the' found at: %d\n", idx2)

	// Not found
	idx3 := httpmsg.IndexOfBytes(data, []byte("cat"), 0)
	fmt.Printf("'cat' found at: %d\n", idx3)

}

Output:
'quick' found at: 4
'the' found at: 31
'cat' found at: -1

func InsertionPointRequiresContentLengthUpdate ¶

func InsertionPointRequiresContentLengthUpdate(ipType InsertionPointType) bool

InsertionPointRequiresContentLengthUpdate returns whether an insertion point type requires Content-Length header updates when modifying request body.

Body parameters need updates because they modify request body length:

• INS_PARAM_BODY: POST body parameters
• INS_PARAM_XML: XML elements
• INS_PARAM_XML_ATTR: XML attributes
• INS_PARAM_MULTIPART_ATTR: Multipart attributes
• INS_PARAM_JSON: JSON values
• INS_ENTIRE_BODY: Entire body

URL/Cookie/Path parameters don't need updates because they don't affect body length.

func IntToString ¶

func IntToString(n int) string

IntToString converts integer to string using loops (NO strconv.Itoa).

Parameters:

• n: Integer to convert

Returns:

• String representation

func IsAbsoluteURL ¶

func IsAbsoluteURL(urlBytes []byte) bool

IsAbsoluteURL checks if URL has a protocol.

Parameters:

• urlBytes: URL bytes to check

Returns:

• true if URL starts with "http://" or "https://"

Example:

isAbs := IsAbsoluteURL([]byte("http://example.com"))
// Returns true

isAbs := IsAbsoluteURL([]byte("/path"))
// Returns false

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	absoluteURL := []byte("http://example.com/path")
	relativeURL := []byte("/path")

	fmt.Printf("http://example.com/path is absolute: %v\n", httpmsg.IsAbsoluteURL(absoluteURL))
	fmt.Printf("/path is absolute: %v\n", httpmsg.IsAbsoluteURL(relativeURL))

}

Output:
http://example.com/path is absolute: true
/path is absolute: false

func IsHTTP2 ¶

func IsHTTP2(request []byte) bool

IsHTTP2 checks if request uses HTTP/2 protocol.

Algorithm:

1. Find end of first line
2. Check if line ends with "HTTP/2" or starts with pseudo-headers
3. Return true if HTTP/2 indicators found

Parameters:

• request: HTTP request bytes

Returns:

• true if request uses HTTP/2 protocol

Example:

isH2 := IsHTTP2(request)  // "GET / HTTP/2\r\n..." → true

func IsMethodType ¶

func IsMethodType(request []byte, method string) (bool, error)

IsMethodType checks if the request uses a specific HTTP method. Provides method checking.

Algorithm:

1. Extract method using GetMethod
2. Compare case-insensitively

Parameters:

• request: HTTP request bytes
• method: Method to check (e.g., "GET", "POST")

Returns:

• true if method matches
• Error if request malformed

Example:

isPost, _ := IsMethodType(request, "POST")

func IsRedirectStatus ¶ added in v0.4.9

func IsRedirectStatus(code int) bool

IsRedirectStatus reports whether a status code is one that carries a Location, i.e. names a destination.

304 is excluded: it is a cache validator, not a redirect, and has no destination to show. 300/305/306 are included because they are 3xx with a Location; none is seen in practice, and excluding them by hand is how a second, subtly different spelling of "redirect" gets written.

It lives here because every layer that asks needs the same answer: the transport's chain handling, the executor's chain_truncated write, discovery's redirect detector, and the stored-record read path that renders chains. Four packages previously carried four spellings of this switch, which is the mechanism by which a write path and the read path rendering it come to disagree — a disagreement whose symptom is a blank destination, not an error.

func IsRelativeURL ¶

func IsRelativeURL(urlBytes []byte) bool

IsRelativeURL checks if URL is relative (no protocol).

Parameters:

• urlBytes: URL bytes to check

Returns:

• true if URL has no protocol

Example:

isRel := IsRelativeURL([]byte("/path"))
// Returns true

isRel := IsRelativeURL([]byte("http://example.com"))
// Returns false

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	absoluteURL := []byte("https://example.com/path")
	relativeURL := []byte("/api/users")

	fmt.Printf("https://example.com/path is relative: %v\n", httpmsg.IsRelativeURL(absoluteURL))
	fmt.Printf("/api/users is relative: %v\n", httpmsg.IsRelativeURL(relativeURL))

}

Output:
https://example.com/path is relative: false
/api/users is relative: true

func IsRequest ¶

func IsRequest(message []byte) bool

IsRequest checks if message is an HTTP request (not a response). Complement of IsResponse.

Parameters:

• message: HTTP message bytes

Returns:

• true if message is an HTTP request

Example:

isReq := IsRequest(data)  // "GET / HTTP/1.1..." → true
isReq := IsRequest(data)  // "HTTP/1.1 200 OK..." → false

func IsResponse ¶

func IsResponse(message []byte) bool

IsResponse checks if message is an HTTP response (starts with "HTTP/").

Algorithm:

1. Check if message starts with "HTTP/" (case-insensitive)
2. Return true if it does

Parameters:

• message: HTTP message bytes

Returns:

• true if message is an HTTP response

Example:

isResp := IsResponse(data)  // "HTTP/1.1 200 OK..." → true
isResp := IsResponse(data)  // "GET / HTTP/1.1..." → false

func IsWellFormed ¶

func IsWellFormed(request []byte) bool

IsWellFormed checks if request is well-formed (convenience wrapper).

Parameters:

• request: HTTP request bytes

Returns:

• true if request is valid

Example:

if IsWellFormed(request) {
    // Process request
}

func IsWhitespace ¶

func IsWhitespace(c byte) bool

IsWhitespace checks if character is space or tab. Helper for TrimSpace.

Parameters:

• c: Character byte

Returns:

• true if space (0x20) or tab (0x09)

func MeasuredMillis ¶

func MeasuredMillis(d time.Duration) int64

MeasuredMillis converts a measured duration to the milliseconds stored in http_records.response_time_ms (and the equivalent columns the discovery and browser stores carry it through).

It owns the one invariant the whole timing feature rests on. Those columns are INTEGER DEFAULT 0 with no NULL to express "never measured", and most responses in this process are rebuilt from stored bytes and genuinely have no timing — so a MEASURED value is floored at 1ms, and only an unmeasured one is allowed to be 0. Without the floor a loopback probe and an un-timed import are the same value, which is what made db stats' p50/p95/p99 a percentile over a column of zeros.

Every path that writes one of those columns must go through here. Three hand-written copies of this rule had already drifted into three shapes before it was centralized.

func MergeCookieHeaders ¶

func MergeCookieHeaders(existing, carried string) string

MergeCookieHeaders returns a Cookie header value that keeps every cookie in existing and appends any cookie from carried whose name is not already present. Existing cookies always win — a request that already carries a cookie (e.g. a browser-crawled record) is never overwritten, we only add the clearance/session cookies it is missing.

func NormalizeHost ¶

func NormalizeHost(host string) string

NormalizeHost lowercases a host and strips any port, returning the bare hostname used as the CarriedSession key and the request-match key. Delegates port-stripping to the package's IPv6-aware extractHostname.

func NormalizeLineEndings ¶

func NormalizeLineEndings(request []byte) []byte

NormalizeLineEndings ensures all line endings are CRLF.

Parameters:

• request: HTTP request bytes

Returns:

• Normalized request

Example:

normalized := NormalizeLineEndings(request)

func OriginFromURL ¶

func OriginFromURL(raw string) string

OriginFromURL returns the normalized origin (scheme://host[:port]) of raw, or "" when it has no scheme+host. A default port for the scheme is dropped so origins compare equal regardless of an explicit vs implicit default port.

func OriginMatchesURL ¶

func OriginMatchesURL(origin string, u *url.URL) bool

OriginMatchesURL reports whether u has the same origin (scheme, host, port) as the normalized origin string produced by OriginFromURL. An empty origin or nil URL never matches.

func OriginRefererScheme ¶

func OriginRefererScheme(raw, host string, targetPort int) (scheme, header string, ok bool)

OriginRefererScheme returns the URL scheme ("http" or "https") declared by the request's Origin or Referer header, but only when that header names the same host — and, when targetPort > 0, the same port — we are about to connect to. It lets raw requests captured from a browser/proxy keep their real scheme when the request line is origin-form (no scheme) and the port is non-standard — e.g. an http service on :3000. A cross-origin Origin/Referer (a different host, or a different port when targetPort is known, as in a CORS request or an external referrer) is ignored so it cannot mislead scheme inference; Origin is preferred over Referer as it is the exact origin the browser attached. host must be the bare hostname (no port); targetPort is the port being connected to (0 when unknown, which falls back to host-only matching). header names which header supplied the scheme ("Origin"/"Referer"). Returns ok=false when neither header yields a same-origin http/https scheme.

func ParseContentType ¶

func ParseContentType(headers []string) (contentType string, boundary string)

ParseContentType extracts MIME type and boundary from Content-Type header. Handles multipart/form-data boundary parsing.

Parameters:

• headers: List of header lines from ExtractHeaders

Returns:

• contentType: MIME type (e.g., "multipart/form-data")
• boundary: Boundary string for multipart, or empty string

Logic:

1. Get Content-Type header value
2. Parse MIME type (before semicolon)
3. Parse parameters (after semicolon)
4. Extract boundary parameter if present

Example:

headers := []string{"POST / HTTP/1.1", "Content-Type: multipart/form-data; boundary=----WebKit"}
contentType, boundary := ParseContentType(headers)
// contentType = "multipart/form-data"
// boundary = "----WebKit"

func ParseHostPort ¶

func ParseHostPort(hostBytes []byte) (host string, port int)

ParseHostPort extracts host and port from "host:port" string. Loop-based parsing (no strings.Split or strconv).

Parameters:

• hostBytes: Bytes containing host:port (e.g., "example.com:8080")

Returns:

• host: Hostname or IP address
• port: Port number, or -1 if not specified

Algorithm:

1. Find ':' separator using loop
2. Extract host before ':'
3. Extract port after ':' and parse as integer
4. Return -1 for port if no ':' found

Example:

hostBytes := []byte("example.com:8080")
host, port := ParseHostPort(hostBytes)
// host = "example.com", port = 8080

hostBytes := []byte("example.com")
host, port := ParseHostPort(hostBytes)
// host = "example.com", port = -1

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	hostBytes := []byte("api.example.com:8443")

	host, port := httpmsg.ParseHostPort(hostBytes)

	fmt.Printf("Host: %s\n", host)
	fmt.Printf("Port: %d\n", port)

}

Output:
Host: api.example.com
Port: 8443

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	hostBytes := []byte("example.com")

	host, port := httpmsg.ParseHostPort(hostBytes)

	fmt.Printf("Host: %s\n", host)
	fmt.Printf("Port: %d (not specified)\n", port)

}

Output:
Host: example.com
Port: -1 (not specified)

func ParseInt ¶

func ParseInt(s string) int

ParseInt parses an integer string using loops (no strconv.Atoi). Loop-based digit-by-digit parsing.

Parameters:

• s: String containing digits

Returns:

• Parsed integer, or -1 if invalid

Algorithm:

1. Loop through each character
2. Check if character is digit (0-9)
3. Build result: result = result*10 + digit
4. Return -1 if non-digit found

Example:

port := ParseInt("8080")
// Returns 8080

port := ParseInt("abc")
// Returns -1 (invalid)

func ParseParameter ¶

func ParseParameter(params string, name string) string

ParseParameter extracts parameter value from header parameter string. Loop-based parsing for "name=value" or "name=\"value\"" format.

Parameters:

• params: Parameter string (e.g., "boundary=----WebKit; charset=utf-8")
• name: Parameter name to extract

Returns:

• Parameter value, or empty string if not found

Logic:

1. Find parameter name (case-insensitive)
2. Skip past "name="
3. Handle quoted values ("value")
4. Handle unquoted values (until semicolon or end)

Example:

params := "boundary=----WebKit; charset=utf-8"
value := ParseParameter(params, "boundary")
// value = "----WebKit"

func PrependBody ¶

func PrependBody(request []byte, data []byte) ([]byte, error)

PrependBody prepends data to the existing request body. Provides body prepend operation.

Algorithm:

1. Get current body
2. Prepend new data
3. Set combined body

Parameters:

• request: HTTP request bytes
• data: Data to prepend

Returns:

• Modified request with prepended body
• Error if request malformed

Example:

modified, _ := PrependBody(request, []byte("prefix_"))

func PutRequestBuffer ¶

func PutRequestBuffer(buf []byte)

PutRequestBuffer returns a buffer to the pool. Buffers larger than 1 MiB are not pooled to avoid holding excessive memory.

func ReconcileDeclaredBody ¶ added in v0.5.2

func ReconcileDeclaredBody(raw []byte) []byte

ReconcileDeclaredBody returns raw with its body and its declared Content-Length in agreement. See the file comment for which side wins and why. It returns raw itself — not a copy — whenever there is nothing to reconcile, which is the overwhelmingly common case.

func RemoveAllParametersByType ¶

func RemoveAllParametersByType(request []byte, paramType ParamType) ([]byte, error)

RemoveAllParametersByType removes all parameters of a specific type. Provides batch remove operation.

Parameters:

• request: HTTP request bytes
• paramType: Parameter type to remove

Returns:

• Modified request without parameters of specified type
• Error if request malformed

Example:

modified, _ := RemoveAllParametersByType(request, ParamURL)

func RemoveCookie ¶

func RemoveCookie(request []byte, name string) ([]byte, error)

RemoveCookie removes a cookie.

Parameters:

• request: HTTP request bytes
• name: Cookie name

Returns:

• Modified request without cookie
• Error if request malformed

Example:

modified, _ := RemoveCookie(request, "tracking")

func RemoveHeader ¶

func RemoveHeader(message []byte, name string) ([]byte, error)

RemoveHeader removes a header from an HTTP message.

Algorithm:

1. Extract all headers and body offset
2. Filter out matching header (case-insensitive)
3. Rebuild message

Parameters:

• message: Original HTTP message
• name: Header name to remove (case-insensitive)

Returns:

• Modified HTTP message without the header
• Error if message is malformed

Example:

request := []byte("GET / HTTP/1.1\r\nHost: example.com\r\nUser-Agent: test\r\n\r\n")
modified, _ := RemoveHeader(request, "User-Agent")
// Returns: "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"

func RemoveParameter ¶

func RemoveParameter(request []byte, param *Param) ([]byte, error)

RemoveParameter removes a parameter from an HTTP request.

Algorithm:

1. Analyze request to get all parameters
2. Find parameter to remove by matching name and type
3. Remove parameter from appropriate location (URL, body, cookie)
4. Update Content-Length if body changed

Parameters:

• request: Original HTTP request
• param: Parameter to remove (name and type must match)

Returns:

• Modified request without the parameter
• Error if parameter not found or request malformed

Example:

param := BuildParameter("debug", "", ParamURL)
modified, _ := RemoveParameter(request, param)

func RemoveParametersByName ¶

func RemoveParametersByName(request []byte, names []string, paramType ParamType) ([]byte, error)

RemoveParametersByName removes all parameters matching names. Provides batch name-based removal.

Parameters:

• request: HTTP request bytes
• names: Parameter names to remove
• paramType: Parameter type

Returns:

• Modified request without specified parameters
• Error if request malformed

Example:

modified, _ := RemoveParametersByName(request, []string{"debug", "trace"}, ParamURL)

func ReplaceHeader ¶

func ReplaceHeader(request []byte, name, value string) ([]byte, error)

ReplaceHeader atomically replaces a header value (remove + add).

Algorithm:

1. Remove existing header if present
2. Add new header

Parameters:

• request: HTTP request bytes
• name: Header name
• value: New header value

Returns:

• Modified request with replaced header
• Error if request malformed

Example:

modified, _ := ReplaceHeader(request, "User-Agent", "CustomAgent/1.0")

func RequestsEqual ¶

func RequestsEqual(req1, req2 []byte) bool

RequestsEqual checks if two requests are byte-level equal.

Parameters:

• req1: First request
• req2: Second request

Returns:

• true if requests are identical

Example:

if RequestsEqual(req1, req2) {
    // Requests are identical
}

func RequestsEqualNormalized ¶

func RequestsEqualNormalized(req1, req2 []byte) bool

RequestsEqualNormalized checks if requests are equal after normalization.

Parameters:

• req1: First request
• req2: Second request

Returns:

• true if requests are equal after normalization

Example:

if RequestsEqualNormalized(req1, req2) {
    // Requests are functionally identical
}

func SetAllCookies ¶

func SetAllCookies(request []byte, cookies map[string]string) ([]byte, error)

SetAllCookies replaces all cookies with those from a map.

Parameters:

• request: HTTP request bytes
• cookies: Map of cookie name → value

Returns:

• Modified request with new cookies
• Error if request malformed

Example:

cookies := map[string]string{"session": "abc", "tracking": "xyz"}
modified, _ := SetAllCookies(request, cookies)

func SetBody ¶

func SetBody(request []byte, body []byte) ([]byte, error)

SetBody replaces the body of an HTTP request. Provides direct body modification.

Algorithm:

1. Extract headers
2. Build new request with headers + new body
3. Update Content-Length header

Parameters:

• request: HTTP request bytes
• body: New body bytes

Returns:

• Modified request with new body
• Error if request malformed

Example:

newBody := []byte("new data")
modified, _ := SetBody(request, newBody)

func SetBodyParametersMap ¶

func SetBodyParametersMap(request []byte, params map[string]string) ([]byte, error)

SetBodyParametersMap replaces all body parameters with those from a map. Provides map-based body parameter setting.

Parameters:

• request: HTTP request bytes
• params: Map of parameter name → value

Returns:

• Modified request with new body parameters
• Error if request malformed

Example:

params := map[string]string{"username": "admin", "password": "test"}
modified, _ := SetBodyParametersMap(request, params)

func SetBodyString ¶

func SetBodyString(request []byte, body string) ([]byte, error)

SetBodyString replaces the body with a string value. Provides string body modification.

Algorithm:

1. Convert string to bytes
2. Call SetBody

Parameters:

• request: HTTP request bytes
• body: New body as string

Returns:

• Modified request with new body
• Error if request malformed

Example:

modified, _ := SetBodyString(request, "new data")

func SetBuildVersion ¶

func SetBuildVersion(v string)

SetBuildVersion records the running binary version so a configured User-Agent containing the {version} placeholder resolves correctly. Called once from the CLI layer (httpmsg cannot import the version, that would cycle).

func SetContentType ¶

func SetContentType(request []byte, contentType string) ([]byte, error)

SetContentType sets the Content-Type header.

Algorithm:

1. Call ReplaceHeader for "Content-Type"

Parameters:

• request: HTTP request bytes
• contentType: Content-Type value

Returns:

• Modified request with Content-Type set
• Error if request malformed

Example:

modified, _ := SetContentType(request, "application/json")

func SetCookie ¶

func SetCookie(request []byte, name, value string) ([]byte, error)

SetCookie sets or updates a cookie.

Parameters:

• request: HTTP request bytes
• name: Cookie name
• value: Cookie value

Returns:

• Modified request with cookie set
• Error if request malformed

Example:

modified, _ := SetCookie(request, "session", "abc123")

func SetDefaultUserAgent ¶

func SetDefaultUserAgent(ua string)

SetDefaultUserAgent installs the process-global User-Agent selector applied to every outgoing HTTP request across all scan phases. Accepts a selector keyword ("preset" / "random"), a blank string (== "random"), or any literal User-Agent (with {version} expansion). Safe for concurrent use; last writer wins.

func SetMethod ¶

func SetMethod(request []byte, method string) ([]byte, error)

SetMethod replaces the HTTP method in a request. Provides direct method modification.

Algorithm:

1. Extract all headers and body
2. Parse current request line
3. Build new request line with new method
4. Rebuild request with modified line

Parameters:

• request: HTTP request bytes
• method: New HTTP method (e.g., "POST", "PUT")

Returns:

• Modified request with new method
• Error if request malformed

Example:

modified, _ := SetMethod(request, "POST")
// Changes "GET /api HTTP/1.1" to "POST /api HTTP/1.1"

func SetPath ¶

func SetPath(request []byte, path string) ([]byte, error)

SetPath replaces the full path (including query string) in a request. Provides direct path modification.

Algorithm:

1. Extract all headers and body
2. Parse current request line
3. Build new request line with new path
4. Rebuild request with modified line

Parameters:

• request: HTTP request bytes
• path: New path (can include query string)

Returns:

• Modified request with new path
• Error if request malformed

Example:

modified, _ := SetPath(request, "/api/v2/users?id=456")
// Changes path from old to new

func SetPathOnly ¶

func SetPathOnly(request []byte, pathOnly string) ([]byte, error)

SetPathOnly replaces the path portion while preserving the query string. Provides path-only modification.

Algorithm:

1. Get current full path
2. Extract query string if present
3. Combine new path with existing query
4. Call SetPath with combined result

Parameters:

• request: HTTP request bytes
• pathOnly: New path without query string

Returns:

• Modified request with new path, preserving query
• Error if request malformed

Example:

modified, _ := SetPathOnly(request, "/api/v2/users")
// For "/api/users?id=123" changes to "/api/v2/users?id=123"

func SetQueryString ¶

func SetQueryString(request []byte, query string) ([]byte, error)

SetQueryString replaces the query string in a request. Provides direct query modification.

Algorithm:

1. Get current path without query using GetPathOnly
2. Append new query string with '?'
3. Call SetPath with combined result

Parameters:

• request: HTTP request bytes
• query: New query string without '?' (e.g., "id=456&name=new")

Returns:

• Modified request with new query string
• Error if request malformed

Example:

modified, _ := SetQueryString(request, "id=456&name=new")
// Changes "/api?id=123" to "/api?id=456&name=new"

func SetURLParametersMap ¶

func SetURLParametersMap(request []byte, params map[string]string) ([]byte, error)

SetURLParametersMap replaces all URL parameters with those from a map. Provides map-based parameter setting.

Algorithm:

1. Build query string from map
2. URL-encode each name and value
3. Join with '&'
4. Call SetQueryString

Parameters:

• request: HTTP request bytes
• params: Map of parameter name → value

Returns:

• Modified request with new parameters
• Error if request malformed

Example:

params := map[string]string{"id": "456", "name": "new"}
modified, _ := SetURLParametersMap(request, params)
// Creates query string "id=456&name=new"

func SkipLineTerminator ¶

func SkipLineTerminator(data []byte, pos, end int) int

SkipLineTerminator advances position past line ending. Helper function for header parsing.

Parameters:

• data: Byte slice
• pos: Current position (at CR or LF)
• end: End boundary

Returns:

• New position after line terminator

Logic:

• If at CRLF (\r\n), skip 2 bytes
• If at LF (\n) alone, skip 1 byte
• If at CR (\r) alone, skip 1 byte

func SliceBytes ¶

func SliceBytes(data []byte, start, end int) []byte

SliceBytes performs safe byte slicing with bounds checking.

Example:

data := []byte("hello world")
slice := SliceBytes(data, 0, 5)  // Returns []byte("hello")
slice := SliceBytes(data, 6, 20) // Returns []byte("world") - capped at length

Parameters:

• data: Source byte array
• start: Start index (inclusive)
• end: End index (exclusive)

Returns:

• Sliced byte array
• Empty slice if start >= len(data)
• Capped at len(data) if end > len(data)

package main

import (
	"fmt"

	"github.com/vigolium/vigolium/pkg/httpmsg"
)

func main() {
	data := []byte("Hello, World!")

	// Normal slice
	slice1 := httpmsg.SliceBytes(data, 0, 5)
	fmt.Printf("Slice [0:5]: %s\n", string(slice1))

	// Slice with end beyond length (automatically capped)
	slice2 := httpmsg.SliceBytes(data, 7, 100)
	fmt.Printf("Slice [7:100]: %s\n", string(slice2))

}

Output:
Slice [0:5]: Hello
Slice [7:100]: World!

func StartsWithIgnoreCase ¶

func StartsWithIgnoreCase(s, prefix string) bool

StartsWithIgnoreCase checks if string starts with prefix (case-insensitive). Helper function for header matching.

func StringToBytes ¶

func StringToBytes(s string) []byte

StringToBytes converts a string to byte array.

Algorithm:

1. Create byte array with length = string length
2. Loop through each character
3. Cast each char to byte
4. Store in byte array

Note: This truncates Unicode to single bytes. For proper Unicode handling, use []byte(s) directly in production code.

Example:

StringToBytes("hello")   // Returns []byte{104, 101, 108, 108, 111}
StringToBytes("")        // Returns []byte{}

Parameters:

• s: String to convert

Returns:

• Byte array

func StripTrailingData ¶

func StripTrailingData(request []byte) []byte

StripTrailingData removes any data after the body.

Parameters:

• request: HTTP request bytes

Returns:

• Request without trailing data

Example:

cleaned := StripTrailingData(request)

func SwitchMethod ¶

func SwitchMethod(request []byte, newMethod string) ([]byte, error)

SwitchMethod changes the request to use a different HTTP method. Generalized method switching (beyond GET<->POST).

Algorithm:

1. Use SetMethod to change method
2. If switching to GET and has body, optionally move params to URL
3. If switching from GET to POST, keep params where they are

Note: Unlike ToggleRequestMethod, this doesn't move parameters. Use ToggleRequestMethod for GET↔POST with parameter conversion.

Parameters:

• request: HTTP request bytes
• newMethod: Target HTTP method

Returns:

• Modified request with new method
• Error if request malformed

Example:

modified, _ := SwitchMethod(request, "PUT")
// Changes method to PUT, keeps params in same locations

func ToLower ¶

func ToLower(c byte) byte

ToLower converts ASCII character to lowercase. Loop-based helper (no library functions).

Parameters:

• c: Character byte

Returns:

• Lowercase version if uppercase ASCII letter, otherwise unchanged

func ToLowerByte ¶

func ToLowerByte(b byte) byte

ToLowerByte converts a single byte to lowercase if it's an ASCII letter.

Example:

ToLowerByte('A') // returns 'a'
ToLowerByte('z') // returns 'z'
ToLowerByte('1') // returns '1'

Parameters:

• b: Byte to convert

Returns:

• Lowercase byte if input is uppercase letter, otherwise unchanged

func ToLowerString ¶

func ToLowerString(s string) string

ToLowerString converts a string to lowercase using loops (no strings.ToLower).

Parameters:

• s: String to convert

Returns:

• Lowercase version of string

Algorithm:

1. Create result buffer
2. Loop through each character
3. Convert uppercase to lowercase using ToLower
4. Return result string

Example:

lower := ToLowerString("HTTP")
// Returns "http"

func ToggleRequestMethod ¶

func ToggleRequestMethod(request []byte) ([]byte, error)

ToggleRequestMethod toggles between GET and POST methods.

Algorithm:

1. Parse request to get current method and parameters
2. Determine new method: GET→POST or POST→GET
3. If current method is NOT GET: - Convert BODY params to URL params - URL-encode parameter values
4. If current method IS GET: - Convert URL params to BODY params
5. Rebuild request with new method

Parameters:

• request: HTTP request

Returns:

• Request with toggled method
• Error if request malformed

Example:

// GET /api?foo=bar → POST /api with body: foo=bar
// POST /api with body: foo=bar → GET /api?foo=bar
toggled, _ := ToggleRequestMethod(request)

func TrimSpace ¶

func TrimSpace(s string) string

TrimSpace removes leading and trailing whitespace. Loop-based implementation (NO regex or strings.TrimSpace).

Parameters:

• s: String to trim

Returns:

• String with leading/trailing spaces and tabs removed

Logic:

1. Find first non-whitespace character (from start)
2. Find last non-whitespace character (from end)
3. Return substring

func UpdateContentLength ¶

func UpdateContentLength(message []byte) ([]byte, error)

UpdateContentLength updates or adds Content-Length header.

Algorithm:

1. Find body offset with strict CRLF CRLF check
2. If no separator, return unchanged
3. Extract headers
4. Calculate body length
5. If body exists OR Content-Length header exists, update/add it
6. Return updated message

Parameters:

• message: HTTP message

Returns:

• Message with correct Content-Length
• Error if message is malformed

Example:

request := []byte("POST / HTTP/1.1\r\nHost: example.com\r\n\r\ntest")
updated, _ := UpdateContentLength(request)
// Returns: "POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 4\r\n\r\ntest"

func UpdateParameter ¶

func UpdateParameter(request []byte, param *Param) ([]byte, error)

UpdateParameter updates a parameter's value in an HTTP request.

Algorithm:

1. Remove parameter from request
2. Add parameter with new value
3. Return modified request

Note: Update is implemented as remove+add, not direct replacement. This ensures proper handling of parameter encoding and structure.

Parameters:

• request: Original HTTP request
• param: Parameter with new value (name, type, and value)

Returns:

• Modified request with updated parameter
• Error if parameter not found or request malformed

Example:

param := BuildParameter("version", "2.0", ParamURL)
modified, _ := UpdateParameter(request, param)

func UrlDecode ¶

func UrlDecode(s string) string

UrlDecode decodes a URL-encoded string. Delegates to DecodeQueryValue in query_parser.go.

Example:

UrlDecode("hello+world")      // Returns "hello world"
UrlDecode("a%3Db%26c%3Dd")    // Returns "a=b&c=d"

Parameters:

• s: URL-encoded string to decode

Returns:

• Decoded string

func UrlDecodeBytes ¶

func UrlDecodeBytes(data []byte) ([]byte, error)

UrlDecodeBytes decodes a URL-encoded byte array.

Algorithm:

1. Loop through each byte
2. Convert '+' to space (byte 32)
3. Decode %XX hex sequences
4. Handle %uXXXX unicode sequences (4 hex digits)
5. Copy other bytes as-is

Example:

UrlDecodeBytes([]byte("hello+world"))      // Returns []byte("hello world")
UrlDecodeBytes([]byte("a%3Db%26c%3Dd"))    // Returns []byte("a=b&c=d")

Parameters:

• data: URL-encoded byte array to decode

Returns:

• Decoded byte array
• Error if decoding fails (for API consistency, though current implementation doesn't error)

func UrlEncode ¶

func UrlEncode(s string) string

UrlEncode encodes a string for safe use in URLs. Delegates to EncodeQueryValue in query_parser.go.

Example:

UrlEncode("hello world")   // Returns "hello+world"
UrlEncode("a=b&c=d")       // Returns "a%3Db%26c%3Dd"

Parameters:

• s: String to encode

Returns:

• URL-encoded string

func UrlEncodeBytes ¶

func UrlEncodeBytes(data []byte) []byte

UrlEncodeBytes encodes byte array for safe use in URLs.

Algorithm:

1. Loop through each byte
2. Encode special characters (#, %, &, +, :, ;, =, ?, @) as %XX
3. Encode space as '+'
4. Leave other characters as-is

Example:

UrlEncodeBytes([]byte("hello world"))   // Returns []byte("hello+world")
UrlEncodeBytes([]byte("a=b&c=d"))       // Returns []byte("a%3Db%26c%3Dd")

Parameters:

• data: Byte array to encode

Returns:

• URL-encoded byte array

func UserAgentIsHonestPreset ¶

func UserAgentIsHonestPreset() bool

UserAgentIsHonestPreset reports whether the effective User-Agent selector is the self-identifying "preset" default. When true the operator has not opted into stealth (random/custom), so browser-harvested User-Agents should not be silently pinned onto downstream requests.

func ValidateHeaders ¶

func ValidateHeaders(request []byte) error

ValidateHeaders checks if headers are well-formed.

Parameters:

• request: HTTP request bytes

Returns:

• Error if headers malformed, nil if valid

Example:

if err := ValidateHeaders(request); err != nil {
    // Handle invalid headers
}

func ValidateRequest ¶

func ValidateRequest(request []byte) error

ValidateRequest checks if a request is well-formed.

Parameters:

• request: HTTP request bytes

Returns:

• Error if request is malformed, nil if valid

Example:

if err := ValidateRequest(request); err != nil {
    // Handle invalid request
}

func ValidateRequestLine ¶

func ValidateRequestLine(request []byte) error

ValidateRequestLine checks if the request line is well-formed.

Parameters:

• request: HTTP request bytes

Returns:

• Error if request line malformed, nil if valid

Example:

if err := ValidateRequestLine(request); err != nil {
    // Handle invalid request line
}