Initial QSfera import

Server/vendor/github.com/lestrrat-go/httpcc/.gitignore

@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/

Server/vendor/github.com/lestrrat-go/httpcc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 lestrrat-go
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Server/vendor/github.com/lestrrat-go/httpcc/README.md

@@ -0,0 +1,35 @@
+httpcc
+======
+
+Parses HTTP/1.1 Cache-Control header, and returns a struct that is convenient
+for the end-user to do what they will with.
+
+# Parsing the HTTP Request
+
+```go
+dir, err := httpcc.ParseRequest(req.Header.Get(`Cache-Control`))
+// dir.MaxAge()       uint64, bool
+// dir.MaxStale()     uint64, bool
+// dir.MinFresh()     uint64, bool
+// dir.NoCache()      bool
+// dir.NoStore()      bool
+// dir.NoTransform()  bool
+// dir.OnlyIfCached() bool
+// dir.Extensions()   map[string]string
+```
+
+# Parsing the HTTP Response
+
+```go
+directives, err := httpcc.ParseResponse(res.Header.Get(`Cache-Control`))
+// dir.MaxAge()         uint64, bool
+// dir.MustRevalidate() bool
+// dir.NoCache()        []string
+// dir.NoStore()        bool
+// dir.NoTransform()    bool
+// dir.Public()         bool
+// dir.Private()        bool
+// dir.SMaxAge()        uint64, bool
+// dir.Extensions()     map[string]string
+```
+

Server/vendor/github.com/lestrrat-go/httpcc/directives.go

@@ -0,0 +1,117 @@
+package httpcc
+
+type RequestDirective struct {
+	maxAge       *uint64
+	maxStale     *uint64
+	minFresh     *uint64
+	noCache      bool
+	noStore      bool
+	noTransform  bool
+	onlyIfCached bool
+	extensions   map[string]string
+}
+
+func (d *RequestDirective) MaxAge() (uint64, bool) {
+	if v := d.maxAge; v != nil {
+		return *v, true
+	}
+	return 0, false
+}
+
+func (d *RequestDirective) MaxStale() (uint64, bool) {
+	if v := d.maxStale; v != nil {
+		return *v, true
+	}
+	return 0, false
+}
+
+func (d *RequestDirective) MinFresh() (uint64, bool) {
+	if v := d.minFresh; v != nil {
+		return *v, true
+	}
+	return 0, false
+}
+
+func (d *RequestDirective) NoCache() bool {
+	return d.noCache
+}
+
+func (d *RequestDirective) NoStore() bool {
+	return d.noStore
+}
+
+func (d *RequestDirective) NoTransform() bool {
+	return d.noTransform
+}
+
+func (d *RequestDirective) OnlyIfCached() bool {
+	return d.onlyIfCached
+}
+
+func (d *RequestDirective) Extensions() map[string]string {
+	return d.extensions
+}
+
+func (d *RequestDirective) Extension(s string) string {
+	return d.extensions[s]
+}
+
+type ResponseDirective struct {
+	maxAge          *uint64
+	noCache         []string
+	noStore         bool
+	noTransform     bool
+	public          bool
+	private         []string
+	proxyRevalidate bool
+	sMaxAge         *uint64
+	extensions      map[string]string
+}
+
+func (d *ResponseDirective) MaxAge() (uint64, bool) {
+	if v := d.maxAge; v != nil {
+		return *v, true
+	}
+	return 0, false
+}
+
+func (d *ResponseDirective) NoCache() []string {
+	return d.noCache
+}
+
+func (d *ResponseDirective) NoStore() bool {
+	return d.noStore
+}
+
+func (d *ResponseDirective) NoTransform() bool {
+	return d.noTransform
+}
+
+func (d *ResponseDirective) Public() bool {
+	return d.public
+}
+
+func (d *ResponseDirective) Private() []string {
+	return d.private
+}
+
+func (d *ResponseDirective) ProxyRevalidate() bool {
+	return d.proxyRevalidate
+}
+
+func (d *ResponseDirective) SMaxAge() (uint64, bool) {
+	if v := d.sMaxAge; v != nil {
+		return *v, true
+	}
+	return 0, false
+}
+
+func (d *ResponseDirective) Extensions() map[string]string {
+	return d.extensions
+}
+
+func (d *ResponseDirective) Extension(s string) string {
+	return d.extensions[s]
+}
+
+

Server/vendor/github.com/lestrrat-go/httpcc/httpcc.go

