package rlp import ( "bufio" "encoding/binary" "errors" "fmt" "io" "math/big" "reflect" ) var ( errNoPointer = errors.New("rlp: interface given to Decode must be a pointer") errDecodeIntoNil = errors.New("rlp: pointer given to Decode must not be nil") ) // Decoder is implemented by types that require custom RLP // decoding rules or need to decode into private fields. // // The DecodeRLP method should read one value from the given // Stream. It is not forbidden to read less or more, but it might // be confusing. type Decoder interface { DecodeRLP(*Stream) error } // Decode parses RLP-encoded data from r and stores the result in the // value pointed to by val. Val must be a non-nil pointer. If r does // not implement ByteReader, Decode will do its own buffering. // // Decode uses the following type-dependent decoding rules: // // If the type implements the Decoder interface, decode calls // DecodeRLP. // // To decode into a pointer, Decode will set the pointer to nil if the // input has size zero or the input is a single byte with value zero. // If the input has nonzero size, Decode will allocate a new value of // the type being pointed to. // // To decode into a struct, Decode expects the input to be an RLP // list. The decoded elements of the list are assigned to each public // field in the order given by the struct's definition. If the input // list has too few elements, no error is returned and the remaining // fields will have the zero value. // Recursive struct types are supported. // // To decode into a slice, the input must be a list and the resulting // slice will contain the input elements in order. // As a special case, if the slice has a byte-size element type, the input // can also be an RLP string. // // To decode into a Go string, the input must be an RLP string. The // bytes are taken as-is and will not necessarily be valid UTF-8. // // To decode into an unsigned integer type, the input must also be an RLP // string. The bytes are interpreted as a big endian representation of // the integer. If the RLP string is larger than the bit size of the // type, Decode will return an error. Decode also supports *big.Int. // There is no size limit for big integers. // // To decode into an interface value, Decode stores one of these // in the value: // // []interface{}, for RLP lists // []byte, for RLP strings // // Non-empty interface types are not supported, nor are booleans, // signed integers, floating point numbers, maps, channels and // functions. func Decode(r io.Reader, val interface{}) error { return NewStream(r).Decode(val) } type decodeError struct { msg string typ reflect.Type ctx []string } func (err *decodeError) Error() string { ctx := "" if len(err.ctx) > 0 { ctx = ", decoding into " for i := len(err.ctx) - 1; i >= 0; i-- { ctx += err.ctx[i] } } return fmt.Sprintf("rlp: %s for %v%s", err.msg, err.typ, ctx) } func wrapStreamError(err error, typ reflect.Type) error { switch err { case ErrExpectedList: return &decodeError{msg: "expected input list", typ: typ} case ErrExpectedString: return &decodeError{msg: "expected input string or byte", typ: typ} case errUintOverflow: return &decodeError{msg: "input string too long", typ: typ} case errNotAtEOL: return &decodeError{msg: "input list has too many elements", typ: typ} } return err } func addErrorContext(err error, ctx string) error { if decErr, ok := err.(*decodeError); ok { decErr.ctx = append(decErr.ctx, ctx) } return err } var ( decoderInterface = reflect.TypeOf(new(Decoder)).Elem() bigInt = reflect.TypeOf(big.Int{}) ) func makeDecoder(typ reflect.Type) (dec decoder, err error) { kind := typ.Kind() switch { case typ.Implements(decoderInterface): return decodeDecoder, nil case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface): return decodeDecoderNoPtr, nil case typ.AssignableTo(reflect.PtrTo(bigInt)): return decodeBigInt, nil case typ.AssignableTo(bigInt): return decodeBigIntNoPtr, nil case isUint(kind): return decodeUint, nil case kind == reflect.String: return decodeString, nil case kind == reflect.Slice || kind == reflect.Array: return makeListDecoder(typ) case kind == reflect.Struct: return makeStructDecoder(typ) case kind == reflect.Ptr: return makePtrDecoder(typ) case kind == reflect.Interface: return decodeInterface, nil default: return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ) } } func decodeUint(s *Stream, val reflect.Value) error { typ := val.Type() num, err := s.uint(typ.Bits()) if err != nil { return wrapStreamError(err, val.Type()) } val.SetUint(num) return nil } func decodeString(s *Stream, val reflect.Value) error { b, err := s.Bytes() if err != nil { return wrapStreamError(err, val.Type()) } val.SetString(string(b)) return nil } func decodeBigIntNoPtr(s *Stream, val reflect.Value) error { return decodeBigInt(s, val.Addr()) } func decodeBigInt(s *Stream, val reflect.Value) error { b, err := s.Bytes() if err != nil { return wrapStreamError(err, val.Type()) } i := val.Interface().(*big.Int) if i == nil { i = new(big.Int) val.Set(reflect.ValueOf(i)) } i.SetBytes(b) return nil } func makeListDecoder(typ reflect.Type) (decoder, error) { etype := typ.Elem() if etype.Kind() == reflect.Uint8 && !reflect.PtrTo(etype).Implements(decoderInterface) { if typ.Kind() == reflect.Array { return decodeByteArray, nil } else { return decodeByteSlice, nil } } etypeinfo, err := cachedTypeInfo1(etype) if err != nil { return nil, err } isArray := typ.Kind() == reflect.Array return func(s *Stream, val reflect.Value) error { if isArray { return decodeListArray(s, val, etypeinfo.decoder) } else { return decodeListSlice(s, val, etypeinfo.decoder) } }, nil } func decodeListSlice(s *Stream, val reflect.Value, elemdec decoder) error { size, err := s.List() if err != nil { return wrapStreamError(err, val.Type()) } if size == 0 { val.Set(reflect.MakeSlice(val.Type(), 0, 0)) return s.ListEnd() } i := 0 for ; ; i++ { // grow slice if necessary if i >= val.Cap() { newcap := val.Cap() + val.Cap()/2 if newcap < 4 { newcap = 4 } newv := reflect.MakeSlice(val.Type(), val.Len(), newcap) reflect.Copy(newv, val) val.Set(newv) } if i >= val.Len() { val.SetLen(i + 1) } // decode into element if err := elemdec(s, val.Index(i)); err == EOL { break } else if err != nil { return addErrorContext(err, fmt.Sprint("[", i, "]")) } } if i < val.Len() { val.SetLen(i) } return s.ListEnd() } func decodeListArray(s *Stream, val reflect.Value, elemdec decoder) error { size, err := s.List() if err != nil { return err } if size == 0 { zero(val, 0) return s.ListEnd() } // The approach here is stolen from package json, although we differ // in the semantics for arrays. package json discards remaining // elements that would not fit into the array. We generate an error in // this case because we'd be losing information. vlen := val.Len() i := 0 for ; i < vlen; i++ { if err := elemdec(s, val.Index(i)); err == EOL { break } else if err != nil { return addErrorContext(err, fmt.Sprint("[", i, "]")) } } if i < vlen { zero(val, i) } return wrapStreamError(s.ListEnd(), val.Type()) } func decodeByteSlice(s *Stream, val reflect.Value) error { kind, _, err := s.Kind() if err != nil { return err } if kind == List { return decodeListSlice(s, val, decodeUint) } b, err := s.Bytes() if err == nil { val.SetBytes(b) } return err } func decodeByteArray(s *Stream, val reflect.Value) error { kind, size, err := s.Kind() if err != nil { return err } switch kind { case Byte: if val.Len() == 0 { return &decodeError{msg: "input string too long", typ: val.Type()} } bv, _ := s.Uint() val.Index(0).SetUint(bv) zero(val, 1) case String: if uint64(val.Len()) < size { return &decodeError{msg: "input string too long", typ: val.Type()} } slice := val.Slice(0, int(size)).Interface().([]byte) if err := s.readFull(slice); err != nil { return err } zero(val, int(size)) case List: return decodeListArray(s, val, decodeUint) } return nil } func zero(val reflect.Value, start int) { z := reflect.Zero(val.Type().Elem()) end := val.Len() for i := start; i < end; i++ { val.Index(i).Set(z) } } type field struct { index int info *typeinfo } func makeStructDecoder(typ reflect.Type) (decoder, error) { fields, err := structFields(typ) if err != nil { return nil, err } dec := func(s *Stream, val reflect.Value) (err error) { if _, err = s.List(); err != nil { return wrapStreamError(err, typ) } for _, f := range fields { err = f.info.decoder(s, val.Field(f.index)) if err == EOL { // too few elements. leave the rest at their zero value. break } else if err != nil { return addErrorContext(err, "."+typ.Field(f.index).Name) } } return wrapStreamError(s.ListEnd(), typ) } return dec, nil } func makePtrDecoder(typ reflect.Type) (decoder, error) { etype := typ.Elem() etypeinfo, err := cachedTypeInfo1(etype) if err != nil { return nil, err } dec := func(s *Stream, val reflect.Value) (err error) { _, size, err := s.Kind() if err != nil || size == 0 && s.byteval == 0 { val.Set(reflect.Zero(typ)) // set to nil return err } newval := val if val.IsNil() { newval = reflect.New(etype) } if err = etypeinfo.decoder(s, newval.Elem()); err == nil { val.Set(newval) } return err } return dec, nil } var ifsliceType = reflect.TypeOf([]interface{}{}) func decodeInterface(s *Stream, val reflect.Value) error { if val.Type().NumMethod() != 0 { return fmt.Errorf("rlp: type %v is not RLP-serializable", val.Type()) } kind, _, err := s.Kind() if err != nil { return err } if kind == List { slice := reflect.New(ifsliceType).Elem() if err := decodeListSlice(s, slice, decodeInterface); err != nil { return err } val.Set(slice) } else { b, err := s.Bytes() if err != nil { return err } val.Set(reflect.ValueOf(b)) } return nil } // This decoder is used for non-pointer values of types // that implement the Decoder interface using a pointer receiver. func decodeDecoderNoPtr(s *Stream, val reflect.Value) error { return val.Addr().Interface().(Decoder).DecodeRLP(s) } func decodeDecoder(s *Stream, val reflect.Value) error { // Decoder instances are not handled using the pointer rule if the type // implements Decoder with pointer receiver (i.e. always) // because it might handle empty values specially. // We need to allocate one here in this case, like makePtrDecoder does. if val.Kind() == reflect.Ptr && val.IsNil() { val.Set(reflect.New(val.Type().Elem())) } return val.Interface().(Decoder).DecodeRLP(s) } // Kind represents the kind of value contained in an RLP stream. type Kind int const ( Byte Kind = iota String List ) func (k Kind) String() string { switch k { case Byte: return "Byte" case String: return "String" case List: return "List" default: return fmt.Sprintf("Unknown(%d)", k) } } var ( // EOL is returned when the end of the current list // has been reached during streaming. EOL = errors.New("rlp: end of list") // Other errors ErrExpectedString = errors.New("rlp: expected String or Byte") ErrExpectedList = errors.New("rlp: expected List") ErrElemTooLarge = errors.New("rlp: element is larger than containing list") // internal errors errNotInList = errors.New("rlp: call of ListEnd outside of any list") errNotAtEOL = errors.New("rlp: call of ListEnd not positioned at EOL") ) // ByteReader must be implemented by any input reader for a Stream. It // is implemented by e.g. bufio.Reader and bytes.Reader. type ByteReader interface { io.Reader io.ByteReader } // Stream can be used for piecemeal decoding of an input stream. This // is useful if the input is very large or if the decoding rules for a // type depend on the input structure. Stream does not keep an // internal buffer. After decoding a value, the input reader will be // positioned just before the type information for the next value. // // When decoding a list and the input position reaches the declared // length of the list, all operations will return error EOL. // The end of the list must be acknowledged using ListEnd to continue // reading the enclosing list. // // Stream is not safe for concurrent use. type Stream struct { r ByteReader uintbuf []byte kind Kind // kind of value ahead size uint64 // size of value ahead byteval byte // value of single byte in type tag stack []listpos } type listpos struct{ pos, size uint64 } // NewStream creates a new stream reading from r. // If r does not implement ByteReader, the Stream will // introduce its own buffering. func NewStream(r io.Reader) *Stream { s := new(Stream) s.Reset(r) return s } // NewListStream creates a new stream that pretends to be positioned // at an encoded list of the given length. func NewListStream(r io.Reader, len uint64) *Stream { s := new(Stream) s.Reset(r) s.kind = List s.size = len return s } // Bytes reads an RLP string and returns its contents as a byte slice. // If the input does not contain an RLP string, the returned // error will be ErrExpectedString. func (s *Stream) Bytes() ([]byte, error) { kind, size, err := s.Kind() if err != nil { return nil, err } switch kind { case Byte: s.kind = -1 // rearm Kind return []byte{s.byteval}, nil case String: b := make([]byte, size) if err = s.readFull(b); err != nil { return nil, err } return b, nil default: return nil, ErrExpectedString } } var errUintOverflow = errors.New("rlp: uint overflow") // Uint reads an RLP string of up to 8 bytes and returns its contents // as an unsigned integer. If the input does not contain an RLP string, the // returned error will be ErrExpectedString. func (s *Stream) Uint() (uint64, error) { return s.uint(64) } func (s *Stream) uint(maxbits int) (uint64, error) { kind, size, err := s.Kind() if err != nil { return 0, err } switch kind { case Byte: s.kind = -1 // rearm Kind return uint64(s.byteval), nil case String: if size > uint64(maxbits/8) { return 0, errUintOverflow } return s.readUint(byte(size)) default: return 0, ErrExpectedString } } // List starts decoding an RLP list. If the input does not contain a // list, the returned error will be ErrExpectedList. When the list's // end has been reached, any Stream operation will return EOL. func (s *Stream) List() (size uint64, err error) { kind, size, err := s.Kind() if err != nil { return 0, err } if kind != List { return 0, ErrExpectedList } s.stack = append(s.stack, listpos{0, size}) s.kind = -1 s.size = 0 return size, nil } // ListEnd returns to the enclosing list. // The input reader must be positioned at the end of a list. func (s *Stream) ListEnd() error { if len(s.stack) == 0 { return errNotInList } tos := s.stack[len(s.stack)-1] if tos.pos != tos.size { return errNotAtEOL } s.stack = s.stack[:len(s.stack)-1] // pop if len(s.stack) > 0 { s.stack[len(s.stack)-1].pos += tos.size } s.kind = -1 s.size = 0 return nil } // Decode decodes a value and stores the result in the value pointed // to by val. Please see the documentation for the Decode function // to learn about the decoding rules. func (s *Stream) Decode(val interface{}) error { if val == nil { return errDecodeIntoNil } rval := reflect.ValueOf(val) rtyp := rval.Type() if rtyp.Kind() != reflect.Ptr { return errNoPointer } if rval.IsNil() { return errDecodeIntoNil } info, err := cachedTypeInfo(rtyp.Elem()) if err != nil { return err } err = info.decoder(s, rval.Elem()) if decErr, ok := err.(*decodeError); ok && len(decErr.ctx) > 0 { // add decode target type to error so context has more meaning decErr.ctx = append(decErr.ctx, fmt.Sprint("(", rtyp.Elem(), ")")) } return err } // Reset discards any information about the current decoding context // and starts reading from r. If r does not also implement ByteReader, // Stream will do its own buffering. func (s *Stream) Reset(r io.Reader) { bufr, ok := r.(ByteReader) if !ok { bufr = bufio.NewReader(r) } s.r = bufr s.stack = s.stack[:0] s.size = 0 s.kind = -1 if s.uintbuf == nil { s.uintbuf = make([]byte, 8) } } // Kind returns the kind and size of the next value in the // input stream. // // The returned size is the number of bytes that make up the value. // For kind == Byte, the size is zero because the value is // contained in the type tag. // // The first call to Kind will read size information from the input // reader and leave it positioned at the start of the actual bytes of // the value. Subsequent calls to Kind (until the value is decoded) // will not advance the input reader and return cached information. func (s *Stream) Kind() (kind Kind, size uint64, err error) { var tos *listpos if len(s.stack) > 0 { tos = &s.stack[len(s.stack)-1] } if s.kind < 0 { if tos != nil && tos.pos == tos.size { return 0, 0, EOL } kind, size, err = s.readKind() if err != nil { return 0, 0, err } s.kind, s.size = kind, size } if tos != nil && tos.pos+s.size > tos.size { return 0, 0, ErrElemTooLarge } return s.kind, s.size, nil } func (s *Stream) readKind() (kind Kind, size uint64, err error) { b, err := s.readByte() if err != nil { return 0, 0, err } s.byteval = 0 switch { case b < 0x80: // For a single byte whose value is in the [0x00, 0x7F] range, that byte // is its own RLP encoding. s.byteval = b return Byte, 0, nil case b < 0xB8: // Otherwise, if a string is 0-55 bytes long, // the RLP encoding consists of a single byte with value 0x80 plus the // length of the string followed by the string. The range of the first // byte is thus [0x80, 0xB7]. return String, uint64(b - 0x80), nil case b < 0xC0: // If a string is more than 55 bytes long, the // RLP encoding consists of a single byte with value 0xB7 plus the length // of the length of the string in binary form, followed by the length of // the string, followed by the string. For example, a length-1024 string // would be encoded as 0xB90400 followed by the string. The range of // the first byte is thus [0xB8, 0xBF]. size, err = s.readUint(b - 0xB7) return String, size, err case b < 0xF8: // If the total payload of a list // (i.e. the combined length of all its items) is 0-55 bytes long, the // RLP encoding consists of a single byte with value 0xC0 plus the length // of the list followed by the concatenation of the RLP encodings of the // items. The range of the first byte is thus [0xC0, 0xF7]. return List, uint64(b - 0xC0), nil default: // If the total payload of a list is more than 55 bytes long, // the RLP encoding consists of a single byte with value 0xF7 // plus the length of the length of the payload in binary // form, followed by the length of the payload, followed by // the concatenation of the RLP encodings of the items. The // range of the first byte is thus [0xF8, 0xFF]. size, err = s.readUint(b - 0xF7) return List, size, err } } func (s *Stream) readUint(size byte) (uint64, error) { if size == 1 { b, err := s.readByte() if err == io.EOF { err = io.ErrUnexpectedEOF } return uint64(b), err } start := int(8 - size) for i := 0; i < start; i++ { s.uintbuf[i] = 0 } err := s.readFull(s.uintbuf[start:]) return binary.BigEndian.Uint64(s.uintbuf), err } func (s *Stream) readFull(buf []byte) (err error) { s.willRead(uint64(len(buf))) var nn, n int for n < len(buf) && err == nil { nn, err = s.r.Read(buf[n:]) n += nn } if err == io.EOF { err = io.ErrUnexpectedEOF } return err } func (s *Stream) readByte() (byte, error) { s.willRead(1) b, err := s.r.ReadByte() if len(s.stack) > 0 && err == io.EOF { err = io.ErrUnexpectedEOF } return b, err } func (s *Stream) willRead(n uint64) { s.kind = -1 // rearm Kind if len(s.stack) > 0 { s.stack[len(s.stack)-1].pos += n } }