From b60f0d972eeb79a5fba5fb60f1e0568bc8c97e42 Mon Sep 17 00:00:00 2001 From: Andy Balholm Date: Wed, 21 Aug 2019 08:13:43 -0700 Subject: [PATCH] Copy negotiateContentEncoding. A little copying is better than a little dependency. Fixes #8 --- go.mod | 2 - go.sum | 2 - http.go | 192 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ writer.go | 33 ---------- 4 files changed, 192 insertions(+), 37 deletions(-) create mode 100644 http.go diff --git a/go.mod b/go.mod index cb505fa..8e60984 100644 --- a/go.mod +++ b/go.mod @@ -1,5 +1,3 @@ module github.com/andybalholm/brotli go 1.12 - -require github.com/golang/gddo v0.0.0-20190419222130-af0f2af80721 diff --git a/go.sum b/go.sum index 2ed61f3..e69de29 100644 --- a/go.sum +++ b/go.sum @@ -1,2 +0,0 @@ -github.com/golang/gddo v0.0.0-20190419222130-af0f2af80721 h1:KRMr9A3qfbVM7iV/WcLY/rL5LICqwMHLhwRXKu99fXw= -github.com/golang/gddo v0.0.0-20190419222130-af0f2af80721/go.mod h1:xEhNfoBDX1hzLm2Nf80qUvZ2sVwoMZ8d6IE2SrsQfh4= diff --git a/http.go b/http.go new file mode 100644 index 0000000..af58670 --- /dev/null +++ b/http.go @@ -0,0 +1,192 @@ +package brotli + +import ( + "compress/gzip" + "io" + "net/http" + "strings" +) + +// HTTPCompressor chooses a compression method (brotli, gzip, or none) based on +// the Accept-Encoding header, sets the Content-Encoding header, and returns a +// WriteCloser that implements that compression. The Close method must be called +// before the current HTTP handler returns. +// +// Due to https://github.com/golang/go/issues/31753, the response will not be +// compressed unless you set a Content-Type header before you call +// HTTPCompressor. +func HTTPCompressor(w http.ResponseWriter, r *http.Request) io.WriteCloser { + if w.Header().Get("Content-Type") == "" { + return nopCloser{w} + } + + if w.Header().Get("Vary") == "" { + w.Header().Set("Vary", "Accept-Encoding") + } + + encoding := negotiateContentEncoding(r, []string{"br", "gzip"}) + switch encoding { + case "br": + w.Header().Set("Content-Encoding", "br") + return NewWriter(w) + case "gzip": + w.Header().Set("Content-Encoding", "gzip") + return gzip.NewWriter(w) + } + return nopCloser{w} +} + +// negotiateContentEncoding returns the best offered content encoding for the +// request's Accept-Encoding header. If two offers match with equal weight and +// then the offer earlier in the list is preferred. If no offers are +// acceptable, then "" is returned. +func negotiateContentEncoding(r *http.Request, offers []string) string { + bestOffer := "identity" + bestQ := -1.0 + specs := parseAccept(r.Header, "Accept-Encoding") + for _, offer := range offers { + for _, spec := range specs { + if spec.Q > bestQ && + (spec.Value == "*" || spec.Value == offer) { + bestQ = spec.Q + bestOffer = offer + } + } + } + if bestQ == 0 { + bestOffer = "" + } + return bestOffer +} + +// acceptSpec describes an Accept* header. +type acceptSpec struct { + Value string + Q float64 +} + +// parseAccept parses Accept* headers. +func parseAccept(header http.Header, key string) (specs []acceptSpec) { +loop: + for _, s := range header[key] { + for { + var spec acceptSpec + spec.Value, s = expectTokenSlash(s) + if spec.Value == "" { + continue loop + } + spec.Q = 1.0 + s = skipSpace(s) + if strings.HasPrefix(s, ";") { + s = skipSpace(s[1:]) + if !strings.HasPrefix(s, "q=") { + continue loop + } + spec.Q, s = expectQuality(s[2:]) + if spec.Q < 0.0 { + continue loop + } + } + specs = append(specs, spec) + s = skipSpace(s) + if !strings.HasPrefix(s, ",") { + continue loop + } + s = skipSpace(s[1:]) + } + } + return +} + +func skipSpace(s string) (rest string) { + i := 0 + for ; i < len(s); i++ { + if octetTypes[s[i]]&isSpace == 0 { + break + } + } + return s[i:] +} + +func expectTokenSlash(s string) (token, rest string) { + i := 0 + for ; i < len(s); i++ { + b := s[i] + if (octetTypes[b]&isToken == 0) && b != '/' { + break + } + } + return s[:i], s[i:] +} + +func expectQuality(s string) (q float64, rest string) { + switch { + case len(s) == 0: + return -1, "" + case s[0] == '0': + q = 0 + case s[0] == '1': + q = 1 + default: + return -1, "" + } + s = s[1:] + if !strings.HasPrefix(s, ".") { + return q, s + } + s = s[1:] + i := 0 + n := 0 + d := 1 + for ; i < len(s); i++ { + b := s[i] + if b < '0' || b > '9' { + break + } + n = n*10 + int(b) - '0' + d *= 10 + } + return q + float64(n)/float64(d), s[i:] +} + +// Octet types from RFC 2616. +var octetTypes [256]octetType + +type octetType byte + +const ( + isToken octetType = 1 << iota + isSpace +) + +func init() { + // OCTET = + // CHAR = + // CTL = + // CR = + // LF = + // SP = + // HT = + // <"> = + // CRLF = CR LF + // LWS = [CRLF] 1*( SP | HT ) + // TEXT = + // separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <"> + // | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT + // token = 1* + // qdtext = > + + for c := 0; c < 256; c++ { + var t octetType + isCtl := c <= 31 || c == 127 + isChar := 0 <= c && c <= 127 + isSeparator := strings.IndexRune(" \t\"(),/:;<=>?@[]\\{}", rune(c)) >= 0 + if strings.IndexRune(" \t\r\n", rune(c)) >= 0 { + t |= isSpace + } + if isChar && !isCtl && !isSeparator { + t |= isToken + } + octetTypes[c] = t + } +} diff --git a/writer.go b/writer.go index 22f0faf..ec333f9 100644 --- a/writer.go +++ b/writer.go @@ -1,12 +1,8 @@ package brotli import ( - "compress/gzip" "errors" "io" - "net/http" - - "github.com/golang/gddo/httputil" ) const ( @@ -125,32 +121,3 @@ type nopCloser struct { } func (nopCloser) Close() error { return nil } - -// HTTPCompressor chooses a compression method (brotli, gzip, or none) based on -// the Accept-Encoding header, sets the Content-Encoding header, and returns a -// WriteCloser that implements that compression. The Close method must be called -// before the current HTTP handler returns. -// -// Due to https://github.com/golang/go/issues/31753, the response will not be -// compressed unless you set a Content-Type header before you call -// HTTPCompressor. -func HTTPCompressor(w http.ResponseWriter, r *http.Request) io.WriteCloser { - if w.Header().Get("Content-Type") == "" { - return nopCloser{w} - } - - if w.Header().Get("Vary") == "" { - w.Header().Set("Vary", "Accept-Encoding") - } - - encoding := httputil.NegotiateContentEncoding(r, []string{"br", "gzip"}) - switch encoding { - case "br": - w.Header().Set("Content-Encoding", "br") - return NewWriter(w) - case "gzip": - w.Header().Set("Content-Encoding", "gzip") - return gzip.NewWriter(w) - } - return nopCloser{w} -}