/*
* 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);
}
void UserConnection::handlePM(const AdcCommand& c, bool echo) noexcept{
const string& message = c.getParam(0);
OnlineUserPtr peer = nullptr;
OnlineUserPtr me = nullptr;
auto cm = ClientManager::getInstance();
{
RLock l(cm->getCS());
peer = cm->findOnlineUser(user->getCID(), getHubUrl());
//try to use the same hub so nicks match to a hub, not the perfect solution for CCPM, nicks keep changing when hubs go offline.
if(peer && peer->getHubUrl() != hubUrl)
setHubUrl(peer->getHubUrl());
me = cm->findOnlineUser(cm->getMe()->getCID(), getHubUrl());
}
if (!me || !peer){ //ChatMessage cant be formatted without the OnlineUser!
disconnect(true);
return;
}
if (echo) {
std::swap(peer, me);
}
string tmp;
auto msg = make_shared<ChatMessage>(message, peer, me, peer);
if (c.getParam("TS", 1, tmp)) {
msg->setTime(Util::toInt64(tmp));
}
msg->setThirdPerson(c.hasFlag("ME", 1));
fire(UserConnectionListener::PrivateMessage(), this, msg);
}
void UploadManager::on(AdcCommand::GET, UserConnection* aSource, const AdcCommand& c) throw() {
int64_t aBytes = Util::toInt64(c.getParam(3));
int64_t aStartPos = Util::toInt64(c.getParam(2));
const string& fname = c.getParam(1);
const string& type = c.getParam(0);
if(prepareFile(*aSource, type, fname, aStartPos, aBytes, c.hasFlag("RE", 4))) {
Upload* u = aSource->getUpload();
dcassert(u != NULL);
AdcCommand cmd(AdcCommand::CMD_SND);
cmd.addParam(type).addParam(fname)
.addParam(Util::toString(u->getPos()))
.addParam(Util::toString(u->getSize() - u->getPos()));
if(c.hasFlag("ZL", 4)) {
u->setStream(new FilteredInputStream<ZFilter, true>(u->getStream()));
u->setFlag(Upload::FLAG_ZUPLOAD);
cmd.addParam("ZL1");
}
aSource->send(cmd);
u->setStart(GET_TICK());
aSource->setState(UserConnection::STATE_RUNNING);
aSource->transmitFile(u->getStream());
fire(UploadManagerListener::Starting(), u);
}
}
void UserConnection::handle(AdcCommand::STA t, const AdcCommand& c) {
if(c.getParameters().size() >= 2) {
const string& code = c.getParam(0);
if(!code.empty() && code[0] - '0' == AdcCommand::SEV_FATAL) {
fire(UserConnectionListener::ProtocolError(), this, c.getParam(1));
return;
}
}
fire(t, this, c);
}
void ConnectionManager::on(AdcCommand::INF, UserConnection* aSource, const AdcCommand& cmd) throw() {
if(aSource->getState() != UserConnection::STATE_INF) {
// Already got this once, ignore...
aSource->send(AdcCommand(AdcCommand::SEV_FATAL, AdcCommand::ERROR_PROTOCOL_GENERIC, "Expecting INF"));
dcdebug("CM::onINF %p sent INF twice\n", (void*)aSource);
aSource->disconnect();
return;
}
string cid;
if(!cmd.getParam("ID", 0, cid)) {
aSource->send(AdcCommand(AdcCommand::SEV_FATAL, AdcCommand::ERROR_INF_MISSING, "ID missing").addParam("FL", "ID"));
dcdebug("CM::onINF missing ID\n");
aSource->disconnect();
return;
}
aSource->setUser(ClientManager::getInstance()->findUser(CID(cid)));
if(!aSource->getUser()) {
dcdebug("CM::onINF: User not found");
aSource->send(AdcCommand(AdcCommand::SEV_FATAL, AdcCommand::ERROR_GENERIC, "User not found"));
putConnection(aSource);
return;
}
if(aSource->isSet(UserConnection::FLAG_INCOMING)) {
aSource->setFlag(UserConnection::FLAG_DOWNLOAD);
addDownloadConnection(aSource);
} else {
aSource->setFlag(UserConnection::FLAG_UPLOAD);
addUploadConnection(aSource);
}
}
void SearchManager::respond(const AdcCommand& adc, const CID& from) {
// Filter own searches
if(from == ClientManager::getInstance()->getMe()->getCID())
return;
UserPtr p = ClientManager::getInstance()->findUser(from);
if(!p)
return;
SearchResultList results;
ShareManager::getInstance()->search(results, adc.getParameters(), 10);
string token;
adc.getParam("TO", 0, token);
if(results.empty())
return;
for(SearchResultList::const_iterator i = results.begin(); i != results.end(); ++i) {
AdcCommand cmd = (*i)->toRES(AdcCommand::TYPE_UDP);
if(!token.empty())
cmd.addParam("TO", token);
ClientManager::getInstance()->send(cmd, from);
}
}
/** @todo Handle errors better */
void DownloadManager::on(AdcCommand::STA, UserConnection* aSource, const AdcCommand& cmd) noexcept {
if(cmd.getParameters().size() < 2) {
aSource->disconnect();
return;
}
const string& err = cmd.getParameters()[0];
if(err.length() != 3) {
aSource->disconnect();
return;
}
switch(Util::toInt(err.substr(0, 1))) {
case AdcCommand::SEV_FATAL:
aSource->disconnect();
return;
case AdcCommand::SEV_RECOVERABLE:
switch(Util::toInt(err.substr(1))) {
case AdcCommand::ERROR_FILE_NOT_AVAILABLE:
fileNotAvailable(aSource);
return;
case AdcCommand::ERROR_SLOTS_FULL:
noSlots(aSource);
return;
}
case AdcCommand::SEV_SUCCESS:
// We don't know any messages that would give us these...
dcdebug("Unknown success message %s %s", err.c_str(), cmd.getParam(1).c_str());
return;
}
aSource->disconnect();
}
/*
* 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);
}
void DownloadManager::on(AdcCommand::SND, UserConnection* aSource, const AdcCommand& cmd) noexcept {
if(aSource->getState() != UserConnection::STATE_SND) {
dcdebug("DM::onFileLength Bad state, ignoring\n");
return;
}
const string& type = cmd.getParam(0);
int64_t start = Util::toInt64(cmd.getParam(2));
int64_t bytes = Util::toInt64(cmd.getParam(3));
if(type != Transfer::names[aSource->getDownload()->getType()]) {
// Uhh??? We didn't ask for this...
aSource->disconnect();
return;
}
startData(aSource, start, bytes, cmd.hasFlag("ZL", 4));
}
void UploadManager::on(AdcCommand::GFI, UserConnection* aSource, const AdcCommand& c) throw() {
if(c.getParameters().size() < 2) {
aSource->send(AdcCommand(AdcCommand::SEV_RECOVERABLE, AdcCommand::ERROR_PROTOCOL_GENERIC, "Missing parameters"));
return;
}
const string& type = c.getParam(0);
const string& ident = c.getParam(1);
if(type == Transfer::TYPE_FILE) {
try {
aSource->send(ShareManager::getInstance()->getFileInfo(ident));
} catch(const ShareException&) {
aSource->fileNotAvail();
}
} else {
aSource->fileNotAvail();
}
}
void SearchManager::respond(const AdcCommand& adc, const CID& from, bool isUdpActive, const string& hubIpPort) {
// Filter own searches
if(from == ClientManager::getInstance()->getMe()->getCID())
return;
UserPtr p = ClientManager::getInstance()->findUser(from);
if(!p)
return;
SearchResultList results;
ShareManager::getInstance()->search(results, adc.getParameters(), isUdpActive ? 10 : 5);
string token;
adc.getParam("TO", 0, token);
// TODO: don't send replies to passive users
if(results.empty()) {
string tth;
if(!adc.getParam("TR", 0, tth))
return;
PartsInfo partialInfo;
if(!QueueManager::getInstance()->handlePartialSearch(TTHValue(tth), partialInfo)) {
// if not found, try to find in finished list
if(!FinishedManager::getInstance()->handlePartialRequest(TTHValue(tth), partialInfo)) {
return;
}
}
AdcCommand cmd = toPSR(true, Util::emptyString, hubIpPort, tth, partialInfo);
ClientManager::getInstance()->send(cmd, from);
return;
}
for(SearchResultList::const_iterator i = results.begin(); i != results.end(); ++i) {
AdcCommand cmd = (*i)->toRES(AdcCommand::TYPE_UDP);
if(!token.empty())
cmd.addParam("TO", token);
ClientManager::getInstance()->send(cmd, from);
}
}
/*
* 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());
}
/*
* Processes incoming request to publish file
*/
void IndexManager::processPublishSourceRequest(const string& ip, uint16_t port, const UDPKey& udpKey, const AdcCommand& cmd)
{
const CID cid = CID(cmd.getParam(0));
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), cid, ip, port, 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, ip, port, cid, udpKey);
}
void UserConnection::handlePM(const AdcCommand& c, bool echo) noexcept {
auto message = c.getParam(0);
auto cm = ClientManager::getInstance();
auto lock = cm->lock();
auto peer = cm->findOnlineUser(user->getCID(), hubUrl);
auto me = cm->findOnlineUser(cm->getMe()->getCID(), hubUrl);
// null pointers allowed here as the conn may be going on without hubs.
if(echo) {
std::swap(peer, me);
}
if(peer && peer->getIdentity().noChat())
return;
if(PluginManager::getInstance()->runHook(HOOK_CHAT_PM_IN, peer, message))
return;
string tmp;
fire(UserConnectionListener::PrivateMessage(), this, ChatMessage(message, peer, me, peer,
c.hasFlag("ME", 1), c.getParam("TS", 1, tmp) ? Util::toInt64(tmp) : 0));
}
void SearchManager::respond(const AdcCommand& cmd, const OnlineUser& user) {
// Filter own searches
if(user.getUser() == ClientManager::getInstance()->getMe())
return;
auto results = ShareManager::getInstance()->search(cmd.getParameters(), user.getIdentity().isUdpActive() ? 10 : 5);
if(results.empty())
return;
string token;
cmd.getParam("TO", 0, token);
for(auto& i: results) {
AdcCommand res = i->toRES(AdcCommand::TYPE_UDP);
if(!token.empty())
res.addParam("TO", token);
ClientManager::getInstance()->sendUDP(res, user);
}
}