httphead

func CanonicalizeHeaderKey ¶

func CanonicalizeHeaderKey(k []byte)

CanonicalizeHeaderKey is like standard textproto/CanonicalMIMEHeaderKey, except that it operates with slice of bytes and modifies it inplace without copying.

func IntFromASCII ¶

func IntFromASCII(bts []byte) (ret int, ok bool)

IntFromASCII converts ascii encoded decimal numeric value from HTTP entities to an integer.

func ParseHeaderLine ¶

func ParseHeaderLine(line []byte) (k, v []byte, ok bool)

ParseHeaderLine parses HTTP header as key-value pair. It returns parsed values and true if parse is ok.

func ParseVersion ¶

func ParseVersion(bts []byte) (major, minor int, ok bool)

ParseVersion parses major and minor version of HTTP protocol. It returns parsed values and true if parse is ok.

func ReadLine ¶

func ReadLine(br *bufio.Reader) ([]byte, error)

ReadLine reads line from br. It reads until '\n' and returns bytes without '\n' or '\r\n' at the end. It returns err if and only if line does not end in '\n'. Note that read bytes returned in any case of error.

It is much like the textproto/Reader.ReadLine() except the thing that it returns raw bytes, instead of string. That is, it avoids copying bytes read from br.

textproto/Reader.ReadLineBytes() is also makes copy of resulting bytes to be safe with future I/O operations on br.

We could control I/O operations on br and do not need to make additional copy for safety.

func RemoveByte ¶

func RemoveByte(data []byte, c byte) []byte

RemoveByte returns data without c. If c is not present in data it returns the same slice. If not, it copies data without c.

func ScanCookie ¶

func ScanCookie(data []byte, it func(key, value []byte) bool) bool

ScanCookie scans cookie pairs from data using DefaultCookieScanner.Scan() method.

func ScanOptions ¶

func ScanOptions(data []byte, it func(index int, option, attribute, value []byte) Control) bool

ScanOptions parses data in this form:

values = 1#value value = token *( ";" param ) param = token [ "=" (token | quoted-string) ]

It calls given callback with the index of the option, option itself and its parameter (attribute and its value, both could be nil). Index is useful when header contains multiple choises for the same named option.

Given callback should return one of the defined Control* values. ControlSkip means that passed key is not in caller's interest. That is, all parameters of that key will be skipped. ControlBreak means that no more keys and parameters should be parsed. That is, it must break parsing immediately. ControlContinue means that caller want to receive next parameter and its value or the next key.

It returns false if data is malformed.

foo := map[string]string{}

ScanOptions([]byte(`foo;bar=1;baz`), func(index int, key, param, value []byte) Control {
	foo[string(param)] = string(value)
	return ControlContinue
})

fmt.Printf("bar:%s baz:%s", foo["bar"], foo["baz"])

Output:

bar:1 baz:

func ScanPairGreedy ¶

func ScanPairGreedy(data []byte, open, close byte) (n int)

ScanPairGreedy scans for complete pair of opening and closing chars in greedy manner. Note that first opening byte must not be present in data.

func ScanTokens ¶

func ScanTokens(data []byte, it func([]byte) bool) bool

ScanTokens parses data in this form:

list = 1#token

It returns false if data is malformed.

var values []string

ScanTokens([]byte(`a,b,c`), func(v []byte) bool {
	values = append(values, string(v))
	return v[0] != 'b'
})

fmt.Println(values)

Output:

[a b]

func ScanUntil ¶

func ScanUntil(data []byte, c byte) (n int)

ScanUntil scans for first non-escaped character c in given data. It returns index of matched c and -1 if c is not found.

func SkipSpace ¶

func SkipSpace(p []byte) (n int)

SkipSpace skips spaces and lws-sequences from p. It returns number ob bytes skipped.

func SplitRequestLine ¶

func SplitRequestLine(line []byte) (method, uri, version []byte)

SplitRequestLine splits given slice of bytes into three chunks without parsing.

func SplitResponseLine ¶

func SplitResponseLine(line []byte) (version, status, reason []byte)

SplitResponseLine splits given slice of bytes into three chunks without parsing.

func ValidCookieName ¶

func ValidCookieName(name []byte) bool

ValidCookieName reports wheter given bytes is a valid RFC2616 "token" bytes.

func ValidCookieValue ¶

func ValidCookieValue(value []byte, strict bool) bool

ValidCookieValue reports whether given value is a valid RFC6265 "cookie-octet" bytes.

cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E

; US-ASCII characters excluding CTLs,
; whitespace DQUOTE, comma, semicolon,
; and backslash

Note that the false strict parameter disables errors on space 0x20 and comma 0x2c. This could be useful to bring some compatibility with non-compliant clients/servers in the real world. It acts the same as standard library cookie parser if strict is false.

func WriteOptions ¶

func WriteOptions(dest io.Writer, options []Option) (n int, err error)

WriteOptions write options list to the dest. It uses the same form as {Scan,Parse}Options functions: values = 1#value value = token *( ";" param ) param = token [ "=" (token | quoted-string) ]

It wraps valuse into the quoted-string sequence if it contains any non-token characters.

opts := []Option{
	NewOption("foo", map[string]string{
		"param": "hello, world!",
	}),
	NewOption("bar", nil),
	NewOption("b a z", nil),
}

buf := bytes.Buffer{}
bw := bufio.NewWriter(&buf)

WriteOptions(bw, opts)
bw.Flush()

Output:

foo;param="hello, world!",bar,"b a z"