bool rpc_manager::incoming(msg const& m, node_id* id)
{
INVARIANT_CHECK;
if (m_destructing) return false;
// we only deal with replies and errors, not queries
TORRENT_ASSERT(m.message.dict_find_string_value("y") == "r"
|| m.message.dict_find_string_value("y") == "e");
// if we don't have the transaction id in our
// request list, ignore the packet
std::string transaction_id = m.message.dict_find_string_value("t");
if (transaction_id.empty()) return false;
std::string::const_iterator ptr = transaction_id.begin();
int tid = transaction_id.size() != 2 ? -1 : io::read_uint16(ptr);
observer_ptr o;
std::pair<transactions_t::iterator, transactions_t::iterator> range = m_transactions.equal_range(tid);
for (transactions_t::iterator i = range.first; i != range.second; ++i)
{
if (m.addr.address() != i->second->target_addr()) continue;
o = i->second;
i = m_transactions.erase(i);
break;
}
if (!o)
{
#ifndef TORRENT_DISABLE_LOGGING
if (m_table.native_endpoint(m.addr))
{
m_log->log(dht_logger::rpc_manager, "reply with unknown transaction id size: %d from %s"
, int(transaction_id.size()), print_endpoint(m.addr).c_str());
}
#endif
// this isn't necessarily because the other end is doing
// something wrong. This can also happen when we restart
// the node, and we prematurely abort all outstanding
// requests. Also, this opens up a potential magnification
// attack.
// entry e;
// incoming_error(e, "invalid transaction id");
// m_sock->send_packet(e, m.addr);
return false;
}
time_point now = clock_type::now();
#ifndef TORRENT_DISABLE_LOGGING
m_log->log(dht_logger::rpc_manager, "round trip time(ms): %" PRId64 " from %s"
, total_milliseconds(now - o->sent()), print_endpoint(m.addr).c_str());
#endif
if (m.message.dict_find_string_value("y") == "e")
{
// It's an error.
#ifndef TORRENT_DISABLE_LOGGING
bdecode_node err = m.message.dict_find_list("e");
if (err && err.list_size() >= 2
&& err.list_at(0).type() == bdecode_node::int_t
&& err.list_at(1).type() == bdecode_node::string_t)
{
m_log->log(dht_logger::rpc_manager, "reply with error from %s: (%" PRId64 ") %s"
, print_endpoint(m.addr).c_str()
, err.list_int_value_at(0)
, err.list_string_value_at(1).c_str());
}
else
{
m_log->log(dht_logger::rpc_manager, "reply with (malformed) error from %s"
, print_endpoint(m.addr).c_str());
}
#endif
// Logically, we should call o->reply(m) since we get a reply.
// a reply could be "response" or "error", here the reply is an "error".
// if the reply is an "error", basically the observer could/will
// do nothing with it, especially when observer::reply() is intended to
// handle a "response", not an "error".
// A "response" should somehow call algorithm->finished(), and an error/timeout
// should call algorithm->failed(). From this point of view,
// we should call o->timeout() instead of o->reply(m) because o->reply()
// will call algorithm->finished().
o->timeout();
return false;
}
bdecode_node ret_ent = m.message.dict_find_dict("r");
if (!ret_ent)
{
o->timeout();
return false;
}
bdecode_node node_id_ent = ret_ent.dict_find_string("id");
if (!node_id_ent || node_id_ent.string_length() != 20)
{
o->timeout();
return false;
}
node_id nid = node_id(node_id_ent.string_ptr());
if (m_settings.enforce_node_id && !verify_id(nid, m.addr.address()))
{
o->timeout();
return false;
}
#ifndef TORRENT_DISABLE_LOGGING
m_log->log(dht_logger::rpc_manager, "[%p] reply with transaction id: %d from %s"
, static_cast<void*>(o->algorithm()), int(transaction_id.size())
, print_endpoint(m.addr).c_str());
#endif
o->reply(m);
*id = nid;
int rtt = int(total_milliseconds(now - o->sent()));
// we found an observer for this reply, hence the node is not spoofing
// add it to the routing table
return m_table.node_seen(*id, m.addr, rtt);
}
bool rpc_manager::incoming(msg const& m, node_id* id
, libtorrent::dht_settings const& settings)
{
INVARIANT_CHECK;
if (m_destructing) return false;
// we only deal with replies and errors, not queries
TORRENT_ASSERT(m.message.dict_find_string_value("y") == "r"
|| m.message.dict_find_string_value("y") == "e");
// if we don't have the transaction id in our
// request list, ignore the packet
std::string transaction_id = m.message.dict_find_string_value("t");
if (transaction_id.empty()) return false;
std::string::const_iterator i = transaction_id.begin();
int tid = transaction_id.size() != 2 ? -1 : io::read_uint16(i);
observer_ptr o;
std::pair<transactions_t::iterator, transactions_t::iterator> range = m_transactions.equal_range(tid);
for (transactions_t::iterator i = range.first; i != range.second; ++i)
{
if (m.addr.address() != i->second->target_addr()) continue;
o = i->second;
i = m_transactions.erase(i);
break;
}
if (!o)
{
#ifndef TORRENT_DISABLE_LOGGING
m_log->log(dht_logger::rpc_manager, "reply with unknown transaction id size: %d from %s"
, int(transaction_id.size()), print_endpoint(m.addr).c_str());
#endif
// this isn't necessarily because the other end is doing
// something wrong. This can also happen when we restart
// the node, and we prematurely abort all outstanding
// requests. Also, this opens up a potential magnification
// attack.
// entry e;
// incoming_error(e, "invalid transaction id");
// m_sock->send_packet(e, m.addr, 0);
return false;
}
time_point now = clock_type::now();
#ifndef TORRENT_DISABLE_LOGGING
std::ofstream reply_stats("round_trip_ms.log", std::ios::app);
reply_stats << m.addr << "\t" << total_milliseconds(now - o->sent())
<< std::endl;
#endif
bdecode_node ret_ent = m.message.dict_find_dict("r");
if (!ret_ent)
{
// it may be an error
ret_ent = m.message.dict_find("e");
o->timeout();
if (!ret_ent)
{
entry e;
incoming_error(e, "missing 'r' key");
m_sock->send_packet(e, m.addr, 0);
}
return false;
}
bdecode_node node_id_ent = ret_ent.dict_find_string("id");
if (!node_id_ent || node_id_ent.string_length() != 20)
{
o->timeout();
entry e;
incoming_error(e, "missing 'id' key");
m_sock->send_packet(e, m.addr, 0);
return false;
}
node_id nid = node_id(node_id_ent.string_ptr());
if (settings.enforce_node_id && !verify_id(nid, m.addr.address()))
{
o->timeout();
entry e;
incoming_error(e, "invalid node ID");
m_sock->send_packet(e, m.addr, 0);
return false;
}
#ifndef TORRENT_DISABLE_LOGGING
m_log->log(dht_logger::rpc_manager, "[%p] reply with transaction id: %d from %s"
, o->algorithm(), int(transaction_id.size())
, print_endpoint(m.addr).c_str());
#endif
o->reply(m);
*id = nid;
int rtt = int(total_milliseconds(now - o->sent()));
// we found an observer for this reply, hence the node is not spoofing
// add it to the routing table
return m_table.node_seen(*id, m.addr, rtt);
}
