package rlp import ( "fmt" "io" "math/big" "reflect" "sync" ) var ( // Common encoded values. // These are useful when implementing EncodeRLP. EmptyString = []byte{0x80} EmptyList = []byte{0xC0} ) // Encoder is implemented by types that require custom // encoding rules or want to encode private fields. type Encoder interface { // EncodeRLP should write the RLP encoding of its receiver to w. // If the implementation is a pointer method, it may also be // called for nil pointers. // // Implementations should generate valid RLP. The data written is // not verified at the moment, but a future version might. It is // recommended to write only a single value but writing multiple // values or no value at all is also permitted. EncodeRLP(io.Writer) error } // Encode writes the RLP encoding of val to w. Note that Encode may // perform many small writes in some cases. Consider making w // buffered. // // Encode uses the following type-dependent encoding rules: // // If the type implements the Encoder interface, Encode calls // EncodeRLP. This is true even for nil pointers, please see the // documentation for Encoder. // // To encode a pointer, the value being pointed to is encoded. For nil // pointers, Encode will encode the zero value of the type. A nil // pointer to a struct type always encodes as an empty RLP list. // A nil pointer to an array encodes as an empty list (or empty string // if the array has element type byte). // // Struct values are encoded as an RLP list of all their encoded // public fields. Recursive struct types are supported. // // To encode slices and arrays, the elements are encoded as an RLP // list of the value's elements. Note that arrays and slices with // element type uint8 or byte are always encoded as an RLP string. // // A Go string is encoded as an RLP string. // // An unsigned integer value is encoded as an RLP string. Zero always // encodes as an empty RLP string. Encode also supports *big.Int. // // An interface value encodes as the value contained in the interface. // // Boolean values are not supported, nor are signed integers, floating // point numbers, maps, channels and functions. func Encode(w io.Writer, val interface{}) error { if outer, ok := w.(*encbuf); ok { // Encode was called by some type's EncodeRLP. // Avoid copying by writing to the outer encbuf directly. return outer.encode(val) } eb := encbufPool.Get().(*encbuf) eb.reset() defer encbufPool.Put(eb) if err := eb.encode(val); err != nil { return err } return eb.toWriter(w) } // EncodeBytes returns the RLP encoding of val. // Please see the documentation of Encode for the encoding rules. func EncodeToBytes(val interface{}) ([]byte, error) { eb := encbufPool.Get().(*encbuf) eb.reset() defer encbufPool.Put(eb) if err := eb.encode(val); err != nil { return nil, err } return eb.toBytes(), nil } // EncodeReader returns a reader from which the RLP encoding of val // can be read. The returned size is the total size of the encoded // data. // // Please see the documentation of Encode for the encoding rules. func EncodeToReader(val interface{}) (size int, r io.Reader, err error) { eb := encbufPool.Get().(*encbuf) eb.reset() if err := eb.encode(val); err != nil { return 0, nil, err } return eb.size(), &encReader{buf: eb}, nil } type encbuf struct { str []byte // string data, contains everything except list headers lheads []*listhead // all list headers lhsize int // sum of sizes of all encoded list headers sizebuf []byte // 9-byte auxiliary buffer for uint encoding } type listhead struct { offset int // index of this header in string data size int // total size of encoded data (including list headers) } // encode writes head to the given buffer, which must be at least // 9 bytes long. It returns the encoded bytes. func (head *listhead) encode(buf []byte) []byte { return buf[:puthead(buf, 0xC0, 0xF7, uint64(head.size))] } // headsize returns the size of a list or string header // for a value of the given size. func headsize(size uint64) int { if size < 56 { return 1 } return 1 + intsize(size) } // puthead writes a list or string header to buf. // buf must be at least 9 bytes long. func puthead(buf []byte, smalltag, largetag byte, size uint64) int { if size < 56 { buf[0] = smalltag + byte(size) return 1 } else { sizesize := putint(buf[1:], size) buf[0] = largetag + byte(sizesize) return sizesize + 1 } } // encbufs are pooled. var encbufPool = sync.Pool{ New: func() interface{} { return &encbuf{sizebuf: make([]byte, 9)} }, } func (w *encbuf) reset() { w.lhsize = 0 if w.str != nil { w.str = w.str[:0] } if w.lheads != nil { w.lheads = w.lheads[:0] } } // encbuf implements io.Writer so it can be passed it into EncodeRLP. func (w *encbuf) Write(b []byte) (int, error) { w.str = append(w.str, b...) return len(b), nil } func (w *encbuf) encode(val interface{}) error { rval := reflect.ValueOf(val) ti, err := cachedTypeInfo(rval.Type(), tags{}) if err != nil { return err } return ti.writer(rval, w) } func (w *encbuf) encodeStringHeader(size int) { if size < 56 { w.str = append(w.str, 0x80+byte(size)) } else { // TODO: encode to w.str directly sizesize := putint(w.sizebuf[1:], uint64(size)) w.sizebuf[0] = 0xB7 + byte(sizesize) w.str = append(w.str, w.sizebuf[:sizesize+1]...) } } func (w *encbuf) encodeString(b []byte) { if len(b) == 1 && b[0] <= 0x7F { // fits single byte, no string header w.str = append(w.str, b[0]) } else { w.encodeStringHeader(len(b)) w.str = append(w.str, b...) } } func (w *encbuf) list() *listhead { lh := &listhead{offset: len(w.str), size: w.lhsize} w.lheads = append(w.lheads, lh) return lh } func (w *encbuf) listEnd(lh *listhead) { lh.size = w.size() - lh.offset - lh.size if lh.size < 56 { w.lhsize += 1 // length encoded into kind tag } else { w.lhsize += 1 + intsize(uint64(lh.size)) } } func (w *encbuf) size() int { return len(w.str) + w.lhsize } func (w *encbuf) toBytes() []byte { out := make([]byte, w.size()) strpos := 0 pos := 0 for _, head := range w.lheads { // write string data before header n := copy(out[pos:], w.str[strpos:head.offset]) pos += n strpos += n // write the header enc := head.encode(out[pos:]) pos += len(enc) } // copy string data after the last list header copy(out[pos:], w.str[strpos:]) return out } func (w *encbuf) toWriter(out io.Writer) (err error) { strpos := 0 for _, head := range w.lheads { // write string data before header if head.offset-strpos > 0 { n, err := out.Write(w.str[strpos:head.offset]) strpos += n if err != nil { return err } } // write the header enc := head.encode(w.sizebuf) if _, err = out.Write(enc); err != nil { return err } } if strpos < len(w.str) { // write string data after the last list header _, err = out.Write(w.str[strpos:]) } return err } // encReader is the io.Reader returned by EncodeToReader. // It releases its encbuf at EOF. type encReader struct { buf *encbuf // the buffer we're reading from. this is nil when we're at EOF. lhpos int // index of list header that we're reading strpos int // current position in string buffer piece []byte // next piece to be read } func (r *encReader) Read(b []byte) (n int, err error) { for { if r.piece = r.next(); r.piece == nil { encbufPool.Put(r.buf) r.buf = nil return n, io.EOF } nn := copy(b[n:], r.piece) n += nn if nn < len(r.piece) { // piece didn't fit, see you next time. r.piece = r.piece[nn:] return n, nil } r.piece = nil } panic("not reached") } // next returns the next piece of data to be read. // it returns nil at EOF. func (r *encReader) next() []byte { switch { case r.buf == nil: return nil case r.piece != nil: // There is still data available for reading. return r.piece case r.lhpos < len(r.buf.lheads): // We're before the last list header. head := r.buf.lheads[r.lhpos] sizebefore := head.offset - r.strpos if sizebefore > 0 { // String data before header. p := r.buf.str[r.strpos:head.offset] r.strpos += sizebefore return p } else { r.lhpos++ return head.encode(r.buf.sizebuf) } case r.strpos < len(r.buf.str): // String data at the end, after all list headers. p := r.buf.str[r.strpos:] r.strpos = len(r.buf.str) return p default: return nil } } var ( encoderInterface = reflect.TypeOf(new(Encoder)).Elem() big0 = big.NewInt(0) ) // makeWriter creates a writer function for the given type. func makeWriter(typ reflect.Type) (writer, error) { kind := typ.Kind() switch { case typ.Implements(encoderInterface): return writeEncoder, nil case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(encoderInterface): return writeEncoderNoPtr, nil case kind == reflect.Interface: return writeInterface, nil case typ.AssignableTo(reflect.PtrTo(bigInt)): return writeBigIntPtr, nil case typ.AssignableTo(bigInt): return writeBigIntNoPtr, nil case isUint(kind): return writeUint, nil case kind == reflect.String: return writeString, nil case kind == reflect.Slice && isByte(typ.Elem()): return writeBytes, nil case kind == reflect.Array && isByte(typ.Elem()): return writeByteArray, nil case kind == reflect.Slice || kind == reflect.Array: return makeSliceWriter(typ) case kind == reflect.Struct: return makeStructWriter(typ) case kind == reflect.Ptr: return makePtrWriter(typ) default: return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ) } } func isByte(typ reflect.Type) bool { return typ.Kind() == reflect.Uint8 && !typ.Implements(encoderInterface) } func writeUint(val reflect.Value, w *encbuf) error { i := val.Uint() if i == 0 { w.str = append(w.str, 0x80) } else if i < 128 { // fits single byte w.str = append(w.str, byte(i)) } else { // TODO: encode int to w.str directly s := putint(w.sizebuf[1:], i) w.sizebuf[0] = 0x80 + byte(s) w.str = append(w.str, w.sizebuf[:s+1]...) } return nil } func writeBigIntPtr(val reflect.Value, w *encbuf) error { ptr := val.Interface().(*big.Int) if ptr == nil { w.str = append(w.str, 0x80) return nil } return writeBigInt(ptr, w) } func writeBigIntNoPtr(val reflect.Value, w *encbuf) error { i := val.Interface().(big.Int) return writeBigInt(&i, w) } func writeBigInt(i *big.Int, w *encbuf) error { if cmp := i.Cmp(big0); cmp == -1 { return fmt.Errorf("rlp: cannot encode negative *big.Int") } else if cmp == 0 { w.str = append(w.str, 0x80) } else { w.encodeString(i.Bytes()) } return nil } func writeBytes(val reflect.Value, w *encbuf) error { w.encodeString(val.Bytes()) return nil } func writeByteArray(val reflect.Value, w *encbuf) error { if !val.CanAddr() { // Slice requires the value to be addressable. // Make it addressable by copying. copy := reflect.New(val.Type()).Elem() copy.Set(val) val = copy } size := val.Len() slice := val.Slice(0, size).Bytes() w.encodeString(slice) return nil } func writeString(val reflect.Value, w *encbuf) error { s := val.String() if len(s) == 1 && s[0] <= 0x7f { // fits single byte, no string header w.str = append(w.str, s[0]) } else { w.encodeStringHeader(len(s)) w.str = append(w.str, s...) } return nil } func writeEncoder(val reflect.Value, w *encbuf) error { return val.Interface().(Encoder).EncodeRLP(w) } // writeEncoderNoPtr handles non-pointer values that implement Encoder // with a pointer receiver. func writeEncoderNoPtr(val reflect.Value, w *encbuf) error { if !val.CanAddr() { // We can't get the address. It would be possible make the // value addressable by creating a shallow copy, but this // creates other problems so we're not doing it (yet). // // package json simply doesn't call MarshalJSON for cases like // this, but encodes the value as if it didn't implement the // interface. We don't want to handle it that way. return fmt.Errorf("rlp: game over: unadressable value of type %v, EncodeRLP is pointer method", val.Type()) } return val.Addr().Interface().(Encoder).EncodeRLP(w) } func writeInterface(val reflect.Value, w *encbuf) error { if val.IsNil() { // Write empty list. This is consistent with the previous RLP // encoder that we had and should therefore avoid any // problems. w.str = append(w.str, 0xC0) return nil } eval := val.Elem() ti, err := cachedTypeInfo(eval.Type(), tags{}) if err != nil { return err } return ti.writer(eval, w) } func makeSliceWriter(typ reflect.Type) (writer, error) { etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{}) if err != nil { return nil, err } writer := func(val reflect.Value, w *encbuf) error { lh := w.list() vlen := val.Len() for i := 0; i < vlen; i++ { if err := etypeinfo.writer(val.Index(i), w); err != nil { return err } } w.listEnd(lh) return nil } return writer, nil } func makeStructWriter(typ reflect.Type) (writer, error) { fields, err := structFields(typ) if err != nil { return nil, err } writer := func(val reflect.Value, w *encbuf) error { lh := w.list() for _, f := range fields { if err := f.info.writer(val.Field(f.index), w); err != nil { return err } } w.listEnd(lh) return nil } return writer, nil } func makePtrWriter(typ reflect.Type) (writer, error) { etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{}) if err != nil { return nil, err } // determine nil pointer handler var nilfunc func(*encbuf) error kind := typ.Elem().Kind() switch { case kind == reflect.Array && isByte(typ.Elem().Elem()): nilfunc = func(w *encbuf) error { w.str = append(w.str, 0x80) return nil } case kind == reflect.Struct || kind == reflect.Array: nilfunc = func(w *encbuf) error { // encoding the zero value of a struct/array could trigger // infinite recursion, avoid that. w.listEnd(w.list()) return nil } default: zero := reflect.Zero(typ.Elem()) nilfunc = func(w *encbuf) error { return etypeinfo.writer(zero, w) } } writer := func(val reflect.Value, w *encbuf) error { if val.IsNil() { return nilfunc(w) } else { return etypeinfo.writer(val.Elem(), w) } } return writer, err } // putint writes i to the beginning of b in with big endian byte // order, using the least number of bytes needed to represent i. func putint(b []byte, i uint64) (size int) { switch { case i < (1 << 8): b[0] = byte(i) return 1 case i < (1 << 16): b[0] = byte(i >> 8) b[1] = byte(i) return 2 case i < (1 << 24): b[0] = byte(i >> 16) b[1] = byte(i >> 8) b[2] = byte(i) return 3 case i < (1 << 32): b[0] = byte(i >> 24) b[1] = byte(i >> 16) b[2] = byte(i >> 8) b[3] = byte(i) return 4 case i < (1 << 40): b[0] = byte(i >> 32) b[1] = byte(i >> 24) b[2] = byte(i >> 16) b[3] = byte(i >> 8) b[4] = byte(i) return 5 case i < (1 << 48): b[0] = byte(i >> 40) b[1] = byte(i >> 32) b[2] = byte(i >> 24) b[3] = byte(i >> 16) b[4] = byte(i >> 8) b[5] = byte(i) return 6 case i < (1 << 56): b[0] = byte(i >> 48) b[1] = byte(i >> 40) b[2] = byte(i >> 32) b[3] = byte(i >> 24) b[4] = byte(i >> 16) b[5] = byte(i >> 8) b[6] = byte(i) return 7 default: b[0] = byte(i >> 56) b[1] = byte(i >> 48) b[2] = byte(i >> 40) b[3] = byte(i >> 32) b[4] = byte(i >> 24) b[5] = byte(i >> 16) b[6] = byte(i >> 8) b[7] = byte(i) return 8 } } // intsize computes the minimum number of bytes required to store i. func intsize(i uint64) (size int) { for size = 1; ; size++ { if i >>= 8; i == 0 { return size } } panic("not reached") }