github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 

Made protected member variable private. Added accessor funcs.
	* src/InitiatorMSEHandshakeCommand.cc
	* src/PeerAbstractCommand.cc
	* src/PeerAbstractCommand.h
	* src/PeerInitiateConnectionCommand.cc
	* src/PeerInteractionCommand.cc
	* src/PeerInteractionCommand.h
	* src/PeerReceiveHandshakeCommand.cc
	* src/ReceiverMSEHandshakeCommand.cc
pull/1/head
Tatsuhiro Tsujikawa 2010-06-09 14:02:09 +00:00
parent bc50b5eea2
commit 43460a347f
9 changed files with 213 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
View File

@ -1,3 +1,15 @@
2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Made protected member variable private. Added accessor funcs.
* src/InitiatorMSEHandshakeCommand.cc
* src/PeerAbstractCommand.cc
* src/PeerAbstractCommand.h
* src/PeerInitiateConnectionCommand.cc
* src/PeerInteractionCommand.cc
* src/PeerInteractionCommand.h
* src/PeerReceiveHandshakeCommand.cc
* src/ReceiverMSEHandshakeCommand.cc
2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Code cleanup Code cleanup

37
src/InitiatorMSEHandshakeCommand.cc
View File

@ -73,10 +73,10 @@ InitiatorMSEHandshakeCommand::InitiatorMSEHandshakeCommand
_requestGroup(requestGroup), _requestGroup(requestGroup),
_btRuntime(btRuntime), _btRuntime(btRuntime),
_sequence(INITIATOR_SEND_KEY), _sequence(INITIATOR_SEND_KEY),
_mseHandshake(new MSEHandshake(cuid, socket, getOption().get())) _mseHandshake(new MSEHandshake(cuid, s, getOption().get()))
{ {
disableReadCheckSocket(); disableReadCheckSocket();
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
setTimeout(getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT)); setTimeout(getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT));
_btRuntime->increaseConnections(); _btRuntime->increaseConnections();
@ -94,18 +94,18 @@ InitiatorMSEHandshakeCommand::~InitiatorMSEHandshakeCommand()
bool InitiatorMSEHandshakeCommand::executeInternal() { bool InitiatorMSEHandshakeCommand::executeInternal() {
switch(_sequence) { switch(_sequence) {
case INITIATOR_SEND_KEY: { case INITIATOR_SEND_KEY: {
if(!socket->isWritable(0)) { if(!getSocket()->isWritable(0)) {
break; break;
} }
disableWriteCheckSocket(); disableWriteCheckSocket();
setReadCheckSocket(socket); setReadCheckSocket(getSocket());
//socket->setBlockingMode(); //socket->setBlockingMode();
setTimeout(getOption()->getAsInt(PREF_BT_TIMEOUT)); setTimeout(getOption()->getAsInt(PREF_BT_TIMEOUT));
_mseHandshake->initEncryptionFacility(true); _mseHandshake->initEncryptionFacility(true);
if(_mseHandshake->sendPublicKey()) { if(_mseHandshake->sendPublicKey()) {
_sequence = INITIATOR_WAIT_KEY; _sequence = INITIATOR_WAIT_KEY;
} else { } else {
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
_sequence = INITIATOR_SEND_KEY_PENDING; _sequence = INITIATOR_SEND_KEY_PENDING;
} }
break; break;
@ -123,7 +123,7 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
if(_mseHandshake->sendInitiatorStep2()) { if(_mseHandshake->sendInitiatorStep2()) {
_sequence = INITIATOR_FIND_VC_MARKER; _sequence = INITIATOR_FIND_VC_MARKER;
} else { } else {
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
_sequence = INITIATOR_SEND_STEP2_PENDING; _sequence = INITIATOR_SEND_STEP2_PENDING;
} }
} }
@ -150,25 +150,26 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
case INITIATOR_RECEIVE_PAD_D: { case INITIATOR_RECEIVE_PAD_D: {
if(_mseHandshake->receivePad()) { if(_mseHandshake->receivePad()) {
SharedHandle<PeerConnection> peerConnection SharedHandle<PeerConnection> peerConnection
(new PeerConnection(getCuid(), socket)); (new PeerConnection(getCuid(), getSocket()));
if(_mseHandshake->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4){ if(_mseHandshake->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4){
peerConnection->enableEncryption(_mseHandshake->getEncryptor(), peerConnection->enableEncryption(_mseHandshake->getEncryptor(),
_mseHandshake->getDecryptor()); _mseHandshake->getDecryptor());
} }
PeerInteractionCommand* c = PeerInteractionCommand* c =
new PeerInteractionCommand new PeerInteractionCommand
(getCuid(), _requestGroup, peer, e, _btRuntime, _pieceStorage, (getCuid(), _requestGroup, getPeer(), getDownloadEngine(), _btRuntime,
_pieceStorage,
_peerStorage, _peerStorage,
socket, getSocket(),
PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE, PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE,
peerConnection); peerConnection);
e->addCommand(c); getDownloadEngine()->addCommand(c);
return true; return true;
} }
break; break;
} }
} }
e->addCommand(this); getDownloadEngine()->addCommand(this);
return false; return false;
} }
@ -183,13 +184,13 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait)
} }
if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) { if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) {
SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
peer->usedBy(e->newCUID()); peer->usedBy(getDownloadEngine()->newCUID());
PeerInitiateConnectionCommand* command = PeerInitiateConnectionCommand* command =
new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer,
e, _btRuntime); getDownloadEngine(), _btRuntime);
command->setPeerStorage(_peerStorage); command->setPeerStorage(_peerStorage);
command->setPieceStorage(_pieceStorage); command->setPieceStorage(_pieceStorage);
e->addCommand(command); getDownloadEngine()->addCommand(command);
} }
return true; return true;
} else { } else {
@ -199,11 +200,11 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait)
util::itos(getCuid()).c_str()); util::itos(getCuid()).c_str());
} }
PeerInitiateConnectionCommand* command = PeerInitiateConnectionCommand* command =
new PeerInitiateConnectionCommand(getCuid(), _requestGroup, peer, e, new PeerInitiateConnectionCommand(getCuid(), _requestGroup, getPeer(),
_btRuntime, false); getDownloadEngine(), _btRuntime, false);
command->setPeerStorage(_peerStorage); command->setPeerStorage(_peerStorage);
command->setPieceStorage(_pieceStorage); command->setPieceStorage(_pieceStorage);
e->addCommand(command); getDownloadEngine()->addCommand(command);
return true; return true;
} }
} }
@ -211,7 +212,7 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait)
void InitiatorMSEHandshakeCommand::onAbort() void InitiatorMSEHandshakeCommand::onAbort()
{ {
if(getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) { if(getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
_peerStorage->returnPeer(peer); _peerStorage->returnPeer(getPeer());
} }
} }

