Upgrade to caddy v2.10.0

1 files changed, 25 insertions, 64 deletions

diff --git a/vendor/github.com/fxamacker/cbor/v2/cache.go b/vendor/github.com/fxamacker/cbor/v2/cache.go
index ea0f39e..8a4a5c8 100644
--- a/vendor/github.com/fxamacker/cbor/v2/cache.go
+++ b/vendor/github.com/fxamacker/cbor/v2/cache.go
@@ -6,7 +6,6 @@ package cbor
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"reflect"
 	"sort"
 	"strconv"
@@ -85,25 +84,9 @@ func newTypeInfo(t reflect.Type) *typeInfo {
 }
 
 type decodingStructType struct {
-	fields             fields
-	fieldIndicesByName map[string]int
-	err                error
-	toArray            bool
-}
-
-// The stdlib errors.Join was introduced in Go 1.20, and we still support Go 1.17, so instead,
-// here's a very basic implementation of an aggregated error.
-type multierror []error
-
-func (m multierror) Error() string {
-	var sb strings.Builder
-	for i, err := range m {
-		sb.WriteString(err.Error())
-		if i < len(m)-1 {
-			sb.WriteString(", ")
-		}
-	}
-	return sb.String()
+	fields  fields
+	err     error
+	toArray bool
 }
 
 func getDecodingStructType(t reflect.Type) *decodingStructType {
@@ -115,12 +98,12 @@ func getDecodingStructType(t reflect.Type) *decodingStructType {
 
 	toArray := hasToArrayOption(structOptions)
 
-	var errs []error
+	var err error
 	for i := 0; i < len(flds); i++ {
 		if flds[i].keyAsInt {
 			nameAsInt, numErr := strconv.Atoi(flds[i].name)
 			if numErr != nil {
-				errs = append(errs, errors.New("cbor: failed to parse field name \""+flds[i].name+"\" to int ("+numErr.Error()+")"))
+				err = errors.New("cbor: failed to parse field name \"" + flds[i].name + "\" to int (" + numErr.Error() + ")")
 				break
 			}
 			flds[i].nameAsInt = int64(nameAsInt)
@@ -129,36 +112,7 @@ func getDecodingStructType(t reflect.Type) *decodingStructType {
 		flds[i].typInfo = getTypeInfo(flds[i].typ)
 	}
 
-	fieldIndicesByName := make(map[string]int, len(flds))
-	for i, fld := range flds {
-		if _, ok := fieldIndicesByName[fld.name]; ok {
-			errs = append(errs, fmt.Errorf("cbor: two or more fields of %v have the same name %q", t, fld.name))
-			continue
-		}
-		fieldIndicesByName[fld.name] = i
-	}
-
-	var err error
-	{
-		var multi multierror
-		for _, each := range errs {
-			if each != nil {
-				multi = append(multi, each)
-			}
-		}
-		if len(multi) == 1 {
-			err = multi[0]
-		} else if len(multi) > 1 {
-			err = multi
-		}
-	}
-
-	structType := &decodingStructType{
-		fields:             flds,
-		fieldIndicesByName: fieldIndicesByName,
-		err:                err,
-		toArray:            toArray,
-	}
+	structType := &decodingStructType{fields: flds, err: err, toArray: toArray}
 	decodingStructTypeCache.Store(t, structType)
 	return structType
 }
@@ -170,17 +124,17 @@ type encodingStructType struct {
 	omitEmptyFieldsIdx []int
 	err                error
 	toArray            bool
+	fixedLength        bool // Struct type doesn't have any omitempty or anonymous fields.
 }
 
 func (st *encodingStructType) getFields(em *encMode) fields {
-	switch em.sort {
-	case SortNone, SortFastShuffle:
+	if em.sort == SortNone {
 		return st.fields
-	case SortLengthFirst:
+	}
+	if em.sort == SortLengthFirst {
 		return st.lengthFirstFields
-	default:
-		return st.bytewiseFields
 	}
+	return st.bytewiseFields
 }
 
 type bytewiseFieldSorter struct {
@@ -234,7 +188,8 @@ func getEncodingStructType(t reflect.Type) (*encodingStructType, error) {
 	var hasKeyAsInt bool
 	var hasKeyAsStr bool
 	var omitEmptyIdx []int
-	e := getEncodeBuffer()
+	fixedLength := true
+	e := getEncoderBuffer()
 	for i := 0; i < len(flds); i++ {
 		// Get field's encodeFunc
 		flds[i].ef, flds[i].ief = getEncodeFunc(flds[i].typ)
@@ -276,18 +231,23 @@ func getEncodingStructType(t reflect.Type) (*encodingStructType, error) {
 			copy(flds[i].cborNameByteString, flds[i].cborName)
 			// Reset encoded CBOR type to byte string, preserving the "additional
 			// information" bits:
-			flds[i].cborNameByteString[0] = byte(cborTypeByteString) |
-				getAdditionalInformation(flds[i].cborNameByteString[0])
+			flds[i].cborNameByteString[0] = byte(cborTypeByteString) | (flds[i].cborNameByteString[0] & 0x1f)
 
 			hasKeyAsStr = true
 		}
 
+		// Check if field is from embedded struct
+		if len(flds[i].idx) > 1 {
+			fixedLength = false
+		}
+
 		// Check if field can be omitted when empty
 		if flds[i].omitEmpty {
+			fixedLength = false
 			omitEmptyIdx = append(omitEmptyIdx, i)
 		}
 	}
-	putEncodeBuffer(e)
+	putEncoderBuffer(e)
 
 	if err != nil {
 		structType := &encodingStructType{err: err}
@@ -312,8 +272,8 @@ func getEncodingStructType(t reflect.Type) (*encodingStructType, error) {
 		bytewiseFields:     bytewiseFields,
 		lengthFirstFields:  lengthFirstFields,
 		omitEmptyFieldsIdx: omitEmptyIdx,
+		fixedLength:        fixedLength,
 	}
-
 	encodingStructTypeCache.Store(t, structType)
 	return structType, structType.err
 }
@@ -330,8 +290,9 @@ func getEncodingStructToArrayType(t reflect.Type, flds fields) (*encodingStructT
 	}
 
 	structType := &encodingStructType{
-		fields:  flds,
-		toArray: true,
+		fields:      flds,
+		toArray:     true,
+		fixedLength: true,
 	}
 	encodingStructTypeCache.Store(t, structType)
 	return structType, structType.err