src

headerlist.go (4045B)

---

 package http
 
 import (
 	"fmt"
 	"strconv"
 	"strings"
 	"unicode"
 )
 
 func splitHeaderListValues(vs []string, splitFn func(string) ([]string, error)) ([]string, error) {
 	values := make([]string, 0, len(vs))
 
 	for i := 0; i < len(vs); i++ {
 		parts, err := splitFn(vs[i])
 		if err != nil {
 			return nil, err
 		}
 		values = append(values, parts...)
 	}
 
 	return values, nil
 }
 
 // SplitHeaderListValues attempts to split the elements of the slice by commas,
 // and return a list of all values separated. Returns error if unable to
 // separate the values.
 func SplitHeaderListValues(vs []string) ([]string, error) {
 	return splitHeaderListValues(vs, quotedCommaSplit)
 }
 
 func quotedCommaSplit(v string) (parts []string, err error) {
 	v = strings.TrimSpace(v)
 
 	expectMore := true
 	for i := 0; i < len(v); i++ {
 		if unicode.IsSpace(rune(v[i])) {
 			continue
 		}
 		expectMore = false
 
 		// leading  space in part is ignored.
 		// Start of value must be non-space, or quote.
 		//
 		// - If quote, enter quoted mode, find next non-escaped quote to
 		//   terminate the value.
 		// - Otherwise, find next comma to terminate value.
 
 		remaining := v[i:]
 
 		var value string
 		var valueLen int
 		if remaining[0] == '"' {
 			//------------------------------
 			// Quoted value
 			//------------------------------
 			var j int
 			var skipQuote bool
 			for j += 1; j < len(remaining); j++ {
 				if remaining[j] == '\\' || (remaining[j] != '\\' && skipQuote) {
 					skipQuote = !skipQuote
 					continue
 				}
 				if remaining[j] == '"' {
 					break
 				}
 			}
 			if j == len(remaining) || j == 1 {
 				return nil, fmt.Errorf("value %v missing closing double quote",
 					remaining)
 			}
 			valueLen = j + 1
 
 			tail := remaining[valueLen:]
 			var k int
 			for ; k < len(tail); k++ {
 				if !unicode.IsSpace(rune(tail[k])) && tail[k] != ',' {
 					return nil, fmt.Errorf("value %v has non-space trailing characters",
 						remaining)
 				}
 				if tail[k] == ',' {
 					expectMore = true
 					break
 				}
 			}
 			value = remaining[:valueLen]
 			value, err = strconv.Unquote(value)
 			if err != nil {
 				return nil, fmt.Errorf("failed to unquote value %v, %w", value, err)
 			}
 
 			// Pad valueLen to include trailing space(s) so `i` is updated correctly.
 			valueLen += k
 
 		} else {
 			//------------------------------
 			// Unquoted value
 			//------------------------------
 
 			// Index of the next comma is the length of the value, or end of string.
 			valueLen = strings.Index(remaining, ",")
 			if valueLen != -1 {
 				expectMore = true
 			} else {
 				valueLen = len(remaining)
 			}
 			value = strings.TrimSpace(remaining[:valueLen])
 		}
 
 		i += valueLen
 		parts = append(parts, value)
 
 	}
 
 	if expectMore {
 		parts = append(parts, "")
 	}
 
 	return parts, nil
 }
 
 // SplitHTTPDateTimestampHeaderListValues attempts to split the HTTP-Date
 // timestamp values in the slice by commas, and return a list of all values
 // separated. The split is aware of the HTTP-Date timestamp format, and will skip
 // comma within the timestamp value. Returns an error if unable to split the
 // timestamp values.
 func SplitHTTPDateTimestampHeaderListValues(vs []string) ([]string, error) {
 	return splitHeaderListValues(vs, splitHTTPDateHeaderValue)
 }
 
 func splitHTTPDateHeaderValue(v string) ([]string, error) {
 	if n := strings.Count(v, ","); n <= 1 {
 		// Nothing to do if only contains a no, or single HTTPDate value
 		return []string{v}, nil
 	} else if n%2 == 0 {
 		return nil, fmt.Errorf("invalid timestamp HTTPDate header comma separations, %q", v)
 	}
 
 	var parts []string
 	var i, j int
 
 	var doSplit bool
 	for ; i < len(v); i++ {
 		if v[i] == ',' {
 			if doSplit {
 				doSplit = false
 				parts = append(parts, strings.TrimSpace(v[j:i]))
 				j = i + 1
 			} else {
 				// Skip the first comma in the timestamp value since that
 				// separates the day from the rest of the timestamp.
 				//
 				// Tue, 17 Dec 2019 23:48:18 GMT
 				doSplit = true
 			}
 		}
 	}
 	// Add final part
 	if j < len(v) {
 		parts = append(parts, strings.TrimSpace(v[j:]))
 	}
 
 	return parts, nil
 }