Minh Doan
6 years ago
parent
343f5f5f46
commit
4ea3c61ecf
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,49 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
) |
||||
|
||||
type structWithTail struct { |
||||
A, B uint |
||||
C []uint `rlp:"tail"` |
||||
} |
||||
|
||||
func ExampleDecode_structTagTail() { |
||||
// In this example, the "tail" struct tag is used to decode lists of
|
||||
// differing length into a struct.
|
||||
var val structWithTail |
||||
|
||||
err := Decode(bytes.NewReader([]byte{0xC4, 0x01, 0x02, 0x03, 0x04}), &val) |
||||
fmt.Printf("with 4 elements: err=%v val=%v\n", err, val) |
||||
|
||||
err = Decode(bytes.NewReader([]byte{0xC6, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}), &val) |
||||
fmt.Printf("with 6 elements: err=%v val=%v\n", err, val) |
||||
|
||||
// Note that at least two list elements must be present to
|
||||
// fill fields A and B:
|
||||
err = Decode(bytes.NewReader([]byte{0xC1, 0x01}), &val) |
||||
fmt.Printf("with 1 element: err=%q\n", err) |
||||
|
||||
// Output:
|
||||
// with 4 elements: err=<nil> val={1 2 [3 4]}
|
||||
// with 6 elements: err=<nil> val={1 2 [3 4 5 6]}
|
||||
// with 1 element: err="rlp: too few elements for rlp.structWithTail"
|
||||
} |
||||
@ -0,0 +1,819 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/hex" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"math/big" |
||||
"reflect" |
||||
"strings" |
||||
"testing" |
||||
) |
||||
|
||||
func TestStreamKind(t *testing.T) { |
||||
tests := []struct { |
||||
input string |
||||
wantKind Kind |
||||
wantLen uint64 |
||||
}{ |
||||
{"00", Byte, 0}, |
||||
{"01", Byte, 0}, |
||||
{"7F", Byte, 0}, |
||||
{"80", String, 0}, |
||||
{"B7", String, 55}, |
||||
{"B90400", String, 1024}, |
||||
{"BFFFFFFFFFFFFFFFFF", String, ^uint64(0)}, |
||||
{"C0", List, 0}, |
||||
{"C8", List, 8}, |
||||
{"F7", List, 55}, |
||||
{"F90400", List, 1024}, |
||||
{"FFFFFFFFFFFFFFFFFF", List, ^uint64(0)}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
// using plainReader to inhibit input limit errors.
|
||||
s := NewStream(newPlainReader(unhex(test.input)), 0) |
||||
kind, len, err := s.Kind() |
||||
if err != nil { |
||||
t.Errorf("test %d: Kind returned error: %v", i, err) |
||||
continue |
||||
} |
||||
if kind != test.wantKind { |
||||
t.Errorf("test %d: kind mismatch: got %d, want %d", i, kind, test.wantKind) |
||||
} |
||||
if len != test.wantLen { |
||||
t.Errorf("test %d: len mismatch: got %d, want %d", i, len, test.wantLen) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestNewListStream(t *testing.T) { |
||||
ls := NewListStream(bytes.NewReader(unhex("0101010101")), 3) |
||||
if k, size, err := ls.Kind(); k != List || size != 3 || err != nil { |
||||
t.Errorf("Kind() returned (%v, %d, %v), expected (List, 3, nil)", k, size, err) |
||||
} |
||||
if size, err := ls.List(); size != 3 || err != nil { |
||||
t.Errorf("List() returned (%d, %v), expected (3, nil)", size, err) |
||||
} |
||||
for i := 0; i < 3; i++ { |
||||
if val, err := ls.Uint(); val != 1 || err != nil { |
||||
t.Errorf("Uint() returned (%d, %v), expected (1, nil)", val, err) |
||||
} |
||||
} |
||||
if err := ls.ListEnd(); err != nil { |
||||
t.Errorf("ListEnd() returned %v, expected (3, nil)", err) |
||||
} |
||||
} |
||||
|
||||
func TestStreamErrors(t *testing.T) { |
||||
withoutInputLimit := func(b []byte) *Stream { |
||||
return NewStream(newPlainReader(b), 0) |
||||
} |
||||
withCustomInputLimit := func(limit uint64) func([]byte) *Stream { |
||||
return func(b []byte) *Stream { |
||||
return NewStream(bytes.NewReader(b), limit) |
||||
} |
||||
} |
||||
|
||||
type calls []string |
||||
tests := []struct { |
||||
string |
||||
calls |
||||
newStream func([]byte) *Stream // uses bytes.Reader if nil
|
||||
error error |
||||
}{ |
||||
{"C0", calls{"Bytes"}, nil, ErrExpectedString}, |
||||
{"C0", calls{"Uint"}, nil, ErrExpectedString}, |
||||
{"89000000000000000001", calls{"Uint"}, nil, errUintOverflow}, |
||||
{"00", calls{"List"}, nil, ErrExpectedList}, |
||||
{"80", calls{"List"}, nil, ErrExpectedList}, |
||||
{"C0", calls{"List", "Uint"}, nil, EOL}, |
||||
{"C8C9010101010101010101", calls{"List", "Kind"}, nil, ErrElemTooLarge}, |
||||
{"C3C2010201", calls{"List", "List", "Uint", "Uint", "ListEnd", "Uint"}, nil, EOL}, |
||||
{"00", calls{"ListEnd"}, nil, errNotInList}, |
||||
{"C401020304", calls{"List", "Uint", "ListEnd"}, nil, errNotAtEOL}, |
||||
|
||||
// Non-canonical integers (e.g. leading zero bytes).
|
||||
{"00", calls{"Uint"}, nil, ErrCanonInt}, |
||||
{"820002", calls{"Uint"}, nil, ErrCanonInt}, |
||||
{"8133", calls{"Uint"}, nil, ErrCanonSize}, |
||||
{"817F", calls{"Uint"}, nil, ErrCanonSize}, |
||||
{"8180", calls{"Uint"}, nil, nil}, |
||||
|
||||
// Non-valid boolean
|
||||
{"02", calls{"Bool"}, nil, errors.New("rlp: invalid boolean value: 2")}, |
||||
|
||||
// Size tags must use the smallest possible encoding.
|
||||
// Leading zero bytes in the size tag are also rejected.
|
||||
{"8100", calls{"Uint"}, nil, ErrCanonSize}, |
||||
{"8100", calls{"Bytes"}, nil, ErrCanonSize}, |
||||
{"8101", calls{"Bytes"}, nil, ErrCanonSize}, |
||||
{"817F", calls{"Bytes"}, nil, ErrCanonSize}, |
||||
{"8180", calls{"Bytes"}, nil, nil}, |
||||
{"B800", calls{"Kind"}, withoutInputLimit, ErrCanonSize}, |
||||
{"B90000", calls{"Kind"}, withoutInputLimit, ErrCanonSize}, |
||||
{"B90055", calls{"Kind"}, withoutInputLimit, ErrCanonSize}, |
||||
{"BA0002FFFF", calls{"Bytes"}, withoutInputLimit, ErrCanonSize}, |
||||
{"F800", calls{"Kind"}, withoutInputLimit, ErrCanonSize}, |
||||
{"F90000", calls{"Kind"}, withoutInputLimit, ErrCanonSize}, |
||||
{"F90055", calls{"Kind"}, withoutInputLimit, ErrCanonSize}, |
||||
{"FA0002FFFF", calls{"List"}, withoutInputLimit, ErrCanonSize}, |
||||
|
||||
// Expected EOF
|
||||
{"", calls{"Kind"}, nil, io.EOF}, |
||||
{"", calls{"Uint"}, nil, io.EOF}, |
||||
{"", calls{"List"}, nil, io.EOF}, |
||||
{"8180", calls{"Uint", "Uint"}, nil, io.EOF}, |
||||
{"C0", calls{"List", "ListEnd", "List"}, nil, io.EOF}, |
||||
|
||||
{"", calls{"List"}, withoutInputLimit, io.EOF}, |
||||
{"8180", calls{"Uint", "Uint"}, withoutInputLimit, io.EOF}, |
||||
{"C0", calls{"List", "ListEnd", "List"}, withoutInputLimit, io.EOF}, |
||||
|
||||
// Input limit errors.
|
||||
{"81", calls{"Bytes"}, nil, ErrValueTooLarge}, |
||||
{"81", calls{"Uint"}, nil, ErrValueTooLarge}, |
||||
{"81", calls{"Raw"}, nil, ErrValueTooLarge}, |
||||
{"BFFFFFFFFFFFFFFFFFFF", calls{"Bytes"}, nil, ErrValueTooLarge}, |
||||
{"C801", calls{"List"}, nil, ErrValueTooLarge}, |
||||
|
||||
// Test for list element size check overflow.
|
||||
{"CD04040404FFFFFFFFFFFFFFFFFF0303", calls{"List", "Uint", "Uint", "Uint", "Uint", "List"}, nil, ErrElemTooLarge}, |
||||
|
||||
// Test for input limit overflow. Since we are counting the limit
|
||||
// down toward zero in Stream.remaining, reading too far can overflow
|
||||
// remaining to a large value, effectively disabling the limit.
|
||||
{"C40102030401", calls{"Raw", "Uint"}, withCustomInputLimit(5), io.EOF}, |
||||
{"C4010203048180", calls{"Raw", "Uint"}, withCustomInputLimit(6), ErrValueTooLarge}, |
||||
|
||||
// Check that the same calls are fine without a limit.
|
||||
{"C40102030401", calls{"Raw", "Uint"}, withoutInputLimit, nil}, |
||||
{"C4010203048180", calls{"Raw", "Uint"}, withoutInputLimit, nil}, |
||||
|
||||
// Unexpected EOF. This only happens when there is
|
||||
// no input limit, so the reader needs to be 'dumbed down'.
|
||||
{"81", calls{"Bytes"}, withoutInputLimit, io.ErrUnexpectedEOF}, |
||||
{"81", calls{"Uint"}, withoutInputLimit, io.ErrUnexpectedEOF}, |
||||
{"BFFFFFFFFFFFFFFF", calls{"Bytes"}, withoutInputLimit, io.ErrUnexpectedEOF}, |
||||
{"C801", calls{"List", "Uint", "Uint"}, withoutInputLimit, io.ErrUnexpectedEOF}, |
||||
|
||||
// This test verifies that the input position is advanced
|
||||
// correctly when calling Bytes for empty strings. Kind can be called
|
||||
// any number of times in between and doesn't advance.
|
||||
{"C3808080", calls{ |
||||
"List", // enter the list
|
||||
"Bytes", // past first element
|
||||
|
||||
"Kind", "Kind", "Kind", // this shouldn't advance
|
||||
|
||||
"Bytes", // past second element
|
||||
|
||||
"Kind", "Kind", // can't hurt to try
|
||||
|
||||
"Bytes", // past final element
|
||||
"Bytes", // this one should fail
|
||||
}, nil, EOL}, |
||||
} |
||||
|
||||
testfor: |
||||
for i, test := range tests { |
||||
if test.newStream == nil { |
||||
test.newStream = func(b []byte) *Stream { return NewStream(bytes.NewReader(b), 0) } |
||||
} |
||||
s := test.newStream(unhex(test.string)) |
||||
rs := reflect.ValueOf(s) |
||||
for j, call := range test.calls { |
||||
fval := rs.MethodByName(call) |
||||
ret := fval.Call(nil) |
||||
err := "<nil>" |
||||
if lastret := ret[len(ret)-1].Interface(); lastret != nil { |
||||
err = lastret.(error).Error() |
||||
} |
||||
if j == len(test.calls)-1 { |
||||
want := "<nil>" |
||||
if test.error != nil { |
||||
want = test.error.Error() |
||||
} |
||||
if err != want { |
||||
t.Log(test) |
||||
t.Errorf("test %d: last call (%s) error mismatch\ngot: %s\nwant: %s", |
||||
i, call, err, test.error) |
||||
} |
||||
} else if err != "<nil>" { |
||||
t.Log(test) |
||||
t.Errorf("test %d: call %d (%s) unexpected error: %q", i, j, call, err) |
||||
continue testfor |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestStreamList(t *testing.T) { |
||||
s := NewStream(bytes.NewReader(unhex("C80102030405060708")), 0) |
||||
|
||||
len, err := s.List() |
||||
if err != nil { |
||||
t.Fatalf("List error: %v", err) |
||||
} |
||||
if len != 8 { |
||||
t.Fatalf("List returned invalid length, got %d, want 8", len) |
||||
} |
||||
|
||||
for i := uint64(1); i <= 8; i++ { |
||||
v, err := s.Uint() |
||||
if err != nil { |
||||
t.Fatalf("Uint error: %v", err) |
||||
} |
||||
if i != v { |
||||
t.Errorf("Uint returned wrong value, got %d, want %d", v, i) |
||||
} |
||||
} |
||||
|
||||
if _, err := s.Uint(); err != EOL { |
||||
t.Errorf("Uint error mismatch, got %v, want %v", err, EOL) |
||||
} |
||||
if err = s.ListEnd(); err != nil { |
||||
t.Fatalf("ListEnd error: %v", err) |
||||
} |
||||
} |
||||
|
||||
func TestStreamRaw(t *testing.T) { |
||||
tests := []struct { |
||||
input string |
||||
output string |
||||
}{ |
||||
{ |
||||
"C58401010101", |
||||
"8401010101", |
||||
}, |
||||
{ |
||||
"F842B84001010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101", |
||||
"B84001010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101", |
||||
}, |
||||
} |
||||
for i, tt := range tests { |
||||
s := NewStream(bytes.NewReader(unhex(tt.input)), 0) |
||||
s.List() |
||||
|
||||
want := unhex(tt.output) |
||||
raw, err := s.Raw() |
||||
if err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if !bytes.Equal(want, raw) { |
||||
t.Errorf("test %d: raw mismatch: got %x, want %x", i, raw, want) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestDecodeErrors(t *testing.T) { |
||||
r := bytes.NewReader(nil) |
||||
|
||||
if err := Decode(r, nil); err != errDecodeIntoNil { |
||||
t.Errorf("Decode(r, nil) error mismatch, got %q, want %q", err, errDecodeIntoNil) |
||||
} |
||||
|
||||
var nilptr *struct{} |
||||
if err := Decode(r, nilptr); err != errDecodeIntoNil { |
||||
t.Errorf("Decode(r, nilptr) error mismatch, got %q, want %q", err, errDecodeIntoNil) |
||||
} |
||||
|
||||
if err := Decode(r, struct{}{}); err != errNoPointer { |
||||
t.Errorf("Decode(r, struct{}{}) error mismatch, got %q, want %q", err, errNoPointer) |
||||
} |
||||
|
||||
expectErr := "rlp: type chan bool is not RLP-serializable" |
||||
if err := Decode(r, new(chan bool)); err == nil || err.Error() != expectErr { |
||||
t.Errorf("Decode(r, new(chan bool)) error mismatch, got %q, want %q", err, expectErr) |
||||
} |
||||
|
||||
if err := Decode(r, new(uint)); err != io.EOF { |
||||
t.Errorf("Decode(r, new(int)) error mismatch, got %q, want %q", err, io.EOF) |
||||
} |
||||
} |
||||
|
||||
type decodeTest struct { |
||||
input string |
||||
ptr interface{} |
||||
value interface{} |
||||
error string |
||||
} |
||||
|
||||
type simplestruct struct { |
||||
A uint |
||||
B string |
||||
} |
||||
|
||||
type recstruct struct { |
||||
I uint |
||||
Child *recstruct `rlp:"nil"` |
||||
} |
||||
|
||||
type invalidTail1 struct { |
||||
A uint `rlp:"tail"` |
||||
B string |
||||
} |
||||
|
||||
type invalidTail2 struct { |
||||
A uint |
||||
B string `rlp:"tail"` |
||||
} |
||||
|
||||
type tailRaw struct { |
||||
A uint |
||||
Tail []RawValue `rlp:"tail"` |
||||
} |
||||
|
||||
type tailUint struct { |
||||
A uint |
||||
Tail []uint `rlp:"tail"` |
||||
} |
||||
|
||||
var ( |
||||
veryBigInt = big.NewInt(0).Add( |
||||
big.NewInt(0).Lsh(big.NewInt(0xFFFFFFFFFFFFFF), 16), |
||||
big.NewInt(0xFFFF), |
||||
) |
||||
) |
||||
|
||||
type hasIgnoredField struct { |
||||
A uint |
||||
B uint `rlp:"-"` |
||||
C uint |
||||
} |
||||
|
||||
var decodeTests = []decodeTest{ |
||||
// booleans
|
||||
{input: "01", ptr: new(bool), value: true}, |
||||
{input: "80", ptr: new(bool), value: false}, |
||||
{input: "02", ptr: new(bool), error: "rlp: invalid boolean value: 2"}, |
||||
|
||||
// integers
|
||||
{input: "05", ptr: new(uint32), value: uint32(5)}, |
||||
{input: "80", ptr: new(uint32), value: uint32(0)}, |
||||
{input: "820505", ptr: new(uint32), value: uint32(0x0505)}, |
||||
{input: "83050505", ptr: new(uint32), value: uint32(0x050505)}, |
||||
{input: "8405050505", ptr: new(uint32), value: uint32(0x05050505)}, |
||||
{input: "850505050505", ptr: new(uint32), error: "rlp: input string too long for uint32"}, |
||||
{input: "C0", ptr: new(uint32), error: "rlp: expected input string or byte for uint32"}, |
||||
{input: "00", ptr: new(uint32), error: "rlp: non-canonical integer (leading zero bytes) for uint32"}, |
||||
{input: "8105", ptr: new(uint32), error: "rlp: non-canonical size information for uint32"}, |
||||
{input: "820004", ptr: new(uint32), error: "rlp: non-canonical integer (leading zero bytes) for uint32"}, |
||||
{input: "B8020004", ptr: new(uint32), error: "rlp: non-canonical size information for uint32"}, |
||||
|
||||
// slices
|
||||
{input: "C0", ptr: new([]uint), value: []uint{}}, |
||||
{input: "C80102030405060708", ptr: new([]uint), value: []uint{1, 2, 3, 4, 5, 6, 7, 8}}, |
||||
{input: "F8020004", ptr: new([]uint), error: "rlp: non-canonical size information for []uint"}, |
||||
|
||||
// arrays
|
||||
{input: "C50102030405", ptr: new([5]uint), value: [5]uint{1, 2, 3, 4, 5}}, |
||||
{input: "C0", ptr: new([5]uint), error: "rlp: input list has too few elements for [5]uint"}, |
||||
{input: "C102", ptr: new([5]uint), error: "rlp: input list has too few elements for [5]uint"}, |
||||
{input: "C6010203040506", ptr: new([5]uint), error: "rlp: input list has too many elements for [5]uint"}, |
||||
{input: "F8020004", ptr: new([5]uint), error: "rlp: non-canonical size information for [5]uint"}, |
||||
|
||||
// zero sized arrays
|
||||
{input: "C0", ptr: new([0]uint), value: [0]uint{}}, |
||||
{input: "C101", ptr: new([0]uint), error: "rlp: input list has too many elements for [0]uint"}, |
||||
|
||||
// byte slices
|
||||
{input: "01", ptr: new([]byte), value: []byte{1}}, |
||||
{input: "80", ptr: new([]byte), value: []byte{}}, |
||||
{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")}, |
||||
{input: "C0", ptr: new([]byte), error: "rlp: expected input string or byte for []uint8"}, |
||||
{input: "8105", ptr: new([]byte), error: "rlp: non-canonical size information for []uint8"}, |
||||
|
||||
// byte arrays
|
||||
{input: "02", ptr: new([1]byte), value: [1]byte{2}}, |
||||
{input: "8180", ptr: new([1]byte), value: [1]byte{128}}, |
||||
{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}}, |
||||
|
||||
// byte array errors
|
||||
{input: "02", ptr: new([5]byte), error: "rlp: input string too short for [5]uint8"}, |
||||
{input: "80", ptr: new([5]byte), error: "rlp: input string too short for [5]uint8"}, |
||||
{input: "820000", ptr: new([5]byte), error: "rlp: input string too short for [5]uint8"}, |
||||
{input: "C0", ptr: new([5]byte), error: "rlp: expected input string or byte for [5]uint8"}, |
||||
{input: "C3010203", ptr: new([5]byte), error: "rlp: expected input string or byte for [5]uint8"}, |
||||
{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too long for [5]uint8"}, |
||||
{input: "8105", ptr: new([1]byte), error: "rlp: non-canonical size information for [1]uint8"}, |
||||
{input: "817F", ptr: new([1]byte), error: "rlp: non-canonical size information for [1]uint8"}, |
||||
|
||||
// zero sized byte arrays
|
||||
{input: "80", ptr: new([0]byte), value: [0]byte{}}, |
||||
{input: "01", ptr: new([0]byte), error: "rlp: input string too long for [0]uint8"}, |
||||
{input: "8101", ptr: new([0]byte), error: "rlp: input string too long for [0]uint8"}, |
||||
|
||||
// strings
|
||||
{input: "00", ptr: new(string), value: "\000"}, |
||||
{input: "8D6162636465666768696A6B6C6D", ptr: new(string), value: "abcdefghijklm"}, |
||||
{input: "C0", ptr: new(string), error: "rlp: expected input string or byte for string"}, |
||||
|
||||
// big ints
|
||||
{input: "01", ptr: new(*big.Int), value: big.NewInt(1)}, |
||||
{input: "89FFFFFFFFFFFFFFFFFF", ptr: new(*big.Int), value: veryBigInt}, |
||||
{input: "10", ptr: new(big.Int), value: *big.NewInt(16)}, // non-pointer also works
|
||||
{input: "C0", ptr: new(*big.Int), error: "rlp: expected input string or byte for *big.Int"}, |
||||
{input: "820001", ptr: new(big.Int), error: "rlp: non-canonical integer (leading zero bytes) for *big.Int"}, |
||||
{input: "8105", ptr: new(big.Int), error: "rlp: non-canonical size information for *big.Int"}, |
||||
|
||||
// structs
|
||||
{ |
||||
input: "C50583343434", |
||||
ptr: new(simplestruct), |
||||
value: simplestruct{5, "444"}, |
||||
}, |
||||
{ |
||||
input: "C601C402C203C0", |
||||
ptr: new(recstruct), |
||||
value: recstruct{1, &recstruct{2, &recstruct{3, nil}}}, |
||||
}, |
||||
|
||||
// struct errors
|
||||
{ |
||||
input: "C0", |
||||
ptr: new(simplestruct), |
||||
error: "rlp: too few elements for rlp.simplestruct", |
||||
}, |
||||
{ |
||||
input: "C105", |
||||
ptr: new(simplestruct), |
||||
error: "rlp: too few elements for rlp.simplestruct", |
||||
}, |
||||
{ |
||||
input: "C7C50583343434C0", |
||||
ptr: new([]*simplestruct), |
||||
error: "rlp: too few elements for rlp.simplestruct, decoding into ([]*rlp.simplestruct)[1]", |
||||
}, |
||||
{ |
||||
input: "83222222", |
||||
ptr: new(simplestruct), |
||||
error: "rlp: expected input list for rlp.simplestruct", |
||||
}, |
||||
{ |
||||
input: "C3010101", |
||||
ptr: new(simplestruct), |
||||
error: "rlp: input list has too many elements for rlp.simplestruct", |
||||
}, |
||||
{ |
||||
input: "C501C3C00000", |
||||
ptr: new(recstruct), |
||||
error: "rlp: expected input string or byte for uint, decoding into (rlp.recstruct).Child.I", |
||||
}, |
||||
{ |
||||
input: "C0", |
||||
ptr: new(invalidTail1), |
||||
error: "rlp: invalid struct tag \"tail\" for rlp.invalidTail1.A (must be on last field)", |
||||
}, |
||||
{ |
||||
input: "C0", |
||||
ptr: new(invalidTail2), |
||||
error: "rlp: invalid struct tag \"tail\" for rlp.invalidTail2.B (field type is not slice)", |
||||
}, |
||||
{ |
||||
input: "C50102C20102", |
||||
ptr: new(tailUint), |
||||
error: "rlp: expected input string or byte for uint, decoding into (rlp.tailUint).Tail[1]", |
||||
}, |
||||
|
||||
// struct tag "tail"
|
||||
{ |
||||
input: "C3010203", |
||||
ptr: new(tailRaw), |
||||
value: tailRaw{A: 1, Tail: []RawValue{unhex("02"), unhex("03")}}, |
||||
}, |
||||
{ |
||||
input: "C20102", |
||||
ptr: new(tailRaw), |
||||
value: tailRaw{A: 1, Tail: []RawValue{unhex("02")}}, |
||||
}, |
||||
{ |
||||
input: "C101", |
||||
ptr: new(tailRaw), |
||||
value: tailRaw{A: 1, Tail: []RawValue{}}, |
||||
}, |
||||
|
||||
// struct tag "-"
|
||||
{ |
||||
input: "C20102", |
||||
ptr: new(hasIgnoredField), |
||||
value: hasIgnoredField{A: 1, C: 2}, |
||||
}, |
||||
|
||||
// RawValue
|
||||
{input: "01", ptr: new(RawValue), value: RawValue(unhex("01"))}, |
||||
{input: "82FFFF", ptr: new(RawValue), value: RawValue(unhex("82FFFF"))}, |
||||
{input: "C20102", ptr: new([]RawValue), value: []RawValue{unhex("01"), unhex("02")}}, |
||||
|
||||
// pointers
|
||||
{input: "00", ptr: new(*[]byte), value: &[]byte{0}}, |
||||
{input: "80", ptr: new(*uint), value: uintp(0)}, |
||||
{input: "C0", ptr: new(*uint), error: "rlp: expected input string or byte for uint"}, |
||||
{input: "07", ptr: new(*uint), value: uintp(7)}, |
||||
{input: "817F", ptr: new(*uint), error: "rlp: non-canonical size information for uint"}, |
||||
{input: "8180", ptr: new(*uint), value: uintp(0x80)}, |
||||
{input: "C109", ptr: new(*[]uint), value: &[]uint{9}}, |
||||
{input: "C58403030303", ptr: new(*[][]byte), value: &[][]byte{{3, 3, 3, 3}}}, |
||||
|
||||
// check that input position is advanced also for empty values.
|
||||
{input: "C3808005", ptr: new([]*uint), value: []*uint{uintp(0), uintp(0), uintp(5)}}, |
||||
|
||||
// interface{}
|
||||
{input: "00", ptr: new(interface{}), value: []byte{0}}, |
||||
{input: "01", ptr: new(interface{}), value: []byte{1}}, |
||||
{input: "80", ptr: new(interface{}), value: []byte{}}, |
||||
{input: "850505050505", ptr: new(interface{}), value: []byte{5, 5, 5, 5, 5}}, |
||||
{input: "C0", ptr: new(interface{}), value: []interface{}{}}, |
||||
{input: "C50183040404", ptr: new(interface{}), value: []interface{}{[]byte{1}, []byte{4, 4, 4}}}, |
||||
{ |
||||
input: "C3010203", |
||||
ptr: new([]io.Reader), |
||||
error: "rlp: type io.Reader is not RLP-serializable", |
||||
}, |
||||
|
||||
// fuzzer crashes
|
||||
{ |
||||
input: "c330f9c030f93030ce3030303030303030bd303030303030", |
||||
ptr: new(interface{}), |
||||
error: "rlp: element is larger than containing list", |
||||
}, |
||||
} |
||||
|
||||
func uintp(i uint) *uint { return &i } |
||||
|
||||
func runTests(t *testing.T, decode func([]byte, interface{}) error) { |
||||
for i, test := range decodeTests { |
||||
input, err := hex.DecodeString(test.input) |
||||
if err != nil { |
||||
t.Errorf("test %d: invalid hex input %q", i, test.input) |
||||
continue |
||||
} |
||||
err = decode(input, test.ptr) |
||||
if err != nil && test.error == "" { |
||||
t.Errorf("test %d: unexpected Decode error: %v\ndecoding into %T\ninput %q", |
||||
i, err, test.ptr, test.input) |
||||
continue |
||||
} |
||||
if test.error != "" && fmt.Sprint(err) != test.error { |
||||
t.Errorf("test %d: Decode error mismatch\ngot %v\nwant %v\ndecoding into %T\ninput %q", |
||||
i, err, test.error, test.ptr, test.input) |
||||
continue |
||||
} |
||||
deref := reflect.ValueOf(test.ptr).Elem().Interface() |
||||
if err == nil && !reflect.DeepEqual(deref, test.value) { |
||||
t.Errorf("test %d: value mismatch\ngot %#v\nwant %#v\ndecoding into %T\ninput %q", |
||||
i, deref, test.value, test.ptr, test.input) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestDecodeWithByteReader(t *testing.T) { |
||||
runTests(t, func(input []byte, into interface{}) error { |
||||
return Decode(bytes.NewReader(input), into) |
||||
}) |
||||
} |
||||
|
||||
// plainReader reads from a byte slice but does not
|
||||
// implement ReadByte. It is also not recognized by the
|
||||
// size validation. This is useful to test how the decoder
|
||||
// behaves on a non-buffered input stream.
|
||||
type plainReader []byte |
||||
|
||||
func newPlainReader(b []byte) io.Reader { |
||||
return (*plainReader)(&b) |
||||
} |
||||
|
||||
func (r *plainReader) Read(buf []byte) (n int, err error) { |
||||
if len(*r) == 0 { |
||||
return 0, io.EOF |
||||
} |
||||
n = copy(buf, *r) |
||||
*r = (*r)[n:] |
||||
return n, nil |
||||
} |
||||
|
||||
func TestDecodeWithNonByteReader(t *testing.T) { |
||||
runTests(t, func(input []byte, into interface{}) error { |
||||
return Decode(newPlainReader(input), into) |
||||
}) |
||||
} |
||||
|
||||
func TestDecodeStreamReset(t *testing.T) { |
||||
s := NewStream(nil, 0) |
||||
runTests(t, func(input []byte, into interface{}) error { |
||||
s.Reset(bytes.NewReader(input), 0) |
||||
return s.Decode(into) |
||||
}) |
||||
} |
||||
|
||||
type testDecoder struct{ called bool } |
||||
|
||||
func (t *testDecoder) DecodeRLP(s *Stream) error { |
||||
if _, err := s.Uint(); err != nil { |
||||
return err |
||||
} |
||||
t.called = true |
||||
return nil |
||||
} |
||||
|
||||
func TestDecodeDecoder(t *testing.T) { |
||||
var s struct { |
||||
T1 testDecoder |
||||
T2 *testDecoder |
||||
T3 **testDecoder |
||||
} |
||||
if err := Decode(bytes.NewReader(unhex("C3010203")), &s); err != nil { |
||||
t.Fatalf("Decode error: %v", err) |
||||
} |
||||
|
||||
if !s.T1.called { |
||||
t.Errorf("DecodeRLP was not called for (non-pointer) testDecoder") |
||||
} |
||||
|
||||
if s.T2 == nil { |
||||
t.Errorf("*testDecoder has not been allocated") |
||||
} else if !s.T2.called { |
||||
t.Errorf("DecodeRLP was not called for *testDecoder") |
||||
} |
||||
|
||||
if s.T3 == nil || *s.T3 == nil { |
||||
t.Errorf("**testDecoder has not been allocated") |
||||
} else if !(*s.T3).called { |
||||
t.Errorf("DecodeRLP was not called for **testDecoder") |
||||
} |
||||
} |
||||
|
||||
type byteDecoder byte |
||||
|
||||
func (bd *byteDecoder) DecodeRLP(s *Stream) error { |
||||
_, err := s.Uint() |
||||
*bd = 255 |
||||
return err |
||||
} |
||||
|
||||
func (bd byteDecoder) called() bool { |
||||
return bd == 255 |
||||
} |
||||
|
||||
// This test verifies that the byte slice/byte array logic
|
||||
// does not kick in for element types implementing Decoder.
|
||||
func TestDecoderInByteSlice(t *testing.T) { |
||||
var slice []byteDecoder |
||||
if err := Decode(bytes.NewReader(unhex("C101")), &slice); err != nil { |
||||
t.Errorf("unexpected Decode error %v", err) |
||||
} else if !slice[0].called() { |
||||
t.Errorf("DecodeRLP not called for slice element") |
||||
} |
||||
|
||||
var array [1]byteDecoder |
||||
if err := Decode(bytes.NewReader(unhex("C101")), &array); err != nil { |
||||
t.Errorf("unexpected Decode error %v", err) |
||||
} else if !array[0].called() { |
||||
t.Errorf("DecodeRLP not called for array element") |
||||
} |
||||
} |
||||
|
||||
func ExampleDecode() { |
||||
input, _ := hex.DecodeString("C90A1486666F6F626172") |
||||
|
||||
type example struct { |
||||
A, B uint |
||||
private uint // private fields are ignored
|
||||
String string |
||||
} |
||||
|
||||
var s example |
||||
err := Decode(bytes.NewReader(input), &s) |
||||
if err != nil { |
||||
fmt.Printf("Error: %v\n", err) |
||||
} else { |
||||
fmt.Printf("Decoded value: %#v\n", s) |
||||
} |
||||
// Output:
|
||||
// Decoded value: rlp.example{A:0xa, B:0x14, private:0x0, String:"foobar"}
|
||||
} |
||||
|
||||
func ExampleDecode_structTagNil() { |
||||
// In this example, we'll use the "nil" struct tag to change
|
||||
// how a pointer-typed field is decoded. The input contains an RLP
|
||||
// list of one element, an empty string.
|
||||
input := []byte{0xC1, 0x80} |
||||
|
||||
// This type uses the normal rules.
|
||||
// The empty input string is decoded as a pointer to an empty Go string.
|
||||
var normalRules struct { |
||||
String *string |
||||
} |
||||
Decode(bytes.NewReader(input), &normalRules) |
||||
fmt.Printf("normal: String = %q\n", *normalRules.String) |
||||
|
||||
// This type uses the struct tag.
|
||||
// The empty input string is decoded as a nil pointer.
|
||||
var withEmptyOK struct { |
||||
String *string `rlp:"nil"` |
||||
} |
||||
Decode(bytes.NewReader(input), &withEmptyOK) |
||||
fmt.Printf("with nil tag: String = %v\n", withEmptyOK.String) |
||||
|
||||
// Output:
|
||||
// normal: String = ""
|
||||
// with nil tag: String = <nil>
|
||||
} |
||||
|
||||
func ExampleStream() { |
||||
input, _ := hex.DecodeString("C90A1486666F6F626172") |
||||
s := NewStream(bytes.NewReader(input), 0) |
||||
|
||||
// Check what kind of value lies ahead
|
||||
kind, size, _ := s.Kind() |
||||
fmt.Printf("Kind: %v size:%d\n", kind, size) |
||||
|
||||
// Enter the list
|
||||
if _, err := s.List(); err != nil { |
||||
fmt.Printf("List error: %v\n", err) |
||||
return |
||||
} |
||||
|
||||
// Decode elements
|
||||
fmt.Println(s.Uint()) |
||||
fmt.Println(s.Uint()) |
||||
fmt.Println(s.Bytes()) |
||||
|
||||
// Acknowledge end of list
|
||||
if err := s.ListEnd(); err != nil { |
||||
fmt.Printf("ListEnd error: %v\n", err) |
||||
} |
||||
// Output:
|
||||
// Kind: List size:9
|
||||
// 10 <nil>
|
||||
// 20 <nil>
|
||||
// [102 111 111 98 97 114] <nil>
|
||||
} |
||||
|
||||
func BenchmarkDecode(b *testing.B) { |
||||
enc := encodeTestSlice(90000) |
||||
b.SetBytes(int64(len(enc))) |
||||
b.ReportAllocs() |
||||
b.ResetTimer() |
||||
|
||||
for i := 0; i < b.N; i++ { |
||||
var s []uint |
||||
r := bytes.NewReader(enc) |
||||
if err := Decode(r, &s); err != nil { |
||||
b.Fatalf("Decode error: %v", err) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func BenchmarkDecodeIntSliceReuse(b *testing.B) { |
||||
enc := encodeTestSlice(100000) |
||||
b.SetBytes(int64(len(enc))) |
||||
b.ReportAllocs() |
||||
b.ResetTimer() |
||||
|
||||
var s []uint |
||||
for i := 0; i < b.N; i++ { |
||||
r := bytes.NewReader(enc) |
||||
if err := Decode(r, &s); err != nil { |
||||
b.Fatalf("Decode error: %v", err) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func encodeTestSlice(n uint) []byte { |
||||
s := make([]uint, n) |
||||
for i := uint(0); i < n; i++ { |
||||
s[i] = i |
||||
} |
||||
b, err := EncodeToBytes(s) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("encode error: %v", err)) |
||||
} |
||||
return b |
||||
} |
||||
|
||||
func unhex(str string) []byte { |
||||
b, err := hex.DecodeString(strings.Replace(str, " ", "", -1)) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("invalid hex string: %q", str)) |
||||
} |
||||
return b |
||||
} |
||||
@ -0,0 +1,33 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
/* |
||||
Package rlp implements the RLP serialization format. |
||||
|
||||
The purpose of RLP (Recursive Linear Prefix) is to encode arbitrarily |
||||
nested arrays of binary data, and RLP is the main encoding method used |
||||
to serialize objects in Ethereum. The only purpose of RLP is to encode |
||||
structure; encoding specific atomic data types (eg. strings, ints, |
||||
floats) is left up to higher-order protocols; in Ethereum integers |
||||
must be represented in big endian binary form with no leading zeroes |
||||
(thus making the integer value zero equivalent to the empty byte |
||||
array). |
||||
|
||||
RLP values are distinguished by a type tag. The type tag precedes the |
||||
value in the input stream and defines the size and kind of the bytes |
||||
that follow. |
||||
*/ |
||||
package rlp |
||||
@ -0,0 +1,649 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
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) |
||||
defer encbufPool.Put(eb) |
||||
eb.reset() |
||||
if err := eb.encode(val); err != nil { |
||||
return err |
||||
} |
||||
return eb.toWriter(w) |
||||
} |
||||
|
||||
// EncodeToBytes 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) |
||||
defer encbufPool.Put(eb) |
||||
eb.reset() |
||||
if err := eb.encode(val); err != nil { |
||||
return nil, err |
||||
} |
||||
return eb.toBytes(), nil |
||||
} |
||||
|
||||
// EncodeToReader 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 |
||||
} |
||||
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++ // 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 { |
||||
// Put the encode buffer back into the pool at EOF when it
|
||||
// is first encountered. Subsequent calls still return EOF
|
||||
// as the error but the buffer is no longer valid.
|
||||
if r.buf != 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 |
||||
} |
||||
} |
||||
|
||||
// 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 |
||||
} |
||||
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, ts tags) (writer, error) { |
||||
kind := typ.Kind() |
||||
switch { |
||||
case typ == rawValueType: |
||||
return writeRawValue, nil |
||||
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.Bool: |
||||
return writeBool, 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, ts) |
||||
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 writeRawValue(val reflect.Value, w *encbuf) error { |
||||
w.str = append(w.str, val.Bytes()...) |
||||
return nil |
||||
} |
||||
|
||||
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 writeBool(val reflect.Value, w *encbuf) error { |
||||
if val.Bool() { |
||||
w.str = append(w.str, 0x01) |
||||
} else { |
||||
w.str = append(w.str, 0x80) |
||||
} |
||||
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 to 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, ts tags) (writer, error) { |
||||
etypeinfo, err := cachedTypeInfo1(typ.Elem(), tags{}) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
writer := func(val reflect.Value, w *encbuf) error { |
||||
if !ts.tail { |
||||
defer w.listEnd(w.list()) |
||||
} |
||||
vlen := val.Len() |
||||
for i := 0; i < vlen; i++ { |
||||
if err := etypeinfo.writer(val.Index(i), w); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
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) |
||||
} |
||||
return etypeinfo.writer(val.Elem(), w) |
||||
} |
||||
return writer, err |
||||
} |
||||
|
||||
// putint writes i to the beginning of b in 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 |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,341 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"bytes" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"io/ioutil" |
||||
"math/big" |
||||
"sync" |
||||
"testing" |
||||
) |
||||
|
||||
type testEncoder struct { |
||||
err error |
||||
} |
||||
|
||||
func (e *testEncoder) EncodeRLP(w io.Writer) error { |
||||
if e == nil { |
||||
w.Write([]byte{0, 0, 0, 0}) |
||||
} else if e.err != nil { |
||||
return e.err |
||||
} else { |
||||
w.Write([]byte{0, 1, 0, 1, 0, 1, 0, 1, 0, 1}) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type byteEncoder byte |
||||
|
||||
func (e byteEncoder) EncodeRLP(w io.Writer) error { |
||||
w.Write(EmptyList) |
||||
return nil |
||||
} |
||||
|
||||
type encodableReader struct { |
||||
A, B uint |
||||
} |
||||
|
||||
func (e *encodableReader) Read(b []byte) (int, error) { |
||||
panic("called") |
||||
} |
||||
|
||||
type namedByteType byte |
||||
|
||||
var ( |
||||
_ = Encoder(&testEncoder{}) |
||||
_ = Encoder(byteEncoder(0)) |
||||
|
||||
reader io.Reader = &encodableReader{1, 2} |
||||
) |
||||
|
||||
type encTest struct { |
||||
val interface{} |
||||
output, error string |
||||
} |
||||
|
||||
var encTests = []encTest{ |
||||
// booleans
|
||||
{val: true, output: "01"}, |
||||
{val: false, output: "80"}, |
||||
|
||||
// integers
|
||||
{val: uint32(0), output: "80"}, |
||||
{val: uint32(127), output: "7F"}, |
||||
{val: uint32(128), output: "8180"}, |
||||
{val: uint32(256), output: "820100"}, |
||||
{val: uint32(1024), output: "820400"}, |
||||
{val: uint32(0xFFFFFF), output: "83FFFFFF"}, |
||||
{val: uint32(0xFFFFFFFF), output: "84FFFFFFFF"}, |
||||
{val: uint64(0xFFFFFFFF), output: "84FFFFFFFF"}, |
||||
{val: uint64(0xFFFFFFFFFF), output: "85FFFFFFFFFF"}, |
||||
{val: uint64(0xFFFFFFFFFFFF), output: "86FFFFFFFFFFFF"}, |
||||
{val: uint64(0xFFFFFFFFFFFFFF), output: "87FFFFFFFFFFFFFF"}, |
||||
{val: uint64(0xFFFFFFFFFFFFFFFF), output: "88FFFFFFFFFFFFFFFF"}, |
||||
|
||||
// big integers (should match uint for small values)
|
||||
{val: big.NewInt(0), output: "80"}, |
||||
{val: big.NewInt(1), output: "01"}, |
||||
{val: big.NewInt(127), output: "7F"}, |
||||
{val: big.NewInt(128), output: "8180"}, |
||||
{val: big.NewInt(256), output: "820100"}, |
||||
{val: big.NewInt(1024), output: "820400"}, |
||||
{val: big.NewInt(0xFFFFFF), output: "83FFFFFF"}, |
||||
{val: big.NewInt(0xFFFFFFFF), output: "84FFFFFFFF"}, |
||||
{val: big.NewInt(0xFFFFFFFFFF), output: "85FFFFFFFFFF"}, |
||||
{val: big.NewInt(0xFFFFFFFFFFFF), output: "86FFFFFFFFFFFF"}, |
||||
{val: big.NewInt(0xFFFFFFFFFFFFFF), output: "87FFFFFFFFFFFFFF"}, |
||||
{ |
||||
val: big.NewInt(0).SetBytes(unhex("102030405060708090A0B0C0D0E0F2")), |
||||
output: "8F102030405060708090A0B0C0D0E0F2", |
||||
}, |
||||
{ |
||||
val: big.NewInt(0).SetBytes(unhex("0100020003000400050006000700080009000A000B000C000D000E01")), |
||||
output: "9C0100020003000400050006000700080009000A000B000C000D000E01", |
||||
}, |
||||
{ |
||||
val: big.NewInt(0).SetBytes(unhex("010000000000000000000000000000000000000000000000000000000000000000")), |
||||
output: "A1010000000000000000000000000000000000000000000000000000000000000000", |
||||
}, |
||||
|
||||
// non-pointer big.Int
|
||||
{val: *big.NewInt(0), output: "80"}, |
||||
{val: *big.NewInt(0xFFFFFF), output: "83FFFFFF"}, |
||||
|
||||
// negative ints are not supported
|
||||
{val: big.NewInt(-1), error: "rlp: cannot encode negative *big.Int"}, |
||||
|
||||
// byte slices, strings
|
||||
{val: []byte{}, output: "80"}, |
||||
{val: []byte{0x7E}, output: "7E"}, |
||||
{val: []byte{0x7F}, output: "7F"}, |
||||
{val: []byte{0x80}, output: "8180"}, |
||||
{val: []byte{1, 2, 3}, output: "83010203"}, |
||||
|
||||
{val: []namedByteType{1, 2, 3}, output: "83010203"}, |
||||
{val: [...]namedByteType{1, 2, 3}, output: "83010203"}, |
||||
|
||||
{val: "", output: "80"}, |
||||
{val: "\x7E", output: "7E"}, |
||||
{val: "\x7F", output: "7F"}, |
||||
{val: "\x80", output: "8180"}, |
||||
{val: "dog", output: "83646F67"}, |
||||
{ |
||||
val: "Lorem ipsum dolor sit amet, consectetur adipisicing eli", |
||||
output: "B74C6F72656D20697073756D20646F6C6F722073697420616D65742C20636F6E7365637465747572206164697069736963696E6720656C69", |
||||
}, |
||||
{ |
||||
val: "Lorem ipsum dolor sit amet, consectetur adipisicing elit", |
||||
output: "B8384C6F72656D20697073756D20646F6C6F722073697420616D65742C20636F6E7365637465747572206164697069736963696E6720656C6974", |
||||
}, |
||||
{ |
||||
val: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur mauris magna, suscipit sed vehicula non, iaculis faucibus tortor. Proin suscipit ultricies malesuada. Duis tortor elit, dictum quis tristique eu, ultrices at risus. Morbi a est imperdiet mi ullamcorper aliquet suscipit nec lorem. Aenean quis leo mollis, vulputate elit varius, consequat enim. Nulla ultrices turpis justo, et posuere urna consectetur nec. Proin non convallis metus. Donec tempor ipsum in mauris congue sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Suspendisse convallis sem vel massa faucibus, eget lacinia lacus tempor. Nulla quis ultricies purus. Proin auctor rhoncus nibh condimentum mollis. Aliquam consequat enim at metus luctus, a eleifend purus egestas. Curabitur at nibh metus. Nam bibendum, neque at auctor tristique, lorem libero aliquet arcu, non interdum tellus lectus sit amet eros. Cras rhoncus, metus ac ornare cursus, dolor justo ultrices metus, at ullamcorper volutpat", |
||||
output: "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", |
||||
}, |
||||
|
||||
// slices
|
||||
{val: []uint{}, output: "C0"}, |
||||
{val: []uint{1, 2, 3}, output: "C3010203"}, |
||||
{ |
||||
// [ [], [[]], [ [], [[]] ] ]
|
||||
val: []interface{}{[]interface{}{}, [][]interface{}{{}}, []interface{}{[]interface{}{}, [][]interface{}{{}}}}, |
||||
output: "C7C0C1C0C3C0C1C0", |
||||
}, |
||||
{ |
||||
val: []string{"aaa", "bbb", "ccc", "ddd", "eee", "fff", "ggg", "hhh", "iii", "jjj", "kkk", "lll", "mmm", "nnn", "ooo"}, |
||||
output: "F83C836161618362626283636363836464648365656583666666836767678368686883696969836A6A6A836B6B6B836C6C6C836D6D6D836E6E6E836F6F6F", |
||||
}, |
||||
{ |
||||
val: []interface{}{uint(1), uint(0xFFFFFF), []interface{}{[]uint{4, 5, 5}}, "abc"}, |
||||
output: "CE0183FFFFFFC4C304050583616263", |
||||
}, |
||||
{ |
||||
val: [][]string{ |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
{"asdf", "qwer", "zxcv"}, |
||||
}, |
||||
output: "F90200CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376", |
||||
}, |
||||
|
||||
// RawValue
|
||||
{val: RawValue(unhex("01")), output: "01"}, |
||||
{val: RawValue(unhex("82FFFF")), output: "82FFFF"}, |
||||
{val: []RawValue{unhex("01"), unhex("02")}, output: "C20102"}, |
||||
|
||||
// structs
|
||||
{val: simplestruct{}, output: "C28080"}, |
||||
{val: simplestruct{A: 3, B: "foo"}, output: "C50383666F6F"}, |
||||
{val: &recstruct{5, nil}, output: "C205C0"}, |
||||
{val: &recstruct{5, &recstruct{4, &recstruct{3, nil}}}, output: "C605C404C203C0"}, |
||||
{val: &tailRaw{A: 1, Tail: []RawValue{unhex("02"), unhex("03")}}, output: "C3010203"}, |
||||
{val: &tailRaw{A: 1, Tail: []RawValue{unhex("02")}}, output: "C20102"}, |
||||
{val: &tailRaw{A: 1, Tail: []RawValue{}}, output: "C101"}, |
||||
{val: &tailRaw{A: 1, Tail: nil}, output: "C101"}, |
||||
{val: &hasIgnoredField{A: 1, B: 2, C: 3}, output: "C20103"}, |
||||
|
||||
// nil
|
||||
{val: (*uint)(nil), output: "80"}, |
||||
{val: (*string)(nil), output: "80"}, |
||||
{val: (*[]byte)(nil), output: "80"}, |
||||
{val: (*[10]byte)(nil), output: "80"}, |
||||
{val: (*big.Int)(nil), output: "80"}, |
||||
{val: (*[]string)(nil), output: "C0"}, |
||||
{val: (*[10]string)(nil), output: "C0"}, |
||||
{val: (*[]interface{})(nil), output: "C0"}, |
||||
{val: (*[]struct{ uint })(nil), output: "C0"}, |
||||
{val: (*interface{})(nil), output: "C0"}, |
||||
|
||||
// interfaces
|
||||
{val: []io.Reader{reader}, output: "C3C20102"}, // the contained value is a struct
|
||||
|
||||
// Encoder
|
||||
{val: (*testEncoder)(nil), output: "00000000"}, |
||||
{val: &testEncoder{}, output: "00010001000100010001"}, |
||||
{val: &testEncoder{errors.New("test error")}, error: "test error"}, |
||||
// verify that pointer method testEncoder.EncodeRLP is called for
|
||||
// addressable non-pointer values.
|
||||
{val: &struct{ TE testEncoder }{testEncoder{}}, output: "CA00010001000100010001"}, |
||||
{val: &struct{ TE testEncoder }{testEncoder{errors.New("test error")}}, error: "test error"}, |
||||
// verify the error for non-addressable non-pointer Encoder
|
||||
{val: testEncoder{}, error: "rlp: game over: unadressable value of type rlp.testEncoder, EncodeRLP is pointer method"}, |
||||
// verify the special case for []byte
|
||||
{val: []byteEncoder{0, 1, 2, 3, 4}, output: "C5C0C0C0C0C0"}, |
||||
} |
||||
|
||||
func runEncTests(t *testing.T, f func(val interface{}) ([]byte, error)) { |
||||
for i, test := range encTests { |
||||
output, err := f(test.val) |
||||
if err != nil && test.error == "" { |
||||
t.Errorf("test %d: unexpected error: %v\nvalue %#v\ntype %T", |
||||
i, err, test.val, test.val) |
||||
continue |
||||
} |
||||
if test.error != "" && fmt.Sprint(err) != test.error { |
||||
t.Errorf("test %d: error mismatch\ngot %v\nwant %v\nvalue %#v\ntype %T", |
||||
i, err, test.error, test.val, test.val) |
||||
continue |
||||
} |
||||
if err == nil && !bytes.Equal(output, unhex(test.output)) { |
||||
t.Errorf("test %d: output mismatch:\ngot %X\nwant %s\nvalue %#v\ntype %T", |
||||
i, output, test.output, test.val, test.val) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestEncode(t *testing.T) { |
||||
runEncTests(t, func(val interface{}) ([]byte, error) { |
||||
b := new(bytes.Buffer) |
||||
err := Encode(b, val) |
||||
return b.Bytes(), err |
||||
}) |
||||
} |
||||
|
||||
func TestEncodeToBytes(t *testing.T) { |
||||
runEncTests(t, EncodeToBytes) |
||||
} |
||||
|
||||
func TestEncodeToReader(t *testing.T) { |
||||
runEncTests(t, func(val interface{}) ([]byte, error) { |
||||
_, r, err := EncodeToReader(val) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return ioutil.ReadAll(r) |
||||
}) |
||||
} |
||||
|
||||
func TestEncodeToReaderPiecewise(t *testing.T) { |
||||
runEncTests(t, func(val interface{}) ([]byte, error) { |
||||
size, r, err := EncodeToReader(val) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// read output piecewise
|
||||
output := make([]byte, size) |
||||
for start, end := 0, 0; start < size; start = end { |
||||
if remaining := size - start; remaining < 3 { |
||||
end += remaining |
||||
} else { |
||||
end = start + 3 |
||||
} |
||||
n, err := r.Read(output[start:end]) |
||||
end = start + n |
||||
if err == io.EOF { |
||||
break |
||||
} else if err != nil { |
||||
return nil, err |
||||
} |
||||
} |
||||
return output, nil |
||||
}) |
||||
} |
||||
|
||||
// This is a regression test verifying that encReader
|
||||
// returns its encbuf to the pool only once.
|
||||
func TestEncodeToReaderReturnToPool(t *testing.T) { |
||||
buf := make([]byte, 50) |
||||
wg := new(sync.WaitGroup) |
||||
for i := 0; i < 5; i++ { |
||||
wg.Add(1) |
||||
go func() { |
||||
for i := 0; i < 1000; i++ { |
||||
_, r, _ := EncodeToReader("foo") |
||||
ioutil.ReadAll(r) |
||||
r.Read(buf) |
||||
r.Read(buf) |
||||
r.Read(buf) |
||||
r.Read(buf) |
||||
} |
||||
wg.Done() |
||||
}() |
||||
} |
||||
wg.Wait() |
||||
} |
||||
@ -0,0 +1,54 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io" |
||||
) |
||||
|
||||
type MyCoolType struct { |
||||
Name string |
||||
a, b uint |
||||
} |
||||
|
||||
// EncodeRLP writes x as RLP list [a, b] that omits the Name field.
|
||||
func (x *MyCoolType) EncodeRLP(w io.Writer) (err error) { |
||||
// Note: the receiver can be a nil pointer. This allows you to
|
||||
// control the encoding of nil, but it also means that you have to
|
||||
// check for a nil receiver.
|
||||
if x == nil { |
||||
err = Encode(w, []uint{0, 0}) |
||||
} else { |
||||
err = Encode(w, []uint{x.a, x.b}) |
||||
} |
||||
return err |
||||
} |
||||
|
||||
func ExampleEncoder() { |
||||
var t *MyCoolType // t is nil pointer to MyCoolType
|
||||
bytes, _ := EncodeToBytes(t) |
||||
fmt.Printf("%v → %X\n", t, bytes) |
||||
|
||||
t = &MyCoolType{Name: "foobar", a: 5, b: 6} |
||||
bytes, _ = EncodeToBytes(t) |
||||
fmt.Printf("%v → %X\n", t, bytes) |
||||
|
||||
// Output:
|
||||
// <nil> → C28080
|
||||
// &{foobar 5 6} → C20506
|
||||
} |
||||
@ -0,0 +1,156 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"io" |
||||
"reflect" |
||||
) |
||||
|
||||
// RawValue represents an encoded RLP value and can be used to delay
|
||||
// RLP decoding or to precompute an encoding. Note that the decoder does
|
||||
// not verify whether the content of RawValues is valid RLP.
|
||||
type RawValue []byte |
||||
|
||||
var rawValueType = reflect.TypeOf(RawValue{}) |
||||
|
||||
// ListSize returns the encoded size of an RLP list with the given
|
||||
// content size.
|
||||
func ListSize(contentSize uint64) uint64 { |
||||
return uint64(headsize(contentSize)) + contentSize |
||||
} |
||||
|
||||
// Split returns the content of first RLP value and any
|
||||
// bytes after the value as subslices of b.
|
||||
func Split(b []byte) (k Kind, content, rest []byte, err error) { |
||||
k, ts, cs, err := readKind(b) |
||||
if err != nil { |
||||
return 0, nil, b, err |
||||
} |
||||
return k, b[ts : ts+cs], b[ts+cs:], nil |
||||
} |
||||
|
||||
// SplitString splits b into the content of an RLP string
|
||||
// and any remaining bytes after the string.
|
||||
func SplitString(b []byte) (content, rest []byte, err error) { |
||||
k, content, rest, err := Split(b) |
||||
if err != nil { |
||||
return nil, b, err |
||||
} |
||||
if k == List { |
||||
return nil, b, ErrExpectedString |
||||
} |
||||
return content, rest, nil |
||||
} |
||||
|
||||
// SplitList splits b into the content of a list and any remaining
|
||||
// bytes after the list.
|
||||
func SplitList(b []byte) (content, rest []byte, err error) { |
||||
k, content, rest, err := Split(b) |
||||
if err != nil { |
||||
return nil, b, err |
||||
} |
||||
if k != List { |
||||
return nil, b, ErrExpectedList |
||||
} |
||||
return content, rest, nil |
||||
} |
||||
|
||||
// CountValues counts the number of encoded values in b.
|
||||
func CountValues(b []byte) (int, error) { |
||||
i := 0 |
||||
for ; len(b) > 0; i++ { |
||||
_, tagsize, size, err := readKind(b) |
||||
if err != nil { |
||||
return 0, err |
||||
} |
||||
b = b[tagsize+size:] |
||||
} |
||||
return i, nil |
||||
} |
||||
|
||||
func readKind(buf []byte) (k Kind, tagsize, contentsize uint64, err error) { |
||||
if len(buf) == 0 { |
||||
return 0, 0, 0, io.ErrUnexpectedEOF |
||||
} |
||||
b := buf[0] |
||||
switch { |
||||
case b < 0x80: |
||||
k = Byte |
||||
tagsize = 0 |
||||
contentsize = 1 |
||||
case b < 0xB8: |
||||
k = String |
||||
tagsize = 1 |
||||
contentsize = uint64(b - 0x80) |
||||
// Reject strings that should've been single bytes.
|
||||
if contentsize == 1 && len(buf) > 1 && buf[1] < 128 { |
||||
return 0, 0, 0, ErrCanonSize |
||||
} |
||||
case b < 0xC0: |
||||
k = String |
||||
tagsize = uint64(b-0xB7) + 1 |
||||
contentsize, err = readSize(buf[1:], b-0xB7) |
||||
case b < 0xF8: |
||||
k = List |
||||
tagsize = 1 |
||||
contentsize = uint64(b - 0xC0) |
||||
default: |
||||
k = List |
||||
tagsize = uint64(b-0xF7) + 1 |
||||
contentsize, err = readSize(buf[1:], b-0xF7) |
||||
} |
||||
if err != nil { |
||||
return 0, 0, 0, err |
||||
} |
||||
// Reject values larger than the input slice.
|
||||
if contentsize > uint64(len(buf))-tagsize { |
||||
return 0, 0, 0, ErrValueTooLarge |
||||
} |
||||
return k, tagsize, contentsize, err |
||||
} |
||||
|
||||
func readSize(b []byte, slen byte) (uint64, error) { |
||||
if int(slen) > len(b) { |
||||
return 0, io.ErrUnexpectedEOF |
||||
} |
||||
var s uint64 |
||||
switch slen { |
||||
case 1: |
||||
s = uint64(b[0]) |
||||
case 2: |
||||
s = uint64(b[0])<<8 | uint64(b[1]) |
||||
case 3: |
||||
s = uint64(b[0])<<16 | uint64(b[1])<<8 | uint64(b[2]) |
||||
case 4: |
||||
s = uint64(b[0])<<24 | uint64(b[1])<<16 | uint64(b[2])<<8 | uint64(b[3]) |
||||
case 5: |
||||
s = uint64(b[0])<<32 | uint64(b[1])<<24 | uint64(b[2])<<16 | uint64(b[3])<<8 | uint64(b[4]) |
||||
case 6: |
||||
s = uint64(b[0])<<40 | uint64(b[1])<<32 | uint64(b[2])<<24 | uint64(b[3])<<16 | uint64(b[4])<<8 | uint64(b[5]) |
||||
case 7: |
||||
s = uint64(b[0])<<48 | uint64(b[1])<<40 | uint64(b[2])<<32 | uint64(b[3])<<24 | uint64(b[4])<<16 | uint64(b[5])<<8 | uint64(b[6]) |
||||
case 8: |
||||
s = uint64(b[0])<<56 | uint64(b[1])<<48 | uint64(b[2])<<40 | uint64(b[3])<<32 | uint64(b[4])<<24 | uint64(b[5])<<16 | uint64(b[6])<<8 | uint64(b[7]) |
||||
} |
||||
// Reject sizes < 56 (shouldn't have separate size) and sizes with
|
||||
// leading zero bytes.
|
||||
if s < 56 || b[0] == 0 { |
||||
return 0, ErrCanonSize |
||||
} |
||||
return s, nil |
||||
} |
||||
@ -0,0 +1,196 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"bytes" |
||||
"io" |
||||
"reflect" |
||||
"testing" |
||||
) |
||||
|
||||
func TestCountValues(t *testing.T) { |
||||
tests := []struct { |
||||
input string // note: spaces in input are stripped by unhex
|
||||
count int |
||||
err error |
||||
}{ |
||||
// simple cases
|
||||
{"", 0, nil}, |
||||
{"00", 1, nil}, |
||||
{"80", 1, nil}, |
||||
{"C0", 1, nil}, |
||||
{"01 02 03", 3, nil}, |
||||
{"01 C406070809 02", 3, nil}, |
||||
{"820101 820202 8403030303 04", 4, nil}, |
||||
|
||||
// size errors
|
||||
{"8142", 0, ErrCanonSize}, |
||||
{"01 01 8142", 0, ErrCanonSize}, |
||||
{"02 84020202", 0, ErrValueTooLarge}, |
||||
|
||||
{ |
||||
input: "A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", |
||||
count: 2, |
||||
}, |
||||
} |
||||
for i, test := range tests { |
||||
count, err := CountValues(unhex(test.input)) |
||||
if count != test.count { |
||||
t.Errorf("test %d: count mismatch, got %d want %d\ninput: %s", i, count, test.count, test.input) |
||||
} |
||||
if !reflect.DeepEqual(err, test.err) { |
||||
t.Errorf("test %d: err mismatch, got %q want %q\ninput: %s", i, err, test.err, test.input) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestSplitTypes(t *testing.T) { |
||||
if _, _, err := SplitString(unhex("C100")); err != ErrExpectedString { |
||||
t.Errorf("SplitString returned %q, want %q", err, ErrExpectedString) |
||||
} |
||||
if _, _, err := SplitList(unhex("01")); err != ErrExpectedList { |
||||
t.Errorf("SplitString returned %q, want %q", err, ErrExpectedList) |
||||
} |
||||
if _, _, err := SplitList(unhex("81FF")); err != ErrExpectedList { |
||||
t.Errorf("SplitString returned %q, want %q", err, ErrExpectedList) |
||||
} |
||||
} |
||||
|
||||
func TestSplit(t *testing.T) { |
||||
tests := []struct { |
||||
input string |
||||
kind Kind |
||||
val, rest string |
||||
err error |
||||
}{ |
||||
{input: "01FFFF", kind: Byte, val: "01", rest: "FFFF"}, |
||||
{input: "80FFFF", kind: String, val: "", rest: "FFFF"}, |
||||
{input: "C3010203", kind: List, val: "010203"}, |
||||
|
||||
// errors
|
||||
{input: "", err: io.ErrUnexpectedEOF}, |
||||
|
||||
{input: "8141", err: ErrCanonSize, rest: "8141"}, |
||||
{input: "B800", err: ErrCanonSize, rest: "B800"}, |
||||
{input: "B802FFFF", err: ErrCanonSize, rest: "B802FFFF"}, |
||||
{input: "B90000", err: ErrCanonSize, rest: "B90000"}, |
||||
{input: "B90055", err: ErrCanonSize, rest: "B90055"}, |
||||
{input: "BA0002FFFF", err: ErrCanonSize, rest: "BA0002FFFF"}, |
||||
{input: "F800", err: ErrCanonSize, rest: "F800"}, |
||||
{input: "F90000", err: ErrCanonSize, rest: "F90000"}, |
||||
{input: "F90055", err: ErrCanonSize, rest: "F90055"}, |
||||
{input: "FA0002FFFF", err: ErrCanonSize, rest: "FA0002FFFF"}, |
||||
|
||||
{input: "81", err: ErrValueTooLarge, rest: "81"}, |
||||
{input: "8501010101", err: ErrValueTooLarge, rest: "8501010101"}, |
||||
{input: "C60607080902", err: ErrValueTooLarge, rest: "C60607080902"}, |
||||
|
||||
// size check overflow
|
||||
{input: "BFFFFFFFFFFFFFFFFF", err: ErrValueTooLarge, rest: "BFFFFFFFFFFFFFFFFF"}, |
||||
{input: "FFFFFFFFFFFFFFFFFF", err: ErrValueTooLarge, rest: "FFFFFFFFFFFFFFFFFF"}, |
||||
|
||||
{ |
||||
input: "B838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
||||
err: ErrValueTooLarge, |
||||
rest: "B838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
||||
}, |
||||
{ |
||||
input: "F838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
||||
err: ErrValueTooLarge, |
||||
rest: "F838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
||||
}, |
||||
|
||||
// a few bigger values, just for kicks
|
||||
{ |
||||
input: "F839FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
||||
kind: List, |
||||
val: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
||||
rest: "", |
||||
}, |
||||
{ |
||||
input: "F90211A060EF29F20CC1007AE6E9530AEE16F4B31F8F1769A2D1264EC995C6D1241868D6A07C62AB8AC9838F5F5877B20BB37B387BC2106E97A3D52172CBEDB5EE17C36008A00EAB6B7324AADC0F6047C6AFC8229F09F7CF451B51D67C8DFB08D49BA8C3C626A04453343B2F3A6E42FCF87948F88AF7C8FC16D0C2735CBA7F026836239AB2C15FA024635C7291C882CE4C0763760C1A362DFC3FFCD802A55722236DE058D74202ACA0A220C808DE10F55E40AB25255201CFF009EA181D3906638E944EE2BF34049984A08D325AB26796F1CCB470F69C0F842501DC35D368A0C2575B2D243CFD1E8AB0FDA0B5298FF60DA5069463D610513C9F04F24051348391A143AFFAB7197DFACDEA72A02D2A7058A4463F8FB69378369E11EF33AE3252E2DB86CB545B36D3C26DDECE5AA0888F97BCA8E0BD83DC5B3B91CFF5FAF2F66F9501010682D67EF4A3B4E66115FBA0E8175A60C93BE9ED02921958F0EA55DA0FB5E4802AF5846147BAD92BC2D8AF26A08B3376FF433F3A4250FA64B7F804004CAC5807877D91C4427BD1CD05CF912ED8A09B32EF0F03BD13C37FF950C0CCCEFCCDD6669F2E7F2AA5CB859928E84E29763EA09BBA5E46610C8C8B1F8E921E5691BF8C7E40D75825D5EA3217AA9C3A8A355F39A0EEB95BC78251CCCEC54A97F19755C4A59A293544EEE6119AFA50531211E53C4FA00B6E86FE150BF4A9E0FEEE9C90F5465E617A861BB5E357F942881EE762212E2580", |
||||
kind: List, |
||||
val: "A060EF29F20CC1007AE6E9530AEE16F4B31F8F1769A2D1264EC995C6D1241868D6A07C62AB8AC9838F5F5877B20BB37B387BC2106E97A3D52172CBEDB5EE17C36008A00EAB6B7324AADC0F6047C6AFC8229F09F7CF451B51D67C8DFB08D49BA8C3C626A04453343B2F3A6E42FCF87948F88AF7C8FC16D0C2735CBA7F026836239AB2C15FA024635C7291C882CE4C0763760C1A362DFC3FFCD802A55722236DE058D74202ACA0A220C808DE10F55E40AB25255201CFF009EA181D3906638E944EE2BF34049984A08D325AB26796F1CCB470F69C0F842501DC35D368A0C2575B2D243CFD1E8AB0FDA0B5298FF60DA5069463D610513C9F04F24051348391A143AFFAB7197DFACDEA72A02D2A7058A4463F8FB69378369E11EF33AE3252E2DB86CB545B36D3C26DDECE5AA0888F97BCA8E0BD83DC5B3B91CFF5FAF2F66F9501010682D67EF4A3B4E66115FBA0E8175A60C93BE9ED02921958F0EA55DA0FB5E4802AF5846147BAD92BC2D8AF26A08B3376FF433F3A4250FA64B7F804004CAC5807877D91C4427BD1CD05CF912ED8A09B32EF0F03BD13C37FF950C0CCCEFCCDD6669F2E7F2AA5CB859928E84E29763EA09BBA5E46610C8C8B1F8E921E5691BF8C7E40D75825D5EA3217AA9C3A8A355F39A0EEB95BC78251CCCEC54A97F19755C4A59A293544EEE6119AFA50531211E53C4FA00B6E86FE150BF4A9E0FEEE9C90F5465E617A861BB5E357F942881EE762212E2580", |
||||
rest: "", |
||||
}, |
||||
{ |
||||
input: "F877A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", |
||||
kind: List, |
||||
val: "A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", |
||||
rest: "", |
||||
}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
kind, val, rest, err := Split(unhex(test.input)) |
||||
if kind != test.kind { |
||||
t.Errorf("test %d: kind mismatch: got %v, want %v", i, kind, test.kind) |
||||
} |
||||
if !bytes.Equal(val, unhex(test.val)) { |
||||
t.Errorf("test %d: val mismatch: got %x, want %s", i, val, test.val) |
||||
} |
||||
if !bytes.Equal(rest, unhex(test.rest)) { |
||||
t.Errorf("test %d: rest mismatch: got %x, want %s", i, rest, test.rest) |
||||
} |
||||
if err != test.err { |
||||
t.Errorf("test %d: error mismatch: got %q, want %q", i, err, test.err) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestReadSize(t *testing.T) { |
||||
tests := []struct { |
||||
input string |
||||
slen byte |
||||
size uint64 |
||||
err error |
||||
}{ |
||||
{input: "", slen: 1, err: io.ErrUnexpectedEOF}, |
||||
{input: "FF", slen: 2, err: io.ErrUnexpectedEOF}, |
||||
{input: "00", slen: 1, err: ErrCanonSize}, |
||||
{input: "36", slen: 1, err: ErrCanonSize}, |
||||
{input: "37", slen: 1, err: ErrCanonSize}, |
||||
{input: "38", slen: 1, size: 0x38}, |
||||
{input: "FF", slen: 1, size: 0xFF}, |
||||
{input: "FFFF", slen: 2, size: 0xFFFF}, |
||||
{input: "FFFFFF", slen: 3, size: 0xFFFFFF}, |
||||
{input: "FFFFFFFF", slen: 4, size: 0xFFFFFFFF}, |
||||
{input: "FFFFFFFFFF", slen: 5, size: 0xFFFFFFFFFF}, |
||||
{input: "FFFFFFFFFFFF", slen: 6, size: 0xFFFFFFFFFFFF}, |
||||
{input: "FFFFFFFFFFFFFF", slen: 7, size: 0xFFFFFFFFFFFFFF}, |
||||
{input: "FFFFFFFFFFFFFFFF", slen: 8, size: 0xFFFFFFFFFFFFFFFF}, |
||||
{input: "0102", slen: 2, size: 0x0102}, |
||||
{input: "010203", slen: 3, size: 0x010203}, |
||||
{input: "01020304", slen: 4, size: 0x01020304}, |
||||
{input: "0102030405", slen: 5, size: 0x0102030405}, |
||||
{input: "010203040506", slen: 6, size: 0x010203040506}, |
||||
{input: "01020304050607", slen: 7, size: 0x01020304050607}, |
||||
{input: "0102030405060708", slen: 8, size: 0x0102030405060708}, |
||||
} |
||||
|
||||
for _, test := range tests { |
||||
size, err := readSize(unhex(test.input), test.slen) |
||||
if err != test.err { |
||||
t.Errorf("readSize(%s, %d): error mismatch: got %q, want %q", test.input, test.slen, err, test.err) |
||||
continue |
||||
} |
||||
if size != test.size { |
||||
t.Errorf("readSize(%s, %d): size mismatch: got %#x, want %#x", test.input, test.slen, size, test.size) |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,156 @@ |
||||
// Copyright 2014 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package rlp |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"strings" |
||||
"sync" |
||||
) |
||||
|
||||
var ( |
||||
typeCacheMutex sync.RWMutex |
||||
typeCache = make(map[typekey]*typeinfo) |
||||
) |
||||
|
||||
type typeinfo struct { |
||||
decoder |
||||
writer |
||||
} |
||||
|
||||
// represents struct tags
|
||||
type tags struct { |
||||
// rlp:"nil" controls whether empty input results in a nil pointer.
|
||||
nilOK bool |
||||
// rlp:"tail" controls whether this field swallows additional list
|
||||
// elements. It can only be set for the last field, which must be
|
||||
// of slice type.
|
||||
tail bool |
||||
// rlp:"-" ignores fields.
|
||||
ignored bool |
||||
} |
||||
|
||||
type typekey struct { |
||||
reflect.Type |
||||
// the key must include the struct tags because they
|
||||
// might generate a different decoder.
|
||||
tags |
||||
} |
||||
|
||||
type decoder func(*Stream, reflect.Value) error |
||||
|
||||
type writer func(reflect.Value, *encbuf) error |
||||
|
||||
func cachedTypeInfo(typ reflect.Type, tags tags) (*typeinfo, error) { |
||||
typeCacheMutex.RLock() |
||||
info := typeCache[typekey{typ, tags}] |
||||
typeCacheMutex.RUnlock() |
||||
if info != nil { |
||||
return info, nil |
||||
} |
||||
// not in the cache, need to generate info for this type.
|
||||
typeCacheMutex.Lock() |
||||
defer typeCacheMutex.Unlock() |
||||
return cachedTypeInfo1(typ, tags) |
||||
} |
||||
|
||||
func cachedTypeInfo1(typ reflect.Type, tags tags) (*typeinfo, error) { |
||||
key := typekey{typ, tags} |
||||
info := typeCache[key] |
||||
if info != nil { |
||||
// another goroutine got the write lock first
|
||||
return info, nil |
||||
} |
||||
// put a dummy value into the cache before generating.
|
||||
// if the generator tries to lookup itself, it will get
|
||||
// the dummy value and won't call itself recursively.
|
||||
typeCache[key] = new(typeinfo) |
||||
info, err := genTypeInfo(typ, tags) |
||||
if err != nil { |
||||
// remove the dummy value if the generator fails
|
||||
delete(typeCache, key) |
||||
return nil, err |
||||
} |
||||
*typeCache[key] = *info |
||||
return typeCache[key], err |
||||
} |
||||
|
||||
type field struct { |
||||
index int |
||||
info *typeinfo |
||||
} |
||||
|
||||
func structFields(typ reflect.Type) (fields []field, err error) { |
||||
for i := 0; i < typ.NumField(); i++ { |
||||
if f := typ.Field(i); f.PkgPath == "" { // exported
|
||||
tags, err := parseStructTag(typ, i) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
if tags.ignored { |
||||
continue |
||||
} |
||||
info, err := cachedTypeInfo1(f.Type, tags) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
fields = append(fields, field{i, info}) |
||||
} |
||||
} |
||||
return fields, nil |
||||
} |
||||
|
||||
func parseStructTag(typ reflect.Type, fi int) (tags, error) { |
||||
f := typ.Field(fi) |
||||
var ts tags |
||||
for _, t := range strings.Split(f.Tag.Get("rlp"), ",") { |
||||
switch t = strings.TrimSpace(t); t { |
||||
case "": |
||||
case "-": |
||||
ts.ignored = true |
||||
case "nil": |
||||
ts.nilOK = true |
||||
case "tail": |
||||
ts.tail = true |
||||
if fi != typ.NumField()-1 { |
||||
return ts, fmt.Errorf(`rlp: invalid struct tag "tail" for %v.%s (must be on last field)`, typ, f.Name) |
||||
} |
||||
if f.Type.Kind() != reflect.Slice { |
||||
return ts, fmt.Errorf(`rlp: invalid struct tag "tail" for %v.%s (field type is not slice)`, typ, f.Name) |
||||
} |
||||
default: |
||||
return ts, fmt.Errorf("rlp: unknown struct tag %q on %v.%s", t, typ, f.Name) |
||||
} |
||||
} |
||||
return ts, nil |
||||
} |
||||
|
||||
func genTypeInfo(typ reflect.Type, tags tags) (info *typeinfo, err error) { |
||||
info = new(typeinfo) |
||||
if info.decoder, err = makeDecoder(typ, tags); err != nil { |
||||
return nil, err |
||||
} |
||||
if info.writer, err = makeWriter(typ, tags); err != nil { |
||||
return nil, err |
||||
} |
||||
return info, nil |
||||
} |
||||
|
||||
func isUint(k reflect.Kind) bool { |
||||
return k >= reflect.Uint && k <= reflect.Uintptr |
||||
} |
||||
Loading…
Reference in new issue