diff --git a/ChangeLog b/ChangeLog index c96e7fd0..8baeeb27 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,39 @@ +2008-02-01 Tatsuhiro Tsujikawa + + Added DHT functionality, compatible with mainline. + DHT is disabled by default. To enable it, give --enable-dht to aria2c. + You may need to specify entry point to DHT network using + --dht-entry-point. DHT uses UDP port to listen incoming message. + Use --dht-listen-port to specify port number. Make sure that your + firewall configuration can pass through UDP traffic to the port. + The routing table is saved in $HOME/.aria2/dht.dat. + * src/DHT* + * src/BNode.{h, cc} + * src/PeerInteractionCommand.cc: enable DHT functionality for a + particular torrent. + * src/Data.cc: Rewritten ctor. + * src/OptionHandlerFactory.cc: Added --enable-dht, --dht-listen-port, + --dht-entry-point. + * src/DefaultBtInteractive.cc: Send port message if dht is enabled. + * src/RequestGroup.cc: Initialize DHT functionality. When download + ends, remove BtContext from DHTPeerAnnounceStorage. + * src/BtPortMessage.{h, cc}: Rewritten. + * src/message.h + * src/OptionHandlerImpl.cc + * src/option_processing.cc: Added --enable-dht, --dht-listen-port, + --dht-entry-point. + * src/Dictionary.{h, cc} (remove): New function. + * src/prefs.h + * src/DefaultBtMessageFactory.h + * src/BtHandshakeMessage.cc + * src/ActivePeerConnectionCommand.cc + * src/SocketCore.{h, cc}: Added datagram socket support. + * src/DefaultBtMessageFactory.cc + * src/BtSetup.cc: Add BtContext to DHTPeerAnnounceStorage here. + Create DHT commands. + * src/BtMessageFactory.h + * src/PeerMessageUtil.{h, cc} + 2008-01-21 Tatsuhiro Tsujikawa Fixed the bug that log file is not written when configuration file doesn't exist. diff --git a/src/ActivePeerConnectionCommand.cc b/src/ActivePeerConnectionCommand.cc index ef7e1a32..4a8659a9 100644 --- a/src/ActivePeerConnectionCommand.cc +++ b/src/ActivePeerConnectionCommand.cc @@ -59,10 +59,10 @@ bool ActivePeerConnectionCommand::execute() { } if(!pieceStorage->downloadFinished() && checkPoint.elapsed(interval)) { checkPoint.reset(); - TransferStat tstat = peerStorage->calculateStat(); - if(tstat.getDownloadSpeed() < _lowestSpeedLimit) { - for(int i = 0; i < _numNewConnection && peerStorage->isPeerAvailable(); ++i) { + size_t numAdd = btRuntime->lessThanEqMinPeer() ? MIN_PEERS-btRuntime->getConnections():_numNewConnection; + if(tstat.getDownloadSpeed() < _lowestSpeedLimit || btRuntime->lessThanEqMinPeer()) { + for(; numAdd > 0 && peerStorage->isPeerAvailable(); --numAdd) { PeerHandle peer = peerStorage->getUnusedPeer(); connectToPeer(peer); } diff --git a/src/BNode.cc b/src/BNode.cc new file mode 100644 index 00000000..6e8f7d69 --- /dev/null +++ b/src/BNode.cc @@ -0,0 +1,217 @@ +/* */ +#include "BNode.h" +#include "DHTBucket.h" +#include "DHTNode.h" + +BNode::BNode(const DHTBucketHandle& bucket):_bucket(bucket), + _up(0), + _left(0), _right(0) {} + +BNode::~BNode() +{ + delete _left; + delete _right; +} + +DHTBucketHandle BNode::getBucket() const +{ + return _bucket; +} + +BNode* BNode::getLeft() const +{ + return _left; +} + +BNode* BNode::getRight() const +{ + return _right; +} + +BNode* BNode::getUp() const +{ + return _up; +} + +void BNode::setLeft(BNode* left) +{ + _left = left; + _left->_up = this; +} + +void BNode::setRight(BNode* right) +{ + _right = right; + _right->_up = this; +} + +void BNode::setUp(BNode* up) +{ + _up = up; +} + +void BNode::setBucket(const DHTBucketHandle& bucket) +{ + _bucket = bucket; +} + +bool BNode::isInRange(const unsigned char* key) const +{ + if(_bucket.isNull()) { + return _left->isInRange(key) || _right->isInRange(key); + } else { + return _bucket->isInRange(key); + } +} + +BNode* BNode::findBNodeFor(BNode* b, const unsigned char* key) +{ + if(!b->isInRange(key)) { + return 0; + } + while(1) { + if(!b->getBucket().isNull()) { + return b; + } + // we assume key fits in either left or right bucket range. + if(b->getLeft()->isInRange(key)) { + b = b->getLeft(); + } else { + b = b->getRight(); + } + } + // for properly configured BNode tree, here is unreachable. + return 0; +} + +DHTBucketHandle BNode::findBucketFor(BNode* b, const unsigned char* key) +{ + BNode* bnode = findBNodeFor(b, key); + if(bnode) { + return bnode->getBucket(); + } else { + return 0; + } +} + + +DHTNodes BNode::findClosestKNodes(BNode* b, const unsigned char* key) +{ + BNode* bnode = findBNodeFor(b, key); + DHTNodes nodes; + if(!bnode) { + return nodes; + } + { + DHTBucketHandle bucket = bnode->getBucket(); + DHTNodes goodNodes = bucket->getGoodNodes(); + nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end()); + } + if(nodes.size() >= DHTBucket::K) { + return nodes; + } + BNodes visited; + visited.push_back(bnode); + + BNode* up = bnode->getUp(); + if(!up) { + return nodes; + } + bool leftFirst = false; + if(up->getLeft() == bnode) { + leftFirst = true; + } + bnode = up; + + const_mem_fun_t firstfunc = leftFirst?mem_fun(&BNode::getLeft):mem_fun(&BNode::getRight); + const_mem_fun_t secondfunc = leftFirst?mem_fun(&BNode::getRight):mem_fun(&BNode::getLeft); + while(nodes.size() < DHTBucket::K) { + + if(!bnode->getLeft() && !bnode->getRight()) { + bnode = bnode->getUp(); + } else { + if(find(visited.begin(), visited.end(), firstfunc(bnode)) == visited.end()) { + bnode = firstfunc(bnode); + } else if(find(visited.begin(), visited.end(), secondfunc(bnode)) == visited.end()) { + bnode = secondfunc(bnode); + } else { + bnode = bnode->getUp(); + } + } + visited.push_back(bnode); + if(!bnode) { + break; + } + { + DHTBucketHandle bucket = bnode->getBucket(); + if(!bucket.isNull()) { + DHTNodes goodNodes = bucket->getGoodNodes(); + size_t r = DHTBucket::K-nodes.size(); + if(goodNodes.size() <= r) { + nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end()); + } else { + nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.begin()+r); + } + } + } + } + return nodes; +} + +DHTBuckets BNode::enumerateBucket(const BNode* b) +{ + DHTBuckets buckets; + deque visited; + visited.push_back(b); + while(1) { + if(!b) { + break; + } + if(!b->getBucket().isNull()) { + buckets.push_back(b->getBucket()); + b = b->getUp(); + } else if(find(visited.begin(), visited.end(), b->getLeft()) == visited.end()) { + b = b->getLeft(); + visited.push_back(b); + } else if(find(visited.begin(), visited.end(), b->getRight()) == visited.end()) { + b = b->getRight(); + visited.push_back(b); + } else { + b = b->getUp(); + } + } + return buckets; +} diff --git a/src/BNode.h b/src/BNode.h new file mode 100644 index 00000000..4be3ac8f --- /dev/null +++ b/src/BNode.h @@ -0,0 +1,85 @@ +/* */ +#ifndef _D_BNODE_H_ +#define _D_BNODE_H_ + +#include "common.h" +#include "DHTBucketDecl.h" +#include "BNodeDecl.h" +#include "DHTNodeDecl.h" + +class BNode { +private: + DHTBucketHandle _bucket; + + BNode* _up; + + BNode* _left; + + BNode* _right; + +public: + BNode(const DHTBucketHandle& bucket = 0); + + ~BNode(); + + DHTBucketHandle getBucket() const; + + void setBucket(const DHTBucketHandle& bucket); + + BNode* getLeft() const; + + void setLeft(BNode* left); + + BNode* getRight() const; + + void setRight(BNode* right); + + BNode* getUp() const; + + void setUp(BNode* up); + + bool isInRange(const unsigned char* key) const; + + static BNode* findBNodeFor(BNode* b, const unsigned char* key); + + static DHTBucketHandle findBucketFor(BNode* b, const unsigned char* key); + + static DHTNodes findClosestKNodes(BNode* b, const unsigned char* key); + + static DHTBuckets enumerateBucket(const BNode* b); +}; + +#endif // _D_BNODE_H_ diff --git a/src/BNodeDecl.h b/src/BNodeDecl.h new file mode 100644 index 00000000..56abb655 --- /dev/null +++ b/src/BNodeDecl.h @@ -0,0 +1,44 @@ +/* */ +#ifndef _D_BNODE_DECL_H_ +#define _D_BNODE_DECL_H_ + +#include "SharedHandle.h" +#include + +class BNode; + +typedef std::deque BNodes; +#endif // _D_BNODE_DECL_H_ diff --git a/src/BtContext.h b/src/BtContext.h index 6cec275b..c48dff74 100644 --- a/src/BtContext.h +++ b/src/BtContext.h @@ -36,6 +36,7 @@ #define _D_BT_CONTEXT_H_ #include "DownloadContext.h" +#include "BtContextDecl.h" #define INFO_HASH_LENGTH 20 #define MAX_PEER_ERROR 5 @@ -81,6 +82,4 @@ public: }; -typedef SharedHandle BtContextHandle; - #endif // _D_BT_CONTEXT_H_ diff --git a/src/BtContextDecl.h b/src/BtContextDecl.h new file mode 100644 index 00000000..2cc3b5cf --- /dev/null +++ b/src/BtContextDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_BT_CONTEXT_DECL_H_ +#define _D_BT_CONTEXT_DECL_H_ + +#include "SharedHandle.h" + +class BtContext; +typedef SharedHandle BtContextHandle; + +#endif // _D_BT_CONTEXT_DECL_H_ diff --git a/src/BtHandshakeMessage.cc b/src/BtHandshakeMessage.cc index 33ad8915..c79e2119 100644 --- a/src/BtHandshakeMessage.cc +++ b/src/BtHandshakeMessage.cc @@ -105,3 +105,9 @@ bool BtHandshakeMessage::isExtendedMessagingEnabled() const { return reserved[5]&0x10; } + +bool BtHandshakeMessage::isDHTEnabled() const +{ + return reserved[7]&0x01; +} + diff --git a/src/BtHandshakeMessage.h b/src/BtHandshakeMessage.h index 9ad92f08..bbf9afa3 100644 --- a/src/BtHandshakeMessage.h +++ b/src/BtHandshakeMessage.h @@ -89,6 +89,17 @@ public: bool isExtendedMessagingEnabled() const; + bool isDHTEnabled() const; + + void setDHTEnabled(bool enabled) + { + if(enabled) { + this->reserved[7] |= 0x01; + } else { + this->reserved[7] &= ~0x01; + } + } + int8_t getPstrlen() const { return pstrlen; } diff --git a/src/BtMessageFactory.h b/src/BtMessageFactory.h index 11ea7926..24fac205 100644 --- a/src/BtMessageFactory.h +++ b/src/BtMessageFactory.h @@ -88,6 +88,8 @@ public: virtual BtMessageHandle createAllowedFastMessage(int32_t index) = 0; + virtual BtMessageHandle createPortMessage(uint16_t port) = 0; + virtual BtMessageHandle createBtExtendedMessage(const ExensionMessageHandle& msg) = 0; }; diff --git a/src/BtPortMessage.cc b/src/BtPortMessage.cc index 4358dc5b..d81e7101 100644 --- a/src/BtPortMessage.cc +++ b/src/BtPortMessage.cc @@ -37,8 +37,20 @@ #include "DlAbortEx.h" #include "Util.h" #include "message.h" +#include "DHTNode.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTTask.h" -BtPortMessageHandle BtPortMessage::create(const unsigned char* data, int32_t dataLength) { +BtPortMessage::BtPortMessage(uint16_t port): _port(port), _msg(0) {} + +BtPortMessage::~BtPortMessage() +{ + delete [] _msg; +} + +SharedHandle BtPortMessage::create(const unsigned char* data, int32_t dataLength) +{ if(dataLength != 3) { throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "port", dataLength, 3); } @@ -46,11 +58,55 @@ BtPortMessageHandle BtPortMessage::create(const unsigned char* data, int32_t dat if(id != ID) { throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "piece", ID); } - BtPortMessageHandle message = new BtPortMessage(); - message->setPort(PeerMessageUtil::getShortIntParam(data, 1)); + uint16_t port = PeerMessageUtil::getShortIntParam(data, 1); + SharedHandle message = new BtPortMessage(port); return message; } -string BtPortMessage::toString() const { - return "port port="+Util::itos(port); +void BtPortMessage::doReceivedAction() +{ + if(!_taskFactory.isNull() && !_taskQueue.isNull()) { + // node id is random at this point. When ping reply received, new DHTNode + // instance created with proper node ID and is added to a routing table. + DHTNodeHandle node = new DHTNode(); + node->setIPAddress(peer->ipaddr); + node->setPort(_port); + DHTTaskHandle task = _taskFactory->createPingTask(node); + _taskQueue->addImmediateTask(task); + } else { + logger->info("DHT port message received while localhost didn't declare support it."); + } +} + +const unsigned char* BtPortMessage::getMessage() { + if(!_msg) { + /** + * len --- 5, 4bytes + * id --- 4, 1byte + * port --- port number, 2bytes + * total: 7bytes + */ + _msg = new unsigned char[MESSAGE_LENGTH]; + PeerMessageUtil::createPeerMessageString(_msg, MESSAGE_LENGTH, 3, ID); + PeerMessageUtil::setShortIntParam(&_msg[5], _port); + } + return _msg; +} + +int32_t BtPortMessage::getMessageLength() { + return MESSAGE_LENGTH; +} + +string BtPortMessage::toString() const { + return "port port="+Util::uitos(_port); +} + +void BtPortMessage::setTaskQueue(const WeakHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void BtPortMessage::setTaskFactory(const WeakHandle& taskFactory) +{ + _taskFactory = taskFactory; } diff --git a/src/BtPortMessage.h b/src/BtPortMessage.h index 9b8e8297..d500a446 100644 --- a/src/BtPortMessage.h +++ b/src/BtPortMessage.h @@ -35,36 +35,43 @@ #ifndef _D_BT_PORT_MESSAGE_H_ #define _D_BT_PORT_MESSAGE_H_ -#include "AbstractBtMessage.h" +#include "SimpleBtMessage.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" -class BtPortMessage; - -typedef SharedHandle BtPortMessageHandle; - -class BtPortMessage : public AbstractBtMessage { +class BtPortMessage : public SimpleBtMessage { private: - int16_t port; -public: - BtPortMessage(int16_t port = 0):port(port) {} + uint16_t _port; + unsigned char* _msg; + static const size_t MESSAGE_LENGTH = 7; - virtual ~BtPortMessage() {} + WeakHandle _taskQueue; + + WeakHandle _taskFactory; +public: + BtPortMessage(uint16_t port); + + virtual ~BtPortMessage(); static const int8_t ID = 9; - int16_t getPort() const { return port; } + uint16_t getPort() const { return _port; } - void setPort(int16_t port) { this->port = port; } + static SharedHandle create(const unsigned char* data, int32_t dataLength); virtual int8_t getId() { return ID; } - static BtPortMessageHandle create(const unsigned char* data, int32_t dataLength); + virtual void doReceivedAction(); - virtual void doReceivedAction() { - logger->info("DHT is not supported yet."); - } - virtual void send() {} + virtual const unsigned char* getMessage(); + + virtual int32_t getMessageLength(); virtual string toString() const; + + void setTaskQueue(const WeakHandle& taskQueue); + + void setTaskFactory(const WeakHandle& taskFactory); }; #endif // _D_BT_PORT_MESSAGE_H_ diff --git a/src/BtSetup.cc b/src/BtSetup.cc index 03026c40..666c1027 100644 --- a/src/BtSetup.cc +++ b/src/BtSetup.cc @@ -54,6 +54,10 @@ #include "Logger.h" #include "Util.h" #include "IntSequence.h" +#include "DHTGetPeersCommand.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTSetup.h" +#include "DHTRegistry.h" BtSetup::BtSetup():_logger(LogFactory::getInstance()) {} @@ -80,8 +84,17 @@ Commands BtSetup::setup(RequestGroup* requestGroup, requestGroup, e, btContext, - 30)); - + 10)); + if(!btContext->isPrivate() && DHTSetup::initialized()) { + DHTRegistry::_peerAnnounceStorage->addPeerAnnounce(btContext); + DHTGetPeersCommand* command = new DHTGetPeersCommand(CUIDCounterSingletonHolder::instance()->newID(), + requestGroup, + e, + btContext); + command->setTaskQueue(DHTRegistry::_taskQueue); + command->setTaskFactory(DHTRegistry::_taskFactory); + commands.push_back(command); + } SharedHandle unionCri = new UnionSeedCriteria(); if(option->defined(PREF_SEED_TIME)) { unionCri->addSeedCriteria(new TimeSeedCriteria(option->getAsInt(PREF_SEED_TIME)*60)); diff --git a/src/DHTAbstractMessage.cc b/src/DHTAbstractMessage.cc new file mode 100644 index 00000000..6e3d585c --- /dev/null +++ b/src/DHTAbstractMessage.cc @@ -0,0 +1,90 @@ +/* */ +#include "DHTAbstractMessage.h" +#include "DHTNode.h" +#include "BencodeVisitor.h" +#include "DHTConnection.h" +#include "Data.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageFactory.h" +#include "DHTRoutingTable.h" + +DHTAbstractMessage::DHTAbstractMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + DHTMessage(localNode, remoteNode, transactionID) {} + +DHTAbstractMessage::~DHTAbstractMessage() {} + +string DHTAbstractMessage::getBencodedMessage() +{ + SharedHandle msg = new Dictionary(); + msg->put(string("t"), new Data(_transactionID)); + msg->put(string("y"), new Data(getType())); + fillMessage(msg.get()); + + BencodeVisitor v; + msg->accept(&v); + return v.getBencodedData(); +} + +void DHTAbstractMessage::send() +{ + string message = getBencodedMessage(); + _connection->sendMessage(message.c_str(), + message.size(), + _remoteNode->getIPAddress(), + _remoteNode->getPort()); +} + +void DHTAbstractMessage::setConnection(const WeakHandle& connection) +{ + _connection = connection; +} + +void DHTAbstractMessage::setMessageDispatcher(const WeakHandle& dispatcher) +{ + _dispatcher = dispatcher; +} + +void DHTAbstractMessage::setMessageFactory(const WeakHandle& factory) +{ + _factory = factory; +} + +void DHTAbstractMessage::setRoutingTable(const WeakHandle& routingTable) +{ + _routingTable = routingTable; +} diff --git a/src/DHTAbstractMessage.h b/src/DHTAbstractMessage.h new file mode 100644 index 00000000..42d658b3 --- /dev/null +++ b/src/DHTAbstractMessage.h @@ -0,0 +1,78 @@ +/* */ +#ifndef _D_DHT_ABSTRACT_MESSAGE_H_ +#define _D_DHT_ABSTRACT_MESSAGE_H_ + +#include "DHTMessage.h" +#include "Dictionary.h" +#include "DHTConnectionDecl.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTMessageFactoryDecl.h" +#include "DHTRoutingTableDecl.h" + +class DHTAbstractMessage:public DHTMessage { +protected: + WeakHandle _connection; + + WeakHandle _dispatcher; + + WeakHandle _factory; + + WeakHandle _routingTable; +public: + DHTAbstractMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID = ""); + + virtual ~DHTAbstractMessage(); + + virtual void send(); + + virtual string getType() const = 0; + + virtual void fillMessage(Dictionary* message) = 0; + + string getBencodedMessage(); + + void setConnection(const WeakHandle& connection); + + void setMessageDispatcher(const WeakHandle& dispatcher); + + void setMessageFactory(const WeakHandle& factory); + + void setRoutingTable(const WeakHandle& routingTable); +}; + +#endif // _D_DHT_ABSTRACT_MESSAGE_H_ diff --git a/src/DHTAbstractNodeLookupTask.cc b/src/DHTAbstractNodeLookupTask.cc new file mode 100644 index 00000000..9bc8ddf8 --- /dev/null +++ b/src/DHTAbstractNodeLookupTask.cc @@ -0,0 +1,150 @@ +/* */ +#include "DHTAbstractNodeLookupTask.h" +#include "DHTRoutingTable.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageFactory.h" +#include "DHTMessage.h" +#include "DHTNode.h" +#include "DHTNodeLookupEntry.h" +#include "DHTMessageCallbackImpl.h" +#include "DHTBucket.h" +#include "LogFactory.h" +#include "Util.h" +#include "DHTIDCloser.h" + +DHTAbstractNodeLookupTask::DHTAbstractNodeLookupTask(const unsigned char* targetID): + _inFlightMessage(0) +{ + memcpy(_targetID, targetID, DHT_ID_LENGTH); +} + +void DHTAbstractNodeLookupTask::onReceived(const DHTMessageHandle& message) +{ + --_inFlightMessage; + onReceivedInternal(message); + DHTNodeLookupEntries newEntries = toEntries(getNodesFromMessage(message)); + size_t count = 0; + for(DHTNodeLookupEntries::const_iterator i = newEntries.begin(); + i != newEntries.end(); ++i) { + if(memcmp(_localNode->getID(), (*i)->_node->getID(), DHT_ID_LENGTH) != 0) { + _entries.push_front(*i); + ++count; + } + } + _logger->debug("%u node lookup entries added.", count); + stable_sort(_entries.begin(), _entries.end(), DHTIDCloser(_targetID)); + _entries.erase(unique(_entries.begin(), _entries.end()), _entries.end()); + _logger->debug("%u node lookup entries are unique.", _entries.size()); + if(_entries.size() > DHTBucket::K) { + _entries.erase(_entries.begin()+DHTBucket::K, _entries.end()); + } + if(needsAdditionalOutgoingMessage()) { + sendMessage(); + } + if(_inFlightMessage == 0) { + _logger->debug("Finished node_lookup for node ID %s", + Util::toHex(_targetID, DHT_ID_LENGTH).c_str()); + onFinish(); + updateBucket(); + _finished = true; + } +} + +void DHTAbstractNodeLookupTask::onTimeout(const DHTNodeHandle& node) +{ + _logger->debug("node lookup message timeout for node ID=%s", + Util::toHex(node->getID(), DHT_ID_LENGTH).c_str()); + --_inFlightMessage; + for(DHTNodeLookupEntries::iterator i = _entries.begin(); i != _entries.end(); ++i) { + if((*i)->_node == node) { + _entries.erase(i); + break; + } + } + if(needsAdditionalOutgoingMessage()) { + sendMessage(); + } + if(_inFlightMessage == 0) { + _logger->debug("Finished node_lookup for node ID %s", + Util::toHex(_targetID, DHT_ID_LENGTH).c_str()); + onFinish(); + updateBucket(); + _finished = true; + } +} + +void DHTAbstractNodeLookupTask::sendMessage() +{ + for(DHTNodeLookupEntries::iterator i = _entries.begin(); i != _entries.end() && _inFlightMessage < ALPHA; ++i) { + if((*i)->_used == false) { + ++_inFlightMessage; + (*i)->_used = true; + DHTMessageHandle m = createMessage((*i)->_node); + _dispatcher->addMessageToQueue(m, new DHTMessageCallbackImpl(this)); + } + } +} + +void DHTAbstractNodeLookupTask::updateBucket() +{ + // TODO we have to something here? +} + +void DHTAbstractNodeLookupTask::startup() +{ + _entries = toEntries(_routingTable->getClosestKNodes(_targetID)); + if(_entries.empty()) { + _finished = true; + } else { + // TODO use RTT here + _inFlightMessage = 0; + sendMessage(); + if(_inFlightMessage == 0) { + _logger->debug("No message was sent in this lookup stage. Finished."); + _finished = true; + } + } +} + +DHTNodeLookupEntries DHTAbstractNodeLookupTask::toEntries(const DHTNodes& nodes) const +{ + DHTNodeLookupEntries entries; + for(DHTNodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i) { + DHTNodeLookupEntryHandle e = new DHTNodeLookupEntry(*i); + entries.push_back(e); + } + return entries; +} diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h new file mode 100644 index 00000000..28255a43 --- /dev/null +++ b/src/DHTAbstractNodeLookupTask.h @@ -0,0 +1,82 @@ +/* */ +#ifndef _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_ +#define _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_ + +#include "DHTAbstractTask.h" +#include "DHTNodeDecl.h" +#include "DHTNodeLookupEntryDecl.h" +#include "DHTConstants.h" +#include "DHTTask.h" +#include "DHTMessageDecl.h" +#include "DHTMessageCallbackListener.h" + +class DHTAbstractNodeLookupTask:public DHTAbstractTask, public DHTMessageCallbackListener { +protected: + unsigned char _targetID[DHT_ID_LENGTH]; + + DHTNodeLookupEntries _entries; + + size_t _inFlightMessage; + + DHTNodeLookupEntries toEntries(const DHTNodes& nodes) const; + + void sendMessage(); + + void updateBucket(); + +public: + DHTAbstractNodeLookupTask(const unsigned char* targetID); + + static const size_t ALPHA = 3; + + virtual void startup(); + + virtual void onReceived(const DHTMessageHandle& message); + + virtual void onTimeout(const DHTNodeHandle& node); + + virtual DHTNodes getNodesFromMessage(const DHTMessageHandle& message) = 0; + + virtual void onReceivedInternal(const DHTMessageHandle& message) {} + + virtual bool needsAdditionalOutgoingMessage() { return true; } + + virtual void onFinish() {} + + virtual DHTMessageHandle createMessage(const DHTNodeHandle& remoteNode) = 0; +}; + +#endif // _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_ diff --git a/src/DHTAbstractTask.cc b/src/DHTAbstractTask.cc new file mode 100644 index 00000000..e43e554f --- /dev/null +++ b/src/DHTAbstractTask.cc @@ -0,0 +1,81 @@ +/* */ +#include "DHTAbstractTask.h" +#include "DHTRoutingTable.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageFactory.h" +#include "DHTMessage.h" +#include "DHTNode.h" +#include "DHTMessageCallback.h" +#include "DHTBucket.h" +#include "DHTTaskQueue.h" +#include "LogFactory.h" +#include "Util.h" + +DHTAbstractTask::DHTAbstractTask(): + _finished(false), + _logger(LogFactory::getInstance()), + _localNode(0) +{} + +bool DHTAbstractTask::finished() +{ + return _finished; +} + +void DHTAbstractTask::setRoutingTable(const WeakHandle routingTable) +{ + _routingTable = routingTable; +} + +void DHTAbstractTask::setMessageDispatcher(const WeakHandle dispatcher) +{ + _dispatcher = dispatcher; +} + +void DHTAbstractTask::setMessageFactory(const WeakHandle factory) +{ + _factory = factory; +} + +void DHTAbstractTask::setTaskQueue(const WeakHandle taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTAbstractTask::setLocalNode(const DHTNodeHandle& localNode) +{ + _localNode = localNode; +} diff --git a/src/DHTAbstractTask.h b/src/DHTAbstractTask.h new file mode 100644 index 00000000..0efdcc8e --- /dev/null +++ b/src/DHTAbstractTask.h @@ -0,0 +1,82 @@ +/* */ +#ifndef _D_DHT_ABSTRACT_TASK_H_ +#define _D_DHT_ABSTRACT_TASK_H_ + +#include "common.h" +#include "DHTAbstractTaskDecl.h" +#include "DHTNodeDecl.h" +#include "DHTRoutingTableDecl.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTMessageFactoryDecl.h" +#include "DHTConstants.h" +#include "DHTTask.h" +#include "DHTMessageDecl.h" +#include "DHTTaskQueueDecl.h" + +class Logger; + +class DHTAbstractTask:public DHTTask { +protected: + bool _finished; + + const Logger* _logger; + + DHTNodeHandle _localNode; + + WeakHandle _routingTable; + + WeakHandle _dispatcher; + + WeakHandle _factory; + + WeakHandle _taskQueue; +public: + DHTAbstractTask(); + + virtual bool finished(); + + void setRoutingTable(const WeakHandle routingTable); + + void setMessageDispatcher(const WeakHandle dispatcher); + + void setMessageFactory(const WeakHandle factory); + + void setTaskQueue(const WeakHandle taskQueue); + + void setLocalNode(const DHTNodeHandle& localNode); +}; + +#endif // _D_DHT_ABSTRACT_TASK_H_ diff --git a/src/DHTAbstractTaskDecl.h b/src/DHTAbstractTaskDecl.h new file mode 100644 index 00000000..f68bf702 --- /dev/null +++ b/src/DHTAbstractTaskDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_ABSTRACT_TASK_DECL_H_ +#define _D_DHT_ABSTRACT_TASK_DECL_H_ + +#include "SharedHandle.h" + +class DHTAbstractTask; +typedef SharedHandle DHTAbstractTaskHandle; + +#endif // _D_DHT_ABSTRACT_TASK_DECL_H_ diff --git a/src/DHTAnnouncePeerMessage.cc b/src/DHTAnnouncePeerMessage.cc new file mode 100644 index 00000000..414511e7 --- /dev/null +++ b/src/DHTAnnouncePeerMessage.cc @@ -0,0 +1,113 @@ +/* */ +#include "DHTAnnouncePeerMessage.h" +#include "DHTNode.h" +#include "Data.h" +#include "Dictionary.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallback.h" +#include "Util.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTTokenTracker.h" +#include "DlAbortEx.h" + +DHTAnnouncePeerMessage::DHTAnnouncePeerMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + uint16_t tcpPort, + const string& token, + const string& transactionID): + DHTQueryMessage(localNode, remoteNode, transactionID), + _token(token), + _tcpPort(tcpPort), + _peerAnnounceStorage(0), + _tokenTracker(0) +{ + memcpy(_infoHash, infoHash, DHT_ID_LENGTH); +} + +DHTAnnouncePeerMessage::~DHTAnnouncePeerMessage() {} + +void DHTAnnouncePeerMessage::doReceivedAction() +{ + _peerAnnounceStorage->addPeerAnnounce(_infoHash, _remoteNode->getIPAddress(), + _tcpPort); + + DHTMessageHandle reply = + _factory->createAnnouncePeerReplyMessage(_remoteNode, _transactionID); + _dispatcher->addMessageToQueue(reply); +} + +Dictionary* DHTAnnouncePeerMessage::getArgument() +{ + Dictionary* a = new Dictionary(); + a->put("id", new Data(reinterpret_cast(_localNode->getID()), + DHT_ID_LENGTH)); + a->put("info_hash", new Data(reinterpret_cast(_infoHash), + DHT_ID_LENGTH)); + a->put("port", new Data(Util::uitos(_tcpPort), true)); + a->put("token", new Data(_token)); + + return a; +} + +string DHTAnnouncePeerMessage::getMessageType() const +{ + return "announce_peer"; +} + +void DHTAnnouncePeerMessage::validate() const +{ + if(!_tokenTracker->validateToken(_token, _infoHash, + _remoteNode->getIPAddress(), + _remoteNode->getPort())) { + throw new DlAbortEx("Invalid token=%s from %s:%u", + Util::toHex(_token).c_str(), + _remoteNode->getIPAddress().c_str(), + _remoteNode->getPort()); + } +} + +void DHTAnnouncePeerMessage::setPeerAnnounceStorage(const WeakHandle& storage) +{ + _peerAnnounceStorage = storage; +} + +void DHTAnnouncePeerMessage::setTokenTracker(const WeakHandle& tokenTracker) +{ + _tokenTracker = tokenTracker; +} diff --git a/src/DHTAnnouncePeerMessage.h b/src/DHTAnnouncePeerMessage.h new file mode 100644 index 00000000..452629c4 --- /dev/null +++ b/src/DHTAnnouncePeerMessage.h @@ -0,0 +1,92 @@ +/* */ +#ifndef _D_DHT_ANNOUNCE_PEER_MESSAGE_H_ +#define _D_DHT_ANNOUNCE_PEER_MESSAGE_H_ + +#include "DHTQueryMessage.h" +#include "DHTConstants.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTTokenTrackerDecl.h" + +class DHTAnnouncePeerMessage:public DHTQueryMessage { +private: + string _token; + + unsigned char _infoHash[DHT_ID_LENGTH]; + + uint16_t _tcpPort; + + WeakHandle _peerAnnounceStorage; + + WeakHandle _tokenTracker; +public: + DHTAnnouncePeerMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + uint16_t tcpPort, + const string& token, + const string& transactionID = ""); + + virtual ~DHTAnnouncePeerMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getArgument(); + + virtual string getMessageType() const; + + virtual void validate() const; + + const unsigned char* getInfoHash() const + { + return _infoHash; + } + + const string& getToken() const + { + return _token; + } + + uint16_t getTCPPort() const + { + return _tcpPort; + } + + void setPeerAnnounceStorage(const WeakHandle& storage); + + void setTokenTracker(const WeakHandle& tokenTracker); +}; + +#endif // _D_DHT_ANNOUNCE_PEER_MESSAGE_H_ diff --git a/src/DHTAnnouncePeerReplyMessage.cc b/src/DHTAnnouncePeerReplyMessage.cc new file mode 100644 index 00000000..b3674c08 --- /dev/null +++ b/src/DHTAnnouncePeerReplyMessage.cc @@ -0,0 +1,61 @@ +/* */ +#include "DHTAnnouncePeerReplyMessage.h" +#include "DHTNode.h" +#include "Dictionary.h" +#include "Data.h" + +DHTAnnouncePeerReplyMessage::DHTAnnouncePeerReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + DHTResponseMessage(localNode, remoteNode, transactionID) {} + +DHTAnnouncePeerReplyMessage::~DHTAnnouncePeerReplyMessage() {} + +void DHTAnnouncePeerReplyMessage::doReceivedAction() {} + +Dictionary* DHTAnnouncePeerReplyMessage::getResponse() +{ + Dictionary* r = new Dictionary(); + r->put("id", new Data(_localNode->getID(), DHT_ID_LENGTH)); + return r; +} + +string DHTAnnouncePeerReplyMessage::getMessageType() const +{ + return "announce_peer"; +} + +void DHTAnnouncePeerReplyMessage::validate() const {} diff --git a/src/DHTAnnouncePeerReplyMessage.h b/src/DHTAnnouncePeerReplyMessage.h new file mode 100644 index 00000000..f134fadb --- /dev/null +++ b/src/DHTAnnouncePeerReplyMessage.h @@ -0,0 +1,57 @@ +/* */ +#ifndef _D_DHT_ANNOUNCE_PEER_REPLY_MESSAGE_H_ +#define _D_DHT_ANNOUNCE_PEER_REPLY_MESSAGE_H_ + +#include "DHTResponseMessage.h" + +class DHTAnnouncePeerReplyMessage:public DHTResponseMessage { +public: + DHTAnnouncePeerReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID); + + virtual ~DHTAnnouncePeerReplyMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getResponse(); + + virtual string getMessageType() const; + + virtual void validate() const; +}; + +#endif // _D_DHT_ANNOUNCE_PEER_REPLY_MESSAGE_H_ diff --git a/src/DHTAutoSaveCommand.cc b/src/DHTAutoSaveCommand.cc new file mode 100644 index 00000000..b7809bf9 --- /dev/null +++ b/src/DHTAutoSaveCommand.cc @@ -0,0 +1,109 @@ +/* */ +#include "DHTAutoSaveCommand.h" +#include "DHTRoutingTable.h" +#include "DHTNode.h" +#include "File.h" +#include "DHTRoutingTableSerializer.h" +#include "RecoverableException.h" +#include "DownloadEngine.h" +#include "Util.h" +#include "DHTBucket.h" +#include "RequestGroupMan.h" +#include "prefs.h" +#include "Option.h" +#include + +DHTAutoSaveCommand::DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval): + TimeBasedCommand(cuid, e, interval), + _localNode(0), + _routingTable(0) {} + +DHTAutoSaveCommand::~DHTAutoSaveCommand() {} + +void DHTAutoSaveCommand::preProcess() +{ + if(_e->_requestGroupMan->downloadFinished() || _e->isHaltRequested()) { + save(); + _exit = true; + } +} + +void DHTAutoSaveCommand::process() +{ + save(); +} + +void DHTAutoSaveCommand::save() +{ + DHTNodes nodes; + DHTBuckets buckets = _routingTable->getBuckets(); + for(DHTBuckets::const_iterator i = buckets.begin(); i != buckets.end(); ++i) { + const DHTBucketHandle& bucket = *i; + DHTNodes goodNodes = bucket->getGoodNodes(); + nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end()); + } + + DHTRoutingTableSerializer serializer; + serializer.setLocalNode(_localNode); + serializer.setNodes(nodes); + + string dhtFile = _e->option->get(PREF_DHT_FILE_PATH); + string tempFile = dhtFile+"__temp"; + ofstream o(tempFile.c_str(), ios::out|ios::binary); + o.exceptions(ios::failbit); + try { + serializer.serialize(o); + + if(!File(tempFile).renameTo(dhtFile)) { + logger->error("Cannot move file from %s to %s.", + tempFile.c_str(), dhtFile.c_str()); + } + } catch(RecoverableException* e) { + logger->error("Exception caught while saving DHT routing table to %s", + e, tempFile.c_str()); + delete e; + } +} + +void DHTAutoSaveCommand::setLocalNode(const DHTNodeHandle& localNode) +{ + _localNode = localNode; +} + +void DHTAutoSaveCommand::setRoutingTable(const DHTRoutingTableHandle& routingTable) +{ + _routingTable = routingTable; +} diff --git a/src/DHTAutoSaveCommand.h b/src/DHTAutoSaveCommand.h new file mode 100644 index 00000000..86f586bf --- /dev/null +++ b/src/DHTAutoSaveCommand.h @@ -0,0 +1,64 @@ +/* */ +#ifndef _D_DHT_AUTO_SAVE_COMMAND_H_ +#define _D_DHT_AUTO_SAVE_COMMAND_H_ + +#include "TimeBasedCommand.h" +#include "DHTRoutingTableDecl.h" +#include "DHTNodeDecl.h" + +class DHTAutoSaveCommand : public TimeBasedCommand +{ +private: + DHTNodeHandle _localNode; + + DHTRoutingTableHandle _routingTable; + + void save(); +public: + DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval); + + virtual ~DHTAutoSaveCommand(); + + virtual void preProcess(); + + virtual void process(); + + void setLocalNode(const DHTNodeHandle& localNode); + + void setRoutingTable(const DHTRoutingTableHandle& routingTable); +}; + +#endif // _D_DHT_AUTO_SAVE_COMMAND_H_ diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc new file mode 100644 index 00000000..4088dbc1 --- /dev/null +++ b/src/DHTBucket.cc @@ -0,0 +1,281 @@ +/* */ +#include "DHTBucket.h" +#include "DHTUtil.h" +#include "DHTNode.h" +#include "LogFactory.h" +#include "Util.h" +#include "DHTConstants.h" +#include "a2functional.h" + +DHTBucket::DHTBucket(uint32_t prefixLength, + const unsigned char* max, const unsigned char* min, + const DHTNodeHandle& localNode): + _prefixLength(prefixLength), + _localNode(localNode), + _logger(LogFactory::getInstance()) +{ + memcpy(_max, max, DHT_ID_LENGTH); + memcpy(_min, min, DHT_ID_LENGTH); +} + +DHTBucket::DHTBucket(const DHTNodeHandle& localNode): + _prefixLength(0), + _localNode(localNode), + _logger(LogFactory::getInstance()) +{ + memset(_max, 0xff, DHT_ID_LENGTH); + memset(_min, 0, DHT_ID_LENGTH); +} + +DHTBucket::~DHTBucket() {} + +void DHTBucket::getRandomNodeID(unsigned char* nodeID) const +{ + if(_prefixLength == 0) { + DHTUtil::generateRandomKey(nodeID); + } else { + size_t lastByteIndex = (_prefixLength-1)/8; + DHTUtil::generateRandomKey(nodeID); + memcpy(nodeID, _min, lastByteIndex+1); + } +} + +bool DHTBucket::isInRange(const DHTNodeHandle& node) const +{ + return isInRange(node->getID()); +} + +bool DHTBucket::isInRange(const unsigned char* nodeID) const +{ + for(size_t i = 0; i < DHT_ID_LENGTH; ++i) { + if(nodeID[i] < _min[i]) { + return false; + } else if(_min[i] < nodeID[i]) { + break; + } + } + for(size_t i = 0; i < DHT_ID_LENGTH; ++i) { + if(_max[i] < nodeID[i]) { + return false; + } else if(nodeID[i] < _max[i]) { + break; + } + } + return true; +} + +bool DHTBucket::addNode(const DHTNodeHandle& node) +{ + notifyUpdate(); + DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node); + if(itr == _nodes.end()) { + if(_nodes.size() < K) { + _nodes.push_back(node); + return true; + } else { + if(_nodes.front()->isBad()) { + _nodes.erase(_nodes.begin()); + _nodes.push_back(node); + return true; + } else { + return false; + } + /* + } else if(splitAllowed()) { + return false; + } else { + DHTNodes::iterator ci = find(_cachedNodes.begin(), _cachedNodes.end(), node); + if(ci == _cachedNodes.end()) { + _cachedNodes.push_back(node); + if(_cachedNodes.size() > CACHE_SIZE) { + _cachedNodes.erase(_cachedNodes.begin(), _cachedNodes().begin()+CACHE_SIZE-_cachedNodes.size()); + } + } else { + _cachedNodes.erase(ci); + _cachedNodes.push_back(node); + } + return true; + } + */ + } + } else { + _nodes.erase(itr); + _nodes.push_back(node); + return true; + } +} + +void DHTBucket::dropNode(const DHTNodeHandle& node) +{ + return; + /* + DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node); + if(itr != _nodes.end()) { + _nodes.erase(itr); + if(_cachedNodes.size()) { + _nodes.push_back(_cachedNodes.back()); + _cachedNodes.erase(_cachedNodes.begin()+_cachedNodes.size()-1); + } + } + */ +} + +void DHTBucket::moveToHead(const DHTNodeHandle& node) +{ + DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node); + if(itr != _nodes.end()) { + _nodes.erase(itr); + _nodes.push_front(node); + } +} + +void DHTBucket::moveToTail(const DHTNodeHandle& node) +{ + DHTNodes::iterator itr = find(_nodes.begin(), _nodes.end(), node); + if(itr != _nodes.end()) { + _nodes.erase(itr); + _nodes.push_back(node); + } +} + +bool DHTBucket::splitAllowed() const +{ + return _prefixLength < DHT_ID_LENGTH*8-1 && isInRange(_localNode); +} + +DHTBucketHandle DHTBucket::split() +{ + assert(splitAllowed()); + size_t newPrefixLength = _prefixLength+1; + + unsigned char rMax[DHT_ID_LENGTH]; + memcpy(rMax, _max, DHT_ID_LENGTH); + DHTUtil::flipBit(rMax, DHT_ID_LENGTH, _prefixLength); + + DHTBucketHandle rBucket = new DHTBucket(newPrefixLength, + rMax, _min, _localNode); + DHTNodes tempNodes = _nodes; + for(DHTNodes::iterator i = tempNodes.begin(); i != tempNodes.end();) { + if(rBucket->isInRange(*i)) { + assert(rBucket->addNode(*i)); + i = tempNodes.erase(i); + } else { + ++i; + } + } + DHTUtil::flipBit(_min, DHT_ID_LENGTH, _prefixLength); + _prefixLength = newPrefixLength; + _nodes = tempNodes; + // TODO create toString() and use it. + _logger->debug("New bucket. Range:%s-%s", + Util::toHex(rBucket->getMinID(), DHT_ID_LENGTH).c_str(), + Util::toHex(rBucket->getMaxID(), DHT_ID_LENGTH).c_str()); + _logger->debug("Existing bucket. Range:%s-%s", + Util::toHex(getMinID(), DHT_ID_LENGTH).c_str(), + Util::toHex(getMaxID(), DHT_ID_LENGTH).c_str()); + + return rBucket; +} + +size_t DHTBucket::countNode() const +{ + return _nodes.size(); +} + +const DHTNodes& DHTBucket::getNodes() const +{ + return _nodes; +} + +DHTNodes DHTBucket::getGoodNodes() const +{ + DHTNodes goodNodes = _nodes; + goodNodes.erase(remove_if(goodNodes.begin(), goodNodes.end(), + mem_fun_sh(&DHTNode::isBad)), goodNodes.end()); + return goodNodes; +} + +DHTNodeHandle DHTBucket::getNode(const unsigned char* nodeID, const string& ipaddr, uint16_t port) const +{ + DHTNodeHandle node = new DHTNode(nodeID); + node->setIPAddress(ipaddr); + node->setPort(port); + DHTNodes::const_iterator itr = find(_nodes.begin(), _nodes.end(), node); + if(itr == _nodes.end()) { + return 0; + } else { + return *itr; + } +} + +bool DHTBucket::operator==(const DHTBucket& bucket) const +{ + return memcmp(_max, bucket._max, DHT_ID_LENGTH) == 0 && + memcmp(_min, bucket._min, DHT_ID_LENGTH) == 0; +} + +bool DHTBucket::needsRefresh() const +{ + return _nodes.size() < K || _lastUpdated.elapsed(DHT_BUCKET_REFRESH_INTERVAL); +} + +void DHTBucket::notifyUpdate() +{ + _lastUpdated.reset(); +} + +class FindQuestionableNode { +public: + bool operator()(const DHTNodeHandle& node) const + { + return node->isQuestionable(); + } +}; + +bool DHTBucket::containsQuestionableNode() const +{ + return find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode()) != _nodes.end(); +} + +DHTNodeHandle DHTBucket::getLRUQuestionableNode() const +{ + DHTNodes::const_iterator i = find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode()); + if(i == _nodes.end()) { + return 0; + } else { + return *i; + } +} diff --git a/src/DHTBucket.h b/src/DHTBucket.h new file mode 100644 index 00000000..42ca67b2 --- /dev/null +++ b/src/DHTBucket.h @@ -0,0 +1,132 @@ +/* */ +#ifndef _D_DHT_BUCKET_H_ +#define _D_DHT_BUCKET_H_ + +#include "common.h" +#include "DHTConstants.h" +#include "DHTNodeDecl.h" +#include "DHTBucketDecl.h" +#include "TimeA2.h" + +class Logger; + +class DHTBucket { +private: + size_t _prefixLength; + + // this bucket contains nodes of distance between [_min, _max](inclusive). + unsigned char _min[DHT_ID_LENGTH]; + + unsigned char _max[DHT_ID_LENGTH]; + + DHTNodeHandle _localNode; + + // sorted in ascending order + DHTNodes _nodes; + + DHTNodes _cachedNodes; + + Time _lastUpdated; + + const Logger* _logger; +public: + DHTBucket(const DHTNodeHandle& localNode); + + DHTBucket(size_t prefixLength, + const unsigned char* max, const unsigned char* min, + const DHTNodeHandle& localNode); + + ~DHTBucket(); + + static const size_t K = 8; + + static const size_t CACHE_SIZE = 2; + + void getRandomNodeID(unsigned char* nodeID) const; + + DHTBucketHandle split(); + + bool isInRange(const DHTNodeHandle& node) const; + + bool isInRange(const unsigned char* nodeID) const; + + bool addNode(const DHTNodeHandle& node); + + bool splitAllowed() const; + + size_t getPrefixLength() const + { + return _prefixLength; + } + + const unsigned char* getMaxID() const + { + return _max; + } + + const unsigned char* getMinID() const + { + return _min; + } + + size_t countNode() const; + + const DHTNodes& getNodes() const; + + DHTNodes getGoodNodes() const; + + void dropNode(const DHTNodeHandle& node); + + void moveToHead(const DHTNodeHandle& node); + + void moveToTail(const DHTNodeHandle& node); + + bool contains(const DHTNodeHandle& node) const; + + DHTNodeHandle getNode(const unsigned char* nodeID, const string& ipaddr, uint16_t port) const; + + bool operator==(const DHTBucket& bucket) const; + + bool needsRefresh() const; + + void notifyUpdate(); + + bool containsQuestionableNode() const; + + DHTNodeHandle getLRUQuestionableNode() const; +}; + +#endif // _D_DHT_BUCKET_H_ diff --git a/src/DHTBucketDecl.h b/src/DHTBucketDecl.h new file mode 100644 index 00000000..a3ab9751 --- /dev/null +++ b/src/DHTBucketDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_BUCKET_DECL_H_ +#define _D_DHT_BUCKET_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTBucket; +typedef SharedHandle DHTBucketHandle; +typedef std::deque DHTBuckets; + +#endif // _D_DHT_BUCKET_DECL_H_ diff --git a/src/DHTBucketRefreshCommand.cc b/src/DHTBucketRefreshCommand.cc new file mode 100644 index 00000000..0a31938d --- /dev/null +++ b/src/DHTBucketRefreshCommand.cc @@ -0,0 +1,75 @@ +/* */ +#include "DHTBucketRefreshCommand.h" +#include "DHTRoutingTable.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTTask.h" +#include "DownloadEngine.h" +#include "SingletonHolder.h" +#include "RequestGroupMan.h" + +DHTBucketRefreshCommand::DHTBucketRefreshCommand(int32_t cuid, DownloadEngine* e, time_t interval): + TimeBasedCommand(cuid, e, interval), + _routingTable(0), + _taskQueue(0), + _taskFactory(0) {} + +DHTBucketRefreshCommand::~DHTBucketRefreshCommand() {} + +void DHTBucketRefreshCommand::preProcess() +{ + _exit = _e->_requestGroupMan->downloadFinished() || _e->isHaltRequested(); +} + +void DHTBucketRefreshCommand::process() +{ + _taskQueue->addPeriodicTask1(_taskFactory->createBucketRefreshTask()); +} + +void DHTBucketRefreshCommand::setRoutingTable(const DHTRoutingTableHandle& routingTable) +{ + _routingTable = routingTable; +} + +void DHTBucketRefreshCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTBucketRefreshCommand::setTaskFactory(const DHTTaskFactoryHandle& taskFactory) +{ + _taskFactory = taskFactory; +} diff --git a/src/DHTBucketRefreshCommand.h b/src/DHTBucketRefreshCommand.h new file mode 100644 index 00000000..e000c5e0 --- /dev/null +++ b/src/DHTBucketRefreshCommand.h @@ -0,0 +1,66 @@ +/* */ +#ifndef _D_DHT_BUCKET_REFRESH_COMMAND_H_ +#define _D_DHT_BUCKET_REFRESH_COMMAND_H_ + +#include "TimeBasedCommand.h" +#include "DHTRoutingTableDecl.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" + +class DHTBucketRefreshCommand:public TimeBasedCommand { +private: + DHTRoutingTableHandle _routingTable; + + DHTTaskQueueHandle _taskQueue; + + DHTTaskFactoryHandle _taskFactory; +public: + DHTBucketRefreshCommand(int32_t cuid, DownloadEngine* e, time_t interval); + + virtual ~DHTBucketRefreshCommand(); + + virtual void preProcess(); + + virtual void process(); + + void setRoutingTable(const DHTRoutingTableHandle& routingTable); + + void setTaskQueue(const DHTTaskQueueHandle& taskQueue); + + void setTaskFactory(const DHTTaskFactoryHandle& taskFactory); +}; + +#endif // _D_DHT_BUCKET_REFRESH_COMMAND_H_ diff --git a/src/DHTBucketRefreshTask.cc b/src/DHTBucketRefreshTask.cc new file mode 100644 index 00000000..5d1f6b89 --- /dev/null +++ b/src/DHTBucketRefreshTask.cc @@ -0,0 +1,69 @@ +/* */ +#include "DHTBucketRefreshTask.h" +#include "DHTBucket.h" +#include "DHTRoutingTable.h" +#include "DHTNodeLookupTask.h" +#include "DHTTaskQueue.h" +#include "DHTNode.h" +#include "DHTNodeLookupEntry.h" +#include "Util.h" +#include "Logger.h" + +DHTBucketRefreshTask::DHTBucketRefreshTask() {} + +DHTBucketRefreshTask::~DHTBucketRefreshTask() {} + +void DHTBucketRefreshTask::startup() +{ + DHTBuckets buckets = _routingTable->getBuckets(); + for(DHTBuckets::iterator i = buckets.begin(); i != buckets.end(); ++i) { + if((*i)->needsRefresh()) { + (*i)->notifyUpdate(); + unsigned char targetID[DHT_ID_LENGTH]; + (*i)->getRandomNodeID(targetID); + SharedHandle task = new DHTNodeLookupTask(targetID); + task->setRoutingTable(_routingTable); + task->setMessageDispatcher(_dispatcher); + task->setMessageFactory(_factory); + task->setTaskQueue(_taskQueue); + task->setLocalNode(_localNode); + + _logger->info("Dispating bucket refresh. targetID=%s", Util::toHex(targetID, DHT_ID_LENGTH).c_str()); + _taskQueue->addPeriodicTask1(task); + } + } + _finished = true; +} diff --git a/src/DHTBucketRefreshTask.h b/src/DHTBucketRefreshTask.h new file mode 100644 index 00000000..38212b78 --- /dev/null +++ b/src/DHTBucketRefreshTask.h @@ -0,0 +1,49 @@ +/* */ +#ifndef _D_DHT_BUCKET_REFRESH_TASK_H_ +#define _D_DHT_BUCKET_REFRESH_TASK_H_ + +#include "DHTAbstractTask.h" + +class DHTBucketRefreshTask:public DHTAbstractTask { +public: + DHTBucketRefreshTask(); + + virtual ~DHTBucketRefreshTask(); + + virtual void startup(); +}; + +#endif // _D_DHT_BUCKET_REFRESH_TASK_H_ diff --git a/src/DHTConnection.h b/src/DHTConnection.h new file mode 100644 index 00000000..5bedca3c --- /dev/null +++ b/src/DHTConnection.h @@ -0,0 +1,49 @@ +/* */ +#ifndef _D_DHT_CONNECTION_H_ +#define _D_DHT_CONNECTION_H_ + +#include "common.h" + +class DHTConnection { +public: + virtual ~DHTConnection() {} + + virtual ssize_t receiveMessage(char* data, size_t len, string& host, uint16_t& port) = 0; + + virtual void sendMessage(const char* data, size_t len, const string& host, uint16_t port) = 0; +}; + +#endif // _D_DHT_CONNECTION_H_ diff --git a/src/DHTConnectionDecl.h b/src/DHTConnectionDecl.h new file mode 100644 index 00000000..8744ccf9 --- /dev/null +++ b/src/DHTConnectionDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_CONNECTION_DECL_H_ +#define _D_DHT_CONNECTION_DECL_H_ + +#include "SharedHandle.h" + +class DHTConnection; +typedef SharedHandle DHTConnectionHandle; + +#endif // _D_DHT_CONNECTION_DECL_H_ diff --git a/src/DHTConnectionImpl.cc b/src/DHTConnectionImpl.cc new file mode 100644 index 00000000..605b2d54 --- /dev/null +++ b/src/DHTConnectionImpl.cc @@ -0,0 +1,91 @@ +/* */ +#include "DHTConnectionImpl.h" +#include "LogFactory.h" +#include "RecoverableException.h" +#include "Util.h" +DHTConnectionImpl::DHTConnectionImpl():_socket(new SocketCore(SOCK_DGRAM)), + _logger(LogFactory::getInstance()) {} + +DHTConnectionImpl::~DHTConnectionImpl() {} + +uint16_t DHTConnectionImpl::bind(IntSequence& ports) +{ + while(ports.hasNext()) { + uint16_t port = bind(ports.next()); + if(port > 0) { + return port; + } + } + return 0; +} + +uint16_t DHTConnectionImpl::bind(uint16_t port) +{ + try { + _socket->bind(port); + pair svaddr; + _socket->getAddrInfo(svaddr); + _logger->info("Bind socket for DHT. port=%u", port); + return svaddr.second; + } catch(RecoverableException* e) { + _logger->error("Failed to bind for DHT. port=%u", e, port); + delete e; + } + return 0; +} + +ssize_t DHTConnectionImpl::receiveMessage(char* data, size_t len, string& host, uint16_t& port) +{ + if(_socket->isReadable(0)) { + pair remoteHost; + ssize_t length = _socket->readDataFrom(data, len, remoteHost); + host = remoteHost.first; + port = remoteHost.second; + return length; + } else { + return -1; + } +} + +void DHTConnectionImpl::sendMessage(const char* data, size_t len, const string& host, uint16_t port) +{ + _socket->writeData(data, len, host, port); +} + +SocketHandle DHTConnectionImpl::getSocket() const +{ + return _socket; +} diff --git a/src/DHTConnectionImpl.h b/src/DHTConnectionImpl.h new file mode 100644 index 00000000..011b232f --- /dev/null +++ b/src/DHTConnectionImpl.h @@ -0,0 +1,65 @@ +/* */ +#ifndef _D_DHT_CONNECTION_IMPL_H_ +#define _D_DHT_CONNECTION_IMPL_H_ + +#include "DHTConnection.h" +#include "Socket.h" +#include "IntSequence.h" + +class Logger; + +class DHTConnectionImpl:public DHTConnection { +private: + SocketHandle _socket; + + const Logger* _logger; +public: + DHTConnectionImpl(); + + virtual ~DHTConnectionImpl(); + + uint16_t bind(IntSequence& ports); + + uint16_t bind(uint16_t port); + + virtual ssize_t receiveMessage(char* data, size_t len, string& host, uint16_t& port); + + virtual void sendMessage(const char* data, size_t len, const string& host, uint16_t port); + + SocketHandle getSocket() const; +}; + +#endif // _D_DHT_CONNECTION_IMPL_H_ diff --git a/src/DHTConstants.h b/src/DHTConstants.h new file mode 100644 index 00000000..16f1aea4 --- /dev/null +++ b/src/DHTConstants.h @@ -0,0 +1,60 @@ +/* */ +#ifndef _D_DHT_CONSTANTS_H_ +#define _D_DHT_CONSTANTS_H_ + +#define DHT_ID_LENGTH 20 + +#define DHT_TRANSACTION_ID_LENGTH 2 + +#define DHT_TOKEN_LENGTH 4 + +#define DHT_MESSAGE_TIMEOUT 15 + +#define DHT_NODE_CONTACT_INTERVAL (15*60) + +#define DHT_BUCKET_REFRESH_INTERVAL (15*60) + +#define DHT_BUCKET_REFRESH_CHECK_INTERVAL (5*60) + +#define DHT_PEER_ANNOUNCE_PURGE_INTERVAL (30*60) + +#define DHT_PEER_ANNOUNCE_INTERVAL (15*60) + +#define DHT_PEER_ANNOUNCE_CHECK_INTERVAL (5*60) + +#define DHT_TOKEN_UPDATE_INTERVAL (10*60) + +#endif // _D_DHT_CONSTANTS_H_ diff --git a/src/DHTEntryPointNameResolveCommand.cc b/src/DHTEntryPointNameResolveCommand.cc new file mode 100644 index 00000000..b0721517 --- /dev/null +++ b/src/DHTEntryPointNameResolveCommand.cc @@ -0,0 +1,161 @@ +/* */ +#include "DHTEntryPointNameResolveCommand.h" +#include "DownloadEngine.h" +#include "NameResolver.h" +#include "DNSCache.h" +#include "DlAbortEx.h" +#include "prefs.h" +#include "message.h" +#include "Util.h" +#include "Option.h" +#include "DHTNode.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTTask.h" +#include "RequestGroupMan.h" + +DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e): + Command(cuid), + _e(e), + _resolver(new NameResolver()), + _taskQueue(0), + _taskFactory(0), + _localNode(0) +{} + +DHTEntryPointNameResolveCommand::~DHTEntryPointNameResolveCommand() +{ +#ifdef ENABLE_ASYNC_DNS + disableNameResolverCheck(_resolver); +#endif // ENABLE_ASYNC_DNS +} + +bool DHTEntryPointNameResolveCommand::execute() +{ + if(_e->_requestGroupMan->downloadFinished() || _e->isHaltRequested()) { + return true; + } + + try { + string hostname = _e->option->get(PREF_DHT_ENTRY_POINT_HOST); + if(!Util::isNumbersAndDotsNotation(hostname)) { + if(resolveHostname(hostname, _resolver)) { + hostname = _resolver->getAddrString(); + } else { + _e->commands.push_back(this); + return false; + } + } + + DHTNodeHandle entryNode = new DHTNode(); + entryNode->setIPAddress(hostname); + entryNode->setPort(_e->option->getAsInt(PREF_DHT_ENTRY_POINT_PORT)); + + _taskQueue->addPeriodicTask1(_taskFactory->createPingTask(entryNode, 10)); + _taskQueue->addPeriodicTask1(_taskFactory->createNodeLookupTask(_localNode->getID())); + _taskQueue->addPeriodicTask1(_taskFactory->createBucketRefreshTask()); + } catch(RecoverableException* e) { + logger->error(EX_EXCEPTION_CAUGHT, e); + delete e; + } + return true; +} + +bool DHTEntryPointNameResolveCommand::resolveHostname(const string& hostname, + const NameResolverHandle& resolver) +{ + string ipaddr = DNSCacheSingletonHolder::instance()->find(hostname); + if(ipaddr.empty()) { +#ifdef ENABLE_ASYNC_DNS + switch(resolver->getStatus()) { + case NameResolver::STATUS_READY: + logger->info(MSG_RESOLVING_HOSTNAME, cuid, hostname.c_str()); + resolver->resolve(hostname); + setNameResolverCheck(resolver); + return false; + case NameResolver::STATUS_SUCCESS: + logger->info(MSG_NAME_RESOLUTION_COMPLETE, cuid, + hostname.c_str(), resolver->getAddrString().c_str()); + DNSCacheSingletonHolder::instance()->put(hostname, resolver->getAddrString()); + return true; + break; + case NameResolver::STATUS_ERROR: + throw new DlAbortEx(MSG_NAME_RESOLUTION_FAILED, cuid, + hostname.c_str(), + resolver->getError().c_str()); + default: + return false; + } +#else + logger->info(MSG_RESOLVING_HOSTNAME, cuid, hostname.c_str()); + resolver->resolve(hostname); + logger->info(MSG_NAME_RESOLUTION_COMPLETE, cuid, + hostname.c_str(), resolver->getAddrString().c_str()); + DNSCacheSingletonHolder::instance()->put(hostname, resolver->getAddrString()); + return true; +#endif // ENABLE_ASYNC_DNS + } else { + logger->info(MSG_DNS_CACHE_HIT, cuid, + hostname.c_str(), ipaddr.c_str()); + resolver->setAddr(ipaddr); + return true; + } +} + +#ifdef ENABLE_ASYNC_DNS +void DHTEntryPointNameResolveCommand::setNameResolverCheck(const NameResolverHandle& resolver) { + _e->addNameResolverCheck(resolver, this); +} + +void DHTEntryPointNameResolveCommand::disableNameResolverCheck(const NameResolverHandle& resolver) { + _e->deleteNameResolverCheck(resolver, this); +} +#endif // ENABLE_ASYNC_DNS + +void DHTEntryPointNameResolveCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTEntryPointNameResolveCommand::setTaskFactory(const DHTTaskFactoryHandle& taskFactory) +{ + _taskFactory = taskFactory; +} + +void DHTEntryPointNameResolveCommand::setLocalNode(const DHTNodeHandle& localNode) +{ + _localNode = localNode; +} diff --git a/src/DHTEntryPointNameResolveCommand.h b/src/DHTEntryPointNameResolveCommand.h new file mode 100644 index 00000000..2bf3a9db --- /dev/null +++ b/src/DHTEntryPointNameResolveCommand.h @@ -0,0 +1,80 @@ +/* */ +#ifndef _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_ +#define _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_ + +#include "Command.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" +#include "DHTNodeDecl.h" + +class DownloadEngine; +class NameResolver; +typedef SharedHandle NameResolverHandle; + +class DHTEntryPointNameResolveCommand:public Command { +protected: + DownloadEngine* _e; +private: + NameResolverHandle _resolver; + + DHTTaskQueueHandle _taskQueue; + + DHTTaskFactoryHandle _taskFactory; + + DHTNodeHandle _localNode; + + bool resolveHostname(const string& hostname, + const NameResolverHandle& resolver); + + void setNameResolverCheck(const NameResolverHandle& resolver); + + void disableNameResolverCheck(const NameResolverHandle& resolver); + +public: + DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e); + + virtual ~DHTEntryPointNameResolveCommand(); + + virtual bool execute(); + + void setTaskQueue(const DHTTaskQueueHandle& taskQueue); + + void setTaskFactory(const DHTTaskFactoryHandle& taskFactory); + + void setLocalNode(const DHTNodeHandle& localNode); +}; + +#endif // _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_ diff --git a/src/DHTFindNodeMessage.cc b/src/DHTFindNodeMessage.cc new file mode 100644 index 00000000..72aaa398 --- /dev/null +++ b/src/DHTFindNodeMessage.cc @@ -0,0 +1,78 @@ +/* */ +#include "DHTFindNodeMessage.h" +#include "DHTNode.h" +#include "Data.h" +#include "Dictionary.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallback.h" + +DHTFindNodeMessage::DHTFindNodeMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* targetNodeID, + const string& transactionID): + DHTQueryMessage(localNode, remoteNode, transactionID) +{ + memcpy(_targetNodeID, targetNodeID, DHT_ID_LENGTH); +} + +DHTFindNodeMessage::~DHTFindNodeMessage() {} + +void DHTFindNodeMessage::doReceivedAction() +{ + DHTNodes nodes = _routingTable->getClosestKNodes(_targetNodeID); + DHTMessageHandle reply = + _factory->createFindNodeReplyMessage(_remoteNode, nodes, _transactionID); + _dispatcher->addMessageToQueue(reply); +} + +Dictionary* DHTFindNodeMessage::getArgument() +{ + Dictionary* a = new Dictionary(); + a->put("id", new Data(reinterpret_cast(_localNode->getID()), + DHT_ID_LENGTH)); + a->put("target", new Data(reinterpret_cast(_targetNodeID), + DHT_ID_LENGTH)); + return a; +} + +string DHTFindNodeMessage::getMessageType() const +{ + return "find_node"; +} + +void DHTFindNodeMessage::validate() const {} diff --git a/src/DHTFindNodeMessage.h b/src/DHTFindNodeMessage.h new file mode 100644 index 00000000..88bdbece --- /dev/null +++ b/src/DHTFindNodeMessage.h @@ -0,0 +1,66 @@ +/* */ +#ifndef _D_DHT_FIND_NODE_MESSAGE_H_ +#define _D_DHT_FIND_NODE_MESSAGE_H_ + +#include "DHTQueryMessage.h" +#include "DHTConstants.h" + +class DHTFindNodeMessage:public DHTQueryMessage { +private: + unsigned char _targetNodeID[DHT_ID_LENGTH]; +public: + DHTFindNodeMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* targetNodeID, + const string& transactionID = ""); + + virtual ~DHTFindNodeMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getArgument(); + + virtual string getMessageType() const; + + virtual void validate() const; + + const unsigned char* getTargetNodeID() const + { + return _targetNodeID; + } +}; + +#endif // _D_DHT_FIND_NODE_MESSAGE_H_ diff --git a/src/DHTFindNodeReplyMessage.cc b/src/DHTFindNodeReplyMessage.cc new file mode 100644 index 00000000..b5cfdcad --- /dev/null +++ b/src/DHTFindNodeReplyMessage.cc @@ -0,0 +1,95 @@ +/* */ +#include "DHTFindNodeReplyMessage.h" +#include "DHTNode.h" +#include "DHTBucket.h" +#include "Data.h" +#include "Dictionary.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallback.h" +#include "PeerMessageUtil.h" + +DHTFindNodeReplyMessage::DHTFindNodeReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + DHTResponseMessage(localNode, remoteNode, transactionID) {} + +DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {} + +void DHTFindNodeReplyMessage::doReceivedAction() +{ + for(DHTNodes::iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) { + if(memcmp((*i)->getID(), _localNode->getID(), DHT_ID_LENGTH) != 0) { + _routingTable->addNode(*i); + } + } +} + +Dictionary* DHTFindNodeReplyMessage::getResponse() +{ + Dictionary* a = new Dictionary(); + a->put("id", new Data(reinterpret_cast(_localNode->getID()), + DHT_ID_LENGTH)); + size_t offset = 0; + char buffer[DHTBucket::K*26]; + for(DHTNodes::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) { + DHTNodeHandle node = *i; + memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH); + if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(), node->getPort())) { + offset += 26; + } + } + a->put("nodes", new Data(buffer, offset)); + return a; +} + +string DHTFindNodeReplyMessage::getMessageType() const +{ + return "find_node"; +} + +void DHTFindNodeReplyMessage::validate() const {} + +const DHTNodes& DHTFindNodeReplyMessage::getClosestKNodes() const +{ + return _closestKNodes; +} + +void DHTFindNodeReplyMessage::setClosestKNodes(const DHTNodes& closestKNodes) +{ + _closestKNodes = closestKNodes; +} diff --git a/src/DHTFindNodeReplyMessage.h b/src/DHTFindNodeReplyMessage.h new file mode 100644 index 00000000..80ab387c --- /dev/null +++ b/src/DHTFindNodeReplyMessage.h @@ -0,0 +1,63 @@ +/* */ +#ifndef _D_DHT_FIND_NODE_REPLY_MESSAGE_H_ +#define _D_DHT_FIND_NODE_REPLY_MESSAGE_H_ + +#include "DHTResponseMessage.h" + +class DHTFindNodeReplyMessage:public DHTResponseMessage { +private: + DHTNodes _closestKNodes; +public: + DHTFindNodeReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID); + + virtual ~DHTFindNodeReplyMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getResponse(); + + virtual string getMessageType() const; + + virtual void validate() const; + + const DHTNodes& getClosestKNodes() const; + + void setClosestKNodes(const DHTNodes& closestKNodes); +}; + +#endif // _D_DHT_FIND_NODE_REPLY_MESSAGE_H_ diff --git a/src/DHTGetPeersCommand.cc b/src/DHTGetPeersCommand.cc new file mode 100644 index 00000000..7788577e --- /dev/null +++ b/src/DHTGetPeersCommand.cc @@ -0,0 +1,96 @@ +/* */ +#include "DHTGetPeersCommand.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTTask.h" +#include "DownloadEngine.h" +#include "RequestGroup.h" +#include "DHTPeerLookupTask.h" +#include "DHTNode.h" +#include "DHTNodeLookupEntry.h" + +DHTGetPeersCommand::DHTGetPeersCommand(int32_t cuid, + RequestGroup* requestGroup, + DownloadEngine* e, + const BtContextHandle& ctx): + Command(cuid), + BtContextAwareCommand(ctx), + RequestGroupAware(requestGroup), + _e(e), + _taskQueue(0), + _taskFactory(0), + _task(0), + _numRetry(0), + _lastGetPeerTime(0) +{} + +DHTGetPeersCommand::~DHTGetPeersCommand() {} + +bool DHTGetPeersCommand::execute() +{ + if(btRuntime->isHalt()) { + return true; + } + if(_task.isNull() && + (_numRetry > 0 && _lastGetPeerTime.elapsed(RETRY_INTERVAL) || + _lastGetPeerTime.elapsed(GET_PEER_INTERVAL))) { + logger->debug("Issuing PeerLookup for infoHash=%s", + btContext->getInfoHashAsString().c_str()); + _task = _taskFactory->createPeerLookupTask(btContext); + _taskQueue->addPeriodicTask2(_task); + } else if(!_task.isNull() && _task->finished()) { + _lastGetPeerTime.reset(); + if(_numRetry < MAX_RETRIES && btRuntime->lessThanEqMinPeer()) { + ++_numRetry; + } else { + _numRetry = 0; + } + _task = 0; + } + + _e->commands.push_back(this); + return false; +} + +void DHTGetPeersCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTGetPeersCommand::setTaskFactory(const DHTTaskFactoryHandle& taskFactory) +{ + _taskFactory = taskFactory; +} diff --git a/src/DHTGetPeersCommand.h b/src/DHTGetPeersCommand.h new file mode 100644 index 00000000..9661bc95 --- /dev/null +++ b/src/DHTGetPeersCommand.h @@ -0,0 +1,85 @@ +/* */ +#ifndef _D_DHT_GET_PEERS_COMMAND_H_ +#define _D_DHT_GET_PEERS_COMMAND_H_ + +#include "Command.h" +#include "BtContextAwareCommand.h" +#include "RequestGroupAware.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" +#include "TimeA2.h" + +class DHTPeerLookupTask; +class DownloadEngine; +class RequestGroup; +typedef SharedHandle RequestGroupHandle; + +class DHTGetPeersCommand:public Command, + public BtContextAwareCommand, + public RequestGroupAware +{ +private: + static const time_t GET_PEER_INTERVAL = (15*60); + + static const time_t RETRY_INTERVAL = 60; + + static const size_t MAX_RETRIES = 10; + + DownloadEngine* _e; + + DHTTaskQueueHandle _taskQueue; + + DHTTaskFactoryHandle _taskFactory; + + SharedHandle _task; + + size_t _numRetry; + + Time _lastGetPeerTime; +public: + DHTGetPeersCommand(int32_t cuid, RequestGroup* requestGroup, + DownloadEngine* e, const BtContextHandle& ctx); + + virtual ~DHTGetPeersCommand(); + + virtual bool execute(); + + void setTaskQueue(const DHTTaskQueueHandle& taskQueue); + + void setTaskFactory(const DHTTaskFactoryHandle& taskFactory); +}; + +#endif // _D_DHT_GET_PEERS_COMMAND_H_ diff --git a/src/DHTGetPeersMessage.cc b/src/DHTGetPeersMessage.cc new file mode 100644 index 00000000..cb0a5ee4 --- /dev/null +++ b/src/DHTGetPeersMessage.cc @@ -0,0 +1,103 @@ +/* */ +#include "DHTGetPeersMessage.h" +#include "DHTNode.h" +#include "Data.h" +#include "Dictionary.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallback.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTUtil.h" +#include "Peer.h" +#include "DHTTokenTracker.h" + +DHTGetPeersMessage::DHTGetPeersMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + const string& transactionID): + DHTQueryMessage(localNode, remoteNode, transactionID) +{ + memcpy(_infoHash, infoHash, DHT_ID_LENGTH); +} + +DHTGetPeersMessage::~DHTGetPeersMessage() {} + +void DHTGetPeersMessage::doReceivedAction() +{ + string token = _tokenTracker->generateToken(_infoHash, + _remoteNode->getIPAddress(), + _remoteNode->getPort()); + // Check to see localhost has the contents which has same infohash + Peers peers = _peerAnnounceStorage->getPeers(_infoHash); + DHTMessageHandle reply = 0; + if(peers.empty()) { + DHTNodes nodes = _routingTable->getClosestKNodes(_infoHash); + reply = + _factory->createGetPeersReplyMessage(_remoteNode, nodes, token, + _transactionID); + } else { + reply = + _factory->createGetPeersReplyMessage(_remoteNode, peers, token, + _transactionID); + } + _dispatcher->addMessageToQueue(reply); +} + +Dictionary* DHTGetPeersMessage::getArgument() +{ + Dictionary* a = new Dictionary(); + a->put("id", new Data(_localNode->getID(), DHT_ID_LENGTH)); + a->put("info_hash", new Data(_infoHash, DHT_ID_LENGTH)); + return a; +} + +string DHTGetPeersMessage::getMessageType() const +{ + return "get_peers"; +} + +void DHTGetPeersMessage::validate() const {} + +void DHTGetPeersMessage::setPeerAnnounceStorage(const WeakHandle& storage) +{ + _peerAnnounceStorage = storage; +} + +void DHTGetPeersMessage::setTokenTracker(const WeakHandle& tokenTracker) +{ + _tokenTracker = tokenTracker; +} diff --git a/src/DHTGetPeersMessage.h b/src/DHTGetPeersMessage.h new file mode 100644 index 00000000..926a0430 --- /dev/null +++ b/src/DHTGetPeersMessage.h @@ -0,0 +1,77 @@ +/* */ +#ifndef _D_DHT_GET_PEERS_MESSAGE_H_ +#define _D_DHT_GET_PEERS_MESSAGE_H_ + +#include "DHTQueryMessage.h" +#include "DHTConstants.h" +#include "DHTPeerAnnounceStorageDecl.h" +#include "DHTTokenTrackerDecl.h" + +class DHTGetPeersMessage:public DHTQueryMessage { +private: + unsigned char _infoHash[DHT_ID_LENGTH]; + + WeakHandle _peerAnnounceStorage; + + WeakHandle _tokenTracker; +public: + DHTGetPeersMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + const string& transactionID = ""); + + virtual ~DHTGetPeersMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getArgument(); + + virtual string getMessageType() const; + + virtual void validate() const; + + const unsigned char* getInfoHash() const + { + return _infoHash; + } + + void setPeerAnnounceStorage(const WeakHandle& storage); + + + void setTokenTracker(const WeakHandle& tokenTracker); +}; + +#endif // _D_DHT_GET_PEERS_MESSAGE_H_ diff --git a/src/DHTGetPeersReplyMessage.cc b/src/DHTGetPeersReplyMessage.cc new file mode 100644 index 00000000..7bdf421e --- /dev/null +++ b/src/DHTGetPeersReplyMessage.cc @@ -0,0 +1,119 @@ +/* */ +#include "DHTGetPeersReplyMessage.h" +#include "DHTNode.h" +#include "DHTBucket.h" +#include "Data.h" +#include "Dictionary.h" +#include "List.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallback.h" +#include "PeerMessageUtil.h" +#include "Peer.h" +#include "DHTUtil.h" + +DHTGetPeersReplyMessage::DHTGetPeersReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& token, + const string& transactionID): + DHTResponseMessage(localNode, remoteNode, transactionID), + _token(token) {} + +DHTGetPeersReplyMessage::~DHTGetPeersReplyMessage() {} + +void DHTGetPeersReplyMessage::doReceivedAction() +{ + // Returned peers and nodes are handled in DHTPeerLookupTask. +} + +Dictionary* DHTGetPeersReplyMessage::getResponse() +{ + Dictionary* r = new Dictionary(); + r->put("id", new Data(reinterpret_cast(_localNode->getID()), + DHT_ID_LENGTH)); + r->put("token", new Data(_token)); + if(_values.size()) { + List* valuesList = new List(); + r->put("values", valuesList); + for(Peers::const_iterator i = _values.begin(); i != _values.end(); ++i) { + PeerHandle peer = *i; + char buffer[6]; + if(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)) { + valuesList->add(new Data(buffer, sizeof(buffer))); + } + } + } else { + size_t offset = 0; + char buffer[DHTBucket::K*26]; + for(DHTNodes::const_iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) { + DHTNodeHandle node = *i; + memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH); + if(PeerMessageUtil::createcompact(buffer+20+offset, node->getIPAddress(), node->getPort())) { + offset += 26; + } + } + r->put("nodes", new Data(buffer, offset)); + } + return r; +} + +string DHTGetPeersReplyMessage::getMessageType() const +{ + return "get_peers"; +} + +void DHTGetPeersReplyMessage::validate() const {} + +const DHTNodes& DHTGetPeersReplyMessage::getClosestKNodes() const +{ + return _closestKNodes; +} + +void DHTGetPeersReplyMessage::setClosestKNodes(const DHTNodes& closestKNodes) +{ + _closestKNodes = closestKNodes; +} + +const Peers& DHTGetPeersReplyMessage::getValues() const +{ + return _values; +} + +void DHTGetPeersReplyMessage::setValues(const Peers& peers) +{ + _values = peers; +} diff --git a/src/DHTGetPeersReplyMessage.h b/src/DHTGetPeersReplyMessage.h new file mode 100644 index 00000000..0d9a88ac --- /dev/null +++ b/src/DHTGetPeersReplyMessage.h @@ -0,0 +1,79 @@ +/* */ +#ifndef _D_DHT_GET_PEERS_REPLY_MESSAGE_H_ +#define _D_DHT_GET_PEERS_REPLY_MESSAGE_H_ + +#include "DHTResponseMessage.h" +#include "DHTConstants.h" +#include "PeerDecl.h" + +class DHTGetPeersReplyMessage:public DHTResponseMessage { +private: + string _token; + + DHTNodes _closestKNodes; + + Peers _values; +public: + DHTGetPeersReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& token, + const string& transactionID); + + virtual ~DHTGetPeersReplyMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getResponse(); + + virtual string getMessageType() const; + + virtual void validate() const; + + const DHTNodes& getClosestKNodes() const; + + const Peers& getValues() const; + + void setClosestKNodes(const DHTNodes& closestKNodes); + + void setValues(const Peers& peers); + + const string& getToken() const + { + return _token; + } +}; + +#endif // _D_DHT_GET_PEERS_REPLY_MESSAGE_H_ diff --git a/src/DHTIDCloser.h b/src/DHTIDCloser.h new file mode 100644 index 00000000..978f4e01 --- /dev/null +++ b/src/DHTIDCloser.h @@ -0,0 +1,57 @@ +/* */ +#ifndef _D_DHT_ID_CLOSER_H_ +#define _D_DHT_ID_CLOSER_H_ + +#include "DHTNodeLookupEntryDecl.h" +#include "DHTConstants.h" +#include "XORCloser.h" + +class DHTIDCloser { +private: + const unsigned char* _targetID; + + XORCloser _closer; +public: + DHTIDCloser(const unsigned char* targetID):_closer(targetID, DHT_ID_LENGTH) {} + + bool operator()(const DHTNodeLookupEntryHandle& m1, + const DHTNodeLookupEntryHandle& m2) const + { + return _closer(m1->_node->getID(), m2->_node->getID()); + } +}; + +#endif // _D_DHT_ID_CLOSER_H_ diff --git a/src/DHTInteractionCommand.cc b/src/DHTInteractionCommand.cc new file mode 100644 index 00000000..0b4b0323 --- /dev/null +++ b/src/DHTInteractionCommand.cc @@ -0,0 +1,111 @@ +/* */ +#include "DHTInteractionCommand.h" +#include "DownloadEngine.h" +#include "RecoverableException.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageReceiver.h" +#include "DHTTaskQueue.h" +#include "DHTMessage.h" +#include "Socket.h" +#include "message.h" +#include "RequestGroupMan.h" + +DHTInteractionCommand::DHTInteractionCommand(int32_t cuid, DownloadEngine* e): + Command(cuid), + _e(e), + _dispatcher(0), + _receiver(0), + _taskQueue(0), + _readCheckSocket(0) +{} + +DHTInteractionCommand::~DHTInteractionCommand() +{ + disableReadCheckSocket(_readCheckSocket); +} + +void DHTInteractionCommand::setReadCheckSocket(const SocketHandle& socket) +{ + _readCheckSocket = socket; + _e->addSocketForReadCheck(socket, this); +} + +void DHTInteractionCommand::disableReadCheckSocket(const SocketHandle& socket) +{ + _e->deleteSocketForReadCheck(socket, this); +} + +bool DHTInteractionCommand::execute() +{ + if(_e->_requestGroupMan->downloadFinished() || _e->isHaltRequested()) { + return true; + } + + _taskQueue->executeTask(); + + for(size_t i = 0; i < 20 && _readCheckSocket->isReadable(0); ++i) { + try { + _receiver->receiveMessage(); + } catch(RecoverableException* e) { + logger->error(EX_EXCEPTION_CAUGHT, e); + delete e; + } + } + try { + _receiver->handleTimeout(); + _dispatcher->sendMessages(); + } catch(RecoverableException* e) { + logger->error(EX_EXCEPTION_CAUGHT, e); + delete e; + } + _e->commands.push_back(this); + return false; +} + +void DHTInteractionCommand::setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher) +{ + _dispatcher = dispatcher; +} + +void DHTInteractionCommand::setMessageReceiver(const DHTMessageReceiverHandle& receiver) +{ + _receiver = receiver; +} + +void DHTInteractionCommand::setTaskQueue(const DHTTaskQueueHandle& taskQueue) +{ + _taskQueue = taskQueue; +} diff --git a/src/DHTInteractionCommand.h b/src/DHTInteractionCommand.h new file mode 100644 index 00000000..40e6d0fb --- /dev/null +++ b/src/DHTInteractionCommand.h @@ -0,0 +1,74 @@ +/* */ +#ifndef _D_DHT_INTERACTION_COMMAND_H_ +#define _D_DHT_INTERACTION_COMMAND_H_ + +#include "Command.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTMessageReceiverDecl.h" +#include "DHTTaskQueueDecl.h" + +class DownloadEngine; +class SocketCore; +typedef SharedHandle SocketHandle; + +class DHTInteractionCommand:public Command { +protected: + DownloadEngine* _e; +private: + DHTMessageDispatcherHandle _dispatcher; + DHTMessageReceiverHandle _receiver; + DHTTaskQueueHandle _taskQueue; + SocketHandle _readCheckSocket; + +public: + DHTInteractionCommand(int32_t cuid, DownloadEngine* e); + + virtual ~DHTInteractionCommand(); + + virtual bool execute(); + + void setReadCheckSocket(const SocketHandle& socket); + + void disableReadCheckSocket(const SocketHandle& socket); + + void setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher); + + void setMessageReceiver(const DHTMessageReceiverHandle& receiver); + + void setTaskQueue(const DHTTaskQueueHandle& taskQueue); +}; + +#endif // _D_DHT_INTERACTION_COMMAND_H_ diff --git a/src/DHTMessage.cc b/src/DHTMessage.cc new file mode 100644 index 00000000..ac32e691 --- /dev/null +++ b/src/DHTMessage.cc @@ -0,0 +1,67 @@ +/* */ +#include "DHTMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" + +DHTMessage::DHTMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + _localNode(localNode), _remoteNode(remoteNode), _transactionID(transactionID) +{ + if(transactionID.empty()) { + generateTransactionID(); + } +} + +DHTMessage::~DHTMessage() {} + +void DHTMessage::generateTransactionID() +{ + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + _transactionID = string(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); +} + +DHTNodeHandle DHTMessage::getLocalNode() const +{ + return _localNode; +} + +DHTNodeHandle DHTMessage::getRemoteNode() const +{ + return _remoteNode; +} + diff --git a/src/DHTMessage.h b/src/DHTMessage.h new file mode 100644 index 00000000..e2417624 --- /dev/null +++ b/src/DHTMessage.h @@ -0,0 +1,80 @@ +/* */ +#ifndef _D_DHT_MESSAGE_H_ +#define _D_DHT_MESSAGE_H_ + +#include "common.h" +#include "DHTMessageDecl.h" +#include "DHTNodeDecl.h" + +class DHTMessage { +protected: + DHTNodeHandle _localNode; + + DHTNodeHandle _remoteNode; + + string _transactionID; + + void generateTransactionID(); +public: + DHTMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID = ""); + + virtual ~DHTMessage(); + + const string& getTransactionID() const + { + return _transactionID; + } + + DHTNodeHandle getLocalNode() const; + + DHTNodeHandle getRemoteNode() const; + + virtual void doReceivedAction() = 0; + + virtual void send() = 0; + + virtual bool isReply() const = 0; + + virtual void validate() const = 0; + + virtual string getMessageType() const = 0; + + virtual string toString() const = 0; +}; + +#endif // _D_DHT_MESSAGE_H_ diff --git a/src/DHTMessageCallback.h b/src/DHTMessageCallback.h new file mode 100644 index 00000000..56fbfd01 --- /dev/null +++ b/src/DHTMessageCallback.h @@ -0,0 +1,52 @@ +/* */ +#ifndef _D_DHT_MESSAGE_CALLBACK_H_ +#define _D_DHT_MESSAGE_CALLBACK_H_ + +#include "common.h" +#include "DHTMessageCallbackDecl.h" +#include "DHTMessageDecl.h" +#include "DHTNodeDecl.h" + +class DHTMessageCallback { +public: + virtual ~DHTMessageCallback() {} + + virtual void onReceived(const DHTMessageHandle& message) = 0; + + virtual void onTimeout(const DHTNodeHandle& remoteNode) = 0; +}; + +#endif // _D_DHT_MESSAGE_CALLBACK_H_ diff --git a/src/DHTMessageCallbackDecl.h b/src/DHTMessageCallbackDecl.h new file mode 100644 index 00000000..f0fadcee --- /dev/null +++ b/src/DHTMessageCallbackDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_MESSAGE_CALLBACK_DECL_H_ +#define _D_DHT_MESSAGE_CALLBACK_DECL_H_ + +#include "SharedHandle.h" + +class DHTMessageCallback; +typedef SharedHandle DHTMessageCallbackHandle; + +#endif // _D_DHT_MESSAGE_CALLBACK_DECL_H_ diff --git a/src/DHTMessageCallbackImpl.cc b/src/DHTMessageCallbackImpl.cc new file mode 100644 index 00000000..a6e96545 --- /dev/null +++ b/src/DHTMessageCallbackImpl.cc @@ -0,0 +1,55 @@ +/* */ +#include "DHTMessageCallbackImpl.h" +#include "DHTMessage.h" +#include "DHTNode.h" + +DHTMessageCallbackImpl::DHTMessageCallbackImpl(const WeakHandle& listener):_listener(listener) {} + +DHTMessageCallbackImpl::~DHTMessageCallbackImpl() {} + +void DHTMessageCallbackImpl::onReceived(const DHTMessageHandle& message) +{ + if(!_listener.isNull()) { + _listener->onReceived(message); + } +} + +void DHTMessageCallbackImpl::onTimeout(const DHTNodeHandle& remoteNode) +{ + if(!_listener.isNull()) { + _listener->onTimeout(remoteNode); + } +} diff --git a/src/DHTMessageCallbackImpl.h b/src/DHTMessageCallbackImpl.h new file mode 100644 index 00000000..b7a2e912 --- /dev/null +++ b/src/DHTMessageCallbackImpl.h @@ -0,0 +1,55 @@ +/* */ +#ifndef _D_DHT_MESSAGE_CALLBACK_IMPL_H_ +#define _D_DHT_MESSAGE_CALLBACK_IMPL_H_ + +#include "DHTMessageCallback.h" +#include "DHTMessageCallbackListener.h" + +class DHTMessageCallbackImpl:public DHTMessageCallback { +private: + WeakHandle _listener; + +public: + DHTMessageCallbackImpl(const WeakHandle& listener); + + virtual ~DHTMessageCallbackImpl(); + + virtual void onReceived(const DHTMessageHandle& message); + + virtual void onTimeout(const DHTNodeHandle& remoteNode); +}; + +#endif // _D_DHT_MESSAGE_CALLBACK_IMPL_H_ diff --git a/src/DHTMessageCallbackListener.h b/src/DHTMessageCallbackListener.h new file mode 100644 index 00000000..6a77a529 --- /dev/null +++ b/src/DHTMessageCallbackListener.h @@ -0,0 +1,51 @@ +/* */ +#ifndef _D_DHT_MESSAGE_CALLBACK_LISTENER_H_ +#define _D_DHT_MESSAGE_CALLBACK_LISTENER_H_ + +#include "common.h" +#include "DHTMessageDecl.h" +#include "DHTNodeDecl.h" + +class DHTMessageCallbackListener { +public: + virtual ~DHTMessageCallbackListener() {} + + virtual void onReceived(const DHTMessageHandle& message) = 0; + + virtual void onTimeout(const DHTNodeHandle& remoteNode) = 0; +}; + +#endif // _D_DHT_MESSAGE_CALLBACK_LISTENER_H_ diff --git a/src/DHTMessageDecl.h b/src/DHTMessageDecl.h new file mode 100644 index 00000000..0d5c7351 --- /dev/null +++ b/src/DHTMessageDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_MESSAGE_DECL_H_ +#define _D_DHT_MESSAGE_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTMessage; +typedef SharedHandle DHTMessageHandle; +typedef std::deque DHTMessages; + +#endif // _D_DHT_MESSAGE_DECL_H_ diff --git a/src/DHTMessageDispatcher.cc b/src/DHTMessageDispatcher.cc new file mode 100644 index 00000000..73be8beb --- /dev/null +++ b/src/DHTMessageDispatcher.cc @@ -0,0 +1,86 @@ +/* */ +#include "DHTMessageDispatcher.h" +#include "DHTMessage.h" +#include "DHTMessageCallback.h" +#include "DHTMessageEntry.h" +#include "DHTMessageTracker.h" +#include "RecoverableException.h" +#include "LogFactory.h" +#include "DHTConstants.h" + +DHTMessageDispatcher::DHTMessageDispatcher(const DHTMessageTrackerHandle& tracker):_tracker(tracker), _logger(LogFactory::getInstance()) {} + +DHTMessageDispatcher::~DHTMessageDispatcher() {} + +void DHTMessageDispatcher::addMessageToQueue(const DHTMessageHandle& message, + time_t timeout, + const DHTMessageCallbackHandle& callback) +{ + _messageQueue.push_back(new DHTMessageEntry(message, timeout, callback)); +} + +void DHTMessageDispatcher::addMessageToQueue(const DHTMessageHandle& message, + const DHTMessageCallbackHandle& callback) +{ + addMessageToQueue(message, DHT_MESSAGE_TIMEOUT, callback); +} + +void DHTMessageDispatcher::sendMessage(const DHTMessageEntryHandle& entry) +{ + try { + entry->_message->send(); + if(!entry->_message->isReply()) { + _tracker->addMessage(entry->_message, entry->_timeout, entry->_callback); + } + _logger->info("Message sent: %s", entry->_message->toString().c_str()); + } catch(RecoverableException* e) { + _logger->error("Failed to send message: %s", e, entry->_message->toString().c_str()); + delete e; + } +} + +void DHTMessageDispatcher::sendMessages() +{ + for(DHTMessageEntries::iterator itr = _messageQueue.begin(); itr != _messageQueue.end(); ++itr) { + sendMessage(*itr); + } + _messageQueue.clear(); +} + +size_t DHTMessageDispatcher::countMessageInQueue() const +{ + return _messageQueue.size(); +} diff --git a/src/DHTMessageDispatcher.h b/src/DHTMessageDispatcher.h new file mode 100644 index 00000000..b2c63a4a --- /dev/null +++ b/src/DHTMessageDispatcher.h @@ -0,0 +1,73 @@ +/* */ +#ifndef _D_DHT_MESSAGE_DISPATCHER_H_ +#define _D_DHT_MESSAGE_DISPATCHER_H_ + +#include "common.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTMessageTrackerDecl.h" +#include "DHTMessageCallbackDecl.h" +#include "DHTMessageEntryDecl.h" +#include "DHTMessageDecl.h" + +class Logger; + +class DHTMessageDispatcher { +private: + DHTMessageTrackerHandle _tracker; + + DHTMessageEntries _messageQueue; + + const Logger* _logger; + + void sendMessage(const DHTMessageEntryHandle& msg); +public: + DHTMessageDispatcher(const DHTMessageTrackerHandle& tracker); + + ~DHTMessageDispatcher(); + + void addMessageToQueue(const DHTMessageHandle& message, + time_t timeout, + const DHTMessageCallbackHandle& callback = 0); + + void addMessageToQueue(const DHTMessageHandle& message, + const DHTMessageCallbackHandle& callback = 0); + + void sendMessages(); + + size_t countMessageInQueue() const; +}; + +#endif // _D_DHT_MESSAGE_DISPATCHER_H_ diff --git a/src/DHTMessageDispatcherDecl.h b/src/DHTMessageDispatcherDecl.h new file mode 100644 index 00000000..e3836347 --- /dev/null +++ b/src/DHTMessageDispatcherDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_MESSAGE_DISPATCHER_DECL_H_ +#define _D_DHT_MESSAGE_DISPATCHER_DECL_H_ + +#include "SharedHandle.h" + +class DHTMessageDispatcher; +typedef SharedHandle DHTMessageDispatcherHandle; + +#endif // _D_DHT_MESSAGE_DISPATCHER_DECL_H_ diff --git a/src/DHTMessageEntry.cc b/src/DHTMessageEntry.cc new file mode 100644 index 00000000..c3882f3c --- /dev/null +++ b/src/DHTMessageEntry.cc @@ -0,0 +1,44 @@ +/* */ +#include "DHTMessageEntry.h" +#include "DHTMessage.h" +#include "DHTMessageCallback.h" + +DHTMessageEntry::DHTMessageEntry(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback): + _message(message), + _timeout(timeout), + _callback(callback) {} + +DHTMessageEntry::~DHTMessageEntry() {} diff --git a/src/DHTMessageEntry.h b/src/DHTMessageEntry.h new file mode 100644 index 00000000..46e8a261 --- /dev/null +++ b/src/DHTMessageEntry.h @@ -0,0 +1,54 @@ +/* */ +#ifndef _D_DHT_MESSAGE_ENTRY_H_ +#define _D_DHT_MESSAGE_ENTRY_H_ + +#include "common.h" +#include "DHTMessageEntryDecl.h" +#include "DHTMessageDecl.h" +#include "DHTMessageCallbackDecl.h" + +class DHTMessageEntry { +public: + DHTMessageHandle _message; + time_t _timeout; + DHTMessageCallbackHandle _callback; + + DHTMessageEntry(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback); + + ~DHTMessageEntry(); +}; + +#endif // _D_DHT_MESSAGE_ENTRY_H_ diff --git a/src/DHTMessageEntryDecl.h b/src/DHTMessageEntryDecl.h new file mode 100644 index 00000000..2c80a9dd --- /dev/null +++ b/src/DHTMessageEntryDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_MESSAGE_ENTRY_DECL_H_ +#define _D_DHT_MESSAGE_ENTRY_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTMessageEntry; +typedef SharedHandle DHTMessageEntryHandle; +typedef std::deque DHTMessageEntries; + +#endif // _D_DHT_MESSAGE_ENTRY_DECL_H_ diff --git a/src/DHTMessageFactory.h b/src/DHTMessageFactory.h new file mode 100644 index 00000000..59472164 --- /dev/null +++ b/src/DHTMessageFactory.h @@ -0,0 +1,107 @@ +/* */ +#ifndef _D_DHT_MESSAGE_FACTORY_H_ +#define _D_DHT_MESSAGE_FACTORY_H_ + +#include "common.h" +#include "DHTMessageDecl.h" +#include "DHTNodeDecl.h" +#include "PeerDecl.h" + +class Dictionary; + +class DHTMessageFactory { +public: + virtual ~DHTMessageFactory() {} + + virtual DHTMessageHandle + createQueryMessage(const Dictionary* d, + const string& ipaddr, uint16_t port) = 0; + + virtual DHTMessageHandle + createResponseMessage(const string& messageType, + const Dictionary* d, + const DHTNodeHandle& remoteNode) = 0; + + virtual DHTMessageHandle + createPingMessage(const DHTNodeHandle& remoteNode, + const string& transactionID = "") = 0; + + virtual DHTMessageHandle + createPingReplyMessage(const DHTNodeHandle& remoteNode, + const unsigned char* id, + const string& transactionID) = 0; + + virtual DHTMessageHandle + createFindNodeMessage(const DHTNodeHandle& remoteNode, + const unsigned char* targetNodeID, + const string& transactionID = "") = 0; + + virtual DHTMessageHandle + createFindNodeReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& transactionID) = 0; + + virtual DHTMessageHandle + createGetPeersMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + const string& transactionID = "") = 0; + + virtual DHTMessageHandle + createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& token, + const string& transactionID) = 0; + + virtual DHTMessageHandle + createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const Peers& peers, + const string& token, + const string& transactionID) = 0; + + virtual DHTMessageHandle + createAnnouncePeerMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + uint16_t tcpPort, + const string& token, + const string& transactionID = "") = 0; + + virtual DHTMessageHandle + createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode, + const string& transactionID) = 0; + +}; + +#endif // _D_DHT_MESSAGE_FACTORY_H_ diff --git a/src/DHTMessageFactoryDecl.h b/src/DHTMessageFactoryDecl.h new file mode 100644 index 00000000..131d1053 --- /dev/null +++ b/src/DHTMessageFactoryDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_MESSAGE_FACTORY_DECL_H_ +#define _D_DHT_MESSAGE_FACTORY_DECL_H_ + +#include "SharedHandle.h" + +class DHTMessageFactory; +typedef SharedHandle DHTMessageFactoryHandle; + +#endif // _D_DHT_MESSAGE_FACTORY_DECL_H_ diff --git a/src/DHTMessageFactoryImpl.cc b/src/DHTMessageFactoryImpl.cc new file mode 100644 index 00000000..12bf3d65 --- /dev/null +++ b/src/DHTMessageFactoryImpl.cc @@ -0,0 +1,418 @@ +/* */ +#include "DHTMessageFactoryImpl.h" +#include "LogFactory.h" +#include "DlAbortEx.h" +#include "Data.h" +#include "Dictionary.h" +#include "List.h" +#include "DHTNode.h" +#include "DHTRoutingTable.h" +#include "DHTPingMessage.h" +#include "DHTPingReplyMessage.h" +#include "DHTFindNodeMessage.h" +#include "DHTFindNodeReplyMessage.h" +#include "DHTGetPeersMessage.h" +#include "DHTGetPeersReplyMessage.h" +#include "DHTAnnouncePeerMessage.h" +#include "DHTAnnouncePeerReplyMessage.h" +#include "DHTConnection.h" +#include "DHTMessageDispatcher.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTTokenTracker.h" +#include "PeerMessageUtil.h" +#include "BtRuntime.h" +#include "Util.h" +#include "Peer.h" + +DHTMessageFactoryImpl::DHTMessageFactoryImpl():_localNode(0), + _logger(LogFactory::getInstance()) {} + +DHTMessageFactoryImpl::~DHTMessageFactoryImpl() {} + +DHTNodeHandle +DHTMessageFactoryImpl::getRemoteNode(const unsigned char* id, const string& ipaddr, uint16_t port) const +{ + DHTNodeHandle node = _routingTable->getNode(id, ipaddr, port); + if(node.isNull()) { + node = new DHTNode(id); + node->setIPAddress(ipaddr); + node->setPort(port); + } + return node; +} + +static const Dictionary* getDictionary(const Dictionary* d, const string& key) +{ + const Dictionary* c = dynamic_cast(d->get(key)); + if(c) { + return c; + } else { + throw new DlAbortEx("Malformed DHT message. Missing %s", key.c_str()); + } +} + +static const Data* getData(const Dictionary* d, const string& key) +{ + const Data* c = dynamic_cast(d->get(key)); + if(c) { + return c; + } else { + throw new DlAbortEx("Malformed DHT message. Missing %s", key.c_str()); + } +} + +static const List* getList(const Dictionary* d, const string& key) +{ + const List* l = dynamic_cast(d->get(key)); + if(l) { + return l; + } else { + throw new DlAbortEx("Malformed DHT message. Missing %s", key.c_str()); + } +} + +void DHTMessageFactoryImpl::validateID(const Data* id) const +{ + if(id->getLen() != DHT_ID_LENGTH) { + throw new DlAbortEx("Malformed DHT message. Invalid ID length. Expected:%d, Actual:%d", DHT_ID_LENGTH, id->getLen()); + } +} + +void DHTMessageFactoryImpl::validateIDMatch(const unsigned char* expected, const unsigned char* actual) const +{ + if(memcmp(expected, actual, DHT_ID_LENGTH) != 0) { + //throw new DlAbortEx("Different ID received."); + } +} + +void DHTMessageFactoryImpl::validatePort(const Data* i) const +{ + if(!i->isNumber()) { + throw new DlAbortEx("Malformed DHT message. Invalid port=%s", + Util::toHex(i->toString()).c_str()); + } + uint32_t port = i->toInt(); + if(UINT16_MAX < port) { + throw new DlAbortEx("Malformed DHT message. Invalid port=%u", port); + } +} + +DHTMessageHandle DHTMessageFactoryImpl::createQueryMessage(const Dictionary* d, + const string& ipaddr, + uint16_t port) +{ + const Data* q = getData(d, "q"); + const Data* t = getData(d, "t"); + const Data* y = getData(d, "y"); + const Dictionary* a = getDictionary(d, "a"); + if(y->toString() != "q") { + throw new DlAbortEx("Malformed DHT message. y != q"); + } + const Data* id = getData(getDictionary(d, "a"), "id"); + validateID(id); + DHTNodeHandle remoteNode = getRemoteNode((const unsigned char*)id->toString().c_str(), ipaddr, port); + string messageType = q->toString(); + string transactionID = t->toString(); + if(messageType == "ping") { + return createPingMessage(remoteNode, transactionID); + } else if(messageType == "find_node") { + const Data* targetNodeID = getData(a, "target"); + validateID(targetNodeID); + return createFindNodeMessage(remoteNode, + (const unsigned char*)targetNodeID->getData(), + transactionID); + } else if(messageType == "get_peers") { + const Data* infoHash = getData(a, "info_hash"); + validateID(infoHash); + return createGetPeersMessage(remoteNode, + (const unsigned char*)infoHash->getData(), + transactionID); + } else if(messageType == "announce_peer") { + const Data* infoHash = getData(a, "info_hash"); + validateID(infoHash); + const Data* port = getData(a, "port"); + validatePort(port); + const Data* token = getData(a, "token"); + return createAnnouncePeerMessage(remoteNode, + (const unsigned char*)infoHash->getData(), + (uint16_t)port->toInt(), + token->toString(), + transactionID); + } else { + throw new DlAbortEx("Unsupported message type: %s", messageType.c_str()); + } +} + +DHTMessageHandle DHTMessageFactoryImpl::createResponseMessage(const string& messageType, + const Dictionary* d, + const DHTNodeHandle& remoteNode) +{ + const Data* t = getData(d, "t"); + const Data* y = getData(d, "y"); + const Dictionary* r = getDictionary(d, "r"); + // TODO handle y == "e" case + if(y->toString() != "r") { + throw new DlAbortEx("Malformed DHT message. y != r: y=%s", + Util::urlencode(y->toString()).c_str()); + } + const Data* id = getData(r, "id"); + validateID(id); + validateIDMatch(remoteNode->getID(), + (const unsigned char*)id->toString().c_str()); + string transactionID = t->toString(); + if(messageType == "ping") { + return createPingReplyMessage(remoteNode, (const unsigned char*)id->getData(), transactionID); + } else if(messageType == "find_node") { + return createFindNodeReplyMessage(remoteNode, d, transactionID); + } else if(messageType == "get_peers") { + const List* values = dynamic_cast(r->get("values")); + if(values) { + return createGetPeersReplyMessageWithValues(remoteNode, d, transactionID); + } else { + const Data* nodes = dynamic_cast(r->get("nodes")); + if(nodes) { + return createGetPeersReplyMessageWithNodes(remoteNode, d, transactionID); + } else { + throw new DlAbortEx("Malformed DHT message: missing nodes/values"); + } + } + } else if(messageType == "announce_peer") { + return createAnnouncePeerReplyMessage(remoteNode, transactionID); + } else { + throw new DlAbortEx("Unsupported message type: %s", messageType.c_str()); + } +} + +void DHTMessageFactoryImpl::setCommonProperty(const SharedHandle& m) +{ + m->setConnection(_connection); + m->setMessageDispatcher(_dispatcher); + m->setRoutingTable(_routingTable); + m->setMessageFactory(this); +} + +DHTMessageHandle DHTMessageFactoryImpl::createPingMessage(const DHTNodeHandle& remoteNode, const string& transactionID) +{ + SharedHandle m = new DHTPingMessage(_localNode, remoteNode, transactionID); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createPingReplyMessage(const DHTNodeHandle& remoteNode, + const unsigned char* id, + const string& transactionID) +{ + SharedHandle m = new DHTPingReplyMessage(_localNode, remoteNode, id, transactionID); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createFindNodeMessage(const DHTNodeHandle& remoteNode, + const unsigned char* targetNodeID, + const string& transactionID) +{ + SharedHandle m = new DHTFindNodeMessage(_localNode, remoteNode, targetNodeID, transactionID); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createFindNodeReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& transactionID) +{ + SharedHandle m = new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID); + m->setClosestKNodes(closestKNodes); + setCommonProperty(m); + return m; +} + +DHTNodes DHTMessageFactoryImpl::extractNodes(const char* src, size_t length) +{ + if(length%26 != 0) { + throw new DlAbortEx("Nodes length is not multiple of 26"); + } + DHTNodes nodes; + for(size_t offset = 0; offset < length; offset += 26) { + DHTNodeHandle node = new DHTNode(reinterpret_cast(src+offset)); + pair addr = + PeerMessageUtil::unpackcompact(src+offset+DHT_ID_LENGTH); + node->setIPAddress(addr.first); + node->setPort(addr.second); + nodes.push_back(node); + } + return nodes; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createFindNodeReplyMessage(const DHTNodeHandle& remoteNode, + const Dictionary* d, + const string& transactionID) +{ + const Data* nodesData = getData(getDictionary(d, "r"), "nodes"); + DHTNodes nodes = extractNodes(nodesData->getData(), nodesData->getLen()); + return createFindNodeReplyMessage(remoteNode, nodes, transactionID); +} + +DHTMessageHandle +DHTMessageFactoryImpl::createGetPeersMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + const string& transactionID) +{ + SharedHandle m = new DHTGetPeersMessage(_localNode, + remoteNode, + infoHash, + transactionID); + m->setPeerAnnounceStorage(_peerAnnounceStorage); + m->setTokenTracker(_tokenTracker); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes(const DHTNodeHandle& remoteNode, + const Dictionary* d, + const string& transactionID) +{ + const Dictionary* r = getDictionary(d, "r"); + const Data* nodesData = getData(r, "nodes"); + DHTNodes nodes = extractNodes(nodesData->getData(), nodesData->getLen()); + const Data* token = getData(r, "token"); + return createGetPeersReplyMessage(remoteNode, nodes, token->toString(), + transactionID); +} + +DHTMessageHandle +DHTMessageFactoryImpl::createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& token, + const string& transactionID) +{ + SharedHandle m = new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID); + m->setClosestKNodes(closestKNodes); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues(const DHTNodeHandle& remoteNode, + const Dictionary* d, + const string& transactionID) +{ + const Dictionary* r = getDictionary(d, "r"); + const List* valuesList = getList(r, "values"); + Peers peers; + for(MetaList::const_iterator i = valuesList->getList().begin(); i != valuesList->getList().end(); ++i) { + const Data* data = dynamic_cast(*i); + if(data && data->getLen() == 6) { + pair addr = PeerMessageUtil::unpackcompact(data->getData()); + PeerHandle peer = new Peer(addr.first, addr.second); + peers.push_back(peer); + } + } + const Data* token = getData(r, "token"); + return createGetPeersReplyMessage(remoteNode, peers, token->toString(), + transactionID); +} + +DHTMessageHandle +DHTMessageFactoryImpl::createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const Peers& values, + const string& token, + const string& transactionID) +{ + SharedHandle m = new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID); + m->setValues(values); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createAnnouncePeerMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + uint16_t tcpPort, + const string& token, + const string& transactionID) +{ + SharedHandle m = + new DHTAnnouncePeerMessage(_localNode, remoteNode, infoHash, tcpPort, token, transactionID); + m->setPeerAnnounceStorage(_peerAnnounceStorage); + m->setTokenTracker(_tokenTracker); + setCommonProperty(m); + return m; +} + +DHTMessageHandle +DHTMessageFactoryImpl::createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode, + const string& transactionID) +{ + SharedHandle m = + new DHTAnnouncePeerReplyMessage(_localNode, remoteNode, transactionID); + setCommonProperty(m); + return m; +} + +void DHTMessageFactoryImpl::setRoutingTable(const DHTRoutingTableHandle& routingTable) +{ + _routingTable = routingTable; +} + +void DHTMessageFactoryImpl::setConnection(const DHTConnectionHandle& connection) +{ + _connection = connection; +} + +void DHTMessageFactoryImpl::setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher) +{ + _dispatcher = dispatcher; +} + +void DHTMessageFactoryImpl::setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage) +{ + _peerAnnounceStorage = storage; +} + +void DHTMessageFactoryImpl::setTokenTracker(const DHTTokenTrackerHandle& tokenTracker) +{ + _tokenTracker = tokenTracker; +} + +void DHTMessageFactoryImpl::setLocalNode(const DHTNodeHandle& localNode) +{ + _localNode = localNode; +} diff --git a/src/DHTMessageFactoryImpl.h b/src/DHTMessageFactoryImpl.h new file mode 100644 index 00000000..1176740c --- /dev/null +++ b/src/DHTMessageFactoryImpl.h @@ -0,0 +1,168 @@ +/* */ +#ifndef _D_DHT_MESSAGE_FACTORY_IMPL_H_ +#define _D_DHT_MESSAGE_FACTORY_IMPL_H_ + +#include "DHTMessageFactory.h" +#include "DHTRoutingTableDecl.h" +#include "DHTConnectionDecl.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTPeerAnnounceStorageDecl.h" +#include "DHTTokenTrackerDecl.h" + +class Logger; +class Data; +class DHTAbstractMessage; + +class DHTMessageFactoryImpl:public DHTMessageFactory { +private: + DHTNodeHandle _localNode; + + WeakHandle _connection; + + WeakHandle _dispatcher; + + WeakHandle _routingTable; + + WeakHandle _peerAnnounceStorage; + + WeakHandle _tokenTracker; + + const Logger* _logger; + + // search node in routingTable. If it is not found, create new one. + DHTNodeHandle getRemoteNode(const unsigned char* id, const string& ipaddr, uint16_t port) const; + + void validateID(const Data* id) const; + + void validateIDMatch(const unsigned char* expected, const unsigned char* actual) const; + + void validatePort(const Data* i) const; + + DHTNodes extractNodes(const char* src, size_t length); + + void setCommonProperty(const SharedHandle& m); + +public: + DHTMessageFactoryImpl(); + + virtual ~DHTMessageFactoryImpl(); + + virtual DHTMessageHandle + createQueryMessage(const Dictionary* d, + const string& ipaddr, uint16_t port); + + virtual DHTMessageHandle + createResponseMessage(const string& messageType, + const Dictionary* d, + const DHTNodeHandle& remoteNode); + + virtual DHTMessageHandle + createPingMessage(const DHTNodeHandle& remoteNode, + const string& transactionID = ""); + + virtual DHTMessageHandle + createPingReplyMessage(const DHTNodeHandle& remoteNode, + const unsigned char* id, + const string& transactionID); + + virtual DHTMessageHandle + createFindNodeMessage(const DHTNodeHandle& remoteNode, + const unsigned char* targetNodeID, + const string& transactionID = ""); + + DHTMessageHandle + createFindNodeReplyMessage(const DHTNodeHandle& remoteNode, + const Dictionary* d, + const string& transactionID); + + + virtual DHTMessageHandle + createFindNodeReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& transactionID); + + virtual DHTMessageHandle + createGetPeersMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + const string& transactionID = ""); + + virtual DHTMessageHandle + createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& token, + const string& transactionID); + + DHTMessageHandle + createGetPeersReplyMessageWithNodes(const DHTNodeHandle& remoteNode, + const Dictionary* d, + const string& transactionID); + + virtual DHTMessageHandle + createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const Peers& peers, + const string& token, + const string& transactionID); + + DHTMessageHandle + createGetPeersReplyMessageWithValues(const DHTNodeHandle& remoteNode, + const Dictionary* d, + const string& transactionID); + + virtual DHTMessageHandle + createAnnouncePeerMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + uint16_t tcpPort, + const string& token, + const string& transactionID = ""); + + virtual DHTMessageHandle + createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode, + const string& transactionID); + + void setRoutingTable(const DHTRoutingTableHandle& routingTable); + + void setConnection(const DHTConnectionHandle& connection); + + void setMessageDispatcher(const DHTMessageDispatcherHandle& dispatcher); + + void setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage); + + void setTokenTracker(const DHTTokenTrackerHandle& tokenTracker); + + void setLocalNode(const DHTNodeHandle& localNode); +}; + +#endif // _D_DHT_MESSAGE_FACTORY_IMPL_H_ diff --git a/src/DHTMessageReceiver.cc b/src/DHTMessageReceiver.cc new file mode 100644 index 00000000..f763f813 --- /dev/null +++ b/src/DHTMessageReceiver.cc @@ -0,0 +1,134 @@ +/* */ +#include "DHTMessageReceiver.h" +#include "DHTMessageTracker.h" +#include "DHTConnection.h" +#include "DHTMessage.h" +#include "DHTMessageFactory.h" +#include "DHTRoutingTable.h" +#include "DHTNode.h" +#include "DHTMessageCallback.h" +#include "MetaEntry.h" +#include "MetaFileUtil.h" +#include "DlAbortEx.h" +#include "LogFactory.h" +#include "Util.h" + +DHTMessageReceiver::DHTMessageReceiver(const DHTMessageTrackerHandle& tracker): + _tracker(tracker), + _connection(0), + _factory(0), + _routingTable(0), + _logger(LogFactory::getInstance()) +{} + +DHTMessageReceiver::~DHTMessageReceiver() {} + +DHTMessageHandle DHTMessageReceiver::receiveMessage() +{ + string remoteAddr; + uint16_t remotePort; + char data[64*1024]; + ssize_t length = _connection->receiveMessage(data, sizeof(data), + remoteAddr, + remotePort); + if(length <= 0) { + return 0; + } + bool isReply = false; + MetaEntryHandle msgroot = MetaFileUtil::bdecoding(data, length); + const Dictionary* d = dynamic_cast(msgroot.get()); + if(d) { + const Data* y = dynamic_cast(d->get("y")); + if(y->toString() == "r" || y->toString() == "e") { + isReply = true; + } + } else { + throw new DlAbortEx("Malformed DHT message. From:%s:%u", remoteAddr.c_str(), remotePort); + } + DHTMessageHandle message = 0; + DHTMessageCallbackHandle callback = 0; + if(isReply) { + std::pair p = _tracker->messageArrived(d, remoteAddr, remotePort); + message = p.first; + callback = p.second; + if(message.isNull()) { + // timeout or malicious message + return 0; + } + } else { + message = _factory->createQueryMessage(d, remoteAddr, remotePort); + } + _logger->info("Message received: %s", message->toString().c_str()); + message->validate(); + message->doReceivedAction(); + message->getRemoteNode()->markGood(); + message->getRemoteNode()->updateLastContact(); + _routingTable->addGoodNode(message->getRemoteNode()); + if(!callback.isNull()) { + callback->onReceived(message); + } + return message; +} + +void DHTMessageReceiver::handleTimeout() +{ + _tracker->handleTimeout(); +} + +DHTConnectionHandle DHTMessageReceiver::getConnection() const +{ + return _connection; +} + +DHTMessageTrackerHandle DHTMessageReceiver::getMessageTracker() const +{ + return _tracker; +} + +void DHTMessageReceiver::setConnection(const DHTConnectionHandle& connection) +{ + _connection = connection; +} + +void DHTMessageReceiver::setMessageFactory(const DHTMessageFactoryHandle& factory) +{ + _factory = factory; +} + +void DHTMessageReceiver::setRoutingTable(const DHTRoutingTableHandle& routingTable) +{ + _routingTable = routingTable; +} diff --git a/src/DHTMessageReceiver.h b/src/DHTMessageReceiver.h new file mode 100644 index 00000000..b5b30d72 --- /dev/null +++ b/src/DHTMessageReceiver.h @@ -0,0 +1,80 @@ +/* */ +#ifndef _D_DHT_MESSAGE_RECEIVER_H_ +#define _D_DHT_MESSAGE_RECEIVER_H_ + +#include "common.h" +#include "DHTMessageReceiverDecl.h" +#include "DHTMessageTrackerDecl.h" +#include "DHTMessageDecl.h" +#include "DHTConnectionDecl.h" +#include "DHTMessageFactoryDecl.h" +#include "DHTRoutingTableDecl.h" + +class Logger; + +class DHTMessageReceiver { +private: + DHTMessageTrackerHandle _tracker; + + DHTConnectionHandle _connection; + + DHTMessageFactoryHandle _factory; + + DHTRoutingTableHandle _routingTable; + + const Logger* _logger; +public: + DHTMessageReceiver(const DHTMessageTrackerHandle& tracker); + + ~DHTMessageReceiver(); + + // caller must handle thrown exception. + DHTMessageHandle receiveMessage(); + + void handleTimeout(); + + DHTConnectionHandle getConnection() const; + + DHTMessageTrackerHandle getMessageTracker() const; + + void setConnection(const DHTConnectionHandle& connection); + + void setMessageFactory(const DHTMessageFactoryHandle& factory); + + void setRoutingTable(const DHTRoutingTableHandle& routingTable); +}; + +#endif // _D_DHT_MESSAGE_RECEIVER_H_ diff --git a/src/DHTMessageReceiverDecl.h b/src/DHTMessageReceiverDecl.h new file mode 100644 index 00000000..09405759 --- /dev/null +++ b/src/DHTMessageReceiverDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_MESSAGE_RECEIVER_DECL_H_ +#define _D_DHT_MESSAGE_RECEIVER_DECL_H_ + +#include "SharedHandle.h" + +class DHTMessageReceiver; +typedef SharedHandle DHTMessageReceiverHandle; + +#endif // _D_DHT_MESSAGE_RECEIVER_DECL_H_ diff --git a/src/DHTMessageTracker.cc b/src/DHTMessageTracker.cc new file mode 100644 index 00000000..cd9753a7 --- /dev/null +++ b/src/DHTMessageTracker.cc @@ -0,0 +1,149 @@ +/* */ +#include "DHTMessageTracker.h" +#include "DHTMessage.h" +#include "DHTMessageCallback.h" +#include "DHTMessageTrackerEntry.h" +#include "DHTNode.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactory.h" +#include "Util.h" +#include "LogFactory.h" +#include "Dictionary.h" +#include "Data.h" +#include "DlAbortEx.h" +#include "DHTConstants.h" + +DHTMessageTracker::DHTMessageTracker(): + _routingTable(0), + _factory(0), + _logger(LogFactory::getInstance()) {} + +DHTMessageTracker::~DHTMessageTracker() {} + +void DHTMessageTracker::addMessage(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback) +{ + _entries.push_back(new DHTMessageTrackerEntry(message, timeout, callback)); +} + +void DHTMessageTracker::addMessage(const DHTMessageHandle& message, const DHTMessageCallbackHandle& callback) +{ + addMessage(message, DHT_MESSAGE_TIMEOUT, callback); +} + +pair +DHTMessageTracker::messageArrived(const Dictionary* d, + const string& ipaddr, uint16_t port) +{ + const Data* tid = dynamic_cast(d->get("t")); + if(!tid) { + throw new DlAbortEx("Malformed DHT message. From:%s:%u", ipaddr.c_str(), port); + } + _logger->debug("Searching tracker entry for TransactionID=%s, Remote=%s:%u", + Util::toHex(tid->toString()).c_str(), ipaddr.c_str(), port); + for(DHTMessageTrackerEntries::iterator i = _entries.begin(); + i != _entries.end(); ++i) { + if((*i)->match(tid->toString(), ipaddr, port)) { + DHTMessageTrackerEntryHandle entry = *i; + _entries.erase(i); + _logger->debug("Tracker entry found."); + DHTNodeHandle targetNode = entry->getTargetNode(); + + DHTMessageHandle message = _factory->createResponseMessage(entry->getMessageType(), + d, targetNode); + int64_t rtt = entry->getElapsedMillis(); + _logger->debug("RTT is %s", Util::llitos(rtt).c_str()); + targetNode->updateRTT(rtt); + DHTMessageCallbackHandle callback = entry->getCallback(); + return pair(message, callback); + } + } + _logger->debug("Tracker entry not found."); + return pair(0, 0); +} + +void DHTMessageTracker::handleTimeout() +{ + for(DHTMessageTrackerEntries::iterator i = _entries.begin(); + i != _entries.end();) { + if((*i)->isTimeout()) { + DHTMessageTrackerEntryHandle entry = *i; + i = _entries.erase(i); + DHTNodeHandle node = entry->getTargetNode(); + _logger->debug("Message timeout: To:%s:%u", + node->getIPAddress().c_str(), node->getPort()); + node->updateRTT(entry->getElapsedMillis()); + node->timeout(); + if(node->isBad()) { + _logger->debug("Marked bad: %s:%u", + node->getIPAddress().c_str(), node->getPort()); + _routingTable->dropNode(node); + } + DHTMessageCallbackHandle callback = entry->getCallback(); + if(!callback.isNull()) { + callback->onTimeout(node); + } + } else { + ++i; + } + } +} + +DHTMessageTrackerEntryHandle +DHTMessageTracker::getEntryFor(const DHTMessageHandle& message) const +{ + for(DHTMessageTrackerEntries::const_iterator i = _entries.begin(); + i != _entries.end(); ++i) { + if((*i)->match(message->getTransactionID(), message->getRemoteNode()->getIPAddress(), message->getRemoteNode()->getPort())) { + return *i; + } + } + return 0; +} + +size_t DHTMessageTracker::countEntry() const +{ + return _entries.size(); +} + +void DHTMessageTracker::setRoutingTable(const DHTRoutingTableHandle& routingTable) +{ + _routingTable = routingTable; +} + +void DHTMessageTracker::setMessageFactory(const DHTMessageFactoryHandle& factory) +{ + _factory = factory; +} diff --git a/src/DHTMessageTracker.h b/src/DHTMessageTracker.h new file mode 100644 index 00000000..e4cf6b3a --- /dev/null +++ b/src/DHTMessageTracker.h @@ -0,0 +1,81 @@ +/* */ +#ifndef _D_DHT_MESSAGE_TRACKER_H_ +#define _D_DHT_MESSAGE_TRACKER_H_ + +#include "common.h" +#include "DHTMessageTrackerDecl.h" +#include "DHTMessageDecl.h" +#include "DHTMessageCallbackDecl.h" +#include "DHTMessageTrackerEntryDecl.h" +#include "DHTRoutingTableDecl.h" +#include "DHTMessageFactoryDecl.h" + +class Logger; +class Dictionary; + +class DHTMessageTracker { +private: + DHTMessageTrackerEntries _entries; + + DHTRoutingTableHandle _routingTable; + + DHTMessageFactoryHandle _factory; + + const Logger* _logger; +public: + DHTMessageTracker(); + + ~DHTMessageTracker(); + + void addMessage(const DHTMessageHandle& message, time_t timeout, const DHTMessageCallbackHandle& callback = 0); + + void addMessage(const DHTMessageHandle& message, const DHTMessageCallbackHandle& callback = 0); + + pair + messageArrived(const Dictionary* d, const string& ipaddr, uint16_t port); + + void handleTimeout(); + + DHTMessageTrackerEntryHandle getEntryFor(const DHTMessageHandle& message) const; + + size_t countEntry() const; + + void setRoutingTable(const DHTRoutingTableHandle& routingTable); + + void setMessageFactory(const DHTMessageFactoryHandle& factory); +}; + +#endif // _D_DHT_MESSAGE_TRACKER_H_ diff --git a/src/DHTMessageTrackerDecl.h b/src/DHTMessageTrackerDecl.h new file mode 100644 index 00000000..59e6d062 --- /dev/null +++ b/src/DHTMessageTrackerDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_MESSAGE_TRACKER_DECL_H_ +#define _D_DHT_MESSAGE_TRACKER_DECL_H_ + +#include "SharedHandle.h" + +class DHTMessageTracker; +typedef SharedHandle DHTMessageTrackerHandle; + +#endif // _D_DHT_MESSAGE_TRACKER_DECL_H_ diff --git a/src/DHTMessageTrackerEntry.cc b/src/DHTMessageTrackerEntry.cc new file mode 100644 index 00000000..ab0231d7 --- /dev/null +++ b/src/DHTMessageTrackerEntry.cc @@ -0,0 +1,73 @@ +/* */ +#include "DHTMessageTrackerEntry.h" +#include "DHTNode.h" +#include "DHTMessage.h" +#include "DHTMessageCallback.h" +#include "DHTConstants.h" + +DHTMessageTrackerEntry::DHTMessageTrackerEntry(const DHTMessageHandle& sentMessage, + time_t timeout, + const DHTMessageCallbackHandle& callback): + _targetNode(sentMessage->getRemoteNode()), + _transactionID(sentMessage->getTransactionID()), + _messageType(sentMessage->getMessageType()), + _callback(callback), + _timeout(timeout) +{} + +bool DHTMessageTrackerEntry::isTimeout() const +{ + return _dispatchedTime.elapsed(_timeout); +} + +void DHTMessageTrackerEntry::extendTimeout() +{} + +bool DHTMessageTrackerEntry::match(const string& transactionID, const string& ipaddr, uint16_t port) const +{ + return _transactionID == transactionID && + _targetNode->getIPAddress() == ipaddr && _targetNode->getPort() == port; +} + +DHTMessageCallbackHandle DHTMessageTrackerEntry::getCallback() const +{ + return _callback; +} + +DHTNodeHandle DHTMessageTrackerEntry::getTargetNode() const +{ + return _targetNode; +} diff --git a/src/DHTMessageTrackerEntry.h b/src/DHTMessageTrackerEntry.h new file mode 100644 index 00000000..b6425e24 --- /dev/null +++ b/src/DHTMessageTrackerEntry.h @@ -0,0 +1,85 @@ +/* */ +#ifndef _D_DHT_MESSAGE_TRACKER_ENTRY_H_ +#define _D_DHT_MESSAGE_TRACKER_ENTRY_H_ + +#include "common.h" +#include "DHTMessageTrackerEntryDecl.h" +#include "DHTConstants.h" +#include "DHTNodeDecl.h" +#include "DHTMessageDecl.h" +#include "DHTMessageCallbackDecl.h" +#include "TimeA2.h" + +class DHTMessageTrackerEntry { +private: + DHTNodeHandle _targetNode; + + string _transactionID; + + string _messageType; + + DHTMessageCallbackHandle _callback; + + Time _dispatchedTime; + + time_t _timeout; +public: + DHTMessageTrackerEntry(const DHTMessageHandle& sentMessage, + time_t timeout, + const DHTMessageCallbackHandle& callback = 0); + + bool isTimeout() const; + + void extendTimeout(); + + bool match(const string& transactionID, const string& ipaddr, uint16_t port) const; + + DHTNodeHandle getTargetNode() const; + + const string& getMessageType() const + { + return _messageType; + } + + DHTMessageCallbackHandle getCallback() const; + + int64_t getElapsedMillis() const + { + return _dispatchedTime.differenceInMillis(); + } +}; + +#endif // _D_DHT_MESSAGE_TRACKER_ENTRY_H_ diff --git a/src/DHTMessageTrackerEntryDecl.h b/src/DHTMessageTrackerEntryDecl.h new file mode 100644 index 00000000..cb3c565f --- /dev/null +++ b/src/DHTMessageTrackerEntryDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_MESSAGE_TRACKER_ENTRY_DECL_H_ +#define _D_DHT_MESSAGE_TRACKER_ENTRY_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTMessageTrackerEntry; +typedef SharedHandle DHTMessageTrackerEntryHandle; +typedef std::deque DHTMessageTrackerEntries; + +#endif // _D_DHT_MESSAGE_TRACKER_ENTRY_DECL_H_ diff --git a/src/DHTNode.cc b/src/DHTNode.cc new file mode 100644 index 00000000..cca92f55 --- /dev/null +++ b/src/DHTNode.cc @@ -0,0 +1,115 @@ +/* */ +#include "DHTNode.h" +#include "DHTUtil.h" +#include "Util.h" + +DHTNode::DHTNode():_port(0), _rtt(0), _condition(0), _lastContact(0) +{ + generateID(); +} + +DHTNode::DHTNode(const unsigned char* id):_port(0), _rtt(0), _condition(1), _lastContact(0) +{ + memcpy(_id, id, DHT_ID_LENGTH); +} + +void DHTNode::generateID() +{ + DHTUtil::generateRandomKey(_id); +} + +bool DHTNode::operator==(const DHTNode& node) const +{ + return memcmp(_id, node._id, DHT_ID_LENGTH) == 0 && + _ipaddr == node._ipaddr && _port == node._port; +} + +bool DHTNode::operator<(const DHTNode& node) const +{ + for(size_t i = 0; i < DHT_ID_LENGTH; ++i) { + if(_id[i] > node._id[i]) { + return false; + } else if(_id[i] < node._id[i]) { + return true; + } + } + return true; +} + +bool DHTNode::isGood() const +{ + return !isBad() && !isQuestionable(); +} + +#define BAD_CONDITION 5 + +bool DHTNode::isBad() const +{ + return _condition >= BAD_CONDITION; +} + +bool DHTNode::isQuestionable() const +{ + return !isBad() && _lastContact.elapsed(DHT_NODE_CONTACT_INTERVAL); +} + +void DHTNode::markGood() +{ + _condition = 0; +} + +void DHTNode::markBad() +{ + _condition = BAD_CONDITION; +} + +void DHTNode::updateLastContact() +{ + _lastContact.reset(); +} + +void DHTNode::timeout() +{ + ++_condition; +} + +string DHTNode::toString() const +{ + return "DHTNode ID="+Util::toHex(_id, DHT_ID_LENGTH)+ + ", Host="+_ipaddr+":"+Util::uitos(_port)+ + ", Condition="+Util::uitos(_condition)+ + ", RTT="+Util::itos(_rtt); +} diff --git a/src/DHTNode.h b/src/DHTNode.h new file mode 100644 index 00000000..c6af39aa --- /dev/null +++ b/src/DHTNode.h @@ -0,0 +1,123 @@ +/* */ +#ifndef _D_DHT_NODE_H_ +#define _D_DHT_NODE_H_ + +#include "common.h" +#include "DHTConstants.h" +#include "DHTNodeDecl.h" +#include "TimeA2.h" + +class DHTNode { +private: + unsigned char _id[DHT_ID_LENGTH]; + + string _ipaddr; + + uint16_t _port; + + // in milli sec + int32_t _rtt; + + uint32_t _condition; + + Time _lastContact; +public: + DHTNode(); + + /** + * id must be 20 bytes length + */ + DHTNode(const unsigned char* id); + + void generateID(); + + const unsigned char* getID() const + { + return _id; + } + + void updateRTT(int32_t millisec) + { + _rtt = millisec; + } + + string getIPAddress() const + { + return _ipaddr; + } + + void setIPAddress(const string& ipaddr) + { + _ipaddr = ipaddr; + } + + void setID(const unsigned char* id) + { + memcpy(_id, id, DHT_ID_LENGTH); + } + + uint16_t getPort() const + { + return _port; + } + + void setPort(uint16_t port) + { + _port = port; + } + + bool isGood() const; + + bool isBad() const; + + bool isQuestionable() const; + + void updateLastContact(); + + void markGood(); + + void markBad(); + + void timeout(); + + bool operator==(const DHTNode& node) const; + + bool operator<(const DHTNode& node) const; + + string toString() const; +}; + +#endif // _D_DHT_NODE_H_ diff --git a/src/DHTNodeDecl.h b/src/DHTNodeDecl.h new file mode 100644 index 00000000..9648e3d6 --- /dev/null +++ b/src/DHTNodeDecl.h @@ -0,0 +1,44 @@ +/* */ +#ifndef _D_DHT_NODE_DECL_H_ +#define _D_DHT_NODE_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTNode; +typedef SharedHandle DHTNodeHandle; +typedef std::deque DHTNodes; +#endif // _D_DHT_NODE_DECL_H_ diff --git a/src/DHTNodeLookupEntry.cc b/src/DHTNodeLookupEntry.cc new file mode 100644 index 00000000..473cb47d --- /dev/null +++ b/src/DHTNodeLookupEntry.cc @@ -0,0 +1,47 @@ +/* */ +#include "DHTNodeLookupEntry.h" +#include "DHTNode.h" + +DHTNodeLookupEntry::DHTNodeLookupEntry(const DHTNodeHandle& node): + _node(node), _used(false) {} + +DHTNodeLookupEntry::DHTNodeLookupEntry(): + _node(0), _used(false) {} + +bool DHTNodeLookupEntry::operator==(const DHTNodeLookupEntry& entry) const +{ + return _node == entry._node; +} diff --git a/src/DHTNodeLookupEntry.h b/src/DHTNodeLookupEntry.h new file mode 100644 index 00000000..e041f6b0 --- /dev/null +++ b/src/DHTNodeLookupEntry.h @@ -0,0 +1,54 @@ +/* */ +#ifndef _D_DHT_NODE_LOOKUP_ENTRY_H_ +#define _D_DHT_NODE_LOOKUP_ENTRY_H_ + +#include "common.h" +#include "DHTNodeDecl.h" + +class DHTNodeLookupEntry { +public: + DHTNodeHandle _node; + + bool _used; + + DHTNodeLookupEntry(const DHTNodeHandle& node); + + DHTNodeLookupEntry(); + + bool operator==(const DHTNodeLookupEntry& entry) const; +}; + +#endif // _D_DHT_NODE_LOOKUP_ENTRY_H_ diff --git a/src/DHTNodeLookupEntryDecl.h b/src/DHTNodeLookupEntryDecl.h new file mode 100644 index 00000000..0d1e54fa --- /dev/null +++ b/src/DHTNodeLookupEntryDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_NODE_LOOKUP_ENTRY_DECL_H_ +#define _D_DHT_NODE_LOOKUP_ENTRY_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTNodeLookupEntry; +typedef SharedHandle DHTNodeLookupEntryHandle; +typedef std::deque DHTNodeLookupEntries; + +#endif // _D_DHT_NODE_LOOKUP_ENTRY_DECL_H_ diff --git a/src/DHTNodeLookupTask.cc b/src/DHTNodeLookupTask.cc new file mode 100644 index 00000000..7770d55b --- /dev/null +++ b/src/DHTNodeLookupTask.cc @@ -0,0 +1,56 @@ +/* */ +#include "DHTNodeLookupTask.h" +#include "DHTMessageFactory.h" +#include "DHTFindNodeReplyMessage.h" +#include "DHTNode.h" +#include "DHTNodeLookupEntry.h" +#include "LogFactory.h" +#include "Util.h" + +DHTNodeLookupTask::DHTNodeLookupTask(const unsigned char* targetNodeID): + DHTAbstractNodeLookupTask(targetNodeID) +{} + +DHTNodes DHTNodeLookupTask::getNodesFromMessage(const DHTMessageHandle& message) +{ + SharedHandle m = message; + return m->getClosestKNodes(); +} + +DHTMessageHandle DHTNodeLookupTask::createMessage(const DHTNodeHandle& remoteNode) +{ + return _factory->createFindNodeMessage(remoteNode, _targetID); +} diff --git a/src/DHTNodeLookupTask.h b/src/DHTNodeLookupTask.h new file mode 100644 index 00000000..3fbf2ce7 --- /dev/null +++ b/src/DHTNodeLookupTask.h @@ -0,0 +1,49 @@ +/* */ +#ifndef _D_DHT_NODE_LOOKUP_TASK_H_ +#define _D_DHT_NODE_LOOKUP_TASK_H_ + +#include "DHTAbstractNodeLookupTask.h" + +class DHTNodeLookupTask:public DHTAbstractNodeLookupTask { +public: + DHTNodeLookupTask(const unsigned char* targetNodeID); + + virtual DHTNodes getNodesFromMessage(const DHTMessageHandle& message); + + virtual DHTMessageHandle createMessage(const DHTNodeHandle& remoteNode); +}; + +#endif // _D_DHT_NODE_LOOKUP_TASK_H_ diff --git a/src/DHTPeerAnnounceCommand.cc b/src/DHTPeerAnnounceCommand.cc new file mode 100644 index 00000000..e6272e54 --- /dev/null +++ b/src/DHTPeerAnnounceCommand.cc @@ -0,0 +1,68 @@ +/* */ +#include "DHTPeerAnnounceCommand.h" +#include "DHTPeerAnnounceStorage.h" +#include "DownloadEngine.h" +#include "SingletonHolder.h" +#include "RequestGroupMan.h" +#include "RecoverableException.h" +#include "message.h" + +DHTPeerAnnounceCommand::DHTPeerAnnounceCommand(int32_t cuid, DownloadEngine* e, time_t interval): + TimeBasedCommand(cuid, e, interval), + _peerAnnounceStorage(0) +{} + +DHTPeerAnnounceCommand::~DHTPeerAnnounceCommand() {} + +void DHTPeerAnnounceCommand::preProcess() +{ + _exit = _e->_requestGroupMan->downloadFinished() || _e->isHaltRequested(); +} + +void DHTPeerAnnounceCommand::process() +{ + try { + _peerAnnounceStorage->handleTimeout(); + } catch(RecoverableException* e) { + logger->error(EX_EXCEPTION_CAUGHT, e); + delete e; + } +} + +void DHTPeerAnnounceCommand::setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage) +{ + _peerAnnounceStorage = storage; +} diff --git a/src/DHTPeerAnnounceCommand.h b/src/DHTPeerAnnounceCommand.h new file mode 100644 index 00000000..6eec7717 --- /dev/null +++ b/src/DHTPeerAnnounceCommand.h @@ -0,0 +1,56 @@ +/* */ +#ifndef _D_DHT_PEER_ANNOUNCE_COMMAND_H_ +#define _D_DHT_PEER_ANNOUNCE_COMMAND_H_ + +#include "TimeBasedCommand.h" +#include "DHTPeerAnnounceStorageDecl.h" + +class DHTPeerAnnounceCommand:public TimeBasedCommand { +private: + DHTPeerAnnounceStorageHandle _peerAnnounceStorage; +public: + DHTPeerAnnounceCommand(int32_t cuid, DownloadEngine* e, time_t interval); + + virtual ~DHTPeerAnnounceCommand(); + + virtual void preProcess(); + + virtual void process(); + + void setPeerAnnounceStorage(const DHTPeerAnnounceStorageHandle& storage); +}; + +#endif // _D_DHT_PEER_ANNOUNCE_COMMAND_H_ diff --git a/src/DHTPeerAnnounceEntry.cc b/src/DHTPeerAnnounceEntry.cc new file mode 100644 index 00000000..74b27b29 --- /dev/null +++ b/src/DHTPeerAnnounceEntry.cc @@ -0,0 +1,121 @@ +/* */ +#include "DHTPeerAnnounceEntry.h" +#include "BtContext.h" +#include "Peer.h" +#include "BtRegistry.h" + +DHTPeerAnnounceEntry::DHTPeerAnnounceEntry(const unsigned char* infoHash): + _btCtx(0) +{ + memcpy(_infoHash, infoHash, DHT_ID_LENGTH); +} + +DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {} + +void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry) +{ + PeerAddrEntries::iterator i = find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry); + if(i == _peerAddrEntries.end()) { + _peerAddrEntries.push_back(entry); + } else { + (*i).notifyUpdate(); + } + notifyUpdate(); +} + +void DHTPeerAnnounceEntry::setBtContext(const BtContextHandle& btCtx) +{ + _btCtx = btCtx; +} + +size_t DHTPeerAnnounceEntry::countPeerAddrEntry() const +{ + return _peerAddrEntries.size(); +} + +const PeerAddrEntries& DHTPeerAnnounceEntry::getPeerAddrEntries() const +{ + return _peerAddrEntries; +} + +class FindStaleEntry { +private: + time_t _timeout; +public: + FindStaleEntry(time_t timeout):_timeout(timeout) {} + + bool operator()(const PeerAddrEntry& entry) const + { + if(entry.getLastUpdated().elapsed(_timeout)) { + return true; + } else { + return false; + } + } +}; + +void DHTPeerAnnounceEntry::removeStalePeerAddrEntry(time_t timeout) +{ + _peerAddrEntries.erase(remove_if(_peerAddrEntries.begin(), _peerAddrEntries.end(), + FindStaleEntry(timeout)), _peerAddrEntries.end()); +} + +bool DHTPeerAnnounceEntry::empty() const +{ + return _peerAddrEntries.empty() && _btCtx.isNull(); +} + +Peers DHTPeerAnnounceEntry::getPeers() const +{ + Peers peers; + for(PeerAddrEntries::const_iterator i = _peerAddrEntries.begin(); + i != _peerAddrEntries.end(); ++i) { + peers.push_back(new Peer((*i).getIPAddress(), (*i).getPort())); + } + if(!_btCtx.isNull()) { + PeerStorageHandle peerStorage = PEER_STORAGE(_btCtx); + if(!peerStorage.isNull()) { + const Peers& activePeers = peerStorage->getActivePeers(); + peers.insert(peers.end(), activePeers.begin(), activePeers.end()); + } + } + return peers; +} + +void DHTPeerAnnounceEntry::notifyUpdate() +{ + _lastUpdated.reset(); +} diff --git a/src/DHTPeerAnnounceEntry.h b/src/DHTPeerAnnounceEntry.h new file mode 100644 index 00000000..b4cb6d56 --- /dev/null +++ b/src/DHTPeerAnnounceEntry.h @@ -0,0 +1,91 @@ +/* */ +#ifndef _D_DHT_PEER_ANNOUNCE_ENTRY_H_ +#define _D_DHT_PEER_ANNOUNCE_ENTRY_H_ + +#include "common.h" +#include "DHTConstants.h" +#include "PeerAddrEntry.h" +#include "PeerDecl.h" +#include "TimeA2.h" + +class BtContext; +typedef SharedHandle BtContextHandle; + +class DHTPeerAnnounceEntry { +private: + unsigned char _infoHash[DHT_ID_LENGTH]; + + PeerAddrEntries _peerAddrEntries; + + BtContextHandle _btCtx; + + Time _lastUpdated; +public: + DHTPeerAnnounceEntry(const unsigned char* infoHash); + + ~DHTPeerAnnounceEntry(); + + // add peer addr entry. + // if it already exists, update "Last Updated" property. + void addPeerAddrEntry(const PeerAddrEntry& entry); + + void setBtContext(const BtContextHandle& btCtx); + + size_t countPeerAddrEntry() const; + + const PeerAddrEntries& getPeerAddrEntries() const; + + void removeStalePeerAddrEntry(time_t timeout); + + bool empty() const; + + const Time& getLastUpdated() const + { + return _lastUpdated; + } + + void notifyUpdate(); + + const unsigned char* getInfoHash() const + { + return _infoHash; + } + + Peers getPeers() const; + +}; + +#endif // _D_DHT_PEER_ANNOUNCE_ENTRY_H_ diff --git a/src/DHTPeerAnnounceEntryDecl.h b/src/DHTPeerAnnounceEntryDecl.h new file mode 100644 index 00000000..047c55f5 --- /dev/null +++ b/src/DHTPeerAnnounceEntryDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_PEER_ANNOUNCE_ENTRY_DECL_H_ +#define _D_DHT_PEER_ANNOUNCE_ENTRY_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTPeerAnnounceEntry; +typedef SharedHandle DHTPeerAnnounceEntryHandle; +typedef std::deque DHTPeerAnnounceEntries; + +#endif // _D_DHT_PEER_ANNOUNCE_ENTRY_DECL_H_ diff --git a/src/DHTPeerAnnounceStorage.cc b/src/DHTPeerAnnounceStorage.cc new file mode 100644 index 00000000..f36ef9ac --- /dev/null +++ b/src/DHTPeerAnnounceStorage.cc @@ -0,0 +1,165 @@ +/* */ +#include "DHTPeerAnnounceStorage.h" +#include "DHTPeerAnnounceEntry.h" +#include "Peer.h" +#include "BtContext.h" +#include "DHTConstants.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTTask.h" +#include "LogFactory.h" +#include "Util.h" + +DHTPeerAnnounceStorage::DHTPeerAnnounceStorage():_taskQueue(0), + _taskFactory(0), + _logger(LogFactory::getInstance()) {} + +DHTPeerAnnounceStorage::~DHTPeerAnnounceStorage() {} + +class FindPeerAnnounceEntry { +private: + unsigned char _infoHash[DHT_ID_LENGTH]; +public: + FindPeerAnnounceEntry(const unsigned char* infoHash) + { + memcpy(_infoHash, infoHash, DHT_ID_LENGTH); + } + + bool operator()(const DHTPeerAnnounceEntryHandle& entry) const + { + return memcmp(_infoHash, entry->getInfoHash(), DHT_ID_LENGTH) == 0; + } +}; + +DHTPeerAnnounceEntryHandle +DHTPeerAnnounceStorage::getPeerAnnounceEntry(const unsigned char* infoHash) +{ + DHTPeerAnnounceEntries::iterator i = + find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash)); + DHTPeerAnnounceEntryHandle entry = 0; + if(i == _entries.end()) { + entry = new DHTPeerAnnounceEntry(infoHash); + _entries.push_back(entry); + } else { + entry = *i; + } + return entry; +} + +void +DHTPeerAnnounceStorage::addPeerAnnounce(const unsigned char* infoHash, + const string& ipaddr, uint16_t port) +{ + _logger->debug("Adding %s:%u to peer announce list: infoHash=%s", + ipaddr.c_str(), port, Util::toHex(infoHash, DHT_ID_LENGTH).c_str()); + getPeerAnnounceEntry(infoHash)->addPeerAddrEntry(PeerAddrEntry(ipaddr, port)); +} + +// add peer announce as localhost downloading the content +void DHTPeerAnnounceStorage::addPeerAnnounce(const BtContextHandle& ctx) +{ + _logger->debug("Adding localhost to peer announce list: infoHash=%s", + ctx->getInfoHashAsString().c_str()); + getPeerAnnounceEntry(ctx->getInfoHash())->setBtContext(ctx); +} + +void DHTPeerAnnounceStorage::removePeerAnnounce(const BtContextHandle& ctx) +{ + DHTPeerAnnounceEntries::iterator i = + find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(ctx->getInfoHash())); + if(i != _entries.end()) { + (*i)->setBtContext(0); + if((*i)->empty()) { + _entries.erase(i); + } + } +} + +bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const +{ + return + find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash)) + != _entries.end(); +} + +Peers DHTPeerAnnounceStorage::getPeers(const unsigned char* infoHash) +{ + DHTPeerAnnounceEntries::iterator i = + find_if(_entries.begin(), _entries.end(), FindPeerAnnounceEntry(infoHash)); + if(i == _entries.end() || (*i)->empty()) { + return Peers(); + } + return (*i)->getPeers(); +} + +void DHTPeerAnnounceStorage::handleTimeout() +{ + _logger->debug("Now purge peer announces which are timed out."); + for(DHTPeerAnnounceEntries::iterator i = _entries.begin(); i != _entries.end();) { + (*i)->removeStalePeerAddrEntry(DHT_PEER_ANNOUNCE_PURGE_INTERVAL); + if((*i)->empty()) { + _logger->debug("1 entry purged: infoHash=%s", + Util::toHex((*i)->getInfoHash(), DHT_ID_LENGTH).c_str()); + i = _entries.erase(i); + } else { + ++i; + } + } +} + +void DHTPeerAnnounceStorage::announcePeer() +{ + _logger->debug("Now announcing peer."); + for(DHTPeerAnnounceEntries::iterator i = _entries.begin(); i != _entries.end(); ++i) { + if((*i)->getLastUpdated().elapsed(DHT_PEER_ANNOUNCE_INTERVAL)) { + (*i)->notifyUpdate(); + DHTTaskHandle task = _taskFactory->createPeerAnnounceTask((*i)->getInfoHash()); + _taskQueue->addPeriodicTask2(task); + _logger->debug("Added 1 peer announce: infoHash=%s", + Util::toHex((*i)->getInfoHash(), DHT_ID_LENGTH).c_str()); + } + } +} + +void DHTPeerAnnounceStorage::setTaskQueue(const DHTTaskQueueHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTPeerAnnounceStorage::setTaskFactory(const DHTTaskFactoryHandle& taskFactory) +{ + _taskFactory = taskFactory; +} diff --git a/src/DHTPeerAnnounceStorage.h b/src/DHTPeerAnnounceStorage.h new file mode 100644 index 00000000..93dbb73f --- /dev/null +++ b/src/DHTPeerAnnounceStorage.h @@ -0,0 +1,92 @@ +/* */ +#ifndef _D_DHT_PEER_ANNOUNCE_STORAGE_H_ +#define _D_DHT_PEER_ANNOUNCE_STORAGE_H_ + +#include "common.h" +#include "DHTPeerAnnounceStorageDecl.h" +#include "DHTPeerAnnounceEntryDecl.h" +#include "PeerDecl.h" +#include "BtContextDecl.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" + +class Logger; + +class DHTPeerAnnounceStorage { +private: + DHTPeerAnnounceEntries _entries; + + DHTPeerAnnounceEntryHandle getPeerAnnounceEntry(const unsigned char* infoHash); + + DHTTaskQueueHandle _taskQueue; + + DHTTaskFactoryHandle _taskFactory; + + const Logger* _logger; +public: + DHTPeerAnnounceStorage(); + + ~DHTPeerAnnounceStorage(); + + void addPeerAnnounce(const unsigned char* infoHash, + const string& ipaddr, uint16_t port); + + // add peer announce as localhost downloading the content + void addPeerAnnounce(const BtContextHandle& ctx); + + // give 0 to DHTPeerAnnounceEntry::setBtContext(). + // If DHTPeerAnnounceEntry is empty, it is erased. + void removePeerAnnounce(const BtContextHandle& ctx); + + bool contains(const unsigned char* infoHash) const; + + Peers getPeers(const unsigned char* infoHash); + + // drop peer announce entry which is not updated in the past + // DHT_PEER_ANNOUNCE_PURGE_INTERVAL seconds. + void handleTimeout(); + + // announce peer in every DHT_PEER_ANNOUNCE_PURGE_INTERVAL. + // The torrents which are announced in the past DHT_PEER_ANNOUNCE_PURGE_INTERVAL + // are excluded from announce. + void announcePeer(); + + void setTaskQueue(const DHTTaskQueueHandle& taskQueue); + + void setTaskFactory(const DHTTaskFactoryHandle& taskFactory); +}; + +#endif // _D_DHT_PEER_ANNOUNCE_STORAGE_H_ diff --git a/src/DHTPeerAnnounceStorageDecl.h b/src/DHTPeerAnnounceStorageDecl.h new file mode 100644 index 00000000..132f8742 --- /dev/null +++ b/src/DHTPeerAnnounceStorageDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_PEER_ANNOUNCE_STORAGE_DECL_H_ +#define _D_DHT_PEER_ANNOUNCE_STORAGE_DECL_H_ + +#include "SharedHandle.h" + +class DHTPeerAnnounceStorage; +typedef SharedHandle DHTPeerAnnounceStorageHandle; + +#endif // _D_DHT_PEER_ANNOUNCE_STORAGE_DECL_H_ diff --git a/src/DHTPeerLookupTask.cc b/src/DHTPeerLookupTask.cc new file mode 100644 index 00000000..f16409e3 --- /dev/null +++ b/src/DHTPeerLookupTask.cc @@ -0,0 +1,102 @@ +/* */ +#include "DHTPeerLookupTask.h" +#include "Peer.h" +#include "DHTGetPeersReplyMessage.h" +#include "Logger.h" +#include "DHTMessageFactory.h" +#include "DHTNode.h" +#include "DHTNodeLookupEntry.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallback.h" +#include "BtRegistry.h" +#include "PeerStorage.h" +#include "BtRuntime.h" +#include "BtContext.h" +#include "Util.h" +#include "DHTBucket.h" + +DHTPeerLookupTask::DHTPeerLookupTask(const BtContextHandle& btContext): + DHTAbstractNodeLookupTask(btContext->getInfoHash()), + _ctx(btContext), + _peerStorage(PEER_STORAGE(btContext)), + _btRuntime(BT_RUNTIME(btContext)) {} + +DHTNodes DHTPeerLookupTask::getNodesFromMessage(const DHTMessageHandle& message) +{ + SharedHandle m = message; + return m->getClosestKNodes(); +} + +void DHTPeerLookupTask::onReceivedInternal(const DHTMessageHandle& message) +{ + SharedHandle m = message; + + DHTNodeHandle remoteNode = m->getRemoteNode(); + _tokenStorage[Util::toHex(remoteNode->getID(), DHT_ID_LENGTH)] = m->getToken(); + + _peerStorage->addPeer(m->getValues()); + _peers.insert(_peers.end(), m->getValues().begin(), m->getValues().end()); + _logger->info("Received %u peers.", m->getValues().size()); +} + +DHTMessageHandle DHTPeerLookupTask::createMessage(const DHTNodeHandle& remoteNode) +{ + return _factory->createGetPeersMessage(remoteNode, _targetID); +} + +void DHTPeerLookupTask::onFinish() +{ + // send announce_peer message to K closest nodes + size_t num = DHTBucket::K; + for(DHTNodeLookupEntries::const_iterator i = _entries.begin(); + i != _entries.end() && num > 0; ++i, --num) { + if((*i)->_used) { + const DHTNodeHandle& node = (*i)->_node; + DHTMessageHandle m = + _factory->createAnnouncePeerMessage(node, + _ctx->getInfoHash(), + _btRuntime->getListenPort(), + _tokenStorage[Util::toHex(node->getID(), + DHT_ID_LENGTH)]); + _dispatcher->addMessageToQueue(m); + } + } +} + +const Peers& DHTPeerLookupTask::getPeers() const +{ + return _peers; +} diff --git a/src/DHTPeerLookupTask.h b/src/DHTPeerLookupTask.h new file mode 100644 index 00000000..396b2033 --- /dev/null +++ b/src/DHTPeerLookupTask.h @@ -0,0 +1,73 @@ +/* */ +#ifndef _D_DHT_PEER_LOOKUP_TASK_H_ +#define _D_DHT_PEER_LOOKUP_TASK_H_ + +#include "DHTAbstractNodeLookupTask.h" +#include "BtContextDecl.h" +#include "PeerDecl.h" +#include + +class PeerStorage; +typedef SharedHandle PeerStorageHandle; +class BtRuntime; +typedef SharedHandle BtRuntimeHandle; + +class DHTPeerLookupTask:public DHTAbstractNodeLookupTask { +private: + std::map _tokenStorage; + + Peers _peers; + + BtContextHandle _ctx; + + PeerStorageHandle _peerStorage; + + BtRuntimeHandle _btRuntime; +public: + DHTPeerLookupTask(const BtContextHandle& btContext); + + virtual DHTNodes getNodesFromMessage(const DHTMessageHandle& message); + + virtual void onReceivedInternal(const DHTMessageHandle& message); + + virtual DHTMessageHandle createMessage(const DHTNodeHandle& remoteNode); + + virtual void onFinish(); + + const Peers& getPeers() const; +}; + +#endif // _D_DHT_PEER_LOOKUP_TASK_H_ diff --git a/src/DHTPingMessage.cc b/src/DHTPingMessage.cc new file mode 100644 index 00000000..844a4a9e --- /dev/null +++ b/src/DHTPingMessage.cc @@ -0,0 +1,70 @@ +/* */ +#include "DHTPingMessage.h" +#include "DHTNode.h" +#include "Data.h" +#include "DHTConstants.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageFactory.h" +#include "DHTMessageCallback.h" + +DHTPingMessage::DHTPingMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + DHTQueryMessage(localNode, remoteNode, transactionID) {} + +DHTPingMessage::~DHTPingMessage() {} + +void DHTPingMessage::doReceivedAction() +{ + // send back ping reply + DHTMessageHandle reply = _factory->createPingReplyMessage(_remoteNode, _localNode->getID(), _transactionID); + _dispatcher->addMessageToQueue(reply); +} + +Dictionary* DHTPingMessage::getArgument() +{ + Dictionary* a = new Dictionary(); + a->put("id", new Data(reinterpret_cast(_localNode->getID()), + DHT_ID_LENGTH)); + return a; +} + +string DHTPingMessage::getMessageType() const +{ + return "ping"; +} + +void DHTPingMessage::validate() const {} diff --git a/src/DHTPingMessage.h b/src/DHTPingMessage.h new file mode 100644 index 00000000..16b5d8ab --- /dev/null +++ b/src/DHTPingMessage.h @@ -0,0 +1,57 @@ +/* */ +#ifndef _D_DHT_PING_MESSAGE_H_ +#define _D_DHT_PING_MESSAGE_H_ + +#include "DHTQueryMessage.h" + +class DHTPingMessage:public DHTQueryMessage { +public: + DHTPingMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID = ""); + + virtual ~DHTPingMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getArgument(); + + virtual string getMessageType() const; + + virtual void validate() const; +}; + +#endif // _D_DHT_PING_MESSAGE_H_ diff --git a/src/DHTPingReplyMessage.cc b/src/DHTPingReplyMessage.cc new file mode 100644 index 00000000..f8ac1848 --- /dev/null +++ b/src/DHTPingReplyMessage.cc @@ -0,0 +1,65 @@ +/* */ +#include "DHTPingReplyMessage.h" +#include "DHTNode.h" +#include "Dictionary.h" +#include "Data.h" + +DHTPingReplyMessage::DHTPingReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* id, + const string& transactionID): + DHTResponseMessage(localNode, remoteNode, transactionID) +{ + memcpy(_id, id, DHT_ID_LENGTH); +} + +DHTPingReplyMessage::~DHTPingReplyMessage() {} + +void DHTPingReplyMessage::doReceivedAction() {} + +Dictionary* DHTPingReplyMessage::getResponse() +{ + Dictionary* r = new Dictionary(); + r->put("id", new Data(_id, DHT_ID_LENGTH)); + return r; +} + +string DHTPingReplyMessage::getMessageType() const +{ + return "ping"; +} + +void DHTPingReplyMessage::validate() const {} diff --git a/src/DHTPingReplyMessage.h b/src/DHTPingReplyMessage.h new file mode 100644 index 00000000..33659956 --- /dev/null +++ b/src/DHTPingReplyMessage.h @@ -0,0 +1,66 @@ +/* */ +#ifndef _D_DHT_PING_REPLY_MESSAGE_H_ +#define _D_DHT_PING_REPLY_MESSAGE_H_ + +#include "DHTResponseMessage.h" +#include "DHTConstants.h" + +class DHTPingReplyMessage:public DHTResponseMessage { +private: + unsigned char _id[DHT_ID_LENGTH]; +public: + DHTPingReplyMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const unsigned char* id, + const string& transactionID); + + virtual ~DHTPingReplyMessage(); + + virtual void doReceivedAction(); + + virtual Dictionary* getResponse(); + + virtual string getMessageType() const; + + virtual void validate() const; + + const unsigned char* getRemoteID() + { + return _id; + } +}; + +#endif // _D_DHT_PING_REPLY_MESSAGE_H_ diff --git a/src/DHTPingTask.cc b/src/DHTPingTask.cc new file mode 100644 index 00000000..9f31b388 --- /dev/null +++ b/src/DHTPingTask.cc @@ -0,0 +1,80 @@ +/* */ +#include "DHTPingTask.h" +#include "DHTMessageCallbackImpl.h" +#include "DHTMessage.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTNode.h" +#include "DHTConstants.h" + +DHTPingTask::DHTPingTask(const DHTNodeHandle& remoteNode, size_t numMaxRetry): + _remoteNode(remoteNode), + _numMaxRetry(numMaxRetry), + _numRetry(0), + _pingSuccessful(false), + _timeout(DHT_MESSAGE_TIMEOUT) +{} + +DHTPingTask::~DHTPingTask() {} + +void DHTPingTask::startup() +{ + DHTMessageHandle m = _factory->createPingMessage(_remoteNode); + _dispatcher->addMessageToQueue(m, _timeout, new DHTMessageCallbackImpl(this)); +} + +void DHTPingTask::onReceived(const DHTMessageHandle& message) +{ + _pingSuccessful = true; + _finished = true; +} + +void DHTPingTask::onTimeout(const DHTNodeHandle& node) +{ + ++_numRetry; + if(_numRetry >= _numMaxRetry) { + _pingSuccessful = false; + _finished = true; + } else { + DHTMessageHandle m = _factory->createPingMessage(_remoteNode); + _dispatcher->addMessageToQueue(m, _timeout, new DHTMessageCallbackImpl(this)); + } +} + +bool DHTPingTask::isPingSuccessful() const +{ + return _pingSuccessful; +} diff --git a/src/DHTPingTask.h b/src/DHTPingTask.h new file mode 100644 index 00000000..7e84cbc3 --- /dev/null +++ b/src/DHTPingTask.h @@ -0,0 +1,71 @@ +/* */ +#ifndef _D_DHT_PING_TASK_H_ +#define _D_DHT_PING_TASK_H_ + +#include "DHTAbstractTask.h" +#include "DHTMessageCallbackListener.h" + +class DHTPingTask:public DHTAbstractTask, public DHTMessageCallbackListener { +protected: + DHTNodeHandle _remoteNode; + + size_t _numMaxRetry; + + size_t _numRetry; + + bool _pingSuccessful; + + time_t _timeout; +public: + DHTPingTask(const DHTNodeHandle& remoteNode, size_t numMaxRetry = 0); + + virtual ~DHTPingTask(); + + virtual void startup(); + + virtual void onReceived(const DHTMessageHandle& message); + + virtual void onTimeout(const DHTNodeHandle& node); + + void setTimeout(time_t timeout) + { + _timeout = timeout; + } + + bool isPingSuccessful() const; +}; + +#endif // _D_DHT_PING_TASK_H_ diff --git a/src/DHTQueryMessage.cc b/src/DHTQueryMessage.cc new file mode 100644 index 00000000..a6862230 --- /dev/null +++ b/src/DHTQueryMessage.cc @@ -0,0 +1,70 @@ +/* */ +#include "DHTQueryMessage.h" +#include "DHTNode.h" +#include "Util.h" +#include "Data.h" + +DHTQueryMessage::DHTQueryMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + DHTAbstractMessage(localNode, remoteNode, transactionID) {} + +DHTQueryMessage::~DHTQueryMessage() {} + +string DHTQueryMessage::getType() const +{ + return "q"; +} + +void DHTQueryMessage::fillMessage(Dictionary* message) +{ + message->put("q", new Data(getMessageType())); + message->put("a", getArgument()); +} + +bool DHTQueryMessage::isReply() const +{ + return false; +} + +string DHTQueryMessage::toString() const +{ + return "dht query "+getMessageType()+ + " TransactionID="+Util::toHex(_transactionID)+ + " Remote:"+ + _remoteNode->getIPAddress()+":"+Util::itos(_remoteNode->getPort())+ + ", id="+Util::toHex(_remoteNode->getID(), DHT_ID_LENGTH); +} diff --git a/src/DHTQueryMessage.h b/src/DHTQueryMessage.h new file mode 100644 index 00000000..29057f67 --- /dev/null +++ b/src/DHTQueryMessage.h @@ -0,0 +1,59 @@ +/* */ +#ifndef _D_DHT_QUERY_MESSAGE_H_ +#define _D_DHT_QUERY_MESSAGE_H_ + +#include "DHTAbstractMessage.h" + +class DHTQueryMessage:public DHTAbstractMessage { +public: + DHTQueryMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID = ""); + + virtual ~DHTQueryMessage(); + + virtual string getType() const; + + virtual void fillMessage(Dictionary* message); + + virtual Dictionary* getArgument() = 0; + + virtual bool isReply() const; + + virtual string toString() const; +}; + +#endif // _D_DHT_QUERY_MESSAGE_H_ diff --git a/src/DHTRegistry.cc b/src/DHTRegistry.cc new file mode 100644 index 00000000..7210c0b3 --- /dev/null +++ b/src/DHTRegistry.cc @@ -0,0 +1,75 @@ +/* */ +#include "DHTRegistry.h" +#include "DHTNode.h" +#include "DHTRoutingTable.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTTokenTracker.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageReceiver.h" +#include "DHTMessageFactory.h" + +DHTNodeHandle DHTRegistry::_localNode = 0; + +DHTRoutingTableHandle DHTRegistry::_routingTable = 0; + +DHTTaskQueueHandle DHTRegistry::_taskQueue = 0; + +DHTTaskFactoryHandle DHTRegistry::_taskFactory = 0; + +DHTPeerAnnounceStorageHandle DHTRegistry::_peerAnnounceStorage = 0; + +DHTTokenTrackerHandle DHTRegistry::_tokenTracker = 0; + +DHTMessageDispatcherHandle DHTRegistry::_messageDispatcher = 0; + +DHTMessageReceiverHandle DHTRegistry::_messageReceiver = 0; + +DHTMessageFactoryHandle DHTRegistry::_messageFactory = 0; + +void DHTRegistry::clear() +{ + _localNode = 0; + _routingTable = 0; + _taskQueue = 0; + _taskFactory = 0; + _peerAnnounceStorage = 0; + _tokenTracker = 0; + _messageDispatcher = 0; + _messageReceiver = 0; + _messageFactory = 0; +} diff --git a/src/DHTRegistry.h b/src/DHTRegistry.h new file mode 100644 index 00000000..2962b4ee --- /dev/null +++ b/src/DHTRegistry.h @@ -0,0 +1,74 @@ +/* */ +#ifndef _D_DHT_REGISTRY_H_ +#define _D_DHT_REGISTRY_H_ + +#include "common.h" +#include "DHTNodeDecl.h" +#include "DHTRoutingTableDecl.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" +#include "DHTPeerAnnounceStorageDecl.h" +#include "DHTTokenTrackerDecl.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTMessageReceiverDecl.h" +#include "DHTMessageFactoryDecl.h" + +class DHTRegistry { +public: + static DHTNodeHandle _localNode; + + static DHTRoutingTableHandle _routingTable; + + static DHTTaskQueueHandle _taskQueue; + + static DHTTaskFactoryHandle _taskFactory; + + static DHTPeerAnnounceStorageHandle _peerAnnounceStorage; + + static DHTTokenTrackerHandle _tokenTracker; + + static DHTMessageDispatcherHandle _messageDispatcher; + + static DHTMessageReceiverHandle _messageReceiver; + + static DHTMessageFactoryHandle _messageFactory; + + static void clear(); +private: + DHTRegistry(); +}; + +#endif // _D_DHT_REGISTRY_H_ diff --git a/src/DHTReplaceNodeTask.cc b/src/DHTReplaceNodeTask.cc new file mode 100644 index 00000000..16d5254d --- /dev/null +++ b/src/DHTReplaceNodeTask.cc @@ -0,0 +1,91 @@ +/* */ +#include "DHTReplaceNodeTask.h" +#include "DHTBucket.h" +#include "DHTNode.h" +#include "DHTMessage.h" +#include "DHTMessageFactory.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageCallbackImpl.h" +#include "Logger.h" + +DHTReplaceNodeTask::DHTReplaceNodeTask(const DHTBucketHandle& bucket, + const DHTNodeHandle& newNode): + _bucket(bucket), + _newNode(newNode), + _numRetry(0), + _timeout(DHT_MESSAGE_TIMEOUT) +{} + +DHTReplaceNodeTask::~DHTReplaceNodeTask() {} + +void DHTReplaceNodeTask::startup() +{ + sendMessage(); +} + +void DHTReplaceNodeTask::sendMessage() +{ + DHTNodeHandle questionableNode = _bucket->getLRUQuestionableNode(); + if(questionableNode.isNull()) { + _finished = true; + } else { + DHTMessageHandle m = _factory->createPingMessage(questionableNode); + _dispatcher->addMessageToQueue(m, _timeout, new DHTMessageCallbackImpl(this)); + } +} + +void DHTReplaceNodeTask::onReceived(const DHTMessageHandle& message) +{ + _logger->info("ReplaceNode: Ping reply received from %s.", + message->getRemoteNode()->toString().c_str()); + _finished = true; +} + +void DHTReplaceNodeTask::onTimeout(const DHTNodeHandle& node) +{ + ++_numRetry; + if(_numRetry >= MAX_RETRY) { + _logger->info("ReplaceNode: Ping failed %u times. Replace %s with %s.", + _numRetry, node->toString().c_str(), _newNode->toString().c_str()); + node->markBad(); + _bucket->addNode(_newNode); + _finished = true; + } else { + _logger->info("ReplaceNode: Ping reply timeout from %s. Try once more.", + node->toString().c_str()); + sendMessage(); + } +} diff --git a/src/DHTReplaceNodeTask.h b/src/DHTReplaceNodeTask.h new file mode 100644 index 00000000..812c3216 --- /dev/null +++ b/src/DHTReplaceNodeTask.h @@ -0,0 +1,67 @@ +/* */ +#ifndef _D_DHT_REPLACE_NODE_TASK_H_ +#define _D_DHT_REPLACE_NODE_TASK_H_ + +#include "DHTAbstractTask.h" +#include "DHTMessageCallbackListener.h" +#include "DHTBucketDecl.h" + +class DHTReplaceNodeTask:public DHTAbstractTask, public DHTMessageCallbackListener { +private: + DHTBucketHandle _bucket; + + DHTNodeHandle _newNode; + + static const size_t MAX_RETRY = 2; + + size_t _numRetry; + + time_t _timeout; + + void sendMessage(); +public: + DHTReplaceNodeTask(const DHTBucketHandle& bucket, const DHTNodeHandle& newNode); + + virtual ~DHTReplaceNodeTask(); + + virtual void startup(); + + virtual void onReceived(const DHTMessageHandle& message); + + virtual void onTimeout(const DHTNodeHandle& node); +}; + +#endif // _D_DHT_REPLACE_NODE_TASK_H_ diff --git a/src/DHTResponseMessage.cc b/src/DHTResponseMessage.cc new file mode 100644 index 00000000..6c9f4734 --- /dev/null +++ b/src/DHTResponseMessage.cc @@ -0,0 +1,69 @@ +/* */ +#include "DHTResponseMessage.h" +#include "DHTNode.h" +#include "Util.h" +#include "Data.h" + +DHTResponseMessage::DHTResponseMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID): + DHTAbstractMessage(localNode, remoteNode, transactionID) {} + +DHTResponseMessage::~DHTResponseMessage() {} + +string DHTResponseMessage::getType() const +{ + return "r"; +} + +void DHTResponseMessage::fillMessage(Dictionary* message) +{ + message->put("r", getResponse()); +} + +bool DHTResponseMessage::isReply() const +{ + return true; +} + +string DHTResponseMessage::toString() const +{ + return "dht response "+getMessageType()+ + " TransactionID="+Util::toHex(_transactionID)+ + " Remote:"+ + _remoteNode->getIPAddress()+":"+Util::itos(_remoteNode->getPort())+ + ", id="+Util::toHex(_remoteNode->getID(), DHT_ID_LENGTH); +} diff --git a/src/DHTResponseMessage.h b/src/DHTResponseMessage.h new file mode 100644 index 00000000..a41335ea --- /dev/null +++ b/src/DHTResponseMessage.h @@ -0,0 +1,59 @@ +/* */ +#ifndef _D_DHT_RESPONSE_MESSAGE_H_ +#define _D_DHT_RESPONSE_MESSAGE_H_ + +#include "DHTAbstractMessage.h" + +class DHTResponseMessage:public DHTAbstractMessage { +public: + DHTResponseMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID); + + virtual ~DHTResponseMessage(); + + virtual string getType() const; + + virtual void fillMessage(Dictionary* message); + + virtual Dictionary* getResponse() = 0; + + virtual bool isReply() const; + + virtual string toString() const; +}; + +#endif // _D_DHT_RESPONSE_MESSAGE_H_ diff --git a/src/DHTRoutingTable.cc b/src/DHTRoutingTable.cc new file mode 100644 index 00000000..bbf6e1f2 --- /dev/null +++ b/src/DHTRoutingTable.cc @@ -0,0 +1,171 @@ +/* */ +#include "DHTRoutingTable.h" +#include "DHTNode.h" +#include "DHTBucket.h" +#include "Util.h" +#include "LogFactory.h" +#include "BNode.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTTask.h" + +DHTRoutingTable::DHTRoutingTable(const DHTNodeHandle& localNode): + _localNode(localNode), + _root(new BNode(new DHTBucket(localNode))), + _numBucket(1), + _taskQueue(0), + _taskFactory(0), + _logger(LogFactory::getInstance()) +{} + +DHTRoutingTable::~DHTRoutingTable() +{ + delete _root; +} + +bool DHTRoutingTable::addNode(const DHTNodeHandle& node) +{ + return addNode(node, false); +} + +bool DHTRoutingTable::addGoodNode(const DHTNodeHandle& node) +{ + return addNode(node, true); +} + +bool DHTRoutingTable::addNode(const DHTNodeHandle& node, bool good) +{ + _logger->debug("Trying to add node:%s", node->toString().c_str()); + BNode* bnode = BNode::findBNodeFor(_root, node->getID()); + DHTBucketHandle bucket = bnode->getBucket(); + while(1) { + if(bucket->addNode(node)) { + _logger->debug("Added DHTNode."); + return true; + } else if(bucket->splitAllowed()) { + _logger->debug("Splitting bucket. Range:%s-%s", + Util::toHex(bucket->getMinID(), DHT_ID_LENGTH).c_str(), + Util::toHex(bucket->getMaxID(), DHT_ID_LENGTH).c_str()); + DHTBucketHandle r = bucket->split(); + + bnode->setBucket(0); + BNode* lbnode = new BNode(bucket); + BNode* rbnode = new BNode(r); + bnode->setLeft(lbnode); + bnode->setRight(rbnode); + ++_numBucket; + + if(r->isInRange(node)) { + bucket = r; + bnode = rbnode; + } else { + bnode = lbnode; + } + } else { + if(good && bucket->containsQuestionableNode()) { + _logger->debug("Issuing ReplaceNodeTask: new node=%s", node->toString().c_str()); + _taskQueue->addImmediateTask(_taskFactory->createReplaceNodeTask(bucket, node)); + } + return false; + } + } + return false; +} + +DHTNodes DHTRoutingTable::getClosestKNodes(const unsigned char* key) const +{ + return BNode::findClosestKNodes(_root, key); +} + +size_t DHTRoutingTable::countBucket() const +{ + return _numBucket; +} + +void DHTRoutingTable::showBuckets() const +{/* + for(DHTBuckets::const_iterator itr = _buckets.begin(); itr != _buckets.end(); ++itr) { + cerr << "prefix = " << (*itr)->getPrefixLength() << ", " + << "nodes = " << (*itr)->countNode() << endl; + } + */ +} + +DHTBucketHandle DHTRoutingTable::getBucketFor(const unsigned char* nodeID) const +{ + return BNode::findBucketFor(_root, nodeID); +} + +DHTBucketHandle DHTRoutingTable::getBucketFor(const DHTNodeHandle& node) const +{ + return getBucketFor(node->getID()); +} + +DHTNodeHandle DHTRoutingTable::getNode(const unsigned char* nodeID, const string& ipaddr, uint16_t port) const +{ + DHTBucketHandle bucket = getBucketFor(nodeID); + return bucket->getNode(nodeID, ipaddr, port); +} + +void DHTRoutingTable::dropNode(const DHTNodeHandle& node) +{ + getBucketFor(node)->dropNode(node); +} +/* +void DHTRoutingTable::moveBucketHead(const DHTNodeHandle& node) +{ + getBucketFor(node)->moveToHead(node); +} +*/ +void DHTRoutingTable::moveBucketTail(const DHTNodeHandle& node) +{ + getBucketFor(node)->moveToTail(node); +} + +DHTBuckets DHTRoutingTable::getBuckets() const +{ + return BNode::enumerateBucket(_root); +} + +void DHTRoutingTable::setTaskQueue(const DHTTaskQueueHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTRoutingTable::setTaskFactory(const DHTTaskFactoryHandle& taskFactory) +{ + _taskFactory = taskFactory; +} diff --git a/src/DHTRoutingTable.h b/src/DHTRoutingTable.h new file mode 100644 index 00000000..7afa9209 --- /dev/null +++ b/src/DHTRoutingTable.h @@ -0,0 +1,97 @@ +/* */ +#ifndef _D_DHT_ROUTING_TABLE_H_ +#define _D_DHT_ROUTING_TABLE_H_ + +#include "common.h" +#include "DHTBucketDecl.h" +#include "DHTNodeDecl.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" + +class BNode; + +class Logger; + +class DHTRoutingTable { +private: + DHTNodeHandle _localNode; + + BNode* _root; + + size_t _numBucket; + + DHTTaskQueueHandle _taskQueue; + + DHTTaskFactoryHandle _taskFactory; + + const Logger* _logger; + + bool addNode(const DHTNodeHandle& node, bool good); +public: + DHTRoutingTable(const DHTNodeHandle& localNode); + + ~DHTRoutingTable(); + + bool addNode(const DHTNodeHandle& node); + + bool addGoodNode(const DHTNodeHandle& node); + + DHTNodes getClosestKNodes(const unsigned char* key) const; + + size_t countBucket() const; + + void showBuckets() const; + + void dropNode(const DHTNodeHandle& node); + + void moveBucketHead(const DHTNodeHandle& node); + + void moveBucketTail(const DHTNodeHandle& node); + + DHTBucketHandle getBucketFor(const unsigned char* nodeID) const; + + DHTBucketHandle getBucketFor(const DHTNodeHandle& node) const; + + DHTNodeHandle getNode(const unsigned char* id, const string& ipaddr, uint16_t port) const; + + DHTBuckets getBuckets() const; + + void setTaskQueue(const DHTTaskQueueHandle& taskQueue); + + void setTaskFactory(const DHTTaskFactoryHandle& taskFactory); +}; + +#endif // _D_DHT_ROUTING_TABLE_H_ diff --git a/src/DHTRoutingTableDecl.h b/src/DHTRoutingTableDecl.h new file mode 100644 index 00000000..517dbf27 --- /dev/null +++ b/src/DHTRoutingTableDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_ROUTING_TABLE_DECL_H_ +#define _D_DHT_ROUTING_TABLE_DECL_H_ + +#include "SharedHandle.h" + +class DHTRoutingTable; +typedef SharedHandle DHTRoutingTableHandle; + +#endif // _D_DHT_ROUTING_TABLE_DECL_H_ diff --git a/src/DHTRoutingTableDeserializer.cc b/src/DHTRoutingTableDeserializer.cc new file mode 100644 index 00000000..17b981f4 --- /dev/null +++ b/src/DHTRoutingTableDeserializer.cc @@ -0,0 +1,134 @@ +/* */ +#include "DHTRoutingTableDeserializer.h" +#include "DHTNode.h" +#include "DHTConstants.h" +#include "PeerMessageUtil.h" +#include "DlAbortEx.h" +#include +#include +#include +#include + +DHTRoutingTableDeserializer::DHTRoutingTableDeserializer(): + _localNode(0) {} + +DHTRoutingTableDeserializer::~DHTRoutingTableDeserializer() {} + +DHTNodeHandle DHTRoutingTableDeserializer::getLocalNode() const +{ + return _localNode; +} + +const DHTNodes& DHTRoutingTableDeserializer::getNodes() const +{ + return _nodes; +} + +void DHTRoutingTableDeserializer::deserialize(istream& in) +{ + try { + char header[8]; + memset(header, 0, sizeof(header)); + // magic + header[0] = 0xa1; + header[1] = 0xa2; + // format ID + header[2] = 0x02; + // version + header[6] = 0; + header[7] = 0x01; + + char zero[8]; + memset(zero, 0, sizeof(zero)); + + char buf[26]; + // header + in.read(buf, 8); + if(memcmp(header, buf, 8) != 0) { + throw new DlAbortEx("Failed to load DHT routing table. cause:%s", + "bad header"); + } + // time + in.read(buf, 4); + _serializedTime.setTimeInSec(ntohl(*reinterpret_cast(buf))); + // 4bytes reserved + in.read(buf, 4); + + // localnode + // 8bytes reserved + in.read(buf, 8); + // localnode ID + in.read(buf, DHT_ID_LENGTH); + DHTNodeHandle localNode = new DHTNode(reinterpret_cast(buf)); + // 4bytes reserved + in.read(buf, 4); + + // number of nodes + in.read(buf, 4); + uint32_t numNodes = ntohl(*reinterpret_cast(buf)); + // 4bytes reserved + in.read(buf, 4); + + // nodes + for(size_t i = 0; i < numNodes; ++i) { + // 6bytes compact peer info + in.read(buf, 6); + if(memcmp(zero, buf, 6) == 0) { + // skip this entry + in.read(buf, 26); + continue; + } + pair peer = PeerMessageUtil::unpackcompact(buf); + // 2bytes reserved + in.read(buf, 2); + // localnode ID + in.read(buf, DHT_ID_LENGTH); + + DHTNodeHandle node = new DHTNode(reinterpret_cast(buf)); + node->setIPAddress(peer.first); + node->setPort(peer.second); + // 4bytes reserved + in.read(buf, 4); + + _nodes.push_back(node); + } + _localNode = localNode; + } catch(ios::failure const& exception) { + _nodes.clear(); + throw new DlAbortEx("Failed to load DHT routing table. cause:%s", + strerror(errno)); + } +} diff --git a/src/DHTRoutingTableDeserializer.h b/src/DHTRoutingTableDeserializer.h new file mode 100644 index 00000000..e3122f55 --- /dev/null +++ b/src/DHTRoutingTableDeserializer.h @@ -0,0 +1,67 @@ +/* */ +#ifndef _D_DHT_ROUTING_TABLE_DESERIALIZER_H_ +#define _D_DHT_ROUTING_TABLE_DESERIALIZER_H_ + +#include "common.h" +#include "DHTNodeDecl.h" +#include "TimeA2.h" +#include + +class DHTRoutingTableDeserializer { +private: + DHTNodeHandle _localNode; + + DHTNodes _nodes; + + Time _serializedTime; +public: + DHTRoutingTableDeserializer(); + + ~DHTRoutingTableDeserializer(); + + DHTNodeHandle getLocalNode() const; + + const DHTNodes& getNodes() const; + + Time getSerializedTime() const + { + return _serializedTime; + } + + void deserialize(istream& in); +}; + +#endif // _D_DHT_ROUTING_TABLE_DESERIALIZER_H_ diff --git a/src/DHTRoutingTableSerializer.cc b/src/DHTRoutingTableSerializer.cc new file mode 100644 index 00000000..cda73ef9 --- /dev/null +++ b/src/DHTRoutingTableSerializer.cc @@ -0,0 +1,116 @@ +/* */ +#include "DHTRoutingTableSerializer.h" +#include "DHTNode.h" +#include "DlAbortEx.h" +#include "DHTConstants.h" +#include "PeerMessageUtil.h" +#include +#include +#include +#include + +DHTRoutingTableSerializer::DHTRoutingTableSerializer():_localNode(0) {} + +DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {} + +void DHTRoutingTableSerializer::setLocalNode(const DHTNodeHandle& localNode) +{ + _localNode = localNode; +} + +void DHTRoutingTableSerializer::setNodes(const DHTNodes& nodes) +{ + _nodes = nodes; +} + +void DHTRoutingTableSerializer::serialize(ostream& o) +{ + char header[8]; + memset(header, 0, sizeof(header)); + // magic + header[0] = 0xa1; + header[1] = 0xa2; + // format ID + header[2] = 0x02; + // version + header[6] = 0; + header[7] = 0x01; + + char zero[8]; + memset(zero, 0, sizeof(zero)); + try { + o.write(header, 8); + // write save date + uint32_t ntime = htonl(Time().getTime()); + o.write(reinterpret_cast(&ntime), sizeof(uint32_t)); + // 4bytes reserved + o.write(zero, 4); + + // localnode + // 8bytes reserved + o.write(zero, 8); + // 20bytes localnode ID + o.write(reinterpret_cast(_localNode->getID()), DHT_ID_LENGTH); + // 4bytes reserved + o.write(zero, 4); + + // number of nodes + uint32_t numNodes = htonl(_nodes.size()); + o.write(reinterpret_cast(&numNodes), sizeof(uint32_t)); + // 4bytes reserved + o.write(zero, 4); + + // nodes + for(DHTNodes::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i) { + const DHTNodeHandle& node = *i; + // 6bytes: write IP address + port in Compact IP-address/port info form. + char compactPeer[6]; + if(!PeerMessageUtil::createcompact(compactPeer, node->getIPAddress(), node->getPort())) { + memset(compactPeer, 0, 6); + } + o.write(compactPeer, 6); + // 2bytes reserved + o.write(zero, 2); + // 20bytes: node ID + o.write(reinterpret_cast(node->getID()), DHT_ID_LENGTH); + // 4bytes reserved + o.write(zero, 4); + } + } catch(ios::failure const& exception) { + throw new DlAbortEx("Failed to save DHT routing table. cause:%s", + strerror(errno)); + } +} diff --git a/src/DHTRoutingTableSerializer.h b/src/DHTRoutingTableSerializer.h new file mode 100644 index 00000000..9121379d --- /dev/null +++ b/src/DHTRoutingTableSerializer.h @@ -0,0 +1,59 @@ +/* */ +#ifndef _D_DHT_ROUTING_TABLE_SERIALIZER_H_ +#define _D_DHT_ROUTING_TABLE_SERIALIZER_H_ + +#include "common.h" +#include "DHTNodeDecl.h" +#include + +class DHTRoutingTableSerializer { +private: + DHTNodeHandle _localNode; + + DHTNodes _nodes; +public: + DHTRoutingTableSerializer(); + + ~DHTRoutingTableSerializer(); + + void setLocalNode(const DHTNodeHandle& localNode); + + void setNodes(const DHTNodes& nodes); + + void serialize(ostream& o); +}; + +#endif // _D_DHT_ROUTING_TABLE_SERIALIZER_H_ diff --git a/src/DHTSetup.cc b/src/DHTSetup.cc new file mode 100644 index 00000000..d1708921 --- /dev/null +++ b/src/DHTSetup.cc @@ -0,0 +1,233 @@ +/* */ +#include "DHTSetup.h" +#include "LogFactory.h" +#include "Util.h" +#include "DHTNode.h" +#include "DHTConnectionImpl.h" +#include "DHTRoutingTable.h" +#include "DHTMessageFactoryImpl.h" +#include "DHTMessageTracker.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageReceiver.h" +#include "DHTTaskQueueImpl.h" +#include "DHTTaskFactoryImpl.h" +#include "DHTPeerAnnounceStorage.h" +#include "DHTTokenTracker.h" +#include "DHTInteractionCommand.h" +#include "DHTTokenUpdateCommand.h" +#include "DHTBucketRefreshCommand.h" +#include "DHTPeerAnnounceCommand.h" +#include "DHTEntryPointNameResolveCommand.h" +#include "DHTAutoSaveCommand.h" +#include "DHTTask.h" +#include "DHTRoutingTableDeserializer.h" +#include "DHTRegistry.h" +#include "CUIDCounter.h" +#include "prefs.h" +#include "Option.h" +#include "DlAbortEx.h" +#include "RecoverableException.h" +#include + +size_t DHTSetup::_initialized = 0; + +DHTSetup::DHTSetup():_logger(LogFactory::getInstance()) {} + +DHTSetup::~DHTSetup() {} + +Commands DHTSetup::setup(DownloadEngine* e, const Option* option) +{ + if(_initialized) { + return Commands(); + } + try { + // load routing table and localnode id here + + DHTNodeHandle localNode = 0; + + DHTRoutingTableDeserializer deserializer; + string dhtFile = option->get(PREF_DHT_FILE_PATH); + if(File(dhtFile).isFile()) { + try { + ifstream in(dhtFile.c_str()); + in.exceptions(ios::failbit); + deserializer.deserialize(in); + localNode = deserializer.getLocalNode(); + } catch(RecoverableException* e) { + _logger->error("Exception caught while loading DHT routing table from %s", + e, dhtFile.c_str()); + delete e; + } + } + if(localNode.isNull()) { + localNode = new DHTNode(); + } + + SharedHandle connection = new DHTConnectionImpl(); + { + IntSequence seq = Util::parseIntRange(option->get(PREF_DHT_LISTEN_PORT)); + uint16_t port = connection->bind(seq); + if(port == 0) { + throw new DlAbortEx("Error occurred while binding port for DHT"); + } + localNode->setPort(port); + } + _logger->debug("Initialized local node ID=%s", + Util::toHex(localNode->getID(), DHT_ID_LENGTH).c_str()); + + DHTRoutingTableHandle routingTable = new DHTRoutingTable(localNode); + + SharedHandle factory = new DHTMessageFactoryImpl(); + + DHTMessageTrackerHandle tracker = new DHTMessageTracker(); + + DHTMessageDispatcherHandle dispatcher = new DHTMessageDispatcher(tracker); + + DHTMessageReceiverHandle receiver = new DHTMessageReceiver(tracker); + + DHTTaskQueueHandle taskQueue = new DHTTaskQueueImpl(); + + SharedHandle taskFactory = new DHTTaskFactoryImpl(); + + DHTPeerAnnounceStorageHandle peerAnnounceStorage = new DHTPeerAnnounceStorage(); + + DHTTokenTrackerHandle tokenTracker = new DHTTokenTracker(); + + // wiring up + tracker->setRoutingTable(routingTable); + tracker->setMessageFactory(factory); + + receiver->setConnection(connection); + receiver->setMessageFactory(factory); + receiver->setRoutingTable(routingTable); + + taskFactory->setLocalNode(localNode); + taskFactory->setRoutingTable(routingTable); + taskFactory->setMessageDispatcher(dispatcher); + taskFactory->setMessageFactory(factory); + taskFactory->setTaskQueue(taskQueue); + + routingTable->setTaskQueue(taskQueue); + routingTable->setTaskFactory(taskFactory); + + peerAnnounceStorage->setTaskQueue(taskQueue); + peerAnnounceStorage->setTaskFactory(taskFactory); + + factory->setRoutingTable(routingTable); + factory->setConnection(connection); + factory->setMessageDispatcher(dispatcher); + factory->setPeerAnnounceStorage(peerAnnounceStorage); + factory->setTokenTracker(tokenTracker); + factory->setLocalNode(localNode); + + // assign them into DHTRegistry + DHTRegistry::_localNode = localNode; + DHTRegistry::_routingTable = routingTable; + DHTRegistry::_taskQueue = taskQueue; + DHTRegistry::_taskFactory = taskFactory; + DHTRegistry::_peerAnnounceStorage = peerAnnounceStorage; + DHTRegistry::_tokenTracker = tokenTracker; + DHTRegistry::_messageDispatcher = dispatcher; + DHTRegistry::_messageReceiver = receiver; + DHTRegistry::_messageFactory = factory; + + // add deserialized nodes to routing table + const DHTNodes& desnodes = deserializer.getNodes(); + for(DHTNodes::const_iterator i = desnodes.begin(); i != desnodes.end(); ++i) { + routingTable->addNode(*i); + } + if(!desnodes.empty() && deserializer.getSerializedTime().elapsed(DHT_BUCKET_REFRESH_INTERVAL)) { + taskQueue->addPeriodicTask1(taskFactory->createBucketRefreshTask()); + } + + Commands commands; + if(!option->get(PREF_DHT_ENTRY_POINT_HOST).empty()) { + { + DHTEntryPointNameResolveCommand* command = new DHTEntryPointNameResolveCommand(CUIDCounterSingletonHolder::instance()->newID(), e); + command->setTaskQueue(taskQueue); + command->setTaskFactory(taskFactory); + command->setLocalNode(localNode); + commands.push_back(command); + } + } else { + _logger->info("No DHT entry point specified."); + } + { + DHTInteractionCommand* command = new DHTInteractionCommand(CUIDCounterSingletonHolder::instance()->newID(), e); + command->setMessageDispatcher(dispatcher); + command->setMessageReceiver(receiver); + command->setTaskQueue(taskQueue); + command->setReadCheckSocket(connection->getSocket()); + commands.push_back(command); + } + { + DHTTokenUpdateCommand* command = new DHTTokenUpdateCommand(CUIDCounterSingletonHolder::instance()->newID(), e, DHT_TOKEN_UPDATE_INTERVAL); + command->setTokenTracker(tokenTracker); + commands.push_back(command); + } + { + DHTBucketRefreshCommand* command = new DHTBucketRefreshCommand(CUIDCounterSingletonHolder::instance()->newID(), e, DHT_BUCKET_REFRESH_CHECK_INTERVAL); + command->setTaskQueue(taskQueue); + command->setRoutingTable(routingTable); + command->setTaskFactory(taskFactory); + commands.push_back(command); + } + { + DHTPeerAnnounceCommand* command = new DHTPeerAnnounceCommand(CUIDCounterSingletonHolder::instance()->newID(), e, DHT_PEER_ANNOUNCE_CHECK_INTERVAL); + command->setPeerAnnounceStorage(peerAnnounceStorage); + commands.push_back(command); + } + { + DHTAutoSaveCommand* command = new DHTAutoSaveCommand(CUIDCounterSingletonHolder::instance()->newID(), e, 30*60); + command->setLocalNode(localNode); + command->setRoutingTable(routingTable); + commands.push_back(command); + } + _initialized = true; + + return commands; + } catch(RecoverableException* e) { + _logger->error("Exception caught while initializing DHT functionality. DHT is disabled.", e); + delete e; + DHTRegistry::clear(); + return Commands(); + } +} + +bool DHTSetup::initialized() +{ + return _initialized; +} diff --git a/src/DHTSetup.h b/src/DHTSetup.h new file mode 100644 index 00000000..eb01eb98 --- /dev/null +++ b/src/DHTSetup.h @@ -0,0 +1,62 @@ +/* */ +#ifndef _D_DHT_SETUP_H_ +#define _D_DHT_SETUP_H_ + +#include "common.h" + +class Logger; +class Option; +class DownloadEngine; +class Command; +typedef deque Commands; + +class DHTSetup { +private: + static size_t _initialized; + + const Logger* _logger; + +public: + DHTSetup(); + + ~DHTSetup(); + + Commands setup(DownloadEngine* e, const Option* option); + + static bool initialized(); +}; + +#endif // _D_DHT_SETUP_H_ diff --git a/src/DHTTask.h b/src/DHTTask.h new file mode 100644 index 00000000..59bac5a1 --- /dev/null +++ b/src/DHTTask.h @@ -0,0 +1,50 @@ +/* */ +#ifndef _D_DHT_TASK_H_ +#define _D_DHT_TASK_H_ + +#include "common.h" +#include "DHTTaskDecl.h" + +class DHTTask { +public: + virtual ~DHTTask() {} + + virtual void startup() = 0; + + virtual bool finished() = 0; +}; + +#endif // _D_DHT_TASK_H_ diff --git a/src/DHTTaskDecl.h b/src/DHTTaskDecl.h new file mode 100644 index 00000000..c837c8fe --- /dev/null +++ b/src/DHTTaskDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_DHT_TASK_DECL_H_ +#define _D_DHT_TASK_DECL_H_ + +#include "SharedHandle.h" +#include + +class DHTTask; +typedef SharedHandle DHTTaskHandle; +typedef std::deque DHTTasks; + +#endif // _D_DHT_TASK_DECL_H_ diff --git a/src/DHTTaskFactory.h b/src/DHTTaskFactory.h new file mode 100644 index 00000000..a603b35d --- /dev/null +++ b/src/DHTTaskFactory.h @@ -0,0 +1,64 @@ +/* */ +#ifndef _D_DHT_TASK_FACTORY_H_ +#define _D_DHT_TASK_FACTORY_H_ + +#include "common.h" +#include "DHTTaskFactoryDecl.h" +#include "DHTTaskDecl.h" +#include "DHTNodeDecl.h" +#include "DHTBucketDecl.h" +#include "BtContextDecl.h" + +class DHTTaskFactory { +public: + virtual ~DHTTaskFactory() {} + + virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode, + size_t numRetry = 0) = 0; + + virtual DHTTaskHandle createNodeLookupTask(const unsigned char* targetID) = 0; + + virtual DHTTaskHandle createBucketRefreshTask() = 0; + + virtual DHTTaskHandle createPeerLookupTask(const BtContextHandle& ctx) = 0; + + virtual DHTTaskHandle createPeerAnnounceTask(const unsigned char* infoHash) = 0; + + virtual DHTTaskHandle createReplaceNodeTask(const DHTBucketHandle& bucket, + const DHTNodeHandle& newNode) = 0; +}; + +#endif // _D_DHT_TASK_FACTORY_H_ diff --git a/src/DHTTaskFactoryDecl.h b/src/DHTTaskFactoryDecl.h new file mode 100644 index 00000000..a1e442e5 --- /dev/null +++ b/src/DHTTaskFactoryDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_TASK_FACTORY_DECL_H_ +#define _D_DHT_TASK_FACTORY_DECL_H_ + +#include "SharedHandle.h" + +class DHTTaskFactory; +typedef SharedHandle DHTTaskFactoryHandle; + +#endif // _D_DHT_TASK_FACTORY_DECL_H_ diff --git a/src/DHTTaskFactoryImpl.cc b/src/DHTTaskFactoryImpl.cc new file mode 100644 index 00000000..9fd31342 --- /dev/null +++ b/src/DHTTaskFactoryImpl.cc @@ -0,0 +1,143 @@ +/* */ +#include "DHTTaskFactoryImpl.h" +#include "DHTNode.h" +#include "DHTRoutingTable.h" +#include "DHTMessageDispatcher.h" +#include "DHTMessageFactory.h" +#include "DHTTaskQueue.h" +#include "LogFactory.h" +#include "DHTPingTask.h" +#include "DHTNodeLookupTask.h" +#include "DHTBucketRefreshTask.h" +#include "DHTPeerLookupTask.h" +#include "DHTReplaceNodeTask.h" +#include "Peer.h" +#include "DHTNodeLookupEntry.h" +#include "BtContext.h" +#include "PeerStorage.h" +#include "BtRuntime.h" + +DHTTaskFactoryImpl::DHTTaskFactoryImpl():_localNode(0), + _routingTable(0), + _dispatcher(0), + _factory(0), + _taskQueue(0), + _logger(LogFactory::getInstance()) {} + +DHTTaskFactoryImpl::~DHTTaskFactoryImpl() {} + +DHTTaskHandle +DHTTaskFactoryImpl::createPingTask(const DHTNodeHandle& remoteNode, + size_t numRetry) +{ + SharedHandle task = new DHTPingTask(remoteNode, numRetry); + setCommonProperty(task); + return task; +} + +DHTTaskHandle +DHTTaskFactoryImpl::createNodeLookupTask(const unsigned char* targetID) +{ + SharedHandle task = new DHTNodeLookupTask(targetID); + setCommonProperty(task); + return task; +} + +DHTTaskHandle +DHTTaskFactoryImpl::createBucketRefreshTask() +{ + SharedHandle task = new DHTBucketRefreshTask(); + setCommonProperty(task); + return task; +} + +DHTTaskHandle +DHTTaskFactoryImpl::createPeerLookupTask(const BtContextHandle& ctx) +{ + SharedHandle task = new DHTPeerLookupTask(ctx); + setCommonProperty(task); + return task; +} + +DHTTaskHandle +DHTTaskFactoryImpl::createPeerAnnounceTask(const unsigned char* infoHash) +{ + // TODO + return 0; +} + +DHTTaskHandle +DHTTaskFactoryImpl::createReplaceNodeTask(const DHTBucketHandle& bucket, + const DHTNodeHandle& newNode) +{ + SharedHandle task = new DHTReplaceNodeTask(bucket, newNode); + setCommonProperty(task); + return task; +} + +void DHTTaskFactoryImpl::setCommonProperty(const DHTAbstractTaskHandle& task) +{ + task->setRoutingTable(_routingTable); + task->setMessageDispatcher(_dispatcher); + task->setMessageFactory(_factory); + task->setTaskQueue(_taskQueue); + task->setLocalNode(_localNode); +} + +void DHTTaskFactoryImpl::setRoutingTable(const WeakHandle routingTable) +{ + _routingTable = routingTable; +} + +void DHTTaskFactoryImpl::setMessageDispatcher(const WeakHandle dispatcher) +{ + _dispatcher = dispatcher; +} + +void DHTTaskFactoryImpl::setMessageFactory(const WeakHandle factory) +{ + _factory = factory; +} + +void DHTTaskFactoryImpl::setTaskQueue(const WeakHandle taskQueue) +{ + _taskQueue = taskQueue; +} + +void DHTTaskFactoryImpl::setLocalNode(const DHTNodeHandle& localNode) +{ + _localNode = localNode; +} diff --git a/src/DHTTaskFactoryImpl.h b/src/DHTTaskFactoryImpl.h new file mode 100644 index 00000000..0324f101 --- /dev/null +++ b/src/DHTTaskFactoryImpl.h @@ -0,0 +1,94 @@ +/* */ +#ifndef _D_DHT_TASK_FACTORY_IMPL_H_ +#define _D_DHT_TASK_FACTORY_IMPL_H_ + +#include "DHTTaskFactory.h" +#include "DHTNodeDecl.h" +#include "DHTRoutingTableDecl.h" +#include "DHTMessageDispatcherDecl.h" +#include "DHTMessageFactoryDecl.h" +#include "DHTTaskQueueDecl.h" +#include "DHTAbstractTaskDecl.h" + +class Logger; + +class DHTTaskFactoryImpl:public DHTTaskFactory { +private: + DHTNodeHandle _localNode; + + WeakHandle _routingTable; + + WeakHandle _dispatcher; + + WeakHandle _factory; + + WeakHandle _taskQueue; + + const Logger* _logger; + + void setCommonProperty(const DHTAbstractTaskHandle& task); +public: + DHTTaskFactoryImpl(); + + virtual ~DHTTaskFactoryImpl(); + + virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode, + size_t numRetry = 0); + + virtual DHTTaskHandle createNodeLookupTask(const unsigned char* targetID); + + virtual DHTTaskHandle createBucketRefreshTask(); + + virtual DHTTaskHandle createPeerLookupTask(const BtContextHandle& ctx); + + virtual DHTTaskHandle createPeerAnnounceTask(const unsigned char* infoHash); + + virtual DHTTaskHandle createReplaceNodeTask(const DHTBucketHandle& bucket, + const DHTNodeHandle& newNode); + + void setRoutingTable(const WeakHandle routingTable); + + void setMessageDispatcher(const WeakHandle dispatcher); + + void setMessageFactory(const WeakHandle factory); + + void setTaskQueue(const WeakHandle taskQueue); + + void setLocalNode(const DHTNodeHandle& localNode); + +}; + +#endif // _D_DHT_TASK_FACTORY_IMPL_H_ diff --git a/src/DHTTaskQueue.h b/src/DHTTaskQueue.h new file mode 100644 index 00000000..46427ba4 --- /dev/null +++ b/src/DHTTaskQueue.h @@ -0,0 +1,55 @@ +/* */ +#ifndef _D_DHT_TASK_QUEUE_H_ +#define _D_DHT_TASK_QUEUE_H_ + +#include "common.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskDecl.h" + +class DHTTaskQueue { +public: + virtual ~DHTTaskQueue() {} + + virtual void executeTask() = 0; + + virtual void addPeriodicTask1(const DHTTaskHandle& task) = 0; + + virtual void addPeriodicTask2(const DHTTaskHandle& task) = 0; + + virtual void addImmediateTask(const DHTTaskHandle& task) = 0; +}; + +#endif // _D_DHT_TASK_QUEUE_H_ diff --git a/src/DHTTaskQueueDecl.h b/src/DHTTaskQueueDecl.h new file mode 100644 index 00000000..d8105fbf --- /dev/null +++ b/src/DHTTaskQueueDecl.h @@ -0,0 +1,42 @@ +/* */ +#ifndef _D_DHT_TASK_QUEUE_DECL_H_ +#define _D_DHT_TASK_QUEUE_DECL_H_ + +#include "SharedHandle.h" + +class DHTTaskQueue; +typedef SharedHandle DHTTaskQueueHandle; +#endif // _D_DHT_TASK_QUEUE_DECL_H_ diff --git a/src/DHTTaskQueueImpl.cc b/src/DHTTaskQueueImpl.cc new file mode 100644 index 00000000..85a4e13e --- /dev/null +++ b/src/DHTTaskQueueImpl.cc @@ -0,0 +1,81 @@ +/* */ +#include "DHTTaskQueueImpl.h" +#include "DHTTask.h" + +DHTTaskQueueImpl::DHTTaskQueueImpl():_periodicTask1(0), + _periodicTask2(0), + _immediateTask(0) {} + +DHTTaskQueueImpl::~DHTTaskQueueImpl() {} + +void DHTTaskQueueImpl::executeTask(DHTTaskHandle& task, DHTTasks& taskQueue) +{ + while(1) { + if(task.isNull() || task->finished()) { + task = 0; + if(taskQueue.empty()) { + break; + } + task = taskQueue.front(); + taskQueue.erase(taskQueue.begin()); + task->startup(); + } else { + break; + } + } +} + +void DHTTaskQueueImpl::executeTask() +{ + executeTask(_periodicTask1, _periodicTaskQueue1); + executeTask(_periodicTask2, _periodicTaskQueue2); + executeTask(_immediateTask, _immediateTaskQueue); +} + +void DHTTaskQueueImpl::addPeriodicTask1(const DHTTaskHandle& task) +{ + _periodicTaskQueue1.push_back(task); +} + +void DHTTaskQueueImpl::addPeriodicTask2(const DHTTaskHandle& task) +{ + _periodicTaskQueue2.push_back(task); +} + +void DHTTaskQueueImpl::addImmediateTask(const DHTTaskHandle& task) +{ + _immediateTaskQueue.push_back(task); +} diff --git a/src/DHTTaskQueueImpl.h b/src/DHTTaskQueueImpl.h new file mode 100644 index 00000000..951aa2ba --- /dev/null +++ b/src/DHTTaskQueueImpl.h @@ -0,0 +1,70 @@ +/* */ +#ifndef _D_DHT_TASK_QUEUE_IMPL_H_ +#define _D_DHT_TASK_QUEUE_IMPL_H_ + +#include "DHTTaskQueue.h" + +class DHTTaskQueueImpl:public DHTTaskQueue { +private: + + DHTTaskHandle _periodicTask1; + + DHTTaskHandle _periodicTask2; + + DHTTaskHandle _immediateTask; + + DHTTasks _periodicTaskQueue1; + + DHTTasks _periodicTaskQueue2; + + DHTTasks _immediateTaskQueue; + + void executeTask(DHTTaskHandle& task, DHTTasks& taskQueue); +public: + DHTTaskQueueImpl(); + + virtual ~DHTTaskQueueImpl(); + + virtual void executeTask(); + + virtual void addPeriodicTask1(const DHTTaskHandle& task); + + virtual void addPeriodicTask2(const DHTTaskHandle& task); + + virtual void addImmediateTask(const DHTTaskHandle& task); +}; + +#endif // _D_DHT_TASK_QUEUE_IMPL_H_ diff --git a/src/DHTTokenTracker.cc b/src/DHTTokenTracker.cc new file mode 100644 index 00000000..aaede48a --- /dev/null +++ b/src/DHTTokenTracker.cc @@ -0,0 +1,92 @@ +/* */ +#include "DHTTokenTracker.h" +#include "DHTUtil.h" +#include "PeerMessageUtil.h" +#include "DlAbortEx.h" +#include "DHTConstants.h" +#include "MessageDigestHelper.h" + +DHTTokenTracker::DHTTokenTracker() +{ + DHTUtil::generateRandomData(_secret[0], SECRET_SIZE); + memcpy(_secret[1], _secret[0], SECRET_SIZE); +} + +DHTTokenTracker::DHTTokenTracker(const char* initialSecret) +{ + memcpy(_secret[0], initialSecret, SECRET_SIZE); + memcpy(_secret[1], initialSecret, SECRET_SIZE); +} + +DHTTokenTracker::~DHTTokenTracker() {} + +string DHTTokenTracker::generateToken(const unsigned char* infoHash, + const string& ipaddr, uint16_t port, + const char* secret) const +{ + char src[DHT_ID_LENGTH+6+SECRET_SIZE]; + if(!PeerMessageUtil::createcompact(src+DHT_ID_LENGTH, ipaddr, port)) { + throw new DlAbortEx("Token generation failed: ipaddr=%s, port=%u", + ipaddr.c_str(), port); + } + memcpy(src, infoHash, DHT_ID_LENGTH); + memcpy(src+DHT_ID_LENGTH+6, secret, SECRET_SIZE); + return MessageDigestHelper::digest("sha1", src, sizeof(src)); +} + +string DHTTokenTracker::generateToken(const unsigned char* infoHash, + const string& ipaddr, uint16_t port) const +{ + return generateToken(infoHash, ipaddr, port, _secret[0]); +} + +bool DHTTokenTracker::validateToken(const string& token, + const unsigned char* infoHash, + const string& ipaddr, uint16_t port) const +{ + for(int i = 0; i < 2; ++i) { + if(generateToken(infoHash, ipaddr, port, _secret[i]) == token) { + return true; + } + } + return false; +} + +void DHTTokenTracker::updateTokenSecret() +{ + memcpy(_secret[1], _secret[0], SECRET_SIZE); + DHTUtil::generateRandomData(_secret[0], SECRET_SIZE); +} diff --git a/src/DHTTokenTracker.h b/src/DHTTokenTracker.h new file mode 100644 index 00000000..2c510a91 --- /dev/null +++ b/src/DHTTokenTracker.h @@ -0,0 +1,68 @@ +/* */ +#ifndef _D_DHT_TOKEN_TRACKER_H_ +#define _D_DHT_TOKEN_TRACKER_H_ + +#include "common.h" +#include "DHTTokenTrackerDecl.h" + +class DHTTokenTracker { +private: + static const size_t SECRET_SIZE = 4; + + char _secret[2][SECRET_SIZE]; + + string generateToken(const unsigned char* infoHash, + const string& ipaddr, uint16_t port, + const char* secret) const; +public: + DHTTokenTracker(); + + DHTTokenTracker(const char* initialSecret); + + ~DHTTokenTracker(); + + // TODO handle exception thrown by this function. + string generateToken(const unsigned char* infoHash, + const string& ipaddr, uint16_t port) const; + + bool validateToken(const string& token, + const unsigned char* infoHash, + const string& ipaddr, uint16_t port) const; + + void updateTokenSecret(); +}; + +#endif // _D_DHT_TOKEN_TRACKER_H_ diff --git a/src/DHTTokenTrackerDecl.h b/src/DHTTokenTrackerDecl.h new file mode 100644 index 00000000..a95672e3 --- /dev/null +++ b/src/DHTTokenTrackerDecl.h @@ -0,0 +1,43 @@ +/* */ +#ifndef _D_DHT_TOKEN_TRACKER_DECL_H_ +#define _D_DHT_TOKEN_TRACKER_DECL_H_ + +#include "SharedHandle.h" + +class DHTTokenTracker; +typedef SharedHandle DHTTokenTrackerHandle; + +#endif // _D_DHT_TOKEN_TRACKER_DECL_H_ diff --git a/src/DHTTokenUpdateCommand.cc b/src/DHTTokenUpdateCommand.cc new file mode 100644 index 00000000..63020169 --- /dev/null +++ b/src/DHTTokenUpdateCommand.cc @@ -0,0 +1,70 @@ +/* */ +#include "DHTTokenUpdateCommand.h" +#include "DHTTokenTracker.h" +#include "SingletonHolder.h" +#include "DownloadEngine.h" +#include "RequestGroupMan.h" +#include "RecoverableException.h" +#include "message.h" + +DHTTokenUpdateCommand::DHTTokenUpdateCommand(int32_t cuid, + DownloadEngine* e, + time_t interval): + TimeBasedCommand(cuid, e, interval), + _tokenTracker(0) +{} + +DHTTokenUpdateCommand::~DHTTokenUpdateCommand() {} + +void DHTTokenUpdateCommand::preProcess() +{ + _exit = _e->_requestGroupMan->downloadFinished() || _e->isHaltRequested(); +} + +void DHTTokenUpdateCommand::process() +{ + try { + _tokenTracker->updateTokenSecret(); + } catch(RecoverableException* e) { + logger->error(EX_EXCEPTION_CAUGHT, e); + delete e; + } +} + +void DHTTokenUpdateCommand::setTokenTracker(const DHTTokenTrackerHandle& tokenTracker) +{ + _tokenTracker = tokenTracker; +} diff --git a/src/DHTTokenUpdateCommand.h b/src/DHTTokenUpdateCommand.h new file mode 100644 index 00000000..1030e843 --- /dev/null +++ b/src/DHTTokenUpdateCommand.h @@ -0,0 +1,56 @@ +/* */ +#ifndef _D_DHT_TOKEN_UPDATE_COMMAND_H_ +#define _D_DHT_TOKEN_UPDATE_COMMAND_H_ + +#include "TimeBasedCommand.h" +#include "DHTTokenTrackerDecl.h" + +class DHTTokenUpdateCommand:public TimeBasedCommand { +private: + DHTTokenTrackerHandle _tokenTracker; +public: + DHTTokenUpdateCommand(int32_t cuid, DownloadEngine* e, time_t interval); + + virtual ~DHTTokenUpdateCommand(); + + virtual void preProcess(); + + virtual void process(); + + void setTokenTracker(const DHTTokenTrackerHandle& tokenTracker); +}; + +#endif // _D_DHT_TOKEN_UPDATE_COMMAND_H_ diff --git a/src/DHTUtil.cc b/src/DHTUtil.cc new file mode 100644 index 00000000..7c32853e --- /dev/null +++ b/src/DHTUtil.cc @@ -0,0 +1,59 @@ +/* */ +#include "DHTUtil.h" +#include "MessageDigestHelper.h" +#include +#include + +void DHTUtil::generateRandomKey(unsigned char* key) +{ + char bytes[40]; + generateRandomData(bytes, sizeof(bytes)); + MessageDigestHelper::digest(key, 20, "sha1", bytes, sizeof(bytes)); +} + +void DHTUtil::generateRandomData(char* data, size_t length) +{ + ifstream i("/dev/urandom"); + i.read(data, length); +} + +void DHTUtil::flipBit(unsigned char* data, size_t length, size_t bitIndex) +{ + size_t byteIndex = bitIndex/8; + assert(byteIndex <= length); + unsigned char mask = 128 >> (bitIndex%8); + data[byteIndex] ^= mask; +} diff --git a/src/DHTUtil.h b/src/DHTUtil.h new file mode 100644 index 00000000..9cd59e3b --- /dev/null +++ b/src/DHTUtil.h @@ -0,0 +1,56 @@ +/* */ +#ifndef _D_DHT_UTIL_H_ +#define _D_DHT_UTIL_H_ + +#include "common.h" + +class DHTUtil { +public: + + static void generateRandomKey(unsigned char* key); + + static void generateRandomData(char* data, size_t length); + + static void generateRandomData(unsigned char* data, size_t length) + { + return generateRandomData(reinterpret_cast(data), length); + } + + static void flipBit(unsigned char* data, size_t length, size_t bitIndex); + +}; + +#endif // _D_DHT_UTIL_H_ diff --git a/src/Data.cc b/src/Data.cc index 0bfc91bd..5767a580 100644 --- a/src/Data.cc +++ b/src/Data.cc @@ -36,26 +36,28 @@ #include "MetaEntryVisitor.h" Data::Data(const char* data, int32_t len, bool number):number(number) { - if(data == NULL) { - this->data = NULL; - this->len = 0; - } else { - this->data = new char[len]; - memcpy(this->data, data, len); - this->len = len; - } + init(data, len); +} + +Data::Data(const unsigned char* data, int32_t len, bool number):number(number) { + init(reinterpret_cast(data), len); } Data::Data(const string& data, bool number):number(number) { - if(data.empty()) { - this->data = 0; - this->len = 0; - } else { - this->data = new char[data.size()]; - memcpy(this->data, data.c_str(), data.size()); - this->len = data.size(); - } + init(data.c_str(), data.size()); +} + +void Data::init(const char* src, int32_t slen) +{ + if(src) { + data = new char[slen]; + memcpy(data, src, slen); + len = slen; + } else { + data = 0; + len = 0; + } } Data::~Data() { diff --git a/src/Data.h b/src/Data.h index 03499ea3..4d394c12 100644 --- a/src/Data.h +++ b/src/Data.h @@ -45,6 +45,8 @@ private: int32_t len; char* data; bool number; + + void init(const char* data, int32_t len); public: /** * This class stores the copy of data. So caller must take care of freeing @@ -52,6 +54,8 @@ public: */ Data(const char* data, int32_t len, bool number = false); + Data(const unsigned char* data, int32_t len, bool number = false); + Data(const string& data, bool number = false); ~Data(); diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc index cdd35ae9..66b68ce2 100644 --- a/src/DefaultBtInteractive.cc +++ b/src/DefaultBtInteractive.cc @@ -48,6 +48,7 @@ #include "UTPexExtensionMessage.h" #include "DefaultExtensionMessageFactory.h" #include "BtRegistry.h" +#include "DHTNode.h" void DefaultBtInteractive::initiateHandshake() { BtHandshakeMessageHandle message = @@ -79,7 +80,10 @@ BtMessageHandle DefaultBtInteractive::receiveHandshake(bool quickReply) { PEER_OBJECT(btContext, peer)->extensionMessageFactory = factory; logger->info(MSG_EXTENDED_MESSAGING_ENABLED, cuid); } - + if(message->isDHTEnabled()) { + peer->setDHTEnabled(true); + logger->info(MSG_DHT_ENABLED_PEER, cuid); + } logger->info(MSG_RECEIVE_PEER_MESSAGE, cuid, peer->ipaddr.c_str(), peer->port, message->toString().c_str()); @@ -100,10 +104,18 @@ void DefaultBtInteractive::doPostHandshakeProcessing() { addHandshakeExtendedMessageToQueue(); } addBitfieldMessageToQueue(); + if(peer->isDHTEnabled() && _dhtEnabled) { + addPortMessageToQueue(); + } addAllowedFastMessageToQueue(); sendPendingMessage(); } +void DefaultBtInteractive::addPortMessageToQueue() +{ + dispatcher->addMessageToQueue(messageFactory->createPortMessage(_localNode->getPort())); +} + void DefaultBtInteractive::addHandshakeExtendedMessageToQueue() { HandshakeExtensionMessageHandle m = new HandshakeExtensionMessage(); @@ -387,3 +399,8 @@ void DefaultBtInteractive::doInteractionProcessing() { sendPendingMessage(); } + +void DefaultBtInteractive::setLocalNode(const WeakHandle& node) +{ + _localNode = node; +} diff --git a/src/DefaultBtInteractive.h b/src/DefaultBtInteractive.h index c0c70077..9247c8ac 100644 --- a/src/DefaultBtInteractive.h +++ b/src/DefaultBtInteractive.h @@ -48,6 +48,7 @@ #include "Logger.h" #include "LogFactory.h" #include "TimeA2.h" +#include "DHTNodeDecl.h" class FloodingStat { private: @@ -95,6 +96,7 @@ private: BtRequestFactoryWeakHandle btRequestFactory; PeerConnectionWeakHandle peerConnection; BtMessageFactoryWeakHandle messageFactory; + WeakHandle _localNode; const Logger* logger; int32_t allowedFastSetSize; Time haveCheckPoint; @@ -106,6 +108,7 @@ private: int32_t keepAliveInterval; int32_t maxDownloadSpeedLimit; bool _utPexEnabled; + bool _dhtEnabled; static const int32_t FLOODING_CHECK_INTERVAL = 5; @@ -121,6 +124,7 @@ private: void detectMessageFlooding(); void checkActiveInteraction(); void addPeerExchangeMessage(); + void addPortMessageToQueue(); public: DefaultBtInteractive():peer(0), @@ -136,7 +140,8 @@ public: allowedFastSetSize(10), keepAliveInterval(120), maxDownloadSpeedLimit(0), - _utPexEnabled(false) + _utPexEnabled(false), + _dhtEnabled(false) {} virtual ~DefaultBtInteractive() {} @@ -212,6 +217,13 @@ public: { _utPexEnabled = f; } + + void setLocalNode(const WeakHandle& node); + + void setDHTEnabled(bool f) + { + _dhtEnabled = f; + } }; typedef SharedHandle DefaultBtInteractiveHandle; diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc index c10d47d9..48819d48 100644 --- a/src/DefaultBtMessageFactory.cc +++ b/src/DefaultBtMessageFactory.cc @@ -64,6 +64,15 @@ #include "BtExtendedMessage.h" #include "ExtensionMessage.h" +DefaultBtMessageFactory::DefaultBtMessageFactory():cuid(0), + btContext(0), + pieceStorage(0), + peer(0), + _dhtEnabled(false) +{} + +DefaultBtMessageFactory::~DefaultBtMessageFactory() {} + BtMessageHandle DefaultBtMessageFactory::createBtMessage(const unsigned char* data, int32_t dataLength) { @@ -126,9 +135,6 @@ DefaultBtMessageFactory::createBtMessage(const unsigned char* data, int32_t data msg = temp; break; } - case BtPortMessage::ID: - msg = BtPortMessage::create(data, dataLength); - break; case BtHaveAllMessage::ID: msg = BtHaveAllMessage::create(data, dataLength); break; @@ -163,6 +169,13 @@ DefaultBtMessageFactory::createBtMessage(const unsigned char* data, int32_t data msg = temp; break; } + case BtPortMessage::ID: { + SharedHandle temp = BtPortMessage::create(data, dataLength); + temp->setTaskQueue(_taskQueue); + temp->setTaskFactory(_taskFactory); + msg = temp; + break; + } case BtExtendedMessage::ID: { if(peer->isExtendedMessagingEnabled()) { msg = BtExtendedMessage::create(btContext, peer, (const char*)data, dataLength); @@ -210,6 +223,7 @@ DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash, new BtHandshakeMessageValidator(msg.get(), btContext->getInfoHash()); msg->setBtMessageValidator(validator); + msg->setDHTEnabled(_dhtEnabled); setCommonProperty(msg); return msg; } @@ -360,6 +374,14 @@ DefaultBtMessageFactory::createAllowedFastMessage(int32_t index) return msg; } +BtMessageHandle +DefaultBtMessageFactory::createPortMessage(uint16_t port) +{ + SharedHandle msg = new BtPortMessage(port); + setCommonProperty(msg); + return msg; +} + BtMessageHandle DefaultBtMessageFactory::createBtExtendedMessage(const ExensionMessageHandle& msg) { @@ -367,3 +389,13 @@ DefaultBtMessageFactory::createBtExtendedMessage(const ExensionMessageHandle& ms setCommonProperty(m); return m; } + +void DefaultBtMessageFactory::setTaskQueue(const WeakHandle& taskQueue) +{ + _taskQueue = taskQueue; +} + +void DefaultBtMessageFactory::setTaskFactory(const WeakHandle& taskFactory) +{ + _taskFactory = taskFactory; +} diff --git a/src/DefaultBtMessageFactory.h b/src/DefaultBtMessageFactory.h index d87da9ec..6b1ad1aa 100644 --- a/src/DefaultBtMessageFactory.h +++ b/src/DefaultBtMessageFactory.h @@ -39,6 +39,8 @@ #include "Peer.h" #include "AbstractBtMessage.h" #include "BtRegistry.h" +#include "DHTTaskQueueDecl.h" +#include "DHTTaskFactoryDecl.h" class DefaultBtMessageFactory : public BtMessageFactory { private: @@ -47,26 +49,23 @@ private: PieceStorageHandle pieceStorage; PeerHandle peer; + bool _dhtEnabled; + BtMessageDispatcherWeakHandle dispatcher; BtRequestFactoryWeakHandle requestFactory; PeerConnectionWeakHandle peerConnection; + WeakHandle _taskQueue; + + WeakHandle _taskFactory; + void setCommonProperty(const AbstractBtMessageHandle& msg); public: - DefaultBtMessageFactory():cuid(0), - btContext(0), - pieceStorage(0), - peer(0) - { - LogFactory::getInstance()->debug("DefaultBtMessageFactory::instantiated"); - } + DefaultBtMessageFactory(); - virtual ~DefaultBtMessageFactory() - { - LogFactory::getInstance()->debug("DefaultBtMessageFactory::deleted"); - } + virtual ~DefaultBtMessageFactory(); virtual BtMessageHandle createBtMessage(const unsigned char* msg, int32_t msgLength); @@ -110,6 +109,8 @@ public: virtual BtMessageHandle createAllowedFastMessage(int32_t index); + virtual BtMessageHandle createPortMessage(uint16_t port); + virtual BtMessageHandle createBtExtendedMessage(const ExensionMessageHandle& msg); void setPeer(const PeerHandle& peer) { @@ -133,6 +134,10 @@ public: this->cuid = cuid; } + void setDHTEnabled(bool enabled) { + _dhtEnabled = enabled; + } + void setBtMessageDispatcher(const BtMessageDispatcherWeakHandle& dispatcher) { this->dispatcher = dispatcher; @@ -146,6 +151,9 @@ public: this->peerConnection = connection; } + void setTaskQueue(const WeakHandle& taskQueue); + + void setTaskFactory(const WeakHandle& taskFactory); }; typedef SharedHandle DefaultBtMessageFactoryHandle; diff --git a/src/Dictionary.cc b/src/Dictionary.cc index d88e468d..821753dc 100644 --- a/src/Dictionary.cc +++ b/src/Dictionary.cc @@ -61,6 +61,12 @@ void Dictionary::put(const string& name, MetaEntry* entry) { order.push_back(name); } +void Dictionary::remove(const string& name) +{ + table.erase(name); + order.erase(std::remove(order.begin(), order.end(), name), order.end()); +} + void Dictionary::accept(MetaEntryVisitor* v) const { v->visit(this); } diff --git a/src/Dictionary.h b/src/Dictionary.h index a140f416..85c56d04 100644 --- a/src/Dictionary.h +++ b/src/Dictionary.h @@ -56,6 +56,7 @@ public: const MetaEntry* get(const string& name) const; void put(const string& name, MetaEntry* entry); + void remove(const string& name); void accept(MetaEntryVisitor* v) const; const Order& getOrder() const; diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc index 7fa680a7..1b062b2a 100644 --- a/src/DownloadEngine.cc +++ b/src/DownloadEngine.cc @@ -135,6 +135,7 @@ void DownloadEngine::run() { noWait = false; calculateStatistics(); } + cerr << commands.size() << endl; onEndOfRun(); } diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc index 1395f929..e1548aac 100644 --- a/src/FtpConnection.cc +++ b/src/FtpConnection.cc @@ -101,6 +101,7 @@ void FtpConnection::sendPasv() const SocketHandle FtpConnection::sendPort() const { SocketHandle serverSocket; + serverSocket->bind(0); serverSocket->beginListen(); pair addrinfo; diff --git a/src/HelpItemFactory.cc b/src/HelpItemFactory.cc index 72540044..4c491088 100644 --- a/src/HelpItemFactory.cc +++ b/src/HelpItemFactory.cc @@ -334,6 +334,21 @@ TagContainerHandle HelpItemFactory::createHelpItems() item->addTag(TAG_BITTORRENT); tc->addItem(item); } + { + HelpItemHandle item = new HelpItem(PREF_ENABLE_DHT, TEXT_ENABLE_DHT, V_FALSE); + item->addTag(TAG_BITTORRENT); + tc->addItem(item); + } + { + HelpItemHandle item = new HelpItem(PREF_DHT_LISTEN_PORT, TEXT_DHT_LISTEN_PORT, "6881-6999"); + item->addTag(TAG_BITTORRENT); + tc->addItem(item); + } + { + HelpItemHandle item = new HelpItem(PREF_DHT_ENTRY_POINT, TEXT_DHT_ENTRY_POINT); + item->addTag(TAG_BITTORRENT); + tc->addItem(item); + } #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK { diff --git a/src/Makefile.am b/src/Makefile.am index 7aa71f0a..66214950 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -257,7 +257,56 @@ SRCS += MetaEntry.h\ BtExtendedMessage.cc\ DefaultExtensionMessageFactory.cc\ HandshakeExtensionMessage.cc\ - UTPexExtensionMessage.cc + UTPexExtensionMessage.cc\ + DHTNode.cc\ + DHTUtil.cc\ + DHTBucket.cc\ + DHTRoutingTable.cc\ + DHTMessageEntry.cc\ + DHTMessageDispatcher.cc\ + DHTMessageReceiver.cc\ + DHTMessageTracker.cc\ + DHTMessageTrackerEntry.cc\ + DHTMessage.cc\ + DHTConnectionImpl.cc\ + DHTAbstractMessage.cc\ + DHTQueryMessage.cc\ + DHTResponseMessage.cc\ + DHTPingMessage.cc\ + DHTPingReplyMessage.cc\ + DHTFindNodeMessage.cc\ + DHTFindNodeReplyMessage.cc\ + DHTGetPeersMessage.cc\ + DHTGetPeersReplyMessage.cc\ + DHTAnnouncePeerMessage.cc\ + DHTAnnouncePeerReplyMessage.cc\ + DHTMessageFactoryImpl.cc\ + DHTNodeLookupTask.cc\ + DHTNodeLookupEntry.cc\ + BNode.cc\ + DHTMessageCallbackImpl.cc\ + DHTAbstractTask.cc\ + DHTPingTask.cc\ + DHTTaskQueueImpl.cc\ + DHTBucketRefreshTask.cc\ + DHTAbstractNodeLookupTask.cc\ + DHTPeerLookupTask.cc\ + DHTSetup.cc\ + DHTTaskFactoryImpl.cc\ + DHTInteractionCommand.cc\ + DHTPeerAnnounceEntry.cc\ + DHTPeerAnnounceStorage.cc\ + DHTTokenTracker.cc\ + DHTGetPeersCommand.cc\ + DHTTokenUpdateCommand.cc\ + DHTBucketRefreshCommand.cc\ + DHTPeerAnnounceCommand.cc\ + DHTReplaceNodeTask.cc\ + DHTEntryPointNameResolveCommand.cc\ + DHTRoutingTableSerializer.cc\ + DHTRoutingTableDeserializer.cc\ + DHTAutoSaveCommand.cc\ + DHTRegistry.cc endif # ENABLE_BITTORRENT if ENABLE_METALINK diff --git a/src/Makefile.in b/src/Makefile.in index ffc90332..215b4f91 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -140,7 +140,56 @@ bin_PROGRAMS = aria2c$(EXEEXT) @ENABLE_BITTORRENT_TRUE@ BtExtendedMessage.cc\ @ENABLE_BITTORRENT_TRUE@ DefaultExtensionMessageFactory.cc\ @ENABLE_BITTORRENT_TRUE@ HandshakeExtensionMessage.cc\ -@ENABLE_BITTORRENT_TRUE@ UTPexExtensionMessage.cc +@ENABLE_BITTORRENT_TRUE@ UTPexExtensionMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTNode.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTUtil.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTBucket.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTable.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageEntry.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageDispatcher.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageReceiver.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageTracker.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageTrackerEntry.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTConnectionImpl.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAbstractMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTQueryMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTResponseMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPingMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPingReplyMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTFindNodeMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTFindNodeReplyMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersReplyMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAnnouncePeerMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAnnouncePeerReplyMessage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageFactoryImpl.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTNodeLookupTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTNodeLookupEntry.cc\ +@ENABLE_BITTORRENT_TRUE@ BNode.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageCallbackImpl.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAbstractTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPingTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTTaskQueueImpl.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTBucketRefreshTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAbstractNodeLookupTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPeerLookupTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTSetup.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTTaskFactoryImpl.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTInteractionCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceEntry.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceStorage.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTTokenTracker.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTTokenUpdateCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTBucketRefreshCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTReplaceNodeTask.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTEntryPointNameResolveCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableSerializer.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableDeserializer.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAutoSaveCommand.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRegistry.cc @ENABLE_METALINK_TRUE@am__append_3 = Metalinker.cc Metalinker.h\ @ENABLE_METALINK_TRUE@ MetalinkEntry.cc MetalinkEntry.h\ @@ -365,7 +414,28 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \ BtCheckIntegrityEntry.cc BtCheckIntegrityEntry.h \ BtExtendedMessage.cc DefaultExtensionMessageFactory.cc \ HandshakeExtensionMessage.cc UTPexExtensionMessage.cc \ - Metalinker.cc Metalinker.h MetalinkEntry.cc MetalinkEntry.h \ + DHTNode.cc DHTUtil.cc DHTBucket.cc DHTRoutingTable.cc \ + DHTMessageEntry.cc DHTMessageDispatcher.cc \ + DHTMessageReceiver.cc DHTMessageTracker.cc \ + DHTMessageTrackerEntry.cc DHTMessage.cc DHTConnectionImpl.cc \ + DHTAbstractMessage.cc DHTQueryMessage.cc DHTResponseMessage.cc \ + DHTPingMessage.cc DHTPingReplyMessage.cc DHTFindNodeMessage.cc \ + DHTFindNodeReplyMessage.cc DHTGetPeersMessage.cc \ + DHTGetPeersReplyMessage.cc DHTAnnouncePeerMessage.cc \ + DHTAnnouncePeerReplyMessage.cc DHTMessageFactoryImpl.cc \ + DHTNodeLookupTask.cc DHTNodeLookupEntry.cc BNode.cc \ + DHTMessageCallbackImpl.cc DHTAbstractTask.cc DHTPingTask.cc \ + DHTTaskQueueImpl.cc DHTBucketRefreshTask.cc \ + DHTAbstractNodeLookupTask.cc DHTPeerLookupTask.cc DHTSetup.cc \ + DHTTaskFactoryImpl.cc DHTInteractionCommand.cc \ + DHTPeerAnnounceEntry.cc DHTPeerAnnounceStorage.cc \ + DHTTokenTracker.cc DHTGetPeersCommand.cc \ + DHTTokenUpdateCommand.cc DHTBucketRefreshCommand.cc \ + DHTPeerAnnounceCommand.cc DHTReplaceNodeTask.cc \ + DHTEntryPointNameResolveCommand.cc \ + DHTRoutingTableSerializer.cc DHTRoutingTableDeserializer.cc \ + DHTAutoSaveCommand.cc DHTRegistry.cc Metalinker.cc \ + Metalinker.h MetalinkEntry.cc MetalinkEntry.h \ MetalinkResource.cc MetalinkResource.h MetalinkProcessor.h \ MetalinkProcessorFactory.cc MetalinkParserController.cc \ MetalinkParserStateMachine.cc InitialMetalinkParserState.cc \ @@ -447,7 +517,55 @@ am__libaria2c_a_SOURCES_DIST = Socket.h SocketCore.cc SocketCore.h \ @ENABLE_BITTORRENT_TRUE@ BtExtendedMessage.$(OBJEXT) \ @ENABLE_BITTORRENT_TRUE@ DefaultExtensionMessageFactory.$(OBJEXT) \ @ENABLE_BITTORRENT_TRUE@ HandshakeExtensionMessage.$(OBJEXT) \ -@ENABLE_BITTORRENT_TRUE@ UTPexExtensionMessage.$(OBJEXT) +@ENABLE_BITTORRENT_TRUE@ UTPexExtensionMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTNode.$(OBJEXT) DHTUtil.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTBucket.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTable.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageEntry.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageDispatcher.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageReceiver.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageTracker.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageTrackerEntry.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTConnectionImpl.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTAbstractMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTQueryMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTResponseMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPingMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPingReplyMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTFindNodeMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTFindNodeReplyMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersReplyMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTAnnouncePeerMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTAnnouncePeerReplyMessage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageFactoryImpl.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTNodeLookupTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTNodeLookupEntry.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ BNode.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTMessageCallbackImpl.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTAbstractTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPingTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTTaskQueueImpl.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTBucketRefreshTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTAbstractNodeLookupTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPeerLookupTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTSetup.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTTaskFactoryImpl.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTInteractionCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceEntry.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceStorage.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTTokenTracker.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTTokenUpdateCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTBucketRefreshCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTReplaceNodeTask.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTEntryPointNameResolveCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableSerializer.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableDeserializer.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTAutoSaveCommand.$(OBJEXT) \ +@ENABLE_BITTORRENT_TRUE@ DHTRegistry.$(OBJEXT) @ENABLE_METALINK_TRUE@am__objects_3 = Metalinker.$(OBJEXT) \ @ENABLE_METALINK_TRUE@ MetalinkEntry.$(OBJEXT) \ @ENABLE_METALINK_TRUE@ MetalinkResource.$(OBJEXT) \ @@ -950,6 +1068,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AuthConfig.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AuthConfigFactory.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/AutoSaveCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BNode.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Base64.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BencodeVisitor.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/BitfieldMan.Po@am__quote@ @@ -994,6 +1113,54 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CookieBoxFactory.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CookieParser.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CopyDiskAdaptor.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAbstractMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAbstractNodeLookupTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAbstractTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAnnouncePeerMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAnnouncePeerReplyMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTAutoSaveCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTBucket.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTBucketRefreshCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTBucketRefreshTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTConnectionImpl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTEntryPointNameResolveCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTFindNodeMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTFindNodeReplyMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTGetPeersCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTGetPeersMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTGetPeersReplyMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTInteractionCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageCallbackImpl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageDispatcher.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageEntry.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageFactoryImpl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageReceiver.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageTracker.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTMessageTrackerEntry.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTNode.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTNodeLookupEntry.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTNodeLookupTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPeerAnnounceCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPeerAnnounceEntry.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPeerAnnounceStorage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPeerLookupTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPingMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPingReplyMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTPingTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTQueryMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRegistry.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTReplaceNodeTask.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTResponseMessage.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRoutingTable.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRoutingTableDeserializer.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTRoutingTableSerializer.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTSetup.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTTaskFactoryImpl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTTaskQueueImpl.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTTokenTracker.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTTokenUpdateCommand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DHTUtil.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Data.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultAuthResolver.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/DefaultBtAnnounce.Po@am__quote@ diff --git a/src/OptionHandlerFactory.cc b/src/OptionHandlerFactory.cc index 30fdfed3..b9c7b6ba 100644 --- a/src/OptionHandlerFactory.cc +++ b/src/OptionHandlerFactory.cc @@ -40,7 +40,9 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers() { OptionHandlers handlers; - handlers.push_back(new HttpProxyOptionHandler(PREF_HTTP_PROXY)); + handlers.push_back(new HttpProxyOptionHandler(PREF_HTTP_PROXY, + PREF_HTTP_PROXY_HOST, + PREF_HTTP_PROXY_PORT)); handlers.push_back(new DefaultOptionHandler(PREF_HTTP_USER)); handlers.push_back(new DefaultOptionHandler(PREF_HTTP_PASSWD)); handlers.push_back(new DefaultOptionHandler(PREF_HTTP_PROXY_USER)); @@ -109,6 +111,11 @@ OptionHandlers OptionHandlerFactory::createOptionHandlers() Strings(¶ms[0], ¶ms[arrayLength(params)]))); } handlers.push_back(new BooleanOptionHandler(PREF_ENABLE_PEER_EXCHANGE)); + handlers.push_back(new BooleanOptionHandler(PREF_ENABLE_DHT)); + handlers.push_back(new IntegerRangeOptionHandler(PREF_DHT_LISTEN_PORT, 1024, UINT16_MAX)); + handlers.push_back(new HostPortOptionHandler(PREF_DHT_ENTRY_POINT, + PREF_DHT_ENTRY_POINT_HOST, + PREF_DHT_ENTRY_POINT_PORT)); return handlers; } diff --git a/src/OptionHandlerImpl.h b/src/OptionHandlerImpl.h index c48333f6..194f3f73 100644 --- a/src/OptionHandlerImpl.h +++ b/src/OptionHandlerImpl.h @@ -243,11 +243,20 @@ public: } }; -class HttpProxyOptionHandler : public NameMatchOptionHandler { +class HostPortOptionHandler : public NameMatchOptionHandler { +private: + string _hostOptionName; + + string _portOptionName; public: - HttpProxyOptionHandler(const string& optName):NameMatchOptionHandler(optName) {} + HostPortOptionHandler(const string& optName, + const string& hostOptionName, + const string& portOptionName): + NameMatchOptionHandler(optName), + _hostOptionName(hostOptionName), + _portOptionName(portOptionName) {} - virtual ~HttpProxyOptionHandler() {} + virtual ~HostPortOptionHandler() {} virtual void parseArg(Option* option, const string& optarg) { @@ -257,9 +266,29 @@ public: port <= 0 || 65535 < port) { throw new FatalException(_("unrecognized proxy format")); } - option->put(PREF_HTTP_PROXY, optarg); - option->put(PREF_HTTP_PROXY_HOST, proxy.first); - option->put(PREF_HTTP_PROXY_PORT, Util::itos(port)); + option->put(_optName, optarg); + setHostAndPort(option, proxy.first, port); + } + + void setHostAndPort(Option* option, const string& hostname, uint16_t port) + { + option->put(_hostOptionName, hostname); + option->put(_portOptionName, Util::uitos(port)); + } +}; + +class HttpProxyOptionHandler : public HostPortOptionHandler { +public: + HttpProxyOptionHandler(const string& optName, + const string& hostOptionName, + const string& portOptionName): + HostPortOptionHandler(optName, hostOptionName, portOptionName) {} + + virtual ~HttpProxyOptionHandler() {} + + virtual void parseArg(Option* option, const string& optarg) + { + HostPortOptionHandler::parseArg(option, optarg); option->put(PREF_HTTP_PROXY_ENABLED, V_TRUE); } }; diff --git a/src/Peer.cc b/src/Peer.cc index 51245cd8..995fbc7d 100644 --- a/src/Peer.cc +++ b/src/Peer.cc @@ -117,6 +117,7 @@ void Peer::resetStatus() { fastExtensionEnabled = false; _extendedMessagingEnabled = false; _extensions.clear(); + _dhtEnabled = false; latency = DEFAULT_LATENCY; peerAllowedIndexSet.clear(); amAllowedIndexSet.clear(); diff --git a/src/Peer.h b/src/Peer.h index a7aae305..37e2d745 100644 --- a/src/Peer.h +++ b/src/Peer.h @@ -40,6 +40,7 @@ #include "PeerStat.h" #include "TimeA2.h" #include "BtConstants.h" +#include "PeerDecl.h" #include #define PEER_ID_LENGTH 20 @@ -71,6 +72,7 @@ private: Integers amAllowedIndexSet; bool _extendedMessagingEnabled; Extensions _extensions; + bool _dhtEnabled; PeerStat peerStat; int64_t sessionUploadLength; int64_t sessionDownloadLength; @@ -219,6 +221,16 @@ public: return _extendedMessagingEnabled; } + void setDHTEnabled(bool enabled) + { + _dhtEnabled = enabled; + } + + bool isDHTEnabled() const + { + return _dhtEnabled; + } + bool shouldBeChoking() const; bool hasPiece(int32_t index) const; @@ -260,7 +272,4 @@ public: void setExtension(const string& name, uint8_t id); }; -typedef SharedHandle PeerHandle; -typedef deque Peers; - #endif // _D_PEER_H_ diff --git a/src/PeerAddrEntry.h b/src/PeerAddrEntry.h new file mode 100644 index 00000000..b2a6d3fe --- /dev/null +++ b/src/PeerAddrEntry.h @@ -0,0 +1,80 @@ +/* */ +#ifndef _D_DHT_PEER_ADDR_ENTRY_H_ +#define _D_DHT_PEER_ADDR_ENTRY_H_ + +#include "common.h" +#include "TimeA2.h" + +class PeerAddrEntry { +private: + string _ipaddr; + + uint16_t _port; + + Time _lastUpdated; +public: + PeerAddrEntry(const string& ipaddr, uint16_t port, Time updated = Time()): + _ipaddr(ipaddr), _port(port), _lastUpdated(updated) {} + + const string& getIPAddress() const + { + return _ipaddr; + } + + uint16_t getPort() const + { + return _port; + } + + const Time& getLastUpdated() const + { + return _lastUpdated; + } + + void notifyUpdate() + { + _lastUpdated.reset(); + } + + bool operator==(const PeerAddrEntry& entry) const + { + return _ipaddr == entry._ipaddr && _port == entry._port; + } +}; + +typedef deque PeerAddrEntries; + +#endif // _D_DHT_PEER_ADDR_ENTRY_H_ diff --git a/src/PeerDecl.h b/src/PeerDecl.h new file mode 100644 index 00000000..318beff9 --- /dev/null +++ b/src/PeerDecl.h @@ -0,0 +1,45 @@ +/* */ +#ifndef _D_PEER_DECL_H_ +#define _D_PEER_DECL_H_ + +#include "SharedHandle.h" +#include + +class Peer; +typedef SharedHandle PeerHandle; +typedef std::deque Peers; + +#endif // _D_PEER_DECL_H_ diff --git a/src/PeerInteractionCommand.cc b/src/PeerInteractionCommand.cc index 2cd64a27..3a60b6b7 100644 --- a/src/PeerInteractionCommand.cc +++ b/src/PeerInteractionCommand.cc @@ -47,6 +47,11 @@ #include "DefaultBtMessageFactory.h" #include "DefaultBtInteractive.h" #include "CUIDCounter.h" +#include "DHTTaskQueue.h" +#include "DHTTaskFactory.h" +#include "DHTNode.h" +#include "DHTSetup.h" +#include "DHTRegistry.h" #include PeerInteractionCommand::PeerInteractionCommand(int32_t cuid, @@ -74,6 +79,8 @@ PeerInteractionCommand::PeerInteractionCommand(int32_t cuid, factory->setCuid(cuid); factory->setBtContext(btContext); factory->setPeer(peer); + factory->setTaskQueue(DHTRegistry::_taskQueue); + factory->setTaskFactory(DHTRegistry::_taskFactory); PeerConnectionHandle peerConnection = passedPeerConnection.isNull() ? new PeerConnection(cuid, socket, e->option) : passedPeerConnection; @@ -112,8 +119,15 @@ PeerInteractionCommand::PeerInteractionCommand(int32_t cuid, btInteractive->setKeepAliveInterval(e->option->getAsInt(PREF_BT_KEEP_ALIVE_INTERVAL)); btInteractive->setMaxDownloadSpeedLimit(e->option->getAsInt(PREF_MAX_DOWNLOAD_LIMIT)); btInteractive->setBtMessageFactory(factory); - if(!btContext->isPrivate() && e->option->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) { - btInteractive->setUTPexEnabled(true); + if(!btContext->isPrivate()) { + if(e->option->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) { + btInteractive->setUTPexEnabled(true); + } + if(DHTSetup::initialized()) { + btInteractive->setDHTEnabled(true); + btInteractive->setLocalNode(DHTRegistry::_localNode); + factory->setDHTEnabled(true); + } } this->btInteractive = btInteractive; diff --git a/src/PeerListenCommand.cc b/src/PeerListenCommand.cc index 188040b4..a8f52afa 100644 --- a/src/PeerListenCommand.cc +++ b/src/PeerListenCommand.cc @@ -63,7 +63,8 @@ int32_t PeerListenCommand::bindPort(IntSequence& seq) while(seq.hasNext()) { int32_t port = seq.next(); try { - socket->beginListen(port); + socket->bind(port); + socket->beginListen(); logger->info(MSG_LISTENING_PORT, cuid, port); return port; diff --git a/src/PeerMessageUtil.cc b/src/PeerMessageUtil.cc index 0665939f..eb526407 100644 --- a/src/PeerMessageUtil.cc +++ b/src/PeerMessageUtil.cc @@ -135,3 +135,11 @@ bool PeerMessageUtil::createcompact(char* compact, const string& addr, uint16_t return true; } +pair PeerMessageUtil::unpackcompact(const char* compact) +{ + struct in_addr in; + in.s_addr = *(uint32_t*)(compact); + string ipaddr = inet_ntoa(in); + uint16_t port = ntohs(*(uint16_t*)(compact+sizeof(uint32_t))); + return pair(ipaddr, port); +} diff --git a/src/PeerMessageUtil.h b/src/PeerMessageUtil.h index f66f2f0e..29bf1479 100644 --- a/src/PeerMessageUtil.h +++ b/src/PeerMessageUtil.h @@ -75,6 +75,8 @@ public: * notation. */ static bool createcompact(char* compact, const string& addr, uint16_t port); + + static pair unpackcompact(const char* compact); }; #endif // _D_PEER_MESSAGE_UTIL_H_ diff --git a/src/RequestGroup.cc b/src/RequestGroup.cc index 4dedd96e..ae3d80f7 100644 --- a/src/RequestGroup.cc +++ b/src/RequestGroup.cc @@ -74,6 +74,9 @@ # include "BtSetup.h" # include "BtFileAllocationEntry.h" # include "BtPostDownloadHandler.h" +# include "DHTSetup.h" +# include "DHTRegistry.h" +# include "DHTPeerAnnounceStorage.h" #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK # include "MetalinkPostDownloadHandler.h" @@ -219,6 +222,10 @@ Commands RequestGroup::createInitialCommand(DownloadEngine* e) } } _progressInfoFile = progressInfoFile; + + if(!btContext->isPrivate() && _option->getAsBool(PREF_ENABLE_DHT)) { + e->addCommand(DHTSetup().setup(e, _option)); + } CheckIntegrityEntryHandle entry = new BtCheckIntegrityEntry(this); return processCheckIntegrityEntry(entry, e); @@ -584,6 +591,7 @@ void RequestGroup::releaseRuntimeResource() btContextInReg->getOwnerRequestGroup()->getGID() == btContext->getOwnerRequestGroup()->getGID()) { BtRegistry::unregister(btContext->getInfoHashAsString()); + DHTRegistry::_peerAnnounceStorage->removePeerAnnounce(btContext); } } #endif // ENABLE_BITTORRENT diff --git a/src/SocketCore.cc b/src/SocketCore.cc index 6d256a66..7dba735e 100644 --- a/src/SocketCore.cc +++ b/src/SocketCore.cc @@ -48,11 +48,11 @@ # define SOCKET_ERRNO (WSAGetLastError()) #endif // __MINGW32__ -SocketCore::SocketCore():sockfd(-1) { +SocketCore::SocketCore(int sockType):_sockType(sockType), sockfd(-1) { init(); } -SocketCore::SocketCore(int32_t sockfd):sockfd(sockfd) { +SocketCore::SocketCore(int32_t sockfd, int sockType):_sockType(sockType), sockfd(sockfd) { init(); } @@ -82,11 +82,11 @@ SocketCore::~SocketCore() { #endif // HAVE_LIBGNUTLS } -void SocketCore::beginListen(int32_t port) +void SocketCore::bind(uint16_t port) { closeConnection(); - //sockfd = socket(AF_UNSPEC, SOCK_STREAM, PF_UNSPEC); - sockfd = socket(AF_INET, SOCK_STREAM, 0); + //sockfd = socket(AF_UNSPEC, _sockType, PF_UNSPEC); + sockfd = socket(AF_INET, _sockType, 0); if(sockfd == -1) { throw new DlAbortEx(EX_SOCKET_OPEN, errorMsg()); } @@ -107,15 +107,16 @@ void SocketCore::beginListen(int32_t port) sockaddr.sin_addr.s_addr = INADDR_ANY; sockaddr.sin_port = htons(port); - if(bind(sockfd, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == -1) { + if(::bind(sockfd, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == -1) { throw new DlAbortEx(EX_SOCKET_BIND, errorMsg()); } +} +void SocketCore::beginListen() +{ if(listen(sockfd, 1) == -1) { throw new DlAbortEx(EX_SOCKET_LISTEN, errorMsg()); } - - setNonBlockingMode(); } SocketCore* SocketCore::acceptConnection() const @@ -128,7 +129,7 @@ SocketCore* SocketCore::acceptConnection() const if(fd == -1) { throw new DlAbortEx(EX_SOCKET_ACCEPT, errorMsg()); } - SocketCore* s = new SocketCore(fd); + SocketCore* s = new SocketCore(fd, _sockType); return s; } @@ -159,7 +160,7 @@ void SocketCore::getPeerInfo(pair& peerinfo) const void SocketCore::establishConnection(const string& host, int32_t port) { closeConnection(); - sockfd = socket(AF_INET, SOCK_STREAM, 0); + sockfd = socket(AF_INET, _sockType, 0); if(sockfd == -1) { throw new DlAbortEx(EX_SOCKET_OPEN, errorMsg()); } @@ -181,7 +182,7 @@ void SocketCore::establishConnection(const string& host, int32_t port) memset((char*)&ai, 0, sizeof(ai)); ai.ai_flags = 0; ai.ai_family = PF_INET; - ai.ai_socktype = SOCK_STREAM; + ai.ai_socktype = _sockType; ai.ai_protocol = 0; struct addrinfo* res; int32_t ec; @@ -194,6 +195,7 @@ void SocketCore::establishConnection(const string& host, int32_t port) } // make socket non-blocking mode setNonBlockingMode(); + // TODO handle EINTR if(connect(sockfd, (struct sockaddr*)&sockaddr, (socklen_t)sizeof(sockaddr)) == -1 && SOCKET_ERRNO != #ifndef __MINGW32__ EINPROGRESS @@ -574,3 +576,94 @@ void SocketCore::initiateSecureConnection() return buf; #endif // __MINGW32__ } + +template +string uitos(T value) +{ + string str; + if(value == 0) { + str = "0"; + return str; + } + int32_t count = 0; + while(value) { + ++count; + char digit = value%10+'0'; + str.insert(str.begin(), digit); + value /= 10; + } + return str; +} + +void fillSockaddr(sockaddr* addr, int sockType, const string& host, uint16_t port) +{ + struct addrinfo hints; + struct addrinfo* result; + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_INET; + hints.ai_socktype = sockType; + hints.ai_flags = 0; + hints.ai_protocol = 0; + { + int r = getaddrinfo(host.c_str(), uitos(port).c_str(), &hints, &result); + if(r != 0) { + throw new DlAbortEx(EX_RESOLVE_HOSTNAME, + host.c_str(), gai_strerror(r)); + } + } + memcpy(addr, result->ai_addr, result->ai_addrlen); + freeaddrinfo(result); +} + +void SocketCore::writeData(const char* data, size_t len, const string& host, uint16_t port) +{ + struct sockaddr_storage addrPeer; + fillSockaddr((struct sockaddr*)&addrPeer, _sockType, host, port); + ssize_t r; + while((r = sendto(sockfd, data, len, 0, (const sockaddr*)&addrPeer, sizeof(struct sockaddr_storage))) == -1 && EINTR == errno); + if(r == -1) { + throw new DlAbortEx(EX_SOCKET_SEND, errorMsg()); + } +} + +ssize_t SocketCore::readDataFrom(char* data, size_t len, struct sockaddr* sender, socklen_t* senderLength) +{ + ssize_t r; + while((r = recvfrom(sockfd, data, len, 0, sender, senderLength)) == -1 && + EINTR == errno); + if(r == -1) { + throw new DlAbortEx(EX_SOCKET_RECV, errorMsg()); + } + return r; +} + +ssize_t SocketCore::readDataFrom(char* data, size_t len) +{ + + return readDataFrom(data, len, 0, 0); +} + +ssize_t SocketCore::readDataFrom(char* data, size_t len, + pair& sender) +{ + struct sockaddr_storage addrSender; + socklen_t addrSenderLength = sizeof(struct sockaddr_storage); + ssize_t rlength = readDataFrom(data, len, (struct sockaddr*)&addrSender, &addrSenderLength); + + char host[NI_MAXHOST]; + char service[NI_MAXSERV]; + { + int s = getnameinfo((struct sockaddr*)&addrSender, addrSenderLength, + host, NI_MAXHOST, service, NI_MAXSERV, + NI_NUMERICHOST|NI_NUMERICSERV); + if(s != 0) { + throw new DlAbortEx("Failed to get peer's hostname and port. cause: %s", + gai_strerror(s)); + } + } + sender.first = host; + sender.second = atoi(service); // TODO + return rlength; +} + diff --git a/src/SocketCore.h b/src/SocketCore.h index fda3e8a0..262e0d70 100644 --- a/src/SocketCore.h +++ b/src/SocketCore.h @@ -38,6 +38,7 @@ #include "common.h" #include #include +#include #ifdef HAVE_LIBSSL // for SSL @@ -55,6 +56,8 @@ class SocketCore { friend bool operator!=(const SocketCore& s1, const SocketCore& s2); friend bool operator<(const SocketCore& s1, const SocketCore& s2); private: + // socket type defined in + int _sockType; // socket endpoint descriptor int32_t sockfd; // reference counter for this object. @@ -80,12 +83,12 @@ private: #endif // HAVE_LIBGNUTLS void init(); - SocketCore(int32_t sockfd); + SocketCore(int32_t sockfd, int sockType); static int error(); static const char *errorMsg(); static const char *errorMsg(const int err); public: - SocketCore(); + SocketCore(int sockType = SOCK_STREAM); ~SocketCore(); int32_t getSockfd() const { return sockfd; } @@ -93,11 +96,17 @@ public: bool isOpen() const { return sockfd != -1; } /** - * Creates a socket and listens form connection on it. + * Creates a socket and bind it with locahost's address and port. * @param port port to listen. If 0 is specified, os automaticaly * choose avaiable port. */ - void beginListen(int32_t port = 0); + void bind(uint16_t port); + + /** + * Listens form connection on it. + * Call bind(uint16_t) before calling this function. + */ + void beginListen(); /** * Stores host address and port of this socket to addrinfo. @@ -172,6 +181,8 @@ public: writeData(msg.c_str(), msg.size()); } + void writeData(const char* data, size_t len, const string& host, uint16_t port); + /** * Reads up to len bytes from this socket. * data is a pointer pointing the first @@ -186,6 +197,15 @@ public: */ void readData(char* data, int32_t& len); + ssize_t readDataFrom(char* data, size_t len, struct sockaddr* sender, + socklen_t* senderLength); + + ssize_t readDataFrom(char*, size_t len, + pair& sender); + + ssize_t readDataFrom(char* data, size_t len); + /** * Reads up to len bytes from this socket, but bytes are not removed from * this socket. diff --git a/src/Util.h b/src/Util.h index 811050f7..bf531b58 100644 --- a/src/Util.h +++ b/src/Util.h @@ -101,6 +101,11 @@ public: static string toHex(const unsigned char* src, int32_t len); + static string toHex(const string& src) + { + return toHex(reinterpret_cast(src.c_str()), src.size()); + } + static FILE* openFile(const string& filename, const string& mode); static void fileCopy(const string& destFile, const string& src); diff --git a/src/XORCloser.h b/src/XORCloser.h new file mode 100644 index 00000000..33f21047 --- /dev/null +++ b/src/XORCloser.h @@ -0,0 +1,64 @@ +/* */ +#ifndef _D_XOR_CLOSER_H_ +#define _D_XOR_CLOSER_H_ + +#include + +class XORCloser { +private: + const unsigned char* _key; + std::size_t _length; +public: + XORCloser(const unsigned char* key, std::size_t length):_key(key), _length(length) {} + + bool operator()(const unsigned char* key1, + const unsigned char* key2) const + { + for(std::size_t i = 0; i < _length; ++i) { + unsigned char c1 = _key[i]^key1[i]; + unsigned char c2 = _key[i]^key2[i]; + + if(c1 < c2) { + return true; + } else if(c1 > c2) { + return false; + } + } + return true; + } +}; + +#endif // _D_XOR_CLOSER_H_ diff --git a/src/message.h b/src/message.h index 7e08f7ae..f73b0dcd 100644 --- a/src/message.h +++ b/src/message.h @@ -89,6 +89,7 @@ #define MSG_TRACKER_RESPONSE_PROCESSING_FAILED _("CUID#%d - Error occurred while processing tracker response.") #define MSG_TRACKER_REQUEST_CREATION_FAILED _("CUID#%d - Cannot create tracker request.") #define MSG_CREATING_TRACKER_REQUEST _("CUID#%d - Creating new tracker request command #%d") +#define MSG_DHT_ENABLED_PEER _("CUID#%d - The peer is DHT-enabled.") #define MSG_UNRECOGNIZED_URI _("Unrecognized URI or unsupported protocol: %s") #define MSG_TRACKER_WARNING_MESSAGE _("Tracker returned warning message: %s") diff --git a/src/option_processing.cc b/src/option_processing.cc index 4da41332..21e1a607 100644 --- a/src/option_processing.cc +++ b/src/option_processing.cc @@ -131,8 +131,11 @@ Option* option_processing(int argc, char* const argv[]) op->put(PREF_ENABLE_DIRECT_IO, V_FALSE); op->put(PREF_ALLOW_PIECE_LENGTH_CHANGE, V_FALSE); op->put(PREF_METALINK_PREFERRED_PROTOCOL, V_NONE); - op->put(PREF_ENABLE_PEER_EXCHANGE, V_TRUE); op->put(PREF_METALINK_ENABLE_UNIQUE_PROTOCOL, V_TRUE); + op->put(PREF_ENABLE_PEER_EXCHANGE, V_TRUE); + op->put(PREF_ENABLE_DHT, V_FALSE); + op->put(PREF_DHT_LISTEN_PORT, "6881-6999"); + op->put(PREF_DHT_FILE_PATH, Util::getHomeDir()+"/.aria2/dht.dat"); // following options are not parsed by OptionHandler and not stored in Option. bool noConf = false; @@ -210,6 +213,9 @@ Option* option_processing(int argc, char* const argv[]) { "max-upload-limit", required_argument, &lopt, 24 }, { "peer-id-prefix", required_argument, &lopt, 25 }, { "enable-peer-exchange", optional_argument, &lopt, 26 }, + { "enable-dht", optional_argument, &lopt, 27 }, + { "dht-listen-port", required_argument, &lopt, 28 }, + { "dht-entry-point", required_argument, &lopt, 29 }, #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK { "metalink-file", required_argument, NULL, 'M' }, @@ -305,6 +311,15 @@ Option* option_processing(int argc, char* const argv[]) case 26: cmdstream << PREF_ENABLE_PEER_EXCHANGE << "=" << toBoolArg(optarg) << "\n"; break; + case 27: + cmdstream << PREF_ENABLE_DHT << "=" << toBoolArg(optarg) << "\n"; + break; + case 28: + cmdstream << PREF_DHT_LISTEN_PORT << "=" << optarg << "\n"; + break; + case 29: + cmdstream << PREF_DHT_ENTRY_POINT << "=" << optarg << "\n"; + break; case 100: cmdstream << PREF_METALINK_VERSION << "=" << optarg << "\n"; break; diff --git a/src/prefs.h b/src/prefs.h index 3a76b46b..88426c3c 100644 --- a/src/prefs.h +++ b/src/prefs.h @@ -214,6 +214,18 @@ #define PREF_PEER_ID_PREFIX "peer-id-prefix" // values: true | false #define PREF_ENABLE_PEER_EXCHANGE "enable-peer-exchange" +// values: true | false +#define PREF_ENABLE_DHT "enable-dht" +// values: 1*digit +#define PREF_DHT_LISTEN_PORT "dht-listen-port" +// values: a string +#define PREF_DHT_ENTRY_POINT_HOST "dht-entry-point-host" +// values: 1*digit +#define PREF_DHT_ENTRY_POINT_PORT "dht-entry-point-port" +// values: a string (hostname:port) +#define PREF_DHT_ENTRY_POINT "dht-entry-point" +// values: a string +#define PREF_DHT_FILE_PATH "dht-file-path" /** * Metalink related preferences diff --git a/src/usage_text.h b/src/usage_text.h index d6dfcae1..914bacdf 100644 --- a/src/usage_text.h +++ b/src/usage_text.h @@ -256,6 +256,17 @@ _(" --peer-id-prefix=PEERI_ID_PREFIX Specify the prefix of peer ID. The peer ID " Default: -aria2-") #define TEXT_ENABLE_PEER_EXCHANGE \ _(" --enable-peer-exchange[=true|false] Enable peer exchange extension.") +#define TEXT_ENABLE_DHT \ +_(" --enable-dht[=true|false] Enable DHT functionality.") +#define TEXT_DHT_LISTEN_PORT \ +_(" --dht-listen-port... Set UDP listening port for DHT.\n"\ + " Multiple ports can be specified by using ',',\n"\ + " for example: \"6881,6885\". You can also use '-'\n"\ + " to specify a range: \"6881-6999\". ',' and '-' can\n"\ + " be used together.") +#define TEXT_DHT_ENTRY_POINT \ +_(" --dht-entry-point=HOST:PORT Set host and port as an entry point to DHT\n"\ + " network.") #define TEXT_METALINK_FILE \ _(" -M, --metalink-file=METALINK_FILE The file path to the .metalink file.") #define TEXT_METALINK_SERVERS \ diff --git a/test/BNodeTest.cc b/test/BNodeTest.cc new file mode 100644 index 00000000..57bc63d7 --- /dev/null +++ b/test/BNodeTest.cc @@ -0,0 +1,250 @@ +#include "BNode.h" +#include "DHTNode.h" +#include "DHTBucket.h" +#include "DHTUtil.h" +#include "Exception.h" +#include "Util.h" +#include + +class BNodeTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(BNodeTest); + CPPUNIT_TEST(testIsInRange); + CPPUNIT_TEST(testFindBucketFor); + CPPUNIT_TEST(testFindClosestKNodes); + CPPUNIT_TEST(testEnumerateBucket); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testIsInRange(); + void testFindBucketFor(); + void testFindClosestKNodes(); + void testEnumerateBucket(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(BNodeTest); + +void BNodeTest::testIsInRange() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0xff, DHT_ID_LENGTH); + + DHTNodeHandle localNode = new DHTNode(localNodeID); + + DHTBucketHandle bucket1 = new DHTBucket(localNode); + DHTBucketHandle bucket2 = bucket1->split(); + DHTBucketHandle bucket3 = bucket1->split(); + + { + BNode b(bucket1); + CPPUNIT_ASSERT(b.isInRange(localNode->getID())); + } + { + BNode b(bucket2); + CPPUNIT_ASSERT(!b.isInRange(localNode->getID())); + } +} + +void BNodeTest::testFindBucketFor() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0xaa, DHT_ID_LENGTH); + + DHTNodeHandle localNode = new DHTNode(localNodeID); + + DHTBucketHandle bucket1 = new DHTBucket(localNode); + DHTBucketHandle bucket2 = bucket1->split(); + DHTBucketHandle bucket3 = bucket1->split(); + DHTBucketHandle bucket4 = bucket3->split(); + DHTBucketHandle bucket5 = bucket3->split(); + + { + BNode b(bucket5); + CPPUNIT_ASSERT(bucket5 == BNode::findBucketFor(&b, localNodeID)); + } + { + BNode b(bucket1); + CPPUNIT_ASSERT(BNode::findBucketFor(&b, localNodeID).isNull()); + } + { + BNode* b1 = new BNode(bucket1); + BNode* b2 = new BNode(bucket2); + BNode* b3 = new BNode(bucket3); + BNode* b4 = new BNode(bucket4); + BNode* b5 = new BNode(bucket5); + + BNode* bp1 = new BNode(); + bp1->setLeft(b3); + bp1->setRight(b5); + + BNode* bp2 = new BNode(); + bp2->setLeft(bp1); + bp2->setRight(b4); + + BNode* bp3 = new BNode(); + bp3->setLeft(b1); + bp3->setRight(bp2); + + BNode* bp4 = new BNode(); + bp4->setLeft(bp3); + bp4->setRight(b2); + + CPPUNIT_ASSERT(bucket5 == BNode::findBucketFor(bp4, localNode->getID())); + + delete bp4; + } +} + +void BNodeTest::testFindClosestKNodes() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0xaa, DHT_ID_LENGTH); + + DHTNodeHandle localNode = new DHTNode(localNodeID); + + DHTBucketHandle bucket1 = new DHTBucket(localNode); + DHTBucketHandle bucket2 = bucket1->split(); + DHTBucketHandle bucket3 = bucket1->split(); + DHTBucketHandle bucket4 = bucket3->split(); + DHTBucketHandle bucket5 = bucket3->split(); + + unsigned char id[DHT_ID_LENGTH]; + { + BNode* b1 = new BNode(bucket1); + BNode* b2 = new BNode(bucket2); + BNode* b3 = new BNode(bucket3); + BNode* b4 = new BNode(bucket4); + BNode* b5 = new BNode(bucket5); + + BNode* bp1 = new BNode(); + bp1->setLeft(b3); + bp1->setRight(b5); + + BNode* bp2 = new BNode(); + bp2->setLeft(bp1); + bp2->setRight(b4); + + BNode* bp3 = new BNode(); + bp3->setLeft(b1); + bp3->setRight(bp2); + + BNode* bp4 = new BNode(); + bp4->setLeft(bp3); + bp4->setRight(b2); + + + for(size_t i = 0; i < 2; ++i) { + bucket1->getRandomNodeID(id); + bucket1->addNode(new DHTNode(id)); + bucket2->getRandomNodeID(id); + bucket2->addNode(new DHTNode(id)); + bucket3->getRandomNodeID(id); + bucket3->addNode(new DHTNode(id)); + bucket4->getRandomNodeID(id); + bucket4->addNode(new DHTNode(id)); + bucket5->getRandomNodeID(id); + bucket5->addNode(new DHTNode(id)); + } + { + unsigned char targetID[DHT_ID_LENGTH]; + memset(targetID, 0x80, DHT_ID_LENGTH); + DHTNodes nodes = BNode::findClosestKNodes(bp4, targetID); + CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size()); + CPPUNIT_ASSERT(bucket4->isInRange(nodes[0])); + CPPUNIT_ASSERT(bucket4->isInRange(nodes[1])); + CPPUNIT_ASSERT(bucket5->isInRange(nodes[2])); + CPPUNIT_ASSERT(bucket5->isInRange(nodes[3])); + CPPUNIT_ASSERT(bucket3->isInRange(nodes[4])); + CPPUNIT_ASSERT(bucket3->isInRange(nodes[5])); + CPPUNIT_ASSERT(bucket1->isInRange(nodes[6])); + CPPUNIT_ASSERT(bucket1->isInRange(nodes[7])); + } + { + unsigned char targetID[DHT_ID_LENGTH]; + memset(targetID, 0xf0, DHT_ID_LENGTH); + DHTNodes nodes = BNode::findClosestKNodes(bp4, targetID); + CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size()); + CPPUNIT_ASSERT(bucket1->isInRange(nodes[0])); + CPPUNIT_ASSERT(bucket1->isInRange(nodes[1])); + CPPUNIT_ASSERT(bucket3->isInRange(nodes[2])); + CPPUNIT_ASSERT(bucket3->isInRange(nodes[3])); + CPPUNIT_ASSERT(bucket5->isInRange(nodes[4])); + CPPUNIT_ASSERT(bucket5->isInRange(nodes[5])); + CPPUNIT_ASSERT(bucket4->isInRange(nodes[6])); + CPPUNIT_ASSERT(bucket4->isInRange(nodes[7])); + } + { + for(size_t i = 0; i < 6; ++i) { + bucket4->getRandomNodeID(id); + bucket4->addNode(new DHTNode(id)); + } + unsigned char targetID[DHT_ID_LENGTH]; + memset(targetID, 0x80, DHT_ID_LENGTH); + DHTNodes nodes = BNode::findClosestKNodes(bp4, targetID); + CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size()); + for(size_t i = 0; i < DHTBucket::K; ++i) { + CPPUNIT_ASSERT(bucket4->isInRange(nodes[i])); + } + } + delete bp4; + } +} + + +void BNodeTest::testEnumerateBucket() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0xaa, DHT_ID_LENGTH); + + DHTNodeHandle localNode = new DHTNode(localNodeID); + + DHTBucketHandle bucket1 = new DHTBucket(localNode); + DHTBucketHandle bucket2 = bucket1->split(); + DHTBucketHandle bucket3 = bucket1->split(); + DHTBucketHandle bucket4 = bucket3->split(); + DHTBucketHandle bucket5 = bucket3->split(); + + { + BNode b(bucket1); + DHTBuckets buckets = BNode::enumerateBucket(&b); + CPPUNIT_ASSERT_EQUAL((size_t)1, buckets.size()); + CPPUNIT_ASSERT(bucket1 == buckets[0]); + } + { + BNode* b1 = new BNode(bucket1); + BNode* b2 = new BNode(bucket2); + BNode* b3 = new BNode(bucket3); + BNode* b4 = new BNode(bucket4); + BNode* b5 = new BNode(bucket5); + + BNode* bp1 = new BNode(); + bp1->setLeft(b3); + bp1->setRight(b5); + + BNode* bp2 = new BNode(); + bp2->setLeft(bp1); + bp2->setRight(b4); + + BNode* bp3 = new BNode(); + bp3->setLeft(b1); + bp3->setRight(bp2); + + BNode* bp4 = new BNode(); + bp4->setLeft(bp3); + bp4->setRight(b2); + + DHTBuckets buckets = BNode::enumerateBucket(bp4); + CPPUNIT_ASSERT_EQUAL((size_t)5, buckets.size()); + CPPUNIT_ASSERT(bucket1 == buckets[0]); + CPPUNIT_ASSERT(bucket3 == buckets[1]); + CPPUNIT_ASSERT(bucket5 == buckets[2]); + CPPUNIT_ASSERT(bucket4 == buckets[3]); + CPPUNIT_ASSERT(bucket2 == buckets[4]); + + delete bp4; + } +} diff --git a/test/BtHandshakeMessageTest.cc b/test/BtHandshakeMessageTest.cc index 64b9d774..ce57b7f4 100644 --- a/test/BtHandshakeMessageTest.cc +++ b/test/BtHandshakeMessageTest.cc @@ -11,6 +11,7 @@ class BtHandshakeMessageTest:public CppUnit::TestFixture { CPPUNIT_TEST(testCreate); CPPUNIT_TEST(testGetMessage); CPPUNIT_TEST(testToString); + CPPUNIT_TEST(testSetDHTEnabled); CPPUNIT_TEST_SUITE_END(); private: @@ -21,6 +22,7 @@ public: void testCreate(); void testGetMessage(); void testToString(); + void testSetDHTEnabled(); static string BTPSTR; }; @@ -100,3 +102,13 @@ void BtHandshakeMessageTest::testToString() { CPPUNIT_ASSERT_EQUAL(string("handshake peerId=%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0%f0, reserved=0000000000100004"), msg.toString()); } + +void BtHandshakeMessageTest::testSetDHTEnabled() +{ + BtHandshakeMessage msg; + CPPUNIT_ASSERT(!msg.isDHTEnabled()); + msg.setDHTEnabled(false); + CPPUNIT_ASSERT(!msg.isDHTEnabled()); + msg.setDHTEnabled(true); + CPPUNIT_ASSERT(msg.isDHTEnabled()); +} diff --git a/test/BtPortMessageTest.cc b/test/BtPortMessageTest.cc index 73bae9d3..f1c63f6d 100644 --- a/test/BtPortMessageTest.cc +++ b/test/BtPortMessageTest.cc @@ -1,6 +1,10 @@ #include "BtPortMessage.h" #include "PeerMessageUtil.h" #include "Util.h" +#include "DHTNode.h" +#include "MockDHTTask.h" +#include "MockDHTTaskFactory.h" +#include "MockDHTTaskQueue.h" #include using namespace std; @@ -10,6 +14,8 @@ class BtPortMessageTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE(BtPortMessageTest); CPPUNIT_TEST(testCreate); CPPUNIT_TEST(testToString); + CPPUNIT_TEST(testGetMessage); + CPPUNIT_TEST(testDoReceivedAction); CPPUNIT_TEST_SUITE_END(); private: @@ -19,6 +25,17 @@ public: void testCreate(); void testToString(); + void testGetMessage(); + void testDoReceivedAction(); + + class MockDHTTaskFactory2:public MockDHTTaskFactory { + public: + virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode, + size_t numRetry) + { + return new MockDHTTask(remoteNode); + } + }; }; @@ -28,9 +45,9 @@ void BtPortMessageTest::testCreate() { unsigned char msg[7]; PeerMessageUtil::createPeerMessageString(msg, sizeof(msg), 3, 9); PeerMessageUtil::setShortIntParam(&msg[5], 12345); - BtPortMessageHandle pm = BtPortMessage::create(&msg[4], 3); + SharedHandle pm = BtPortMessage::create(&msg[4], 3); CPPUNIT_ASSERT_EQUAL((int8_t)9, pm->getId()); - CPPUNIT_ASSERT_EQUAL((int16_t)12345, pm->getPort()); + CPPUNIT_ASSERT_EQUAL((uint16_t)12345, pm->getPort()); // case: payload size is wrong try { @@ -49,7 +66,34 @@ void BtPortMessageTest::testCreate() { } catch(...) { } } + void BtPortMessageTest::testToString() { BtPortMessage msg(1); CPPUNIT_ASSERT_EQUAL(string("port port=1"), msg.toString()); } + +void BtPortMessageTest::testGetMessage() { + BtPortMessage msg(6881); + unsigned char data[7]; + PeerMessageUtil::createPeerMessageString(data, sizeof(data), 3, 9); + PeerMessageUtil::setShortIntParam(&data[5], 6881); + CPPUNIT_ASSERT(memcmp(msg.getMessage(), data, 7) == 0); +} + +void BtPortMessageTest::testDoReceivedAction() +{ + PeerHandle peer = new Peer("192.168.0.1", 6881); + BtPortMessage msg(6881); + MockDHTTaskQueue taskQueue; + MockDHTTaskFactory2 taskFactory; + msg.setTaskQueue(&taskQueue); + msg.setTaskFactory(&taskFactory); + msg.setPeer(peer); + + msg.doReceivedAction(); + + CPPUNIT_ASSERT_EQUAL((size_t)1, taskQueue._immediateTaskQueue.size()); + DHTNodeHandle node = SharedHandle(taskQueue._immediateTaskQueue.front())->_remoteNode; + CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), node->getIPAddress()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, node->getPort()); +} diff --git a/test/DHTAnnouncePeerMessageTest.cc b/test/DHTAnnouncePeerMessageTest.cc new file mode 100644 index 00000000..a614b2d2 --- /dev/null +++ b/test/DHTAnnouncePeerMessageTest.cc @@ -0,0 +1,62 @@ +#include "DHTAnnouncePeerMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTAnnouncePeerMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTAnnouncePeerMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTAnnouncePeerMessageTest); + +void DHTAnnouncePeerMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + unsigned char infoHash[DHT_ID_LENGTH]; + DHTUtil::generateRandomData(infoHash, DHT_ID_LENGTH); + + string token = "token"; + uint16_t port = 6881; + + DHTAnnouncePeerMessage msg(localNode, remoteNode, infoHash, port, token, transactionID); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("q")); + cm->put("q", new Data("announce_peer")); + Dictionary* a = new Dictionary(); + cm->put("a", a); + a->put("id", new Data(reinterpret_cast(localNode->getID()), DHT_ID_LENGTH)); + a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH)); + a->put("port", new Data(Util::uitos(port), true)); + a->put("token", new Data(token)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()), + Util::urlencode(msgbody)); +} diff --git a/test/DHTAnnouncePeerReplyMessageTest.cc b/test/DHTAnnouncePeerReplyMessageTest.cc new file mode 100644 index 00000000..6cf6f6e1 --- /dev/null +++ b/test/DHTAnnouncePeerReplyMessageTest.cc @@ -0,0 +1,51 @@ +#include "DHTAnnouncePeerReplyMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTAnnouncePeerReplyMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTAnnouncePeerReplyMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTAnnouncePeerReplyMessageTest); + +void DHTAnnouncePeerReplyMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + DHTAnnouncePeerReplyMessage msg(localNode, remoteNode, transactionID); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + cm->put("r", r); + r->put("id", new Data(localNode->getID(), DHT_ID_LENGTH)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody); +} diff --git a/test/DHTBucketTest.cc b/test/DHTBucketTest.cc new file mode 100644 index 00000000..f79721e4 --- /dev/null +++ b/test/DHTBucketTest.cc @@ -0,0 +1,336 @@ +#include "DHTBucket.h" +#include "DHTNode.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTBucketTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTBucketTest); + CPPUNIT_TEST(testGetRandomNodeID); + CPPUNIT_TEST(testIsInRange); + CPPUNIT_TEST(testSplitAllowed); + CPPUNIT_TEST(testSplit); + CPPUNIT_TEST(testAddNode); + CPPUNIT_TEST(testMoveToHead); + CPPUNIT_TEST(testMoveToTail); + CPPUNIT_TEST(testGetGoodNodes); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetRandomNodeID(); + void testIsInRange(); + void testSplitAllowed(); + void testSplit(); + void testAddNode(); + void testMoveToHead(); + void testMoveToTail(); + void testGetGoodNodes(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTBucketTest); + +void DHTBucketTest::testGetRandomNodeID() +{ + unsigned char localNodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle localNode = new DHTNode(localNodeID); + { + DHTBucket bucket(localNode); + unsigned char nodeID[DHT_ID_LENGTH]; + bucket.getRandomNodeID(nodeID); + } + { + unsigned char max[] = { 0x01, 0x01, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }; + unsigned char min[] = { 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTBucket bucket(16, max, min, localNode); + unsigned char nodeID[DHT_ID_LENGTH]; + bucket.getRandomNodeID(nodeID); + CPPUNIT_ASSERT_EQUAL(string("0101"), + Util::toHex(nodeID, sizeof(nodeID)).substr(0, 4)); + } +} + +void DHTBucketTest::testIsInRange() +{ + unsigned char localNodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle localNode = new DHTNode(localNodeID); + { + unsigned char nodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle node = new DHTNode(nodeID); + DHTBucket bucket(localNode); + CPPUNIT_ASSERT(bucket.isInRange(node)); + memset(nodeID, 0xff, sizeof(nodeID)); + CPPUNIT_ASSERT(bucket.isInRange(node)); + } + { + unsigned char max[] = { 0x01, 0x01, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }; + unsigned char min[] = { 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + { + //min + unsigned char nodeID[] = { 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle node = new DHTNode(nodeID); + DHTBucket bucket(16, max, min, localNode); + CPPUNIT_ASSERT(bucket.isInRange(node)); + } + { + //max + unsigned char nodeID[] = { 0x01, 0x01, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }; + DHTNodeHandle node = new DHTNode(nodeID); + DHTBucket bucket(16, max, min, localNode); + CPPUNIT_ASSERT(bucket.isInRange(node)); + } + { + unsigned char nodeID[] = { 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }; + DHTNodeHandle node = new DHTNode(nodeID); + DHTBucket bucket(16, max, min, localNode); + CPPUNIT_ASSERT(bucket.isInRange(node)); + } + { + // nodeID is out of range: smaller than this range + unsigned char nodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle node = new DHTNode(nodeID); + DHTBucket bucket(16, max, min, localNode); + CPPUNIT_ASSERT(!bucket.isInRange(node)); + } + { + // nodeID is out of range: larger than this range + unsigned char nodeID[] = { 0x10, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle node = new DHTNode(nodeID); + DHTBucket bucket(16, max, min, localNode); + CPPUNIT_ASSERT(!bucket.isInRange(node)); + } + } +} + +void DHTBucketTest::testSplitAllowed() +{ + { + unsigned char localNodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(localNode); + CPPUNIT_ASSERT(bucket.splitAllowed()); + } + { + unsigned char max[] = { 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }; + unsigned char min[] = { 0xe0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + { + unsigned char localNodeID[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(3, max, min, localNode); + CPPUNIT_ASSERT(!bucket.splitAllowed()); + } + { + unsigned char localNodeID[] = { 0xe0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01 }; + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(3, max, min, localNode); + CPPUNIT_ASSERT(bucket.splitAllowed()); + } + } +} + +void DHTBucketTest::testSplit() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0, DHT_ID_LENGTH); + DHTNodeHandle localNode = new DHTNode(localNodeID); + { + DHTBucket bucket(localNode); + DHTBucketHandle r = bucket.split(); + { + unsigned char expectedRMax[] = { 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff }; + unsigned char expectedRMin[DHT_ID_LENGTH]; + memset(expectedRMin, 0, DHT_ID_LENGTH); + CPPUNIT_ASSERT_EQUAL(Util::toHex(expectedRMax, DHT_ID_LENGTH), + Util::toHex(r->getMaxID(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL(Util::toHex(expectedRMin, DHT_ID_LENGTH), + Util::toHex(r->getMinID(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL((size_t)1, r->getPrefixLength()); + } + { + unsigned char expectedLMax[DHT_ID_LENGTH]; + memset(expectedLMax, 0xff, DHT_ID_LENGTH); + unsigned char expectedLMin[] = { 0x80, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00 }; + CPPUNIT_ASSERT_EQUAL(Util::toHex(expectedLMax, DHT_ID_LENGTH), + Util::toHex(bucket.getMaxID(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL(Util::toHex(expectedLMin, DHT_ID_LENGTH), + Util::toHex(bucket.getMinID(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL((size_t)1, bucket.getPrefixLength()); + } + } + { + DHTBucketHandle bucket = new DHTBucket(localNode); + for(int i = 0; i < 159; ++i) { + CPPUNIT_ASSERT(bucket->splitAllowed()); + DHTBucketHandle t = bucket; + bucket = bucket->split(); + CPPUNIT_ASSERT(!t->splitAllowed()); + } + CPPUNIT_ASSERT(!bucket->splitAllowed()); + unsigned char expectedMax[] = { 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01 }; + unsigned char expectedMin[DHT_ID_LENGTH]; + memset(expectedMin, 0, DHT_ID_LENGTH); + CPPUNIT_ASSERT_EQUAL(Util::toHex(expectedMax, DHT_ID_LENGTH), + Util::toHex(bucket->getMaxID(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL(Util::toHex(expectedMin, DHT_ID_LENGTH), + Util::toHex(bucket->getMinID(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL((size_t)159, bucket->getPrefixLength()); + } +} + +static void createID(unsigned char* id, unsigned char firstChar, unsigned char lastChar) +{ + memset(id, 0, DHT_ID_LENGTH); + id[0] = firstChar; + id[DHT_ID_LENGTH-1] = lastChar; +} + +void DHTBucketTest::testAddNode() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0, DHT_ID_LENGTH); + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(localNode); + + unsigned char id[DHT_ID_LENGTH]; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0xf0, i); + nodes[i] = new DHTNode(id); + CPPUNIT_ASSERT(bucket.addNode(nodes[i])); + } + createID(id, 0xf0, 0xff); + DHTNodeHandle newNode = new DHTNode(id); + CPPUNIT_ASSERT(!bucket.addNode(newNode)); + + // nodes[0] is located at the tail of the bucket(least recent seen) + nodes[0]->markBad(); + CPPUNIT_ASSERT(bucket.addNode(newNode)); + CPPUNIT_ASSERT(bucket.getNodes().back() == newNode); +} + +void DHTBucketTest::testMoveToHead() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0, DHT_ID_LENGTH); + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(localNode); + + unsigned char id[DHT_ID_LENGTH]; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0xf0, i); + nodes[i] = new DHTNode(id); + CPPUNIT_ASSERT(bucket.addNode(nodes[i])); + } + bucket.moveToHead(nodes[DHTBucket::K-1]); + CPPUNIT_ASSERT(bucket.getNodes().front() == nodes[DHTBucket::K-1]); +} + +void DHTBucketTest::testMoveToTail() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0, DHT_ID_LENGTH); + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(localNode); + + unsigned char id[DHT_ID_LENGTH]; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0xf0, i); + nodes[i] = new DHTNode(id); + CPPUNIT_ASSERT(bucket.addNode(nodes[i])); + } + bucket.moveToTail(nodes[0]); + CPPUNIT_ASSERT(bucket.getNodes().back() == nodes[0]); +} + +void DHTBucketTest::testGetGoodNodes() +{ + unsigned char localNodeID[DHT_ID_LENGTH]; + memset(localNodeID, 0, DHT_ID_LENGTH); + DHTNodeHandle localNode = new DHTNode(localNodeID); + DHTBucket bucket(localNode); + + unsigned char id[DHT_ID_LENGTH]; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0xf0, i); + nodes[i] = new DHTNode(id); + nodes[i]->setPort(6881+i); + CPPUNIT_ASSERT(bucket.addNode(nodes[i])); + } + nodes[3]->markBad(); + nodes[5]->markBad(); + DHTNodes goodNodes = bucket.getGoodNodes(); + CPPUNIT_ASSERT_EQUAL((size_t)6, goodNodes.size()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, goodNodes[0]->getPort()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6882, goodNodes[1]->getPort()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6883, goodNodes[2]->getPort()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6885, goodNodes[3]->getPort()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6887, goodNodes[4]->getPort()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6888, goodNodes[5]->getPort()); +} diff --git a/test/DHTConnectionImplTest.cc b/test/DHTConnectionImplTest.cc new file mode 100644 index 00000000..74c975af --- /dev/null +++ b/test/DHTConnectionImplTest.cc @@ -0,0 +1,47 @@ +#include "DHTConnectionImpl.h" +#include "Exception.h" +#include + +class DHTConnectionImplTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTConnectionImplTest); + CPPUNIT_TEST(testWriteAndReadData); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testWriteAndReadData(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTConnectionImplTest); + +void DHTConnectionImplTest::testWriteAndReadData() +{ + try { + DHTConnectionImpl con1; + /*uint16_t con1port =*/ con1.bind(0); + DHTConnectionImpl con2; + uint16_t con2port = con2.bind(0); + + string message1 = "hello world."; + con1.sendMessage(message1.c_str(), message1.size(), "localhost", con2port); + + char readbuffer[100]; + string remoteHost; + uint16_t remotePort; + { + ssize_t rlength = con2.receiveMessage(readbuffer, sizeof(readbuffer), remoteHost, remotePort); + CPPUNIT_ASSERT_EQUAL(string("127.0.0.1"), remoteHost); + CPPUNIT_ASSERT_EQUAL((ssize_t)message1.size(), rlength); + readbuffer[rlength] = '\0'; + CPPUNIT_ASSERT_EQUAL(message1, string(readbuffer)); + } + } catch(Exception* e) { + cerr << *e << endl; + delete e; + CPPUNIT_FAIL("exception thrown"); + } +} diff --git a/test/DHTFindNodeMessageTest.cc b/test/DHTFindNodeMessageTest.cc new file mode 100644 index 00000000..cdcee77a --- /dev/null +++ b/test/DHTFindNodeMessageTest.cc @@ -0,0 +1,55 @@ +#include "DHTFindNodeMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTFindNodeMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTFindNodeMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTFindNodeMessageTest); + +void DHTFindNodeMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + DHTNodeHandle targetNode = new DHTNode(); + + DHTFindNodeMessage msg(localNode, remoteNode, targetNode->getID(), transactionID); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("q")); + cm->put("q", new Data("find_node")); + Dictionary* a = new Dictionary(); + cm->put("a", a); + a->put("id", new Data(reinterpret_cast(localNode->getID()), DHT_ID_LENGTH)); + a->put("target", new Data(reinterpret_cast(targetNode->getID()), DHT_ID_LENGTH)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody); +} diff --git a/test/DHTFindNodeReplyMessageTest.cc b/test/DHTFindNodeReplyMessageTest.cc new file mode 100644 index 00000000..b683203f --- /dev/null +++ b/test/DHTFindNodeReplyMessageTest.cc @@ -0,0 +1,69 @@ +#include "DHTFindNodeReplyMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include "DHTBucket.h" +#include "PeerMessageUtil.h" +#include + +class DHTFindNodeReplyMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTFindNodeReplyMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTFindNodeReplyMessageTest); + +void DHTFindNodeReplyMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + DHTFindNodeReplyMessage msg(localNode, remoteNode, transactionID); + + string compactNodeInfo; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + nodes[i] = new DHTNode(); + nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1)); + nodes[i]->setPort(6881+i); + + char buf[6]; + CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort())); + compactNodeInfo += + string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+ + string(&buf[0], &buf[sizeof(buf)]); + } + msg.setClosestKNodes(DHTNodes(&nodes[0], &nodes[DHTBucket::K])); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + cm->put("r", r); + r->put("id", new Data(reinterpret_cast(localNode->getID()), DHT_ID_LENGTH)); + r->put("nodes", new Data(compactNodeInfo)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody); +} diff --git a/test/DHTGetPeersMessageTest.cc b/test/DHTGetPeersMessageTest.cc new file mode 100644 index 00000000..0fbbe0f0 --- /dev/null +++ b/test/DHTGetPeersMessageTest.cc @@ -0,0 +1,57 @@ +#include "DHTGetPeersMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTGetPeersMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTGetPeersMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTGetPeersMessageTest); + +void DHTGetPeersMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + unsigned char infoHash[DHT_ID_LENGTH]; + DHTUtil::generateRandomData(infoHash, DHT_ID_LENGTH); + + DHTGetPeersMessage msg(localNode, remoteNode, infoHash, transactionID); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("q")); + cm->put("q", new Data("get_peers")); + Dictionary* a = new Dictionary(); + cm->put("a", a); + a->put("id", new Data(reinterpret_cast(localNode->getID()), DHT_ID_LENGTH)); + a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()), + Util::urlencode(msgbody)); +} diff --git a/test/DHTGetPeersReplyMessageTest.cc b/test/DHTGetPeersReplyMessageTest.cc new file mode 100644 index 00000000..537dd5f1 --- /dev/null +++ b/test/DHTGetPeersReplyMessageTest.cc @@ -0,0 +1,97 @@ +#include "DHTGetPeersReplyMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include "DHTBucket.h" +#include "PeerMessageUtil.h" +#include "List.h" +#include "Peer.h" +#include + +class DHTGetPeersReplyMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTGetPeersReplyMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTGetPeersReplyMessageTest); + +void DHTGetPeersReplyMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + string token = "token"; + + DHTGetPeersReplyMessage msg(localNode, remoteNode, token, transactionID); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + cm->put("r", r); + r->put("id", new Data(reinterpret_cast(localNode->getID()), DHT_ID_LENGTH)); + r->put("token", new Data(token)); + + { + string compactNodeInfo; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + nodes[i] = new DHTNode(); + nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1)); + nodes[i]->setPort(6881+i); + + char buf[6]; + CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort())); + compactNodeInfo += + string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+ + string(&buf[0], &buf[sizeof(buf)]); + } + msg.setClosestKNodes(DHTNodes(&nodes[0], &nodes[DHTBucket::K])); + + string msgbody = msg.getBencodedMessage(); + + r->put("nodes", new Data(compactNodeInfo)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()), + Util::urlencode(msgbody)); + } + r->remove("nodes"); + { + Peers peers; + List* values = new List(); + r->put("values", values); + for(size_t i = 0; i < 4; ++i) { + PeerHandle peer = new Peer("192.168.0."+Util::uitos(i+1), 6881+i); + char buffer[6]; + CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)); + values->add(new Data(buffer, sizeof(buffer))); + peers.push_back(peer); + } + msg.setValues(peers); + string msgbody = msg.getBencodedMessage(); + BencodeVisitor v; + cm->accept(&v); + CPPUNIT_ASSERT_EQUAL(Util::urlencode(v.getBencodedData()), + Util::urlencode(msgbody)); + } +} diff --git a/test/DHTIDCloserTest.cc b/test/DHTIDCloserTest.cc new file mode 100644 index 00000000..3851742f --- /dev/null +++ b/test/DHTIDCloserTest.cc @@ -0,0 +1,57 @@ +#include "DHTNode.h" +#include "DHTNodeLookupEntry.h" +#include "DHTIDCloser.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTIDCloserTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTIDCloserTest); + CPPUNIT_TEST(testOperator); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testOperator(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTIDCloserTest); + +void DHTIDCloserTest::testOperator() +{ + unsigned char id[DHT_ID_LENGTH]; + memset(id, 0xf0, DHT_ID_LENGTH); + + DHTNodeLookupEntryHandle e1 = new DHTNodeLookupEntry(new DHTNode(id)); + + id[0] = 0xb0; + DHTNodeLookupEntryHandle e2 = new DHTNodeLookupEntry(new DHTNode(id)); + + id[0] = 0xa0; + DHTNodeLookupEntryHandle e3 = new DHTNodeLookupEntry(new DHTNode(id)); + + id[0] = 0x80; + DHTNodeLookupEntryHandle e4 = new DHTNodeLookupEntry(new DHTNode(id)); + + id[0] = 0x00; + DHTNodeLookupEntryHandle e5 = new DHTNodeLookupEntry(new DHTNode(id)); + + DHTNodeLookupEntries entries; + entries.push_back(e1); + entries.push_back(e2); + entries.push_back(e3); + entries.push_back(e4); + entries.push_back(e5); + + std::sort(entries.begin(), entries.end(), DHTIDCloser(e3->_node->getID())); + + CPPUNIT_ASSERT(e3 == entries[0]); + CPPUNIT_ASSERT(e2 == entries[1]); + CPPUNIT_ASSERT(e4 == entries[2]); + CPPUNIT_ASSERT(e1 == entries[3]); + CPPUNIT_ASSERT(e5 == entries[4]); +} diff --git a/test/DHTMessageFactoryImplTest.cc b/test/DHTMessageFactoryImplTest.cc new file mode 100644 index 00000000..4dcdf1c9 --- /dev/null +++ b/test/DHTMessageFactoryImplTest.cc @@ -0,0 +1,361 @@ +#include "DHTMessageFactoryImpl.h" +#include "Exception.h" +#include "Util.h" +#include "DHTNode.h" +#include "DHTRoutingTable.h" +#include "Dictionary.h" +#include "Data.h" +#include "List.h" +#include "Peer.h" +#include "PeerMessageUtil.h" +#include "DHTBucket.h" +#include "DHTPingMessage.h" +#include "DHTPingReplyMessage.h" +#include "DHTFindNodeMessage.h" +#include "DHTFindNodeReplyMessage.h" +#include "DHTGetPeersMessage.h" +#include "DHTGetPeersReplyMessage.h" +#include "DHTAnnouncePeerMessage.h" +#include "DHTAnnouncePeerReplyMessage.h" +#include + +class DHTMessageFactoryImplTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTMessageFactoryImplTest); + CPPUNIT_TEST(testCreatePingMessage); + CPPUNIT_TEST(testCreatePingReplyMessage); + CPPUNIT_TEST(testCreateFindNodeMessage); + CPPUNIT_TEST(testCreateFindNodeReplyMessage); + CPPUNIT_TEST(testCreateGetPeersMessage); + CPPUNIT_TEST(testCreateGetPeersReplyMessage_nodes); + CPPUNIT_TEST(testCreateGetPeersReplyMessage_values); + CPPUNIT_TEST(testCreateAnnouncePeerMessage); + CPPUNIT_TEST(testCreateAnnouncePeerReplyMessage); + CPPUNIT_TEST_SUITE_END(); +public: + DHTMessageFactoryImplTest():factory(0), routingTable(0), localNode(0) {} + + DHTMessageFactoryImpl* factory; + + DHTRoutingTableHandle routingTable; + + DHTNodeHandle localNode; + + unsigned char transactionID[DHT_TRANSACTION_ID_LENGTH]; + + unsigned char remoteNodeID[DHT_ID_LENGTH]; + + void setUp() + { + localNode = new DHTNode(); + factory = new DHTMessageFactoryImpl(); + factory->setLocalNode(localNode); + memset(transactionID, 0xff, DHT_TRANSACTION_ID_LENGTH); + memset(remoteNodeID, 0x0f, DHT_ID_LENGTH); + routingTable = new DHTRoutingTable(localNode); + factory->setRoutingTable(routingTable); + } + + void tearDown() + { + delete factory; + } + + void testCreatePingMessage(); + void testCreatePingReplyMessage(); + void testCreateFindNodeMessage(); + void testCreateFindNodeReplyMessage(); + void testCreateGetPeersMessage(); + void testCreateGetPeersReplyMessage_nodes(); + void testCreateGetPeersReplyMessage_values(); + void testCreateAnnouncePeerMessage(); + void testCreateAnnouncePeerReplyMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageFactoryImplTest); + +void DHTMessageFactoryImplTest::testCreatePingMessage() +{ + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("q")); + d->put("q", new Data("ping")); + Dictionary* a = new Dictionary(); + a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + d->put("a", a); + + SharedHandle m = factory->createQueryMessage(d.get(), "192.168.0.1", 6881); + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); +} + +void DHTMessageFactoryImplTest::testCreatePingReplyMessage() +{ + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + d->put("r", r); + + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + SharedHandle m = factory->createResponseMessage("ping", d.get(), remoteNode); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); +} + +void DHTMessageFactoryImplTest::testCreateFindNodeMessage() +{ + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("q")); + d->put("q", new Data("find_node")); + Dictionary* a = new Dictionary(); + a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + unsigned char targetNodeID[DHT_ID_LENGTH]; + memset(targetNodeID, 0x11, DHT_ID_LENGTH); + a->put("target", new Data(targetNodeID, DHT_ID_LENGTH)); + d->put("a", a); + + SharedHandle m = factory->createQueryMessage(d.get(), "192.168.0.1", 6881); + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); + CPPUNIT_ASSERT_EQUAL(Util::toHex(targetNodeID, DHT_ID_LENGTH), + Util::toHex(m->getTargetNodeID(), DHT_ID_LENGTH)); +} + +void DHTMessageFactoryImplTest::testCreateFindNodeReplyMessage() +{ + try { + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + string compactNodeInfo; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + nodes[i] = new DHTNode(); + nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1)); + nodes[i]->setPort(6881+i); + + char buf[6]; + CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort())); + compactNodeInfo += + string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+ + string(&buf[0], &buf[sizeof(buf)]); + } + r->put("nodes", new Data(compactNodeInfo)); + d->put("r", r); + + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + SharedHandle m = factory->createResponseMessage("find_node", d.get(), remoteNode); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL((size_t)DHTBucket::K, m->getClosestKNodes().size()); + CPPUNIT_ASSERT(nodes[0] == m->getClosestKNodes()[0]); + CPPUNIT_ASSERT(nodes[7] == m->getClosestKNodes()[7]); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); + } catch(Exception* e) { + cerr << *e << endl; + CPPUNIT_FAIL("exception thrown."); + } +} + +void DHTMessageFactoryImplTest::testCreateGetPeersMessage() +{ + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("q")); + d->put("q", new Data("get_peers")); + Dictionary* a = new Dictionary(); + a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + unsigned char infoHash[DHT_ID_LENGTH]; + memset(infoHash, 0x11, DHT_ID_LENGTH); + a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH)); + d->put("a", a); + + SharedHandle m = factory->createQueryMessage(d.get(), "192.168.0.1", 6881); + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); + CPPUNIT_ASSERT_EQUAL(Util::toHex(infoHash, DHT_ID_LENGTH), + Util::toHex(m->getInfoHash(), DHT_ID_LENGTH)); +} + +void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_nodes() +{ + try { + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + string compactNodeInfo; + DHTNodeHandle nodes[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + nodes[i] = new DHTNode(); + nodes[i]->setIPAddress("192.168.0."+Util::uitos(i+1)); + nodes[i]->setPort(6881+i); + + char buf[6]; + CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buf, nodes[i]->getIPAddress(), nodes[i]->getPort())); + compactNodeInfo += + string(&nodes[i]->getID()[0], &nodes[i]->getID()[DHT_ID_LENGTH])+ + string(&buf[0], &buf[sizeof(buf)]); + } + r->put("nodes", new Data(compactNodeInfo)); + r->put("token", new Data("token")); + d->put("r", r); + + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + SharedHandle m = factory->createResponseMessage("get_peers", d.get(), remoteNode); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(string("token"), m->getToken()); + CPPUNIT_ASSERT_EQUAL((size_t)DHTBucket::K, m->getClosestKNodes().size()); + CPPUNIT_ASSERT(nodes[0] == m->getClosestKNodes()[0]); + CPPUNIT_ASSERT(nodes[7] == m->getClosestKNodes()[7]); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); + } catch(Exception* e) { + cerr << *e << endl; + CPPUNIT_FAIL("exception thrown."); + } +} + +void DHTMessageFactoryImplTest::testCreateGetPeersReplyMessage_values() +{ + try { + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + + Peers peers; + List* values = new List(); + r->put("values", values); + for(size_t i = 0; i < 4; ++i) { + PeerHandle peer = new Peer("192.168.0."+Util::uitos(i+1), 6881+i); + char buffer[6]; + CPPUNIT_ASSERT(PeerMessageUtil::createcompact(buffer, peer->ipaddr, peer->port)); + values->add(new Data(buffer, sizeof(buffer))); + peers.push_back(peer); + } + r->put("values", values); + r->put("token", new Data("token")); + d->put("r", r); + + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + SharedHandle m = factory->createResponseMessage("get_peers", d.get(), remoteNode); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(string("token"), m->getToken()); + CPPUNIT_ASSERT_EQUAL((size_t)4, m->getValues().size()); + CPPUNIT_ASSERT(peers[0] == m->getValues()[0]); + CPPUNIT_ASSERT(peers[3] == m->getValues()[3]); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); + } catch(Exception* e) { + cerr << *e << endl; + CPPUNIT_FAIL("exception thrown."); + } +} + +void DHTMessageFactoryImplTest::testCreateAnnouncePeerMessage() +{ + try { + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("q")); + d->put("q", new Data("announce_peer")); + Dictionary* a = new Dictionary(); + a->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + unsigned char infoHash[DHT_ID_LENGTH]; + memset(infoHash, 0x11, DHT_ID_LENGTH); + a->put("info_hash", new Data(infoHash, DHT_ID_LENGTH)); + string token = "ffff"; + uint16_t port = 6881; + a->put("port", new Data(Util::uitos(port), true)); + a->put("token", new Data(token)); + d->put("a", a); + + SharedHandle m = factory->createQueryMessage(d.get(), "192.168.0.1", 6882); + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6882); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(token, m->getToken()); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); + CPPUNIT_ASSERT_EQUAL(Util::toHex(infoHash, DHT_ID_LENGTH), + Util::toHex(m->getInfoHash(), DHT_ID_LENGTH)); + CPPUNIT_ASSERT_EQUAL(port, m->getTCPPort()); + } catch(Exception* e) { + cerr << *e << endl; + string msg = e->getMsg(); + delete e; + CPPUNIT_FAIL(msg); + } +} + +void DHTMessageFactoryImplTest::testCreateAnnouncePeerReplyMessage() +{ + SharedHandle d = new Dictionary(); + d->put("t", new Data(transactionID, DHT_TRANSACTION_ID_LENGTH)); + d->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + r->put("id", new Data(remoteNodeID, DHT_ID_LENGTH)); + d->put("r", r); + + DHTNodeHandle remoteNode = new DHTNode(remoteNodeID); + remoteNode->setIPAddress("192.168.0.1"); + remoteNode->setPort(6881); + + SharedHandle m = factory->createResponseMessage("announce_peer", d.get(), remoteNode); + + CPPUNIT_ASSERT(localNode == m->getLocalNode()); + CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); + CPPUNIT_ASSERT_EQUAL(Util::toHex(transactionID, DHT_TRANSACTION_ID_LENGTH), + Util::toHex(m->getTransactionID())); +} diff --git a/test/DHTMessageTrackerEntryTest.cc b/test/DHTMessageTrackerEntryTest.cc new file mode 100644 index 00000000..c53bd5e9 --- /dev/null +++ b/test/DHTMessageTrackerEntryTest.cc @@ -0,0 +1,52 @@ +#include "DHTMessageTrackerEntry.h" +#include "Exception.h" +#include "Util.h" +#include "MockDHTMessage.h" +#include "DHTNode.h" +#include "MetaEntry.h" +#include "DHTMessageCallback.h" +#include + +class DHTMessageTrackerEntryTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTMessageTrackerEntryTest); + CPPUNIT_TEST(testMatch); + CPPUNIT_TEST(testHandleTimeout); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testMatch(); + + void testHandleTimeout(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageTrackerEntryTest); + +void DHTMessageTrackerEntryTest::testMatch() +{ + DHTNodeHandle localNode = new DHTNode(); + try { + MockDHTMessageHandle msg1 = new MockDHTMessage(localNode, new DHTNode()); + MockDHTMessageHandle msg2 = new MockDHTMessage(localNode, new DHTNode()); + + DHTMessageTrackerEntry entry(msg1, 30); + + CPPUNIT_ASSERT(entry.match(msg1->getTransactionID(), + msg1->getRemoteNode()->getIPAddress(), + msg1->getRemoteNode()->getPort())); + CPPUNIT_ASSERT(!entry.match(msg2->getTransactionID(), + msg2->getRemoteNode()->getIPAddress(), + msg2->getRemoteNode()->getPort())); + } catch(Exception* e) { + cerr << *e << endl; + CPPUNIT_FAIL("exception thrown."); + } +} + +void DHTMessageTrackerEntryTest::testHandleTimeout() +{ +} diff --git a/test/DHTMessageTrackerTest.cc b/test/DHTMessageTrackerTest.cc new file mode 100644 index 00000000..17a4a007 --- /dev/null +++ b/test/DHTMessageTrackerTest.cc @@ -0,0 +1,112 @@ +#include "DHTMessageTracker.h" +#include "Exception.h" +#include "Util.h" +#include "MockDHTMessage.h" +#include "MockDHTMessageCallback.h" +#include "DHTNode.h" +#include "MetaEntry.h" +#include "DHTMessageTrackerEntry.h" +#include "DHTRoutingTable.h" +#include "MockDHTMessageFactory.h" +#include "Dictionary.h" +#include "Data.h" +#include + +class DHTMessageTrackerTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTMessageTrackerTest); + CPPUNIT_TEST(testMessageArrived); + CPPUNIT_TEST(testHandleTimeout); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testMessageArrived(); + + void testHandleTimeout(); + + class MockDHTMessageCallback2:public MockDHTMessageCallback { + public: + uint32_t _countOnRecivedCalled; + + MockDHTMessageCallback2():_countOnRecivedCalled(0) {} + + virtual void onReceived(const DHTMessageHandle& message) + { + ++_countOnRecivedCalled; + } + }; + + typedef SharedHandle MockDHTMessageCallback2Handle; +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTMessageTrackerTest); + +void DHTMessageTrackerTest::testMessageArrived() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTRoutingTableHandle routingTable = new DHTRoutingTable(localNode); + MockDHTMessageFactoryHandle factory = new MockDHTMessageFactory(); + factory->setLocalNode(localNode); + + MockDHTMessageHandle m1 = new MockDHTMessage(localNode, new DHTNode()); + MockDHTMessageHandle m2 = new MockDHTMessage(localNode, new DHTNode()); + MockDHTMessageHandle m3 = new MockDHTMessage(localNode, new DHTNode()); + + m1->getRemoteNode()->setIPAddress("192.168.0.1"); + m1->getRemoteNode()->setPort(6881); + m2->getRemoteNode()->setIPAddress("192.168.0.2"); + m2->getRemoteNode()->setPort(6882); + m3->getRemoteNode()->setIPAddress("192.168.0.3"); + m3->getRemoteNode()->setPort(6883); + + MockDHTMessageCallback2Handle c2 = new MockDHTMessageCallback2(); + + DHTMessageTracker tracker; + tracker.setRoutingTable(routingTable); + tracker.setMessageFactory(factory); + tracker.addMessage(m1); + tracker.addMessage(m2, c2); + tracker.addMessage(m3); + + { + SharedHandle res = new Dictionary(); + res->put("t", new Data(m2->getTransactionID())); + + std::pair p = + tracker.messageArrived(res.get(), m2->getRemoteNode()->getIPAddress(), m2->getRemoteNode()->getPort()); + DHTMessageHandle reply = p.first; + + CPPUNIT_ASSERT(!reply.isNull()); + CPPUNIT_ASSERT_EQUAL((uint32_t)0, c2->_countOnRecivedCalled); + CPPUNIT_ASSERT(tracker.getEntryFor(m2).isNull()); + CPPUNIT_ASSERT_EQUAL((size_t)2, tracker.countEntry()); + } + { + SharedHandle res = new Dictionary(); + res->put("t", new Data(m3->getTransactionID())); + + std::pair p = tracker.messageArrived(res.get(), m3->getRemoteNode()->getIPAddress(), m3->getRemoteNode()->getPort()); + DHTMessageHandle reply = p.first; + + CPPUNIT_ASSERT(!reply.isNull()); + CPPUNIT_ASSERT(tracker.getEntryFor(m3).isNull()); + CPPUNIT_ASSERT_EQUAL((size_t)1, tracker.countEntry()); + } + { + SharedHandle res = new Dictionary(); + res->put("t", new Data(m1->getTransactionID())); + + std::pair p = tracker.messageArrived(res.get(), "192.168.1.100", 6889); + DHTMessageHandle reply = p.first; + + CPPUNIT_ASSERT(reply.isNull()); + } +} + +void DHTMessageTrackerTest::testHandleTimeout() +{ +} diff --git a/test/DHTNodeTest.cc b/test/DHTNodeTest.cc new file mode 100644 index 00000000..cd24544c --- /dev/null +++ b/test/DHTNodeTest.cc @@ -0,0 +1,26 @@ +#include "DHTNode.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTNodeTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTNodeTest); + CPPUNIT_TEST(testGenerateID); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGenerateID(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTNodeTest); + +void DHTNodeTest::testGenerateID() +{ + DHTNode node; + cerr << Util::toHex(node.getID(), DHT_ID_LENGTH) << endl; +} diff --git a/test/DHTPeerAnnounceEntryTest.cc b/test/DHTPeerAnnounceEntryTest.cc new file mode 100644 index 00000000..a8222102 --- /dev/null +++ b/test/DHTPeerAnnounceEntryTest.cc @@ -0,0 +1,141 @@ +#include "DHTPeerAnnounceEntry.h" +#include "Exception.h" +#include "Util.h" +#include "MockBtContext.h" +#include "MockPeerStorage.h" +#include "BtRegistry.h" +#include + +class DHTPeerAnnounceEntryTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTPeerAnnounceEntryTest); + CPPUNIT_TEST(testRemoveStalePeerAddrEntry); + CPPUNIT_TEST(testEmpty); + CPPUNIT_TEST(testAddPeerAddrEntry); + CPPUNIT_TEST(testGetPeers); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() + { + BtRegistry::unregisterAll(); + } + + void tearDown() + { + BtRegistry::unregisterAll(); + } + + void testRemoveStalePeerAddrEntry(); + void testEmpty(); + void testAddPeerAddrEntry(); + void testGetPeers(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTPeerAnnounceEntryTest); + +void DHTPeerAnnounceEntryTest::testRemoveStalePeerAddrEntry() +{ + unsigned char infohash[DHT_ID_LENGTH]; + memset(infohash, 0xff, DHT_ID_LENGTH); + DHTPeerAnnounceEntry entry(infohash); + + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.1", 6881)); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.2", 6882, Time(0))); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.3", 6883)); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.4", 6884, Time(0))); + + entry.removeStalePeerAddrEntry(10); + + CPPUNIT_ASSERT_EQUAL((size_t)2, entry.countPeerAddrEntry()); + + const PeerAddrEntries& peerAdderEntries = entry.getPeerAddrEntries(); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peerAdderEntries[0].getIPAddress()); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peerAdderEntries[1].getIPAddress()); +} + + +void DHTPeerAnnounceEntryTest::testEmpty() +{ + unsigned char infohash[DHT_ID_LENGTH]; + memset(infohash, 0xff, DHT_ID_LENGTH); + { + DHTPeerAnnounceEntry entry(infohash); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.1", 6881)); + CPPUNIT_ASSERT(!entry.empty()); + } + { + DHTPeerAnnounceEntry entry(infohash); + entry.setBtContext(new MockBtContext()); + CPPUNIT_ASSERT(!entry.empty()); + } + { + DHTPeerAnnounceEntry entry(infohash); + CPPUNIT_ASSERT(entry.empty()); + } +} + +void DHTPeerAnnounceEntryTest::testAddPeerAddrEntry() +{ + unsigned char infohash[DHT_ID_LENGTH]; + memset(infohash, 0xff, DHT_ID_LENGTH); + + DHTPeerAnnounceEntry entry(infohash); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.1", 6881, Time(0))); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.1", 6882)); + + CPPUNIT_ASSERT_EQUAL((size_t)2, entry.countPeerAddrEntry()); + + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.1", 6881)); + + CPPUNIT_ASSERT_EQUAL((size_t)2, entry.countPeerAddrEntry()); + CPPUNIT_ASSERT(0 != entry.getPeerAddrEntries()[0].getLastUpdated().getTime()); +} + +void DHTPeerAnnounceEntryTest::testGetPeers() +{ + unsigned char infohash[DHT_ID_LENGTH]; + memset(infohash, 0xff, DHT_ID_LENGTH); + + MockBtContextHandle ctx = new MockBtContext(); + ctx->setInfoHash(infohash); + MockPeerStorageHandle peerStorage = new MockPeerStorage(); + { + PeerHandle activePeers[] = { new Peer("192.168.0.3", 6883), + new Peer("192.168.0.4", 6884) }; + peerStorage->setActivePeers(Peers(&activePeers[0], + &activePeers[2])); + } + BtRegistry::registerPeerStorage(ctx->getInfoHashAsString(), peerStorage); + + DHTPeerAnnounceEntry entry(infohash); + { + Peers peers = entry.getPeers(); + CPPUNIT_ASSERT_EQUAL((size_t)0, peers.size()); + } + + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.1", 6881, Time(0))); + entry.addPeerAddrEntry(PeerAddrEntry("192.168.0.2", 6882)); + + { + Peers peers = entry.getPeers(); + CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size()); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peers[0]->ipaddr); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, peers[0]->port); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"), peers[1]->ipaddr); + CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peers[1]->port); + } + entry.setBtContext(ctx); + { + Peers peers = entry.getPeers(); + CPPUNIT_ASSERT_EQUAL((size_t)4, peers.size()); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peers[0]->ipaddr); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, peers[0]->port); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.2"), peers[1]->ipaddr); + CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peers[1]->port); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peers[2]->ipaddr); + CPPUNIT_ASSERT_EQUAL((uint16_t)6883, peers[2]->port); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.4"), peers[3]->ipaddr); + CPPUNIT_ASSERT_EQUAL((uint16_t)6884, peers[3]->port); + } +} diff --git a/test/DHTPeerAnnounceStorageTest.cc b/test/DHTPeerAnnounceStorageTest.cc new file mode 100644 index 00000000..19b51214 --- /dev/null +++ b/test/DHTPeerAnnounceStorageTest.cc @@ -0,0 +1,70 @@ +#include "DHTPeerAnnounceStorage.h" +#include "Exception.h" +#include "Util.h" +#include "MockBtContext.h" +#include "DHTConstants.h" +#include "Peer.h" +#include + +class DHTPeerAnnounceStorageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTPeerAnnounceStorageTest); + CPPUNIT_TEST(testAddAnnounce); + CPPUNIT_TEST(testRemovePeerAnnounce); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testAddAnnounce(); + void testRemovePeerAnnounce(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTPeerAnnounceStorageTest); + +void DHTPeerAnnounceStorageTest::testAddAnnounce() +{ + unsigned char infohash1[DHT_ID_LENGTH]; + memset(infohash1, 0xff, DHT_ID_LENGTH); + unsigned char infohash2[DHT_ID_LENGTH]; + memset(infohash2, 0xf0, DHT_ID_LENGTH); + DHTPeerAnnounceStorage storage; + + storage.addPeerAnnounce(infohash1, "192.168.0.1", 6881); + storage.addPeerAnnounce(infohash1, "192.168.0.2", 6882); + storage.addPeerAnnounce(infohash2, "192.168.0.3", 6883); + storage.addPeerAnnounce(infohash2, "192.168.0.4", 6884); + + Peers peers = storage.getPeers(infohash2); + + CPPUNIT_ASSERT_EQUAL((size_t)2, peers.size()); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peers[0]->ipaddr); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.4"), peers[1]->ipaddr); +} + +void DHTPeerAnnounceStorageTest::testRemovePeerAnnounce() +{ + unsigned char infohash1[DHT_ID_LENGTH]; + memset(infohash1, 0xff, DHT_ID_LENGTH); + unsigned char infohash2[DHT_ID_LENGTH]; + memset(infohash2, 0xf0, DHT_ID_LENGTH); + DHTPeerAnnounceStorage storage; + + MockBtContextHandle ctx1 = new MockBtContext(); + ctx1->setInfoHash(infohash1); + + MockBtContextHandle ctx2 = new MockBtContext(); + ctx2->setInfoHash(infohash2); + + storage.addPeerAnnounce(infohash1, "192.168.0.1", 6881); + storage.addPeerAnnounce(ctx1); + storage.addPeerAnnounce(ctx2); + + storage.removePeerAnnounce(ctx2); + CPPUNIT_ASSERT(!storage.contains(infohash2)); + + storage.removePeerAnnounce(ctx1); + CPPUNIT_ASSERT(storage.contains(infohash1)); +} diff --git a/test/DHTPingMessageTest.cc b/test/DHTPingMessageTest.cc new file mode 100644 index 00000000..091ab85c --- /dev/null +++ b/test/DHTPingMessageTest.cc @@ -0,0 +1,52 @@ +#include "DHTPingMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTPingMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTPingMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTPingMessageTest); + +void DHTPingMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + DHTPingMessage msg(localNode, remoteNode, transactionID); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("q")); + cm->put("q", new Data("ping")); + Dictionary* a = new Dictionary(); + cm->put("a", a); + a->put("id", new Data(reinterpret_cast(localNode->getID()), DHT_ID_LENGTH)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody); +} diff --git a/test/DHTPingReplyMessageTest.cc b/test/DHTPingReplyMessageTest.cc new file mode 100644 index 00000000..7d5ce4cb --- /dev/null +++ b/test/DHTPingReplyMessageTest.cc @@ -0,0 +1,54 @@ +#include "DHTPingReplyMessage.h" +#include "DHTNode.h" +#include "DHTUtil.h" +#include "BencodeVisitor.h" +#include "Dictionary.h" +#include "Data.h" +#include "Exception.h" +#include "Util.h" +#include + +class DHTPingReplyMessageTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTPingReplyMessageTest); + CPPUNIT_TEST(testGetBencodedMessage); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGetBencodedMessage(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTPingReplyMessageTest); + +void DHTPingReplyMessageTest::testGetBencodedMessage() +{ + DHTNodeHandle localNode = new DHTNode(); + DHTNodeHandle remoteNode = new DHTNode(); + + char tid[DHT_TRANSACTION_ID_LENGTH]; + DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); + string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + + char id[DHT_ID_LENGTH]; + DHTUtil::generateRandomData(id, DHT_ID_LENGTH); + + DHTPingReplyMessage msg(localNode, remoteNode, (const unsigned char*)id, transactionID); + + string msgbody = msg.getBencodedMessage(); + + SharedHandle cm = new Dictionary(); + cm->put("t", new Data(transactionID)); + cm->put("y", new Data("r")); + Dictionary* r = new Dictionary(); + cm->put("r", r); + r->put("id", new Data(id, DHT_ID_LENGTH)); + + BencodeVisitor v; + cm->accept(&v); + + CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody); +} diff --git a/test/DHTRoutingTableDeserializerTest.cc b/test/DHTRoutingTableDeserializerTest.cc new file mode 100644 index 00000000..5008b648 --- /dev/null +++ b/test/DHTRoutingTableDeserializerTest.cc @@ -0,0 +1,66 @@ +#include "DHTRoutingTableDeserializer.h" +#include "DHTRoutingTableSerializer.h" +#include "Exception.h" +#include "Util.h" +#include "DHTNode.h" +#include "a2functional.h" +#include "DHTConstants.h" +#include "PeerMessageUtil.h" +#include +#include +#include +#include + +class DHTRoutingTableDeserializerTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTRoutingTableDeserializerTest); + CPPUNIT_TEST(testDeserialize); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testDeserialize(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableDeserializerTest); + +void DHTRoutingTableDeserializerTest::testDeserialize() +{ + DHTNodeHandle localNode = new DHTNode(); + + DHTNodeHandle nodesSrc[] = { 0, 0, 0 }; + for(size_t i = 0; i < arrayLength(nodesSrc); ++i) { + nodesSrc[i] = new DHTNode(); + nodesSrc[i]->setIPAddress("192.168.0."+Util::uitos(i+1)); + nodesSrc[i]->setPort(6881+i); + } + nodesSrc[1]->setIPAddress("non-numerical-name"); + DHTNodes nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]); + + DHTRoutingTableSerializer s; + s.setLocalNode(localNode); + s.setNodes(nodes); + + stringstream ss; + s.serialize(ss); + + DHTRoutingTableDeserializer d; + d.deserialize(ss); + + CPPUNIT_ASSERT(memcmp(localNode->getID(), d.getLocalNode()->getID(), + DHT_ID_LENGTH) == 0); + + cout << d.getSerializedTime().getTime() << endl; + + CPPUNIT_ASSERT_EQUAL((size_t)2, d.getNodes().size()); + const DHTNodes& dsnodes = d.getNodes(); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), dsnodes[0]->getIPAddress()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, dsnodes[0]->getPort()); + CPPUNIT_ASSERT(memcmp(nodes[0]->getID(), dsnodes[0]->getID(), DHT_ID_LENGTH) == 0); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), dsnodes[1]->getIPAddress()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6883, dsnodes[1]->getPort()); + CPPUNIT_ASSERT(memcmp(nodes[2]->getID(), dsnodes[1]->getID(), DHT_ID_LENGTH) == 0); +} diff --git a/test/DHTRoutingTableSerializerTest.cc b/test/DHTRoutingTableSerializerTest.cc new file mode 100644 index 00000000..025f336d --- /dev/null +++ b/test/DHTRoutingTableSerializerTest.cc @@ -0,0 +1,151 @@ +#include "DHTRoutingTableSerializer.h" +#include "Exception.h" +#include "Util.h" +#include "DHTNode.h" +#include "a2functional.h" +#include "DHTConstants.h" +#include "PeerMessageUtil.h" +#include +#include +#include +#include + +class DHTRoutingTableSerializerTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTRoutingTableSerializerTest); + CPPUNIT_TEST(testSerialize); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testSerialize(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableSerializerTest); + +void DHTRoutingTableSerializerTest::testSerialize() +{ + DHTNodeHandle localNode = new DHTNode(); + + DHTNodeHandle nodesSrc[] = { 0, 0, 0 }; + for(size_t i = 0; i < arrayLength(nodesSrc); ++i) { + nodesSrc[i] = new DHTNode(); + nodesSrc[i]->setIPAddress("192.168.0."+Util::uitos(i+1)); + nodesSrc[i]->setPort(6881+i); + } + nodesSrc[1]->setIPAddress("non-numerical-name"); + DHTNodes nodes(&nodesSrc[0], &nodesSrc[arrayLength(nodesSrc)]); + + DHTRoutingTableSerializer s; + s.setLocalNode(localNode); + s.setNodes(nodes); + + stringstream ss; + s.serialize(ss); + + char zero[8]; + memset(zero, 0, sizeof(zero)); + + char buf[20]; + // header + ss.read(buf, 8); + // magic + CPPUNIT_ASSERT((char)0xa1 == buf[0]); + CPPUNIT_ASSERT((char)0xa2 == buf[1]); + // format ID + CPPUNIT_ASSERT((char)0x02 == buf[2]); + // reserved + CPPUNIT_ASSERT((char)0x00 == buf[3]); + CPPUNIT_ASSERT((char)0x00 == buf[4]); + CPPUNIT_ASSERT((char)0x00 == buf[5]); + // version + CPPUNIT_ASSERT((char)0x00 == buf[6]); + CPPUNIT_ASSERT((char)0x01 == buf[7]); + + // time + ss.read(buf, 4); + time_t time = ntohl(*reinterpret_cast(buf)); + cerr << time << endl; + // 4bytes reserved + ss.read(buf, 4); + CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0); + + // localnode + // 8bytes reserved + ss.read(buf, 8); + CPPUNIT_ASSERT(memcmp(zero, buf, 8) == 0); + // localnode ID + ss.read(buf, DHT_ID_LENGTH); + CPPUNIT_ASSERT(memcmp(localNode->getID(), buf, DHT_ID_LENGTH) == 0); + // 4bytes reserved + ss.read(buf, 4); + CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0); + + // number of nodes saved + ss.read(buf, 4); + uint32_t numNodes = ntohl(*reinterpret_cast(buf)); + CPPUNIT_ASSERT_EQUAL((uint32_t)3, numNodes); + // 4bytes reserved + ss.read(buf, 4); + CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0); + + // node[0] + // 6bytes compact peer info + ss.read(buf, 6); + { + pair peer = PeerMessageUtil::unpackcompact(buf); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.1"), peer.first); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, peer.second); + } + // 2bytes reserved + ss.read(buf, 2); + CPPUNIT_ASSERT(memcmp(zero, buf, 2) == 0); + // localnode ID + ss.read(buf, DHT_ID_LENGTH); + CPPUNIT_ASSERT(memcmp(nodes[0]->getID(), buf, DHT_ID_LENGTH) == 0); + // 4bytes reserved + ss.read(buf, 4); + CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0); + + // node[1] + // 6bytes compact peer info + ss.read(buf, 6); + // zero filled because node[1]'s hostname is not numerical form + // deserializer should skip this entry + CPPUNIT_ASSERT(memcmp(zero, buf, 6) == 0); + // 2bytes reserved + ss.read(buf, 2); + CPPUNIT_ASSERT(memcmp(zero, buf, 2) == 0); + // localnode ID + ss.read(buf, DHT_ID_LENGTH); + CPPUNIT_ASSERT(memcmp(nodes[1]->getID(), buf, DHT_ID_LENGTH) == 0); + // 4bytes reserved + ss.read(buf, 4); + CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0); + + // node[2] + // 6bytes compact peer info + ss.read(buf, 6); + { + pair peer = PeerMessageUtil::unpackcompact(buf); + CPPUNIT_ASSERT_EQUAL(string("192.168.0.3"), peer.first); + CPPUNIT_ASSERT_EQUAL((uint16_t)6883, peer.second); + } + // 2bytes reserved + ss.read(buf, 2); + CPPUNIT_ASSERT(memcmp(zero, buf, 2) == 0); + // localnode ID + ss.read(buf, DHT_ID_LENGTH); + CPPUNIT_ASSERT(memcmp(nodes[2]->getID(), buf, DHT_ID_LENGTH) == 0); + // 4bytes reserved + ss.read(buf, 4); + CPPUNIT_ASSERT(memcmp(zero, buf, 4) == 0); + + // check to see stream ends + ss.read(buf, 1); + CPPUNIT_ASSERT_EQUAL((std::streamsize)0, ss.gcount()); + CPPUNIT_ASSERT(ss.eof()); +} diff --git a/test/DHTRoutingTableTest.cc b/test/DHTRoutingTableTest.cc new file mode 100644 index 00000000..421ae220 --- /dev/null +++ b/test/DHTRoutingTableTest.cc @@ -0,0 +1,84 @@ +#include "DHTRoutingTable.h" +#include "Exception.h" +#include "Util.h" +#include "DHTNode.h" +#include "DHTBucket.h" +#include "MockDHTTaskQueue.h" +#include "MockDHTTaskFactory.h" +#include "DHTTask.h" +#include + +class DHTRoutingTableTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTRoutingTableTest); + CPPUNIT_TEST(testAddNode); + CPPUNIT_TEST(testGetClosestKNodes); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testAddNode(); + void testGetClosestKNodes(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTRoutingTableTest); + +void DHTRoutingTableTest::testAddNode() +{ + DHTRoutingTable table(new DHTNode()); + table.setTaskFactory(new MockDHTTaskFactory()); + table.setTaskQueue(new MockDHTTaskQueue()); + uint32_t count = 0; + for(int i = 0; i < 100; ++i) { + if(table.addNode(new DHTNode())) { + ++count; + } + } + table.showBuckets(); +} + +static void createID(unsigned char* id, unsigned char firstChar, unsigned char lastChar) +{ + memset(id, 0, DHT_ID_LENGTH); + id[0] = firstChar; + id[DHT_ID_LENGTH-1] = lastChar; +} + +void DHTRoutingTableTest::testGetClosestKNodes() +{ + unsigned char id[DHT_ID_LENGTH]; + createID(id, 0x81, 0); + DHTNodeHandle localNode = new DHTNode(id); + + DHTRoutingTable table(localNode); + + DHTNodeHandle nodes1[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + DHTNodeHandle nodes2[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + DHTNodeHandle nodes3[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0xf0, i); + nodes1[i] = new DHTNode(id); + CPPUNIT_ASSERT(table.addNode(nodes1[i])); + } + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0x80, i); + nodes2[i] = new DHTNode(id); + CPPUNIT_ASSERT(table.addNode(nodes2[i])); + } + for(size_t i = 0; i < DHTBucket::K; ++i) { + createID(id, 0x70, i); + nodes3[i] = new DHTNode(id); + CPPUNIT_ASSERT(table.addNode(nodes3[i])); + } + { + createID(id, 0x80, 0x10); + DHTNodes nodes = table.getClosestKNodes(id); + CPPUNIT_ASSERT_EQUAL((size_t)8, nodes.size()); + for(size_t i = 0; i < nodes.size(); ++i) { + CPPUNIT_ASSERT(memcmp(nodes2[0]->getID(), nodes[0]->getID(), DHT_ID_LENGTH) == 0); + } + } +} diff --git a/test/DHTTokenTrackerTest.cc b/test/DHTTokenTrackerTest.cc new file mode 100644 index 00000000..4f4d65fc --- /dev/null +++ b/test/DHTTokenTrackerTest.cc @@ -0,0 +1,41 @@ +#include "DHTTokenTracker.h" +#include "Exception.h" +#include "Util.h" +#include "DHTUtil.h" +#include "DHTConstants.h" +#include + +class DHTTokenTrackerTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(DHTTokenTrackerTest); + CPPUNIT_TEST(testGenerateToken); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testGenerateToken(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(DHTTokenTrackerTest); + +void DHTTokenTrackerTest::testGenerateToken() +{ + unsigned char infohash[DHT_ID_LENGTH]; + DHTUtil::generateRandomData(reinterpret_cast(infohash), DHT_ID_LENGTH); + string ipaddr = "192.168.0.1"; + uint16_t port = 6881; + + DHTTokenTracker tracker; + string token = tracker.generateToken(infohash, ipaddr, port); + CPPUNIT_ASSERT(tracker.validateToken(token, infohash, ipaddr, port)); + + tracker.updateTokenSecret(); + CPPUNIT_ASSERT(tracker.validateToken(token, infohash, ipaddr, port)); + string newtoken = tracker.generateToken(infohash, ipaddr, port); + tracker.updateTokenSecret(); + CPPUNIT_ASSERT(!tracker.validateToken(token, infohash, ipaddr, port)); + CPPUNIT_ASSERT(tracker.validateToken(newtoken, infohash, ipaddr, port)); +} diff --git a/test/DataTest.cc b/test/DataTest.cc index 19c8ef6a..65de34c9 100644 --- a/test/DataTest.cc +++ b/test/DataTest.cc @@ -31,7 +31,7 @@ void DataTest::testToString() { Data data("aria2", 5); CPPUNIT_ASSERT_EQUAL(string("aria2"), data.toString()); - Data null(NULL, 0); + Data null(reinterpret_cast(0), 0); CPPUNIT_ASSERT_EQUAL(string(""), null.toString()); } @@ -40,7 +40,7 @@ void DataTest::testGetData() { CPPUNIT_ASSERT_EQUAL(0, memcmp("aria2", data.getData(), 5)); CPPUNIT_ASSERT_EQUAL((int32_t)5, data.getLen()); - Data null(NULL, 0); + Data null(reinterpret_cast(0), 0); CPPUNIT_ASSERT_EQUAL((const char*)NULL, null.getData()); CPPUNIT_ASSERT_EQUAL((int32_t)0, null.getLen()); @@ -50,7 +50,7 @@ void DataTest::testToInt() { Data data("1000", 4); CPPUNIT_ASSERT_EQUAL((int32_t)1000, data.toInt()); - Data null(NULL, 0); + Data null(reinterpret_cast(0), 0); CPPUNIT_ASSERT_EQUAL((int32_t)0, null.toInt()); Data alpha("abc", 3); @@ -61,7 +61,7 @@ void DataTest::testToLLInt() { Data data("1000", 4); CPPUNIT_ASSERT_EQUAL(1000, (int)data.toLLInt()); - Data null(NULL, 0); + Data null(reinterpret_cast(0), 0); CPPUNIT_ASSERT_EQUAL(0, (int)null.toLLInt()); Data alpha("abc", 3); diff --git a/test/DefaultBtMessageFactoryTest.cc b/test/DefaultBtMessageFactoryTest.cc index 31f2232a..5b7660cb 100644 --- a/test/DefaultBtMessageFactoryTest.cc +++ b/test/DefaultBtMessageFactoryTest.cc @@ -5,12 +5,14 @@ #include "MockBtContext.h" #include "MockExtensionMessageFactory.h" #include "BtExtendedMessage.h" +#include "BtPortMessage.h" #include class DefaultBtMessageFactoryTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE(DefaultBtMessageFactoryTest); CPPUNIT_TEST(testCreateBtMessage_BtExtendedMessage); + CPPUNIT_TEST(testCreatePortMessage); CPPUNIT_TEST_SUITE_END(); private: MockBtContextHandle _btContext; @@ -45,6 +47,7 @@ public: } void testCreateBtMessage_BtExtendedMessage(); + void testCreatePortMessage(); }; @@ -76,3 +79,30 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage() delete e; } } + +void DefaultBtMessageFactoryTest::testCreatePortMessage() +{ + DefaultBtMessageFactory factory; + factory.setBtContext(_btContext); + factory.setPeer(_peer); + + { + unsigned char data[7]; + PeerMessageUtil::createPeerMessageString(data, sizeof(data), 3, 9); + PeerMessageUtil::setShortIntParam(&data[5], 6881); + try { + SharedHandle m = factory.createBtMessage(&data[4], sizeof(data)-4); + CPPUNIT_ASSERT(!m.isNull()); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort()); + } catch(Exception* e) { + cerr << *e << endl; + string msg = e->getMsg(); + delete e; + CPPUNIT_FAIL(msg); + } + } + { + SharedHandle m = factory.createPortMessage(6881); + CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort()); + } +} diff --git a/test/Makefile.am b/test/Makefile.am index c78d0977..098332d8 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -1,6 +1,7 @@ TESTS = aria2c check_PROGRAMS = $(TESTS) aria2c_SOURCES = AllTest.cc\ + SocketCoreTest.cc\ array_funTest.cc\ HelpItemTest.cc\ TaggedItemTest.cc\ @@ -106,6 +107,29 @@ aria2c_SOURCES += BtAllowedFastMessageTest.cc\ UTPexExtensionMessageTest.cc\ DefaultBtMessageFactoryTest.cc\ DefaultExtensionMessageFactoryTest.cc + DHTNodeTest.cc\ + DHTBucketTest.cc\ + DHTRoutingTableTest.cc\ + DHTMessageTrackerEntryTest.cc\ + DHTMessageTrackerTest.cc\ + DHTConnectionImplTest.cc\ + DHTPingMessageTest.cc\ + DHTPingReplyMessageTest.cc\ + DHTFindNodeMessageTest.cc\ + DHTFindNodeReplyMessageTest.cc\ + DHTGetPeersMessageTest.cc\ + DHTGetPeersReplyMessageTest.cc\ + DHTAnnouncePeerMessageTest.cc\ + DHTAnnouncePeerReplyMessageTest.cc\ + DHTMessageFactoryImplTest.cc\ + BNodeTest.cc\ + DHTPeerAnnounceEntryTest.cc\ + DHTPeerAnnounceStorageTest.cc\ + DHTTokenTrackerTest.cc\ + XORCloserTest.cc\ + DHTIDCloserTest.cc\ + DHTRoutingTableSerializerTest.cc\ + DHTRoutingTableDeserializerTest.cc endif # ENABLE_BITTORRENT if ENABLE_METALINK diff --git a/test/Makefile.in b/test/Makefile.in index 0be52740..e403f9d2 100644 --- a/test/Makefile.in +++ b/test/Makefile.in @@ -121,10 +121,11 @@ mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = am__EXEEXT_1 = aria2c$(EXEEXT) -am__aria2c_SOURCES_DIST = AllTest.cc array_funTest.cc HelpItemTest.cc \ - TaggedItemTest.cc TagContainerTest.cc Base64Test.cc \ - SequenceTest.cc a2functionalTest.cc FileEntryTest.cc \ - PieceTest.cc SegmentTest.cc GrowSegmentTest.cc \ +am__aria2c_SOURCES_DIST = AllTest.cc SocketCoreTest.cc \ + array_funTest.cc HelpItemTest.cc TaggedItemTest.cc \ + TagContainerTest.cc Base64Test.cc SequenceTest.cc \ + a2functionalTest.cc FileEntryTest.cc PieceTest.cc \ + SegmentTest.cc GrowSegmentTest.cc \ SingleFileAllocationIteratorTest.cc \ DefaultBtProgressInfoFileTest.cc \ SingleFileDownloadContextTest.cc RequestGroupTest.cc \ @@ -227,12 +228,13 @@ am__aria2c_SOURCES_DIST = AllTest.cc array_funTest.cc HelpItemTest.cc \ @ENABLE_METALINK_TRUE@ MetalinkHelperTest.$(OBJEXT) \ @ENABLE_METALINK_TRUE@ MetalinkParserControllerTest.$(OBJEXT) \ @ENABLE_METALINK_TRUE@ MetalinkProcessorTest.$(OBJEXT) -am_aria2c_OBJECTS = AllTest.$(OBJEXT) array_funTest.$(OBJEXT) \ - HelpItemTest.$(OBJEXT) TaggedItemTest.$(OBJEXT) \ - TagContainerTest.$(OBJEXT) Base64Test.$(OBJEXT) \ - SequenceTest.$(OBJEXT) a2functionalTest.$(OBJEXT) \ - FileEntryTest.$(OBJEXT) PieceTest.$(OBJEXT) \ - SegmentTest.$(OBJEXT) GrowSegmentTest.$(OBJEXT) \ +am_aria2c_OBJECTS = AllTest.$(OBJEXT) SocketCoreTest.$(OBJEXT) \ + array_funTest.$(OBJEXT) HelpItemTest.$(OBJEXT) \ + TaggedItemTest.$(OBJEXT) TagContainerTest.$(OBJEXT) \ + Base64Test.$(OBJEXT) SequenceTest.$(OBJEXT) \ + a2functionalTest.$(OBJEXT) FileEntryTest.$(OBJEXT) \ + PieceTest.$(OBJEXT) SegmentTest.$(OBJEXT) \ + GrowSegmentTest.$(OBJEXT) \ SingleFileAllocationIteratorTest.$(OBJEXT) \ DefaultBtProgressInfoFileTest.$(OBJEXT) \ SingleFileDownloadContextTest.$(OBJEXT) \ @@ -448,11 +450,11 @@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ TESTS = aria2c -aria2c_SOURCES = AllTest.cc array_funTest.cc HelpItemTest.cc \ - TaggedItemTest.cc TagContainerTest.cc Base64Test.cc \ - SequenceTest.cc a2functionalTest.cc FileEntryTest.cc \ - PieceTest.cc SegmentTest.cc GrowSegmentTest.cc \ - SingleFileAllocationIteratorTest.cc \ +aria2c_SOURCES = AllTest.cc SocketCoreTest.cc array_funTest.cc \ + HelpItemTest.cc TaggedItemTest.cc TagContainerTest.cc \ + Base64Test.cc SequenceTest.cc a2functionalTest.cc \ + FileEntryTest.cc PieceTest.cc SegmentTest.cc \ + GrowSegmentTest.cc SingleFileAllocationIteratorTest.cc \ DefaultBtProgressInfoFileTest.cc \ SingleFileDownloadContextTest.cc RequestGroupTest.cc \ PStringBuildVisitorTest.cc ParameterizedStringParserTest.cc \ @@ -626,6 +628,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingleFileAllocationIteratorTest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingleFileDownloadContextTest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SingletonHolderTest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SocketCoreTest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SpeedCalcTest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StreamUriListParserTest.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/TagContainerTest.Po@am__quote@ @@ -889,6 +892,29 @@ uninstall-am: uninstall-info-am mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \ uninstall-am uninstall-info-am +@ENABLE_BITTORRENT_TRUE@ DHTNodeTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTBucketTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageTrackerEntryTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageTrackerTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTConnectionImplTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPingMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPingReplyMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTFindNodeMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTFindNodeReplyMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTGetPeersReplyMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAnnouncePeerMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTAnnouncePeerReplyMessageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTMessageFactoryImplTest.cc\ +@ENABLE_BITTORRENT_TRUE@ BNodeTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceEntryTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTPeerAnnounceStorageTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTTokenTrackerTest.cc\ +@ENABLE_BITTORRENT_TRUE@ XORCloserTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTIDCloserTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableSerializerTest.cc\ +@ENABLE_BITTORRENT_TRUE@ DHTRoutingTableDeserializerTest.cc # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: diff --git a/test/MockBtMessageFactory.h b/test/MockBtMessageFactory.h index f4b063f7..196c578f 100644 --- a/test/MockBtMessageFactory.h +++ b/test/MockBtMessageFactory.h @@ -87,6 +87,11 @@ public: virtual BtMessageHandle createAllowedFastMessage(int32_t index) { return BtMessageHandle(0); } + + virtual BtMessageHandle createPortMessage(uint16_t port) + { + return BtMessageHandle(0); + } virtual BtMessageHandle createBtExtendedMessage(const ExensionMessageHandle&) { diff --git a/test/MockDHTMessage.h b/test/MockDHTMessage.h new file mode 100644 index 00000000..bac33e92 --- /dev/null +++ b/test/MockDHTMessage.h @@ -0,0 +1,35 @@ +#ifndef _D_MOCK_DHT_MESSAGE_H_ +#define _D_MOCK_DHT_MESSAGE_H_ + +#include "DHTMessage.h" + +class MockDHTMessage:public DHTMessage { +private: + bool _isReply; + + string _messageType; +public: + MockDHTMessage(const DHTNodeHandle& localNode, + const DHTNodeHandle& remoteNode, + const string& transactionID = ""): + DHTMessage(localNode, remoteNode, transactionID), _isReply(false), _messageType("mock") {} + + virtual ~MockDHTMessage() {} + + virtual void doReceivedAction() {} + + virtual void send() {} + + virtual bool isReply() const { return _isReply; } + + void setReply(bool f) { _isReply = f; } + + virtual string getMessageType() const { return _messageType; } + + virtual string toString() const { return "MockDHTMessage"; } + + virtual void validate() const {} +}; + +typedef SharedHandle MockDHTMessageHandle; +#endif // _D_MOCK_DHT_MESSAGE_H_ diff --git a/test/MockDHTMessageCallback.h b/test/MockDHTMessageCallback.h new file mode 100644 index 00000000..09f0ff48 --- /dev/null +++ b/test/MockDHTMessageCallback.h @@ -0,0 +1,17 @@ +#ifndef _D_MOCK_DHT_MESSAGE_CALLBACK_H_ +#define _D_MOCK_DHT_MESSAGE_CALLBACK_H_ + +#include "DHTMessageCallback.h" + +class MockDHTMessageCallback:public DHTMessageCallback { +public: + MockDHTMessageCallback() {} + + virtual ~MockDHTMessageCallback() {} + + virtual void onReceived(const DHTMessageHandle& message) {} + + virtual void onTimeout(const DHTNodeHandle& remoteNode) {} +}; + +#endif // _D_MOCK_DHT_MESSAGE_CALLBACK_H_ diff --git a/test/MockDHTMessageFactory.h b/test/MockDHTMessageFactory.h new file mode 100644 index 00000000..f54617fc --- /dev/null +++ b/test/MockDHTMessageFactory.h @@ -0,0 +1,117 @@ +#ifndef _D_MOCK_DHT_MESSAGE_FACTORY_H_ +#define _D_MOCK_DHT_MESSAGE_FACTORY_H_ + +#include "DHTMessageFactory.h" +#include "DHTNode.h" +#include "MockDHTMessage.h" +#include "Dictionary.h" +#include "Data.h" + +class MockDHTMessageFactory:public DHTMessageFactory { +private: + DHTNodeHandle _localNode; +public: + MockDHTMessageFactory() {} + + virtual ~MockDHTMessageFactory() {} + + virtual DHTMessageHandle + createQueryMessage(const Dictionary* d, + const string& ipaddr, uint16_t port) + { + return 0; + } + + virtual DHTMessageHandle + createResponseMessage(const string& messageType, + const Dictionary* d, + const DHTNodeHandle& remoteNode) + { + MockDHTMessageHandle m = new MockDHTMessage(_localNode, remoteNode, + reinterpret_cast(d->get("t"))->toString()); + m->setReply(true); + return m; + } + + virtual DHTMessageHandle + createPingMessage(const DHTNodeHandle& remoteNode, + const string& transactionID = "") + { + return 0; + } + + virtual DHTMessageHandle + createPingReplyMessage(const DHTNodeHandle& remoteNode, + const unsigned char* remoteNodeID, + const string& transactionID) + { + return 0; + } + + virtual DHTMessageHandle + createFindNodeMessage(const DHTNodeHandle& remoteNode, + const unsigned char* targetNodeID, + const string& transactionID = "") + { + return 0; + } + + virtual DHTMessageHandle + createFindNodeReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& transactionID) + { + return 0; + } + + virtual DHTMessageHandle + createGetPeersMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + const string& transactionID) + { + return 0; + } + + virtual DHTMessageHandle + createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const DHTNodes& closestKNodes, + const string& transactionID, + const string& token = "") + { + return 0; + } + + virtual DHTMessageHandle + createGetPeersReplyMessage(const DHTNodeHandle& remoteNode, + const Peers& peers, + const string& transactionID, + const string& token = "") + { + return 0; + } + + virtual DHTMessageHandle + createAnnouncePeerMessage(const DHTNodeHandle& remoteNode, + const unsigned char* infoHash, + uint16_t tcpPort, + const string& token, + const string& transactionID = "") + { + return 0; + } + + virtual DHTMessageHandle + createAnnouncePeerReplyMessage(const DHTNodeHandle& remoteNode, + const string& transactionID) + { + return 0; + } + + void setLocalNode(const DHTNodeHandle& node) + { + _localNode = node; + } +}; + +typedef SharedHandle MockDHTMessageFactoryHandle; +#endif // _D_MOCK_DHT_MESSAGE_FACTORY_H_ diff --git a/test/MockDHTTask.h b/test/MockDHTTask.h new file mode 100644 index 00000000..e12954b0 --- /dev/null +++ b/test/MockDHTTask.h @@ -0,0 +1,23 @@ +#ifndef _D_MOCK_DHT_TASK_H_ +#define _D_MOCK_DHT_TASK_H_ + +#include "DHTTask.h" +#include "DHTNode.h" + +class MockDHTTask:public DHTTask { +public: + DHTNodeHandle _remoteNode; + + MockDHTTask(const DHTNodeHandle& remoteNode):_remoteNode(remoteNode) {} + + virtual ~MockDHTTask() {} + + virtual void startup() {} + + virtual bool finished() + { + return false; + } +}; + +#endif // _D_MOCK_DHT_TASK_H_ diff --git a/test/MockDHTTaskFactory.h b/test/MockDHTTaskFactory.h new file mode 100644 index 00000000..355ce45a --- /dev/null +++ b/test/MockDHTTaskFactory.h @@ -0,0 +1,49 @@ +#ifndef _D_MOCK_DHT_TASK_FACTORY_H_ +#define _D_MOCK_DHT_TASK_FACTORY_H_ + +#include "DHTTaskFactory.h" + +class MockDHTTaskFactory:public DHTTaskFactory { +public: + virtual ~MockDHTTaskFactory() {} + + virtual DHTTaskHandle createPingTask(const DHTNodeHandle& remoteNode, + size_t numRetry = 0) + { + return 0; + } + + virtual DHTTaskHandle createGetIDTask(const DHTNodeHandle& remoteNode, + size_t numRetry = 0) + { + return 0; + } + + virtual DHTTaskHandle createNodeLookupTask(const unsigned char* targetID) + { + return 0; + } + + virtual DHTTaskHandle createBucketRefreshTask() + { + return 0; + } + + virtual DHTTaskHandle createPeerLookupTask(const BtContextHandle& ctx) + { + return 0; + } + + virtual DHTTaskHandle createPeerAnnounceTask(const unsigned char* infoHash) + { + return 0; + } + + virtual DHTTaskHandle createReplaceNodeTask(const DHTBucketHandle& bucket, + const DHTNodeHandle& newNode) + { + return 0; + } +}; + +#endif // _D_MOCK_DHT_TASK_FACTORY_H_ diff --git a/test/MockDHTTaskQueue.h b/test/MockDHTTaskQueue.h new file mode 100644 index 00000000..0c6680ba --- /dev/null +++ b/test/MockDHTTaskQueue.h @@ -0,0 +1,36 @@ +#ifndef _D_MOCK_DHT_TASK_QUEUE_H_ +#define _D_MOCK_DHT_TASK_QUEUE_H_ + +#include "DHTTaskQueue.h" + +class MockDHTTaskQueue:public DHTTaskQueue { +public: + DHTTasks _periodicTaskQueue1; + + DHTTasks _periodicTaskQueue2; + + DHTTasks _immediateTaskQueue; + + MockDHTTaskQueue() {} + + virtual ~MockDHTTaskQueue() {} + + virtual void executeTask() {} + + virtual void addPeriodicTask1(const DHTTaskHandle& task) + { + _periodicTaskQueue1.push_back(task); + } + + virtual void addPeriodicTask2(const DHTTaskHandle& task) + { + _periodicTaskQueue2.push_back(task); + } + + virtual void addImmediateTask(const DHTTaskHandle& task) + { + _immediateTaskQueue.push_back(task); + } +}; + +#endif // _D_MOCK_DHT_TASK_QUEUE_H_ diff --git a/test/MockPeerStorage.h b/test/MockPeerStorage.h index aea23336..a7572807 100644 --- a/test/MockPeerStorage.h +++ b/test/MockPeerStorage.h @@ -33,6 +33,11 @@ public: return false; } + void setActivePeers(const Peers& activePeers) + { + this->activePeers = activePeers; + } + virtual Peers getActivePeers() { return activePeers; } diff --git a/test/OptionHandlerTest.cc b/test/OptionHandlerTest.cc index 741f881e..95555bf1 100644 --- a/test/OptionHandlerTest.cc +++ b/test/OptionHandlerTest.cc @@ -326,8 +326,10 @@ void OptionHandlerTest::testLogOptionHandler() void OptionHandlerTest::testHttpProxyOptionHandler() { - HttpProxyOptionHandler handler("foo"); - CPPUNIT_ASSERT(handler.canHandle("foo")); + HttpProxyOptionHandler handler(PREF_HTTP_PROXY, + PREF_HTTP_PROXY_HOST, + PREF_HTTP_PROXY_PORT); + CPPUNIT_ASSERT(handler.canHandle(PREF_HTTP_PROXY)); CPPUNIT_ASSERT(!handler.canHandle("foobar")); Option option; handler.parse(&option, "bar:80"); diff --git a/test/SocketCoreTest.cc b/test/SocketCoreTest.cc new file mode 100644 index 00000000..279457a1 --- /dev/null +++ b/test/SocketCoreTest.cc @@ -0,0 +1,57 @@ +#include "SocketCore.h" +#include "Exception.h" +#include + +class SocketCoreTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(SocketCoreTest); + CPPUNIT_TEST(testWriteAndReadDatagram); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testWriteAndReadDatagram(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(SocketCoreTest); + +void SocketCoreTest::testWriteAndReadDatagram() +{ + try { + SocketCore s(SOCK_DGRAM); + s.bind(0); + SocketCore c(SOCK_DGRAM); + c.bind(0); + + pair svaddr; + s.getAddrInfo(svaddr); + + string message1 = "hello world."; + c.writeData(message1.c_str(), message1.size(), "localhost", svaddr.second); + string message2 = "chocolate coated pie"; + c.writeData(message2.c_str(), message2.size(), "localhost", svaddr.second); + + char readbuffer[100]; + pair peer; + { + ssize_t rlength = s.readDataFrom(readbuffer, sizeof(readbuffer), peer); + CPPUNIT_ASSERT_EQUAL(string("127.0.0.1"), peer.first); + CPPUNIT_ASSERT_EQUAL((ssize_t)message1.size(), rlength); + readbuffer[rlength] = '\0'; + CPPUNIT_ASSERT_EQUAL(message1, string(readbuffer)); + } + { + ssize_t rlength = s.readDataFrom(readbuffer, sizeof(readbuffer)); + CPPUNIT_ASSERT_EQUAL((ssize_t)message2.size(), rlength); + readbuffer[rlength] = '\0'; + CPPUNIT_ASSERT_EQUAL(message2, string(readbuffer)); + } + } catch(Exception* e) { + cerr << *e << endl; + delete e; + CPPUNIT_FAIL("exception thrown"); + } +} diff --git a/test/XORCloserTest.cc b/test/XORCloserTest.cc new file mode 100644 index 00000000..4323b289 --- /dev/null +++ b/test/XORCloserTest.cc @@ -0,0 +1,48 @@ +#include "XORCloser.h" +#include "Exception.h" +#include "Util.h" +#include "DHTNodeLookupEntry.h" +#include "DHTNode.h" +#include + +class XORCloserTest:public CppUnit::TestFixture { + + CPPUNIT_TEST_SUITE(XORCloserTest); + CPPUNIT_TEST(testOperator); + CPPUNIT_TEST_SUITE_END(); +public: + void setUp() {} + + void tearDown() {} + + void testOperator(); +}; + + +CPPUNIT_TEST_SUITE_REGISTRATION(XORCloserTest); + +void XORCloserTest::testOperator() +{ + const size_t NUM_KEY = 6; + unsigned char keys[NUM_KEY][DHT_ID_LENGTH]; + memset(keys, 0, 6*DHT_ID_LENGTH); + + keys[0][0] = 0xf0; + keys[1][0] = 0xb0; + keys[2][0] = 0xa0; + keys[3][0] = 0x80; + keys[4][0] = 0x00; + keys[4][DHT_ID_LENGTH-1] = 0x01; + keys[5][0] = 0x00; + + deque l(&keys[0], &keys[NUM_KEY]); + + std::sort(l.begin(), l.end(), XORCloser(keys[2], DHT_ID_LENGTH)); + + CPPUNIT_ASSERT(memcmp(keys[2], l[0], DHT_ID_LENGTH) == 0); + CPPUNIT_ASSERT(memcmp(keys[1], l[1], DHT_ID_LENGTH) == 0); + CPPUNIT_ASSERT(memcmp(keys[3], l[2], DHT_ID_LENGTH) == 0); + CPPUNIT_ASSERT(memcmp(keys[0], l[3], DHT_ID_LENGTH) == 0); + CPPUNIT_ASSERT(memcmp(keys[5], l[4], DHT_ID_LENGTH) == 0); + CPPUNIT_ASSERT(memcmp(keys[4], l[5], DHT_ID_LENGTH) == 0); +}