2019-10-02 11:40:20 +03:00
|
|
|
// Copyright 2019 The Grin Developers
|
2016-10-24 00:02:02 +03:00
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
//! Message types that transit over the network and related serialization code.
|
|
|
|
|
2019-10-07 18:22:05 +03:00
|
|
|
use crate::conn::Tracker;
|
2018-12-08 02:59:40 +03:00
|
|
|
use crate::core::core::hash::Hash;
|
|
|
|
use crate::core::core::BlockHeader;
|
|
|
|
use crate::core::pow::Difficulty;
|
2019-06-27 19:19:41 +03:00
|
|
|
use crate::core::ser::{
|
|
|
|
self, FixedLength, ProtocolVersion, Readable, Reader, StreamingReader, Writeable, Writer,
|
|
|
|
};
|
2018-12-29 01:46:21 +03:00
|
|
|
use crate::core::{consensus, global};
|
2018-12-08 02:59:40 +03:00
|
|
|
use crate::types::{
|
2019-02-18 15:15:32 +03:00
|
|
|
Capabilities, Error, PeerAddr, ReasonForBan, MAX_BLOCK_HEADERS, MAX_LOCATORS, MAX_PEER_ADDRS,
|
2018-12-08 02:59:40 +03:00
|
|
|
};
|
2019-07-13 00:17:38 +03:00
|
|
|
use num::FromPrimitive;
|
2019-10-07 18:22:05 +03:00
|
|
|
use std::fs::File;
|
2019-07-13 00:17:38 +03:00
|
|
|
use std::io::{Read, Write};
|
2019-10-07 18:22:05 +03:00
|
|
|
use std::sync::Arc;
|
2016-10-29 22:36:45 +03:00
|
|
|
|
2018-03-27 15:52:59 +03:00
|
|
|
/// Grin's user agent with current version
|
|
|
|
pub const USER_AGENT: &'static str = concat!("MW/Grin ", env!("CARGO_PKG_VERSION"));
|
2016-10-24 00:02:02 +03:00
|
|
|
|
2018-12-29 01:46:21 +03:00
|
|
|
/// Magic numbers expected in the header of every message
|
|
|
|
const OTHER_MAGIC: [u8; 2] = [73, 43];
|
|
|
|
const FLOONET_MAGIC: [u8; 2] = [83, 59];
|
|
|
|
const MAINNET_MAGIC: [u8; 2] = [97, 61];
|
2016-10-25 07:35:10 +03:00
|
|
|
|
2019-05-30 03:04:17 +03:00
|
|
|
// Types of messages.
|
|
|
|
// Note: Values here are *important* so we should only add new values at the
|
|
|
|
// end.
|
2016-10-29 16:51:24 +03:00
|
|
|
enum_from_primitive! {
|
2018-01-31 23:39:55 +03:00
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
|
|
pub enum Type {
|
2018-05-30 00:57:11 +03:00
|
|
|
Error = 0,
|
|
|
|
Hand = 1,
|
|
|
|
Shake = 2,
|
|
|
|
Ping = 3,
|
|
|
|
Pong = 4,
|
|
|
|
GetPeerAddrs = 5,
|
|
|
|
PeerAddrs = 6,
|
|
|
|
GetHeaders = 7,
|
|
|
|
Header = 8,
|
|
|
|
Headers = 9,
|
|
|
|
GetBlock = 10,
|
|
|
|
Block = 11,
|
|
|
|
GetCompactBlock = 12,
|
|
|
|
CompactBlock = 13,
|
|
|
|
StemTransaction = 14,
|
|
|
|
Transaction = 15,
|
|
|
|
TxHashSetRequest = 16,
|
|
|
|
TxHashSetArchive = 17,
|
|
|
|
BanReason = 18,
|
2018-11-07 12:28:17 +03:00
|
|
|
GetTransaction = 19,
|
|
|
|
TransactionKernel = 20,
|
2019-05-14 19:17:38 +03:00
|
|
|
KernelDataRequest = 21,
|
|
|
|
KernelDataResponse = 22,
|
2018-01-31 23:39:55 +03:00
|
|
|
}
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
|
2019-02-01 13:44:04 +03:00
|
|
|
/// Max theoretical size of a block filled with outputs.
|
|
|
|
fn max_block_size() -> u64 {
|
|
|
|
(global::max_block_weight() / consensus::BLOCK_OUTPUT_WEIGHT * 708) as u64
|
|
|
|
}
|
|
|
|
|
2019-05-14 19:07:51 +03:00
|
|
|
// Max msg size when msg type is unknown.
|
|
|
|
fn default_max_msg_size() -> u64 {
|
|
|
|
max_block_size()
|
|
|
|
}
|
|
|
|
|
2018-05-30 00:57:11 +03:00
|
|
|
// Max msg size for each msg type.
|
|
|
|
fn max_msg_size(msg_type: Type) -> u64 {
|
|
|
|
match msg_type {
|
|
|
|
Type::Error => 0,
|
|
|
|
Type::Hand => 128,
|
|
|
|
Type::Shake => 88,
|
|
|
|
Type::Ping => 16,
|
|
|
|
Type::Pong => 16,
|
|
|
|
Type::GetPeerAddrs => 4,
|
|
|
|
Type::PeerAddrs => 4 + (1 + 16 + 2) * MAX_PEER_ADDRS as u64,
|
|
|
|
Type::GetHeaders => 1 + 32 * MAX_LOCATORS as u64,
|
|
|
|
Type::Header => 365,
|
|
|
|
Type::Headers => 2 + 365 * MAX_BLOCK_HEADERS as u64,
|
|
|
|
Type::GetBlock => 32,
|
2019-02-01 13:44:04 +03:00
|
|
|
Type::Block => max_block_size(),
|
2018-05-30 00:57:11 +03:00
|
|
|
Type::GetCompactBlock => 32,
|
2019-02-01 13:44:04 +03:00
|
|
|
Type::CompactBlock => max_block_size() / 10,
|
|
|
|
Type::StemTransaction => max_block_size(),
|
|
|
|
Type::Transaction => max_block_size(),
|
2018-05-30 00:57:11 +03:00
|
|
|
Type::TxHashSetRequest => 40,
|
|
|
|
Type::TxHashSetArchive => 64,
|
|
|
|
Type::BanReason => 64,
|
2018-11-07 12:28:17 +03:00
|
|
|
Type::GetTransaction => 32,
|
|
|
|
Type::TransactionKernel => 32,
|
2019-05-14 19:17:38 +03:00
|
|
|
Type::KernelDataRequest => 0,
|
|
|
|
Type::KernelDataResponse => 8,
|
2018-05-30 00:57:11 +03:00
|
|
|
}
|
|
|
|
}
|
2018-04-03 23:21:13 +03:00
|
|
|
|
2018-12-29 01:46:21 +03:00
|
|
|
fn magic() -> [u8; 2] {
|
|
|
|
match *global::CHAIN_TYPE.read() {
|
|
|
|
global::ChainTypes::Floonet => FLOONET_MAGIC,
|
|
|
|
global::ChainTypes::Mainnet => MAINNET_MAGIC,
|
|
|
|
_ => OTHER_MAGIC,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-07 18:22:05 +03:00
|
|
|
pub struct Msg {
|
|
|
|
header: MsgHeader,
|
|
|
|
body: Vec<u8>,
|
|
|
|
attachment: Option<File>,
|
|
|
|
version: ProtocolVersion,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Msg {
|
|
|
|
pub fn new<T: Writeable>(
|
|
|
|
msg_type: Type,
|
|
|
|
msg: T,
|
|
|
|
version: ProtocolVersion,
|
|
|
|
) -> Result<Msg, Error> {
|
|
|
|
let body = ser::ser_vec(&msg, version)?;
|
|
|
|
Ok(Msg {
|
|
|
|
header: MsgHeader::new(msg_type, body.len() as u64),
|
|
|
|
body,
|
|
|
|
attachment: None,
|
|
|
|
version,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn add_attachment(&mut self, attachment: File) {
|
|
|
|
self.attachment = Some(attachment)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-16 14:00:39 +03:00
|
|
|
/// Read a header from the provided stream without blocking if the
|
2018-02-02 05:03:12 +03:00
|
|
|
/// underlying stream is async. Typically headers will be polled for, so
|
|
|
|
/// we do not want to block.
|
2019-05-14 19:07:51 +03:00
|
|
|
///
|
|
|
|
/// Note: We return a MsgHeaderWrapper here as we may encounter an unknown msg type.
|
|
|
|
///
|
|
|
|
pub fn read_header(
|
|
|
|
stream: &mut dyn Read,
|
2019-06-27 19:19:41 +03:00
|
|
|
version: ProtocolVersion,
|
2019-05-14 19:07:51 +03:00
|
|
|
) -> Result<MsgHeaderWrapper, Error> {
|
2018-11-13 12:30:02 +03:00
|
|
|
let mut head = vec![0u8; MsgHeader::LEN];
|
2019-07-13 00:17:38 +03:00
|
|
|
stream.read_exact(&mut head)?;
|
2019-06-27 19:19:41 +03:00
|
|
|
let header = ser::deserialize::<MsgHeaderWrapper>(&mut &head[..], version)?;
|
2018-02-02 05:03:12 +03:00
|
|
|
Ok(header)
|
|
|
|
}
|
|
|
|
|
2018-11-16 14:00:39 +03:00
|
|
|
/// Read a single item from the provided stream, always blocking until we
|
|
|
|
/// have a result (or timeout).
|
|
|
|
/// Returns the item and the total bytes read.
|
2019-06-27 19:19:41 +03:00
|
|
|
pub fn read_item<T: Readable>(
|
|
|
|
stream: &mut dyn Read,
|
|
|
|
version: ProtocolVersion,
|
|
|
|
) -> Result<(T, u64), Error> {
|
2019-07-13 00:17:38 +03:00
|
|
|
let mut reader = StreamingReader::new(stream, version);
|
2018-11-16 14:00:39 +03:00
|
|
|
let res = T::read(&mut reader)?;
|
|
|
|
Ok((res, reader.total_bytes_read()))
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Read a message body from the provided stream, always blocking
|
2018-02-02 05:03:12 +03:00
|
|
|
/// until we have a result (or timeout).
|
2019-06-27 19:19:41 +03:00
|
|
|
pub fn read_body<T: Readable>(
|
|
|
|
h: &MsgHeader,
|
|
|
|
stream: &mut dyn Read,
|
|
|
|
version: ProtocolVersion,
|
|
|
|
) -> Result<T, Error> {
|
2018-02-02 05:03:12 +03:00
|
|
|
let mut body = vec![0u8; h.msg_len as usize];
|
2019-07-13 00:17:38 +03:00
|
|
|
stream.read_exact(&mut body)?;
|
2019-06-27 19:19:41 +03:00
|
|
|
ser::deserialize(&mut &body[..], version).map_err(From::from)
|
2018-02-02 05:03:12 +03:00
|
|
|
}
|
|
|
|
|
2019-05-14 19:07:51 +03:00
|
|
|
/// Read (an unknown) message from the provided stream and discard it.
|
|
|
|
pub fn read_discard(msg_len: u64, stream: &mut dyn Read) -> Result<(), Error> {
|
|
|
|
let mut buffer = vec![0u8; msg_len as usize];
|
2019-07-13 00:17:38 +03:00
|
|
|
stream.read_exact(&mut buffer)?;
|
2019-05-14 19:07:51 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2018-11-16 14:00:39 +03:00
|
|
|
/// Reads a full message from the underlying stream.
|
2019-06-27 19:19:41 +03:00
|
|
|
pub fn read_message<T: Readable>(
|
|
|
|
stream: &mut dyn Read,
|
|
|
|
version: ProtocolVersion,
|
|
|
|
msg_type: Type,
|
|
|
|
) -> Result<T, Error> {
|
2019-07-13 00:17:38 +03:00
|
|
|
match read_header(stream, version)? {
|
2019-05-14 19:07:51 +03:00
|
|
|
MsgHeaderWrapper::Known(header) => {
|
|
|
|
if header.msg_type == msg_type {
|
2019-06-27 19:19:41 +03:00
|
|
|
read_body(&header, stream, version)
|
2019-05-14 19:07:51 +03:00
|
|
|
} else {
|
|
|
|
Err(Error::BadMessage)
|
|
|
|
}
|
|
|
|
}
|
2019-11-29 15:04:55 +03:00
|
|
|
MsgHeaderWrapper::Unknown(msg_len, _) => {
|
2019-05-14 19:07:51 +03:00
|
|
|
read_discard(msg_len, stream)?;
|
|
|
|
Err(Error::BadMessage)
|
|
|
|
}
|
2018-02-02 05:03:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-07 18:22:05 +03:00
|
|
|
pub fn write_message(
|
2018-12-08 02:59:40 +03:00
|
|
|
stream: &mut dyn Write,
|
2019-10-07 18:22:05 +03:00
|
|
|
msg: &Msg,
|
|
|
|
tracker: Arc<Tracker>,
|
2018-11-16 14:00:39 +03:00
|
|
|
) -> Result<(), Error> {
|
2019-10-07 18:22:05 +03:00
|
|
|
let mut buf = ser::ser_vec(&msg.header, msg.version)?;
|
|
|
|
buf.extend(&msg.body[..]);
|
2018-11-16 14:00:39 +03:00
|
|
|
stream.write_all(&buf[..])?;
|
2019-10-07 18:22:05 +03:00
|
|
|
tracker.inc_sent(buf.len() as u64);
|
|
|
|
if let Some(file) = &msg.attachment {
|
|
|
|
let mut file = file.try_clone()?;
|
|
|
|
let mut buf = [0u8; 8000];
|
|
|
|
loop {
|
|
|
|
match file.read(&mut buf[..]) {
|
|
|
|
Ok(0) => break,
|
|
|
|
Ok(n) => {
|
|
|
|
stream.write_all(&buf[..n])?;
|
|
|
|
// Increase sent bytes "quietly" without incrementing the counter.
|
|
|
|
// (In a loop here for the single attachment).
|
|
|
|
tracker.inc_quiet_sent(n as u64);
|
|
|
|
}
|
|
|
|
Err(e) => return Err(From::from(e)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-02-02 05:03:12 +03:00
|
|
|
Ok(())
|
2016-12-11 06:11:49 +03:00
|
|
|
}
|
|
|
|
|
2019-05-14 19:07:51 +03:00
|
|
|
/// A wrapper around a message header. If the header is for an unknown msg type
|
|
|
|
/// then we will be unable to parse the msg itself (just a bunch of random bytes).
|
|
|
|
/// But we need to know how many bytes to discard to discard the full message.
|
|
|
|
#[derive(Clone)]
|
|
|
|
pub enum MsgHeaderWrapper {
|
|
|
|
/// A "known" msg type with deserialized msg header.
|
|
|
|
Known(MsgHeader),
|
|
|
|
/// An unknown msg type with corresponding msg size in bytes.
|
2019-11-29 15:04:55 +03:00
|
|
|
Unknown(u64, u8),
|
2019-05-14 19:07:51 +03:00
|
|
|
}
|
|
|
|
|
2016-10-25 07:35:10 +03:00
|
|
|
/// Header of any protocol message, used to identify incoming messages.
|
2019-05-14 19:07:51 +03:00
|
|
|
#[derive(Clone)]
|
2016-10-25 07:35:10 +03:00
|
|
|
pub struct MsgHeader {
|
2017-06-01 01:47:52 +03:00
|
|
|
magic: [u8; 2],
|
2017-02-03 02:51:48 +03:00
|
|
|
/// Type of the message.
|
2016-10-31 04:23:52 +03:00
|
|
|
pub msg_type: Type,
|
2017-11-20 20:35:52 +03:00
|
|
|
/// Total length of the message in bytes.
|
2016-12-11 06:11:49 +03:00
|
|
|
pub msg_len: u64,
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
impl MsgHeader {
|
2017-02-03 02:51:48 +03:00
|
|
|
/// Creates a new message header.
|
2016-12-11 06:11:49 +03:00
|
|
|
pub fn new(msg_type: Type, len: u64) -> MsgHeader {
|
2016-10-31 04:23:52 +03:00
|
|
|
MsgHeader {
|
2018-12-29 01:46:21 +03:00
|
|
|
magic: magic(),
|
2016-10-31 04:23:52 +03:00
|
|
|
msg_type: msg_type,
|
2016-12-11 06:11:49 +03:00
|
|
|
msg_len: len,
|
2016-10-31 04:23:52 +03:00
|
|
|
}
|
|
|
|
}
|
2018-11-13 12:30:02 +03:00
|
|
|
}
|
2016-10-31 04:23:52 +03:00
|
|
|
|
2018-11-13 12:30:02 +03:00
|
|
|
impl FixedLength for MsgHeader {
|
2019-05-14 19:07:51 +03:00
|
|
|
// 2 magic bytes + 1 type byte + 8 bytes (msg_len)
|
|
|
|
const LEN: usize = 2 + 1 + 8;
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for MsgHeader {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2017-09-29 21:44:25 +03:00
|
|
|
ser_multiwrite!(
|
|
|
|
writer,
|
|
|
|
[write_u8, self.magic[0]],
|
|
|
|
[write_u8, self.magic[1]],
|
|
|
|
[write_u8, self.msg_type as u8],
|
|
|
|
[write_u64, self.msg_len]
|
|
|
|
);
|
2016-11-01 05:03:12 +03:00
|
|
|
Ok(())
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-14 19:07:51 +03:00
|
|
|
impl Readable for MsgHeaderWrapper {
|
|
|
|
fn read(reader: &mut dyn Reader) -> Result<MsgHeaderWrapper, ser::Error> {
|
2018-12-29 01:46:21 +03:00
|
|
|
let m = magic();
|
|
|
|
reader.expect_u8(m[0])?;
|
|
|
|
reader.expect_u8(m[1])?;
|
2019-05-14 19:07:51 +03:00
|
|
|
|
|
|
|
// Read the msg header.
|
|
|
|
// We do not yet know if the msg type is one we support locally.
|
|
|
|
let (t, msg_len) = ser_multiread!(reader, read_u8, read_u64);
|
|
|
|
|
|
|
|
// Attempt to convert the msg type byte into one of our known msg type enum variants.
|
|
|
|
// Check the msg_len while we are at it.
|
2016-11-01 20:42:33 +03:00
|
|
|
match Type::from_u8(t) {
|
2019-05-14 19:07:51 +03:00
|
|
|
Some(msg_type) => {
|
|
|
|
// TODO 4x the limits for now to leave ourselves space to change things.
|
|
|
|
let max_len = max_msg_size(msg_type) * 4;
|
|
|
|
if msg_len > max_len {
|
|
|
|
error!(
|
|
|
|
"Too large read {:?}, max_len: {}, msg_len: {}.",
|
|
|
|
msg_type, max_len, msg_len
|
|
|
|
);
|
|
|
|
return Err(ser::Error::TooLargeReadErr);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(MsgHeaderWrapper::Known(MsgHeader {
|
|
|
|
magic: m,
|
|
|
|
msg_type,
|
|
|
|
msg_len,
|
|
|
|
}))
|
|
|
|
}
|
|
|
|
None => {
|
|
|
|
// Unknown msg type, but we still want to limit how big the msg is.
|
|
|
|
let max_len = default_max_msg_size() * 4;
|
|
|
|
if msg_len > max_len {
|
|
|
|
error!(
|
|
|
|
"Too large read (unknown msg type) {:?}, max_len: {}, msg_len: {}.",
|
|
|
|
t, max_len, msg_len
|
|
|
|
);
|
|
|
|
return Err(ser::Error::TooLargeReadErr);
|
|
|
|
}
|
|
|
|
|
2019-11-29 15:04:55 +03:00
|
|
|
Ok(MsgHeaderWrapper::Unknown(msg_len, t))
|
2019-05-14 19:07:51 +03:00
|
|
|
}
|
2016-10-28 00:28:02 +03:00
|
|
|
}
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// First part of a handshake, sender advertises its version and
|
|
|
|
/// characteristics.
|
2016-10-24 00:02:02 +03:00
|
|
|
pub struct Hand {
|
2016-10-26 08:06:13 +03:00
|
|
|
/// protocol version of the sender
|
2019-05-08 22:51:07 +03:00
|
|
|
pub version: ProtocolVersion,
|
2016-10-26 08:06:13 +03:00
|
|
|
/// capabilities of the sender
|
|
|
|
pub capabilities: Capabilities,
|
|
|
|
/// randomly generated for each handshake, helps detect self
|
|
|
|
pub nonce: u64,
|
2017-11-20 20:35:52 +03:00
|
|
|
/// genesis block of our chain, only connect to peers on the same chain
|
|
|
|
pub genesis: Hash,
|
2017-02-08 00:52:17 +03:00
|
|
|
/// total difficulty accumulated by the sender, used to check whether sync
|
2017-11-02 01:56:59 +03:00
|
|
|
/// may be needed
|
2017-02-08 00:52:17 +03:00
|
|
|
pub total_difficulty: Difficulty,
|
2016-10-26 08:06:13 +03:00
|
|
|
/// network address of the sender
|
2019-02-18 15:15:32 +03:00
|
|
|
pub sender_addr: PeerAddr,
|
2016-10-26 08:06:13 +03:00
|
|
|
/// network address of the receiver
|
2019-02-18 15:15:32 +03:00
|
|
|
pub receiver_addr: PeerAddr,
|
2016-10-26 08:06:13 +03:00
|
|
|
/// name of version of the software
|
|
|
|
pub user_agent: String,
|
2016-10-24 00:02:02 +03:00
|
|
|
}
|
|
|
|
|
2016-10-25 07:35:10 +03:00
|
|
|
impl Writeable for Hand {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2019-05-08 22:51:07 +03:00
|
|
|
self.version.write(writer)?;
|
2017-09-29 21:44:25 +03:00
|
|
|
ser_multiwrite!(
|
|
|
|
writer,
|
|
|
|
[write_u32, self.capabilities.bits()],
|
|
|
|
[write_u64, self.nonce]
|
|
|
|
);
|
2019-02-25 21:48:54 +03:00
|
|
|
self.total_difficulty.write(writer)?;
|
|
|
|
self.sender_addr.write(writer)?;
|
|
|
|
self.receiver_addr.write(writer)?;
|
|
|
|
writer.write_bytes(&self.user_agent)?;
|
|
|
|
self.genesis.write(writer)?;
|
2017-11-20 20:35:52 +03:00
|
|
|
Ok(())
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 09:17:23 +03:00
|
|
|
impl Readable for Hand {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<Hand, ser::Error> {
|
2019-05-08 22:51:07 +03:00
|
|
|
let version = ProtocolVersion::read(reader)?;
|
|
|
|
let (capab, nonce) = ser_multiread!(reader, read_u32, read_u64);
|
2018-11-07 14:15:37 +03:00
|
|
|
let capabilities = Capabilities::from_bits_truncate(capab);
|
2019-05-08 22:51:07 +03:00
|
|
|
let total_difficulty = Difficulty::read(reader)?;
|
2019-02-18 15:15:32 +03:00
|
|
|
let sender_addr = PeerAddr::read(reader)?;
|
|
|
|
let receiver_addr = PeerAddr::read(reader)?;
|
2018-11-13 12:30:40 +03:00
|
|
|
let ua = reader.read_bytes_len_prefix()?;
|
2018-06-04 19:05:49 +03:00
|
|
|
let user_agent = String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)?;
|
|
|
|
let genesis = Hash::read(reader)?;
|
2016-10-26 08:06:13 +03:00
|
|
|
Ok(Hand {
|
2019-05-08 22:51:07 +03:00
|
|
|
version,
|
|
|
|
capabilities,
|
|
|
|
nonce,
|
|
|
|
genesis,
|
|
|
|
total_difficulty,
|
|
|
|
sender_addr,
|
|
|
|
receiver_addr,
|
|
|
|
user_agent,
|
2016-10-26 08:06:13 +03:00
|
|
|
})
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Second part of a handshake, receiver of the first part replies with its own
|
|
|
|
/// version and characteristics.
|
2016-10-24 00:02:02 +03:00
|
|
|
pub struct Shake {
|
2016-10-26 08:06:13 +03:00
|
|
|
/// sender version
|
2019-05-08 22:51:07 +03:00
|
|
|
pub version: ProtocolVersion,
|
2016-10-26 08:06:13 +03:00
|
|
|
/// sender capabilities
|
|
|
|
pub capabilities: Capabilities,
|
2017-11-20 20:35:52 +03:00
|
|
|
/// genesis block of our chain, only connect to peers on the same chain
|
|
|
|
pub genesis: Hash,
|
2017-02-08 00:52:17 +03:00
|
|
|
/// total difficulty accumulated by the sender, used to check whether sync
|
2017-11-02 01:56:59 +03:00
|
|
|
/// may be needed
|
2017-02-08 00:52:17 +03:00
|
|
|
pub total_difficulty: Difficulty,
|
2016-10-26 08:06:13 +03:00
|
|
|
/// name of version of the software
|
|
|
|
pub user_agent: String,
|
2016-10-24 00:02:02 +03:00
|
|
|
}
|
|
|
|
|
2016-10-26 08:06:13 +03:00
|
|
|
impl Writeable for Shake {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2019-05-08 22:51:07 +03:00
|
|
|
self.version.write(writer)?;
|
|
|
|
writer.write_u32(self.capabilities.bits())?;
|
2019-02-25 21:48:54 +03:00
|
|
|
self.total_difficulty.write(writer)?;
|
|
|
|
writer.write_bytes(&self.user_agent)?;
|
|
|
|
self.genesis.write(writer)?;
|
2016-11-01 05:03:12 +03:00
|
|
|
Ok(())
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 09:17:23 +03:00
|
|
|
impl Readable for Shake {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<Shake, ser::Error> {
|
2019-05-08 22:51:07 +03:00
|
|
|
let version = ProtocolVersion::read(reader)?;
|
|
|
|
let capab = reader.read_u32()?;
|
2018-11-07 14:15:37 +03:00
|
|
|
let capabilities = Capabilities::from_bits_truncate(capab);
|
2019-05-08 22:51:07 +03:00
|
|
|
let total_difficulty = Difficulty::read(reader)?;
|
2018-11-13 12:30:40 +03:00
|
|
|
let ua = reader.read_bytes_len_prefix()?;
|
2018-06-04 19:05:49 +03:00
|
|
|
let user_agent = String::from_utf8(ua).map_err(|_| ser::Error::CorruptedData)?;
|
|
|
|
let genesis = Hash::read(reader)?;
|
2016-10-26 08:06:13 +03:00
|
|
|
Ok(Shake {
|
2019-05-08 22:51:07 +03:00
|
|
|
version,
|
|
|
|
capabilities,
|
|
|
|
genesis,
|
|
|
|
total_difficulty,
|
|
|
|
user_agent,
|
2016-10-26 08:06:13 +03:00
|
|
|
})
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-29 22:36:45 +03:00
|
|
|
/// Ask for other peers addresses, required for network discovery.
|
|
|
|
pub struct GetPeerAddrs {
|
|
|
|
/// Filters on the capabilities we'd like the peers to have
|
|
|
|
pub capabilities: Capabilities,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for GetPeerAddrs {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2016-10-29 22:36:45 +03:00
|
|
|
writer.write_u32(self.capabilities.bits())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 09:17:23 +03:00
|
|
|
impl Readable for GetPeerAddrs {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<GetPeerAddrs, ser::Error> {
|
2018-06-04 19:05:49 +03:00
|
|
|
let capab = reader.read_u32()?;
|
2018-11-07 14:15:37 +03:00
|
|
|
let capabilities = Capabilities::from_bits_truncate(capab);
|
2018-11-07 12:28:17 +03:00
|
|
|
Ok(GetPeerAddrs { capabilities })
|
2016-10-29 22:36:45 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Peer addresses we know of that are fresh enough, in response to
|
|
|
|
/// GetPeerAddrs.
|
2018-01-29 17:45:01 +03:00
|
|
|
#[derive(Debug)]
|
2016-10-29 22:36:45 +03:00
|
|
|
pub struct PeerAddrs {
|
2019-02-18 15:15:32 +03:00
|
|
|
pub peers: Vec<PeerAddr>,
|
2016-10-29 22:36:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for PeerAddrs {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2018-06-04 19:05:49 +03:00
|
|
|
writer.write_u32(self.peers.len() as u32)?;
|
2016-10-29 22:36:45 +03:00
|
|
|
for p in &self.peers {
|
2019-02-25 21:48:54 +03:00
|
|
|
p.write(writer)?;
|
2016-10-29 22:36:45 +03:00
|
|
|
}
|
2016-11-01 20:42:33 +03:00
|
|
|
Ok(())
|
2016-10-29 22:36:45 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 09:17:23 +03:00
|
|
|
impl Readable for PeerAddrs {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<PeerAddrs, ser::Error> {
|
2018-06-04 19:05:49 +03:00
|
|
|
let peer_count = reader.read_u32()?;
|
2017-02-19 05:42:34 +03:00
|
|
|
if peer_count > MAX_PEER_ADDRS {
|
2016-12-11 06:11:49 +03:00
|
|
|
return Err(ser::Error::TooLargeReadErr);
|
2017-02-19 05:42:34 +03:00
|
|
|
} else if peer_count == 0 {
|
|
|
|
return Ok(PeerAddrs { peers: vec![] });
|
|
|
|
}
|
|
|
|
let mut peers = Vec::with_capacity(peer_count as usize);
|
|
|
|
for _ in 0..peer_count {
|
2019-02-18 15:15:32 +03:00
|
|
|
peers.push(PeerAddr::read(reader)?);
|
2016-10-29 22:36:45 +03:00
|
|
|
}
|
|
|
|
Ok(PeerAddrs { peers: peers })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-25 07:35:10 +03:00
|
|
|
/// We found some issue in the communication, sending an error back, usually
|
|
|
|
/// followed by closing the connection.
|
2016-10-24 00:02:02 +03:00
|
|
|
pub struct PeerError {
|
2016-10-26 08:06:13 +03:00
|
|
|
/// error code
|
|
|
|
pub code: u32,
|
|
|
|
/// slightly more user friendly message
|
|
|
|
pub message: String,
|
2016-10-24 00:02:02 +03:00
|
|
|
}
|
2016-10-25 07:35:10 +03:00
|
|
|
|
|
|
|
impl Writeable for PeerError {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2016-11-01 20:42:33 +03:00
|
|
|
ser_multiwrite!(writer, [write_u32, self.code], [write_bytes, &self.message]);
|
2016-11-01 05:03:12 +03:00
|
|
|
Ok(())
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 09:17:23 +03:00
|
|
|
impl Readable for PeerError {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<PeerError, ser::Error> {
|
2018-11-13 12:30:40 +03:00
|
|
|
let code = reader.read_u32()?;
|
|
|
|
let msg = reader.read_bytes_len_prefix()?;
|
2018-06-04 19:05:49 +03:00
|
|
|
let message = String::from_utf8(msg).map_err(|_| ser::Error::CorruptedData)?;
|
2016-10-26 08:06:13 +03:00
|
|
|
Ok(PeerError {
|
2016-10-25 07:35:10 +03:00
|
|
|
code: code,
|
|
|
|
message: message,
|
2016-10-26 08:06:13 +03:00
|
|
|
})
|
2016-10-25 07:35:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-08 00:52:17 +03:00
|
|
|
/// Serializable wrapper for the block locator.
|
2018-01-30 17:42:04 +03:00
|
|
|
#[derive(Debug)]
|
2017-02-08 00:52:17 +03:00
|
|
|
pub struct Locator {
|
|
|
|
pub hashes: Vec<Hash>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for Locator {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2017-02-08 00:52:17 +03:00
|
|
|
writer.write_u8(self.hashes.len() as u8)?;
|
|
|
|
for h in &self.hashes {
|
|
|
|
h.write(writer)?
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 09:17:23 +03:00
|
|
|
impl Readable for Locator {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<Locator, ser::Error> {
|
2017-02-08 00:52:17 +03:00
|
|
|
let len = reader.read_u8()?;
|
2018-04-03 23:21:13 +03:00
|
|
|
if len > (MAX_LOCATORS as u8) {
|
|
|
|
return Err(ser::Error::TooLargeReadErr);
|
|
|
|
}
|
2017-02-08 00:52:17 +03:00
|
|
|
let mut hashes = Vec::with_capacity(len as usize);
|
|
|
|
for _ in 0..len {
|
|
|
|
hashes.push(Hash::read(reader)?);
|
|
|
|
}
|
|
|
|
Ok(Locator { hashes: hashes })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Serializable wrapper for a list of block headers.
|
|
|
|
pub struct Headers {
|
|
|
|
pub headers: Vec<BlockHeader>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for Headers {
|
2017-04-07 08:54:54 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2017-02-08 00:52:17 +03:00
|
|
|
writer.write_u16(self.headers.len() as u16)?;
|
|
|
|
for h in &self.headers {
|
|
|
|
h.write(writer)?
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-21 17:24:29 +03:00
|
|
|
pub struct Ping {
|
|
|
|
/// total difficulty accumulated by the sender, used to check whether sync
|
|
|
|
/// may be needed
|
|
|
|
pub total_difficulty: Difficulty,
|
2017-12-14 00:52:21 +03:00
|
|
|
/// total height
|
|
|
|
pub height: u64,
|
2017-11-21 17:24:29 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for Ping {
|
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2019-02-25 21:48:54 +03:00
|
|
|
self.total_difficulty.write(writer)?;
|
|
|
|
self.height.write(writer)?;
|
2017-11-21 17:24:29 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
2016-12-11 06:11:49 +03:00
|
|
|
|
2017-11-21 17:24:29 +03:00
|
|
|
impl Readable for Ping {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<Ping, ser::Error> {
|
2018-07-13 02:55:21 +03:00
|
|
|
let total_difficulty = Difficulty::read(reader)?;
|
|
|
|
let height = reader.read_u64()?;
|
2018-03-04 03:19:54 +03:00
|
|
|
Ok(Ping {
|
|
|
|
total_difficulty,
|
|
|
|
height,
|
|
|
|
})
|
2017-11-21 17:24:29 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Pong {
|
|
|
|
/// total difficulty accumulated by the sender, used to check whether sync
|
|
|
|
/// may be needed
|
|
|
|
pub total_difficulty: Difficulty,
|
2017-12-14 00:52:21 +03:00
|
|
|
/// height accumulated by sender
|
2018-03-04 03:19:54 +03:00
|
|
|
pub height: u64,
|
2017-11-21 17:24:29 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for Pong {
|
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
2019-02-25 21:48:54 +03:00
|
|
|
self.total_difficulty.write(writer)?;
|
|
|
|
self.height.write(writer)?;
|
2016-12-11 06:11:49 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-21 17:24:29 +03:00
|
|
|
impl Readable for Pong {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<Pong, ser::Error> {
|
2018-07-13 02:55:21 +03:00
|
|
|
let total_difficulty = Difficulty::read(reader)?;
|
|
|
|
let height = reader.read_u64()?;
|
2018-03-04 03:19:54 +03:00
|
|
|
Ok(Pong {
|
|
|
|
total_difficulty,
|
|
|
|
height,
|
|
|
|
})
|
2016-12-11 06:11:49 +03:00
|
|
|
}
|
|
|
|
}
|
2018-02-10 01:32:16 +03:00
|
|
|
|
2018-05-29 05:45:31 +03:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct BanReason {
|
|
|
|
/// the reason for the ban
|
|
|
|
pub ban_reason: ReasonForBan,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for BanReason {
|
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
|
|
|
let ban_reason_i32 = self.ban_reason as i32;
|
2019-02-25 21:48:54 +03:00
|
|
|
ban_reason_i32.write(writer)?;
|
2018-05-29 05:45:31 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Readable for BanReason {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<BanReason, ser::Error> {
|
2018-05-29 05:45:31 +03:00
|
|
|
let ban_reason_i32 = match reader.read_i32() {
|
|
|
|
Ok(h) => h,
|
|
|
|
Err(_) => 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
let ban_reason = ReasonForBan::from_i32(ban_reason_i32).ok_or(ser::Error::CorruptedData)?;
|
|
|
|
|
|
|
|
Ok(BanReason { ban_reason })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
/// Request to get an archive of the full txhashset store, required to sync
|
2018-02-10 01:32:16 +03:00
|
|
|
/// a new node.
|
2018-03-05 22:33:44 +03:00
|
|
|
pub struct TxHashSetRequest {
|
|
|
|
/// Hash of the block for which the txhashset should be provided
|
2018-02-10 01:32:16 +03:00
|
|
|
pub hash: Hash,
|
2018-03-04 03:19:54 +03:00
|
|
|
/// Height of the corresponding block
|
|
|
|
pub height: u64,
|
2018-02-10 01:32:16 +03:00
|
|
|
}
|
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
impl Writeable for TxHashSetRequest {
|
2018-02-10 01:32:16 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
|
|
|
self.hash.write(writer)?;
|
|
|
|
writer.write_u64(self.height)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
impl Readable for TxHashSetRequest {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<TxHashSetRequest, ser::Error> {
|
2018-03-05 22:33:44 +03:00
|
|
|
Ok(TxHashSetRequest {
|
2018-02-10 01:32:16 +03:00
|
|
|
hash: Hash::read(reader)?,
|
|
|
|
height: reader.read_u64()?,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
/// Response to a txhashset archive request, must include a zip stream of the
|
2018-02-10 01:32:16 +03:00
|
|
|
/// archive after the message body.
|
2018-03-05 22:33:44 +03:00
|
|
|
pub struct TxHashSetArchive {
|
|
|
|
/// Hash of the block for which the txhashset are provided
|
2018-02-10 01:32:16 +03:00
|
|
|
pub hash: Hash,
|
2018-03-04 03:19:54 +03:00
|
|
|
/// Height of the corresponding block
|
2018-02-10 01:32:16 +03:00
|
|
|
pub height: u64,
|
|
|
|
/// Size in bytes of the archive
|
|
|
|
pub bytes: u64,
|
|
|
|
}
|
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
impl Writeable for TxHashSetArchive {
|
2018-02-10 01:32:16 +03:00
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
|
|
|
self.hash.write(writer)?;
|
2018-08-12 23:02:30 +03:00
|
|
|
ser_multiwrite!(writer, [write_u64, self.height], [write_u64, self.bytes]);
|
2018-02-10 01:32:16 +03:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
impl Readable for TxHashSetArchive {
|
2018-12-08 02:59:40 +03:00
|
|
|
fn read(reader: &mut dyn Reader) -> Result<TxHashSetArchive, ser::Error> {
|
2018-02-10 01:32:16 +03:00
|
|
|
let hash = Hash::read(reader)?;
|
2018-07-02 02:23:24 +03:00
|
|
|
let (height, bytes) = ser_multiread!(reader, read_u64, read_u64);
|
2018-02-10 01:32:16 +03:00
|
|
|
|
2018-03-05 22:33:44 +03:00
|
|
|
Ok(TxHashSetArchive {
|
2018-03-04 03:19:54 +03:00
|
|
|
hash,
|
|
|
|
height,
|
|
|
|
bytes,
|
|
|
|
})
|
2018-02-10 01:32:16 +03:00
|
|
|
}
|
|
|
|
}
|
2019-05-14 19:17:38 +03:00
|
|
|
|
|
|
|
pub struct KernelDataRequest {}
|
|
|
|
|
|
|
|
impl Writeable for KernelDataRequest {
|
|
|
|
fn write<W: Writer>(&self, _writer: &mut W) -> Result<(), ser::Error> {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct KernelDataResponse {
|
|
|
|
/// Size in bytes of the attached kernel data file.
|
|
|
|
pub bytes: u64,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Writeable for KernelDataResponse {
|
|
|
|
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ser::Error> {
|
|
|
|
writer.write_u64(self.bytes)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Readable for KernelDataResponse {
|
|
|
|
fn read(reader: &mut dyn Reader) -> Result<KernelDataResponse, ser::Error> {
|
|
|
|
let bytes = reader.read_u64()?;
|
|
|
|
Ok(KernelDataResponse { bytes })
|
|
|
|
}
|
|
|
|
}
|