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 }