Strip Accept-Ranges on compressed content

Fixes nytimes/gziphandler#83

Adds `KeepAcceptRanges()` if for whatever reason you would want to keep them.

gzhttp/gzip.go

@@ -20,6 +20,8 @@ const (
  vary = "Vary"
  acceptEncoding = "Accept-Encoding"
  contentEncoding = "Content-Encoding"
+ contentRange = "Content-Range"
+ acceptRanges = "Accept-Ranges"
  contentType = "Content-Type"
  contentLength = "Content-Length"
 )
@@ -51,9 +53,10 @@ type GzipResponseWriter struct {
 
  code int // Saves the WriteHeader value.
 
- minSize int // Specifies the minimum response size to gzip. If the response length is bigger than this value, it is compressed.
- buf []byte // Holds the first part of the write before reaching the minSize or the end of the write.
- ignore bool // If true, then we immediately passthru writes to the underlying ResponseWriter.
+ minSize int // Specifies the minimum response size to gzip. If the response length is bigger than this value, it is compressed.
+ buf []byte // Holds the first part of the write before reaching the minSize or the end of the write.
+ ignore bool // If true, then we immediately passthru writes to the underlying ResponseWriter.
+ keepAcceptRanges bool // Keep "Accept-Ranges" header.
 
  contentTypeFilter func(ct string) bool // Only compress if the response is one of these content-types. All are accepted if empty.
 }
@@ -86,13 +89,16 @@ func (w *GzipResponseWriter) Write(b []byte) (int, error) {
  cl, _ = strconv.Atoi(w.Header().Get(contentLength))
  ct = w.Header().Get(contentType)
  ce = w.Header().Get(contentEncoding)
+ cr = w.Header().Get(contentRange)
  )
+
  // Only continue if they didn't already choose an encoding or a known unhandled content length or type.
- if ce == "" && (cl == 0 || cl >= w.minSize) && (ct == "" || w.contentTypeFilter(ct)) {
+ if ce == "" && cr == "" && (cl == 0 || cl >= w.minSize) && (ct == "" || w.contentTypeFilter(ct)) {
  // If the current buffer is less than minSize and a Content-Length isn't set, then wait until we have more data.
  if len(w.buf) < w.minSize && cl == 0 {
  return len(b), nil
  }
+
  // If the Content-Length is larger than minSize or the current buffer is larger than minSize, then continue.
  if cl >= w.minSize || len(w.buf) >= w.minSize {
  // If a Content-Type wasn't specified, infer it from the current buffer.
@@ -132,6 +138,11 @@ func (w *GzipResponseWriter) startGzip() error {
  // See: https://github.com/golang/go/issues/14975.
  w.Header().Del(contentLength)
 
+ // Delete Accept-Ranges.
+ if !w.keepAcceptRanges {
+ w.Header().Del(acceptRanges)
+ }
+
  // Write the header to gzip response.
  if w.code != 0 {
  w.ResponseWriter.WriteHeader(w.code)
@@ -297,6 +308,7 @@ func NewWrapper(opts ...option) (func(http.Handler) http.Handler, error) {
  level: c.level,
  minSize: c.minSize,
  contentTypeFilter: c.contentTypes,
+ keepAcceptRanges: c.keepAcceptRanges,
  }
  defer gw.Close()
 
@@ -345,10 +357,11 @@ func (pct parsedContentType) equals(mediaType string, params map[string]string)
 
 // Used for functional configuration.
 type config struct {
- minSize int
- level int
- writer writer.GzipWriterFactory
- contentTypes func(ct string) bool
+ minSize int
+ level int
+ writer writer.GzipWriterFactory
+ contentTypes func(ct string) bool
+ keepAcceptRanges bool
 }
 
 func (c *config) validate() error {
@@ -457,6 +470,15 @@ func ExceptContentTypes(types []string) option {
  }
 }
 
+// KeepAcceptRanges will keep Accept-Ranges header on gzipped responses.
+// This will likely break ranged requests since that cannot be transparently
+// handled by the filter.
+func KeepAcceptRanges() option {
+ return func(c *config) {
+ c.keepAcceptRanges = true
+ }
+}
+
 // ContentTypeFilter allows adding a custom content type filter.
 //
 // The supplied function must return true/false to indicate if content

gzhttp/gzip_test.go

@@ -114,6 +114,72 @@ func TestGzipHandlerAlreadyCompressed(t *testing.T) {
  assertEqual(t, testBody, res.Body.String())
 }
 
+func TestGzipHandlerRangeReply(t *testing.T) {
+ handler := GzipHandler(
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Range", "bytes 0-300/804")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testBody))
+ }))
+ req, _ := http.NewRequest("GET", "/gzipped", nil)
+ req.Header.Set("Accept-Encoding", "gzip")
+
+ resp := httptest.NewRecorder()
+ handler.ServeHTTP(resp, req)
+ res := resp.Result()
+ assertEqual(t, 200, res.StatusCode)
+ assertEqual(t, "", res.Header.Get("Content-Encoding"))
+ assertEqual(t, testBody, resp.Body.String())
+}
+
+func TestGzipHandlerAcceptRange(t *testing.T) {
+ handler := GzipHandler(
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Accept-Ranges", "bytes")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testBody))
+ }))
+ req, _ := http.NewRequest("GET", "/gzipped", nil)
+ req.Header.Set("Accept-Encoding", "gzip")
+
+ resp := httptest.NewRecorder()
+ handler.ServeHTTP(resp, req)
+ res := resp.Result()
+ assertEqual(t, 200, res.StatusCode)
+ assertEqual(t, "gzip", res.Header.Get("Content-Encoding"))
+ assertEqual(t, "", res.Header.Get("Accept-Ranges"))
+ zr, err := gzip.NewReader(resp.Body)
+ assertNil(t, err)
+ got, err := ioutil.ReadAll(zr)
+ assertNil(t, err)
+ assertEqual(t, testBody, string(got))
+}
+
+func TestGzipHandlerKeepAcceptRange(t *testing.T) {
+ wrapper, err := NewWrapper(KeepAcceptRanges())
+ assertNil(t, err)
+ handler := wrapper(
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Accept-Ranges", "bytes")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testBody))
+ }))
+ req, _ := http.NewRequest("GET", "/gzipped", nil)
+ req.Header.Set("Accept-Encoding", "gzip")
+
+ resp := httptest.NewRecorder()
+ handler.ServeHTTP(resp, req)
+ res := resp.Result()
+ assertEqual(t, 200, res.StatusCode)
+ assertEqual(t, "gzip", res.Header.Get("Content-Encoding"))
+ assertEqual(t, "bytes", res.Header.Get("Accept-Ranges"))
+ zr, err := gzip.NewReader(resp.Body)
+ assertNil(t, err)
+ got, err := ioutil.ReadAll(zr)
+ assertNil(t, err)
+ assertEqual(t, testBody, string(got))
+}
+
 func TestNewGzipLevelHandler(t *testing.T) {
  handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  w.WriteHeader(http.StatusOK)