99
src/PeerAbstractCommand.cc
View File

@ -58,19 +58,19 @@ PeerAbstractCommand::PeerAbstractCommand(cuid_t cuid,
DownloadEngine* e, DownloadEngine* e,
const SocketHandle& s): const SocketHandle& s):
Command(cuid), Command(cuid),
checkPoint(global::wallclock), _checkPoint(global::wallclock),
e(e),
socket(s),
peer(peer),
checkSocketIsReadable(false),
checkSocketIsWritable(false),
noCheck(false)
{
if(!socket.isNull() && socket->isOpen()) {
setReadCheckSocket(socket);
}
// TODO referring global option // TODO referring global option
timeout = e->getOption()->getAsInt(PREF_BT_TIMEOUT); _timeout(e->getOption()->getAsInt(PREF_BT_TIMEOUT)),
_e(e),
_socket(s),
_peer(peer),
_checkSocketIsReadable(false),
_checkSocketIsWritable(false),
_noCheck(false)
{
if(!_socket.isNull() && _socket->isOpen()) {
setReadCheckSocket(_socket);
}
} }
PeerAbstractCommand::~PeerAbstractCommand() PeerAbstractCommand::~PeerAbstractCommand()
@ -87,24 +87,24 @@ bool PeerAbstractCommand::execute()
util::itos(getCuid()).c_str(), util::itos(getCuid()).c_str(),
readEventEnabled(), writeEventEnabled(), readEventEnabled(), writeEventEnabled(),
hupEventEnabled(), errorEventEnabled(), hupEventEnabled(), errorEventEnabled(),
noCheck); _noCheck);
} }
if(exitBeforeExecute()) { if(exitBeforeExecute()) {
onAbort(); onAbort();
return true; return true;
} }
try { try {
if(noCheck || if(_noCheck ||
(checkSocketIsReadable && readEventEnabled()) || (_checkSocketIsReadable && readEventEnabled()) ||
(checkSocketIsWritable && writeEventEnabled()) || (_checkSocketIsWritable && writeEventEnabled()) ||
hupEventEnabled()) { hupEventEnabled()) {
checkPoint = global::wallclock; _checkPoint = global::wallclock;
} else if(errorEventEnabled()) { } else if(errorEventEnabled()) {
throw DL_ABORT_EX throw DL_ABORT_EX
(StringFormat(MSG_NETWORK_PROBLEM, (StringFormat(MSG_NETWORK_PROBLEM,
socket->getSocketError().c_str()).str()); _socket->getSocketError().c_str()).str());
} }
if(checkPoint.difference(global::wallclock) >= timeout) { if(_checkPoint.difference(global::wallclock) >= _timeout) {
throw DL_ABORT_EX(EX_TIME_OUT); throw DL_ABORT_EX(EX_TIME_OUT);
} }
return executeInternal(); return executeInternal();
@ -118,8 +118,8 @@ bool PeerAbstractCommand::execute()
getLogger()->debug(MSG_TORRENT_DOWNLOAD_ABORTED, err, getLogger()->debug(MSG_TORRENT_DOWNLOAD_ABORTED, err,
util::itos(getCuid()).c_str()); util::itos(getCuid()).c_str());
getLogger()->debug(MSG_PEER_BANNED, getLogger()->debug(MSG_PEER_BANNED,
util::itos(getCuid()).c_str(), peer->ipaddr.c_str(), util::itos(getCuid()).c_str(), _peer->ipaddr.c_str(),
peer->port); _peer->port);
} }
onAbort(); onAbort();
return prepareForNextPeer(0); return prepareForNextPeer(0);
@ -134,10 +134,10 @@ bool PeerAbstractCommand::prepareForNextPeer(time_t wait)
void PeerAbstractCommand::disableReadCheckSocket() void PeerAbstractCommand::disableReadCheckSocket()
{ {
if(checkSocketIsReadable) { if(_checkSocketIsReadable) {
e->deleteSocketForReadCheck(readCheckTarget, this); _e->deleteSocketForReadCheck(_readCheckTarget, this);
checkSocketIsReadable = false; _checkSocketIsReadable = false;
readCheckTarget = SocketHandle(); _readCheckTarget.reset();
} }
} }
@ -146,26 +146,26 @@ void PeerAbstractCommand::setReadCheckSocket(const SocketHandle& socket)
if(!socket->isOpen()) { if(!socket->isOpen()) {
disableReadCheckSocket(); disableReadCheckSocket();
} else { } else {
if(checkSocketIsReadable) { if(_checkSocketIsReadable) {
if(readCheckTarget != socket) { if(_readCheckTarget != socket) {
e->deleteSocketForReadCheck(readCheckTarget, this); _e->deleteSocketForReadCheck(_readCheckTarget, this);
e->addSocketForReadCheck(socket, this); _e->addSocketForReadCheck(socket, this);
readCheckTarget = socket; _readCheckTarget = socket;
} }
} else { } else {
e->addSocketForReadCheck(socket, this); _e->addSocketForReadCheck(socket, this);
checkSocketIsReadable = true; _checkSocketIsReadable = true;
readCheckTarget = socket; _readCheckTarget = socket;
} }
} }
} }
void PeerAbstractCommand::disableWriteCheckSocket() void PeerAbstractCommand::disableWriteCheckSocket()
{ {
if(checkSocketIsWritable) { if(_checkSocketIsWritable) {
e->deleteSocketForWriteCheck(writeCheckTarget, this); _e->deleteSocketForWriteCheck(_writeCheckTarget, this);
checkSocketIsWritable = false; _checkSocketIsWritable = false;
writeCheckTarget = SocketHandle(); _writeCheckTarget.reset();
} }
} }
@ -174,28 +174,33 @@ void PeerAbstractCommand::setWriteCheckSocket(const SocketHandle& socket)
if(!socket->isOpen()) { if(!socket->isOpen()) {
disableWriteCheckSocket(); disableWriteCheckSocket();
} else { } else {
if(checkSocketIsWritable) { if(_checkSocketIsWritable) {
if(writeCheckTarget != socket) { if(_writeCheckTarget != socket) {
e->deleteSocketForWriteCheck(writeCheckTarget, this); _e->deleteSocketForWriteCheck(_writeCheckTarget, this);
e->addSocketForWriteCheck(socket, this); _e->addSocketForWriteCheck(socket, this);
writeCheckTarget = socket; _writeCheckTarget = socket;
} }
} else { } else {
e->addSocketForWriteCheck(socket, this); _e->addSocketForWriteCheck(socket, this);
checkSocketIsWritable = true; _checkSocketIsWritable = true;
writeCheckTarget = socket; _writeCheckTarget = socket;
} }
} }
} }
void PeerAbstractCommand::setNoCheck(bool check) void PeerAbstractCommand::setNoCheck(bool check)
{ {
this->noCheck = check; _noCheck = check;
} }
void PeerAbstractCommand::updateKeepAlive() void PeerAbstractCommand::updateKeepAlive()
{ {
checkPoint = global::wallclock; _checkPoint = global::wallclock;
}
void PeerAbstractCommand::createSocket()
{
_socket.reset(new SocketCore());
} }
} // namespace aria2 } // namespace aria2

