// TestVersion tests the MsgVersion API.
func TestVersion(t *testing.T) {
pver := btcwire.ProtocolVersion
// Create version message data.
userAgent := "/btcdtest:0.0.1/"
lastBlock := int32(234234)
tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333}
me, err := btcwire.NewNetAddress(tcpAddrMe, btcwire.SFNodeNetwork)
if err != nil {
t.Errorf("NewNetAddress: %v", err)
}
tcpAddrYou := &net.TCPAddr{IP: net.ParseIP("192.168.0.1"), Port: 8333}
you, err := btcwire.NewNetAddress(tcpAddrYou, btcwire.SFNodeNetwork)
if err != nil {
t.Errorf("NewNetAddress: %v", err)
}
nonce, err := btcwire.RandomUint64()
if err != nil {
t.Errorf("RandomUint64: error generating nonce: %v", err)
}
// Ensure we get the correct data back out.
msg := btcwire.NewMsgVersion(me, you, nonce, userAgent, lastBlock)
if msg.ProtocolVersion != int32(pver) {
t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
msg.ProtocolVersion, pver)
}
if !reflect.DeepEqual(&msg.AddrMe, me) {
t.Errorf("NewMsgVersion: wrong me address - got %v, want %v",
spew.Sdump(&msg.AddrMe), spew.Sdump(me))
}
if !reflect.DeepEqual(&msg.AddrYou, you) {
t.Errorf("NewMsgVersion: wrong you address - got %v, want %v",
spew.Sdump(&msg.AddrYou), spew.Sdump(you))
}
if msg.Nonce != nonce {
t.Errorf("NewMsgVersion: wrong nonce - got %v, want %v",
msg.Nonce, nonce)
}
if msg.UserAgent != userAgent {
t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
msg.UserAgent, userAgent)
}
if msg.LastBlock != lastBlock {
t.Errorf("NewMsgVersion: wrong last block - got %v, want %v",
msg.LastBlock, lastBlock)
}
// Version message should not have any services set by default.
if msg.Services != 0 {
t.Errorf("NewMsgVersion: wrong default services - got %v, want %v",
msg.Services, 0)
}
if msg.HasService(btcwire.SFNodeNetwork) {
t.Errorf("HasService: SFNodeNetwork service is set")
}
// Ensure the command is expected value.
wantCmd := "version"
if cmd := msg.Command(); cmd != wantCmd {
t.Errorf("NewMsgVersion: wrong command - got %v want %v",
cmd, wantCmd)
}
// Ensure max payload is expected value.
// Protocol version 4 bytes + services 8 bytes + timestamp 8 bytes +
// remote and local net addresses + nonce 8 bytes + length of user agent
// (varInt) + max allowed user agent length + last block 4 bytes.
wantPayload := uint32(2101)
maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+
"protocol version %d - got %v, want %v", pver,
maxPayload, wantPayload)
}
// Ensure adding the full service node flag works.
msg.AddService(btcwire.SFNodeNetwork)
if msg.Services != btcwire.SFNodeNetwork {
t.Errorf("AddService: wrong services - got %v, want %v",
msg.Services, btcwire.SFNodeNetwork)
}
if !msg.HasService(btcwire.SFNodeNetwork) {
t.Errorf("HasService: SFNodeNetwork service not set")
}
// Use a fake connection.
conn := &fakeConn{localAddr: tcpAddrMe, remoteAddr: tcpAddrYou}
msg, err = btcwire.NewMsgVersionFromConn(conn, nonce, userAgent, lastBlock)
if err != nil {
t.Errorf("NewMsgVersionFromConn: %v", err)
}
// Ensure we get the correct connection data back out.
if !msg.AddrMe.IP.Equal(tcpAddrMe.IP) {
t.Errorf("NewMsgVersionFromConn: wrong me ip - got %v, want %v",
msg.AddrMe.IP, tcpAddrMe.IP)
}
if !msg.AddrYou.IP.Equal(tcpAddrYou.IP) {
t.Errorf("NewMsgVersionFromConn: wrong you ip - got %v, want %v",
msg.AddrYou.IP, tcpAddrYou.IP)
}
// Use a fake connection with local UDP addresses to force a failure.
conn = &fakeConn{
localAddr: &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333},
remoteAddr: tcpAddrYou,
}
msg, err = btcwire.NewMsgVersionFromConn(conn, nonce, userAgent, lastBlock)
if err != btcwire.ErrInvalidNetAddr {
t.Errorf("NewMsgVersionFromConn: expected error not received "+
"- got %v, want %v", err, btcwire.ErrInvalidNetAddr)
}
// Use a fake connection with remote UDP addresses to force a failure.
conn = &fakeConn{
localAddr: tcpAddrMe,
remoteAddr: &net.UDPAddr{IP: net.ParseIP("192.168.0.1"), Port: 8333},
}
msg, err = btcwire.NewMsgVersionFromConn(conn, nonce, userAgent, lastBlock)
if err != btcwire.ErrInvalidNetAddr {
t.Errorf("NewMsgVersionFromConn: expected error not received "+
"- got %v, want %v", err, btcwire.ErrInvalidNetAddr)
}
return
}
// TestVersion tests the MsgVersion API.
func TestVersion(t *testing.T) {
pver := btcwire.ProtocolVersion
// Create version message data.
lastBlock := int32(234234)
tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333}
me, err := btcwire.NewNetAddress(tcpAddrMe, btcwire.SFNodeNetwork)
if err != nil {
t.Errorf("NewNetAddress: %v", err)
}
tcpAddrYou := &net.TCPAddr{IP: net.ParseIP("192.168.0.1"), Port: 8333}
you, err := btcwire.NewNetAddress(tcpAddrYou, btcwire.SFNodeNetwork)
if err != nil {
t.Errorf("NewNetAddress: %v", err)
}
nonce, err := btcwire.RandomUint64()
if err != nil {
t.Errorf("RandomUint64: error generating nonce: %v", err)
}
// Ensure we get the correct data back out.
msg := btcwire.NewMsgVersion(me, you, nonce, lastBlock)
if msg.ProtocolVersion != int32(pver) {
t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
msg.ProtocolVersion, pver)
}
if !reflect.DeepEqual(&msg.AddrMe, me) {
t.Errorf("NewMsgVersion: wrong me address - got %v, want %v",
spew.Sdump(&msg.AddrMe), spew.Sdump(me))
}
if !reflect.DeepEqual(&msg.AddrYou, you) {
t.Errorf("NewMsgVersion: wrong you address - got %v, want %v",
spew.Sdump(&msg.AddrYou), spew.Sdump(you))
}
if msg.Nonce != nonce {
t.Errorf("NewMsgVersion: wrong nonce - got %v, want %v",
msg.Nonce, nonce)
}
if msg.UserAgent != btcwire.DefaultUserAgent {
t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
msg.UserAgent, btcwire.DefaultUserAgent)
}
if msg.LastBlock != lastBlock {
t.Errorf("NewMsgVersion: wrong last block - got %v, want %v",
msg.LastBlock, lastBlock)
}
if msg.DisableRelayTx != false {
t.Errorf("NewMsgVersion: disable relay tx is not false by "+
"default - got %v, want %v", msg.DisableRelayTx, false)
}
msg.AddUserAgent("myclient", "1.2.3", "optional", "comments")
customUserAgent := btcwire.DefaultUserAgent + "myclient:1.2.3(optional; comments)/"
if msg.UserAgent != customUserAgent {
t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
msg.UserAgent, customUserAgent)
}
msg.AddUserAgent("mygui", "3.4.5")
customUserAgent += "mygui:3.4.5/"
if msg.UserAgent != customUserAgent {
t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
msg.UserAgent, customUserAgent)
}
// accounting for ":", "/"
err = msg.AddUserAgent(strings.Repeat("t",
btcwire.MaxUserAgentLen-len(customUserAgent)-2+1), "")
if _, ok := err.(*btcwire.MessageError); !ok {
t.Errorf("AddUserAgent: expected error not received "+
"- got %v, want %T", err, btcwire.MessageError{})
}
// Version message should not have any services set by default.
if msg.Services != 0 {
t.Errorf("NewMsgVersion: wrong default services - got %v, want %v",
msg.Services, 0)
}
if msg.HasService(btcwire.SFNodeNetwork) {
t.Errorf("HasService: SFNodeNetwork service is set")
}
// Ensure the command is expected value.
wantCmd := "version"
if cmd := msg.Command(); cmd != wantCmd {
t.Errorf("NewMsgVersion: wrong command - got %v want %v",
cmd, wantCmd)
}
// Ensure max payload is expected value.
// Protocol version 4 bytes + services 8 bytes + timestamp 8 bytes +
// remote and local net addresses + nonce 8 bytes + length of user agent
// (varInt) + max allowed user agent length + last block 4 bytes +
// relay transactions flag 1 byte.
wantPayload := uint32(2102)
maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+
"protocol version %d - got %v, want %v", pver,
maxPayload, wantPayload)
}
// Ensure adding the full service node flag works.
msg.AddService(btcwire.SFNodeNetwork)
if msg.Services != btcwire.SFNodeNetwork {
t.Errorf("AddService: wrong services - got %v, want %v",
msg.Services, btcwire.SFNodeNetwork)
}
if !msg.HasService(btcwire.SFNodeNetwork) {
t.Errorf("HasService: SFNodeNetwork service not set")
}
// Use a fake connection.
conn := &fakeConn{localAddr: tcpAddrMe, remoteAddr: tcpAddrYou}
msg, err = btcwire.NewMsgVersionFromConn(conn, nonce, lastBlock)
if err != nil {
t.Errorf("NewMsgVersionFromConn: %v", err)
}
// Ensure we get the correct connection data back out.
if !msg.AddrMe.IP.Equal(tcpAddrMe.IP) {
t.Errorf("NewMsgVersionFromConn: wrong me ip - got %v, want %v",
msg.AddrMe.IP, tcpAddrMe.IP)
}
if !msg.AddrYou.IP.Equal(tcpAddrYou.IP) {
t.Errorf("NewMsgVersionFromConn: wrong you ip - got %v, want %v",
msg.AddrYou.IP, tcpAddrYou.IP)
}
// Use a fake connection with local UDP addresses to force a failure.
conn = &fakeConn{
localAddr: &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8333},
remoteAddr: tcpAddrYou,
}
msg, err = btcwire.NewMsgVersionFromConn(conn, nonce, lastBlock)
if err != btcwire.ErrInvalidNetAddr {
t.Errorf("NewMsgVersionFromConn: expected error not received "+
"- got %v, want %v", err, btcwire.ErrInvalidNetAddr)
}
// Use a fake connection with remote UDP addresses to force a failure.
conn = &fakeConn{
localAddr: tcpAddrMe,
remoteAddr: &net.UDPAddr{IP: net.ParseIP("192.168.0.1"), Port: 8333},
}
msg, err = btcwire.NewMsgVersionFromConn(conn, nonce, lastBlock)
if err != btcwire.ErrInvalidNetAddr {
t.Errorf("NewMsgVersionFromConn: expected error not received "+
"- got %v, want %v", err, btcwire.ErrInvalidNetAddr)
}
return
}
func connHandler(id int, outAddrs chan<- []*btc.NetAddress, outNode chan<- Node, inAddr <-chan *btc.NetAddress) {
// A worker that deals with the connection to a single bitcoin node.
// It writes the list of nodes reported by node into out.
// It also writes a valid node into outNode.
// It reads from inAddr everytime it closes a connection
for {
addr := <-inAddr
strA := addressFmt(*addr)
threadLog := func(reported LogLevel, msg string) {
if reported <= Level {
logger.Printf("[%d] %s: %s\n", id, strA, msg)
}
}
connProtoVer := btc.ProtocolVersion
write := composeWrite(threadLog, connProtoVer)
conn, err := net.DialTimeout("tcp", strA, time.Millisecond*500)
if err != nil {
threadLog(Log, err.Error())
continue
}
threadLog(Info, "Connected")
ver_m, _ := btc.NewMsgVersionFromConn(conn, genNonce(), 0)
ver_m.AddUserAgent("btcmonitor", "0.0.1")
write(conn, ver_m)
// We are looking for successful addr messages
wins := 0
// After 10 seconds we just close the conn and handle errors
time.AfterFunc(time.Second*10, func() { conn.Close() })
MessageLoop:
for {
var resp btc.Message
resp, _, err := btc.ReadMessage(conn, connProtoVer, btcnet)
if err != nil {
threadLog(Log, err.Error())
break MessageLoop
}
threadLog(Info, resp.Command())
switch resp := resp.(type) {
case *btc.MsgVersion:
nodePVer := uint32(resp.ProtocolVersion)
if nodePVer < connProtoVer {
connProtoVer = nodePVer
write = composeWrite(threadLog, connProtoVer)
}
node := convNode(*addr, *resp)
outNode <- node
verack := btc.NewMsgVerAck()
write(conn, verack)
getAddr := btc.NewMsgGetAddr()
write(conn, getAddr)
case *btc.MsgAddr:
wins += 1
addrs := resp.AddrList
outAddrs <- addrs
if wins == 3 {
break MessageLoop
}
case *btc.MsgPing:
nonce := resp.Nonce
pong := btc.NewMsgPong(nonce)
write(conn, pong)
}
}
}
}
func nodeHandler(cfg TowerCfg, txStream chan<- *TxMeta, blockStream chan<- *btcwire.MsgBlock) {
conn := setupConn(cfg.Addr, cfg.Logger)
connparams := connParams{
conn: conn,
pver: btcwire.ProtocolVersion,
btcnet: cfg.Net,
logger: cfg.Logger,
insetup: true,
}
read, write := composeConnOuts(connparams)
// Initial handshake
ver_m, _ := btcwire.NewMsgVersionFromConn(conn, genNonce(), int32(cfg.StartHeight))
ver_m.AddUserAgent("Watchtower", "0.0.0")
write(ver_m)
// Wait for responses
acked, responded := false, false
for {
var msg btcwire.Message
msg = read()
cfg.Logger.Println(msg.Command())
switch msg := msg.(type) {
case *btcwire.MsgVersion:
responded = true
ack := btcwire.NewMsgVerAck()
nodeVer := uint32(msg.ProtocolVersion)
if nodeVer < connparams.pver {
connparams.pver = nodeVer
read, write = composeConnOuts(connparams)
}
write(ack)
case *btcwire.MsgVerAck:
acked = true
}
if responded && acked {
break
}
}
// We are through the initial handshake, assume functional channel from here
// on out. If there any errors with the pipe logger.Fatal gets called.
connparams.insetup = false
read, write = composeConnOuts(connparams)
cfg.Logger.Println("Conn Negotiated")
for {
// If there are messages to send to peers send them. Otherwise, listen!
select {
case msg := <-cfg.MsgChan:
write(msg)
default:
// listen for txs + blocks then push them into the appropriatestreams
msg := read()
switch msg := msg.(type) {
case *btcwire.MsgInv:
want := btcwire.NewMsgGetData()
invVec := msg.InvList
for i := range invVec {
chunk := invVec[i]
want.AddInvVect(chunk)
}
write(want)
case *btcwire.MsgTx:
var empt []byte // evaluates to nil
meta := TxMeta{MsgTx: msg, BlockSha: empt, Time: time.Now()}
txStream <- &meta
case *btcwire.MsgBlock:
blockStream <- msg
case *btcwire.MsgPing:
pong := btcwire.NewMsgPong(msg.Nonce)
// More fun than anything...
write(pong)
}
}
}
}