clawbot
7b6712538e
check / check (push) Canceled after 0s
The image request now holds only its source and its transform, exactly what the variant key covers. The /v1/image/ handler checks the allowlist and verifies the signature itself with Signer.Verify(req, sig, expires). Both image handlers keep the URL's expiry as a local value for Cache-Control. The image service holds no signer, allowlist or AllowHTTP, and ValidateRequest is gone. The fetcher takes the source and builds its URL with Source.URL from its own AllowHTTP, so no URL string is built and parsed again. chooseAutoFormat returns the format it chooses instead of writing into the request. The signed URL format and every route's answers are unchanged. Model: opus-5-5
135 lines
3.6 KiB
Go
135 lines
3.6 KiB
Go
package handlers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"mime"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"sneak.berlin/go/pixa/internal/imagerequest"
|
|
)
|
|
|
|
// Errors for an Accept header that an auto URL cannot be served for.
|
|
var (
|
|
errInvalidAccept = errors.New("invalid Accept header")
|
|
errNotAcceptable = errors.New("not acceptable: auto serves " +
|
|
"image/jxl, image/avif, image/webp or image/jpeg")
|
|
)
|
|
|
|
// chooseAutoFormat returns the format to serve for the requested format: for
|
|
// the format auto, the format formatForAccept chooses from r's Accept header,
|
|
// and any other format as it is. For auto it adds Vary: Accept to the
|
|
// response, which then depends on that header. It answers 400 for an Accept
|
|
// header that is not valid and 406 for one that allows none of the formats,
|
|
// and reports whether the image can be served.
|
|
func (s *Handlers) chooseAutoFormat(
|
|
w http.ResponseWriter, r *http.Request, requested imagerequest.Format,
|
|
) (imagerequest.Format, bool) {
|
|
if requested != imagerequest.FormatAuto {
|
|
return requested, true
|
|
}
|
|
|
|
w.Header().Add("Vary", "Accept")
|
|
|
|
format, err := formatForAccept(strings.Join(r.Header.Values("Accept"), ","))
|
|
if errors.Is(err, errNotAcceptable) {
|
|
s.respondError(w, err.Error(), http.StatusNotAcceptable)
|
|
|
|
return "", false
|
|
}
|
|
|
|
if err != nil {
|
|
s.respondError(w, err.Error(), http.StatusBadRequest)
|
|
|
|
return "", false
|
|
}
|
|
|
|
return format, true
|
|
}
|
|
|
|
// formatForAccept returns the format an auto URL is served in for the Accept
|
|
// header accept: JPEG XL when it names image/jxl, else AVIF when it names
|
|
// image/avif, else WebP when it names image/webp, else JPEG when its most
|
|
// specific entry of image/jpeg, image/* and */* allows it, or when it names
|
|
// nothing. A q of 0 refuses a format. JPEG XL, AVIF and WebP must be named, as
|
|
// clients that cannot show them send image/* and */* too.
|
|
func formatForAccept(accept string) (imagerequest.Format, error) {
|
|
qualities, err := parseAccept(accept)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if len(qualities) == 0 {
|
|
return imagerequest.FormatJPEG, nil
|
|
}
|
|
|
|
if qualities["image/jxl"] > 0 {
|
|
return imagerequest.FormatJXL, nil
|
|
}
|
|
|
|
if qualities["image/avif"] > 0 {
|
|
return imagerequest.FormatAVIF, nil
|
|
}
|
|
|
|
if qualities["image/webp"] > 0 {
|
|
return imagerequest.FormatWebP, nil
|
|
}
|
|
|
|
// For JPEG, the most specific entry the header has decides
|
|
quality, named := qualities["image/jpeg"]
|
|
if !named {
|
|
quality, named = qualities["image/*"]
|
|
}
|
|
|
|
if !named {
|
|
quality = qualities["*/*"]
|
|
}
|
|
|
|
if quality > 0 {
|
|
return imagerequest.FormatJPEG, nil
|
|
}
|
|
|
|
return "", errNotAcceptable
|
|
}
|
|
|
|
// parseAccept returns the q of each media range the Accept header accept
|
|
// names, 1 where it gives none. A media range named more than once keeps its
|
|
// lowest q, so a refusal is never overridden. A media range that does not
|
|
// parse, or a q that is not a number from 0 to 1, is an error.
|
|
func parseAccept(accept string) (map[string]float64, error) {
|
|
qualities := make(map[string]float64)
|
|
|
|
for entry := range strings.SplitSeq(accept, ",") {
|
|
// A header field list may hold empty entries
|
|
if strings.TrimSpace(entry) == "" {
|
|
continue
|
|
}
|
|
|
|
mediaRange, params, err := mime.ParseMediaType(entry)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%w: %q: %w", errInvalidAccept, entry, err)
|
|
}
|
|
|
|
quality := 1.0
|
|
|
|
if qParam, given := params["q"]; given {
|
|
quality, err = strconv.ParseFloat(qParam, 64)
|
|
inRange := quality >= 0 && quality <= 1
|
|
|
|
if err != nil || !inRange {
|
|
return nil, fmt.Errorf("%w: %q: q is not a number from 0 to 1",
|
|
errInvalidAccept, entry)
|
|
}
|
|
}
|
|
|
|
previous, named := qualities[mediaRange]
|
|
if !named || quality < previous {
|
|
qualities[mediaRange] = quality
|
|
}
|
|
}
|
|
|
|
return qualities, nil
|
|
}
|