use std::net::SocketAddr;
use std::time::Duration;
use tracing::{debug, trace, warn};
use super::dispatcher::DhtDispatcher;
use super::message::DhtMessage;
use super::message_decode;
use super::node::DhtNode;
use super::node_id::NodeId;
use super::peer_announce::DhtPeerAnnounceStorage;
use super::routing_table::RoutingTable;
use super::token_tracker::TokenTracker;
#[derive(Debug)]
pub enum ReceiveAction {
Respond(DhtMessage),
ResponseReceived {
method: String,
sender_addr: SocketAddr,
target_node_id: NodeId,
elapsed: Duration,
},
NoAction,
}
pub struct DhtReceiver {
local_id: NodeId,
}
impl DhtReceiver {
pub fn new(local_id: NodeId) -> Self {
Self { local_id }
}
pub fn receive_message(
&self,
data: &[u8],
remote_addr: SocketAddr,
dispatcher: &mut DhtDispatcher,
routing_table: &mut RoutingTable,
peer_announce_storage: &mut DhtPeerAnnounceStorage,
token_tracker: &mut TokenTracker,
) -> Vec<ReceiveAction> {
let mut actions = Vec::new();
if let Some(tid) = Self::extract_transaction_id(data)
&& let Some(tracked) = dispatcher.take_tracked(&tid, remote_addr)
{
let method = tracked.method.clone();
let target_node_id = tracked.target_node_id;
let elapsed = tracked.elapsed;
trace!(
tid = ?tid,
addr = %remote_addr,
method = %method,
"Received DHT response matching tracked query"
);
match message_decode::decode_response_with_method(data, remote_addr, &method) {
Ok(msg) => {
self.handle_response(
&msg,
remote_addr,
target_node_id,
elapsed,
routing_table,
peer_announce_storage,
&mut actions,
);
}
Err(e) => {
warn!(
addr = %remote_addr,
method = %method,
error = %e,
"Failed to decode DHT response"
);
}
}
return actions;
}
match message_decode::decode(data, remote_addr) {
Ok(msg) => {
self.handle_query(
&msg,
remote_addr,
routing_table,
peer_announce_storage,
token_tracker,
&mut actions,
);
}
Err(e) => {
trace!(
addr = %remote_addr,
error = %e,
"Failed to decode DHT message (may be unknown response)"
);
}
}
actions
}
#[allow(clippy::too_many_arguments)]
fn handle_response(
&self,
msg: &DhtMessage,
_remote_addr: SocketAddr,
target_node_id: NodeId,
elapsed: Duration,
routing_table: &mut RoutingTable,
peer_announce_storage: &mut DhtPeerAnnounceStorage,
actions: &mut Vec<ReceiveAction>,
) {
if let Some(sender_id) = msg.sender_id() {
if *sender_id != target_node_id && target_node_id != NodeId::ZERO {
debug!(
old_id = %target_node_id,
new_id = %sender_id,
"Node ID has changed, dropping stale entry from routing table"
);
routing_table.drop_node(&target_node_id);
}
let mut node = DhtNode::new(*sender_id, *msg.sender_addr());
node.update_rtt(elapsed.as_millis() as u64);
routing_table.add_good_node(node);
}
if let DhtMessage::GetPeersResponse { payload, .. } = msg {
for peer_info in &payload.values {
peer_announce_storage.add_peer_announce(
&NodeId::ZERO, peer_info.addr,
);
}
}
actions.push(ReceiveAction::ResponseReceived {
method: msg.method_name().unwrap_or("unknown").to_owned(),
sender_addr: *msg.sender_addr(),
target_node_id,
elapsed,
});
}
fn handle_query(
&self,
msg: &DhtMessage,
remote_addr: SocketAddr,
routing_table: &mut RoutingTable,
peer_announce_storage: &mut DhtPeerAnnounceStorage,
token_tracker: &mut TokenTracker,
actions: &mut Vec<ReceiveAction>,
) {
if let Some(sender_id) = msg.sender_id() {
let node = DhtNode::new(*sender_id, remote_addr);
routing_table.add_node(node);
}
match msg {
DhtMessage::PingQuery { transaction_id, .. } => {
debug!(tid = ?transaction_id, addr = %remote_addr, "Received DHT ping query");
let reply = DhtMessage::PingResponse {
transaction_id: transaction_id.clone(),
sender_id: self.local_id,
sender_addr: remote_addr,
payload: super::message::PingResponsePayload,
};
actions.push(ReceiveAction::Respond(reply));
}
DhtMessage::FindNodeQuery {
transaction_id,
sender_id: _,
payload,
..
} => {
debug!(
tid = ?transaction_id,
addr = %remote_addr,
target = %payload.target,
"Received DHT find_node query"
);
let closest = routing_table.get_closest_k_nodes(&payload.target);
let nodes: Vec<super::message::CompactNodeInfo> = closest
.into_iter()
.map(|n| super::message::CompactNodeInfo {
node_id: *n.id(),
addr: n.addr(),
})
.collect();
let reply = DhtMessage::FindNodeResponse {
transaction_id: transaction_id.clone(),
sender_id: self.local_id,
sender_addr: remote_addr,
payload: super::message::FindNodeResponsePayload { nodes },
};
actions.push(ReceiveAction::Respond(reply));
}
DhtMessage::GetPeersQuery {
transaction_id,
sender_id: _,
payload,
..
} => {
debug!(
tid = ?transaction_id,
addr = %remote_addr,
info_hash = %payload.info_hash,
"Received DHT get_peers query"
);
let ip_str = remote_addr.ip().to_string();
let port = remote_addr.port();
let token =
token_tracker.generate_token(payload.info_hash.as_bytes(), &ip_str, port);
let peers = peer_announce_storage.get_peers(&payload.info_hash);
let values: Vec<super::message::CompactPeerInfo> = peers
.into_iter()
.map(|addr| super::message::CompactPeerInfo { addr })
.collect();
let closest = routing_table.get_closest_k_nodes(&payload.info_hash);
let nodes: Vec<super::message::CompactNodeInfo> = closest
.into_iter()
.map(|n| super::message::CompactNodeInfo {
node_id: *n.id(),
addr: n.addr(),
})
.collect();
let reply = DhtMessage::GetPeersResponse {
transaction_id: transaction_id.clone(),
sender_id: self.local_id,
sender_addr: remote_addr,
payload: super::message::GetPeersResponsePayload {
token,
nodes,
values,
},
};
actions.push(ReceiveAction::Respond(reply));
}
DhtMessage::AnnouncePeerQuery {
transaction_id,
sender_id: _,
payload,
..
} => {
debug!(
tid = ?transaction_id,
addr = %remote_addr,
info_hash = %payload.info_hash,
port = payload.port,
"Received DHT announce_peer query"
);
let ip_str = remote_addr.ip().to_string();
let port = remote_addr.port();
if token_tracker.validate_token(
&payload.token,
payload.info_hash.as_bytes(),
&ip_str,
port,
) {
let announce_addr = if payload.port > 0 {
SocketAddr::new(remote_addr.ip(), payload.port)
} else {
remote_addr
};
peer_announce_storage.add_peer_announce(&payload.info_hash, announce_addr);
let reply = DhtMessage::AnnouncePeerResponse {
transaction_id: transaction_id.clone(),
sender_id: self.local_id,
sender_addr: remote_addr,
payload: super::message::AnnouncePeerResponsePayload,
};
actions.push(ReceiveAction::Respond(reply));
} else {
warn!(
addr = %remote_addr,
"Invalid token in announce_peer query, ignoring"
);
}
}
DhtMessage::Error { code, message, .. } => {
warn!(
addr = %remote_addr,
code = code,
msg = %message,
"Received DHT error message"
);
actions.push(ReceiveAction::NoAction);
}
_ => {
trace!(addr = %remote_addr, "Unexpected message type in query handler");
}
}
}
fn extract_transaction_id(data: &[u8]) -> Option<Vec<u8>> {
let pattern = b"1:t";
let start = data.windows(3).position(|w| w == pattern)?;
let after = &data[start + 3..];
let colon_pos = after.iter().position(|&b| b == b':')?;
let len_str = std::str::from_utf8(&after[..colon_pos]).ok()?;
let len: usize = len_str.parse().ok()?;
let tid_start = colon_pos + 1;
let tid_end = tid_start + len;
if tid_end > after.len() {
return None;
}
Some(after[tid_start..tid_end].to_vec())
}
pub fn handle_timeouts(
&self,
dispatcher: &mut DhtDispatcher,
routing_table: &mut RoutingTable,
) -> Vec<super::tracker::TimeoutEntry> {
let timed_out = dispatcher.handle_timeouts();
for entry in &timed_out {
debug!(
addr = %entry.target_addr,
method = %entry.method,
elapsed_ms = entry.elapsed.as_millis(),
"DHT query timed out"
);
if entry.target_node_id != NodeId::ZERO {
let node_id = entry.target_node_id;
let rtt_ms = entry.elapsed.as_millis() as u64;
if let Some(node) = routing_table.get_node_mut(&node_id) {
node.update_rtt(rtt_ms);
node.timeout();
trace!(
node_id = %node_id,
rtt_ms = rtt_ms,
condition = node.condition(),
"Applied timeout penalty to DHT node"
);
} else {
routing_table.move_bucket_tail(&node_id);
}
}
}
timed_out
}
}
#[cfg(test)]
mod tests {
use super::super::constants::ID_LENGTH;
use super::*;
fn test_local_id() -> NodeId {
NodeId([0xAA; ID_LENGTH])
}
#[allow(dead_code)]
fn test_addr() -> SocketAddr {
"192.168.0.1:6881".parse().unwrap()
}
#[allow(dead_code)]
fn test_sender_id() -> NodeId {
NodeId([0xBB; ID_LENGTH])
}
#[test]
fn extract_tid_from_ping_query() {
let data = b"d1:t4:abcd1:y1:q1:q4:pinge";
let tid = DhtReceiver::extract_transaction_id(data);
assert_eq!(tid, Some(b"abcd".to_vec()));
}
#[test]
fn extract_tid_from_response() {
let data = b"d1:t2:xx1:y1:re";
let tid = DhtReceiver::extract_transaction_id(data);
assert_eq!(tid, Some(b"xx".to_vec()));
}
#[test]
fn extract_tid_missing_returns_none() {
let data = b"d1:y1:qe";
let tid = DhtReceiver::extract_transaction_id(data);
assert!(tid.is_none());
}
#[test]
fn extract_tid_empty_data() {
let tid = DhtReceiver::extract_transaction_id(b"");
assert!(tid.is_none());
}
#[test]
fn new_receiver_has_local_id() {
let r = DhtReceiver::new(test_local_id());
assert_eq!(r.local_id, test_local_id());
}
}