// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved. // SPDX-License-Identifier: Apache-2.0 package response // import "miniflux.app/v2/internal/http/response" import ( "bytes" "compress/flate" "compress/gzip" "fmt" "io" "log/slog" "maps" "mime" "net/http" "strings" "sync" "time" "github.com/andybalholm/brotli" ) const compressionThreshold = 1024 // Compression writers are pooled so each request reuses their internal // state (brotli sliding window + hash tables, flate dictionary, etc.) // instead of allocating it from scratch. Reset(dst) rebinds the // destination without re-allocating the buffers. var ( brotliWriterPool = sync.Pool{ New: func() any { return brotli.NewWriterV2(io.Discard, brotli.DefaultCompression) }, } gzipWriterPool = sync.Pool{ New: func() any { return gzip.NewWriter(io.Discard) }, } flateWriterPool = sync.Pool{ New: func() any { w, _ := flate.NewWriter(io.Discard, flate.DefaultCompression) return w }, } ) type writeResetCloser interface { io.WriteCloser Reset(io.Writer) } func pooledWriter(pool *sync.Pool, dst io.Writer) (io.WriteCloser, func()) { w := pool.Get().(writeResetCloser) w.Reset(dst) cancel := func() { w.Reset(io.Discard) pool.Put(w) } return w, cancel } // Builder generates HTTP responses. type Builder struct { w http.ResponseWriter r *http.Request statusCode int headers http.Header enableCompression bool body io.Reader } // NewBuilder creates a new response builder. func NewBuilder(w http.ResponseWriter, r *http.Request) *Builder { return &Builder{w: w, r: r, statusCode: http.StatusOK, headers: make(http.Header), enableCompression: true} } // WithStatus uses the given status code to build the response. func (b *Builder) WithStatus(statusCode int) *Builder { b.statusCode = statusCode return b } // WithHeader adds the given HTTP header to the response. func (b *Builder) WithHeader(key, value string) *Builder { b.headers.Set(key, value) return b } // WithBodyAsBytes uses the given bytes to build the response. func (b *Builder) WithBodyAsBytes(body []byte) *Builder { b.body = bytes.NewReader(body) return b } // WithBodyAsString uses the given string to build the response. func (b *Builder) WithBodyAsString(body string) *Builder { b.body = strings.NewReader(body) return b } // WithBodyAsReader uses the given reader to build the response. func (b *Builder) WithBodyAsReader(body io.Reader) *Builder { b.body = body return b } // WithAttachment forces the document to be downloaded by the web browser. func (b *Builder) WithAttachment(filename string) *Builder { b.headers.Set("Content-Disposition", formatContentDisposition("attachment", filename)) return b } // WithInline suggests an inline filename for the current response. func (b *Builder) WithInline(filename string) *Builder { b.headers.Set("Content-Disposition", formatContentDisposition("inline", filename)) return b } // WithoutCompression disables HTTP compression. func (b *Builder) WithoutCompression() *Builder { b.enableCompression = false return b } // WithCaching marks the response as publicly cacheable; use it only when the body never depends on the session. func (b *Builder) WithCaching(etag string, duration time.Duration, callback func(*Builder)) { etag = normalizeETag(etag) b.headers.Set("ETag", etag) // max-age is required for the "immutable" directive to take effect: without // it, browsers still revalidate content-hashed assets on every reload. b.headers.Set("Cache-Control", fmt.Sprintf("public, max-age=%d, immutable", int64(duration.Seconds()))) b.headers.Set("Expires", time.Now().Add(duration).UTC().Format(http.TimeFormat)) if ifNoneMatch(b.r.Header.Get("If-None-Match"), etag) { b.statusCode = http.StatusNotModified b.body = nil b.Write() } else { callback(b) } } type nopWriteCloser struct { io.Writer } func (nopWriteCloser) Close() error { return nil } type nopWriteCloserReaderFrom struct { io.Writer } func (nopWriteCloserReaderFrom) Close() error { return nil } func (c nopWriteCloserReaderFrom) ReadFrom(r io.Reader) (n int64, err error) { return c.Writer.(io.ReaderFrom).ReadFrom(r) } // Write generates the HTTP response. func (b *Builder) Write() { if b.body == nil { b.writeHeaders() return } cancel := func() {} defer func() { cancel() }() var wc io.WriteCloser switch b.acceptEncoding() { case "": // A hack to avoid infinite loop as [HTMLNotAcceptable] also calls [NewBuilder] from request. cloned := b.r.Clone(b.r.Context()) cloned.Header.Del("Content-Encoding") // [Builder.acceptEncoding] returns "" as per [HTTP Semantics]: // As long as the identity;q=0 or *;q=0 directives do not explicitly forbid // the identity value that means no encoding, the server must never return // a 406 Not Acceptable error. // // [HTTP Semantics]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding. HTMLNotAcceptable(b.w, cloned) return case brotliEncoding: b.headers.Set("Content-Encoding", brotliEncoding) wc, cancel = pooledWriter(&brotliWriterPool, b.w) case gzipEncoding: b.headers.Set("Content-Encoding", gzipEncoding) wc, cancel = pooledWriter(&gzipWriterPool, b.w) case deflateEncoding: b.headers.Set("Content-Encoding", deflateEncoding) wc, cancel = pooledWriter(&flateWriterPool, b.w) default: // Fallback writer with no compression. // Wraps [io.Writer] to make it implement [io.WriteCloser]. // // That is straight-up copy from [io.NopCloser] for [io.Reader] // as [io] doesn't have an alternative for [io.Writer]. wc = nopWriteCloser{b.w} if _, ok := b.w.(io.ReaderFrom); ok { wc = nopWriteCloserReaderFrom{b.w} } } b.headers.Set("Vary", "Accept-Encoding") b.writeHeaders() _, err := io.Copy(wc, b.body) if err != nil { slog.Error("Unable to write response body", "error", err) } wc.Close() } func (b *Builder) writeHeaders() { b.headers.Set("X-Content-Type-Options", "nosniff") b.headers.Set("X-Frame-Options", "DENY") b.headers.Set("Referrer-Policy", "no-referrer") maps.Copy(b.w.Header(), b.headers) // Shared caches must never replay a cookie to other visitors. headers := b.w.Header() if len(headers.Values("Set-Cookie")) > 0 && strings.Contains(headers.Get("Cache-Control"), "public") { headers.Set("Cache-Control", "private, no-store") headers.Del("Expires") } b.w.WriteHeader(b.statusCode) } const ( brotliEncoding = "br" gzipEncoding = "gzip" deflateEncoding = "deflate" identityEncoding = "identity" ) var acceptEncoding = AcceptEncoding( brotliEncoding, gzipEncoding, deflateEncoding, ) // acceptEncoding returns appropriate encoding for the response. // // Encoding will always be "identity" when compression explicitly disabled // or size of the body under [compressionThreshold] bytes. // // Otherwise, it is decided by "Accept-Encoding" header. func (b *Builder) acceptEncoding() string { type sizer interface { Size() int64 } encoding := acceptEncoding.Parse(b.r.Header.Get("Accept-Encoding")) if encoding == "" || encoding == identityEncoding { return encoding } if !b.enableCompression { return identityEncoding } if body, ok := b.body.(sizer); ok && body.Size() <= compressionThreshold { return identityEncoding } return encoding } func normalizeETag(etag string) string { etag = strings.TrimSpace(etag) if etag == "" { return "" } if strings.HasPrefix(etag, `"`) || strings.HasPrefix(etag, `W/"`) { return etag } return `"` + etag + `"` } func ifNoneMatch(headerValue, etag string) bool { if headerValue == "" || etag == "" { return false } if strings.TrimSpace(headerValue) == "*" { return true } // Weak ETag comparison: the opaque-tag (quoted string without W/ prefix) must match. return strings.Contains(headerValue, strings.TrimPrefix(etag, `W/`)) } func formatContentDisposition(dispositionType, filename string) string { if filename == "" { return dispositionType } if value := mime.FormatMediaType(dispositionType, map[string]string{"filename": filename}); value != "" { return value } return dispositionType }