42
src/PeerAbstractCommand.h
View File

@ -48,14 +48,36 @@ class SocketCore;
class PeerAbstractCommand : public Command { class PeerAbstractCommand : public Command {
private: private:
Timer checkPoint; Timer _checkPoint;
time_t timeout; time_t _timeout;
protected: DownloadEngine* _e;
DownloadEngine* e; SharedHandle<SocketCore> _socket;
SharedHandle<SocketCore> socket; SharedHandle<Peer> _peer;
SharedHandle<Peer> peer;
void setTimeout(time_t timeout) { this->timeout = timeout; } bool _checkSocketIsReadable;
bool _checkSocketIsWritable;
SharedHandle<SocketCore> _readCheckTarget;
SharedHandle<SocketCore> _writeCheckTarget;
bool _noCheck;
protected:
DownloadEngine* getDownloadEngine() const
{
return _e;
}
const SharedHandle<SocketCore>& getSocket() const
{
return _socket;
}
void createSocket();
const SharedHandle<Peer>& getPeer() const
{
return _peer;
}
void setTimeout(time_t timeout) { _timeout = timeout; }
virtual bool prepareForNextPeer(time_t wait); virtual bool prepareForNextPeer(time_t wait);
virtual void onAbort() {}; virtual void onAbort() {};
// This function is called when DownloadFailureException is caught right after // This function is called when DownloadFailureException is caught right after
@ -69,12 +91,6 @@ protected:
void disableWriteCheckSocket(); void disableWriteCheckSocket();
void setNoCheck(bool check); void setNoCheck(bool check);
void updateKeepAlive(); void updateKeepAlive();
private:
bool checkSocketIsReadable;
bool checkSocketIsWritable;
SharedHandle<SocketCore> readCheckTarget;
SharedHandle<SocketCore> writeCheckTarget;
bool noCheck;
public: public:
PeerAbstractCommand(cuid_t cuid, PeerAbstractCommand(cuid_t cuid,
const SharedHandle<Peer>& peer, const SharedHandle<Peer>& peer,

33
src/PeerInitiateConnectionCommand.cc
View File

@ -82,25 +82,26 @@ PeerInitiateConnectionCommand::~PeerInitiateConnectionCommand()
bool PeerInitiateConnectionCommand::executeInternal() { bool PeerInitiateConnectionCommand::executeInternal() {
if(getLogger()->info()) { if(getLogger()->info()) {
getLogger()->info(MSG_CONNECTING_TO_SERVER, getLogger()->info(MSG_CONNECTING_TO_SERVER,
util::itos(getCuid()).c_str(), peer->ipaddr.c_str(), util::itos(getCuid()).c_str(), getPeer()->ipaddr.c_str(),
peer->port); getPeer()->port);
} }
socket.reset(new SocketCore()); createSocket();
socket->establishConnection(peer->ipaddr, peer->port); getSocket()->establishConnection(getPeer()->ipaddr, getPeer()->port);
if(_mseHandshakeEnabled) { if(_mseHandshakeEnabled) {
InitiatorMSEHandshakeCommand* c = InitiatorMSEHandshakeCommand* c =
new InitiatorMSEHandshakeCommand(getCuid(), _requestGroup, peer, e, new InitiatorMSEHandshakeCommand(getCuid(), _requestGroup, getPeer(),
_btRuntime, socket); getDownloadEngine(),
_btRuntime, getSocket());
c->setPeerStorage(_peerStorage); c->setPeerStorage(_peerStorage);
c->setPieceStorage(_pieceStorage); c->setPieceStorage(_pieceStorage);
e->addCommand(c); getDownloadEngine()->addCommand(c);
} else { } else {
PeerInteractionCommand* command = PeerInteractionCommand* command =
new PeerInteractionCommand new PeerInteractionCommand
(getCuid(), _requestGroup, peer, e, _btRuntime, _pieceStorage, (getCuid(), _requestGroup, getPeer(), getDownloadEngine(),
_peerStorage, _btRuntime, _pieceStorage, _peerStorage,
socket, PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE); getSocket(), PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE);
e->addCommand(command); getDownloadEngine()->addCommand(command);
} }
return true; return true;
} }
@ -109,19 +110,19 @@ bool PeerInitiateConnectionCommand::executeInternal() {
bool PeerInitiateConnectionCommand::prepareForNextPeer(time_t wait) { bool PeerInitiateConnectionCommand::prepareForNextPeer(time_t wait) {
if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) { if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) {
SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
peer->usedBy(e->newCUID()); peer->usedBy(getDownloadEngine()->newCUID());
PeerInitiateConnectionCommand* command = PeerInitiateConnectionCommand* command =
new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, e, new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer,
_btRuntime); getDownloadEngine(), _btRuntime);
command->setPeerStorage(_peerStorage); command->setPeerStorage(_peerStorage);
command->setPieceStorage(_pieceStorage); command->setPieceStorage(_pieceStorage);
e->addCommand(command); getDownloadEngine()->addCommand(command);
} }
return true; return true;
} }
void PeerInitiateConnectionCommand::onAbort() { void PeerInitiateConnectionCommand::onAbort() {
_peerStorage->returnPeer(peer); _peerStorage->returnPeer(getPeer());
} }
bool PeerInitiateConnectionCommand::exitBeforeExecute() bool PeerInitiateConnectionCommand::exitBeforeExecute()

103
src/PeerInteractionCommand.cc
View File

@ -94,12 +94,12 @@ PeerInteractionCommand::PeerInteractionCommand
_btRuntime(btRuntime), _btRuntime(btRuntime),
_pieceStorage(pieceStorage), _pieceStorage(pieceStorage),
_peerStorage(peerStorage), _peerStorage(peerStorage),
sequence(sequence) _sequence(sequence)
{ {
// TODO move following bunch of processing to separate method, like init() // TODO move following bunch of processing to separate method, like init()
if(sequence == INITIATOR_SEND_HANDSHAKE) { if(_sequence == INITIATOR_SEND_HANDSHAKE) {
disableReadCheckSocket(); disableReadCheckSocket();
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
setTimeout(getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT)); setTimeout(getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT));
} }
@ -119,7 +119,7 @@ PeerInteractionCommand::PeerInteractionCommand
} }
SharedHandle<DefaultExtensionMessageFactory> extensionMessageFactory SharedHandle<DefaultExtensionMessageFactory> extensionMessageFactory
(new DefaultExtensionMessageFactory(peer, exMsgRegistry)); (new DefaultExtensionMessageFactory(getPeer(), exMsgRegistry));
extensionMessageFactory->setPeerStorage(peerStorage); extensionMessageFactory->setPeerStorage(peerStorage);
extensionMessageFactory->setDownloadContext extensionMessageFactory->setDownloadContext
(_requestGroup->getDownloadContext()); (_requestGroup->getDownloadContext());
@ -133,7 +133,7 @@ PeerInteractionCommand::PeerInteractionCommand
factory->setPieceStorage(pieceStorage); factory->setPieceStorage(pieceStorage);
factory->setPeerStorage(peerStorage); factory->setPeerStorage(peerStorage);
factory->setExtensionMessageFactory(extensionMessageFactory); factory->setExtensionMessageFactory(extensionMessageFactory);
factory->setPeer(peer); factory->setPeer(getPeer());
factory->setLocalNode(DHTRegistry::_localNode); factory->setLocalNode(DHTRegistry::_localNode);
factory->setRoutingTable(DHTRegistry::_routingTable); factory->setRoutingTable(DHTRegistry::_routingTable);
factory->setTaskQueue(DHTRegistry::_taskQueue); factory->setTaskQueue(DHTRegistry::_taskQueue);
@ -144,7 +144,7 @@ PeerInteractionCommand::PeerInteractionCommand
PeerConnectionHandle peerConnection; PeerConnectionHandle peerConnection;
if(passedPeerConnection.isNull()) { if(passedPeerConnection.isNull()) {
peerConnection.reset(new PeerConnection(cuid, socket)); peerConnection.reset(new PeerConnection(cuid, getSocket()));
} else { } else {
peerConnection = passedPeerConnection; peerConnection = passedPeerConnection;
} }
@ -152,17 +152,17 @@ PeerInteractionCommand::PeerInteractionCommand
SharedHandle<DefaultBtMessageDispatcher> dispatcher SharedHandle<DefaultBtMessageDispatcher> dispatcher
(new DefaultBtMessageDispatcher()); (new DefaultBtMessageDispatcher());
dispatcher->setCuid(cuid); dispatcher->setCuid(cuid);
dispatcher->setPeer(peer); dispatcher->setPeer(getPeer());
dispatcher->setDownloadContext(_requestGroup->getDownloadContext()); dispatcher->setDownloadContext(_requestGroup->getDownloadContext());
dispatcher->setPieceStorage(pieceStorage); dispatcher->setPieceStorage(pieceStorage);
dispatcher->setPeerStorage(peerStorage); dispatcher->setPeerStorage(peerStorage);
dispatcher->setRequestTimeout(getOption()->getAsInt(PREF_BT_REQUEST_TIMEOUT)); dispatcher->setRequestTimeout(getOption()->getAsInt(PREF_BT_REQUEST_TIMEOUT));
dispatcher->setBtMessageFactory(factory); dispatcher->setBtMessageFactory(factory);
dispatcher->setRequestGroupMan(e->getRequestGroupMan()); dispatcher->setRequestGroupMan(getDownloadEngine()->getRequestGroupMan());
DefaultBtMessageReceiverHandle receiver(new DefaultBtMessageReceiver()); DefaultBtMessageReceiverHandle receiver(new DefaultBtMessageReceiver());
receiver->setCuid(cuid); receiver->setCuid(cuid);
receiver->setPeer(peer); receiver->setPeer(getPeer());
receiver->setDownloadContext(_requestGroup->getDownloadContext()); receiver->setDownloadContext(_requestGroup->getDownloadContext());
receiver->setPeerConnection(peerConnection); receiver->setPeerConnection(peerConnection);
receiver->setDispatcher(dispatcher); receiver->setDispatcher(dispatcher);
@ -171,13 +171,13 @@ PeerInteractionCommand::PeerInteractionCommand
SharedHandle<DefaultBtRequestFactory> reqFactory SharedHandle<DefaultBtRequestFactory> reqFactory
(new DefaultBtRequestFactory()); (new DefaultBtRequestFactory());
reqFactory->setCuid(cuid); reqFactory->setCuid(cuid);
reqFactory->setPeer(peer); reqFactory->setPeer(getPeer());
reqFactory->setPieceStorage(pieceStorage); reqFactory->setPieceStorage(pieceStorage);
reqFactory->setBtMessageDispatcher(dispatcher); reqFactory->setBtMessageDispatcher(dispatcher);
reqFactory->setBtMessageFactory(factory); reqFactory->setBtMessageFactory(factory);
DefaultBtInteractiveHandle btInteractive DefaultBtInteractiveHandle btInteractive
(new DefaultBtInteractive(_requestGroup->getDownloadContext(), peer)); (new DefaultBtInteractive(_requestGroup->getDownloadContext(), getPeer()));
btInteractive->setBtRuntime(_btRuntime); btInteractive->setBtRuntime(_btRuntime);
btInteractive->setPieceStorage(_pieceStorage); btInteractive->setPieceStorage(_pieceStorage);
btInteractive->setPeerStorage(peerStorage); // Note: Not a member variable. btInteractive->setPeerStorage(peerStorage); // Note: Not a member variable.
@ -190,10 +190,10 @@ PeerInteractionCommand::PeerInteractionCommand
btInteractive->setExtensionMessageRegistry(exMsgRegistry); btInteractive->setExtensionMessageRegistry(exMsgRegistry);
btInteractive->setKeepAliveInterval btInteractive->setKeepAliveInterval
(getOption()->getAsInt(PREF_BT_KEEP_ALIVE_INTERVAL)); (getOption()->getAsInt(PREF_BT_KEEP_ALIVE_INTERVAL));
btInteractive->setRequestGroupMan(e->getRequestGroupMan()); btInteractive->setRequestGroupMan(getDownloadEngine()->getRequestGroupMan());
btInteractive->setBtMessageFactory(factory); btInteractive->setBtMessageFactory(factory);
if((metadataGetMode || torrentAttrs[bittorrent::PRIVATE].i() == 0) && if((metadataGetMode || torrentAttrs[bittorrent::PRIVATE].i() == 0) &&
!peer->isLocalPeer()) { !getPeer()->isLocalPeer()) {
if(getOption()->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) { if(getOption()->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) {
btInteractive->setUTPexEnabled(true); btInteractive->setUTPexEnabled(true);
} }
@ -209,7 +209,7 @@ PeerInteractionCommand::PeerInteractionCommand
btInteractive->enableMetadataGetMode(); btInteractive->enableMetadataGetMode();
} }
this->btInteractive = btInteractive; _btInteractive = btInteractive;
// reverse depends // reverse depends
factory->setBtMessageDispatcher(dispatcher); factory->setBtMessageDispatcher(dispatcher);
@ -224,26 +224,26 @@ PeerInteractionCommand::PeerInteractionCommand
(_requestGroup->getDownloadContext()); (_requestGroup->getDownloadContext());
utMetadataRequestFactory->setBtMessageDispatcher(dispatcher); utMetadataRequestFactory->setBtMessageDispatcher(dispatcher);
utMetadataRequestFactory->setBtMessageFactory(factory); utMetadataRequestFactory->setBtMessageFactory(factory);
utMetadataRequestFactory->setPeer(peer); utMetadataRequestFactory->setPeer(getPeer());
utMetadataRequestFactory->setUTMetadataRequestTracker utMetadataRequestFactory->setUTMetadataRequestTracker
(utMetadataRequestTracker); (utMetadataRequestTracker);
} }
peer->allocateSessionResource getPeer()->allocateSessionResource
(_requestGroup->getDownloadContext()->getPieceLength(), (_requestGroup->getDownloadContext()->getPieceLength(),
_requestGroup->getDownloadContext()->getTotalLength()); _requestGroup->getDownloadContext()->getTotalLength());
peer->setBtMessageDispatcher(dispatcher); getPeer()->setBtMessageDispatcher(dispatcher);
_btRuntime->increaseConnections(); _btRuntime->increaseConnections();
_requestGroup->increaseNumCommand(); _requestGroup->increaseNumCommand();
} }
PeerInteractionCommand::~PeerInteractionCommand() { PeerInteractionCommand::~PeerInteractionCommand() {
if(peer->getCompletedLength() > 0) { if(getPeer()->getCompletedLength() > 0) {
_pieceStorage->subtractPieceStats(peer->getBitfield(), _pieceStorage->subtractPieceStats(getPeer()->getBitfield(),
peer->getBitfieldLength()); getPeer()->getBitfieldLength());
} }
peer->releaseSessionResource(); getPeer()->releaseSessionResource();
_requestGroup->decreaseNumCommand(); _requestGroup->decreaseNumCommand();
_btRuntime->decreaseConnections(); _btRuntime->decreaseConnections();
@ -251,75 +251,76 @@ PeerInteractionCommand::~PeerInteractionCommand() {
bool PeerInteractionCommand::executeInternal() { bool PeerInteractionCommand::executeInternal() {
setNoCheck(false); setNoCheck(false);
switch(sequence) { switch(_sequence) {
case INITIATOR_SEND_HANDSHAKE: case INITIATOR_SEND_HANDSHAKE:
if(!socket->isWritable(0)) { if(!getSocket()->isWritable(0)) {
break; break;
} }
disableWriteCheckSocket(); disableWriteCheckSocket();
setReadCheckSocket(socket); setReadCheckSocket(getSocket());
//socket->setBlockingMode(); //socket->setBlockingMode();
setTimeout(getOption()->getAsInt(PREF_BT_TIMEOUT)); setTimeout(getOption()->getAsInt(PREF_BT_TIMEOUT));
btInteractive->initiateHandshake(); _btInteractive->initiateHandshake();
sequence = INITIATOR_WAIT_HANDSHAKE; _sequence = INITIATOR_WAIT_HANDSHAKE;
break; break;
case INITIATOR_WAIT_HANDSHAKE: { case INITIATOR_WAIT_HANDSHAKE: {
if(btInteractive->countPendingMessage() > 0) { if(_btInteractive->countPendingMessage() > 0) {
btInteractive->sendPendingMessage(); _btInteractive->sendPendingMessage();
if(btInteractive->countPendingMessage() > 0) { if(_btInteractive->countPendingMessage() > 0) {
break; break;
} }
} }
BtMessageHandle handshakeMessage = btInteractive->receiveHandshake(); BtMessageHandle handshakeMessage = _btInteractive->receiveHandshake();
if(handshakeMessage.isNull()) { if(handshakeMessage.isNull()) {
break; break;
} }
btInteractive->doPostHandshakeProcessing(); _btInteractive->doPostHandshakeProcessing();
sequence = WIRED; _sequence = WIRED;
break; break;
} }
case RECEIVER_WAIT_HANDSHAKE: { case RECEIVER_WAIT_HANDSHAKE: {
BtMessageHandle handshakeMessage = btInteractive->receiveAndSendHandshake(); BtMessageHandle handshakeMessage =_btInteractive->receiveAndSendHandshake();
if(handshakeMessage.isNull()) { if(handshakeMessage.isNull()) {
break; break;
} }
btInteractive->doPostHandshakeProcessing(); _btInteractive->doPostHandshakeProcessing();
sequence = WIRED; _sequence = WIRED;
break; break;
} }
case WIRED: case WIRED:
// See the comment for writable check below. // See the comment for writable check below.
disableWriteCheckSocket(); disableWriteCheckSocket();
btInteractive->doInteractionProcessing(); _btInteractive->doInteractionProcessing();
if(btInteractive->countReceivedMessageInIteration() > 0) { if(_btInteractive->countReceivedMessageInIteration() > 0) {
updateKeepAlive(); updateKeepAlive();
} }
if((peer->amInterested() && !peer->peerChoking()) || if((getPeer()->amInterested() && !getPeer()->peerChoking()) ||
btInteractive->countOutstandingRequest() || _btInteractive->countOutstandingRequest() ||
(peer->peerInterested() && !peer->amChoking())) { (getPeer()->peerInterested() && !getPeer()->amChoking())) {
// Writable check to avoid slow seeding // Writable check to avoid slow seeding
if(btInteractive->isSendingMessageInProgress()) { if(_btInteractive->isSendingMessageInProgress()) {
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
} }
if(e->getRequestGroupMan()->doesOverallDownloadSpeedExceed() || if(getDownloadEngine()->getRequestGroupMan()->
doesOverallDownloadSpeedExceed() ||
_requestGroup->doesDownloadSpeedExceed()) { _requestGroup->doesDownloadSpeedExceed()) {
disableReadCheckSocket(); disableReadCheckSocket();
setNoCheck(true); setNoCheck(true);
} else { } else {
setReadCheckSocket(socket); setReadCheckSocket(getSocket());
} }
} else { } else {
disableReadCheckSocket(); disableReadCheckSocket();
} }
break; break;
} }
if(btInteractive->countPendingMessage() > 0) { if(_btInteractive->countPendingMessage() > 0) {
setNoCheck(true); setNoCheck(true);
} }
e->addCommand(this); getDownloadEngine()->addCommand(this);
return false; return false;
} }
@ -327,20 +328,20 @@ bool PeerInteractionCommand::executeInternal() {
bool PeerInteractionCommand::prepareForNextPeer(time_t wait) { bool PeerInteractionCommand::prepareForNextPeer(time_t wait) {
if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) { if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) {
SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
peer->usedBy(e->newCUID()); peer->usedBy(getDownloadEngine()->newCUID());
PeerInitiateConnectionCommand* command = PeerInitiateConnectionCommand* command =
new PeerInitiateConnectionCommand new PeerInitiateConnectionCommand
(peer->usedBy(), _requestGroup, peer, e, _btRuntime); (peer->usedBy(), _requestGroup, peer, getDownloadEngine(), _btRuntime);
command->setPeerStorage(_peerStorage); command->setPeerStorage(_peerStorage);
command->setPieceStorage(_pieceStorage); command->setPieceStorage(_pieceStorage);
e->addCommand(command); getDownloadEngine()->addCommand(command);
} }
return true; return true;
} }
void PeerInteractionCommand::onAbort() { void PeerInteractionCommand::onAbort() {
btInteractive->cancelAllPiece(); _btInteractive->cancelAllPiece();
_peerStorage->returnPeer(peer); _peerStorage->returnPeer(getPeer());
} }
void PeerInteractionCommand::onFailure() void PeerInteractionCommand::onFailure()

4
src/PeerInteractionCommand.h
View File

@ -63,8 +63,8 @@ private:
SharedHandle<PeerStorage> _peerStorage; SharedHandle<PeerStorage> _peerStorage;
Seq sequence; Seq _sequence;
SharedHandle<BtInteractive> btInteractive; SharedHandle<BtInteractive> _btInteractive;
const SharedHandle<Option>& getOption() const; const SharedHandle<Option>& getOption() const;
protected: protected:

27
src/PeerReceiveHandshakeCommand.cc
View File

@ -73,7 +73,7 @@ PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand
_peerConnection(peerConnection) _peerConnection(peerConnection)
{ {
if(_peerConnection.isNull()) { if(_peerConnection.isNull()) {
_peerConnection.reset(new PeerConnection(cuid, socket)); _peerConnection.reset(new PeerConnection(cuid, getSocket()));
} }
} }
@ -81,7 +81,8 @@ PeerReceiveHandshakeCommand::~PeerReceiveHandshakeCommand() {}
bool PeerReceiveHandshakeCommand::exitBeforeExecute() bool PeerReceiveHandshakeCommand::exitBeforeExecute()
{ {
return e->isHaltRequested() || e->getRequestGroupMan()->downloadFinished(); return getDownloadEngine()->isHaltRequested() ||
getDownloadEngine()->getRequestGroupMan()->downloadFinished();
} }
bool PeerReceiveHandshakeCommand::executeInternal() bool PeerReceiveHandshakeCommand::executeInternal()
@ -97,13 +98,13 @@ bool PeerReceiveHandshakeCommand::executeInternal()
std::string infoHash = std::string(&data[28], &data[28+INFO_HASH_LENGTH]); std::string infoHash = std::string(&data[28], &data[28+INFO_HASH_LENGTH]);
SharedHandle<DownloadContext> downloadContext = SharedHandle<DownloadContext> downloadContext =
e->getBtRegistry()->getDownloadContext(infoHash); getDownloadEngine()->getBtRegistry()->getDownloadContext(infoHash);
if(downloadContext.isNull()) { if(downloadContext.isNull()) {
throw DL_ABORT_EX throw DL_ABORT_EX
(StringFormat("Unknown info hash %s", (StringFormat("Unknown info hash %s",
util::toHex(infoHash).c_str()).str()); util::toHex(infoHash).c_str()).str());
} }
BtObject btObject = e->getBtRegistry()->get BtObject btObject = getDownloadEngine()->getBtRegistry()->get
(downloadContext->getOwnerRequestGroup()->getGID()); (downloadContext->getOwnerRequestGroup()->getGID());
SharedHandle<BtRuntime> btRuntime = btObject._btRuntime; SharedHandle<BtRuntime> btRuntime = btObject._btRuntime;
SharedHandle<PieceStorage> pieceStorage = btObject._pieceStorage; SharedHandle<PieceStorage> pieceStorage = btObject._pieceStorage;
@ -128,33 +129,31 @@ bool PeerReceiveHandshakeCommand::executeInternal()
if((!pieceStorage->downloadFinished() && if((!pieceStorage->downloadFinished() &&
tstat.getDownloadSpeed() < thresholdSpeed) || tstat.getDownloadSpeed() < thresholdSpeed) ||
btRuntime->lessThanMaxPeers()) { btRuntime->lessThanMaxPeers()) {
if(peerStorage->addPeer(peer)) { if(peerStorage->addPeer(getPeer())) {
getPeer()->usedBy(getCuid());
peer->usedBy(getCuid());
PeerInteractionCommand* command = PeerInteractionCommand* command =
new PeerInteractionCommand new PeerInteractionCommand
(getCuid(), (getCuid(),
downloadContext->getOwnerRequestGroup(), downloadContext->getOwnerRequestGroup(),
peer, getPeer(),
e, getDownloadEngine(),
btRuntime, btRuntime,
pieceStorage, pieceStorage,
peerStorage, peerStorage,
socket, getSocket(),
PeerInteractionCommand::RECEIVER_WAIT_HANDSHAKE, PeerInteractionCommand::RECEIVER_WAIT_HANDSHAKE,
_peerConnection); _peerConnection);
e->addCommand(command); getDownloadEngine()->addCommand(command);
if(getLogger()->debug()) { if(getLogger()->debug()) {
getLogger()->debug(MSG_INCOMING_PEER_CONNECTION, getLogger()->debug(MSG_INCOMING_PEER_CONNECTION,
util::itos(getCuid()).c_str(), util::itos(getCuid()).c_str(),
util::itos(peer->usedBy()).c_str()); util::itos(getPeer()->usedBy()).c_str());
} }
} }
} }
return true; return true;
} else { } else {
e->addCommand(this); getDownloadEngine()->addCommand(this);
return false; return false;
} }
} }

