Something went wrong. Try again.
[mirror] Scalable static site server for Git forges (like GitHub Pages)
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174package git_pages
import ( "cmp" "fmt" "net" "net/http" "regexp" "slices" "strconv" "strings")
var httpAcceptRegexp = regexp.MustCompile(`` + // token optionally prefixed by whitespace `^[ \t]*([a-zA-Z0-9$!#$%&'*+./^_\x60|~-]+)` + // quality value prefixed by a semicolon optionally surrounded by whitespace `(?:[ \t]*;[ \t]*q=(0(?:\.[0-9]{1,3})?|1(?:\.0{1,3})?))?` + // optional whitespace followed by comma or end of line `[ \t]*(?:,|$)`,)
type httpAcceptOffer struct { code string qval float64}
func parseGenericAcceptHeader(headerValue string) (result []httpAcceptOffer) { for headerValue != "" { matches := httpAcceptRegexp.FindStringSubmatch(headerValue) if matches == nil { return } offer := httpAcceptOffer{strings.ToLower(matches[1]), 1.0} if matches[2] != "" { offer.qval, _ = strconv.ParseFloat(matches[2], 64) } result = append(result, offer) headerValue = headerValue[len(matches[0]):] } return}
func preferredAcceptOffer(offers []httpAcceptOffer) string { slices.SortStableFunc(offers, func(a, b httpAcceptOffer) int { return -cmp.Compare(a.qval, b.qval) }) for _, offer := range offers { if offer.qval != 0 { return offer.code } } return ""}
type HTTPContentTypes struct { contentTypes []httpAcceptOffer}
func ParseAcceptHeader(headerValue string) (result HTTPContentTypes) { if headerValue == "" { headerValue = "*/*" } result = HTTPContentTypes{parseGenericAcceptHeader(headerValue)} return}
func (e *HTTPContentTypes) Negotiate(offers ...string) string { prefs := make(map[string]float64, len(offers)) for _, code := range offers { prefs[code] = 0 } for _, ctyp := range e.contentTypes { if ctyp.code == "*/*" { for code := range prefs { prefs[code] = ctyp.qval } } else if _, ok := prefs[ctyp.code]; ok { prefs[ctyp.code] = ctyp.qval } } ctyps := make([]httpAcceptOffer, len(offers)) for idx, code := range offers { ctyps[idx] = httpAcceptOffer{code, prefs[code]} } return preferredAcceptOffer(ctyps)}
type HTTPEncodings struct { encodings []httpAcceptOffer}
func ParseAcceptEncodingHeader(headerValue string) (result HTTPEncodings) { result = HTTPEncodings{parseGenericAcceptHeader(headerValue)} if len(result.encodings) == 0 { // RFC 9110 says (https://httpwg.org/specs/rfc9110.html#field.accept-encoding): // "If no Accept-Encoding header field is in the request, any content // coding is considered acceptable by the user agent." // In practice, no client expects to receive a compressed response // without having sent Accept-Encoding in the request. } return}
// Negotiate returns the most preferred encoding that is acceptable by the// client, or an empty string if no encodings are acceptable.func (e *HTTPEncodings) Negotiate(offers ...string) string { prefs := make(map[string]float64, len(offers)+1) implicitIdentity := true for _, enc := range e.encodings { if slices.Contains(offers, enc.code) || enc.code == "*" { prefs[enc.code] = enc.qval } if enc.code == "*" || enc.code == "identity" { implicitIdentity = false } } if implicitIdentity { prefs["identity"] = -1 // sort last } encs := make([]httpAcceptOffer, len(offers)) for idx, code := range offers { pref, ok := prefs[code] if !ok { pref = prefs["*"] } encs[idx] = httpAcceptOffer{code, pref} } return preferredAcceptOffer(encs)}
func chainHTTPMiddleware(middleware ...func(http.Handler) http.Handler) func(http.Handler) http.Handler { return func(handler http.Handler) http.Handler { for idx := len(middleware) - 1; idx >= 0; idx-- { handler = middleware[idx](handler) } return handler }}
func remoteAddrMiddleware(handler http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var readXForwardedFor bool switch config.Audit.IncludeIPs { case "X-Forwarded-For": readXForwardedFor = true case "RemoteAddr", "": readXForwardedFor = false default: panic(fmt.Errorf("config.Audit.IncludeIPs is set to an unknown value (%q)", config.Audit.IncludeIPs)) }
usingOriginalRemoteAddr := true if readXForwardedFor { forwardedFor := strings.Split(r.Header.Get("X-Forwarded-For"), ",") if len(forwardedFor) > 0 { remoteAddr := strings.TrimSpace(forwardedFor[len(forwardedFor)-1]) if remoteAddr != "" { r.RemoteAddr = remoteAddr usingOriginalRemoteAddr = false } } } if usingOriginalRemoteAddr { if ipAddress, _, err := net.SplitHostPort(r.RemoteAddr); err == nil { r.RemoteAddr = ipAddress } }
handler.ServeHTTP(w, r) })}