diff --git a/middleware/cache/manager.go b/middleware/cache/manager.go index ad7a8fb5369..0dd92c8ffaf 100644 --- a/middleware/cache/manager.go +++ b/middleware/cache/manager.go @@ -12,16 +12,18 @@ import ( ) // msgp -file="manager.go" -o="manager_msgp.go" -tests=true -unexported +// Default slice limits are sized for cache payloads, with tighter field caps below. // //go:generate msgp -o=manager_msgp.go -tests=true -unexported +//nolint:revive // msgp requires tags on unexported fields for limit enforcement. type item struct { - headers []cachedHeader - body []byte - ctype []byte - cencoding []byte - cacheControl []byte - expires []byte - etag []byte + headers []cachedHeader `msg:",limit=1024"` // Typical HTTP header count stays well below this. + body []byte // Cache bodies are bounded by storage policy, not msgp limits. + ctype []byte `msg:",limit=256"` // Content-Type values are short per RFCs. + cencoding []byte `msg:",limit=128"` // Content-Encoding is typically a short token. + cacheControl []byte `msg:",limit=2048"` // Cache-Control directives are bounded. + expires []byte `msg:",limit=128"` // Expires is a short HTTP-date string. + etag []byte `msg:",limit=256"` // ETags are small tokens/quoted strings. date uint64 status int age uint64 @@ -35,9 +37,10 @@ type item struct { heapidx int } +//nolint:revive // msgp requires tags on unexported fields for limit enforcement. type cachedHeader struct { - key []byte - value []byte + key []byte `msg:",limit=512"` // Header names are small. + value []byte `msg:",limit=16384"` // Header values are bounded to reasonable sizes. } //msgp:ignore manager diff --git a/middleware/cache/manager_msgp.go b/middleware/cache/manager_msgp.go index 6022bd8832c..e5bd1393c9c 100644 --- a/middleware/cache/manager_msgp.go +++ b/middleware/cache/manager_msgp.go @@ -25,13 +25,19 @@ func (z *cachedHeader) DecodeMsg(dc *msgp.Reader) (err error) { } switch msgp.UnsafeString(field) { case "key": - z.key, err = dc.ReadBytes(z.key) + z.key, err = dc.ReadBytesLimit(z.key, 512) + if err == nil && z.key == nil { + z.key = []byte{} + } if err != nil { err = msgp.WrapError(err, "key") return } case "value": - z.value, err = dc.ReadBytes(z.value) + z.value, err = dc.ReadBytesLimit(z.value, 16384) + if err == nil && z.value == nil { + z.value = []byte{} + } if err != nil { err = msgp.WrapError(err, "value") return @@ -105,17 +111,49 @@ func (z *cachedHeader) UnmarshalMsg(bts []byte) (o []byte, err error) { } switch msgp.UnsafeString(field) { case "key": - z.key, bts, err = msgp.ReadBytesBytes(bts, z.key) + var zb0002 uint32 + zb0002, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "key") return } + if zb0002 > 512 { + err = msgp.ErrLimitExceeded + return + } + if z.key == nil || uint32(cap(z.key)) < zb0002 { + z.key = make([]byte, zb0002) + } else { + z.key = z.key[:zb0002] + } + if uint32(len(bts)) < zb0002 { + err = msgp.ErrShortBytes + return + } + copy(z.key, bts[:zb0002]) + bts = bts[zb0002:] case "value": - z.value, bts, err = msgp.ReadBytesBytes(bts, z.value) + var zb0003 uint32 + zb0003, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "value") return } + if zb0003 > 16384 { + err = msgp.ErrLimitExceeded + return + } + if z.value == nil || uint32(cap(z.value)) < zb0003 { + z.value = make([]byte, zb0003) + } else { + z.value = z.value[:zb0003] + } + if uint32(len(bts)) < zb0003 { + err = msgp.ErrShortBytes + return + } + copy(z.value, bts[:zb0003]) + bts = bts[zb0003:] default: bts, err = msgp.Skip(bts) if err != nil { @@ -159,6 +197,10 @@ func (z *item) DecodeMsg(dc *msgp.Reader) (err error) { err = msgp.WrapError(err, "headers") return } + if zb0002 > 1024 { + err = msgp.ErrLimitExceeded + return + } if cap(z.headers) >= int(zb0002) { z.headers = (z.headers)[:zb0002] } else { @@ -171,6 +213,10 @@ func (z *item) DecodeMsg(dc *msgp.Reader) (err error) { err = msgp.WrapError(err, "headers", za0001) return } + if zb0003 > 1024 { + err = msgp.ErrLimitExceeded + return + } for zb0003 > 0 { zb0003-- field, err = dc.ReadMapKeyPtr() @@ -180,13 +226,19 @@ func (z *item) DecodeMsg(dc *msgp.Reader) (err error) { } switch msgp.UnsafeString(field) { case "key": - z.headers[za0001].key, err = dc.ReadBytes(z.headers[za0001].key) + z.headers[za0001].key, err = dc.ReadBytesLimit(z.headers[za0001].key, 512) + if err == nil && z.headers[za0001].key == nil { + z.headers[za0001].key = []byte{} + } if err != nil { err = msgp.WrapError(err, "headers", za0001, "key") return } case "value": - z.headers[za0001].value, err = dc.ReadBytes(z.headers[za0001].value) + z.headers[za0001].value, err = dc.ReadBytesLimit(z.headers[za0001].value, 16384) + if err == nil && z.headers[za0001].value == nil { + z.headers[za0001].value = []byte{} + } if err != nil { err = msgp.WrapError(err, "headers", za0001, "value") return @@ -207,31 +259,46 @@ func (z *item) DecodeMsg(dc *msgp.Reader) (err error) { return } case "ctype": - z.ctype, err = dc.ReadBytes(z.ctype) + z.ctype, err = dc.ReadBytesLimit(z.ctype, 256) + if err == nil && z.ctype == nil { + z.ctype = []byte{} + } if err != nil { err = msgp.WrapError(err, "ctype") return } case "cencoding": - z.cencoding, err = dc.ReadBytes(z.cencoding) + z.cencoding, err = dc.ReadBytesLimit(z.cencoding, 128) + if err == nil && z.cencoding == nil { + z.cencoding = []byte{} + } if err != nil { err = msgp.WrapError(err, "cencoding") return } case "cacheControl": - z.cacheControl, err = dc.ReadBytes(z.cacheControl) + z.cacheControl, err = dc.ReadBytesLimit(z.cacheControl, 2048) + if err == nil && z.cacheControl == nil { + z.cacheControl = []byte{} + } if err != nil { err = msgp.WrapError(err, "cacheControl") return } case "expires": - z.expires, err = dc.ReadBytes(z.expires) + z.expires, err = dc.ReadBytesLimit(z.expires, 128) + if err == nil && z.expires == nil { + z.expires = []byte{} + } if err != nil { err = msgp.WrapError(err, "expires") return } case "etag": - z.etag, err = dc.ReadBytes(z.etag) + z.etag, err = dc.ReadBytesLimit(z.etag, 256) + if err == nil && z.etag == nil { + z.etag = []byte{} + } if err != nil { err = msgp.WrapError(err, "etag") return @@ -598,6 +665,10 @@ func (z *item) UnmarshalMsg(bts []byte) (o []byte, err error) { err = msgp.WrapError(err, "headers") return } + if zb0002 > 1024 { + err = msgp.ErrLimitExceeded + return + } if cap(z.headers) >= int(zb0002) { z.headers = (z.headers)[:zb0002] } else { @@ -610,6 +681,10 @@ func (z *item) UnmarshalMsg(bts []byte) (o []byte, err error) { err = msgp.WrapError(err, "headers", za0001) return } + if zb0003 > 1024 { + err = msgp.ErrLimitExceeded + return + } for zb0003 > 0 { zb0003-- field, bts, err = msgp.ReadMapKeyZC(bts) @@ -619,17 +694,49 @@ func (z *item) UnmarshalMsg(bts []byte) (o []byte, err error) { } switch msgp.UnsafeString(field) { case "key": - z.headers[za0001].key, bts, err = msgp.ReadBytesBytes(bts, z.headers[za0001].key) + var zb0004 uint32 + zb0004, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "headers", za0001, "key") return } + if zb0004 > 512 { + err = msgp.ErrLimitExceeded + return + } + if z.headers[za0001].key == nil || uint32(cap(z.headers[za0001].key)) < zb0004 { + z.headers[za0001].key = make([]byte, zb0004) + } else { + z.headers[za0001].key = z.headers[za0001].key[:zb0004] + } + if uint32(len(bts)) < zb0004 { + err = msgp.ErrShortBytes + return + } + copy(z.headers[za0001].key, bts[:zb0004]) + bts = bts[zb0004:] case "value": - z.headers[za0001].value, bts, err = msgp.ReadBytesBytes(bts, z.headers[za0001].value) + var zb0005 uint32 + zb0005, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "headers", za0001, "value") return } + if zb0005 > 16384 { + err = msgp.ErrLimitExceeded + return + } + if z.headers[za0001].value == nil || uint32(cap(z.headers[za0001].value)) < zb0005 { + z.headers[za0001].value = make([]byte, zb0005) + } else { + z.headers[za0001].value = z.headers[za0001].value[:zb0005] + } + if uint32(len(bts)) < zb0005 { + err = msgp.ErrShortBytes + return + } + copy(z.headers[za0001].value, bts[:zb0005]) + bts = bts[zb0005:] default: bts, err = msgp.Skip(bts) if err != nil { @@ -646,35 +753,115 @@ func (z *item) UnmarshalMsg(bts []byte) (o []byte, err error) { return } case "ctype": - z.ctype, bts, err = msgp.ReadBytesBytes(bts, z.ctype) + var zb0006 uint32 + zb0006, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "ctype") return } + if zb0006 > 256 { + err = msgp.ErrLimitExceeded + return + } + if z.ctype == nil || uint32(cap(z.ctype)) < zb0006 { + z.ctype = make([]byte, zb0006) + } else { + z.ctype = z.ctype[:zb0006] + } + if uint32(len(bts)) < zb0006 { + err = msgp.ErrShortBytes + return + } + copy(z.ctype, bts[:zb0006]) + bts = bts[zb0006:] case "cencoding": - z.cencoding, bts, err = msgp.ReadBytesBytes(bts, z.cencoding) + var zb0007 uint32 + zb0007, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "cencoding") return } + if zb0007 > 128 { + err = msgp.ErrLimitExceeded + return + } + if z.cencoding == nil || uint32(cap(z.cencoding)) < zb0007 { + z.cencoding = make([]byte, zb0007) + } else { + z.cencoding = z.cencoding[:zb0007] + } + if uint32(len(bts)) < zb0007 { + err = msgp.ErrShortBytes + return + } + copy(z.cencoding, bts[:zb0007]) + bts = bts[zb0007:] case "cacheControl": - z.cacheControl, bts, err = msgp.ReadBytesBytes(bts, z.cacheControl) + var zb0008 uint32 + zb0008, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "cacheControl") return } + if zb0008 > 2048 { + err = msgp.ErrLimitExceeded + return + } + if z.cacheControl == nil || uint32(cap(z.cacheControl)) < zb0008 { + z.cacheControl = make([]byte, zb0008) + } else { + z.cacheControl = z.cacheControl[:zb0008] + } + if uint32(len(bts)) < zb0008 { + err = msgp.ErrShortBytes + return + } + copy(z.cacheControl, bts[:zb0008]) + bts = bts[zb0008:] case "expires": - z.expires, bts, err = msgp.ReadBytesBytes(bts, z.expires) + var zb0009 uint32 + zb0009, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "expires") return } + if zb0009 > 128 { + err = msgp.ErrLimitExceeded + return + } + if z.expires == nil || uint32(cap(z.expires)) < zb0009 { + z.expires = make([]byte, zb0009) + } else { + z.expires = z.expires[:zb0009] + } + if uint32(len(bts)) < zb0009 { + err = msgp.ErrShortBytes + return + } + copy(z.expires, bts[:zb0009]) + bts = bts[zb0009:] case "etag": - z.etag, bts, err = msgp.ReadBytesBytes(bts, z.etag) + var zb0010 uint32 + zb0010, bts, err = msgp.ReadBytesHeader(bts) if err != nil { err = msgp.WrapError(err, "etag") return } + if zb0010 > 256 { + err = msgp.ErrLimitExceeded + return + } + if z.etag == nil || uint32(cap(z.etag)) < zb0010 { + z.etag = make([]byte, zb0010) + } else { + z.etag = z.etag[:zb0010] + } + if uint32(len(bts)) < zb0010 { + err = msgp.ErrShortBytes + return + } + copy(z.etag, bts[:zb0010]) + bts = bts[zb0010:] case "date": z.date, bts, err = msgp.ReadUint64Bytes(bts) if err != nil { diff --git a/middleware/idempotency/response.go b/middleware/idempotency/response.go index aafbca60468..e9f9074dcf1 100644 --- a/middleware/idempotency/response.go +++ b/middleware/idempotency/response.go @@ -3,10 +3,12 @@ package idempotency // response is a struct that represents the response of a request. // generation tool `go install github.com/tinylib/msgp@latest` // +// Idempotency payloads are stored in backing storage, so keep headers/bodies bounded. +// //go:generate msgp -o=response_msgp.go -tests=true -unexported type response struct { - Headers map[string][]string `msg:"hs"` + Headers map[string][]string `msg:"hs,limit=1024"` // HTTP header count norms are well below this. - Body []byte `msg:"b"` + Body []byte `msg:"b"` // Idempotency bodies are bounded by storage policy, not msgp limits. StatusCode int `msg:"sc"` } diff --git a/middleware/idempotency/response_msgp.go b/middleware/idempotency/response_msgp.go index 45febba3a44..0b0454aaa02 100644 --- a/middleware/idempotency/response_msgp.go +++ b/middleware/idempotency/response_msgp.go @@ -31,6 +31,10 @@ func (z *response) DecodeMsg(dc *msgp.Reader) (err error) { err = msgp.WrapError(err, "Headers") return } + if zb0002 > 1024 { + err = msgp.ErrLimitExceeded + return + } if z.Headers == nil { z.Headers = make(map[string][]string, zb0002) } else if len(z.Headers) > 0 { @@ -51,6 +55,10 @@ func (z *response) DecodeMsg(dc *msgp.Reader) (err error) { err = msgp.WrapError(err, "Headers", za0001) return } + if zb0003 > 1024 { + err = msgp.ErrLimitExceeded + return + } if cap(za0002) >= int(zb0003) { za0002 = (za0002)[:zb0003] } else { @@ -191,6 +199,10 @@ func (z *response) UnmarshalMsg(bts []byte) (o []byte, err error) { err = msgp.WrapError(err, "Headers") return } + if zb0002 > 1024 { + err = msgp.ErrLimitExceeded + return + } if z.Headers == nil { z.Headers = make(map[string][]string, zb0002) } else if len(z.Headers) > 0 { @@ -211,6 +223,10 @@ func (z *response) UnmarshalMsg(bts []byte) (o []byte, err error) { err = msgp.WrapError(err, "Headers", za0001) return } + if zb0003 > 1024 { + err = msgp.ErrLimitExceeded + return + } if cap(za0002) >= int(zb0003) { za0002 = (za0002)[:zb0003] } else { diff --git a/middleware/session/data.go b/middleware/session/data.go index fabe7cd46cb..2a26b785bbc 100644 --- a/middleware/session/data.go +++ b/middleware/session/data.go @@ -5,11 +5,12 @@ import ( ) // msgp -file="data.go" -o="data_msgp.go" -tests=true -unexported +// Session state should remain small to fit common storage payload limits. // //go:generate msgp -o=data_msgp.go -tests=true -unexported //msgp:ignore data type data struct { - Data map[any]any + Data map[any]any // Session key counts are expected to be bounded. sync.RWMutex `msg:"-"` } diff --git a/redirect.go b/redirect.go index f0cbd8520de..aeb7a377266 100644 --- a/redirect.go +++ b/redirect.go @@ -42,7 +42,9 @@ const ( // redirectionMsgs is a struct that used to store flash messages and old input data in cookie using MSGP. // msgp -file="redirect.go" -o="redirect_msgp.go" -unexported +// Cookie payloads are limited to ~4KB, so keep flash message counts bounded but usable. // +//msgp:limit arrays:256 maps:32 marshal:true //msgp:ignore Redirect RedirectConfig OldInputData FlashMessage type redirectionMsg struct { key string diff --git a/redirect_msgp.go b/redirect_msgp.go index 202f550d178..744543112d0 100644 --- a/redirect_msgp.go +++ b/redirect_msgp.go @@ -1,11 +1,17 @@ -package fiber - // Code generated by github.com/tinylib/msgp DO NOT EDIT. +package fiber + import ( "github.com/tinylib/msgp/msgp" ) +// Size limits for msgp deserialization +const ( + zc920acdalimitArrays = 256 + zc920acdalimitMaps = 32 +) + // DecodeMsg implements msgp.Decodable func (z *redirectionMsg) DecodeMsg(dc *msgp.Reader) (err error) { var field []byte @@ -14,49 +20,53 @@ func (z *redirectionMsg) DecodeMsg(dc *msgp.Reader) (err error) { zb0001, err = dc.ReadMapHeader() if err != nil { err = msgp.WrapError(err) - return err + return + } + if zb0001 > zc920acdalimitMaps { + err = msgp.ErrLimitExceeded + return } for zb0001 > 0 { zb0001-- field, err = dc.ReadMapKeyPtr() if err != nil { err = msgp.WrapError(err) - return err + return } switch msgp.UnsafeString(field) { case "key": z.key, err = dc.ReadString() if err != nil { err = msgp.WrapError(err, "key") - return err + return } case "value": z.value, err = dc.ReadString() if err != nil { err = msgp.WrapError(err, "value") - return err + return } case "level": z.level, err = dc.ReadUint8() if err != nil { err = msgp.WrapError(err, "level") - return err + return } case "isOldInput": z.isOldInput, err = dc.ReadBool() if err != nil { err = msgp.WrapError(err, "isOldInput") - return err + return } default: err = dc.Skip() if err != nil { err = msgp.WrapError(err) - return err + return } } } - return err + return } // EncodeMsg implements msgp.Encodable @@ -65,44 +75,44 @@ func (z *redirectionMsg) EncodeMsg(en *msgp.Writer) (err error) { // write "key" err = en.Append(0x84, 0xa3, 0x6b, 0x65, 0x79) if err != nil { - return err + return } err = en.WriteString(z.key) if err != nil { err = msgp.WrapError(err, "key") - return err + return } // write "value" err = en.Append(0xa5, 0x76, 0x61, 0x6c, 0x75, 0x65) if err != nil { - return err + return } err = en.WriteString(z.value) if err != nil { err = msgp.WrapError(err, "value") - return err + return } // write "level" err = en.Append(0xa5, 0x6c, 0x65, 0x76, 0x65, 0x6c) if err != nil { - return err + return } err = en.WriteUint8(z.level) if err != nil { err = msgp.WrapError(err, "level") - return err + return } // write "isOldInput" err = en.Append(0xaa, 0x69, 0x73, 0x4f, 0x6c, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74) if err != nil { - return err + return } err = en.WriteBool(z.isOldInput) if err != nil { err = msgp.WrapError(err, "isOldInput") - return err + return } - return err + return } // MarshalMsg implements msgp.Marshaler @@ -121,7 +131,7 @@ func (z *redirectionMsg) MarshalMsg(b []byte) (o []byte, err error) { // string "isOldInput" o = append(o, 0xaa, 0x69, 0x73, 0x4f, 0x6c, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74) o = msgp.AppendBool(o, z.isOldInput) - return o, err + return } // UnmarshalMsg implements msgp.Unmarshaler @@ -132,56 +142,60 @@ func (z *redirectionMsg) UnmarshalMsg(bts []byte) (o []byte, err error) { zb0001, bts, err = msgp.ReadMapHeaderBytes(bts) if err != nil { err = msgp.WrapError(err) - return o, err + return + } + if zb0001 > zc920acdalimitMaps { + err = msgp.ErrLimitExceeded + return } for zb0001 > 0 { zb0001-- field, bts, err = msgp.ReadMapKeyZC(bts) if err != nil { err = msgp.WrapError(err) - return o, err + return } switch msgp.UnsafeString(field) { case "key": z.key, bts, err = msgp.ReadStringBytes(bts) if err != nil { err = msgp.WrapError(err, "key") - return o, err + return } case "value": z.value, bts, err = msgp.ReadStringBytes(bts) if err != nil { err = msgp.WrapError(err, "value") - return o, err + return } case "level": z.level, bts, err = msgp.ReadUint8Bytes(bts) if err != nil { err = msgp.WrapError(err, "level") - return o, err + return } case "isOldInput": z.isOldInput, bts, err = msgp.ReadBoolBytes(bts) if err != nil { err = msgp.WrapError(err, "isOldInput") - return o, err + return } default: bts, err = msgp.Skip(bts) if err != nil { err = msgp.WrapError(err) - return o, err + return } } } o = bts - return o, err + return } // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message func (z *redirectionMsg) Msgsize() (s int) { s = 1 + 4 + msgp.StringPrefixSize + len(z.key) + 6 + msgp.StringPrefixSize + len(z.value) + 6 + msgp.Uint8Size + 11 + msgp.BoolSize - return s + return } // DecodeMsg implements msgp.Decodable @@ -190,7 +204,11 @@ func (z *redirectionMsgs) DecodeMsg(dc *msgp.Reader) (err error) { zb0002, err = dc.ReadArrayHeader() if err != nil { err = msgp.WrapError(err) - return err + return + } + if zb0002 > zc920acdalimitArrays { + err = msgp.ErrLimitExceeded + return } if cap((*z)) >= int(zb0002) { (*z) = (*z)[:zb0002] @@ -201,10 +219,10 @@ func (z *redirectionMsgs) DecodeMsg(dc *msgp.Reader) (err error) { err = (*z)[zb0001].DecodeMsg(dc) if err != nil { err = msgp.WrapError(err, zb0001) - return err + return } } - return err + return } // EncodeMsg implements msgp.Encodable @@ -212,30 +230,37 @@ func (z redirectionMsgs) EncodeMsg(en *msgp.Writer) (err error) { err = en.WriteArrayHeader(uint32(len(z))) if err != nil { err = msgp.WrapError(err) - return err + return + } + if uint32(len(z)) > zc920acdalimitArrays { + err = msgp.ErrLimitExceeded + return } for zb0003 := range z { err = z[zb0003].EncodeMsg(en) if err != nil { err = msgp.WrapError(err, zb0003) - return err + return } } - return err + return } // MarshalMsg implements msgp.Marshaler func (z redirectionMsgs) MarshalMsg(b []byte) (o []byte, err error) { o = msgp.Require(b, z.Msgsize()) o = msgp.AppendArrayHeader(o, uint32(len(z))) + if uint32(len(z)) > zc920acdalimitArrays { + return nil, msgp.ErrLimitExceeded + } for zb0003 := range z { o, err = z[zb0003].MarshalMsg(o) if err != nil { err = msgp.WrapError(err, zb0003) - return o, err + return } } - return o, err + return } // UnmarshalMsg implements msgp.Unmarshaler @@ -244,7 +269,11 @@ func (z *redirectionMsgs) UnmarshalMsg(bts []byte) (o []byte, err error) { zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts) if err != nil { err = msgp.WrapError(err) - return o, err + return + } + if zb0002 > zc920acdalimitArrays { + err = msgp.ErrLimitExceeded + return } if cap((*z)) >= int(zb0002) { (*z) = (*z)[:zb0002] @@ -255,11 +284,11 @@ func (z *redirectionMsgs) UnmarshalMsg(bts []byte) (o []byte, err error) { bts, err = (*z)[zb0001].UnmarshalMsg(bts) if err != nil { err = msgp.WrapError(err, zb0001) - return o, err + return } } o = bts - return o, err + return } // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message @@ -268,5 +297,5 @@ func (z redirectionMsgs) Msgsize() (s int) { for zb0003 := range z { s += z[zb0003].Msgsize() } - return s + return } diff --git a/redirect_msgp_test.go b/redirect_msgp_test.go index 8c3b8bb0781..c5f844ac3aa 100644 --- a/redirect_msgp_test.go +++ b/redirect_msgp_test.go @@ -1,7 +1,7 @@ -package fiber - // Code generated by github.com/tinylib/msgp DO NOT EDIT. +package fiber + import ( "bytes" "testing" @@ -35,7 +35,8 @@ func TestMarshalUnmarshalredirectionMsg(t *testing.T) { func BenchmarkMarshalMsgredirectionMsg(b *testing.B) { v := redirectionMsg{} b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { v.MarshalMsg(nil) } } @@ -46,7 +47,8 @@ func BenchmarkAppendMsgredirectionMsg(b *testing.B) { bts, _ = v.MarshalMsg(bts[0:0]) b.SetBytes(int64(len(bts))) b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { bts, _ = v.MarshalMsg(bts[0:0]) } } @@ -56,7 +58,8 @@ func BenchmarkUnmarshalredirectionMsg(b *testing.B) { bts, _ := v.MarshalMsg(nil) b.ReportAllocs() b.SetBytes(int64(len(bts))) - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { _, err := v.UnmarshalMsg(bts) if err != nil { b.Fatal(err) @@ -95,7 +98,8 @@ func BenchmarkEncoderedirectionMsg(b *testing.B) { b.SetBytes(int64(buf.Len())) en := msgp.NewWriter(msgp.Nowhere) b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { v.EncodeMsg(en) } en.Flush() @@ -109,7 +113,8 @@ func BenchmarkDecoderedirectionMsg(b *testing.B) { rd := msgp.NewEndlessReader(buf.Bytes(), b) dc := msgp.NewReader(rd) b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { err := v.DecodeMsg(dc) if err != nil { b.Fatal(err) @@ -143,7 +148,8 @@ func TestMarshalUnmarshalredirectionMsgs(t *testing.T) { func BenchmarkMarshalMsgredirectionMsgs(b *testing.B) { v := redirectionMsgs{} b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { v.MarshalMsg(nil) } } @@ -154,7 +160,8 @@ func BenchmarkAppendMsgredirectionMsgs(b *testing.B) { bts, _ = v.MarshalMsg(bts[0:0]) b.SetBytes(int64(len(bts))) b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { bts, _ = v.MarshalMsg(bts[0:0]) } } @@ -164,7 +171,8 @@ func BenchmarkUnmarshalredirectionMsgs(b *testing.B) { bts, _ := v.MarshalMsg(nil) b.ReportAllocs() b.SetBytes(int64(len(bts))) - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { _, err := v.UnmarshalMsg(bts) if err != nil { b.Fatal(err) @@ -203,7 +211,8 @@ func BenchmarkEncoderedirectionMsgs(b *testing.B) { b.SetBytes(int64(buf.Len())) en := msgp.NewWriter(msgp.Nowhere) b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { v.EncodeMsg(en) } en.Flush() @@ -217,7 +226,8 @@ func BenchmarkDecoderedirectionMsgs(b *testing.B) { rd := msgp.NewEndlessReader(buf.Bytes(), b) dc := msgp.NewReader(rd) b.ReportAllocs() - for b.Loop() { + b.ResetTimer() + for i := 0; i < b.N; i++ { err := v.DecodeMsg(dc) if err != nil { b.Fatal(err)