29
src/ReceiverMSEHandshakeCommand.cc
View File

@ -81,7 +81,8 @@ ReceiverMSEHandshakeCommand::~ReceiverMSEHandshakeCommand()
bool ReceiverMSEHandshakeCommand::exitBeforeExecute() bool ReceiverMSEHandshakeCommand::exitBeforeExecute()
{ {
return e->isHaltRequested() || e->getRequestGroupMan()->downloadFinished(); return getDownloadEngine()->isHaltRequested() ||
getDownloadEngine()->getRequestGroupMan()->downloadFinished();
} }
bool ReceiverMSEHandshakeCommand::executeInternal() bool ReceiverMSEHandshakeCommand::executeInternal()
@ -97,18 +98,21 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
_sequence = RECEIVER_WAIT_KEY; _sequence = RECEIVER_WAIT_KEY;
break; break;
case MSEHandshake::HANDSHAKE_LEGACY: { case MSEHandshake::HANDSHAKE_LEGACY: {
if(e->getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) { if(getDownloadEngine()->getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
throw DL_ABORT_EX throw DL_ABORT_EX
("The legacy BitTorrent handshake is not acceptable by the" ("The legacy BitTorrent handshake is not acceptable by the"
" preference."); " preference.");
} }
SharedHandle<PeerConnection> peerConnection SharedHandle<PeerConnection> peerConnection
(new PeerConnection(getCuid(), socket)); (new PeerConnection(getCuid(), getSocket()));
peerConnection->presetBuffer(_mseHandshake->getBuffer(), peerConnection->presetBuffer(_mseHandshake->getBuffer(),
_mseHandshake->getBufferLength()); _mseHandshake->getBufferLength());
Command* c = new PeerReceiveHandshakeCommand(getCuid(), peer, e, socket, Command* c = new PeerReceiveHandshakeCommand(getCuid(),
getPeer(),
getDownloadEngine(),
getSocket(),
peerConnection); peerConnection);
e->addCommand(c); getDownloadEngine()->addCommand(c);
return true; return true;
} }
default: default:
@ -121,7 +125,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
if(_mseHandshake->sendPublicKey()) { if(_mseHandshake->sendPublicKey()) {
_sequence = RECEIVER_FIND_HASH_MARKER; _sequence = RECEIVER_FIND_HASH_MARKER;
} else { } else {
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
_sequence = RECEIVER_SEND_KEY_PENDING; _sequence = RECEIVER_SEND_KEY_PENDING;
} }
} }
@ -141,7 +145,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
} }
case RECEIVER_RECEIVE_PAD_C_LENGTH: { case RECEIVER_RECEIVE_PAD_C_LENGTH: {
std::vector<SharedHandle<DownloadContext> > downloadContexts; std::vector<SharedHandle<DownloadContext> > downloadContexts;
e->getBtRegistry()->getAllDownloadContext getDownloadEngine()->getBtRegistry()->getAllDownloadContext
(std::back_inserter(downloadContexts)); (std::back_inserter(downloadContexts));
if(_mseHandshake->receiveReceiverHashAndPadCLength(downloadContexts)) { if(_mseHandshake->receiveReceiverHashAndPadCLength(downloadContexts)) {
_sequence = RECEIVER_RECEIVE_PAD_C; _sequence = RECEIVER_RECEIVE_PAD_C;
@ -166,7 +170,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
createCommand(); createCommand();
return true; return true;
} else { } else {
setWriteCheckSocket(socket); setWriteCheckSocket(getSocket());
_sequence = RECEIVER_SEND_STEP2_PENDING; _sequence = RECEIVER_SEND_STEP2_PENDING;
} }
} }
@ -180,14 +184,14 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
} }
break; break;
} }
e->addCommand(this); getDownloadEngine()->addCommand(this);
return false; return false;
} }
void ReceiverMSEHandshakeCommand::createCommand() void ReceiverMSEHandshakeCommand::createCommand()
{ {
SharedHandle<PeerConnection> peerConnection SharedHandle<PeerConnection> peerConnection
(new PeerConnection(getCuid(), socket)); (new PeerConnection(getCuid(), getSocket()));
if(_mseHandshake->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4) { if(_mseHandshake->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4) {
peerConnection->enableEncryption(_mseHandshake->getEncryptor(), peerConnection->enableEncryption(_mseHandshake->getEncryptor(),
_mseHandshake->getDecryptor()); _mseHandshake->getDecryptor());
@ -200,8 +204,9 @@ void ReceiverMSEHandshakeCommand::createCommand()
// as a hint. If this info hash and one in BitTorrent Handshake does not // as a hint. If this info hash and one in BitTorrent Handshake does not
// match, then drop connection. // match, then drop connection.
Command* c = Command* c =
new PeerReceiveHandshakeCommand(getCuid(), peer, e, socket, peerConnection); new PeerReceiveHandshakeCommand(getCuid(), getPeer(), getDownloadEngine(),
e->addCommand(c); getSocket(), peerConnection);
getDownloadEngine()->addCommand(c);
} }
} // namespace aria2 } // namespace aria2