use crate::error::{Error, Result};
use crate::security::MAX_PEER_MESSAGE_PAYLOAD;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PeerMessageId {
Choke = 0,
Unchoke = 1,
Interested = 2,
NotInterested = 3,
Have = 4,
Bitfield = 5,
Request = 6,
Piece = 7,
Cancel = 8,
SuggestPiece = 13,
HaveAll = 14,
HaveNone = 15,
RejectRequest = 16,
AllowedFast = 17,
HashRequest = 21,
Hashes = 22,
HashReject = 23,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PeerMessage {
KeepAlive,
Choke,
Unchoke,
Interested,
NotInterested,
Have(u32),
Bitfield(Vec<u8>),
Request { index: u32, begin: u32, length: u32 },
Piece {
index: u32,
begin: u32,
data: Vec<u8>,
},
Cancel { index: u32, begin: u32, length: u32 },
Port(u16),
SuggestPiece(u32),
HaveAll,
HaveNone,
RejectRequest { index: u32, begin: u32, length: u32 },
AllowedFast(u32),
HashRequest(crate::peer::hash_messages::HashRequest),
Hashes(crate::peer::hash_messages::HashHashes),
HashReject(crate::peer::hash_messages::HashRequest),
Extended { id: u8, payload: Vec<u8> },
}
impl PeerMessage {
pub fn id(&self) -> Option<PeerMessageId> {
match self {
Self::KeepAlive => None,
Self::Choke => Some(PeerMessageId::Choke),
Self::Unchoke => Some(PeerMessageId::Unchoke),
Self::Interested => Some(PeerMessageId::Interested),
Self::NotInterested => Some(PeerMessageId::NotInterested),
Self::Have(_) => Some(PeerMessageId::Have),
Self::Bitfield(_) => Some(PeerMessageId::Bitfield),
Self::Request { .. } => Some(PeerMessageId::Request),
Self::Piece { .. } => Some(PeerMessageId::Piece),
Self::Cancel { .. } => Some(PeerMessageId::Cancel),
Self::Port(_) => None,
Self::SuggestPiece(_) => Some(PeerMessageId::SuggestPiece),
Self::HaveAll => Some(PeerMessageId::HaveAll),
Self::HaveNone => Some(PeerMessageId::HaveNone),
Self::RejectRequest { .. } => Some(PeerMessageId::RejectRequest),
Self::AllowedFast(_) => Some(PeerMessageId::AllowedFast),
Self::HashRequest(_) => Some(PeerMessageId::HashRequest),
Self::Hashes(_) => Some(PeerMessageId::Hashes),
Self::HashReject(_) => Some(PeerMessageId::HashReject),
Self::Extended { .. } => None,
}
}
pub fn encode(&self) -> Vec<u8> {
match self {
Self::KeepAlive => vec![0, 0, 0, 0],
Self::Choke
| Self::Unchoke
| Self::Interested
| Self::NotInterested => {
let id = self.id().expect("message id") as u8;
vec![0, 0, 0, 1, id]
}
Self::Have(index) => {
let mut out = vec![0, 0, 0, 5, PeerMessageId::Have as u8];
out.extend(index.to_be_bytes());
out
}
Self::Bitfield(bits) => {
let len = 1 + bits.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(PeerMessageId::Bitfield as u8);
out.extend(bits);
out
}
Self::Request { index, begin, length } => {
let mut out = vec![0, 0, 0, 13, PeerMessageId::Request as u8];
out.extend(index.to_be_bytes());
out.extend(begin.to_be_bytes());
out.extend(length.to_be_bytes());
out
}
Self::Piece { index, begin, data } => {
let len = 9 + data.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(PeerMessageId::Piece as u8);
out.extend(index.to_be_bytes());
out.extend(begin.to_be_bytes());
out.extend(data);
out
}
Self::Cancel { index, begin, length } => {
let mut out = vec![0, 0, 0, 13, PeerMessageId::Cancel as u8];
out.extend(index.to_be_bytes());
out.extend(begin.to_be_bytes());
out.extend(length.to_be_bytes());
out
}
Self::Port(port) => {
let mut out = vec![0, 0, 0, 3, 9];
out.extend(port.to_be_bytes());
out
}
Self::SuggestPiece(index) => {
let mut out = vec![0, 0, 0, 5, PeerMessageId::SuggestPiece as u8];
out.extend(index.to_be_bytes());
out
}
Self::HaveAll => vec![0, 0, 0, 1, PeerMessageId::HaveAll as u8],
Self::HaveNone => vec![0, 0, 0, 1, PeerMessageId::HaveNone as u8],
Self::RejectRequest { index, begin, length } => {
let mut out = vec![0, 0, 0, 13, PeerMessageId::RejectRequest as u8];
out.extend(index.to_be_bytes());
out.extend(begin.to_be_bytes());
out.extend(length.to_be_bytes());
out
}
Self::AllowedFast(index) => {
let mut out = vec![0, 0, 0, 5, PeerMessageId::AllowedFast as u8];
out.extend(index.to_be_bytes());
out
}
Self::HashRequest(req) => {
let payload = req.encode_payload();
let len = 1 + payload.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(PeerMessageId::HashRequest as u8);
out.extend_from_slice(&payload);
out
}
Self::Hashes(hashes) => {
let payload = hashes.encode_payload();
let len = 1 + payload.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(PeerMessageId::Hashes as u8);
out.extend_from_slice(&payload);
out
}
Self::HashReject(req) => {
let payload = req.encode_payload();
let len = 1 + payload.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(PeerMessageId::HashReject as u8);
out.extend_from_slice(&payload);
out
}
Self::Extended { id, payload } => {
let len = 1 + 1 + payload.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(20);
out.push(*id);
out.extend(payload);
out
}
}
}
pub fn decode(input: &[u8]) -> Result<(Self, &[u8])> {
match Self::try_decode(input)? {
FrameDecode::NeedMore => Err(Error::Peer("incomplete peer message".into())),
FrameDecode::Frame { message, rest } => Ok((message, rest)),
}
}
pub fn try_decode(input: &[u8]) -> Result<FrameDecode<'_>> {
if input.len() < 4 {
return Ok(FrameDecode::NeedMore);
}
let length = u32::from_be_bytes([input[0], input[1], input[2], input[3]]) as usize;
if length > MAX_PEER_MESSAGE_PAYLOAD {
return Err(Error::Peer(format!(
"peer message length {length} exceeds max {MAX_PEER_MESSAGE_PAYLOAD}"
)));
}
if length == 0 {
return Ok(FrameDecode::Frame {
message: Self::KeepAlive,
rest: &input[4..],
});
}
if input.len() < 4 + length {
return Ok(FrameDecode::NeedMore);
}
let id = input[4];
let payload = &input[5..4 + length];
let rest = &input[4 + length..];
let message = match id {
0 => {
require_exact_payload(payload, 0, "choke")?;
Self::Choke
}
1 => {
require_exact_payload(payload, 0, "unchoke")?;
Self::Unchoke
}
2 => {
require_exact_payload(payload, 0, "interested")?;
Self::Interested
}
3 => {
require_exact_payload(payload, 0, "not interested")?;
Self::NotInterested
}
4 => {
require_exact_payload(payload, 4, "have")?;
let index = read_u32(payload)?;
Self::Have(index)
}
5 => Self::Bitfield(payload.to_vec()),
6 => {
require_exact_payload(payload, 12, "request")?;
let (index, begin, length) = read_request(payload)?;
Self::Request {
index,
begin,
length,
}
}
7 => {
let (index, begin, data) = read_piece(payload)?;
Self::Piece { index, begin, data }
}
8 => {
require_exact_payload(payload, 12, "cancel")?;
let (index, begin, length) = read_request(payload)?;
Self::Cancel {
index,
begin,
length,
}
}
9 => {
require_exact_payload(payload, 2, "port")?;
let port = u16::from_be_bytes([payload[0], payload[1]]);
Self::Port(port)
}
13 => {
require_exact_payload(payload, 4, "suggest piece")?;
let index = read_u32(payload)?;
Self::SuggestPiece(index)
}
14 => {
require_exact_payload(payload, 0, "have all")?;
Self::HaveAll
}
15 => {
require_exact_payload(payload, 0, "have none")?;
Self::HaveNone
}
16 => {
require_exact_payload(payload, 12, "reject request")?;
let (index, begin, length) = read_request(payload)?;
Self::RejectRequest {
index,
begin,
length,
}
}
17 => {
require_exact_payload(payload, 4, "allowed fast")?;
let index = read_u32(payload)?;
Self::AllowedFast(index)
}
21 => {
let req = crate::peer::hash_messages::HashRequest::decode_payload(payload)?;
Self::HashRequest(req)
}
22 => {
let hashes = crate::peer::hash_messages::HashHashes::decode_payload(payload)?;
Self::Hashes(hashes)
}
23 => {
let req = crate::peer::hash_messages::HashRequest::decode_payload(payload)?;
Self::HashReject(req)
}
20 => {
if payload.is_empty() {
return Err(Error::Peer("extended message missing id".into()));
}
let id = payload[0];
Self::Extended {
id,
payload: payload[1..].to_vec(),
}
}
_ => Self::KeepAlive,
};
Ok(FrameDecode::Frame { message, rest })
}
}
pub enum FrameDecode<'a> {
NeedMore,
Frame { message: PeerMessage, rest: &'a [u8] },
}
fn require_exact_payload(payload: &[u8], expected: usize, name: &str) -> Result<()> {
if payload.len() != expected {
return Err(Error::Peer(format!(
"{name} payload length {} != {expected}",
payload.len()
)));
}
Ok(())
}
fn read_u32(payload: &[u8]) -> Result<u32> {
let bytes: [u8; 4] = payload
.get(..4)
.ok_or_else(|| Error::Peer("payload too short for u32".into()))?
.try_into()
.expect("slice to array");
Ok(u32::from_be_bytes(bytes))
}
fn read_request(payload: &[u8]) -> Result<(u32, u32, u32)> {
if payload.len() < 12 {
return Err(Error::Peer("request payload too short".into()));
}
Ok((
u32::from_be_bytes(payload[0..4].try_into().expect("index")),
u32::from_be_bytes(payload[4..8].try_into().expect("begin")),
u32::from_be_bytes(payload[8..12].try_into().expect("length")),
))
}
fn read_piece(payload: &[u8]) -> Result<(u32, u32, Vec<u8>)> {
if payload.len() < 8 {
return Err(Error::Peer("piece payload too short".into()));
}
let index = u32::from_be_bytes(payload[0..4].try_into().expect("index"));
let begin = u32::from_be_bytes(payload[4..8].try_into().expect("begin"));
Ok((index, begin, payload[8..].to_vec()))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hash_messages_roundtrip_on_peer_wire() {
let req = crate::peer::hash_messages::HashRequest {
pieces_root: [0x11; 32],
base_layer: 0,
index: 0,
length: 2,
proof_layers: 0,
};
let hashes = PeerMessage::Hashes(crate::peer::hash_messages::HashHashes {
request: req.clone(),
hashes: vec![[0x22; 32], [0x33; 32]],
});
let encoded = hashes.encode();
let (decoded, rest) = PeerMessage::decode(&encoded).expect("decode");
assert!(rest.is_empty());
assert_eq!(decoded, hashes);
let reject = PeerMessage::HashReject(req);
let encoded = reject.encode();
let (decoded, rest) = PeerMessage::decode(&encoded).expect("decode reject");
assert!(rest.is_empty());
assert_eq!(decoded, reject);
}
}