func NewAddressRecord(msg *wire.MsgAddr, ra *net.TCPAddr,
la *net.TCPAddr) *AddressRecord {
ar := &AddressRecord{
Record: Record{
stamp: time.Now(),
ra: ra,
la: la,
cmd: msg.Command(),
},
addrs: make([]*EntryRecord, len(msg.AddrList)),
}
for i, na := range msg.AddrList {
ar.addrs[i] = NewEntryRecord(na)
}
return ar
}
// TestAddrWireErrors performs negative tests against wire encode and decode
// of MsgAddr to confirm error paths work correctly.
func TestAddrWireErrors(t *testing.T) {
pver := wire.ProtocolVersion
pverMA := wire.MultipleAddressVersion
wireErr := &wire.MessageError{}
// A couple of NetAddresses to use for testing.
na := &wire.NetAddress{
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Services: wire.SFNodeNetwork,
IP: net.ParseIP("127.0.0.1"),
Port: 8333,
}
na2 := &wire.NetAddress{
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Services: wire.SFNodeNetwork,
IP: net.ParseIP("192.168.0.1"),
Port: 8334,
}
// Address message with multiple addresses.
baseAddr := wire.NewMsgAddr()
baseAddr.AddAddresses(na, na2)
baseAddrEncoded := []byte{
0x02, // Varint for number of addresses
0x29, 0xab, 0x5f, 0x49, // Timestamp
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01, // IP 127.0.0.1
0x20, 0x8d, // Port 8333 in big-endian
0x29, 0xab, 0x5f, 0x49, // Timestamp
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xc0, 0xa8, 0x00, 0x01, // IP 192.168.0.1
0x20, 0x8e, // Port 8334 in big-endian
}
// Message that forces an error by having more than the max allowed
// addresses.
maxAddr := wire.NewMsgAddr()
for i := 0; i < wire.MaxAddrPerMsg; i++ {
maxAddr.AddAddress(na)
}
maxAddr.AddrList = append(maxAddr.AddrList, na)
maxAddrEncoded := []byte{
0xfd, 0x03, 0xe9, // Varint for number of addresses (1001)
}
tests := []struct {
in *wire.MsgAddr // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
}{
// Latest protocol version with intentional read/write errors.
// Force error in addresses count
{baseAddr, baseAddrEncoded, pver, 0, io.ErrShortWrite, io.EOF},
// Force error in address list.
{baseAddr, baseAddrEncoded, pver, 1, io.ErrShortWrite, io.EOF},
// Force error with greater than max inventory vectors.
{maxAddr, maxAddrEncoded, pver, 3, wireErr, wireErr},
// Force error with greater than max inventory vectors for
// protocol versions before multiple addresses were allowed.
{maxAddr, maxAddrEncoded, pverMA - 1, 3, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
if reflect.TypeOf(err) != reflect.TypeOf(test.writeErr) {
t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
i, err, test.writeErr)
continue
}
// For errors which are not of type wire.MessageError, check
// them for equality.
if _, ok := err.(*wire.MessageError); !ok {
if err != test.writeErr {
t.Errorf("BtcEncode #%d wrong error got: %v, "+
"want: %v", i, err, test.writeErr)
continue
}
}
// Decode from wire format.
var msg wire.MsgAddr
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)
continue
}
// For errors which are not of type wire.MessageError, check
// them for equality.
if _, ok := err.(*wire.MessageError); !ok {
if err != test.readErr {
t.Errorf("BtcDecode #%d wrong error got: %v, "+
"want: %v", i, err, test.readErr)
continue
}
}
}
}
// TestAddrWire tests the MsgAddr wire encode and decode for various numbers
// of addreses and protocol versions.
func TestAddrWire(t *testing.T) {
// A couple of NetAddresses to use for testing.
na := &wire.NetAddress{
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Services: wire.SFNodeNetwork,
IP: net.ParseIP("127.0.0.1"),
Port: 8333,
}
na2 := &wire.NetAddress{
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Services: wire.SFNodeNetwork,
IP: net.ParseIP("192.168.0.1"),
Port: 8334,
}
// Empty address message.
noAddr := wire.NewMsgAddr()
noAddrEncoded := []byte{
0x00, // Varint for number of addresses
}
// Address message with multiple addresses.
multiAddr := wire.NewMsgAddr()
multiAddr.AddAddresses(na, na2)
multiAddrEncoded := []byte{
0x02, // Varint for number of addresses
0x29, 0xab, 0x5f, 0x49, // Timestamp
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01, // IP 127.0.0.1
0x20, 0x8d, // Port 8333 in big-endian
0x29, 0xab, 0x5f, 0x49, // Timestamp
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xc0, 0xa8, 0x00, 0x01, // IP 192.168.0.1
0x20, 0x8e, // Port 8334 in big-endian
}
tests := []struct {
in *wire.MsgAddr // Message to encode
out *wire.MsgAddr // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
}{
// Latest protocol version with no addresses.
{
noAddr,
noAddr,
noAddrEncoded,
wire.ProtocolVersion,
},
// Latest protocol version with multiple addresses.
{
multiAddr,
multiAddr,
multiAddrEncoded,
wire.ProtocolVersion,
},
// Protocol version MultipleAddressVersion-1 with no addresses.
{
noAddr,
noAddr,
noAddrEncoded,
wire.MultipleAddressVersion - 1,
},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
}
if !bytes.Equal(buf.Bytes(), test.buf) {
t.Errorf("BtcEncode #%d\n got: %s want: %s", i,
spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
continue
}
// Decode the message from wire format.
var msg wire.MsgAddr
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
}
if !reflect.DeepEqual(&msg, test.out) {
t.Errorf("BtcDecode #%d\n got: %s want: %s", i,
spew.Sdump(msg), spew.Sdump(test.out))
continue
}
}
}