codekingpro/portable-devtools
114k
1// Copyright 2009 The Go Authors. All rights reserved.2// Use of this source code is governed by a BSD-style3// license that can be found in the LICENSE file.4 5//go:generate go run decgen.go -output dec_helpers.go6 7package gob8 9import (10 "encoding"11 "errors"12 "internal/saferio"13 "io"14 "math"15 "math/bits"16 "reflect"17)18 19var (20 errBadUint = errors.New("gob: encoded unsigned integer out of range")21 errBadType = errors.New("gob: unknown type id or corrupted data")22 errRange = errors.New("gob: bad data: field numbers out of bounds")23)24 25type decHelper func(state *decoderState, v reflect.Value, length int, ovfl error) bool26 27// decoderState is the execution state of an instance of the decoder. A new state28// is created for nested objects.29type decoderState struct {30 dec *Decoder31 // The buffer is stored with an extra indirection because it may be replaced32 // if we load a type during decode (when reading an interface value).33 b *decBuffer34 fieldnum int // the last field number read.35 next *decoderState // for free list36}37 38// decBuffer is an extremely simple, fast implementation of a read-only byte buffer.39// It is initialized by calling Size and then copying the data into the slice returned by Bytes().40type decBuffer struct {41 data []byte42 offset int // Read offset.43}44 45func (d *decBuffer) Read(p []byte) (int, error) {46 n := copy(p, d.data[d.offset:])47 if n == 0 && len(p) != 0 {48 return 0, io.EOF49 }50 d.offset += n51 return n, nil52}53 54func (d *decBuffer) Drop(n int) {55 if n > d.Len() {56 panic("drop")57 }58 d.offset += n59}60 61func (d *decBuffer) ReadByte() (byte, error) {62 if d.offset >= len(d.data) {63 return 0, io.EOF64 }65 c := d.data[d.offset]66 d.offset++67 return c, nil68}69 70func (d *decBuffer) Len() int {71 return len(d.data) - d.offset72}73 74func (d *decBuffer) Bytes() []byte {75 return d.data[d.offset:]76}77 78// SetBytes sets the buffer to the bytes, discarding any existing data.79func (d *decBuffer) SetBytes(data []byte) {80 d.data = data81 d.offset = 082}83 84func (d *decBuffer) Reset() {85 d.data = d.data[0:0]86 d.offset = 087}88 89// We pass the bytes.Buffer separately for easier testing of the infrastructure90// without requiring a full Decoder.91func (dec *Decoder) newDecoderState(buf *decBuffer) *decoderState {92 d := dec.freeList93 if d == nil {94 d = new(decoderState)95 d.dec = dec96 } else {97 dec.freeList = d.next98 }99 d.b = buf100 return d101}102 103func (dec *Decoder) freeDecoderState(d *decoderState) {104 d.next = dec.freeList105 dec.freeList = d106}107 108func overflow(name string) error {109 return errors.New(`value for "` + name + `" out of range`)110}111 112// decodeUintReader reads an encoded unsigned integer from an io.Reader.113// Used only by the Decoder to read the message length.114func decodeUintReader(r io.Reader, buf []byte) (x uint64, width int, err error) {115 width = 1116 n, err := io.ReadFull(r, buf[0:width])117 if n == 0 {118 return119 }120 b := buf[0]121 if b <= 0x7f {122 return uint64(b), width, nil123 }124 n = -int(int8(b))125 if n > uint64Size {126 err = errBadUint127 return128 }129 width, err = io.ReadFull(r, buf[0:n])130 if err != nil {131 if err == io.EOF {132 err = io.ErrUnexpectedEOF133 }134 return135 }136 // Could check that the high byte is zero but it's not worth it.137 for _, b := range buf[0:width] {138 x = x<<8 | uint64(b)139 }140 width++ // +1 for length byte141 return142}143 144// decodeUint reads an encoded unsigned integer from state.r.145// Does not check for overflow.146func (state *decoderState) decodeUint() (x uint64) {147 b, err := state.b.ReadByte()148 if err != nil {149 error_(err)150 }151 if b <= 0x7f {152 return uint64(b)153 }154 n := -int(int8(b))155 if n > uint64Size {156 error_(errBadUint)157 }158 buf := state.b.Bytes()159 if len(buf) < n {160 errorf("invalid uint data length %d: exceeds input size %d", n, len(buf))161 }162 // Don't need to check error; it's safe to loop regardless.163 // Could check that the high byte is zero but it's not worth it.164 for _, b := range buf[0:n] {165 x = x<<8 | uint64(b)166 }167 state.b.Drop(n)168 return x169}170 171// decodeInt reads an encoded signed integer from state.r.172// Does not check for overflow.173func (state *decoderState) decodeInt() int64 {174 x := state.decodeUint()175 if x&1 != 0 {176 return ^int64(x >> 1)177 }178 return int64(x >> 1)179}180 181// getLength decodes the next uint and makes sure it is a possible182// size for a data item that follows, which means it must fit in a183// non-negative int and fit in the buffer.184func (state *decoderState) getLength() (int, bool) {185 n := int(state.decodeUint())186 if n < 0 || state.b.Len() < n || tooBig <= n {187 return 0, false188 }189 return n, true190}191 192// decOp is the signature of a decoding operator for a given type.193type decOp func(i *decInstr, state *decoderState, v reflect.Value)194 195// The 'instructions' of the decoding machine196type decInstr struct {197 op decOp198 field int // field number of the wire type199 index []int // field access indices for destination type200 ovfl error // error message for overflow/underflow (for arrays, of the elements)201}202 203// ignoreUint discards a uint value with no destination.204func ignoreUint(i *decInstr, state *decoderState, v reflect.Value) {205 state.decodeUint()206}207 208// ignoreTwoUints discards a uint value with no destination. It's used to skip209// complex values.210func ignoreTwoUints(i *decInstr, state *decoderState, v reflect.Value) {211 state.decodeUint()212 state.decodeUint()213}214 215// Since the encoder writes no zeros, if we arrive at a decoder we have216// a value to extract and store. The field number has already been read217// (it's how we knew to call this decoder).218// Each decoder is responsible for handling any indirections associated219// with the data structure. If any pointer so reached is nil, allocation must220// be done.221 222// decAlloc takes a value and returns a settable value that can223// be assigned to. If the value is a pointer, decAlloc guarantees it points to storage.224// The callers to the individual decoders are expected to have used decAlloc.225// The individual decoders don't need it.226func decAlloc(v reflect.Value) reflect.Value {227 for v.Kind() == reflect.Pointer {228 if v.IsNil() {229 v.Set(reflect.New(v.Type().Elem()))230 }231 v = v.Elem()232 }233 return v234}235 236// decBool decodes a uint and stores it as a boolean in value.237func decBool(i *decInstr, state *decoderState, value reflect.Value) {238 value.SetBool(state.decodeUint() != 0)239}240 241// decInt8 decodes an integer and stores it as an int8 in value.242func decInt8(i *decInstr, state *decoderState, value reflect.Value) {243 v := state.decodeInt()244 if v < math.MinInt8 || math.MaxInt8 < v {245 error_(i.ovfl)246 }247 value.SetInt(v)248}249 250// decUint8 decodes an unsigned integer and stores it as a uint8 in value.251func decUint8(i *decInstr, state *decoderState, value reflect.Value) {252 v := state.decodeUint()253 if math.MaxUint8 < v {254 error_(i.ovfl)255 }256 value.SetUint(v)257}258 259// decInt16 decodes an integer and stores it as an int16 in value.260func decInt16(i *decInstr, state *decoderState, value reflect.Value) {261 v := state.decodeInt()262 if v < math.MinInt16 || math.MaxInt16 < v {263 error_(i.ovfl)264 }265 value.SetInt(v)266}267 268// decUint16 decodes an unsigned integer and stores it as a uint16 in value.269func decUint16(i *decInstr, state *decoderState, value reflect.Value) {270 v := state.decodeUint()271 if math.MaxUint16 < v {272 error_(i.ovfl)273 }274 value.SetUint(v)275}276 277// decInt32 decodes an integer and stores it as an int32 in value.278func decInt32(i *decInstr, state *decoderState, value reflect.Value) {279 v := state.decodeInt()280 if v < math.MinInt32 || math.MaxInt32 < v {281 error_(i.ovfl)282 }283 value.SetInt(v)284}285 286// decUint32 decodes an unsigned integer and stores it as a uint32 in value.287func decUint32(i *decInstr, state *decoderState, value reflect.Value) {288 v := state.decodeUint()289 if math.MaxUint32 < v {290 error_(i.ovfl)291 }292 value.SetUint(v)293}294 295// decInt64 decodes an integer and stores it as an int64 in value.296func decInt64(i *decInstr, state *decoderState, value reflect.Value) {297 v := state.decodeInt()298 value.SetInt(v)299}300 301// decUint64 decodes an unsigned integer and stores it as a uint64 in value.302func decUint64(i *decInstr, state *decoderState, value reflect.Value) {303 v := state.decodeUint()304 value.SetUint(v)305}306 307// Floating-point numbers are transmitted as uint64s holding the bits308// of the underlying representation. They are sent byte-reversed, with309// the exponent end coming out first, so integer floating point numbers310// (for example) transmit more compactly. This routine does the311// unswizzling.312func float64FromBits(u uint64) float64 {313 v := bits.ReverseBytes64(u)314 return math.Float64frombits(v)315}316 317// float32FromBits decodes an unsigned integer, treats it as a 32-bit floating-point318// number, and returns it. It's a helper function for float32 and complex64.319// It returns a float64 because that's what reflection needs, but its return320// value is known to be accurately representable in a float32.321func float32FromBits(u uint64, ovfl error) float64 {322 v := float64FromBits(u)323 av := v324 if av < 0 {325 av = -av326 }327 // +Inf is OK in both 32- and 64-bit floats. Underflow is always OK.328 if math.MaxFloat32 < av && av <= math.MaxFloat64 {329 error_(ovfl)330 }331 return v332}333 334// decFloat32 decodes an unsigned integer, treats it as a 32-bit floating-point335// number, and stores it in value.336func decFloat32(i *decInstr, state *decoderState, value reflect.Value) {337 value.SetFloat(float32FromBits(state.decodeUint(), i.ovfl))338}339 340// decFloat64 decodes an unsigned integer, treats it as a 64-bit floating-point341// number, and stores it in value.342func decFloat64(i *decInstr, state *decoderState, value reflect.Value) {343 value.SetFloat(float64FromBits(state.decodeUint()))344}345 346// decComplex64 decodes a pair of unsigned integers, treats them as a347// pair of floating point numbers, and stores them as a complex64 in value.348// The real part comes first.349func decComplex64(i *decInstr, state *decoderState, value reflect.Value) {350 real := float32FromBits(state.decodeUint(), i.ovfl)351 imag := float32FromBits(state.decodeUint(), i.ovfl)352 value.SetComplex(complex(real, imag))353}354 355// decComplex128 decodes a pair of unsigned integers, treats them as a356// pair of floating point numbers, and stores them as a complex128 in value.357// The real part comes first.358func decComplex128(i *decInstr, state *decoderState, value reflect.Value) {359 real := float64FromBits(state.decodeUint())360 imag := float64FromBits(state.decodeUint())361 value.SetComplex(complex(real, imag))362}363 364// decUint8Slice decodes a byte slice and stores in value a slice header365// describing the data.366// uint8 slices are encoded as an unsigned count followed by the raw bytes.367func decUint8Slice(i *decInstr, state *decoderState, value reflect.Value) {368 n, ok := state.getLength()369 if !ok {370 errorf("bad %s slice length: %d", value.Type(), n)371 }372 if value.Cap() < n {373 safe := saferio.SliceCap[byte](uint64(n))374 if safe < 0 {375 errorf("%s slice too big: %d elements", value.Type(), n)376 }377 value.Set(reflect.MakeSlice(value.Type(), safe, safe))378 ln := safe379 i := 0380 for i < n {381 if i >= ln {382 // We didn't allocate the entire slice,383 // due to using saferio.SliceCap.384 // Grow the slice for one more element.385 // The slice is full, so this should386 // bump up the capacity.387 value.Grow(1)388 }389 // Copy into s up to the capacity or n,390 // whichever is less.391 ln = value.Cap()392 if ln > n {393 ln = n394 }395 value.SetLen(ln)396 sub := value.Slice(i, ln)397 if _, err := state.b.Read(sub.Bytes()); err != nil {398 errorf("error decoding []byte at %d: %s", i, err)399 }400 i = ln401 }402 } else {403 value.SetLen(n)404 if _, err := state.b.Read(value.Bytes()); err != nil {405 errorf("error decoding []byte: %s", err)406 }407 }408}409 410// decString decodes byte array and stores in value a string header411// describing the data.412// Strings are encoded as an unsigned count followed by the raw bytes.413func decString(i *decInstr, state *decoderState, value reflect.Value) {414 n, ok := state.getLength()415 if !ok {416 errorf("bad %s slice length: %d", value.Type(), n)417 }418 // Read the data.419 data := state.b.Bytes()420 if len(data) < n {421 errorf("invalid string length %d: exceeds input size %d", n, len(data))422 }423 s := string(data[:n])424 state.b.Drop(n)425 value.SetString(s)426}427 428// ignoreUint8Array skips over the data for a byte slice value with no destination.429func ignoreUint8Array(i *decInstr, state *decoderState, value reflect.Value) {430 n, ok := state.getLength()431 if !ok {432 errorf("slice length too large")433 }434 bn := state.b.Len()435 if bn < n {436 errorf("invalid slice length %d: exceeds input size %d", n, bn)437 }438 state.b.Drop(n)439}440 441// Execution engine442 443// The encoder engine is an array of instructions indexed by field number of the incoming444// decoder. It is executed with random access according to field number.445type decEngine struct {446 instr []decInstr447 numInstr int // the number of active instructions448}449 450// decodeSingle decodes a top-level value that is not a struct and stores it in value.451// Such values are preceded by a zero, making them have the memory layout of a452// struct field (although with an illegal field number).453func (dec *Decoder) decodeSingle(engine *decEngine, value reflect.Value) {454 state := dec.newDecoderState(&dec.buf)455 defer dec.freeDecoderState(state)456 state.fieldnum = singletonField457 if state.decodeUint() != 0 {458 errorf("decode: corrupted data: non-zero delta for singleton")459 }460 instr := &engine.instr[singletonField]461 instr.op(instr, state, value)462}463 464// decodeStruct decodes a top-level struct and stores it in value.465// Indir is for the value, not the type. At the time of the call it may466// differ from ut.indir, which was computed when the engine was built.467// This state cannot arise for decodeSingle, which is called directly468// from the user's value, not from the innards of an engine.469func (dec *Decoder) decodeStruct(engine *decEngine, value reflect.Value) {470 state := dec.newDecoderState(&dec.buf)471 defer dec.freeDecoderState(state)472 state.fieldnum = -1473 for state.b.Len() > 0 {474 delta := int(state.decodeUint())475 if delta < 0 {476 errorf("decode: corrupted data: negative delta")477 }478 if delta == 0 { // struct terminator is zero delta fieldnum479 break480 }481 if state.fieldnum >= len(engine.instr)-delta { // subtract to compare without overflow482 error_(errRange)483 }484 fieldnum := state.fieldnum + delta485 instr := &engine.instr[fieldnum]486 var field reflect.Value487 if instr.index != nil {488 // Otherwise the field is unknown to us and instr.op is an ignore op.489 field = value.FieldByIndex(instr.index)490 if field.Kind() == reflect.Pointer {491 field = decAlloc(field)492 }493 }494 instr.op(instr, state, field)495 state.fieldnum = fieldnum496 }497}498 499var noValue reflect.Value500 501// ignoreStruct discards the data for a struct with no destination.502func (dec *Decoder) ignoreStruct(engine *decEngine) {503 state := dec.newDecoderState(&dec.buf)504 defer dec.freeDecoderState(state)505 state.fieldnum = -1506 for state.b.Len() > 0 {507 delta := int(state.decodeUint())508 if delta < 0 {509 errorf("ignore decode: corrupted data: negative delta")510 }511 if delta == 0 { // struct terminator is zero delta fieldnum512 break513 }514 fieldnum := state.fieldnum + delta515 if fieldnum >= len(engine.instr) {516 error_(errRange)517 }518 instr := &engine.instr[fieldnum]519 instr.op(instr, state, noValue)520 state.fieldnum = fieldnum521 }522}523 524// ignoreSingle discards the data for a top-level non-struct value with no525// destination. It's used when calling Decode with a nil value.526func (dec *Decoder) ignoreSingle(engine *decEngine) {527 state := dec.newDecoderState(&dec.buf)528 defer dec.freeDecoderState(state)529 state.fieldnum = singletonField530 delta := int(state.decodeUint())531 if delta != 0 {532 errorf("decode: corrupted data: non-zero delta for singleton")533 }534 instr := &engine.instr[singletonField]535 instr.op(instr, state, noValue)536}537 538// decodeArrayHelper does the work for decoding arrays and slices.539func (dec *Decoder) decodeArrayHelper(state *decoderState, value reflect.Value, elemOp decOp, length int, ovfl error, helper decHelper) {540 if helper != nil && helper(state, value, length, ovfl) {541 return542 }543 instr := &decInstr{elemOp, 0, nil, ovfl}544 isPtr := value.Type().Elem().Kind() == reflect.Pointer545 ln := value.Len()546 for i := 0; i < length; i++ {547 if state.b.Len() == 0 {548 errorf("decoding array or slice: length exceeds input size (%d elements)", length)549 }550 if i >= ln {551 // This is a slice that we only partially allocated.552 // Grow it up to length.553 value.Grow(1)554 cp := value.Cap()555 if cp > length {556 cp = length557 }558 value.SetLen(cp)559 ln = cp560 }561 v := value.Index(i)562 if isPtr {563 v = decAlloc(v)564 }565 elemOp(instr, state, v)566 }567}568 569// decodeArray decodes an array and stores it in value.570// The length is an unsigned integer preceding the elements. Even though the length is redundant571// (it's part of the type), it's a useful check and is included in the encoding.572func (dec *Decoder) decodeArray(state *decoderState, value reflect.Value, elemOp decOp, length int, ovfl error, helper decHelper) {573 if n := state.decodeUint(); n != uint64(length) {574 errorf("length mismatch in decodeArray")575 }576 dec.decodeArrayHelper(state, value, elemOp, length, ovfl, helper)577}578 579// decodeIntoValue is a helper for map decoding.580func decodeIntoValue(state *decoderState, op decOp, isPtr bool, value reflect.Value, instr *decInstr) reflect.Value {581 v := value582 if isPtr {583 v = decAlloc(value)584 }585 586 op(instr, state, v)587 return value588}589 590// decodeMap decodes a map and stores it in value.591// Maps are encoded as a length followed by key:value pairs.592// Because the internals of maps are not visible to us, we must593// use reflection rather than pointer magic.594func (dec *Decoder) decodeMap(mtyp reflect.Type, state *decoderState, value reflect.Value, keyOp, elemOp decOp, ovfl error) {595 n := int(state.decodeUint())596 if value.IsNil() {597 value.Set(reflect.MakeMapWithSize(mtyp, n))598 }599 keyIsPtr := mtyp.Key().Kind() == reflect.Pointer600 elemIsPtr := mtyp.Elem().Kind() == reflect.Pointer601 keyInstr := &decInstr{keyOp, 0, nil, ovfl}602 elemInstr := &decInstr{elemOp, 0, nil, ovfl}603 keyP := reflect.New(mtyp.Key())604 elemP := reflect.New(mtyp.Elem())605 for i := 0; i < n; i++ {606 key := decodeIntoValue(state, keyOp, keyIsPtr, keyP.Elem(), keyInstr)607 elem := decodeIntoValue(state, elemOp, elemIsPtr, elemP.Elem(), elemInstr)608 value.SetMapIndex(key, elem)609 keyP.Elem().SetZero()610 elemP.Elem().SetZero()611 }612}613 614// ignoreArrayHelper does the work for discarding arrays and slices.615func (dec *Decoder) ignoreArrayHelper(state *decoderState, elemOp decOp, length int) {616 instr := &decInstr{elemOp, 0, nil, errors.New("no error")}617 for i := 0; i < length; i++ {618 if state.b.Len() == 0 {619 errorf("decoding array or slice: length exceeds input size (%d elements)", length)620 }621 elemOp(instr, state, noValue)622 }623}624 625// ignoreArray discards the data for an array value with no destination.626func (dec *Decoder) ignoreArray(state *decoderState, elemOp decOp, length int) {627 if n := state.decodeUint(); n != uint64(length) {628 errorf("length mismatch in ignoreArray")629 }630 dec.ignoreArrayHelper(state, elemOp, length)631}632 633// ignoreMap discards the data for a map value with no destination.634func (dec *Decoder) ignoreMap(state *decoderState, keyOp, elemOp decOp) {635 n := int(state.decodeUint())636 keyInstr := &decInstr{keyOp, 0, nil, errors.New("no error")}637 elemInstr := &decInstr{elemOp, 0, nil, errors.New("no error")}638 for i := 0; i < n; i++ {639 keyOp(keyInstr, state, noValue)640 elemOp(elemInstr, state, noValue)641 }642}643 644// decodeSlice decodes a slice and stores it in value.645// Slices are encoded as an unsigned length followed by the elements.646func (dec *Decoder) decodeSlice(state *decoderState, value reflect.Value, elemOp decOp, ovfl error, helper decHelper) {647 u := state.decodeUint()648 typ := value.Type()649 size := uint64(typ.Elem().Size())650 nBytes := u * size651 n := int(u)652 // Take care with overflow in this calculation.653 if n < 0 || uint64(n) != u || nBytes > tooBig || (size > 0 && nBytes/size != u) {654 // We don't check n against buffer length here because if it's a slice655 // of interfaces, there will be buffer reloads.656 errorf("%s slice too big: %d elements of %d bytes", typ.Elem(), u, size)657 }658 if value.Cap() < n {659 safe := saferio.SliceCapWithSize(size, uint64(n))660 if safe < 0 {661 errorf("%s slice too big: %d elements of %d bytes", typ.Elem(), u, size)662 }663 value.Set(reflect.MakeSlice(typ, safe, safe))664 } else {665 value.SetLen(n)666 }667 dec.decodeArrayHelper(state, value, elemOp, n, ovfl, helper)668}669 670// ignoreSlice skips over the data for a slice value with no destination.671func (dec *Decoder) ignoreSlice(state *decoderState, elemOp decOp) {672 dec.ignoreArrayHelper(state, elemOp, int(state.decodeUint()))673}674 675// decodeInterface decodes an interface value and stores it in value.676// Interfaces are encoded as the name of a concrete type followed by a value.677// If the name is empty, the value is nil and no value is sent.678func (dec *Decoder) decodeInterface(ityp reflect.Type, state *decoderState, value reflect.Value) {679 // Read the name of the concrete type.680 nr := state.decodeUint()681 if nr > 1<<31 { // zero is permissible for anonymous types682 errorf("invalid type name length %d", nr)683 }684 if nr > uint64(state.b.Len()) {685 errorf("invalid type name length %d: exceeds input size", nr)686 }687 n := int(nr)688 name := state.b.Bytes()[:n]689 state.b.Drop(n)690 // Allocate the destination interface value.691 if len(name) == 0 {692 // Copy the nil interface value to the target.693 value.SetZero()694 return695 }696 if len(name) > 1024 {697 errorf("name too long (%d bytes): %.20q...", len(name), name)698 }699 // The concrete type must be registered.700 typi, ok := nameToConcreteType.Load(string(name))701 if !ok {702 errorf("name not registered for interface: %q", name)703 }704 typ := typi.(reflect.Type)705 706 // Read the type id of the concrete value.707 concreteId := dec.decodeTypeSequence(true)708 if concreteId < 0 {709 error_(dec.err)710 }711 // Byte count of value is next; we don't care what it is (it's there712 // in case we want to ignore the value by skipping it completely).713 state.decodeUint()714 // Read the concrete value.715 v := allocValue(typ)716 dec.decodeValue(concreteId, v)717 if dec.err != nil {718 error_(dec.err)719 }720 // Assign the concrete value to the interface.721 // Tread carefully; it might not satisfy the interface.722 if !typ.AssignableTo(ityp) {723 errorf("%s is not assignable to type %s", typ, ityp)724 }725 // Copy the interface value to the target.726 value.Set(v)727}728 729// ignoreInterface discards the data for an interface value with no destination.730func (dec *Decoder) ignoreInterface(state *decoderState) {731 // Read the name of the concrete type.732 n, ok := state.getLength()733 if !ok {734 errorf("bad interface encoding: name too large for buffer")735 }736 bn := state.b.Len()737 if bn < n {738 errorf("invalid interface value length %d: exceeds input size %d", n, bn)739 }740 state.b.Drop(n)741 id := dec.decodeTypeSequence(true)742 if id < 0 {743 error_(dec.err)744 }745 // At this point, the decoder buffer contains a delimited value. Just toss it.746 n, ok = state.getLength()747 if !ok {748 errorf("bad interface encoding: data length too large for buffer")749 }750 state.b.Drop(n)751}752 753// decodeGobDecoder decodes something implementing the GobDecoder interface.754// The data is encoded as a byte slice.755func (dec *Decoder) decodeGobDecoder(ut *userTypeInfo, state *decoderState, value reflect.Value) {756 // Read the bytes for the value.757 n, ok := state.getLength()758 if !ok {759 errorf("GobDecoder: length too large for buffer")760 }761 b := state.b.Bytes()762 if len(b) < n {763 errorf("GobDecoder: invalid data length %d: exceeds input size %d", n, len(b))764 }765 b = b[:n]766 state.b.Drop(n)767 var err error768 // We know it's one of these.769 switch ut.externalDec {770 case xGob:771 gobDecoder, _ := reflect.TypeAssert[GobDecoder](value)772 err = gobDecoder.GobDecode(b)773 case xBinary:774 binaryUnmarshaler, _ := reflect.TypeAssert[encoding.BinaryUnmarshaler](value)775 err = binaryUnmarshaler.UnmarshalBinary(b)776 case xText:777 textUnmarshaler, _ := reflect.TypeAssert[encoding.TextUnmarshaler](value)778 err = textUnmarshaler.UnmarshalText(b)779 }780 if err != nil {781 error_(err)782 }783}784 785// ignoreGobDecoder discards the data for a GobDecoder value with no destination.786func (dec *Decoder) ignoreGobDecoder(state *decoderState) {787 // Read the bytes for the value.788 n, ok := state.getLength()789 if !ok {790 errorf("GobDecoder: length too large for buffer")791 }792 bn := state.b.Len()793 if bn < n {794 errorf("GobDecoder: invalid data length %d: exceeds input size %d", n, bn)795 }796 state.b.Drop(n)797}798 799// Index by Go types.800var decOpTable = [...]decOp{801 reflect.Bool: decBool,802 reflect.Int8: decInt8,803 reflect.Int16: decInt16,804 reflect.Int32: decInt32,805 reflect.Int64: decInt64,806 reflect.Uint8: decUint8,807 reflect.Uint16: decUint16,808 reflect.Uint32: decUint32,809 reflect.Uint64: decUint64,810 reflect.Float32: decFloat32,811 reflect.Float64: decFloat64,812 reflect.Complex64: decComplex64,813 reflect.Complex128: decComplex128,814 reflect.String: decString,815}816 817// Indexed by gob types. tComplex will be added during type.init().818var decIgnoreOpMap = map[typeId]decOp{819 tBool: ignoreUint,820 tInt: ignoreUint,821 tUint: ignoreUint,822 tFloat: ignoreUint,823 tBytes: ignoreUint8Array,824 tString: ignoreUint8Array,825 tComplex: ignoreTwoUints,826}827 828// decOpFor returns the decoding op for the base type under rt and829// the indirection count to reach it.830func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string, inProgress map[reflect.Type]*decOp) *decOp {831 ut := userType(rt)832 // If the type implements GobEncoder, we handle it without further processing.833 if ut.externalDec != 0 {834 return dec.gobDecodeOpFor(ut)835 }836 837 // If this type is already in progress, it's a recursive type (e.g. map[string]*T).838 // Return the pointer to the op we're already building.839 if opPtr := inProgress[rt]; opPtr != nil {840 return opPtr841 }842 typ := ut.base843 var op decOp844 k := typ.Kind()845 if int(k) < len(decOpTable) {846 op = decOpTable[k]847 }848 if op == nil {849 inProgress[rt] = &op850 // Special cases851 switch t := typ; t.Kind() {852 case reflect.Array:853 name = "element of " + name854 elemId := dec.wireType[wireId].ArrayT.Elem855 elemOp := dec.decOpFor(elemId, t.Elem(), name, inProgress)856 ovfl := overflow(name)857 helper := decArrayHelper[t.Elem().Kind()]858 op = func(i *decInstr, state *decoderState, value reflect.Value) {859 state.dec.decodeArray(state, value, *elemOp, t.Len(), ovfl, helper)860 }861 862 case reflect.Map:863 keyId := dec.wireType[wireId].MapT.Key864 elemId := dec.wireType[wireId].MapT.Elem865 keyOp := dec.decOpFor(keyId, t.Key(), "key of "+name, inProgress)866 elemOp := dec.decOpFor(elemId, t.Elem(), "element of "+name, inProgress)867 ovfl := overflow(name)868 op = func(i *decInstr, state *decoderState, value reflect.Value) {869 state.dec.decodeMap(t, state, value, *keyOp, *elemOp, ovfl)870 }871 872 case reflect.Slice:873 name = "element of " + name874 if t.Elem().Kind() == reflect.Uint8 {875 op = decUint8Slice876 break877 }878 var elemId typeId879 if tt := builtinIdToType(wireId); tt != nil {880 elemId = tt.(*sliceType).Elem881 } else {882 elemId = dec.wireType[wireId].SliceT.Elem883 }884 elemOp := dec.decOpFor(elemId, t.Elem(), name, inProgress)885 ovfl := overflow(name)886 helper := decSliceHelper[t.Elem().Kind()]887 op = func(i *decInstr, state *decoderState, value reflect.Value) {888 state.dec.decodeSlice(state, value, *elemOp, ovfl, helper)889 }890 891 case reflect.Struct:892 // Generate a closure that calls out to the engine for the nested type.893 ut := userType(typ)894 enginePtr, err := dec.getDecEnginePtr(wireId, ut)895 if err != nil {896 error_(err)897 }898 op = func(i *decInstr, state *decoderState, value reflect.Value) {899 // indirect through enginePtr to delay evaluation for recursive structs.900 dec.decodeStruct(*enginePtr, value)901 }902 case reflect.Interface:903 op = func(i *decInstr, state *decoderState, value reflect.Value) {904 state.dec.decodeInterface(t, state, value)905 }906 }907 }908 if op == nil {909 errorf("decode can't handle type %s", rt)910 }911 return &op912}913 914var maxIgnoreNestingDepth = 10000915 916// decIgnoreOpFor returns the decoding op for a field that has no destination.917func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp) *decOp {918 // Track how deep we've recursed trying to skip nested ignored fields.919 dec.ignoreDepth++920 defer func() { dec.ignoreDepth-- }()921 if dec.ignoreDepth > maxIgnoreNestingDepth {922 error_(errors.New("invalid nesting depth"))923 }924 // If this type is already in progress, it's a recursive type (e.g. map[string]*T).925 // Return the pointer to the op we're already building.926 if opPtr := inProgress[wireId]; opPtr != nil {927 return opPtr928 }929 op, ok := decIgnoreOpMap[wireId]930 if !ok {931 inProgress[wireId] = &op932 if wireId == tInterface {933 // Special case because it's a method: the ignored item might934 // define types and we need to record their state in the decoder.935 op = func(i *decInstr, state *decoderState, value reflect.Value) {936 state.dec.ignoreInterface(state)937 }938 return &op939 }940 // Special cases941 wire := dec.wireType[wireId]942 switch {943 case wire == nil:944 errorf("bad data: undefined type %s", wireId.string())945 case wire.ArrayT != nil:946 elemId := wire.ArrayT.Elem947 elemOp := dec.decIgnoreOpFor(elemId, inProgress)948 op = func(i *decInstr, state *decoderState, value reflect.Value) {949 state.dec.ignoreArray(state, *elemOp, wire.ArrayT.Len)950 }951 952 case wire.MapT != nil:953 keyId := dec.wireType[wireId].MapT.Key954 elemId := dec.wireType[wireId].MapT.Elem955 keyOp := dec.decIgnoreOpFor(keyId, inProgress)956 elemOp := dec.decIgnoreOpFor(elemId, inProgress)957 op = func(i *decInstr, state *decoderState, value reflect.Value) {958 state.dec.ignoreMap(state, *keyOp, *elemOp)959 }960 961 case wire.SliceT != nil:962 elemId := wire.SliceT.Elem963 elemOp := dec.decIgnoreOpFor(elemId, inProgress)964 op = func(i *decInstr, state *decoderState, value reflect.Value) {965 state.dec.ignoreSlice(state, *elemOp)966 }967 968 case wire.StructT != nil:969 // Generate a closure that calls out to the engine for the nested type.970 enginePtr, err := dec.getIgnoreEnginePtr(wireId)971 if err != nil {972 error_(err)973 }974 op = func(i *decInstr, state *decoderState, value reflect.Value) {975 // indirect through enginePtr to delay evaluation for recursive structs976 state.dec.ignoreStruct(*enginePtr)977 }978 979 case wire.GobEncoderT != nil, wire.BinaryMarshalerT != nil, wire.TextMarshalerT != nil:980 op = func(i *decInstr, state *decoderState, value reflect.Value) {981 state.dec.ignoreGobDecoder(state)982 }983 }984 }985 if op == nil {986 errorf("bad data: ignore can't handle type %s", wireId.string())987 }988 return &op989}990 991// gobDecodeOpFor returns the op for a type that is known to implement992// GobDecoder.993func (dec *Decoder) gobDecodeOpFor(ut *userTypeInfo) *decOp {994 rcvrType := ut.user995 if ut.decIndir == -1 {996 rcvrType = reflect.PointerTo(rcvrType)997 } else if ut.decIndir > 0 {998 for i := int8(0); i < ut.decIndir; i++ {999 rcvrType = rcvrType.Elem()1000 }1001 }1002 var op decOp1003 op = func(i *decInstr, state *decoderState, value reflect.Value) {1004 // We now have the base type. We need its address if the receiver is a pointer.1005 if value.Kind() != reflect.Pointer && rcvrType.Kind() == reflect.Pointer {1006 value = value.Addr()1007 }1008 state.dec.decodeGobDecoder(ut, state, value)1009 }1010 return &op1011}1012 1013// compatibleType asks: Are these two gob Types compatible?1014// Answers the question for basic types, arrays, maps and slices, plus1015// GobEncoder/Decoder pairs.1016// Structs are considered ok; fields will be checked later.1017func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId, inProgress map[reflect.Type]typeId) bool {1018 if rhs, ok := inProgress[fr]; ok {1019 return rhs == fw1020 }1021 inProgress[fr] = fw1022 ut := userType(fr)1023 wire, ok := dec.wireType[fw]1024 // If wire was encoded with an encoding method, fr must have that method.1025 // And if not, it must not.1026 // At most one of the booleans in ut is set.1027 // We could possibly relax this constraint in the future in order to1028 // choose the decoding method using the data in the wireType.1029 // The parentheses look odd but are correct.1030 if (ut.externalDec == xGob) != (ok && wire.GobEncoderT != nil) ||1031 (ut.externalDec == xBinary) != (ok && wire.BinaryMarshalerT != nil) ||1032 (ut.externalDec == xText) != (ok && wire.TextMarshalerT != nil) {1033 return false1034 }1035 if ut.externalDec != 0 { // This test trumps all others.1036 return true1037 }1038 switch t := ut.base; t.Kind() {1039 default:1040 // chan, etc: cannot handle.1041 return false1042 case reflect.Bool:1043 return fw == tBool1044 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:1045 return fw == tInt1046 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:1047 return fw == tUint1048 case reflect.Float32, reflect.Float64:1049 return fw == tFloat1050 case reflect.Complex64, reflect.Complex128:1051 return fw == tComplex1052 case reflect.String:1053 return fw == tString1054 case reflect.Interface:1055 return fw == tInterface1056 case reflect.Array:1057 if !ok || wire.ArrayT == nil {1058 return false1059 }1060 array := wire.ArrayT1061 return t.Len() == array.Len && dec.compatibleType(t.Elem(), array.Elem, inProgress)1062 case reflect.Map:1063 if !ok || wire.MapT == nil {1064 return false1065 }1066 MapType := wire.MapT1067 return dec.compatibleType(t.Key(), MapType.Key, inProgress) && dec.compatibleType(t.Elem(), MapType.Elem, inProgress)1068 case reflect.Slice:1069 // Is it an array of bytes?1070 if t.Elem().Kind() == reflect.Uint8 {1071 return fw == tBytes1072 }1073 // Extract and compare element types.1074 var sw *sliceType1075 if tt := builtinIdToType(fw); tt != nil {1076 sw, _ = tt.(*sliceType)1077 } else if wire != nil {1078 sw = wire.SliceT1079 }1080 elem := userType(t.Elem()).base1081 return sw != nil && dec.compatibleType(elem, sw.Elem, inProgress)1082 case reflect.Struct:1083 return true1084 }1085}1086 1087// typeString returns a human-readable description of the type identified by remoteId.1088func (dec *Decoder) typeString(remoteId typeId) string {1089 typeLock.Lock()1090 defer typeLock.Unlock()1091 if t := idToType(remoteId); t != nil {1092 // globally known type.1093 return t.string()1094 }1095 return dec.wireType[remoteId].string()1096}1097 1098// compileSingle compiles the decoder engine for a non-struct top-level value, including1099// GobDecoders.1100func (dec *Decoder) compileSingle(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error) {1101 rt := ut.user1102 engine = new(decEngine)1103 engine.instr = make([]decInstr, 1) // one item1104 name := rt.String() // best we can do1105 if !dec.compatibleType(rt, remoteId, make(map[reflect.Type]typeId)) {1106 remoteType := dec.typeString(remoteId)1107 // Common confusing case: local interface type, remote concrete type.1108 if ut.base.Kind() == reflect.Interface && remoteId != tInterface {1109 return nil, errors.New("gob: local interface type " + name + " can only be decoded from remote interface type; received concrete type " + remoteType)1110 }1111 return nil, errors.New("gob: decoding into local type " + name + ", received remote type " + remoteType)1112 }1113 op := dec.decOpFor(remoteId, rt, name, make(map[reflect.Type]*decOp))1114 ovfl := errors.New(`value for "` + name + `" out of range`)1115 engine.instr[singletonField] = decInstr{*op, singletonField, nil, ovfl}1116 engine.numInstr = 11117 return1118}1119 1120// compileIgnoreSingle compiles the decoder engine for a non-struct top-level value that will be discarded.1121func (dec *Decoder) compileIgnoreSingle(remoteId typeId) *decEngine {1122 engine := new(decEngine)1123 engine.instr = make([]decInstr, 1) // one item1124 op := dec.decIgnoreOpFor(remoteId, make(map[typeId]*decOp))1125 ovfl := overflow(dec.typeString(remoteId))1126 engine.instr[0] = decInstr{*op, 0, nil, ovfl}1127 engine.numInstr = 11128 return engine1129}1130 1131// compileDec compiles the decoder engine for a value. If the value is not a struct,1132// it calls out to compileSingle.1133func (dec *Decoder) compileDec(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error) {1134 defer catchError(&err)1135 rt := ut.base1136 srt := rt1137 if srt.Kind() != reflect.Struct || ut.externalDec != 0 {1138 return dec.compileSingle(remoteId, ut)1139 }1140 var wireStruct *structType1141 // Builtin types can come from global pool; the rest must be defined by the decoder.1142 // Also we know we're decoding a struct now, so the client must have sent one.1143 if t := builtinIdToType(remoteId); t != nil {1144 wireStruct, _ = t.(*structType)1145 } else {1146 wire := dec.wireType[remoteId]1147 if wire == nil {1148 error_(errBadType)1149 }1150 wireStruct = wire.StructT1151 }1152 if wireStruct == nil {1153 errorf("type mismatch in decoder: want struct type %s; got non-struct", rt)1154 }1155 engine = new(decEngine)1156 engine.instr = make([]decInstr, len(wireStruct.Field))1157 seen := make(map[reflect.Type]*decOp)1158 // Loop over the fields of the wire type.1159 for fieldnum := 0; fieldnum < len(wireStruct.Field); fieldnum++ {1160 wireField := wireStruct.Field[fieldnum]1161 if wireField.Name == "" {1162 errorf("empty name for remote field of type %s", wireStruct.Name)1163 }1164 ovfl := overflow(wireField.Name)1165 // Find the field of the local type with the same name.1166 localField, present := srt.FieldByName(wireField.Name)1167 // TODO(r): anonymous names1168 if !present || !isExported(wireField.Name) {1169 op := dec.decIgnoreOpFor(wireField.Id, make(map[typeId]*decOp))1170 engine.instr[fieldnum] = decInstr{*op, fieldnum, nil, ovfl}1171 continue1172 }1173 if !dec.compatibleType(localField.Type, wireField.Id, make(map[reflect.Type]typeId)) {1174 errorf("wrong type (%s) for received field %s.%s", localField.Type, wireStruct.Name, wireField.Name)1175 }1176 op := dec.decOpFor(wireField.Id, localField.Type, localField.Name, seen)1177 engine.instr[fieldnum] = decInstr{*op, fieldnum, localField.Index, ovfl}1178 engine.numInstr++1179 }1180 return1181}1182 1183// getDecEnginePtr returns the engine for the specified type.1184func (dec *Decoder) getDecEnginePtr(remoteId typeId, ut *userTypeInfo) (enginePtr **decEngine, err error) {1185 rt := ut.user1186 decoderMap, ok := dec.decoderCache[rt]1187 if !ok {1188 decoderMap = make(map[typeId]**decEngine)1189 dec.decoderCache[rt] = decoderMap1190 }1191 if enginePtr, ok = decoderMap[remoteId]; !ok {1192 // To handle recursive types, mark this engine as underway before compiling.1193 enginePtr = new(*decEngine)1194 decoderMap[remoteId] = enginePtr1195 *enginePtr, err = dec.compileDec(remoteId, ut)1196 if err != nil {1197 delete(decoderMap, remoteId)1198 }1199 }1200 return