use std::io::{self, Read, Write};
use std::net::SocketAddr;
use std::time::{SystemTime, UNIX_EPOCH};
use tracing::{debug, warn};
use super::constants::ID_LENGTH;
use super::node::DhtNode;
use super::node_id::NodeId;
use super::routing_table::RoutingTable;
const MAGIC: [u8; 2] = [0xA1, 0xA2];
const FORMAT_ID: u8 = 0x02;
const VERSION: u16 = 3;
const MIN_VERSION: u16 = 2;
const COMPACT_LEN_IPV4: usize = 6;
const COMPACT_LEN_IPV6: usize = 18;
#[allow(dead_code)]
const NODE_RECORD_SIZE: usize = 56;
pub fn serialize_to_writer(table: &RoutingTable, mut writer: impl Write) -> io::Result<()> {
let mut header = [0u8; 8];
header[0] = MAGIC[0];
header[1] = MAGIC[1];
header[2] = FORMAT_ID;
header[6..8].copy_from_slice(&VERSION.to_be_bytes());
writer.write_all(&header)?;
let epoch_secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
writer.write_all(&epoch_secs.to_be_bytes())?;
let zero8 = [0u8; 8];
let zero4 = [0u8; 4];
writer.write_all(&zero8)?; writer.write_all(table.local_node_id().as_bytes())?; writer.write_all(&zero4)?;
let buckets = table.get_buckets();
let all_nodes: Vec<&DhtNode> = buckets
.iter()
.flat_map(|b| b.nodes().iter().map(|n| n.as_ref()))
.collect();
let num_nodes = all_nodes.len() as u32;
writer.write_all(&num_nodes.to_be_bytes())?;
writer.write_all(&zero4)?;
for node in &all_nodes {
write_node_record(&mut writer, node)?;
}
debug!(
nodes = all_nodes.len(),
"DHT routing table serialized successfully"
);
Ok(())
}
fn write_node_record(mut writer: impl Write, node: &DhtNode) -> io::Result<()> {
let zero7 = [0u8; 7];
let zero4 = [0u8; 4];
let addr = node.addr();
let (compact, compact_len) = pack_compact_peer(addr);
writer.write_all(&[compact_len as u8])?;
writer.write_all(&zero7)?;
writer.write_all(&compact[..compact_len])?;
let padding = 24 - compact_len;
let zero_buf = [0u8; 24];
writer.write_all(&zero_buf[..padding])?;
writer.write_all(node.id().as_bytes())?;
writer.write_all(&zero4)?;
Ok(())
}
#[derive(Debug)]
pub struct DeserializeResult {
pub local_node_id: NodeId,
pub saved_at: u64,
pub nodes: Vec<DhtNode>,
}
pub fn deserialize_from_reader(mut reader: impl Read) -> io::Result<DeserializeResult> {
let mut header = [0u8; 8];
reader.read_exact(&mut header)?;
if header[0] != MAGIC[0] || header[1] != MAGIC[1] {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"DHT routing table: bad magic bytes",
));
}
if header[2] != FORMAT_ID {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"DHT routing table: unsupported format ID",
));
}
let version = u16::from_be_bytes([header[6], header[7]]);
if !(MIN_VERSION..=VERSION).contains(&version) {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("DHT routing table: unsupported version {}", version),
));
}
let saved_at = if version == 2 {
let mut buf = [0u8; 4];
reader.read_exact(&mut buf)?;
let ts = u32::from_be_bytes(buf);
let mut skip = [0u8; 4];
reader.read_exact(&mut skip)?;
ts as u64
} else {
let mut buf = [0u8; 8];
reader.read_exact(&mut buf)?;
u64::from_be_bytes(buf)
};
let mut skip8 = [0u8; 8];
reader.read_exact(&mut skip8)?;
let mut id_buf = [0u8; ID_LENGTH];
reader.read_exact(&mut id_buf)?; let local_node_id = NodeId::from_slice(&id_buf);
let mut skip4 = [0u8; 4];
reader.read_exact(&mut skip4)?;
let mut count_buf = [0u8; 4];
reader.read_exact(&mut count_buf)?;
let num_nodes = u32::from_be_bytes(count_buf);
reader.read_exact(&mut skip4)?;
let mut nodes = Vec::with_capacity(num_nodes as usize);
for _ in 0..num_nodes {
match read_node_record(&mut reader) {
Ok(Some(node)) => nodes.push(node),
Ok(None) => continue, Err(e) => {
warn!("Error reading DHT node record: {}", e);
break; }
}
}
debug!(
nodes = nodes.len(),
saved_at, "DHT routing table deserialized successfully"
);
Ok(DeserializeResult {
local_node_id,
saved_at,
nodes,
})
}
fn read_node_record(mut reader: impl Read) -> io::Result<Option<DhtNode>> {
let mut skip7 = [0u8; 7];
let mut skip4 = [0u8; 4];
let mut clen_buf = [0u8; 1];
reader.read_exact(&mut clen_buf)?;
let compact_len = clen_buf[0] as usize;
reader.read_exact(&mut skip7)?;
if compact_len != COMPACT_LEN_IPV4 && compact_len != COMPACT_LEN_IPV6 {
let mut skip = [0u8; 48];
reader.read_exact(&mut skip)?;
return Ok(None);
}
let mut compact = [0u8; COMPACT_LEN_IPV6]; reader.read_exact(&mut compact[..compact_len])?;
if compact[..compact_len].iter().all(|&b| b == 0) {
let remaining = (24 - compact_len) + ID_LENGTH + 4;
let mut skip = [0u8; 48]; reader.read_exact(&mut skip[..remaining])?;
return Ok(None);
}
let addr = match unpack_compact_peer(&compact[..compact_len]) {
Some(a) => a,
None => {
let remaining = (24 - compact_len) + ID_LENGTH + 4;
let mut skip = [0u8; 48];
reader.read_exact(&mut skip[..remaining])?;
return Ok(None);
}
};
let padding = 24 - compact_len;
if padding > 0 {
let mut skip = [0u8; 24];
reader.read_exact(&mut skip[..padding])?;
}
let mut id_buf = [0u8; ID_LENGTH];
reader.read_exact(&mut id_buf)?;
let node_id = NodeId::from_slice(&id_buf);
reader.read_exact(&mut skip4)?;
Ok(Some(DhtNode::new(node_id, addr)))
}
fn pack_compact_peer(addr: SocketAddr) -> ([u8; COMPACT_LEN_IPV6], usize) {
use std::net::IpAddr;
let mut buf = [0u8; COMPACT_LEN_IPV6];
match addr.ip() {
IpAddr::V4(v4) => {
buf[..4].copy_from_slice(&v4.octets());
buf[4..6].copy_from_slice(&addr.port().to_be_bytes());
(buf, COMPACT_LEN_IPV4)
}
IpAddr::V6(v6) => {
buf[..16].copy_from_slice(&v6.octets());
buf[16..18].copy_from_slice(&addr.port().to_be_bytes());
(buf, COMPACT_LEN_IPV6)
}
}
}
fn unpack_compact_peer(data: &[u8]) -> Option<SocketAddr> {
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
match data.len() {
COMPACT_LEN_IPV4 => {
let mut ip_bytes = [0u8; 4];
ip_bytes.copy_from_slice(&data[..4]);
let port = u16::from_be_bytes([data[4], data[5]]);
Some(SocketAddr::new(IpAddr::V4(Ipv4Addr::from(ip_bytes)), port))
}
COMPACT_LEN_IPV6 => {
let mut ip_bytes = [0u8; 16];
ip_bytes.copy_from_slice(&data[..16]);
let port = u16::from_be_bytes([data[16], data[17]]);
Some(SocketAddr::new(IpAddr::V6(Ipv6Addr::from(ip_bytes)), port))
}
_ => None,
}
}
pub fn serialize_to_file(table: &RoutingTable, path: &std::path::Path) -> io::Result<()> {
let temp_path = path.with_extension("dat__temp");
{
let file = std::fs::File::create(&temp_path)?;
serialize_to_writer(table, file)?;
}
std::fs::rename(&temp_path, path)?;
debug!("DHT routing table saved to {:?}", path);
Ok(())
}
pub fn deserialize_from_file(path: &std::path::Path) -> io::Result<DeserializeResult> {
let file = std::fs::File::open(path)?;
deserialize_from_reader(file)
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
fn test_addr_v4() -> SocketAddr {
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1)), 6881)
}
fn test_addr_v6() -> SocketAddr {
SocketAddr::new(
IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)),
6881,
)
}
fn make_node(id_byte: u8, addr: SocketAddr) -> DhtNode {
let id = NodeId::from_slice(&[id_byte; ID_LENGTH]);
DhtNode::new(id, addr)
}
#[test]
fn serialize_deserialize_roundtrip_ipv4() {
let local_id = NodeId::from_slice(&[0x80; ID_LENGTH]);
let mut table = RoutingTable::new(local_id);
for i in 1u8..5 {
let mut node = make_node(
i,
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(10, 0, 0, i)), 6881 + i as u16),
);
node.mark_good();
node.update_last_contact();
table.add_node(node);
}
let mut buf = Vec::new();
serialize_to_writer(&table, &mut buf).unwrap();
let result = deserialize_from_reader(&buf[..]).unwrap();
assert_eq!(result.local_node_id, local_id);
assert!(result.saved_at > 0);
assert_eq!(result.nodes.len(), 4);
for node in &result.nodes {
assert_eq!(
node.id().as_bytes()[0],
((node.addr().port() - 6881u16) & 0xFF) as u8
);
}
}
#[test]
fn serialize_deserialize_roundtrip_ipv6() {
let local_id = NodeId::from_slice(&[0x80; ID_LENGTH]);
let mut table = RoutingTable::new(local_id);
let mut node = make_node(0x01, test_addr_v6());
node.mark_good();
node.update_last_contact();
table.add_node(node);
let mut buf = Vec::new();
serialize_to_writer(&table, &mut buf).unwrap();
let result = deserialize_from_reader(&buf[..]).unwrap();
assert_eq!(result.nodes.len(), 1);
assert_eq!(result.nodes[0].addr(), test_addr_v6());
}
#[test]
fn header_magic_validation() {
let bad_data = [0u8; 64];
let result = deserialize_from_reader(&bad_data[..]);
assert!(result.is_err());
assert!(result.unwrap_err().kind() == io::ErrorKind::InvalidData);
}
#[test]
fn version_2_backward_compat() {
let mut buf = Vec::new();
let mut header = [0u8; 8];
header[0] = MAGIC[0];
header[1] = MAGIC[1];
header[2] = FORMAT_ID;
header[6] = 0;
header[7] = 0x02; buf.extend_from_slice(&header);
buf.extend_from_slice(&1000u32.to_be_bytes());
buf.extend_from_slice(&[0u8; 4]);
buf.extend_from_slice(&[0u8; 8]);
buf.extend_from_slice(&[0xAB; ID_LENGTH]);
buf.extend_from_slice(&[0u8; 4]);
buf.extend_from_slice(&0u32.to_be_bytes());
buf.extend_from_slice(&[0u8; 4]);
let result = deserialize_from_reader(&buf[..]).unwrap();
assert_eq!(result.saved_at, 1000);
assert_eq!(result.local_node_id.as_bytes(), &[0xAB; ID_LENGTH]);
assert!(result.nodes.is_empty());
}
#[test]
fn compact_peer_pack_unpack_ipv4() {
let (packed, len) = pack_compact_peer(test_addr_v4());
assert_eq!(len, COMPACT_LEN_IPV4);
let addr = unpack_compact_peer(&packed[..len]).unwrap();
assert_eq!(addr, test_addr_v4());
}
#[test]
fn compact_peer_pack_unpack_ipv6() {
let (packed, len) = pack_compact_peer(test_addr_v6());
assert_eq!(len, COMPACT_LEN_IPV6);
let addr = unpack_compact_peer(&packed[..len]).unwrap();
assert_eq!(addr, test_addr_v6());
}
#[test]
fn empty_routing_table_serializes() {
let local_id = NodeId::from_slice(&[0x80; ID_LENGTH]);
let table = RoutingTable::new(local_id);
let mut buf = Vec::new();
serialize_to_writer(&table, &mut buf).unwrap();
let result = deserialize_from_reader(&buf[..]).unwrap();
assert_eq!(result.local_node_id, local_id);
assert!(result.nodes.is_empty());
}
#[test]
fn file_roundtrip() {
let dir = std::env::temp_dir().join("aria2_rust_dht_test");
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("dht.dat");
let local_id = NodeId::from_slice(&[0x42; ID_LENGTH]);
let mut table = RoutingTable::new(local_id);
let mut node = make_node(0x01, test_addr_v4());
node.mark_good();
node.update_last_contact();
table.add_node(node);
serialize_to_file(&table, &path).unwrap();
let result = deserialize_from_file(&path).unwrap();
assert_eq!(result.local_node_id, local_id);
assert_eq!(result.nodes.len(), 1);
let _ = std::fs::remove_dir_all(&dir);
}
}