@@ -0,0 +1,310 @@
+package httpcc
+
+import (
+	"bufio"
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+const (
+	// Request Cache-Control directives
+	MaxAge       = "max-age" // used in response as well
+	MaxStale     = "max-stale"
+	MinFresh     = "min-fresh"
+	NoCache      = "no-cache"     // used in response as well
+	NoStore      = "no-store"     // used in response as well
+	NoTransform  = "no-transform" // used in response as well
+	OnlyIfCached = "only-if-cached"
+
+	// Response Cache-Control directive
+	MustRevalidate  = "must-revalidate"
+	Public          = "public"
+	Private         = "private"
+	ProxyRevalidate = "proxy-revalidate"
+	SMaxAge         = "s-maxage"
+)
+
+type TokenPair struct {
+	Name  string
+	Value string
+}
+
+type TokenValuePolicy int
+
+const (
+	NoArgument TokenValuePolicy = iota
+	TokenOnly
+	QuotedStringOnly
+	AnyTokenValue
+)
+
+type directiveValidator interface {
+	Validate(string) TokenValuePolicy
+}
+type directiveValidatorFn func(string) TokenValuePolicy
+
+func (fn directiveValidatorFn) Validate(ccd string) TokenValuePolicy {
+	return fn(ccd)
+}
+
+func responseDirectiveValidator(s string) TokenValuePolicy {
+	switch s {
+	case MustRevalidate, NoStore, NoTransform, Public, ProxyRevalidate:
+		return NoArgument
+	case NoCache, Private:
+		return QuotedStringOnly
+	case MaxAge, SMaxAge:
+		return TokenOnly
+	default:
+		return AnyTokenValue
+	}
+}
+
+func requestDirectiveValidator(s string) TokenValuePolicy {
+	switch s {
+	case MaxAge, MaxStale, MinFresh:
+		return TokenOnly
+	case NoCache, NoStore, NoTransform, OnlyIfCached:
+		return NoArgument
+	default:
+		return AnyTokenValue
+	}
+}
+
+// ParseRequestDirective parses a single token.
+func ParseRequestDirective(s string) (*TokenPair, error) {
+	return parseDirective(s, directiveValidatorFn(requestDirectiveValidator))
+}
+
+func ParseResponseDirective(s string) (*TokenPair, error) {
+	return parseDirective(s, directiveValidatorFn(responseDirectiveValidator))
+}
+
+func parseDirective(s string, ccd directiveValidator) (*TokenPair, error) {
+	s = strings.TrimSpace(s)
+
+	i := strings.IndexByte(s, '=')
+	if i == -1 {
+		return &TokenPair{Name: s}, nil
+	}
+
+	pair := &TokenPair{Name: strings.TrimSpace(s[:i])}
+
+	if len(s) <= i {
+		// `key=` feels like it's a parse error, but it's HTTP...
+		// for now, return as if nothing happened.
+		return pair, nil
+	}
+
+	v := strings.TrimSpace(s[i+1:])
+	switch ccd.Validate(pair.Name) {
+	case TokenOnly:
+		if v[0] == '"' {
+			return nil, fmt.Errorf(`invalid value for %s (quoted string not allowed)`, pair.Name)
+		}
+	case QuotedStringOnly: // quoted-string only
+		if v[0] != '"' {
+			return nil, fmt.Errorf(`invalid value for %s (bare token not allowed)`, pair.Name)
+		}
+		tmp, err := strconv.Unquote(v)
+		if err != nil {
+			return nil, fmt.Errorf(`malformed quoted string in token`)
+		}
+		v = tmp
+	case AnyTokenValue:
+		if v[0] == '"' {
+			tmp, err := strconv.Unquote(v)
+			if err != nil {
+				return nil, fmt.Errorf(`malformed quoted string in token`)
+			}
+			v = tmp
+		}
+	case NoArgument:
+		if len(v) > 0 {
+			return nil, fmt.Errorf(`received argument to directive %s`, pair.Name)
+		}
+	}
+
+	pair.Value = v
+	return pair, nil
+}
+
+func ParseResponseDirectives(s string) ([]*TokenPair, error) {
+	return parseDirectives(s, ParseResponseDirective)
+}
+
+func ParseRequestDirectives(s string) ([]*TokenPair, error) {
+	return parseDirectives(s, ParseRequestDirective)
+}
+
+func parseDirectives(s string, p func(string) (*TokenPair, error)) ([]*TokenPair, error) {
+	scanner := bufio.NewScanner(strings.NewReader(s))
+	scanner.Split(scanCommaSeparatedWords)
+
+	var tokens []*TokenPair
+	for scanner.Scan() {
+		tok, err := p(scanner.Text())
+		if err != nil {
+			return nil, fmt.Errorf(`failed to parse token #%d: %w`, len(tokens)+1, err)
+		}
+		tokens = append(tokens, tok)
+	}
+	return tokens, nil
+}
+
+// isSpace reports whether the character is a Unicode white space character.
+// We avoid dependency on the unicode package, but check validity of the implementation
+// in the tests.
+func isSpace(r rune) bool {
+	if r <= '\u00FF' {
+		// Obvious ASCII ones: \t through \r plus space. Plus two Latin-1 oddballs.
+		switch r {
+		case ' ', '\t', '\n', '\v', '\f', '\r':
+			return true
+		case '\u0085', '\u00A0':
+			return true
+		}
+		return false
+	}
+	// High-valued ones.
+	if '\u2000' <= r && r <= '\u200a' {
+		return true
+	}
+	switch r {
+	case '\u1680', '\u2028', '\u2029', '\u202f', '\u205f', '\u3000':
+		return true
+	}
+	return false
+}
+
+func scanCommaSeparatedWords(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	// Skip leading spaces.
+	start := 0
+	for width := 0; start < len(data); start += width {
+		var r rune
+		r, width = utf8.DecodeRune(data[start:])
+		if !isSpace(r) {
+			break
+		}
+	}
+	// Scan until we find a comma. Keep track of consecutive whitespaces
+	// so we remove them from the end result
+	var ws int
+	for width, i := 0, start; i < len(data); i += width {
+		var r rune
+		r, width = utf8.DecodeRune(data[i:])
+		switch {
+		case isSpace(r):
+			ws++
+		case r == ',':
+			return i + width, data[start : i-ws], nil
+		default:
+			ws = 0
+		}
+	}
+
+	// If we're at EOF, we have a final, non-empty, non-terminated word. Return it.
+	if atEOF && len(data) > start {
+		return len(data), data[start : len(data)-ws], nil
+	}
+
+	// Request more data.
+	return start, nil, nil
+}
+
+// ParseRequest parses the content of `Cache-Control` header of an HTTP Request.
+func ParseRequest(v string) (*RequestDirective, error) {
+	var dir RequestDirective
+	tokens, err := ParseRequestDirectives(v)
+	if err != nil {
+		return nil, fmt.Errorf(`failed to parse tokens: %w`, err)
+	}
+
+	for _, token := range tokens {
+		name := strings.ToLower(token.Name)
+		switch name {
+		case MaxAge:
+			iv, err := strconv.ParseUint(token.Value, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf(`failed to parse max-age: %w`, err)
+			}
+			dir.maxAge = &iv
+		case MaxStale:
+			iv, err := strconv.ParseUint(token.Value, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf(`failed to parse max-stale: %w`, err)
+			}
+			dir.maxStale = &iv
+		case MinFresh:
+			iv, err := strconv.ParseUint(token.Value, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf(`failed to parse min-fresh: %w`, err)
+			}
+			dir.minFresh = &iv
+		case NoCache:
+			dir.noCache = true
+		case NoStore:
+			dir.noStore = true
+		case NoTransform:
+			dir.noTransform = true
+		case OnlyIfCached:
+			dir.onlyIfCached = true
+		default:
+			dir.extensions[token.Name] = token.Value
+		}
+	}
+	return &dir, nil
+}
+
+// ParseResponse parses the content of `Cache-Control` header of an HTTP Response.
+func ParseResponse(v string) (*ResponseDirective, error) {
+	tokens, err := ParseResponseDirectives(v)
+	if err != nil {
+		return nil, fmt.Errorf(`failed to parse tokens: %w`, err)
+	}
+
+	var dir ResponseDirective
+	dir.extensions = make(map[string]string)
+	for _, token := range tokens {
+		name := strings.ToLower(token.Name)
+		switch name {
+		case MaxAge:
+			iv, err := strconv.ParseUint(token.Value, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf(`failed to parse max-age: %w`, err)
+			}
+			dir.maxAge = &iv
+		case NoCache:
+			scanner := bufio.NewScanner(strings.NewReader(token.Value))
+			scanner.Split(scanCommaSeparatedWords)
+			for scanner.Scan() {
+				dir.noCache = append(dir.noCache, scanner.Text())
+			}
+		case NoStore:
+			dir.noStore = true
+		case NoTransform:
+			dir.noTransform = true
+		case Public:
+			dir.public = true
+		case Private:
+			scanner := bufio.NewScanner(strings.NewReader(token.Value))
+			scanner.Split(scanCommaSeparatedWords)
+			for scanner.Scan() {
+				dir.private = append(dir.private, scanner.Text())
+			}
+		case ProxyRevalidate:
+			dir.proxyRevalidate = true
+		case SMaxAge:
+			iv, err := strconv.ParseUint(token.Value, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf(`failed to parse s-maxage: %w`, err)
+			}
+			dir.sMaxAge = &iv
+		default:
+			dir.extensions[token.Name] = token.Value
+		}
+	}
+	return &dir, nil
+}