github.com/halybang/go-ethereum@v1.0.5-0.20180325041310-3b262bc1367c/rlp/encode.go (about)

     1  // Copyright 2014 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package rlp
    18  
    19  import (
    20  	"fmt"
    21  	// "github.com/wanchain/go-wanchain/common/hexutil"
    22  	"io"
    23  	"math/big"
    24  	"reflect"
    25  	"sync"
    26  )
    27  
    28  var (
    29  	// Common encoded values.
    30  	// These are useful when implementing EncodeRLP.
    31  	EmptyString = []byte{0x80}
    32  	EmptyList   = []byte{0xC0}
    33  )
    34  
    35  // Encoder is implemented by types that require custom
    36  // encoding rules or want to encode private fields.
    37  type Encoder interface {
    38  	// EncodeRLP should write the RLP encoding of its receiver to w.
    39  	// If the implementation is a pointer method, it may also be
    40  	// called for nil pointers.
    41  	//
    42  	// Implementations should generate valid RLP. The data written is
    43  	// not verified at the moment, but a future version might. It is
    44  	// recommended to write only a single value but writing multiple
    45  	// values or no value at all is also permitted.
    46  	EncodeRLP(io.Writer) error
    47  }
    48  
    49  // Encode writes the RLP encoding of val to w. Note that Encode may
    50  // perform many small writes in some cases. Consider making w
    51  // buffered.
    52  //
    53  // Encode uses the following type-dependent encoding rules:
    54  //
    55  // If the type implements the Encoder interface, Encode calls
    56  // EncodeRLP. This is true even for nil pointers, please see the
    57  // documentation for Encoder.
    58  //
    59  // To encode a pointer, the value being pointed to is encoded. For nil
    60  // pointers, Encode will encode the zero value of the type. A nil
    61  // pointer to a struct type always encodes as an empty RLP list.
    62  // A nil pointer to an array encodes as an empty list (or empty string
    63  // if the array has element type byte).
    64  //
    65  // Struct values are encoded as an RLP list of all their encoded
    66  // public fields. Recursive struct types are supported.
    67  //
    68  // To encode slices and arrays, the elements are encoded as an RLP
    69  // list of the value's elements. Note that arrays and slices with
    70  // element type uint8 or byte are always encoded as an RLP string.
    71  //
    72  // A Go string is encoded as an RLP string.
    73  //
    74  // An unsigned integer value is encoded as an RLP string. Zero always
    75  // encodes as an empty RLP string. Encode also supports *big.Int.
    76  //
    77  // An interface value encodes as the value contained in the interface.
    78  //
    79  // Boolean values are not supported, nor are signed integers, floating
    80  // point numbers, maps, channels and functions.
    81  func Encode(w io.Writer, val interface{}) error {
    82  	if outer, ok := w.(*encbuf); ok {
    83  		// Encode was called by some type's EncodeRLP.
    84  		// Avoid copying by writing to the outer encbuf directly.
    85  		return outer.encode(val)
    86  	}
    87  	eb := encbufPool.Get().(*encbuf)
    88  	defer encbufPool.Put(eb)
    89  	eb.reset()
    90  	if err := eb.encode(val); err != nil {
    91  		return err
    92  	}
    93  
    94  	return eb.toWriter(w)
    95  }
    96  
    97  // EncodeBytes returns the RLP encoding of val.
    98  // Please see the documentation of Encode for the encoding rules.
    99  func EncodeToBytes(val interface{}) ([]byte, error) {
   100  	eb := encbufPool.Get().(*encbuf)
   101  	defer encbufPool.Put(eb)
   102  	eb.reset()
   103  	if err := eb.encode(val); err != nil {
   104  		return nil, err
   105  	}
   106  	return eb.toBytes(), nil
   107  }
   108  
   109  // EncodeReader returns a reader from which the RLP encoding of val
   110  // can be read. The returned size is the total size of the encoded
   111  // data.
   112  //
   113  // Please see the documentation of Encode for the encoding rules.
   114  func EncodeToReader(val interface{}) (size int, r io.Reader, err error) {
   115  	eb := encbufPool.Get().(*encbuf)
   116  	eb.reset()
   117  	if err := eb.encode(val); err != nil {
   118  		return 0, nil, err
   119  	}
   120  	return eb.size(), &encReader{buf: eb}, nil
   121  }
   122  
   123  type encbuf struct {
   124  	str     []byte      // string data, contains everything except list headers
   125  	lheads  []*listhead // all list headers
   126  	lhsize  int         // sum of sizes of all encoded list headers
   127  	sizebuf []byte      // 9-byte auxiliary buffer for uint encoding
   128  }
   129  
   130  type listhead struct {
   131  	offset int // index of this header in string data
   132  	size   int // total size of encoded data (including list headers)
   133  }
   134  
   135  // encode writes head to the given buffer, which must be at least
   136  // 9 bytes long. It returns the encoded bytes.
   137  func (head *listhead) encode(buf []byte) []byte {
   138  	return buf[:puthead(buf, 0xC0, 0xF7, uint64(head.size))]
   139  }
   140  
   141  // headsize returns the size of a list or string header
   142  // for a value of the given size.
   143  func headsize(size uint64) int {
   144  	if size < 56 {
   145  		return 1
   146  	}
   147  	return 1 + intsize(size)
   148  }
   149  
   150  // puthead writes a list or string header to buf.
   151  // buf must be at least 9 bytes long.
   152  func puthead(buf []byte, smalltag, largetag byte, size uint64) int {
   153  	if size < 56 {
   154  		buf[0] = smalltag + byte(size)
   155  		return 1
   156  	} else {
   157  		sizesize := putint(buf[1:], size)
   158  		buf[0] = largetag + byte(sizesize)
   159  		return sizesize + 1
   160  	}
   161  }
   162  
   163  // encbufs are pooled.
   164  var encbufPool = sync.Pool{
   165  	New: func() interface{} { return &encbuf{sizebuf: make([]byte, 9)} },
   166  }
   167  
   168  func (w *encbuf) reset() {
   169  	w.lhsize = 0
   170  	if w.str != nil {
   171  		w.str = w.str[:0]
   172  	}
   173  	if w.lheads != nil {
   174  		w.lheads = w.lheads[:0]
   175  	}
   176  }
   177  
   178  // encbuf implements io.Writer so it can be passed it into EncodeRLP.
   179  func (w *encbuf) Write(b []byte) (int, error) {
   180  	w.str = append(w.str, b...)
   181  	return len(b), nil
   182  }
   183  
   184  func (w *encbuf) encode(val interface{}) error {
   185  	rval := reflect.ValueOf(val)
   186  	// fmt.Println(rval.Type())
   187  	ti, err := cachedTypeInfo(rval.Type(), tags{})
   188  	if err != nil {
   189  		return err
   190  	}
   191  	return ti.writer(rval, w)
   192  }
   193  
   194  func (w *encbuf) encodeStringHeader(size int) {
   195  	if size < 56 {
   196  		w.str = append(w.str, 0x80+byte(size))
   197  	} else {
   198  		// TODO: encode to w.str directly
   199  		sizesize := putint(w.sizebuf[1:], uint64(size))
   200  		w.sizebuf[0] = 0xB7 + byte(sizesize)
   201  		w.str = append(w.str, w.sizebuf[:sizesize+1]...)
   202  	}
   203  }
   204  
   205  func (w *encbuf) encodeString(b []byte) {
   206  	if len(b) == 1 && b[0] <= 0x7F {
   207  		// fits single byte, no string header
   208  		w.str = append(w.str, b[0])
   209  	} else {
   210  		w.encodeStringHeader(len(b))
   211  		w.str = append(w.str, b...)
   212  	}
   213  }
   214  
   215  func (w *encbuf) list() *listhead {
   216  	lh := &listhead{offset: len(w.str), size: w.lhsize}
   217  	w.lheads = append(w.lheads, lh)
   218  	return lh
   219  }
   220  
   221  func (w *encbuf) listEnd(lh *listhead) {
   222  	lh.size = w.size() - lh.offset - lh.size
   223  	if lh.size < 56 {
   224  		w.lhsize += 1 // length encoded into kind tag
   225  	} else {
   226  		w.lhsize += 1 + intsize(uint64(lh.size))
   227  	}
   228  }
   229  
   230  func (w *encbuf) size() int {
   231  	return len(w.str) + w.lhsize
   232  }
   233  
   234  func (w *encbuf) toBytes() []byte {
   235  	out := make([]byte, w.size())
   236  	strpos := 0
   237  	pos := 0
   238  	for _, head := range w.lheads {
   239  		// write string data before header
   240  		n := copy(out[pos:], w.str[strpos:head.offset])
   241  		pos += n
   242  		strpos += n
   243  		// write the header
   244  		enc := head.encode(out[pos:])
   245  		pos += len(enc)
   246  	}
   247  	// copy string data after the last list header
   248  	copy(out[pos:], w.str[strpos:])
   249  	return out
   250  }
   251  
   252  func (w *encbuf) toWriter(out io.Writer) (err error) {
   253  	strpos := 0
   254  	for _, head := range w.lheads {
   255  		// write string data before header
   256  		if head.offset-strpos > 0 {
   257  			n, err := out.Write(w.str[strpos:head.offset])
   258  			strpos += n
   259  			if err != nil {
   260  				return err
   261  			}
   262  		}
   263  		// write the header
   264  		enc := head.encode(w.sizebuf)
   265  		if _, err = out.Write(enc); err != nil {
   266  			return err
   267  		}
   268  	}
   269  	if strpos < len(w.str) {
   270  		// write string data after the last list header
   271  		_, err = out.Write(w.str[strpos:])
   272  	}
   273  	// fmt.Printf(hexutil.Encode(w.str))
   274  
   275  	return err
   276  }
   277  
   278  // encReader is the io.Reader returned by EncodeToReader.
   279  // It releases its encbuf at EOF.
   280  type encReader struct {
   281  	buf    *encbuf // the buffer we're reading from. this is nil when we're at EOF.
   282  	lhpos  int     // index of list header that we're reading
   283  	strpos int     // current position in string buffer
   284  	piece  []byte  // next piece to be read
   285  }
   286  
   287  func (r *encReader) Read(b []byte) (n int, err error) {
   288  	for {
   289  		if r.piece = r.next(); r.piece == nil {
   290  			// Put the encode buffer back into the pool at EOF when it
   291  			// is first encountered. Subsequent calls still return EOF
   292  			// as the error but the buffer is no longer valid.
   293  			if r.buf != nil {
   294  				encbufPool.Put(r.buf)
   295  				r.buf = nil
   296  			}
   297  			return n, io.EOF
   298  		}
   299  		nn := copy(b[n:], r.piece)
   300  		n += nn
   301  		if nn < len(r.piece) {
   302  			// piece didn't fit, see you next time.
   303  			r.piece = r.piece[nn:]
   304  			return n, nil
   305  		}
   306  		r.piece = nil
   307  	}
   308  }
   309  
   310  // next returns the next piece of data to be read.
   311  // it returns nil at EOF.
   312  func (r *encReader) next() []byte {
   313  	switch {
   314  	case r.buf == nil:
   315  		return nil
   316  
   317  	case r.piece != nil:
   318  		// There is still data available for reading.
   319  		return r.piece
   320  
   321  	case r.lhpos < len(r.buf.lheads):
   322  		// We're before the last list header.
   323  		head := r.buf.lheads[r.lhpos]
   324  		sizebefore := head.offset - r.strpos
   325  		if sizebefore > 0 {
   326  			// String data before header.
   327  			p := r.buf.str[r.strpos:head.offset]
   328  			r.strpos += sizebefore
   329  			return p
   330  		} else {
   331  			r.lhpos++
   332  			return head.encode(r.buf.sizebuf)
   333  		}
   334  
   335  	case r.strpos < len(r.buf.str):
   336  		// String data at the end, after all list headers.
   337  		p := r.buf.str[r.strpos:]
   338  		r.strpos = len(r.buf.str)
   339  		return p
   340  
   341  	default:
   342  		return nil
   343  	}
   344  }
   345  
   346  var (
   347  	encoderInterface = reflect.TypeOf(new(Encoder)).Elem()
   348  	big0             = big.NewInt(0)
   349  )
   350  
   351  // makeWriter creates a writer function for the given type.
   352  func makeWriter(typ reflect.Type, ts tags) (writer, error) {
   353  	kind := typ.Kind()
   354  	switch {
   355  	case typ == rawValueType:
   356  		return writeRawValue, nil
   357  	case typ.Implements(encoderInterface):
   358  		return writeEncoder, nil
   359  	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(encoderInterface):
   360  		return writeEncoderNoPtr, nil
   361  	case kind == reflect.Interface:
   362  		return writeInterface, nil
   363  	case typ.AssignableTo(reflect.PtrTo(bigInt)):
   364  		return writeBigIntPtr, nil
   365  	case typ.AssignableTo(bigInt):
   366  		return writeBigIntNoPtr, nil
   367  	case isUint(kind):
   368  		return writeUint, nil
   369  	case kind == reflect.Bool:
   370  		return writeBool, nil
   371  	case kind == reflect.String:
   372  		return writeString, nil
   373  	case kind == reflect.Slice && isByte(typ.Elem()):
   374  		return writeBytes, nil
   375  	case kind == reflect.Array && isByte(typ.Elem()):
   376  		return writeByteArray, nil
   377  	case kind == reflect.Slice || kind == reflect.Array:
   378  		return makeSliceWriter(typ, ts)
   379  	case kind == reflect.Struct:
   380  		return makeStructWriter(typ)
   381  	case kind == reflect.Ptr:
   382  		return makePtrWriter(typ)
   383  	default:
   384  		return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
   385  	}
   386  }
   387  
   388  func isByte(typ reflect.Type) bool {
   389  	return typ.Kind() == reflect.Uint8 && !typ.Implements(encoderInterface)
   390  }
   391  
   392  func writeRawValue(val reflect.Value, w *encbuf) error {
   393  	w.str = append(w.str, val.Bytes()...)
   394  	return nil
   395  }
   396  
   397  func writeUint(val reflect.Value, w *encbuf) error {
   398  	i := val.Uint()
   399  	if i == 0 {
   400  		w.str = append(w.str, 0x80)
   401  	} else if i < 128 {
   402  		// fits single byte
   403  		w.str = append(w.str, byte(i))
   404  	} else {
   405  		// TODO: encode int to w.str directly
   406  		s := putint(w.sizebuf[1:], i)
   407  		w.sizebuf[0] = 0x80 + byte(s)
   408  		w.str = append(w.str, w.sizebuf[:s+1]...)
   409  	}
   410  	return nil
   411  }
   412  
   413  func writeBool(val reflect.Value, w *encbuf) error {
   414  	if val.Bool() {
   415  		w.str = append(w.str, 0x01)
   416  	} else {
   417  		w.str = append(w.str, 0x80)
   418  	}
   419  	return nil
   420  }
   421  
   422  func writeBigIntPtr(val reflect.Value, w *encbuf) error {
   423  	ptr := val.Interface().(*big.Int)
   424  	if ptr == nil {
   425  		w.str = append(w.str, 0x80)
   426  		return nil
   427  	}
   428  	return writeBigInt(ptr, w)
   429  }
   430  
   431  func writeBigIntNoPtr(val reflect.Value, w *encbuf) error {
   432  	i := val.Interface().(big.Int)
   433  	return writeBigInt(&i, w)
   434  }
   435  
   436  func writeBigInt(i *big.Int, w *encbuf) error {
   437  	if cmp := i.Cmp(big0); cmp == -1 {
   438  		return fmt.Errorf("rlp: cannot encode negative *big.Int")
   439  	} else if cmp == 0 {
   440  		w.str = append(w.str, 0x80)
   441  	} else {
   442  		w.encodeString(i.Bytes())
   443  	}
   444  	return nil
   445  }
   446  
   447  func writeBytes(val reflect.Value, w *encbuf) error {
   448  	w.encodeString(val.Bytes())
   449  	return nil
   450  }
   451  
   452  func writeByteArray(val reflect.Value, w *encbuf) error {
   453  	if !val.CanAddr() {
   454  		// Slice requires the value to be addressable.
   455  		// Make it addressable by copying.
   456  		copy := reflect.New(val.Type()).Elem()
   457  		copy.Set(val)
   458  		val = copy
   459  	}
   460  	size := val.Len()
   461  	slice := val.Slice(0, size).Bytes()
   462  	w.encodeString(slice)
   463  	return nil
   464  }
   465  
   466  func writeString(val reflect.Value, w *encbuf) error {
   467  	s := val.String()
   468  	if len(s) == 1 && s[0] <= 0x7f {
   469  		// fits single byte, no string header
   470  		w.str = append(w.str, s[0])
   471  	} else {
   472  		w.encodeStringHeader(len(s))
   473  		w.str = append(w.str, s...)
   474  	}
   475  	return nil
   476  }
   477  
   478  func writeEncoder(val reflect.Value, w *encbuf) error {
   479  	return val.Interface().(Encoder).EncodeRLP(w)
   480  }
   481  
   482  // writeEncoderNoPtr handles non-pointer values that implement Encoder
   483  // with a pointer receiver.
   484  func writeEncoderNoPtr(val reflect.Value, w *encbuf) error {
   485  	if !val.CanAddr() {
   486  		// We can't get the address. It would be possible to make the
   487  		// value addressable by creating a shallow copy, but this
   488  		// creates other problems so we're not doing it (yet).
   489  		//
   490  		// package json simply doesn't call MarshalJSON for cases like
   491  		// this, but encodes the value as if it didn't implement the
   492  		// interface. We don't want to handle it that way.
   493  		return fmt.Errorf("rlp: game over: unadressable value of type %v, EncodeRLP is pointer method", val.Type())
   494  	}
   495  	return val.Addr().Interface().(Encoder).EncodeRLP(w)
   496  }
   497  
   498  func writeInterface(val reflect.Value, w *encbuf) error {
   499  	if val.IsNil() {
   500  		// Write empty list. This is consistent with the previous RLP
   501  		// encoder that we had and should therefore avoid any
   502  		// problems.
   503  		w.str = append(w.str, 0xC0)
   504  		return nil
   505  	}
   506  	eval := val.Elem()
   507  	ti, err := cachedTypeInfo(eval.Type(), tags{})
   508  	if err != nil {
   509  		return err
   510  	}
   511  	return ti.writer(eval, w)
   512  }
   513  
   514  func makeSliceWriter(typ reflect.Type, ts tags) (writer, error) {
   515  	etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{})
   516  	if err != nil {
   517  		return nil, err
   518  	}
   519  	writer := func(val reflect.Value, w *encbuf) error {
   520  		if !ts.tail {
   521  			defer w.listEnd(w.list())
   522  		}
   523  		vlen := val.Len()
   524  		for i := 0; i < vlen; i++ {
   525  			if err := etypeinfo.writer(val.Index(i), w); err != nil {
   526  				return err
   527  			}
   528  		}
   529  		return nil
   530  	}
   531  	return writer, nil
   532  }
   533  
   534  func makeStructWriter(typ reflect.Type) (writer, error) {
   535  	fields, err := structFields(typ)
   536  	if err != nil {
   537  		return nil, err
   538  	}
   539  	writer := func(val reflect.Value, w *encbuf) error {
   540  		lh := w.list()
   541  		for _, f := range fields {
   542  			if err := f.info.writer(val.Field(f.index), w); err != nil {
   543  				return err
   544  			}
   545  		}
   546  		w.listEnd(lh)
   547  		return nil
   548  	}
   549  	return writer, nil
   550  }
   551  
   552  func makePtrWriter(typ reflect.Type) (writer, error) {
   553  	etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{})
   554  	if err != nil {
   555  		return nil, err
   556  	}
   557  
   558  	// determine nil pointer handler
   559  	var nilfunc func(*encbuf) error
   560  	kind := typ.Elem().Kind()
   561  	switch {
   562  	case kind == reflect.Array && isByte(typ.Elem().Elem()):
   563  		nilfunc = func(w *encbuf) error {
   564  			w.str = append(w.str, 0x80)
   565  			return nil
   566  		}
   567  	case kind == reflect.Struct || kind == reflect.Array:
   568  		nilfunc = func(w *encbuf) error {
   569  			// encoding the zero value of a struct/array could trigger
   570  			// infinite recursion, avoid that.
   571  			w.listEnd(w.list())
   572  			return nil
   573  		}
   574  	default:
   575  		zero := reflect.Zero(typ.Elem())
   576  		nilfunc = func(w *encbuf) error {
   577  			return etypeinfo.writer(zero, w)
   578  		}
   579  	}
   580  
   581  	writer := func(val reflect.Value, w *encbuf) error {
   582  		if val.IsNil() {
   583  			return nilfunc(w)
   584  		} else {
   585  			return etypeinfo.writer(val.Elem(), w)
   586  		}
   587  	}
   588  	return writer, err
   589  }
   590  
   591  // putint writes i to the beginning of b in big endian byte
   592  // order, using the least number of bytes needed to represent i.
   593  func putint(b []byte, i uint64) (size int) {
   594  	switch {
   595  	case i < (1 << 8):
   596  		b[0] = byte(i)
   597  		return 1
   598  	case i < (1 << 16):
   599  		b[0] = byte(i >> 8)
   600  		b[1] = byte(i)
   601  		return 2
   602  	case i < (1 << 24):
   603  		b[0] = byte(i >> 16)
   604  		b[1] = byte(i >> 8)
   605  		b[2] = byte(i)
   606  		return 3
   607  	case i < (1 << 32):
   608  		b[0] = byte(i >> 24)
   609  		b[1] = byte(i >> 16)
   610  		b[2] = byte(i >> 8)
   611  		b[3] = byte(i)
   612  		return 4
   613  	case i < (1 << 40):
   614  		b[0] = byte(i >> 32)
   615  		b[1] = byte(i >> 24)
   616  		b[2] = byte(i >> 16)
   617  		b[3] = byte(i >> 8)
   618  		b[4] = byte(i)
   619  		return 5
   620  	case i < (1 << 48):
   621  		b[0] = byte(i >> 40)
   622  		b[1] = byte(i >> 32)
   623  		b[2] = byte(i >> 24)
   624  		b[3] = byte(i >> 16)
   625  		b[4] = byte(i >> 8)
   626  		b[5] = byte(i)
   627  		return 6
   628  	case i < (1 << 56):
   629  		b[0] = byte(i >> 48)
   630  		b[1] = byte(i >> 40)
   631  		b[2] = byte(i >> 32)
   632  		b[3] = byte(i >> 24)
   633  		b[4] = byte(i >> 16)
   634  		b[5] = byte(i >> 8)
   635  		b[6] = byte(i)
   636  		return 7
   637  	default:
   638  		b[0] = byte(i >> 56)
   639  		b[1] = byte(i >> 48)
   640  		b[2] = byte(i >> 40)
   641  		b[3] = byte(i >> 32)
   642  		b[4] = byte(i >> 24)
   643  		b[5] = byte(i >> 16)
   644  		b[6] = byte(i >> 8)
   645  		b[7] = byte(i)
   646  		return 8
   647  	}
   648  }
   649  
   650  // intsize computes the minimum number of bytes required to store i.
   651  func intsize(i uint64) (size int) {
   652  	for size = 1; ; size++ {
   653  		if i >>= 8; i == 0 {
   654  			return size
   655  		}
   656  	}
   657  }