use crate::bencode::decode_with_limits;
use crate::error::{Error, Result};
use crate::security::{validate_metadata_piece, DecodeLimits, MAX_METADATA_BYTES};
use crate::peer::{
build_extension_handshake, parse_extension_handshake, ExtensionMessage, MetadataMessage,
PeerConnection, PeerMessage,
};
use crate::torrent::{parse_info, TorrentInfo};
pub const METADATA_PIECE_SIZE: u32 = 16 * 1024;
const METADATA_BLOCK: u32 = METADATA_PIECE_SIZE;
const MAX_EXTENDED_FRAMES: usize = 256;
const MAX_NOISE_EXTENDED: usize = 128;
const MAX_OTHER_MESSAGES: usize = 256;
pub struct FetchedMetadata {
pub info: TorrentInfo,
pub info_dict_bytes: Vec<u8>,
}
pub async fn fetch_metadata(conn: PeerConnection) -> Result<TorrentInfo> {
Ok(fetch_metadata_with_bytes(conn).await?.info)
}
pub async fn fetch_metadata_with_bytes(mut conn: PeerConnection) -> Result<FetchedMetadata> {
conn.send(&PeerMessage::Interested).await?;
let mut metadata_size = None;
let mut ut_metadata_id = None;
let mut metadata = Vec::new();
let mut received = Vec::new();
let mut extended_seen = 0usize;
let mut noise_extended = 0usize;
let mut other_seen = 0usize;
loop {
if extended_seen >= MAX_EXTENDED_FRAMES || other_seen >= MAX_OTHER_MESSAGES {
break;
}
let message = conn.recv().await?;
match message {
PeerMessage::Extended { id, payload } => {
extended_seen += 1;
if let Some((_, ExtensionMessage::Handshake(body))) =
ExtensionMessage::decode(&payload, id, None, None)?
{
let (size, ext_id, _pex) = parse_extension_handshake(&body)?;
metadata_size = size;
ut_metadata_id = ext_id;
if let (Some(size), Some(ext_id)) = (metadata_size, ut_metadata_id) {
if size as usize > MAX_METADATA_BYTES {
return Err(Error::Metadata("metadata size exceeds limit".into()));
}
metadata.resize(size as usize, 0);
let pieces_total = size.div_ceil(METADATA_BLOCK);
received = vec![false; pieces_total as usize];
conn.send_extended(ext_id, &build_extension_handshake(size))
.await?;
request_all_metadata(&mut conn, ext_id, size).await?;
}
} else if let Some((_ext_id, ExtensionMessage::Metadata(meta))) =
ExtensionMessage::decode(&payload, id, ut_metadata_id, None)?
{
if let MetadataMessage::Data {
piece,
total_size,
data,
} = meta
{
validate_metadata_piece(piece, total_size, data.len())?;
let start = piece as usize * METADATA_BLOCK as usize;
if metadata.len() < total_size as usize {
metadata.resize(total_size as usize, 0);
let pieces_total = total_size.div_ceil(METADATA_BLOCK);
received.resize(pieces_total as usize, false);
}
let end = start.saturating_add(data.len()).min(metadata.len());
metadata[start..end].copy_from_slice(&data[..end - start]);
if (piece as usize) < received.len() {
received[piece as usize] = true;
}
if !received.is_empty() && received.iter().all(|&got| got) {
return parse_metadata(&metadata, total_size);
}
}
} else {
noise_extended += 1;
if noise_extended >= MAX_NOISE_EXTENDED {
return Err(Error::Metadata(
"too many non-metadata extended messages".into(),
));
}
}
}
PeerMessage::Unchoke => {
other_seen += 1;
if let (Some(size), Some(ext_id)) = (metadata_size, ut_metadata_id) {
request_all_metadata(&mut conn, ext_id, size).await?;
}
}
_ => {
other_seen += 1;
}
}
}
Err(Error::Metadata("timed out waiting for metadata".into()))
}
pub fn metadata_piece_data(info_dict_bytes: &[u8], piece: u32) -> Option<&[u8]> {
let start = piece as usize * METADATA_PIECE_SIZE as usize;
if start >= info_dict_bytes.len() {
return None;
}
let end = (start + METADATA_PIECE_SIZE as usize).min(info_dict_bytes.len());
Some(&info_dict_bytes[start..end])
}
pub fn metadata_data_message(info_dict_bytes: &[u8], piece: u32) -> Option<MetadataMessage> {
let data = metadata_piece_data(info_dict_bytes, piece)?;
Some(MetadataMessage::Data {
piece,
total_size: info_dict_bytes.len() as u32,
data: data.to_vec(),
})
}
async fn request_all_metadata(
conn: &mut PeerConnection,
ext_id: u8,
total_size: u32,
) -> Result<()> {
let pieces = total_size.div_ceil(METADATA_BLOCK);
for piece in 0..pieces {
conn.send_extended(
ext_id,
&ExtensionMessage::Metadata(MetadataMessage::Request { piece }),
)
.await?;
}
Ok(())
}
fn parse_metadata(metadata: &[u8], total_size: u32) -> Result<FetchedMetadata> {
let slice = metadata
.get(..total_size as usize)
.ok_or_else(|| Error::Metadata("metadata buffer shorter than total_size".into()))?;
let info_value = decode_with_limits(slice, DecodeLimits::METADATA)?;
let info = parse_info(&info_value)?;
Ok(FetchedMetadata {
info,
info_dict_bytes: slice.to_vec(),
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn metadata_block_count() {
assert_eq!(32_768u32.div_ceil(METADATA_BLOCK), 2);
}
}