2014-07-18 13:56:17 +00:00
|
|
|
// Rust Bitcoin Library
|
|
|
|
// Written in 2014 by
|
2015-04-07 01:51:11 +00:00
|
|
|
// Andrew Poelstra <apoelstra@wpsoftware.net>
|
2014-07-18 13:56:17 +00:00
|
|
|
//
|
|
|
|
// To the extent possible under law, the author(s) have dedicated all
|
|
|
|
// copyright and related and neighboring rights to this software to
|
|
|
|
// the public domain worldwide. This software is distributed without
|
|
|
|
// any warranty.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the CC0 Public Domain Dedication
|
|
|
|
// along with this software.
|
|
|
|
// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
|
|
|
|
//
|
|
|
|
|
2018-08-08 21:38:50 +00:00
|
|
|
//! Network message
|
2014-07-18 13:56:17 +00:00
|
|
|
//!
|
|
|
|
//! This module defines the `Message` traits which are used
|
|
|
|
//! for (de)serializing Bitcoin objects for transmission on the network. It
|
|
|
|
//! also defines (de)serialization routines for many primitives.
|
|
|
|
//!
|
|
|
|
|
2019-07-11 14:56:37 +00:00
|
|
|
use std::{io, iter, mem};
|
2015-04-11 01:55:59 +00:00
|
|
|
use std::io::Cursor;
|
2014-07-18 13:56:17 +00:00
|
|
|
|
|
|
|
use blockdata::block;
|
2014-08-23 23:37:01 +00:00
|
|
|
use blockdata::transaction;
|
2014-07-18 13:56:17 +00:00
|
|
|
use network::address::Address;
|
|
|
|
use network::message_network;
|
|
|
|
use network::message_blockdata;
|
2019-02-08 12:00:51 +00:00
|
|
|
use network::message_filter;
|
2019-07-11 17:06:42 +00:00
|
|
|
use consensus::encode::{CheckedData, Decodable, Encodable, VarInt};
|
|
|
|
use consensus::{encode, serialize};
|
2019-05-17 21:53:38 +00:00
|
|
|
use consensus::encode::MAX_VEC_SIZE;
|
2014-07-18 13:56:17 +00:00
|
|
|
|
|
|
|
/// Serializer for command string
|
2015-03-26 15:35:31 +00:00
|
|
|
#[derive(PartialEq, Eq, Clone, Debug)]
|
2014-07-18 13:56:17 +00:00
|
|
|
pub struct CommandString(pub String);
|
|
|
|
|
2019-07-11 14:56:37 +00:00
|
|
|
impl Encodable for CommandString {
|
2015-04-07 01:51:11 +00:00
|
|
|
#[inline]
|
2019-07-11 14:56:37 +00:00
|
|
|
fn consensus_encode<S: io::Write>(
|
|
|
|
&self,
|
|
|
|
s: S,
|
|
|
|
) -> Result<usize, encode::Error> {
|
2015-04-07 01:51:11 +00:00
|
|
|
let &CommandString(ref inner_str) = self;
|
2015-12-18 04:45:11 +00:00
|
|
|
let mut rawbytes = [0u8; 12];
|
2015-11-08 00:02:28 +00:00
|
|
|
let strbytes = inner_str.as_bytes();
|
|
|
|
if strbytes.len() > 12 {
|
|
|
|
panic!("Command string longer than 12 bytes");
|
|
|
|
}
|
|
|
|
for x in 0..strbytes.len() {
|
|
|
|
rawbytes[x] = strbytes[x];
|
|
|
|
}
|
2015-04-07 01:51:11 +00:00
|
|
|
rawbytes.consensus_encode(s)
|
|
|
|
}
|
2014-08-01 16:01:39 +00:00
|
|
|
}
|
2014-07-18 13:56:17 +00:00
|
|
|
|
2019-07-11 17:06:42 +00:00
|
|
|
impl Decodable for CommandString {
|
2015-04-07 01:51:11 +00:00
|
|
|
#[inline]
|
2019-07-11 17:06:42 +00:00
|
|
|
fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
let rawbytes: [u8; 12] = Decodable::consensus_decode(d)?;
|
2019-07-11 17:06:42 +00:00
|
|
|
let rv = iter::FromIterator::from_iter(
|
|
|
|
rawbytes
|
|
|
|
.iter()
|
|
|
|
.filter_map(|&u| if u > 0 { Some(u as char) } else { None })
|
|
|
|
);
|
2015-04-07 01:51:11 +00:00
|
|
|
Ok(CommandString(rv))
|
|
|
|
}
|
2014-07-18 13:56:17 +00:00
|
|
|
}
|
|
|
|
|
Better RawNewtorkMessage deserealization from IO stream (#231)
Follow-up to https://github.com/rust-bitcoin/rust-bitcoin/pull/229
While working with remote peers over the network it is required to deserealize RawNetworkMessage from `TCPStream` to read the incoming messages. These messages can be partial – or one TCP packet can contain few of them. To make the library usable for such use cases, I have implemented the required functionality and covered it with unit tests.
Sample usage:
```rust
fn run() -> Result<(), Error> {
// Opening stream to the remote bitcoind peer
let mut stream = TcpStream::connect(SocketAddr::from(([37, 187, 0, 47], 8333));
let start = SystemTime::now();
// Constructing and sending `version` message to get some messages back from the remote peer
let since_the_epoch = start.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
let version_msg = message::RawNetworkMessage {
magic: constants::Network::Bitcoin.magic(),
payload: message::NetworkMessage::Version(message_network::VersionMessage::new(
0,
since_the_epoch.as_secs() as i64,
address::Address::new(receiver, 0),
address::Address::new(receiver, 0),
0,
String::from("macx0r"),
0
))
};
stream.write(encode::serialize(&version_msg).as_slice())?;
// Receiving incoming messages
let mut buffer = vec![];
loop {
let result = StreamReader::new(&mut stream, None).read_messages();
if let Err(err) = result {
stream.shutdown(Shutdown::Both)?;
return Err(Error::DataError(err))
}
for msg in result.unwrap() {
println!("Received message: {:?}", msg.payload);
}
}
}
```
Sample output is the following:
```
Received message: Version(VersionMessage { version: 70015, services: 1037, timestamp: 1548637162, receiver: Address {services: 0, address: [0, 0, 0, 0, 0, 65535, 23536, 35968], port: 33716}, sender: Address {services: 1037, address: [0, 0, 0, 0, 0, 0, 0, 0], port: 0}, nonce: 1370726880972892633, user_agent: "/Satoshi:0.17.99/", start_height: 560412, relay: true })
Received message: Verack
Received message: Alert([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 254, 255, 255, 127, 1, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 0, 255, 255, 255, 127, 0, 47, 85, 82, 71, 69, 78, 84, 58, 32, 65, 108, 101, 114, 116, 32, 107, 101, 121, 32, 99, 111, 109, 112, 114, 111, 109, 105, 115, 101, 100, 44, 32, 117, 112, 103, 114, 97, 100, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0])
```
Working sample code can be found here: https://github.com/dr-orlovsky/bitcoinbigdata-netlistener
2019-02-27 21:41:28 +00:00
|
|
|
#[derive(Debug)]
|
2014-07-18 13:56:17 +00:00
|
|
|
/// A Network message
|
|
|
|
pub struct RawNetworkMessage {
|
2015-04-07 01:51:11 +00:00
|
|
|
/// Magic bytes to identify the network these messages are meant for
|
|
|
|
pub magic: u32,
|
|
|
|
/// The actual message data
|
|
|
|
pub payload: NetworkMessage
|
2014-07-18 13:56:17 +00:00
|
|
|
}
|
|
|
|
|
2015-03-26 15:35:31 +00:00
|
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
2016-06-21 14:35:27 +00:00
|
|
|
/// A Network message payload. Proper documentation is available on at
|
|
|
|
/// [Bitcoin Wiki: Protocol Specification](https://en.bitcoin.it/wiki/Protocol_specification)
|
2014-09-10 12:15:48 +00:00
|
|
|
pub enum NetworkMessage {
|
2015-04-07 01:51:11 +00:00
|
|
|
/// `version`
|
|
|
|
Version(message_network::VersionMessage),
|
|
|
|
/// `verack`
|
|
|
|
Verack,
|
|
|
|
/// `addr`
|
|
|
|
Addr(Vec<(u32, Address)>),
|
|
|
|
/// `inv`
|
|
|
|
Inv(Vec<message_blockdata::Inventory>),
|
|
|
|
/// `getdata`
|
|
|
|
GetData(Vec<message_blockdata::Inventory>),
|
|
|
|
/// `notfound`
|
|
|
|
NotFound(Vec<message_blockdata::Inventory>),
|
|
|
|
/// `getblocks`
|
|
|
|
GetBlocks(message_blockdata::GetBlocksMessage),
|
|
|
|
/// `getheaders`
|
|
|
|
GetHeaders(message_blockdata::GetHeadersMessage),
|
2015-11-22 23:28:49 +00:00
|
|
|
/// `mempool`
|
|
|
|
MemPool,
|
2015-04-07 01:51:11 +00:00
|
|
|
/// tx
|
|
|
|
Tx(transaction::Transaction),
|
|
|
|
/// `block`
|
|
|
|
Block(block::Block),
|
|
|
|
/// `headers`
|
2019-05-17 21:53:38 +00:00
|
|
|
Headers(Vec<block::BlockHeader>),
|
2019-05-17 18:09:27 +00:00
|
|
|
/// `sendheaders`
|
|
|
|
SendHeaders,
|
2016-10-10 15:14:12 +00:00
|
|
|
/// `getaddr`
|
|
|
|
GetAddr,
|
2015-04-07 01:51:11 +00:00
|
|
|
// TODO: checkorder,
|
|
|
|
// TODO: submitorder,
|
|
|
|
// TODO: reply,
|
|
|
|
/// `ping`
|
|
|
|
Ping(u64),
|
|
|
|
/// `pong`
|
2018-02-10 15:47:46 +00:00
|
|
|
Pong(u64),
|
2015-04-07 01:51:11 +00:00
|
|
|
// TODO: reject,
|
|
|
|
// TODO: bloom filtering
|
2019-02-08 12:00:51 +00:00
|
|
|
/// BIP157 getcfilters
|
|
|
|
GetCFilters(message_filter::GetCFilters),
|
|
|
|
/// BIP157 cfilter
|
|
|
|
CFilter(message_filter::CFilter),
|
|
|
|
/// BIP157 getcfheaders
|
|
|
|
GetCFHeaders(message_filter::GetCFHeaders),
|
|
|
|
/// BIP157 cfheaders
|
|
|
|
CFHeaders(message_filter::CFHeaders),
|
|
|
|
/// BIP157 getcfcheckpt
|
|
|
|
GetCFCheckpt(message_filter::GetCFCheckpt),
|
|
|
|
/// BIP157 cfcheckpt
|
|
|
|
CFCheckpt(message_filter::CFCheckpt),
|
2018-02-10 15:47:46 +00:00
|
|
|
/// `alert`
|
2019-08-27 11:01:21 +00:00
|
|
|
Alert(Vec<u8>),
|
|
|
|
/// `reject`
|
|
|
|
Reject(message_network::Reject)
|
2014-07-18 13:56:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl RawNetworkMessage {
|
2018-02-28 19:27:52 +00:00
|
|
|
/// Return the message command. This is useful for debug outputs.
|
2018-02-28 09:42:23 +00:00
|
|
|
pub fn command(&self) -> String {
|
2015-04-07 01:51:11 +00:00
|
|
|
match self.payload {
|
|
|
|
NetworkMessage::Version(_) => "version",
|
|
|
|
NetworkMessage::Verack => "verack",
|
|
|
|
NetworkMessage::Addr(_) => "addr",
|
|
|
|
NetworkMessage::Inv(_) => "inv",
|
|
|
|
NetworkMessage::GetData(_) => "getdata",
|
|
|
|
NetworkMessage::NotFound(_) => "notfound",
|
|
|
|
NetworkMessage::GetBlocks(_) => "getblocks",
|
|
|
|
NetworkMessage::GetHeaders(_) => "getheaders",
|
2015-11-22 23:28:49 +00:00
|
|
|
NetworkMessage::MemPool => "mempool",
|
2015-04-07 01:51:11 +00:00
|
|
|
NetworkMessage::Tx(_) => "tx",
|
|
|
|
NetworkMessage::Block(_) => "block",
|
|
|
|
NetworkMessage::Headers(_) => "headers",
|
2019-05-17 18:09:27 +00:00
|
|
|
NetworkMessage::SendHeaders => "sendheaders",
|
2016-10-10 15:14:12 +00:00
|
|
|
NetworkMessage::GetAddr => "getaddr",
|
2015-04-07 01:51:11 +00:00
|
|
|
NetworkMessage::Ping(_) => "ping",
|
|
|
|
NetworkMessage::Pong(_) => "pong",
|
2019-02-08 12:00:51 +00:00
|
|
|
NetworkMessage::GetCFilters(_) => "getcfilters",
|
|
|
|
NetworkMessage::CFilter(_) => "cfilter",
|
|
|
|
NetworkMessage::GetCFHeaders(_) => "getcfheaders",
|
|
|
|
NetworkMessage::CFHeaders(_) => "cfheaders",
|
|
|
|
NetworkMessage::GetCFCheckpt(_) => "getcfckpt",
|
|
|
|
NetworkMessage::CFCheckpt(_) => "cfcheckpt",
|
2018-02-10 15:47:46 +00:00
|
|
|
NetworkMessage::Alert(_) => "alert",
|
2019-08-27 11:01:21 +00:00
|
|
|
NetworkMessage::Reject(_) => "reject",
|
2015-10-28 16:27:23 +00:00
|
|
|
}.to_owned()
|
2015-04-07 01:51:11 +00:00
|
|
|
}
|
2014-07-18 13:56:17 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 21:53:38 +00:00
|
|
|
struct HeaderSerializationWrapper<'a>(&'a Vec<block::BlockHeader>);
|
2019-07-11 14:56:37 +00:00
|
|
|
|
|
|
|
impl<'a> Encodable for HeaderSerializationWrapper<'a> {
|
2019-05-17 21:53:38 +00:00
|
|
|
#[inline]
|
2019-07-11 14:56:37 +00:00
|
|
|
fn consensus_encode<S: io::Write>(
|
|
|
|
&self,
|
|
|
|
mut s: S,
|
|
|
|
) -> Result<usize, encode::Error> {
|
2019-05-23 20:28:10 +00:00
|
|
|
let mut len = 0;
|
2019-07-11 14:56:37 +00:00
|
|
|
len += VarInt(self.0.len() as u64).consensus_encode(&mut s)?;
|
2019-05-17 21:53:38 +00:00
|
|
|
for header in self.0.iter() {
|
2019-07-11 14:56:37 +00:00
|
|
|
len += header.consensus_encode(&mut s)?;
|
|
|
|
len += 0u8.consensus_encode(&mut s)?;
|
2019-05-17 21:53:38 +00:00
|
|
|
}
|
2019-05-23 20:28:10 +00:00
|
|
|
Ok(len)
|
2019-05-17 21:53:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-11 14:56:37 +00:00
|
|
|
impl Encodable for RawNetworkMessage {
|
|
|
|
fn consensus_encode<S: io::Write>(
|
|
|
|
&self,
|
|
|
|
mut s: S,
|
|
|
|
) -> Result<usize, encode::Error> {
|
2019-05-23 20:28:10 +00:00
|
|
|
let mut len = 0;
|
2019-07-11 14:56:37 +00:00
|
|
|
len += self.magic.consensus_encode(&mut s)?;
|
|
|
|
len += CommandString(self.command()).consensus_encode(&mut s)?;
|
2019-05-23 20:28:10 +00:00
|
|
|
len += CheckedData(match self.payload {
|
2015-04-07 01:51:11 +00:00
|
|
|
NetworkMessage::Version(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::Addr(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::Inv(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::GetData(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::NotFound(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::GetBlocks(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::GetHeaders(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::Tx(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::Block(ref dat) => serialize(dat),
|
2019-05-17 21:53:38 +00:00
|
|
|
NetworkMessage::Headers(ref dat) => serialize(&HeaderSerializationWrapper(dat)),
|
2015-04-07 01:51:11 +00:00
|
|
|
NetworkMessage::Ping(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::Pong(ref dat) => serialize(dat),
|
2019-02-08 12:00:51 +00:00
|
|
|
NetworkMessage::GetCFilters(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::CFilter(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::GetCFHeaders(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::CFHeaders(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::GetCFCheckpt(ref dat) => serialize(dat),
|
|
|
|
NetworkMessage::CFCheckpt(ref dat) => serialize(dat),
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
NetworkMessage::Alert(ref dat) => serialize(dat),
|
2019-08-27 11:01:21 +00:00
|
|
|
NetworkMessage::Reject(ref dat) => serialize(dat),
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
NetworkMessage::Verack
|
2019-05-17 18:09:27 +00:00
|
|
|
| NetworkMessage::SendHeaders
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
| NetworkMessage::MemPool
|
|
|
|
| NetworkMessage::GetAddr => vec![],
|
2019-07-11 14:56:37 +00:00
|
|
|
}).consensus_encode(&mut s)?;
|
2019-05-23 20:28:10 +00:00
|
|
|
Ok(len)
|
2015-04-07 01:51:11 +00:00
|
|
|
}
|
2014-08-01 16:01:39 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 21:53:38 +00:00
|
|
|
struct HeaderDeserializationWrapper(Vec<block::BlockHeader>);
|
2019-07-11 17:06:42 +00:00
|
|
|
|
|
|
|
impl Decodable for HeaderDeserializationWrapper {
|
2019-05-17 21:53:38 +00:00
|
|
|
#[inline]
|
2019-07-11 17:06:42 +00:00
|
|
|
fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
|
|
|
|
let len = VarInt::consensus_decode(&mut d)?.0;
|
2019-05-17 21:53:38 +00:00
|
|
|
let byte_size = (len as usize)
|
|
|
|
.checked_mul(mem::size_of::<block::BlockHeader>())
|
|
|
|
.ok_or(encode::Error::ParseFailed("Invalid length"))?;
|
|
|
|
if byte_size > MAX_VEC_SIZE {
|
|
|
|
return Err(encode::Error::OversizedVectorAllocation { requested: byte_size, max: MAX_VEC_SIZE })
|
|
|
|
}
|
|
|
|
let mut ret = Vec::with_capacity(len as usize);
|
|
|
|
for _ in 0..len {
|
2019-07-11 17:06:42 +00:00
|
|
|
ret.push(Decodable::consensus_decode(&mut d)?);
|
|
|
|
if u8::consensus_decode(&mut d)? != 0u8 {
|
2019-05-17 21:53:38 +00:00
|
|
|
return Err(encode::Error::ParseFailed("Headers message should not contain transactions"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(HeaderDeserializationWrapper(ret))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-11 17:06:42 +00:00
|
|
|
impl Decodable for RawNetworkMessage {
|
|
|
|
fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
|
|
|
|
let magic = Decodable::consensus_decode(&mut d)?;
|
|
|
|
let cmd = CommandString::consensus_decode(&mut d)?.0;
|
|
|
|
let raw_payload = CheckedData::consensus_decode(&mut d)?.0;
|
2015-04-07 01:51:11 +00:00
|
|
|
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
let mut mem_d = Cursor::new(raw_payload);
|
2015-04-11 01:55:59 +00:00
|
|
|
let payload = match &cmd[..] {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
"version" => NetworkMessage::Version(Decodable::consensus_decode(&mut mem_d)?),
|
2015-04-07 01:51:11 +00:00
|
|
|
"verack" => NetworkMessage::Verack,
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
"addr" => NetworkMessage::Addr(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"inv" => NetworkMessage::Inv(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"getdata" => NetworkMessage::GetData(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"notfound" => NetworkMessage::NotFound(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"getblocks" => NetworkMessage::GetBlocks(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"getheaders" => NetworkMessage::GetHeaders(Decodable::consensus_decode(&mut mem_d)?),
|
2015-11-22 23:28:49 +00:00
|
|
|
"mempool" => NetworkMessage::MemPool,
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
"block" => NetworkMessage::Block(Decodable::consensus_decode(&mut mem_d)?),
|
2019-07-11 17:06:42 +00:00
|
|
|
"headers" => NetworkMessage::Headers(
|
|
|
|
HeaderDeserializationWrapper::consensus_decode(&mut mem_d)?.0
|
|
|
|
),
|
2019-05-17 18:09:27 +00:00
|
|
|
"sendheaders" => NetworkMessage::SendHeaders,
|
2016-10-10 15:14:12 +00:00
|
|
|
"getaddr" => NetworkMessage::GetAddr,
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
"ping" => NetworkMessage::Ping(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"pong" => NetworkMessage::Pong(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"tx" => NetworkMessage::Tx(Decodable::consensus_decode(&mut mem_d)?),
|
2019-02-08 12:00:51 +00:00
|
|
|
"getcfilters" => NetworkMessage::GetCFilters(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"cfilter" => NetworkMessage::CFilter(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"getcfheaders" => NetworkMessage::GetCFHeaders(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"cfheaders" => NetworkMessage::CFHeaders(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"getcfckpt" => NetworkMessage::GetCFCheckpt(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
"cfcheckpt" => NetworkMessage::CFCheckpt(Decodable::consensus_decode(&mut mem_d)?),
|
2019-09-03 17:59:48 +00:00
|
|
|
"reject" => NetworkMessage::Reject(Decodable::consensus_decode(&mut mem_d)?),
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
"alert" => NetworkMessage::Alert(Decodable::consensus_decode(&mut mem_d)?),
|
|
|
|
_ => return Err(encode::Error::UnrecognizedNetworkCommand(cmd)),
|
2015-04-07 01:51:11 +00:00
|
|
|
};
|
|
|
|
Ok(RawNetworkMessage {
|
|
|
|
magic: magic,
|
|
|
|
payload: payload
|
|
|
|
})
|
|
|
|
}
|
2014-07-18 13:56:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
2015-04-07 01:51:11 +00:00
|
|
|
use super::{RawNetworkMessage, NetworkMessage, CommandString};
|
Better RawNewtorkMessage deserealization from IO stream (#231)
Follow-up to https://github.com/rust-bitcoin/rust-bitcoin/pull/229
While working with remote peers over the network it is required to deserealize RawNetworkMessage from `TCPStream` to read the incoming messages. These messages can be partial – or one TCP packet can contain few of them. To make the library usable for such use cases, I have implemented the required functionality and covered it with unit tests.
Sample usage:
```rust
fn run() -> Result<(), Error> {
// Opening stream to the remote bitcoind peer
let mut stream = TcpStream::connect(SocketAddr::from(([37, 187, 0, 47], 8333));
let start = SystemTime::now();
// Constructing and sending `version` message to get some messages back from the remote peer
let since_the_epoch = start.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
let version_msg = message::RawNetworkMessage {
magic: constants::Network::Bitcoin.magic(),
payload: message::NetworkMessage::Version(message_network::VersionMessage::new(
0,
since_the_epoch.as_secs() as i64,
address::Address::new(receiver, 0),
address::Address::new(receiver, 0),
0,
String::from("macx0r"),
0
))
};
stream.write(encode::serialize(&version_msg).as_slice())?;
// Receiving incoming messages
let mut buffer = vec![];
loop {
let result = StreamReader::new(&mut stream, None).read_messages();
if let Err(err) = result {
stream.shutdown(Shutdown::Both)?;
return Err(Error::DataError(err))
}
for msg in result.unwrap() {
println!("Received message: {:?}", msg.payload);
}
}
}
```
Sample output is the following:
```
Received message: Version(VersionMessage { version: 70015, services: 1037, timestamp: 1548637162, receiver: Address {services: 0, address: [0, 0, 0, 0, 0, 65535, 23536, 35968], port: 33716}, sender: Address {services: 1037, address: [0, 0, 0, 0, 0, 0, 0, 0], port: 0}, nonce: 1370726880972892633, user_agent: "/Satoshi:0.17.99/", start_height: 560412, relay: true })
Received message: Verack
Received message: Alert([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 254, 255, 255, 127, 1, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 0, 255, 255, 255, 127, 0, 47, 85, 82, 71, 69, 78, 84, 58, 32, 65, 108, 101, 114, 116, 32, 107, 101, 121, 32, 99, 111, 109, 112, 114, 111, 109, 105, 115, 101, 100, 44, 32, 117, 112, 103, 114, 97, 100, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0])
```
Working sample code can be found here: https://github.com/dr-orlovsky/bitcoinbigdata-netlistener
2019-02-27 21:41:28 +00:00
|
|
|
use consensus::encode::{deserialize, deserialize_partial, serialize};
|
2015-04-07 01:51:11 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn serialize_commandstring_test() {
|
2015-10-28 16:27:23 +00:00
|
|
|
let cs = CommandString("Andrew".to_owned());
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
assert_eq!(serialize(&cs), vec![0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
|
2015-04-07 01:51:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn deserialize_commandstring_test() {
|
2015-04-08 22:23:45 +00:00
|
|
|
let cs: Result<CommandString, _> = deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
|
2015-04-07 01:51:11 +00:00
|
|
|
assert!(cs.is_ok());
|
2015-10-28 16:27:23 +00:00
|
|
|
assert_eq!(cs.unwrap(), CommandString("Andrew".to_owned()));
|
2015-04-07 01:51:11 +00:00
|
|
|
|
2015-04-08 22:23:45 +00:00
|
|
|
let short_cs: Result<CommandString, _> = deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0]);
|
2015-04-07 01:51:11 +00:00
|
|
|
assert!(short_cs.is_err());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn serialize_verack_test() {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::Verack }),
|
|
|
|
vec![0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x61,
|
|
|
|
0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
|
2015-04-07 01:51:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn serialize_ping_test() {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::Ping(100) }),
|
|
|
|
vec![0xf9, 0xbe, 0xb4, 0xd9, 0x70, 0x69, 0x6e, 0x67,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x08, 0x00, 0x00, 0x00, 0x24, 0x67, 0xf1, 0x1d,
|
|
|
|
0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
|
2015-04-07 01:51:11 +00:00
|
|
|
}
|
2015-11-22 23:28:49 +00:00
|
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn serialize_mempool_test() {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::MemPool }),
|
|
|
|
vec![0xf9, 0xbe, 0xb4, 0xd9, 0x6d, 0x65, 0x6d, 0x70,
|
|
|
|
0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
|
2015-11-22 23:28:49 +00:00
|
|
|
}
|
|
|
|
|
2016-10-10 15:14:12 +00:00
|
|
|
#[test]
|
|
|
|
fn serialize_getaddr_test() {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::GetAddr }),
|
|
|
|
vec![0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
|
|
|
|
0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
|
2016-10-10 15:14:12 +00:00
|
|
|
}
|
|
|
|
|
Better RawNewtorkMessage deserealization from IO stream (#231)
Follow-up to https://github.com/rust-bitcoin/rust-bitcoin/pull/229
While working with remote peers over the network it is required to deserealize RawNetworkMessage from `TCPStream` to read the incoming messages. These messages can be partial – or one TCP packet can contain few of them. To make the library usable for such use cases, I have implemented the required functionality and covered it with unit tests.
Sample usage:
```rust
fn run() -> Result<(), Error> {
// Opening stream to the remote bitcoind peer
let mut stream = TcpStream::connect(SocketAddr::from(([37, 187, 0, 47], 8333));
let start = SystemTime::now();
// Constructing and sending `version` message to get some messages back from the remote peer
let since_the_epoch = start.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
let version_msg = message::RawNetworkMessage {
magic: constants::Network::Bitcoin.magic(),
payload: message::NetworkMessage::Version(message_network::VersionMessage::new(
0,
since_the_epoch.as_secs() as i64,
address::Address::new(receiver, 0),
address::Address::new(receiver, 0),
0,
String::from("macx0r"),
0
))
};
stream.write(encode::serialize(&version_msg).as_slice())?;
// Receiving incoming messages
let mut buffer = vec![];
loop {
let result = StreamReader::new(&mut stream, None).read_messages();
if let Err(err) = result {
stream.shutdown(Shutdown::Both)?;
return Err(Error::DataError(err))
}
for msg in result.unwrap() {
println!("Received message: {:?}", msg.payload);
}
}
}
```
Sample output is the following:
```
Received message: Version(VersionMessage { version: 70015, services: 1037, timestamp: 1548637162, receiver: Address {services: 0, address: [0, 0, 0, 0, 0, 65535, 23536, 35968], port: 33716}, sender: Address {services: 1037, address: [0, 0, 0, 0, 0, 0, 0, 0], port: 0}, nonce: 1370726880972892633, user_agent: "/Satoshi:0.17.99/", start_height: 560412, relay: true })
Received message: Verack
Received message: Alert([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 254, 255, 255, 127, 1, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 0, 255, 255, 255, 127, 0, 47, 85, 82, 71, 69, 78, 84, 58, 32, 65, 108, 101, 114, 116, 32, 107, 101, 121, 32, 99, 111, 109, 112, 114, 111, 109, 105, 115, 101, 100, 44, 32, 117, 112, 103, 114, 97, 100, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0])
```
Working sample code can be found here: https://github.com/dr-orlovsky/bitcoinbigdata-netlistener
2019-02-27 21:41:28 +00:00
|
|
|
#[test]
|
|
|
|
fn deserialize_getaddr_test() {
|
|
|
|
let msg = deserialize(
|
|
|
|
&[0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
|
|
|
|
0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
|
|
|
|
let preimage = RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::GetAddr };
|
|
|
|
assert!(msg.is_ok());
|
|
|
|
let msg : RawNetworkMessage = msg.unwrap();
|
|
|
|
assert_eq!(preimage.magic, msg.magic);
|
|
|
|
assert_eq!(preimage.payload, msg.payload);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn deserialize_version_test() {
|
|
|
|
let msg = deserialize::<RawNetworkMessage>(
|
|
|
|
&[ 0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
|
|
|
|
0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
|
|
|
|
0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
|
|
|
|
0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
|
|
|
|
0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
|
|
|
|
0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
|
|
|
|
0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01 ]);
|
|
|
|
|
|
|
|
assert!(msg.is_ok());
|
|
|
|
let msg = msg.unwrap();
|
|
|
|
assert_eq!(msg.magic, 0xd9b4bef9);
|
|
|
|
if let NetworkMessage::Version(version_msg) = msg.payload {
|
|
|
|
assert_eq!(version_msg.version, 70015);
|
2019-11-22 11:00:48 +00:00
|
|
|
assert_eq!(version_msg.services, 1037.into());
|
Better RawNewtorkMessage deserealization from IO stream (#231)
Follow-up to https://github.com/rust-bitcoin/rust-bitcoin/pull/229
While working with remote peers over the network it is required to deserealize RawNetworkMessage from `TCPStream` to read the incoming messages. These messages can be partial – or one TCP packet can contain few of them. To make the library usable for such use cases, I have implemented the required functionality and covered it with unit tests.
Sample usage:
```rust
fn run() -> Result<(), Error> {
// Opening stream to the remote bitcoind peer
let mut stream = TcpStream::connect(SocketAddr::from(([37, 187, 0, 47], 8333));
let start = SystemTime::now();
// Constructing and sending `version` message to get some messages back from the remote peer
let since_the_epoch = start.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
let version_msg = message::RawNetworkMessage {
magic: constants::Network::Bitcoin.magic(),
payload: message::NetworkMessage::Version(message_network::VersionMessage::new(
0,
since_the_epoch.as_secs() as i64,
address::Address::new(receiver, 0),
address::Address::new(receiver, 0),
0,
String::from("macx0r"),
0
))
};
stream.write(encode::serialize(&version_msg).as_slice())?;
// Receiving incoming messages
let mut buffer = vec![];
loop {
let result = StreamReader::new(&mut stream, None).read_messages();
if let Err(err) = result {
stream.shutdown(Shutdown::Both)?;
return Err(Error::DataError(err))
}
for msg in result.unwrap() {
println!("Received message: {:?}", msg.payload);
}
}
}
```
Sample output is the following:
```
Received message: Version(VersionMessage { version: 70015, services: 1037, timestamp: 1548637162, receiver: Address {services: 0, address: [0, 0, 0, 0, 0, 65535, 23536, 35968], port: 33716}, sender: Address {services: 1037, address: [0, 0, 0, 0, 0, 0, 0, 0], port: 0}, nonce: 1370726880972892633, user_agent: "/Satoshi:0.17.99/", start_height: 560412, relay: true })
Received message: Verack
Received message: Alert([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 254, 255, 255, 127, 1, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 0, 255, 255, 255, 127, 0, 47, 85, 82, 71, 69, 78, 84, 58, 32, 65, 108, 101, 114, 116, 32, 107, 101, 121, 32, 99, 111, 109, 112, 114, 111, 109, 105, 115, 101, 100, 44, 32, 117, 112, 103, 114, 97, 100, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0])
```
Working sample code can be found here: https://github.com/dr-orlovsky/bitcoinbigdata-netlistener
2019-02-27 21:41:28 +00:00
|
|
|
assert_eq!(version_msg.timestamp, 1548554224);
|
|
|
|
assert_eq!(version_msg.nonce, 13952548347456104954);
|
|
|
|
assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
|
|
|
|
assert_eq!(version_msg.start_height, 560275);
|
|
|
|
assert_eq!(version_msg.relay, true);
|
|
|
|
} else {
|
|
|
|
panic!("Wrong message type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn deserialize_partial_message_test() {
|
|
|
|
let data = [ 0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
|
|
|
|
0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
|
|
|
|
0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
|
|
|
|
0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
|
|
|
|
0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
|
|
|
|
0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
|
|
|
|
0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01, 0, 0 ];
|
|
|
|
let msg = deserialize_partial::<RawNetworkMessage>(&data);
|
|
|
|
assert!(msg.is_ok());
|
|
|
|
|
|
|
|
let (msg, consumed) = msg.unwrap();
|
|
|
|
assert_eq!(consumed, data.to_vec().len() - 2);
|
|
|
|
assert_eq!(msg.magic, 0xd9b4bef9);
|
|
|
|
if let NetworkMessage::Version(version_msg) = msg.payload {
|
|
|
|
assert_eq!(version_msg.version, 70015);
|
2019-11-22 11:00:48 +00:00
|
|
|
assert_eq!(version_msg.services, 1037.into());
|
Better RawNewtorkMessage deserealization from IO stream (#231)
Follow-up to https://github.com/rust-bitcoin/rust-bitcoin/pull/229
While working with remote peers over the network it is required to deserealize RawNetworkMessage from `TCPStream` to read the incoming messages. These messages can be partial – or one TCP packet can contain few of them. To make the library usable for such use cases, I have implemented the required functionality and covered it with unit tests.
Sample usage:
```rust
fn run() -> Result<(), Error> {
// Opening stream to the remote bitcoind peer
let mut stream = TcpStream::connect(SocketAddr::from(([37, 187, 0, 47], 8333));
let start = SystemTime::now();
// Constructing and sending `version` message to get some messages back from the remote peer
let since_the_epoch = start.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
let version_msg = message::RawNetworkMessage {
magic: constants::Network::Bitcoin.magic(),
payload: message::NetworkMessage::Version(message_network::VersionMessage::new(
0,
since_the_epoch.as_secs() as i64,
address::Address::new(receiver, 0),
address::Address::new(receiver, 0),
0,
String::from("macx0r"),
0
))
};
stream.write(encode::serialize(&version_msg).as_slice())?;
// Receiving incoming messages
let mut buffer = vec![];
loop {
let result = StreamReader::new(&mut stream, None).read_messages();
if let Err(err) = result {
stream.shutdown(Shutdown::Both)?;
return Err(Error::DataError(err))
}
for msg in result.unwrap() {
println!("Received message: {:?}", msg.payload);
}
}
}
```
Sample output is the following:
```
Received message: Version(VersionMessage { version: 70015, services: 1037, timestamp: 1548637162, receiver: Address {services: 0, address: [0, 0, 0, 0, 0, 65535, 23536, 35968], port: 33716}, sender: Address {services: 1037, address: [0, 0, 0, 0, 0, 0, 0, 0], port: 0}, nonce: 1370726880972892633, user_agent: "/Satoshi:0.17.99/", start_height: 560412, relay: true })
Received message: Verack
Received message: Alert([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 254, 255, 255, 127, 1, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 127, 0, 255, 255, 255, 127, 0, 47, 85, 82, 71, 69, 78, 84, 58, 32, 65, 108, 101, 114, 116, 32, 107, 101, 121, 32, 99, 111, 109, 112, 114, 111, 109, 105, 115, 101, 100, 44, 32, 117, 112, 103, 114, 97, 100, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0])
```
Working sample code can be found here: https://github.com/dr-orlovsky/bitcoinbigdata-netlistener
2019-02-27 21:41:28 +00:00
|
|
|
assert_eq!(version_msg.timestamp, 1548554224);
|
|
|
|
assert_eq!(version_msg.nonce, 13952548347456104954);
|
|
|
|
assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
|
|
|
|
assert_eq!(version_msg.start_height, 560275);
|
|
|
|
assert_eq!(version_msg.relay, true);
|
|
|
|
} else {
|
|
|
|
panic!("Wrong message type");
|
|
|
|
}
|
|
|
|
}
|
2014-07-18 13:56:17 +00:00
|
|
|
}
|