void ConnectionManager::connect(const Node::Ptr& node, const string& token, bool secure)
{
// don't allow connection if we didn't proceed a handshake
if(!node->isOnline())
{
// do handshake at first
DHT::getInstance()->info(node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
DHT::PING | DHT::MAKE_ONLINE, node->getUser()->getCID(), node->getUdpKey());
return;
}
bool active = ClientManager::getInstance()->isActive();
// if I am not active, send reverse connect to me request
AdcCommand cmd(active ? AdcCommand::CMD_CTM : AdcCommand::CMD_RCM, AdcCommand::TYPE_UDP);
cmd.addParam(secure ? SECURE_CLIENT_PROTOCOL_TEST : CLIENT_PROTOCOL);
if(active)
{
uint16_t port = secure ? dcpp::ConnectionManager::getInstance()->getSecurePort() : dcpp::ConnectionManager::getInstance()->getPort();
cmd.addParam(Util::toString(port));
}
cmd.addParam(token);
DHT::getInstance()->send(cmd, node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
node->getUser()->getCID(), node->getUdpKey());
}
/*
* Sends request to create connection with me
*/
void ConnectionManager::revConnectToMe(const Node::Ptr& node, const AdcCommand& cmd)
{
// don't allow connection if we didn't proceed a handshake
//if(!node->isOnline())
// return;
// this is valid for active-passive connections only
if(!ClientManager::getInstance()->isActive())
return;
const string& protocol = cmd.getParam(1);
const string& token = cmd.getParam(2);
bool secure;
if(protocol == CLIENT_PROTOCOL)
{
secure = false;
}
else if(protocol == SECURE_CLIENT_PROTOCOL_TEST && CryptoManager::getInstance()->TLSOk())
{
secure = true;
}
else
{
AdcCommand sta(AdcCommand::SEV_FATAL, AdcCommand::ERROR_PROTOCOL_UNSUPPORTED, "Protocol unknown", AdcCommand::TYPE_UDP);
sta.addParam("PR", protocol);
sta.addParam("TO", token);
DHT::getInstance()->send(sta, node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
node->getUser()->getCID(), node->getUdpKey());
return;
}
connect(node, token, secure);
}
/*
* Creates connection to specified node
*/
void ConnectionManager::connectToMe(const Node::Ptr& node, const AdcCommand& cmd)
{
// don't allow connection if we didn't proceed a handshake
if(!node->isOnline())
{
// do handshake at first
DHT::getInstance()->info(node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
DHT::PING | DHT::MAKE_ONLINE, node->getUser()->getCID(), node->getUdpKey());
return;
}
const string& protocol = cmd.getParam(1);
const string& port = cmd.getParam(2);
const string& token = cmd.getParam(3);
bool secure = false;
if(protocol == CLIENT_PROTOCOL)
{
// Nothing special
}
else if(protocol == SECURE_CLIENT_PROTOCOL_TEST && CryptoManager::getInstance()->TLSOk())
{
secure = true;
}
else
{
AdcCommand cmd(AdcCommand::SEV_FATAL, AdcCommand::ERROR_PROTOCOL_UNSUPPORTED, "Protocol unknown", AdcCommand::TYPE_UDP);
cmd.addParam("PR", protocol);
cmd.addParam("TO", token);
DHT::getInstance()->send(cmd, node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
node->getUser()->getCID(), node->getUdpKey());
return;
}
if(!node->getIdentity().isTcpActive(0))
{
AdcCommand err(AdcCommand::SEV_FATAL, AdcCommand::ERROR_PROTOCOL_GENERIC, "IP unknown", AdcCommand::TYPE_UDP);
DHT::getInstance()->send(err, node->getIdentity().getIp(), static_cast<uint16_t>(Util::toInt(node->getIdentity().getUdpPort())),
node->getUser()->getCID(), node->getUdpKey());
return;
}
dcpp::ConnectionManager::getInstance()->adcConnect(*node, static_cast<uint16_t>(Util::toInt(port)), token, secure);
}
/*
* Add new source to tth list
*/
void IndexManager::addSource(const TTHValue& tth, const Node::Ptr& node, uint64_t size, bool partial)
{
Source source;
source.setCID(node->getUser()->getCID());
source.setIp(node->getIdentity().getIp());
source.setUdpPort(node->getIdentity().getUdpPort());
source.setSize(size);
source.setExpires(GET_TICK() + (partial ? PFS_REPUBLISH_TIME : REPUBLISH_TIME));
source.setPartial(partial);
Lock l(cs);
TTHMap::iterator i = tthList.find(tth);
if(i != tthList.end())
{
// no user duplicites
SourceList& sources = i->second;
for(SourceList::iterator s = sources.begin(); s != sources.end(); ++s)
{
if(node->getUser()->getCID() == (*s).getCID())
{
// delete old item
sources.erase(s);
break;
}
}
// old items in front, new items in back
sources.push_back(source);
// if maximum sources reached, remove the oldest one
if(sources.size() > MAX_SEARCH_RESULTS)
sources.pop_front();
}
else
{
// new file
tthList.insert(std::make_pair(tth, SourceList(1, source)));
}
DHT::getInstance()->setDirty();
}
/*
* Sends Connect To Me request to online node
*/
void ConnectionManager::connect(const Node::Ptr& node, const string& token)
{
connect(node, token, CryptoManager::getInstance()->TLSOk() && node->getUser()->isSet(User::TLS));
}
/*
* Processes incoming request to publish file
*/
void IndexManager::processPublishSourceRequest(const Node::Ptr& node, const AdcCommand& cmd)
{
string tth;
if(!cmd.getParam("TR", 1, tth))
return; // nothing to identify a file?
string size;
if(!cmd.getParam("SI", 1, size))
return; // no file size?
string partial;
cmd.getParam("PF", 1, partial);
addSource(TTHValue(tth), node, Util::toInt64(size), partial == "1");
// send response
AdcCommand res(AdcCommand::SEV_SUCCESS, AdcCommand::SUCCESS, "File published", AdcCommand::TYPE_UDP);
res.addParam("FC", "PUB");
res.addParam("TR", tth);
DHT::getInstance()->send(res, node->getIdentity().getIp(), node->getIdentity().getUdpPort(), node->getUser()->getCID(), node->getUdpKey());
}
