diff options
Diffstat (limited to 'src')
26 files changed, 793 insertions, 668 deletions
diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc index 1973020d..038780ef 100644 --- a/src/AbstractCommand.cc +++ b/src/AbstractCommand.cc @@ -77,15 +77,16 @@ AbstractCommand::AbstractCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e, const SocketHandle& s): - Command(cuid), checkPoint(global::wallclock), _requestGroup(requestGroup), - req(req), _fileEntry(fileEntry), e(e), socket(s), - checkSocketIsReadable(false), checkSocketIsWritable(false), - nameResolverCheck(false) + Command(cuid), _checkPoint(global::wallclock), + _timeout(requestGroup->getTimeout()), + _requestGroup(requestGroup), + _req(req), _fileEntry(fileEntry), _e(e), _socket(s), + _checkSocketIsReadable(false), _checkSocketIsWritable(false), + _nameResolverCheck(false) { - if(!socket.isNull() && socket->isOpen()) { - setReadCheckSocket(socket); + if(!_socket.isNull() && _socket->isOpen()) { + setReadCheckSocket(_socket); } - timeout = _requestGroup->getTimeout(); _requestGroup->increaseStreamConnection(); _requestGroup->increaseNumCommand(); } @@ -113,19 +114,19 @@ bool AbstractCommand::execute() { if(_requestGroup->downloadFinished() || _requestGroup->isHaltRequested()) { return true; } - if(!req.isNull() && req->removalRequested()) { + if(!_req.isNull() && _req->removalRequested()) { if(getLogger()->debug()) { getLogger()->debug ("CUID#%s - Discard original URI=%s because it is requested.", - util::itos(getCuid()).c_str(), req->getUri().c_str()); + util::itos(getCuid()).c_str(), _req->getUri().c_str()); } return prepareForRetry(0); } // TODO it is not needed to check other PeerStats every time. // Find faster Request when no segment is available. - if(!req.isNull() && _fileEntry->countPooledRequest() > 0 && - !_requestGroup->getPieceStorage()->hasMissingUnusedPiece()) { - SharedHandle<Request> fasterRequest = _fileEntry->findFasterRequest(req); + if(!_req.isNull() && _fileEntry->countPooledRequest() > 0 && + !getPieceStorage()->hasMissingUnusedPiece()) { + SharedHandle<Request> fasterRequest = _fileEntry->findFasterRequest(_req); if(!fasterRequest.isNull()) { if(getLogger()->info()) { getLogger()->info("CUID#%s - Use faster Request hostname=%s, port=%u", @@ -134,29 +135,28 @@ bool AbstractCommand::execute() { fasterRequest->getPort()); } // Cancel current Request object and use faster one. - _fileEntry->removeRequest(req); + _fileEntry->removeRequest(_req); Command* command = InitiateConnectionCommandFactory::createInitiateConnectionCommand - (getCuid(), fasterRequest, _fileEntry, _requestGroup, e); - e->setNoWait(true); - e->addCommand(command); + (getCuid(), fasterRequest, _fileEntry, _requestGroup, _e); + _e->setNoWait(true); + _e->addCommand(command); return true; } } - if((checkSocketIsReadable && readEventEnabled()) || - (checkSocketIsWritable && writeEventEnabled()) || + if((_checkSocketIsReadable && readEventEnabled()) || + (_checkSocketIsWritable && writeEventEnabled()) || hupEventEnabled() || #ifdef ENABLE_ASYNC_DNS - (nameResolverCheck && nameResolveFinished()) || + (_nameResolverCheck && nameResolveFinished()) || #endif // ENABLE_ASYNC_DNS - (!checkSocketIsReadable && !checkSocketIsWritable && - !nameResolverCheck)) { - checkPoint = global::wallclock; - if(!_requestGroup->getPieceStorage().isNull()) { + (!_checkSocketIsReadable && !_checkSocketIsWritable && + !_nameResolverCheck)) { + _checkPoint = global::wallclock; + if(!getPieceStorage().isNull()) { _segments.clear(); - _requestGroup->getSegmentMan()->getInFlightSegment - (_segments, getCuid()); - if(!req.isNull() && _segments.empty()) { + getSegmentMan()->getInFlightSegment(_segments, getCuid()); + if(!_req.isNull() && _segments.empty()) { // This command previously has assigned segments, but it is // canceled. So discard current request chain. if(getLogger()->debug()) { @@ -166,11 +166,11 @@ bool AbstractCommand::execute() { } return prepareForRetry(0); } - if(req.isNull() || req->getMaxPipelinedRequest() == 1 || + if(_req.isNull() || _req->getMaxPipelinedRequest() == 1 || _requestGroup->getDownloadContext()->getFileEntries().size() == 1) { if(_segments.empty()) { SharedHandle<Segment> segment = - _requestGroup->getSegmentMan()->getSegment(getCuid()); + getSegmentMan()->getSegment(getCuid()); if(!segment.isNull()) { _segments.push_back(segment); } @@ -183,7 +183,7 @@ bool AbstractCommand::execute() { } // When all segments are ignored in SegmentMan, there are // no URIs available, so don't retry. - if(_requestGroup->getSegmentMan()->allSegmentsIgnored()) { + if(getSegmentMan()->allSegmentsIgnored()) { if(getLogger()->debug()) { getLogger()->debug("All segments are ignored."); } @@ -193,9 +193,9 @@ bool AbstractCommand::execute() { } } } else { - size_t maxSegments = req->getMaxPipelinedRequest(); + size_t maxSegments = _req->getMaxPipelinedRequest(); if(_segments.size() < maxSegments) { - _requestGroup->getSegmentMan()->getSegment + getSegmentMan()->getSegment (_segments, getCuid(), _fileEntry, maxSegments); } if(_segments.empty()) { @@ -207,23 +207,23 @@ bool AbstractCommand::execute() { } else if(errorEventEnabled()) { throw DL_RETRY_EX (StringFormat(MSG_NETWORK_PROBLEM, - socket->getSocketError().c_str()).str()); + _socket->getSocketError().c_str()).str()); } else { - if(checkPoint.difference(global::wallclock) >= timeout) { + if(_checkPoint.difference(global::wallclock) >= _timeout) { // timeout triggers ServerStat error state. SharedHandle<ServerStat> ss = - e->getRequestGroupMan()->getOrCreateServerStat(req->getHost(), - req->getProtocol()); + _e->getRequestGroupMan()->getOrCreateServerStat(_req->getHost(), + _req->getProtocol()); ss->setError(); throw DL_RETRY_EX2(EX_TIME_OUT, downloadresultcode::TIME_OUT); } - e->addCommand(this); + _e->addCommand(this); return false; } } catch(DlAbortEx& err) { - if(req.isNull()) { + if(_req.isNull()) { if(getLogger()->debug()) { getLogger()->debug(EX_EXCEPTION_CAUGHT, err); } @@ -231,10 +231,10 @@ bool AbstractCommand::execute() { getLogger()->error (MSG_DOWNLOAD_ABORTED, DL_ABORT_EX2(StringFormat - ("URI=%s", req->getCurrentUri().c_str()).str(),err), - util::itos(getCuid()).c_str(), req->getUri().c_str()); - _fileEntry->addURIResult(req->getUri(), err.getCode()); - _requestGroup->setLastUriResult(req->getUri(), err.getCode()); + ("URI=%s", _req->getCurrentUri().c_str()).str(),err), + util::itos(getCuid()).c_str(), _req->getUri().c_str()); + _fileEntry->addURIResult(_req->getUri(), err.getCode()); + _requestGroup->setLastUriResult(_req->getUri(), err.getCode()); if(err.getCode() == downloadresultcode::CANNOT_RESUME) { _requestGroup->increaseResumeFailureCount(); } @@ -243,29 +243,29 @@ bool AbstractCommand::execute() { tryReserved(); return true; } catch(DlRetryEx& err) { - assert(!req.isNull()); + assert(!_req.isNull()); if(getLogger()->info()) { getLogger()->info (MSG_RESTARTING_DOWNLOAD, DL_RETRY_EX2(StringFormat - ("URI=%s", req->getCurrentUri().c_str()).str(), + ("URI=%s", _req->getCurrentUri().c_str()).str(), err), - util::itos(getCuid()).c_str(), req->getUri().c_str()); + util::itos(getCuid()).c_str(), _req->getUri().c_str()); } - req->addTryCount(); - req->resetRedirectCount(); + _req->addTryCount(); + _req->resetRedirectCount(); const unsigned int maxTries = getOption()->getAsInt(PREF_MAX_TRIES); - bool isAbort = maxTries != 0 && req->getTryCount() >= maxTries; + bool isAbort = maxTries != 0 && _req->getTryCount() >= maxTries; if(isAbort) { if(getLogger()->info()) { getLogger()->info(MSG_MAX_TRY, - util::itos(getCuid()).c_str(), req->getTryCount()); + util::itos(getCuid()).c_str(), _req->getTryCount()); } getLogger()->error(MSG_DOWNLOAD_ABORTED, err, util::itos(getCuid()).c_str(), - req->getUri().c_str()); - _fileEntry->addURIResult(req->getUri(), err.getCode()); - _requestGroup->setLastUriResult(req->getUri(), err.getCode()); + _req->getUri().c_str()); + _fileEntry->addURIResult(_req->getUri(), err.getCode()); + _requestGroup->setLastUriResult(_req->getUri(), err.getCode()); if(err.getCode() == downloadresultcode::CANNOT_RESUME) { _requestGroup->increaseResumeFailureCount(); } @@ -277,9 +277,9 @@ bool AbstractCommand::execute() { } } catch(DownloadFailureException& err) { getLogger()->error(EX_EXCEPTION_CAUGHT, err); - if(!req.isNull()) { - _fileEntry->addURIResult(req->getUri(), err.getCode()); - _requestGroup->setLastUriResult(req->getUri(), err.getCode()); + if(!_req.isNull()) { + _fileEntry->addURIResult(_req->getUri(), err.getCode()); + _requestGroup->setLastUriResult(_req->getUri(), err.getCode()); } _requestGroup->setHaltRequested(true); return true; @@ -308,59 +308,58 @@ void AbstractCommand::tryReserved() { util::itos(getCuid()).c_str()); } std::vector<Command*> commands; - _requestGroup->createNextCommand(commands, e, 1); - e->setNoWait(true); - e->addCommand(commands); + _requestGroup->createNextCommand(commands, _e, 1); + _e->setNoWait(true); + _e->addCommand(commands); } bool AbstractCommand::prepareForRetry(time_t wait) { - if(!_requestGroup->getPieceStorage().isNull()) { - _requestGroup->getSegmentMan()->cancelSegment(getCuid()); + if(!getPieceStorage().isNull()) { + getSegmentMan()->cancelSegment(getCuid()); } - if(!req.isNull()) { - _fileEntry->poolRequest(req); + if(!_req.isNull()) { + _fileEntry->poolRequest(_req); if(getLogger()->debug()) { getLogger()->debug("CUID#%s - Pooling request URI=%s", - util::itos(getCuid()).c_str(), req->getUri().c_str()); + util::itos(getCuid()).c_str(), _req->getUri().c_str()); } - if(!_requestGroup->getSegmentMan().isNull()) { - _requestGroup->getSegmentMan()->recognizeSegmentFor(_fileEntry); + if(!getSegmentMan().isNull()) { + getSegmentMan()->recognizeSegmentFor(_fileEntry); } } - Command* command = new CreateRequestCommand(getCuid(), _requestGroup, e); + Command* command = new CreateRequestCommand(getCuid(), _requestGroup, _e); if(wait == 0) { - e->setNoWait(true); - e->addCommand(command); + _e->setNoWait(true); + _e->addCommand(command); } else { - SleepCommand* scom = new SleepCommand(getCuid(), e, _requestGroup, + SleepCommand* scom = new SleepCommand(getCuid(), _e, _requestGroup, command, wait); - e->addCommand(scom); + _e->addCommand(scom); } return true; } void AbstractCommand::onAbort() { - if(!req.isNull()) { + if(!_req.isNull()) { // TODO This might be a problem if the failure is caused by proxy. - e->getRequestGroupMan()->getOrCreateServerStat - (req->getHost(), req->getProtocol())->setError(); - _fileEntry->removeIdenticalURI(req->getUri()); - _fileEntry->removeRequest(req); + _e->getRequestGroupMan()->getOrCreateServerStat + (_req->getHost(), _req->getProtocol())->setError(); + _fileEntry->removeIdenticalURI(_req->getUri()); + _fileEntry->removeRequest(_req); } if(getLogger()->debug()) { getLogger()->debug("CUID#%s - Aborting download", util::itos(getCuid()).c_str()); } - if(!_requestGroup->getPieceStorage().isNull()) { - SharedHandle<SegmentMan> segmentMan = _requestGroup->getSegmentMan(); - segmentMan->cancelSegment(getCuid()); + if(!getPieceStorage().isNull()) { + getSegmentMan()->cancelSegment(getCuid()); // Don't do following process if BitTorrent is involved or files // in DownloadContext is more than 1. The latter condition is // limitation of current implementation. if(!getOption()->getAsBool(PREF_ALWAYS_RESUME) && !_fileEntry.isNull() && - segmentMan->calculateSessionDownloadLength() == 0 && + getSegmentMan()->calculateSessionDownloadLength() == 0 && !_requestGroup->p2pInvolved() && _requestGroup->getDownloadContext()->getFileEntries().size() == 1) { const int maxTries = getOption()->getAsInt(PREF_MAX_RESUME_FAILURE_TRIES); @@ -383,9 +382,9 @@ void AbstractCommand::onAbort() { std::deque<URIResult> res; _fileEntry->extractURIResult(res, downloadresultcode::CANNOT_RESUME); if(!res.empty()) { - segmentMan->cancelAllSegments(); - segmentMan->eraseSegmentWrittenLengthMemo(); - _requestGroup->getPieceStorage()->markPiecesDone(0); + getSegmentMan()->cancelAllSegments(); + getSegmentMan()->eraseSegmentWrittenLengthMemo(); + getPieceStorage()->markPiecesDone(0); std::vector<std::string> uris; uris.reserve(res.size()); std::transform(res.begin(), res.end(), std::back_inserter(uris), @@ -396,7 +395,7 @@ void AbstractCommand::onAbort() { static_cast<unsigned long int>(uris.size())); } _fileEntry->addUris(uris.begin(), uris.end()); - segmentMan->recognizeSegmentFor(_fileEntry); + getSegmentMan()->recognizeSegmentFor(_fileEntry); } } } @@ -404,10 +403,10 @@ void AbstractCommand::onAbort() { } void AbstractCommand::disableReadCheckSocket() { - if(checkSocketIsReadable) { - e->deleteSocketForReadCheck(readCheckTarget, this); - checkSocketIsReadable = false; - readCheckTarget = SocketHandle(); + if(_checkSocketIsReadable) { + _e->deleteSocketForReadCheck(_readCheckTarget, this); + _checkSocketIsReadable = false; + _readCheckTarget.reset(); } } @@ -415,16 +414,16 @@ void AbstractCommand::setReadCheckSocket(const SocketHandle& socket) { if(!socket->isOpen()) { disableReadCheckSocket(); } else { - if(checkSocketIsReadable) { - if(readCheckTarget != socket) { - e->deleteSocketForReadCheck(readCheckTarget, this); - e->addSocketForReadCheck(socket, this); - readCheckTarget = socket; + if(_checkSocketIsReadable) { + if(_readCheckTarget != socket) { + _e->deleteSocketForReadCheck(_readCheckTarget, this); + _e->addSocketForReadCheck(socket, this); + _readCheckTarget = socket; } } else { - e->addSocketForReadCheck(socket, this); - checkSocketIsReadable = true; - readCheckTarget = socket; + _e->addSocketForReadCheck(socket, this); + _checkSocketIsReadable = true; + _readCheckTarget = socket; } } } @@ -440,10 +439,10 @@ void AbstractCommand::setReadCheckSocketIf } void AbstractCommand::disableWriteCheckSocket() { - if(checkSocketIsWritable) { - e->deleteSocketForWriteCheck(writeCheckTarget, this); - checkSocketIsWritable = false; - writeCheckTarget = SocketHandle(); + if(_checkSocketIsWritable) { + _e->deleteSocketForWriteCheck(_writeCheckTarget, this); + _checkSocketIsWritable = false; + _writeCheckTarget.reset(); } } @@ -451,16 +450,16 @@ void AbstractCommand::setWriteCheckSocket(const SocketHandle& socket) { if(!socket->isOpen()) { disableWriteCheckSocket(); } else { - if(checkSocketIsWritable) { - if(writeCheckTarget != socket) { - e->deleteSocketForWriteCheck(writeCheckTarget, this); - e->addSocketForWriteCheck(socket, this); - writeCheckTarget = socket; + if(_checkSocketIsWritable) { + if(_writeCheckTarget != socket) { + _e->deleteSocketForWriteCheck(_writeCheckTarget, this); + _e->addSocketForWriteCheck(socket, this); + _writeCheckTarget = socket; } } else { - e->addSocketForWriteCheck(socket, this); - checkSocketIsWritable = true; - writeCheckTarget = socket; + _e->addSocketForWriteCheck(socket, this); + _checkSocketIsWritable = true; + _writeCheckTarget = socket; } } } @@ -570,17 +569,17 @@ static bool inNoProxy(const SharedHandle<Request>& req, bool AbstractCommand::isProxyDefined() const { - return isProxyRequest(req->getProtocol(), getOption()) && - !inNoProxy(req, getOption()->get(PREF_NO_PROXY)); + return isProxyRequest(_req->getProtocol(), getOption()) && + !inNoProxy(_req, getOption()->get(PREF_NO_PROXY)); } SharedHandle<Request> AbstractCommand::createProxyRequest() const { SharedHandle<Request> proxyRequest; - if(inNoProxy(req, getOption()->get(PREF_NO_PROXY))) { + if(inNoProxy(_req, getOption()->get(PREF_NO_PROXY))) { return proxyRequest; } - std::string proxy = getProxyUri(req->getProtocol(), getOption()); + std::string proxy = getProxyUri(_req->getProtocol(), getOption()); if(!proxy.empty()) { proxyRequest.reset(new Request()); if(proxyRequest->setUri(proxy)) { @@ -625,9 +624,9 @@ bool AbstractCommand::asyncResolveHostname() return true; case AsyncNameResolver::STATUS_ERROR: disableNameResolverCheck(_asyncNameResolver); - if(!isProxyRequest(req->getProtocol(), getOption())) { - e->getRequestGroupMan()->getOrCreateServerStat - (req->getHost(), req->getProtocol())->setError(); + if(!isProxyRequest(_req->getProtocol(), getOption())) { + _e->getRequestGroupMan()->getOrCreateServerStat + (_req->getHost(), _req->getProtocol())->setError(); } throw DL_ABORT_EX (StringFormat(MSG_NAME_RESOLUTION_FAILED, @@ -647,16 +646,16 @@ const std::vector<std::string>& AbstractCommand::getResolvedAddresses() void AbstractCommand::setNameResolverCheck (const SharedHandle<AsyncNameResolver>& resolver) { if(!resolver.isNull()) { - nameResolverCheck = true; - e->addNameResolverCheck(resolver, this); + _nameResolverCheck = true; + _e->addNameResolverCheck(resolver, this); } } void AbstractCommand::disableNameResolverCheck (const SharedHandle<AsyncNameResolver>& resolver) { if(!resolver.isNull()) { - nameResolverCheck = false; - e->deleteNameResolverCheck(resolver, this); + _nameResolverCheck = false; + _e->deleteNameResolverCheck(resolver, this); } } @@ -670,7 +669,7 @@ bool AbstractCommand::nameResolveFinished() const { std::string AbstractCommand::resolveHostname (std::vector<std::string>& addrs, const std::string& hostname, uint16_t port) { - e->findAllCachedIPAddresses(std::back_inserter(addrs), hostname, port); + _e->findAllCachedIPAddresses(std::back_inserter(addrs), hostname, port); std::string ipaddr; if(addrs.empty()) { #ifdef ENABLE_ASYNC_DNS @@ -688,7 +687,7 @@ std::string AbstractCommand::resolveHostname { NameResolver res; res.setSocktype(SOCK_STREAM); - if(e->getOption()->getAsBool(PREF_DISABLE_IPV6)) { + if(_e->getOption()->getAsBool(PREF_DISABLE_IPV6)) { res.setFamily(AF_INET); } res.resolve(addrs, hostname); @@ -701,9 +700,9 @@ std::string AbstractCommand::resolveHostname } for(std::vector<std::string>::const_iterator i = addrs.begin(), eoi = addrs.end(); i != eoi; ++i) { - e->cacheIPAddress(hostname, *i, port); + _e->cacheIPAddress(hostname, *i, port); } - ipaddr = e->findCachedIPAddress(hostname, port); + ipaddr = _e->findCachedIPAddress(hostname, port); } else { ipaddr = addrs.front(); if(getLogger()->info()) { @@ -725,13 +724,13 @@ void AbstractCommand::prepareForNextAction(Command* nextCommand) std::vector<Command*> commands; try { - _requestGroup->processCheckIntegrityEntry(commands, entry, e); + _requestGroup->processCheckIntegrityEntry(commands, entry, _e); } catch(RecoverableException& e) { std::for_each(commands.begin(), commands.end(), Deleter()); throw; } - e->addCommand(commands); - e->setNoWait(true); + _e->addCommand(commands); + _e->setNoWait(true); } bool AbstractCommand::checkIfConnectionEstablished @@ -744,8 +743,8 @@ bool AbstractCommand::checkIfConnectionEstablished std::string error = socket->getSocketError(); if(!error.empty()) { // See also InitiateConnectionCommand::executeInternal() - e->markBadIPAddress(connectedHostname, connectedAddr, connectedPort); - if(!e->findCachedIPAddress(connectedHostname, connectedPort).empty()) { + _e->markBadIPAddress(connectedHostname, connectedAddr, connectedPort); + if(!_e->findCachedIPAddress(connectedHostname, connectedPort).empty()) { if(getLogger()->info()) { getLogger()->info(MSG_CONNECT_FAILED_AND_RETRY, util::itos(getCuid()).c_str(), @@ -753,17 +752,17 @@ bool AbstractCommand::checkIfConnectionEstablished } Command* command = InitiateConnectionCommandFactory::createInitiateConnectionCommand - (getCuid(), req, _fileEntry, _requestGroup, e); - e->setNoWait(true); - e->addCommand(command); + (getCuid(), _req, _fileEntry, _requestGroup, _e); + _e->setNoWait(true); + _e->addCommand(command); return false; } - e->removeCachedIPAddress(connectedHostname, connectedPort); + _e->removeCachedIPAddress(connectedHostname, connectedPort); // Don't set error if proxy server is used and its method is GET. - if(resolveProxyMethod(req->getProtocol()) != V_GET || - !isProxyRequest(req->getProtocol(), getOption())) { - e->getRequestGroupMan()->getOrCreateServerStat - (req->getHost(), req->getProtocol())->setError(); + if(resolveProxyMethod(_req->getProtocol()) != V_GET || + !isProxyRequest(_req->getProtocol(), getOption())) { + _e->getRequestGroupMan()->getOrCreateServerStat + (_req->getHost(), _req->getProtocol())->setError(); } throw DL_RETRY_EX (StringFormat(MSG_ESTABLISHING_CONNECTION_FAILED, error.c_str()).str()); @@ -788,4 +787,9 @@ const SharedHandle<Option>& AbstractCommand::getOption() const return _requestGroup->getOption(); } +void AbstractCommand::createSocket() +{ + _socket.reset(new SocketCore()); +} + } // namespace aria2 diff --git a/src/AbstractCommand.h b/src/AbstractCommand.h index fc793cee..577eeedc 100644 --- a/src/AbstractCommand.h +++ b/src/AbstractCommand.h @@ -55,19 +55,83 @@ class AsyncNameResolver; class AbstractCommand : public Command { private: - Timer checkPoint; - time_t timeout; -protected: + Timer _checkPoint; + time_t _timeout; + RequestGroup* _requestGroup; - SharedHandle<Request> req; + SharedHandle<Request> _req; SharedHandle<FileEntry> _fileEntry; - DownloadEngine* e; - SharedHandle<SocketCore> socket; + DownloadEngine* _e; + SharedHandle<SocketCore> _socket; std::vector<SharedHandle<Segment> > _segments; #ifdef ENABLE_ASYNC_DNS SharedHandle<AsyncNameResolver> _asyncNameResolver; +#endif // ENABLE_ASYNC_DNS + + bool _checkSocketIsReadable; + bool _checkSocketIsWritable; + SharedHandle<SocketCore> _readCheckTarget; + SharedHandle<SocketCore> _writeCheckTarget; + bool _nameResolverCheck; + +#ifdef ENABLE_ASYNC_DNS + void setNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver); + + void disableNameResolverCheck + (const SharedHandle<AsyncNameResolver>& resolver); + + bool nameResolveFinished() const; +#endif // ENABLE_ASYNC_DNS +protected: + RequestGroup* getRequestGroup() const + { + return _requestGroup; + } + + const SharedHandle<Request>& getRequest() const + { + return _req; + } + + void setRequest(const SharedHandle<Request>& request) + { + _req = request; + } + + const SharedHandle<FileEntry>& getFileEntry() const + { + return _fileEntry; + } + + void setFileEntry(const SharedHandle<FileEntry>& fileEntry) + { + _fileEntry = fileEntry; + } + + DownloadEngine* getDownloadEngine() const + { + return _e; + } + + const SharedHandle<SocketCore>& getSocket() const + { + return _socket; + } + void setSocket(const SharedHandle<SocketCore>& s) + { + _socket = s; + } + + void createSocket(); + + const std::vector<SharedHandle<Segment> >& getSegments() const + { + return _segments; + } + +#ifdef ENABLE_ASYNC_DNS bool isAsyncNameResolverInitialized() const; void initAsyncNameResolver(const std::string& hostname); @@ -106,7 +170,7 @@ protected: */ void setWriteCheckSocketIf(const SharedHandle<SocketCore>& socket, bool pred); - void setTimeout(time_t timeout) { this->timeout = timeout; } + void setTimeout(time_t timeout) { _timeout = timeout; } void prepareForNextAction(Command* nextCommand = 0); @@ -143,20 +207,16 @@ protected: { return _requestGroup->getDownloadContext(); } -private: - bool checkSocketIsReadable; - bool checkSocketIsWritable; - SharedHandle<SocketCore> readCheckTarget; - SharedHandle<SocketCore> writeCheckTarget; - bool nameResolverCheck; -#ifdef ENABLE_ASYNC_DNS - - void setNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver); + const SharedHandle<SegmentMan>& getSegmentMan() const + { + return _requestGroup->getSegmentMan(); + } - void disableNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver); - bool nameResolveFinished() const; -#endif // ENABLE_ASYNC_DNS + const SharedHandle<PieceStorage>& getPieceStorage() const + { + return _requestGroup->getPieceStorage(); + } public: AbstractCommand(cuid_t cuid, const SharedHandle<Request>& req, const SharedHandle<FileEntry>& fileEntry, diff --git a/src/AbstractProxyRequestCommand.cc b/src/AbstractProxyRequestCommand.cc index d15d9dfc..02b1850f 100644 --- a/src/AbstractProxyRequestCommand.cc +++ b/src/AbstractProxyRequestCommand.cc @@ -64,37 +64,37 @@ AbstractProxyRequestCommand::AbstractProxyRequestCommand : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), _proxyRequest(proxyRequest), - httpConnection(new HttpConnection(cuid, s, getOption().get())) + _httpConnection(new HttpConnection(cuid, s, getOption().get())) { setTimeout(getOption()->getAsInt(PREF_CONNECT_TIMEOUT)); disableReadCheckSocket(); - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } AbstractProxyRequestCommand::~AbstractProxyRequestCommand() {} bool AbstractProxyRequestCommand::executeInternal() { //socket->setBlockingMode(); - if(httpConnection->sendBufferIsEmpty()) { + if(_httpConnection->sendBufferIsEmpty()) { if(!checkIfConnectionEstablished - (socket, _connectedHostname, _connectedAddr, _connectedPort)) { + (getSocket(), _connectedHostname, _connectedAddr, _connectedPort)) { return true; } SharedHandle<HttpRequest> httpRequest(new HttpRequest()); httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT)); - httpRequest->setRequest(req); + httpRequest->setRequest(getRequest()); httpRequest->setProxyRequest(_proxyRequest); - httpConnection->sendProxyRequest(httpRequest); + _httpConnection->sendProxyRequest(httpRequest); } else { - httpConnection->sendPendingData(); + _httpConnection->sendPendingData(); } - if(httpConnection->sendBufferIsEmpty()) { - e->addCommand(getNextCommand()); + if(_httpConnection->sendBufferIsEmpty()) { + getDownloadEngine()->addCommand(getNextCommand()); return true; } else { - setWriteCheckSocket(socket); - e->addCommand(this); + setWriteCheckSocket(getSocket()); + getDownloadEngine()->addCommand(this); return false; } } diff --git a/src/AbstractProxyRequestCommand.h b/src/AbstractProxyRequestCommand.h index 4ffad746..0dfabbd3 100644 --- a/src/AbstractProxyRequestCommand.h +++ b/src/AbstractProxyRequestCommand.h @@ -43,16 +43,21 @@ class HttpConnection; class SocketCore; class AbstractProxyRequestCommand : public AbstractCommand { -protected: +private: SharedHandle<Request> _proxyRequest; - SharedHandle<HttpConnection> httpConnection; + SharedHandle<HttpConnection> _httpConnection; std::string _connectedHostname; std::string _connectedAddr; uint16_t _connectedPort; - +protected: virtual bool executeInternal(); + + const SharedHandle<HttpConnection>& getHttpConnection() const + { + return _httpConnection; + } public: AbstractProxyRequestCommand(cuid_t cuid, const SharedHandle<Request>& req, diff --git a/src/AbstractProxyResponseCommand.cc b/src/AbstractProxyResponseCommand.cc index e0e5b16a..3806507c 100644 --- a/src/AbstractProxyResponseCommand.cc +++ b/src/AbstractProxyResponseCommand.cc @@ -62,21 +62,21 @@ AbstractProxyResponseCommand::AbstractProxyResponseCommand DownloadEngine* e, const SocketHandle& s) :AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - httpConnection(httpConnection) {} + _httpConnection(httpConnection) {} AbstractProxyResponseCommand::~AbstractProxyResponseCommand() {} bool AbstractProxyResponseCommand::executeInternal() { - SharedHandle<HttpResponse> httpResponse = httpConnection->receiveResponse(); + SharedHandle<HttpResponse> httpResponse = _httpConnection->receiveResponse(); if(httpResponse.isNull()) { // the server has not responded our request yet. - e->addCommand(this); + getDownloadEngine()->addCommand(this); return false; } if(httpResponse->getResponseStatus() != HttpHeader::S200) { throw DL_RETRY_EX(EX_PROXY_CONNECTION_FAILED); } - e->addCommand(getNextCommand()); + getDownloadEngine()->addCommand(getNextCommand()); return true; } diff --git a/src/AbstractProxyResponseCommand.h b/src/AbstractProxyResponseCommand.h index e0b06a8f..8e391574 100644 --- a/src/AbstractProxyResponseCommand.h +++ b/src/AbstractProxyResponseCommand.h @@ -43,10 +43,15 @@ class HttpConnection; class SocketCore; class AbstractProxyResponseCommand : public AbstractCommand { +private: + SharedHandle<HttpConnection> _httpConnection; protected: - SharedHandle<HttpConnection> httpConnection; - virtual bool executeInternal(); + + const SharedHandle<HttpConnection>& getHttpConnection() const + { + return _httpConnection; + } public: AbstractProxyResponseCommand (cuid_t cuid, diff --git a/src/CreateRequestCommand.cc b/src/CreateRequestCommand.cc index 40a6c6f6..e519c017 100644 --- a/src/CreateRequestCommand.cc +++ b/src/CreateRequestCommand.cc @@ -67,39 +67,41 @@ CreateRequestCommand::CreateRequestCommand(cuid_t cuid, bool CreateRequestCommand::executeInternal() { - if(_segments.empty()) { - _fileEntry = _requestGroup->getDownloadContext()->findFileEntryByOffset(0); + if(getSegments().empty()) { + setFileEntry(getDownloadContext()->findFileEntryByOffset(0)); } else { // We assume all segments belongs to same file. - _fileEntry = _requestGroup->getDownloadContext()->findFileEntryByOffset - (_segments.front()->getPositionToWrite()); + setFileEntry(getDownloadContext()->findFileEntryByOffset + (getSegments().front()->getPositionToWrite())); } - if(_fileEntry->getRemainingUris().empty() && + if(getFileEntry()->getRemainingUris().empty() && getOption()->getAsBool(PREF_REUSE_URI) && - _fileEntry->countPooledRequest() == 0) { - _fileEntry->reuseUri(_requestGroup->getNumConcurrentCommand()); + getFileEntry()->countPooledRequest() == 0) { + getFileEntry()->reuseUri(getRequestGroup()->getNumConcurrentCommand()); } - req = _fileEntry->getRequest(_requestGroup->getURISelector(), - getOption()->get(PREF_REFERER), - // Don't use HEAD request when file - // size is known. - // Use HEAD for dry-run mode. - (_fileEntry->getLength() == 0 && - getOption()->getAsBool(PREF_USE_HEAD)) || - getOption()->getAsBool(PREF_DRY_RUN)? - Request::METHOD_HEAD:Request::METHOD_GET); - if(req.isNull()) { - if(!_requestGroup->getSegmentMan().isNull()) { - _requestGroup->getSegmentMan()->ignoreSegmentFor(_fileEntry); + setRequest + (getFileEntry()->getRequest(getRequestGroup()->getURISelector(), + getOption()->get(PREF_REFERER), + // Don't use HEAD request when file + // size is known. + // Use HEAD for dry-run mode. + (getFileEntry()->getLength() == 0 && + getOption()->getAsBool(PREF_USE_HEAD)) || + getOption()->getAsBool(PREF_DRY_RUN)? + Request::METHOD_HEAD:Request::METHOD_GET)); + if(getRequest().isNull()) { + if(!getSegmentMan().isNull()) { + getSegmentMan()->ignoreSegmentFor(getFileEntry()); } throw DL_ABORT_EX("No URI available."); } Command* command = InitiateConnectionCommandFactory::createInitiateConnectionCommand - (getCuid(), req, _fileEntry, _requestGroup, e); - e->setNoWait(true); - e->addCommand(command); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), + getDownloadEngine()); + getDownloadEngine()->setNoWait(true); + getDownloadEngine()->addCommand(command); return true; } @@ -113,16 +115,16 @@ bool CreateRequestCommand::prepareForRetry(time_t wait) // called repeatedly. This means that newly created // CreateRequestCommand is deleted one second later: This is not // efficient. For this reason, reuse current CreateRequestCommand. - if(!_requestGroup->getPieceStorage().isNull()) { - _requestGroup->getSegmentMan()->cancelSegment(getCuid()); + if(!getPieceStorage().isNull()) { + getSegmentMan()->cancelSegment(getCuid()); } if(getLogger()->debug()) { getLogger()->debug("CUID#%s - Reusing CreateRequestCommand", util::itos(getCuid()).c_str()); } SleepCommand* scom = new SleepCommand - (getCuid(), e, _requestGroup, this, wait); - e->addCommand(scom); + (getCuid(), getDownloadEngine(), getRequestGroup(), this, wait); + getDownloadEngine()->addCommand(scom); return false; } diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc index 96b12d97..a9cfd24a 100644 --- a/src/DownloadCommand.cc +++ b/src/DownloadCommand.cc @@ -76,7 +76,9 @@ DownloadCommand::DownloadCommand(cuid_t cuid, DownloadEngine* e, const SocketHandle& s): AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - _buf(new unsigned char[BUFSIZE]) + _buf(new unsigned char[BUFSIZE]), + _startupIdleTime(10), + _lowestDownloadSpeedLimit(0) #ifdef ENABLE_MESSAGE_DIGEST , _pieceHashValidationEnabled(false) #endif // ENABLE_MESSAGE_DIGEST @@ -84,8 +86,7 @@ DownloadCommand::DownloadCommand(cuid_t cuid, #ifdef ENABLE_MESSAGE_DIGEST { if(getOption()->getAsBool(PREF_REALTIME_CHUNK_CHECKSUM)) { - std::string algo = - _requestGroup->getDownloadContext()->getPieceHashAlgo(); + const std::string& algo = getDownloadContext()->getPieceHashAlgo(); if(MessageDigestContext::supports(algo)) { _messageDigestContext.reset(new MessageDigestContext()); _messageDigestContext->trySetAlgo(algo); @@ -97,46 +98,47 @@ DownloadCommand::DownloadCommand(cuid_t cuid, } #endif // ENABLE_MESSAGE_DIGEST - peerStat = req->initPeerStat(); - peerStat->downloadStart(); - _requestGroup->getSegmentMan()->registerPeerStat(peerStat); + _peerStat = req->initPeerStat(); + _peerStat->downloadStart(); + getSegmentMan()->registerPeerStat(_peerStat); } DownloadCommand::~DownloadCommand() { - peerStat->downloadStop(); - _requestGroup->getSegmentMan()->updateFastestPeerStat(peerStat); + _peerStat->downloadStop(); + getSegmentMan()->updateFastestPeerStat(_peerStat); delete [] _buf; } bool DownloadCommand::executeInternal() { - if(e->getRequestGroupMan()->doesOverallDownloadSpeedExceed() || - _requestGroup->doesDownloadSpeedExceed()) { - e->addCommand(this); + if(getDownloadEngine()->getRequestGroupMan()->doesOverallDownloadSpeedExceed() + || getRequestGroup()->doesDownloadSpeedExceed()) { + getDownloadEngine()->addCommand(this); disableReadCheckSocket(); return false; } - setReadCheckSocket(socket); - SharedHandle<Segment> segment = _segments.front(); + setReadCheckSocket(getSocket()); + SharedHandle<Segment> segment = getSegments().front(); size_t bufSize; if(segment->getLength() > 0) { if(static_cast<uint64_t>(segment->getPosition()+segment->getLength()) <= - static_cast<uint64_t>(_fileEntry->getLastOffset())) { + static_cast<uint64_t>(getFileEntry()->getLastOffset())) { bufSize = std::min(segment->getLength()-segment->getWrittenLength(), BUFSIZE); } else { bufSize = - std::min(static_cast<size_t> - (_fileEntry->getLastOffset()-segment->getPositionToWrite()), - BUFSIZE); + std::min + (static_cast<size_t> + (getFileEntry()->getLastOffset()-segment->getPositionToWrite()), + BUFSIZE); } } else { bufSize = BUFSIZE; } - socket->readData(_buf, bufSize); + getSocket()->readData(_buf, bufSize); const SharedHandle<DiskAdaptor>& diskAdaptor = - _requestGroup->getPieceStorage()->getDiskAdaptor(); + getPieceStorage()->getDiskAdaptor(); const unsigned char* bufFinal; size_t bufSizeFinal; @@ -173,24 +175,21 @@ bool DownloadCommand::executeInternal() { if(bufSizeFinal > 0) { segment->updateWrittenLength(bufSizeFinal); } - - peerStat->updateDownloadLength(bufSize); - - _requestGroup->getSegmentMan()->updateDownloadSpeedFor(peerStat); - + _peerStat->updateDownloadLength(bufSize); + getSegmentMan()->updateDownloadSpeedFor(_peerStat); bool segmentPartComplete = false; // Note that GrowSegment::complete() always returns false. if(_transferEncodingDecoder.isNull() && _contentEncodingDecoder.isNull()) { if(segment->complete() || - segment->getPositionToWrite() == _fileEntry->getLastOffset()) { + segment->getPositionToWrite() == getFileEntry()->getLastOffset()) { segmentPartComplete = true; } else if(segment->getLength() == 0 && bufSize == 0 && - !socket->wantRead() && !socket->wantWrite()) { + !getSocket()->wantRead() && !getSocket()->wantWrite()) { segmentPartComplete = true; } } else if(!_transferEncodingDecoder.isNull() && (segment->complete() || - segment->getPositionToWrite() == _fileEntry->getLastOffset())) { + segment->getPositionToWrite() == getFileEntry()->getLastOffset())){ // In this case, transferEncodingDecoder is used and // Content-Length is known. segmentPartComplete = true; @@ -202,7 +201,7 @@ bool DownloadCommand::executeInternal() { } if(!segmentPartComplete && bufSize == 0 && - !socket->wantRead() && !socket->wantWrite()) { + !getSocket()->wantRead() && !getSocket()->wantWrite()) { throw DL_RETRY_EX(EX_GOT_EOF); } @@ -219,8 +218,7 @@ bool DownloadCommand::executeInternal() { { const std::string& expectedPieceHash = - _requestGroup->getDownloadContext()->getPieceHash - (segment->getIndex()); + getDownloadContext()->getPieceHash(segment->getIndex()); if(_pieceHashValidationEnabled && !expectedPieceHash.empty()) { if(segment->isHashCalculated()) { if(getLogger()->debug()) { @@ -236,31 +234,31 @@ bool DownloadCommand::executeInternal() { (segment, expectedPieceHash, MessageDigestHelper::digest (_messageDigestContext.get(), - _requestGroup->getPieceStorage()->getDiskAdaptor(), + getPieceStorage()->getDiskAdaptor(), segment->getPosition(), segment->getLength())); } } else { - _requestGroup->getSegmentMan()->completeSegment(getCuid(), segment); + getSegmentMan()->completeSegment(getCuid(), segment); } } #else // !ENABLE_MESSAGE_DIGEST - _requestGroup->getSegmentMan()->completeSegment(getCuid(), segment); + getSegmentMan()->completeSegment(getCuid(), segment); #endif // !ENABLE_MESSAGE_DIGEST } else { // If segment is not canceled here, in the next pipelining // request, aria2 requests bad range // [FileEntry->getLastOffset(), FileEntry->getLastOffset()) - _requestGroup->getSegmentMan()->cancelSegment(getCuid(), segment); + getSegmentMan()->cancelSegment(getCuid(), segment); } checkLowestDownloadSpeed(); // this unit is going to download another segment. return prepareForNextSegment(); } else { checkLowestDownloadSpeed(); - setWriteCheckSocketIf(socket, socket->wantWrite()); - e->addCommand(this); + setWriteCheckSocketIf(getSocket(), getSocket()->wantWrite()); + getDownloadEngine()->addCommand(this); return false; } } @@ -268,67 +266,62 @@ bool DownloadCommand::executeInternal() { void DownloadCommand::checkLowestDownloadSpeed() const { // calculate downloading speed - if(peerStat->getDownloadStartTime().difference(global::wallclock) >= - startupIdleTime) { - unsigned int nowSpeed = peerStat->calculateDownloadSpeed(); - if(lowestDownloadSpeedLimit > 0 && nowSpeed <= lowestDownloadSpeedLimit) { + if(_peerStat->getDownloadStartTime().difference(global::wallclock) >= + _startupIdleTime) { + unsigned int nowSpeed = _peerStat->calculateDownloadSpeed(); + if(_lowestDownloadSpeedLimit > 0 && nowSpeed <= _lowestDownloadSpeedLimit) { throw DL_ABORT_EX2(StringFormat(EX_TOO_SLOW_DOWNLOAD_SPEED, nowSpeed, - lowestDownloadSpeedLimit, - req->getHost().c_str()).str(), + _lowestDownloadSpeedLimit, + getRequest()->getHost().c_str()).str(), downloadresultcode::TOO_SLOW_DOWNLOAD_SPEED); } } } bool DownloadCommand::prepareForNextSegment() { - if(_requestGroup->downloadFinished()) { - const SharedHandle<DownloadContext>& dctx = - _requestGroup->getDownloadContext(); + if(getRequestGroup()->downloadFinished()) { // Remove in-flight request here. - _fileEntry->poolRequest(req); + getFileEntry()->poolRequest(getRequest()); // If this is a single file download, and file size becomes known // just after downloading, set total length to FileEntry object // here. - if(dctx->getFileEntries().size() == 1) { - const SharedHandle<FileEntry>& fileEntry = dctx->getFirstFileEntry(); - if(fileEntry->getLength() == 0) { - fileEntry->setLength - (_requestGroup->getPieceStorage()->getCompletedLength()); + if(getDownloadContext()->getFileEntries().size() == 1) { + if(getFileEntry()->getLength() == 0) { + getFileEntry()->setLength(getPieceStorage()->getCompletedLength()); } } #ifdef ENABLE_MESSAGE_DIGEST - if(dctx->getPieceHashAlgo().empty()) { + if(getDownloadContext()->getPieceHashAlgo().empty()) { SharedHandle<CheckIntegrityEntry> entry - (new ChecksumCheckIntegrityEntry(_requestGroup)); + (new ChecksumCheckIntegrityEntry(getRequestGroup())); if(entry->isValidationReady()) { entry->initValidator(); // TODO do we need cuttrailinggarbage here? - e->getCheckIntegrityMan()->pushEntry(entry); + getDownloadEngine()->getCheckIntegrityMan()->pushEntry(entry); } } // Following 2lines are needed for DownloadEngine to detect // completed RequestGroups without 1sec delay. - e->setNoWait(true); - e->setRefreshInterval(0); + getDownloadEngine()->setNoWait(true); + getDownloadEngine()->setRefreshInterval(0); #endif // ENABLE_MESSAGE_DIGEST return true; } else { // The number of segments should be 1 in order to pass through the next // segment. - if(_segments.size() == 1) { - SharedHandle<Segment> tempSegment = _segments.front(); + if(getSegments().size() == 1) { + SharedHandle<Segment> tempSegment = getSegments().front(); if(!tempSegment->complete()) { return prepareForRetry(0); } - SharedHandle<SegmentMan> segmentMan = _requestGroup->getSegmentMan(); SharedHandle<Segment> nextSegment = - segmentMan->getCleanSegmentIfOwnerIsIdle + getSegmentMan()->getCleanSegmentIfOwnerIsIdle (getCuid(), tempSegment->getIndex()+1); if(nextSegment.isNull()) { return prepareForRetry(0); } else { - e->addCommand(this); + getDownloadEngine()->addCommand(this); return false; } } else { @@ -345,7 +338,7 @@ void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment, { if(actualPieceHash == expectedPieceHash) { getLogger()->info(MSG_GOOD_CHUNK_CHECKSUM, actualPieceHash.c_str()); - _requestGroup->getSegmentMan()->completeSegment(getCuid(), segment); + getSegmentMan()->completeSegment(getCuid(), segment); } else { getLogger()->info(EX_INVALID_CHUNK_CHECKSUM, segment->getIndex(), @@ -353,7 +346,7 @@ void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment, expectedPieceHash.c_str(), actualPieceHash.c_str()); segment->clear(); - _requestGroup->getSegmentMan()->cancelSegment(getCuid()); + getSegmentMan()->cancelSegment(getCuid()); throw DL_RETRY_EX (StringFormat("Invalid checksum index=%d", segment->getIndex()).str()); } diff --git a/src/DownloadCommand.h b/src/DownloadCommand.h index af63c093..1abe4b58 100644 --- a/src/DownloadCommand.h +++ b/src/DownloadCommand.h @@ -49,9 +49,9 @@ class DownloadCommand : public AbstractCommand { private: unsigned char* _buf; - time_t startupIdleTime; - unsigned int lowestDownloadSpeedLimit; - SharedHandle<PeerStat> peerStat; + time_t _startupIdleTime; + unsigned int _lowestDownloadSpeedLimit; + SharedHandle<PeerStat> _peerStat; #ifdef ENABLE_MESSAGE_DIGEST @@ -66,15 +66,14 @@ private: const std::string& actualPieceHash); void checkLowestDownloadSpeed() const; -protected: + SharedHandle<Decoder> _transferEncodingDecoder; SharedHandle<Decoder> _contentEncodingDecoder; - +protected: virtual bool executeInternal(); virtual bool prepareForNextSegment(); - public: DownloadCommand(cuid_t cuid, const SharedHandle<Request>& req, @@ -84,16 +83,28 @@ public: const SharedHandle<SocketCore>& s); virtual ~DownloadCommand(); + const SharedHandle<Decoder>& getTransferEncodingDecoder() const + { + return _transferEncodingDecoder; + } + void setTransferEncodingDecoder(const SharedHandle<Decoder>& decoder); + const SharedHandle<Decoder>& getContentEncodingDecoder() const + { + return _contentEncodingDecoder; + } + void setContentEncodingDecoder(const SharedHandle<Decoder>& decoder); - void setStartupIdleTime(time_t startupIdleTime) { - this->startupIdleTime = startupIdleTime; + void setStartupIdleTime(time_t startupIdleTime) + { + _startupIdleTime = startupIdleTime; } - void setLowestDownloadSpeedLimit(unsigned int lowestDownloadSpeedLimit) { - this->lowestDownloadSpeedLimit = lowestDownloadSpeedLimit; + void setLowestDownloadSpeedLimit(unsigned int lowestDownloadSpeedLimit) + { + _lowestDownloadSpeedLimit = lowestDownloadSpeedLimit; } }; diff --git a/src/FtpDownloadCommand.cc b/src/FtpDownloadCommand.cc index cb735f3a..02023277 100644 --- a/src/FtpDownloadCommand.cc +++ b/src/FtpDownloadCommand.cc @@ -62,7 +62,7 @@ FtpDownloadCommand::FtpDownloadCommand const SocketHandle& ctrlSocket) :DownloadCommand(cuid, req, fileEntry, requestGroup, e, dataSocket), _ftpConnection(ftpConnection), - ctrlSocket(ctrlSocket) {} + _ctrlSocket(ctrlSocket) {} FtpDownloadCommand::~FtpDownloadCommand() {} @@ -71,14 +71,14 @@ bool FtpDownloadCommand::prepareForNextSegment() { if(getOption()->getAsBool(PREF_FTP_REUSE_CONNECTION) && static_cast<uint64_t> - (_fileEntry->gtoloff(_segments.front()->getPositionToWrite())) == - _fileEntry->getLength()) { + (getFileEntry()->gtoloff(getSegments().front()->getPositionToWrite())) == + getFileEntry()->getLength()) { Command* command = new FtpFinishDownloadCommand - (getCuid(), req, _fileEntry, _requestGroup, _ftpConnection, e, - ctrlSocket); - e->addCommand(command); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), + _ftpConnection, getDownloadEngine(), _ctrlSocket); + getDownloadEngine()->addCommand(command); - if(_requestGroup->downloadFinished()) { + if(getRequestGroup()->downloadFinished()) { // To run checksum checking, we had to call following function here. DownloadCommand::prepareForNextSegment(); } diff --git a/src/FtpDownloadCommand.h b/src/FtpDownloadCommand.h index 194b0345..bd5b4d0a 100644 --- a/src/FtpDownloadCommand.h +++ b/src/FtpDownloadCommand.h @@ -45,7 +45,7 @@ class FtpDownloadCommand : public DownloadCommand { private: SharedHandle<FtpConnection> _ftpConnection; - SharedHandle<SocketCore> ctrlSocket; + SharedHandle<SocketCore> _ctrlSocket; protected: virtual bool prepareForNextSegment(); public: diff --git a/src/FtpFinishDownloadCommand.cc b/src/FtpFinishDownloadCommand.cc index e143743a..f3090eec 100644 --- a/src/FtpFinishDownloadCommand.cc +++ b/src/FtpFinishDownloadCommand.cc @@ -71,13 +71,13 @@ FtpFinishDownloadCommand::FtpFinishDownloadCommand // AbstractCommand::_segments is empty. bool FtpFinishDownloadCommand::execute() { - if(_requestGroup->isHaltRequested()) { + if(getRequestGroup()->isHaltRequested()) { return true; } try { unsigned int status = _ftpConnection->receiveResponse(); if(status == 0) { - e->addCommand(this); + getDownloadEngine()->addCommand(this); return false; } if(status != 226) { @@ -86,13 +86,14 @@ bool FtpFinishDownloadCommand::execute() if(getOption()->getAsBool(PREF_FTP_REUSE_CONNECTION)) { std::map<std::string, std::string> options; options["baseWorkingDir"] = _ftpConnection->getBaseWorkingDir(); - e->poolSocket(req, _ftpConnection->getUser(), createProxyRequest(), - socket, options); + getDownloadEngine()->poolSocket + (getRequest(), _ftpConnection->getUser(), createProxyRequest(), + getSocket(), options); } } catch(RecoverableException& e) { getLogger()->info(EX_EXCEPTION_CAUGHT, e); } - if(_requestGroup->downloadFinished()) { + if(getRequestGroup()->downloadFinished()) { return true; } else { return prepareForRetry(0); diff --git a/src/FtpInitiateConnectionCommand.cc b/src/FtpInitiateConnectionCommand.cc index 3fd52954..bbd6503d 100644 --- a/src/FtpInitiateConnectionCommand.cc +++ b/src/FtpInitiateConnectionCommand.cc @@ -80,16 +80,16 @@ Command* FtpInitiateConnectionCommand::createNextCommand if(!proxyRequest.isNull()) { std::map<std::string, std::string> options; SharedHandle<SocketCore> pooledSocket; - std::string proxyMethod = resolveProxyMethod(req->getProtocol()); + std::string proxyMethod = resolveProxyMethod(getRequest()->getProtocol()); if(proxyMethod == V_GET) { - pooledSocket = e->popPooledSocket - (req->getHost(), req->getPort(), + pooledSocket = getDownloadEngine()->popPooledSocket + (getRequest()->getHost(), getRequest()->getPort(), proxyRequest->getHost(), proxyRequest->getPort()); } else { - pooledSocket = e->popPooledSocket - (options, req->getHost(), req->getPort(), - e->getAuthConfigFactory()->createAuthConfig - (req, getOption().get())->getUser(), + pooledSocket = getDownloadEngine()->popPooledSocket + (options, getRequest()->getHost(), getRequest()->getPort(), + getDownloadEngine()->getAuthConfigFactory()->createAuthConfig + (getRequest(), getOption().get())->getUser(), proxyRequest->getHost(), proxyRequest->getPort()); } if(pooledSocket.isNull()) { @@ -97,26 +97,27 @@ Command* FtpInitiateConnectionCommand::createNextCommand getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), addr.c_str(), port); } - socket.reset(new SocketCore()); - socket->establishConnection(addr, port); + createSocket(); + getSocket()->establishConnection(addr, port); if(proxyMethod == V_GET) { // Use GET for FTP via HTTP proxy. - req->setMethod(Request::METHOD_GET); + getRequest()->setMethod(Request::METHOD_GET); SharedHandle<HttpConnection> hc - (new HttpConnection(getCuid(), socket, getOption().get())); + (new HttpConnection(getCuid(), getSocket(), getOption().get())); HttpRequestCommand* c = - new HttpRequestCommand(getCuid(), req, _fileEntry, - _requestGroup, hc, e, socket); + new HttpRequestCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), hc, getDownloadEngine(), + getSocket()); c->setConnectedAddr(hostname, addr, port); c->setProxyRequest(proxyRequest); command = c; } else if(proxyMethod == V_TUNNEL) { FtpTunnelRequestCommand* c = - new FtpTunnelRequestCommand(getCuid(), req, _fileEntry, - _requestGroup, e, - proxyRequest, socket); + new FtpTunnelRequestCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), getDownloadEngine(), + proxyRequest, getSocket()); c->setConnectedAddr(hostname, addr, port); command = c; } else { @@ -126,19 +127,21 @@ Command* FtpInitiateConnectionCommand::createNextCommand } else { if(proxyMethod == V_TUNNEL) { command = - new FtpNegotiationCommand(getCuid(), req, _fileEntry, - _requestGroup, e, pooledSocket, + new FtpNegotiationCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), getDownloadEngine(), + pooledSocket, FtpNegotiationCommand::SEQ_SEND_CWD, options["baseWorkingDir"]); } else if(proxyMethod == V_GET) { // Use GET for FTP via HTTP proxy. - req->setMethod(Request::METHOD_GET); + getRequest()->setMethod(Request::METHOD_GET); SharedHandle<HttpConnection> hc (new HttpConnection(getCuid(), pooledSocket, getOption().get())); HttpRequestCommand* c = - new HttpRequestCommand(getCuid(), req, _fileEntry, - _requestGroup, hc, e, pooledSocket); + new HttpRequestCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), hc, getDownloadEngine(), + pooledSocket); c->setProxyRequest(proxyRequest); command = c; } else { @@ -149,25 +152,29 @@ Command* FtpInitiateConnectionCommand::createNextCommand } else { std::map<std::string, std::string> options; SharedHandle<SocketCore> pooledSocket = - e->popPooledSocket(options, resolvedAddresses, req->getPort(), - e->getAuthConfigFactory()->createAuthConfig - (req, getOption().get())->getUser()); + getDownloadEngine()->popPooledSocket + (options, resolvedAddresses, + getRequest()->getPort(), + getDownloadEngine()->getAuthConfigFactory()->createAuthConfig + (getRequest(), getOption().get())->getUser()); if(pooledSocket.isNull()) { if(getLogger()->info()) { getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), addr.c_str(), port); } - socket.reset(new SocketCore()); - socket->establishConnection(addr, port); + createSocket(); + getSocket()->establishConnection(addr, port); FtpNegotiationCommand* c = - new FtpNegotiationCommand(getCuid(), req, _fileEntry, - _requestGroup, e, socket); + new FtpNegotiationCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), getDownloadEngine(), + getSocket()); c->setConnectedAddr(hostname, addr, port); command = c; } else { command = - new FtpNegotiationCommand(getCuid(), req, _fileEntry, - _requestGroup, e, pooledSocket, + new FtpNegotiationCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), getDownloadEngine(), + pooledSocket, FtpNegotiationCommand::SEQ_SEND_CWD, options["baseWorkingDir"]); } diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc index 303de573..aecd0e1e 100644 --- a/src/FtpNegotiationCommand.cc +++ b/src/FtpNegotiationCommand.cc @@ -83,104 +83,105 @@ FtpNegotiationCommand::FtpNegotiationCommand const SharedHandle<FileEntry>& fileEntry, RequestGroup* requestGroup, DownloadEngine* e, - const SocketHandle& s, + const SocketHandle& socket, Seq seq, const std::string& baseWorkingDir): - AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), sequence(seq), - ftp(new FtpConnection(cuid, socket, req, + AbstractCommand(cuid, req, fileEntry, requestGroup, e, socket), _sequence(seq), + _ftp(new FtpConnection(cuid, socket, req, e->getAuthConfigFactory()->createAuthConfig (req, requestGroup->getOption().get()), getOption().get())) { - ftp->setBaseWorkingDir(baseWorkingDir); + _ftp->setBaseWorkingDir(baseWorkingDir); if(seq == SEQ_RECV_GREETING) { setTimeout(getOption()->getAsInt(PREF_CONNECT_TIMEOUT)); } disableReadCheckSocket(); - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } FtpNegotiationCommand::~FtpNegotiationCommand() {} bool FtpNegotiationCommand::executeInternal() { - while(processSequence(_segments.front())); - if(sequence == SEQ_RETRY) { + while(processSequence(getSegments().front())); + if(_sequence == SEQ_RETRY) { return prepareForRetry(0); - } else if(sequence == SEQ_NEGOTIATION_COMPLETED) { + } else if(_sequence == SEQ_NEGOTIATION_COMPLETED) { FtpDownloadCommand* command = new FtpDownloadCommand - (getCuid(), req, _fileEntry, _requestGroup, ftp, e, dataSocket, socket); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), _ftp, + getDownloadEngine(), _dataSocket, getSocket()); command->setStartupIdleTime(getOption()->getAsInt(PREF_STARTUP_IDLE_TIME)); command->setLowestDownloadSpeedLimit (getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT)); - if(!_fileEntry->isSingleHostMultiConnectionEnabled()) { - _fileEntry->removeURIWhoseHostnameIs(req->getHost()); + if(!getFileEntry()->isSingleHostMultiConnectionEnabled()) { + getFileEntry()->removeURIWhoseHostnameIs(getRequest()->getHost()); } - _requestGroup->getURISelector()->tuneDownloadCommand - (_fileEntry->getRemainingUris(), command); - e->addCommand(command); + getRequestGroup()->getURISelector()->tuneDownloadCommand + (getFileEntry()->getRemainingUris(), command); + getDownloadEngine()->addCommand(command); return true; - } else if(sequence == SEQ_HEAD_OK || - sequence == SEQ_DOWNLOAD_ALREADY_COMPLETED) { + } else if(_sequence == SEQ_HEAD_OK || + _sequence == SEQ_DOWNLOAD_ALREADY_COMPLETED) { return true; - } else if(sequence == SEQ_FILE_PREPARATION) { + } else if(_sequence == SEQ_FILE_PREPARATION) { if(getOption()->getAsBool(PREF_FTP_PASV)) { - sequence = SEQ_SEND_PASV; + _sequence = SEQ_SEND_PASV; } else { - sequence = SEQ_PREPARE_SERVER_SOCKET; + _sequence = SEQ_PREPARE_SERVER_SOCKET; } return false; - } else if(sequence == SEQ_EXIT) { + } else if(_sequence == SEQ_EXIT) { return true; } else { - e->addCommand(this); + getDownloadEngine()->addCommand(this); return false; } } bool FtpNegotiationCommand::recvGreeting() { if(!checkIfConnectionEstablished - (socket, _connectedHostname, _connectedAddr, _connectedPort)) { - sequence = SEQ_EXIT; + (getSocket(), _connectedHostname, _connectedAddr, _connectedPort)) { + _sequence = SEQ_EXIT; return false; } - setTimeout(_requestGroup->getTimeout()); + setTimeout(getRequestGroup()->getTimeout()); //socket->setBlockingMode(); disableWriteCheckSocket(); - setReadCheckSocket(socket); + setReadCheckSocket(getSocket()); - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } if(status != 220) { throw DL_ABORT_EX(EX_CONNECTION_FAILED); } - sequence = SEQ_SEND_USER; + _sequence = SEQ_SEND_USER; return true; } bool FtpNegotiationCommand::sendUser() { - if(ftp->sendUser()) { + if(_ftp->sendUser()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_USER; + _sequence = SEQ_RECV_USER; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvUser() { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); switch(status) { case 0: return false; case 230: - sequence = SEQ_SEND_TYPE; + _sequence = SEQ_SEND_TYPE; break; case 331: - sequence = SEQ_SEND_PASS; + _sequence = SEQ_SEND_PASS; break; default: throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); @@ -189,56 +190,56 @@ bool FtpNegotiationCommand::recvUser() { } bool FtpNegotiationCommand::sendPass() { - if(ftp->sendPass()) { + if(_ftp->sendPass()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_PASS; + _sequence = SEQ_RECV_PASS; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvPass() { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } if(status != 230) { throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); } - sequence = SEQ_SEND_TYPE; + _sequence = SEQ_SEND_TYPE; return true; } bool FtpNegotiationCommand::sendType() { - if(ftp->sendType()) { + if(_ftp->sendType()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_TYPE; + _sequence = SEQ_RECV_TYPE; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvType() { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } if(status != 200) { throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); } - sequence = SEQ_SEND_PWD; + _sequence = SEQ_SEND_PWD; return true; } bool FtpNegotiationCommand::sendPwd() { - if(ftp->sendPwd()) { + if(_ftp->sendPwd()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_PWD; + _sequence = SEQ_RECV_PWD; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } @@ -246,42 +247,42 @@ bool FtpNegotiationCommand::sendPwd() bool FtpNegotiationCommand::recvPwd() { std::string pwd; - unsigned int status = ftp->receivePwdResponse(pwd); + unsigned int status = _ftp->receivePwdResponse(pwd); if(status == 0) { return false; } if(status != 257) { throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); } - ftp->setBaseWorkingDir(pwd); + _ftp->setBaseWorkingDir(pwd); if(getLogger()->info()) { getLogger()->info("CUID#%s - base working directory is '%s'", util::itos(getCuid()).c_str(), pwd.c_str()); } - sequence = SEQ_SEND_CWD; + _sequence = SEQ_SEND_CWD; return true; } bool FtpNegotiationCommand::sendCwd() { // Calling setReadCheckSocket() is needed when the socket is reused, - setReadCheckSocket(socket); - if(ftp->sendCwd()) { + setReadCheckSocket(getSocket()); + if(_ftp->sendCwd()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_CWD; + _sequence = SEQ_RECV_CWD; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvCwd() { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } if(status != 250) { poolConnection(); - _requestGroup->increaseAndValidateFileNotFoundCount(); + getRequestGroup()->increaseAndValidateFileNotFoundCount(); if (status == 550) throw DL_ABORT_EX2(MSG_RESOURCE_NOT_FOUND, downloadresultcode::RESOURCE_NOT_FOUND); @@ -289,20 +290,20 @@ bool FtpNegotiationCommand::recvCwd() { throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); } if(getOption()->getAsBool(PREF_REMOTE_TIME)) { - sequence = SEQ_SEND_MDTM; + _sequence = SEQ_SEND_MDTM; } else { - sequence = SEQ_SEND_SIZE; + _sequence = SEQ_SEND_SIZE; } return true; } bool FtpNegotiationCommand::sendMdtm() { - if(ftp->sendMdtm()) { + if(_ftp->sendMdtm()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_MDTM; + _sequence = SEQ_RECV_MDTM; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } @@ -310,13 +311,13 @@ bool FtpNegotiationCommand::sendMdtm() bool FtpNegotiationCommand::recvMdtm() { Time lastModifiedTime = Time::null(); - unsigned int status = ftp->receiveMdtmResponse(lastModifiedTime); + unsigned int status = _ftp->receiveMdtmResponse(lastModifiedTime); if(status == 0) { return false; } if(status == 213) { if(lastModifiedTime.good()) { - _requestGroup->updateLastModifiedTime(lastModifiedTime); + getRequestGroup()->updateLastModifiedTime(lastModifiedTime); time_t t = lastModifiedTime.getTime(); struct tm* tms = gmtime(&t); // returned struct is statically allocated. if(tms) { @@ -340,84 +341,87 @@ bool FtpNegotiationCommand::recvMdtm() util::itos(getCuid()).c_str()); } } - sequence = SEQ_SEND_SIZE; + _sequence = SEQ_SEND_SIZE; return true; } bool FtpNegotiationCommand::sendSize() { - if(ftp->sendSize()) { + if(_ftp->sendSize()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_SIZE; + _sequence = SEQ_RECV_SIZE; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) { - _fileEntry->setLength(totalLength); - if(_fileEntry->getPath().empty()) { - _fileEntry->setPath + getFileEntry()->setLength(totalLength); + if(getFileEntry()->getPath().empty()) { + getFileEntry()->setPath (util::applyDir (getDownloadContext()->getDir(), - util::fixTaintedBasename(util::percentDecode(req->getFile())))); + util::fixTaintedBasename + (util::percentDecode(getRequest()->getFile())))); } - _requestGroup->preDownloadProcessing(); - if(e->getRequestGroupMan()->isSameFileBeingDownloaded(_requestGroup)) { + getRequestGroup()->preDownloadProcessing(); + if(getDownloadEngine()->getRequestGroupMan()-> + isSameFileBeingDownloaded(getRequestGroup())) { throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat(EX_DUPLICATE_FILE_DOWNLOAD, - _requestGroup->getFirstFilePath().c_str()).str()); + getRequestGroup()->getFirstFilePath().c_str()).str()); } if(totalLength == 0) { if(getOption()->getAsBool(PREF_FTP_PASV)) { - sequence = SEQ_SEND_PASV; + _sequence = SEQ_SEND_PASV; } else { - sequence = SEQ_PREPARE_SERVER_SOCKET; + _sequence = SEQ_PREPARE_SERVER_SOCKET; } if(getOption()->getAsBool(PREF_DRY_RUN)) { - _requestGroup->initPieceStorage(); + getRequestGroup()->initPieceStorage(); onDryRunFileFound(); return false; } - if(_requestGroup->downloadFinishedByFileLength()) { - _requestGroup->initPieceStorage(); - _requestGroup->getPieceStorage()->markAllPiecesDone(); - sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; + if(getRequestGroup()->downloadFinishedByFileLength()) { + getRequestGroup()->initPieceStorage(); + getPieceStorage()->markAllPiecesDone(); + _sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; getLogger()->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, - util::itos(_requestGroup->getGID()).c_str(), - _requestGroup->getFirstFilePath().c_str()); + util::itos(getRequestGroup()->getGID()).c_str(), + getRequestGroup()->getFirstFilePath().c_str()); poolConnection(); return false; } - _requestGroup->shouldCancelDownloadForSafety(); - _requestGroup->initPieceStorage(); - _requestGroup->getPieceStorage()->getDiskAdaptor()->initAndOpenFile(); + getRequestGroup()->shouldCancelDownloadForSafety(); + getRequestGroup()->initPieceStorage(); + getPieceStorage()->getDiskAdaptor()->initAndOpenFile(); if(getDownloadContext()->knowsTotalLength()) { - sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; + _sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; poolConnection(); return false; } // We have to make sure that command that has Request object must // have segment after PieceStorage is initialized. See // AbstractCommand::execute() - _requestGroup->getSegmentMan()->getSegment(getCuid(), 0); + getSegmentMan()->getSegment(getCuid(), 0); return true; } else { - _requestGroup->adjustFilename - (SharedHandle<BtProgressInfoFile>(new DefaultBtProgressInfoFile - (_requestGroup->getDownloadContext(), - SharedHandle<PieceStorage>(), - getOption().get()))); - _requestGroup->initPieceStorage(); + getRequestGroup()->adjustFilename + (SharedHandle<BtProgressInfoFile> + (new DefaultBtProgressInfoFile + (getDownloadContext(), + SharedHandle<PieceStorage>(), + getOption().get()))); + getRequestGroup()->initPieceStorage(); if(getOption()->getAsBool(PREF_DRY_RUN)) { onDryRunFileFound(); @@ -425,27 +429,28 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) } BtProgressInfoFileHandle infoFile - (new DefaultBtProgressInfoFile(_requestGroup->getDownloadContext(), - _requestGroup->getPieceStorage(), + (new DefaultBtProgressInfoFile(getDownloadContext(), + getPieceStorage(), getOption().get())); - if(!infoFile->exists() && _requestGroup->downloadFinishedByFileLength()) { - _requestGroup->getPieceStorage()->markAllPiecesDone(); + if(!infoFile->exists() && + getRequestGroup()->downloadFinishedByFileLength()) { + getPieceStorage()->markAllPiecesDone(); - sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; + _sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; getLogger()->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, - util::itos(_requestGroup->getGID()).c_str(), - _requestGroup->getFirstFilePath().c_str()); + util::itos(getRequestGroup()->getGID()).c_str(), + getRequestGroup()->getFirstFilePath().c_str()); poolConnection(); return false; } - _requestGroup->loadAndOpenFile(infoFile); + getRequestGroup()->loadAndOpenFile(infoFile); // We have to make sure that command that has Request object must // have segment after PieceStorage is initialized. See // AbstractCommand::execute() - _requestGroup->getSegmentMan()->getSegment(getCuid(), 0); + getSegmentMan()->getSegment(getCuid(), 0); prepareForNextAction(this); @@ -456,7 +461,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) bool FtpNegotiationCommand::recvSize() { uint64_t size = 0; - unsigned int status = ftp->receiveSizeResponse(size); + unsigned int status = _ftp->receiveSizeResponse(size); if(status == 0) { return false; } @@ -467,13 +472,13 @@ bool FtpNegotiationCommand::recvSize() { (StringFormat(EX_TOO_LARGE_FILE, util::uitos(size, true).c_str()).str()); } - if(_requestGroup->getPieceStorage().isNull()) { + if(getPieceStorage().isNull()) { - sequence = SEQ_FILE_PREPARATION; + _sequence = SEQ_FILE_PREPARATION; return onFileSizeDetermined(size); } else { - _requestGroup->validateTotalLength(_fileEntry->getLength(), size); + getRequestGroup()->validateTotalLength(getFileEntry()->getLength(), size); } } else { @@ -484,7 +489,7 @@ bool FtpNegotiationCommand::recvSize() { // Even if one of the other servers waiting in the queue supports SIZE // command, resuming and segmented downloading are disabled when the first // contacted FTP server doesn't support it. - if(_requestGroup->getPieceStorage().isNull()) { + if(getPieceStorage().isNull()) { getDownloadContext()->markTotalLengthIsUnknown(); return onFileSizeDetermined(0); @@ -493,62 +498,62 @@ bool FtpNegotiationCommand::recvSize() { // wrong file to be downloaded if user-specified URL is wrong. } if(getOption()->getAsBool(PREF_FTP_PASV)) { - sequence = SEQ_SEND_PASV; + _sequence = SEQ_SEND_PASV; } else { - sequence = SEQ_PREPARE_SERVER_SOCKET; + _sequence = SEQ_PREPARE_SERVER_SOCKET; } return true; } void FtpNegotiationCommand::afterFileAllocation() { - setReadCheckSocket(socket); + setReadCheckSocket(getSocket()); } bool FtpNegotiationCommand::prepareServerSocket() { - serverSocket = ftp->createServerSocket(); - sequence = SEQ_SEND_PORT; + _serverSocket = _ftp->createServerSocket(); + _sequence = SEQ_SEND_PORT; return true; } bool FtpNegotiationCommand::sendPort() { afterFileAllocation(); - if(ftp->sendPort(serverSocket)) { + if(_ftp->sendPort(_serverSocket)) { disableWriteCheckSocket(); - sequence = SEQ_RECV_PORT; + _sequence = SEQ_RECV_PORT; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvPort() { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } if(status != 200) { throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); } - sequence = SEQ_SEND_REST; + _sequence = SEQ_SEND_REST; return true; } bool FtpNegotiationCommand::sendPasv() { afterFileAllocation(); - if(ftp->sendPasv()) { + if(_ftp->sendPasv()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_PASV; + _sequence = SEQ_RECV_PASV; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvPasv() { std::pair<std::string, uint16_t> dest; - unsigned int status = ftp->receivePasvResponse(dest); + unsigned int status = _ftp->receivePasvResponse(dest); if(status == 0) { return false; } @@ -558,7 +563,7 @@ bool FtpNegotiationCommand::recvPasv() { // TODO Should we check to see that dest.first is not in noProxy list? if(isProxyDefined()) { _dataConnAddr = dest; - sequence = SEQ_RESOLVE_PROXY; + _sequence = SEQ_RESOLVE_PROXY; return true; } else { // make a data connection to the server. @@ -567,11 +572,11 @@ bool FtpNegotiationCommand::recvPasv() { dest.first.c_str(), dest.second); } - dataSocket.reset(new SocketCore()); - dataSocket->establishConnection(dest.first, dest.second); + _dataSocket.reset(new SocketCore()); + _dataSocket->establishConnection(dest.first, dest.second); disableReadCheckSocket(); - setWriteCheckSocket(dataSocket); - sequence = SEQ_SEND_REST_PASV; + setWriteCheckSocket(_dataSocket); + _sequence = SEQ_SEND_REST_PASV; return false; } } @@ -589,27 +594,29 @@ bool FtpNegotiationCommand::resolveProxy() getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), _proxyAddr.c_str(), proxyReq->getPort()); } - dataSocket.reset(new SocketCore()); - dataSocket->establishConnection(_proxyAddr, proxyReq->getPort()); + _dataSocket.reset(new SocketCore()); + _dataSocket->establishConnection(_proxyAddr, proxyReq->getPort()); disableReadCheckSocket(); - setWriteCheckSocket(dataSocket); - _http.reset(new HttpConnection(getCuid(), dataSocket, getOption().get())); - sequence = SEQ_SEND_TUNNEL_REQUEST; + setWriteCheckSocket(_dataSocket); + _http.reset(new HttpConnection(getCuid(), _dataSocket, getOption().get())); + _sequence = SEQ_SEND_TUNNEL_REQUEST; return false; } bool FtpNegotiationCommand::sendTunnelRequest() { if(_http->sendBufferIsEmpty()) { - if(dataSocket->isReadable(0)) { - std::string error = socket->getSocketError(); + if(_dataSocket->isReadable(0)) { + std::string error = getSocket()->getSocketError(); if(!error.empty()) { SharedHandle<Request> proxyReq = createProxyRequest(); - e->markBadIPAddress(proxyReq->getHost(),_proxyAddr,proxyReq->getPort()); - std::string nextProxyAddr = e->findCachedIPAddress + getDownloadEngine()->markBadIPAddress(proxyReq->getHost(), + _proxyAddr,proxyReq->getPort()); + std::string nextProxyAddr = getDownloadEngine()->findCachedIPAddress (proxyReq->getHost(), proxyReq->getPort()); if(nextProxyAddr.empty()) { - e->removeCachedIPAddress(proxyReq->getHost(), proxyReq->getPort()); + getDownloadEngine()->removeCachedIPAddress(proxyReq->getHost(), + proxyReq->getPort()); throw DL_RETRY_EX (StringFormat(MSG_ESTABLISHING_CONNECTION_FAILED, error.c_str()).str()); @@ -625,7 +632,7 @@ bool FtpNegotiationCommand::sendTunnelRequest() util::itos(getCuid()).c_str(), _proxyAddr.c_str(), proxyReq->getPort()); } - dataSocket->establishConnection(_proxyAddr, proxyReq->getPort()); + _dataSocket->establishConnection(_proxyAddr, proxyReq->getPort()); return false; } } @@ -644,11 +651,11 @@ bool FtpNegotiationCommand::sendTunnelRequest() } if(_http->sendBufferIsEmpty()) { disableWriteCheckSocket(); - setReadCheckSocket(dataSocket); - sequence = SEQ_RECV_TUNNEL_RESPONSE; + setReadCheckSocket(_dataSocket); + _sequence = SEQ_RECV_TUNNEL_RESPONSE; return false; } else { - setWriteCheckSocket(dataSocket); + setWriteCheckSocket(_dataSocket); return false; } } @@ -662,29 +669,29 @@ bool FtpNegotiationCommand::recvTunnelResponse() if(httpResponse->getResponseStatus() != HttpHeader::S200) { throw DL_RETRY_EX(EX_PROXY_CONNECTION_FAILED); } - sequence = SEQ_SEND_REST_PASV; + _sequence = SEQ_SEND_REST_PASV; return true; } bool FtpNegotiationCommand::sendRestPasv(const SharedHandle<Segment>& segment) { - //dataSocket->setBlockingMode(); - setReadCheckSocket(socket); + //_dataSocket->setBlockingMode(); + setReadCheckSocket(getSocket()); disableWriteCheckSocket(); return sendRest(segment); } bool FtpNegotiationCommand::sendRest(const SharedHandle<Segment>& segment) { - if(ftp->sendRest(segment)) { + if(_ftp->sendRest(segment)) { disableWriteCheckSocket(); - sequence = SEQ_RECV_REST; + _sequence = SEQ_RECV_REST; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvRest(const SharedHandle<Segment>& segment) { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } @@ -696,27 +703,27 @@ bool FtpNegotiationCommand::recvRest(const SharedHandle<Segment>& segment) { downloadresultcode::CANNOT_RESUME); } } - sequence = SEQ_SEND_RETR; + _sequence = SEQ_SEND_RETR; return true; } bool FtpNegotiationCommand::sendRetr() { - if(ftp->sendRetr()) { + if(_ftp->sendRetr()) { disableWriteCheckSocket(); - sequence = SEQ_RECV_RETR; + _sequence = SEQ_RECV_RETR; } else { - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } return false; } bool FtpNegotiationCommand::recvRetr() { - unsigned int status = ftp->receiveResponse(); + unsigned int status = _ftp->receiveResponse(); if(status == 0) { return false; } if(status != 150 && status != 125) { - _requestGroup->increaseAndValidateFileNotFoundCount(); + getRequestGroup()->increaseAndValidateFileNotFoundCount(); if (status == 550) throw DL_ABORT_EX2(MSG_RESOURCE_NOT_FOUND, downloadresultcode::RESOURCE_NOT_FOUND); @@ -724,12 +731,12 @@ bool FtpNegotiationCommand::recvRetr() { throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str()); } if(getOption()->getAsBool(PREF_FTP_PASV)) { - sequence = SEQ_NEGOTIATION_COMPLETED; + _sequence = SEQ_NEGOTIATION_COMPLETED; return false; } else { disableReadCheckSocket(); - setReadCheckSocket(serverSocket); - sequence = SEQ_WAIT_CONNECTION; + setReadCheckSocket(_serverSocket); + _sequence = SEQ_WAIT_CONNECTION; return false; } } @@ -737,17 +744,17 @@ bool FtpNegotiationCommand::recvRetr() { bool FtpNegotiationCommand::waitConnection() { disableReadCheckSocket(); - setReadCheckSocket(socket); - dataSocket.reset(serverSocket->acceptConnection()); - dataSocket->setNonBlockingMode(); - sequence = SEQ_NEGOTIATION_COMPLETED; + setReadCheckSocket(getSocket()); + _dataSocket.reset(_serverSocket->acceptConnection()); + _dataSocket->setNonBlockingMode(); + _sequence = SEQ_NEGOTIATION_COMPLETED; return false; } bool FtpNegotiationCommand::processSequence (const SharedHandle<Segment>& segment) { bool doNextSequence = true; - switch(sequence) { + switch(_sequence) { case SEQ_RECV_GREETING: return recvGreeting(); case SEQ_SEND_USER: @@ -816,16 +823,17 @@ void FtpNegotiationCommand::poolConnection() const { if(getOption()->getAsBool(PREF_FTP_REUSE_CONNECTION)) { std::map<std::string, std::string> options; - options["baseWorkingDir"] = ftp->getBaseWorkingDir(); - e->poolSocket(req, ftp->getUser(), createProxyRequest(), socket, options); + options["baseWorkingDir"] = _ftp->getBaseWorkingDir(); + getDownloadEngine()->poolSocket(getRequest(), _ftp->getUser(), + createProxyRequest(), getSocket(), options); } } void FtpNegotiationCommand::onDryRunFileFound() { - _requestGroup->getPieceStorage()->markAllPiecesDone(); + getPieceStorage()->markAllPiecesDone(); poolConnection(); - sequence = SEQ_HEAD_OK; + _sequence = SEQ_HEAD_OK; } } // namespace aria2 diff --git a/src/FtpNegotiationCommand.h b/src/FtpNegotiationCommand.h index 7eb94795..3a9520ca 100644 --- a/src/FtpNegotiationCommand.h +++ b/src/FtpNegotiationCommand.h @@ -122,10 +122,10 @@ private: void onDryRunFileFound(); - SharedHandle<SocketCore> dataSocket; - SharedHandle<SocketCore> serverSocket; - Seq sequence; - SharedHandle<FtpConnection> ftp; + SharedHandle<SocketCore> _dataSocket; + SharedHandle<SocketCore> _serverSocket; + Seq _sequence; + SharedHandle<FtpConnection> _ftp; // For tunneling SharedHandle<HttpConnection> _http; // IP, Port pair in pasv response diff --git a/src/FtpTunnelRequestCommand.cc b/src/FtpTunnelRequestCommand.cc index 2fcfbcd3..c6ff69fe 100644 --- a/src/FtpTunnelRequestCommand.cc +++ b/src/FtpTunnelRequestCommand.cc @@ -58,7 +58,8 @@ FtpTunnelRequestCommand::~FtpTunnelRequestCommand() {} Command* FtpTunnelRequestCommand::getNextCommand() { return new FtpTunnelResponseCommand - (getCuid(), req, _fileEntry, _requestGroup, httpConnection, e, socket); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), + getHttpConnection(), getDownloadEngine(), getSocket()); } } // namespace aria2 diff --git a/src/FtpTunnelResponseCommand.cc b/src/FtpTunnelResponseCommand.cc index d1d1afb1..86084fe2 100644 --- a/src/FtpTunnelResponseCommand.cc +++ b/src/FtpTunnelResponseCommand.cc @@ -59,8 +59,9 @@ FtpTunnelResponseCommand::~FtpTunnelResponseCommand() {} Command* FtpTunnelResponseCommand::getNextCommand() { - return new FtpNegotiationCommand(getCuid(), req, _fileEntry, - _requestGroup, e, socket); + return new FtpNegotiationCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), getDownloadEngine(), + getSocket()); } } // namespace aria2 diff --git a/src/HttpDownloadCommand.cc b/src/HttpDownloadCommand.cc index 3121da3f..7ff66769 100644 --- a/src/HttpDownloadCommand.cc +++ b/src/HttpDownloadCommand.cc @@ -71,29 +71,29 @@ HttpDownloadCommand::HttpDownloadCommand HttpDownloadCommand::~HttpDownloadCommand() {} bool HttpDownloadCommand::prepareForNextSegment() { - bool downloadFinished = _requestGroup->downloadFinished(); - if(req->isPipeliningEnabled() && !downloadFinished) { + bool downloadFinished = getRequestGroup()->downloadFinished(); + if(getRequest()->isPipeliningEnabled() && !downloadFinished) { HttpRequestCommand* command = - new HttpRequestCommand(getCuid(), req, _fileEntry, - _requestGroup, _httpConnection, e, - socket); + new HttpRequestCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), _httpConnection, + getDownloadEngine(), getSocket()); // Set proxy request here. aria2 sends the HTTP request specialized for // proxy. - if(resolveProxyMethod(req->getProtocol()) == V_GET) { + if(resolveProxyMethod(getRequest()->getProtocol()) == V_GET) { command->setProxyRequest(createProxyRequest()); } - e->addCommand(command); + getDownloadEngine()->addCommand(command); return true; } else { - if(req->isPipeliningEnabled() || - (req->isKeepAliveEnabled() && + if(getRequest()->isPipeliningEnabled() || + (getRequest()->isKeepAliveEnabled() && ( - ((!_transferEncodingDecoder.isNull() && - _transferEncodingDecoder->finished()) || - (!_contentEncodingDecoder.isNull() && - _contentEncodingDecoder->finished())) || - _fileEntry->getLastOffset() == - _segments.front()->getPositionToWrite() + ((!getTransferEncodingDecoder().isNull() && + getTransferEncodingDecoder()->finished()) || + (!getContentEncodingDecoder().isNull() && + getContentEncodingDecoder()->finished())) || + getFileEntry()->getLastOffset() == + getSegments().front()->getPositionToWrite() ) ) ) { @@ -102,20 +102,23 @@ bool HttpDownloadCommand::prepareForNextSegment() { // pool terminated socket. In HTTP/1.1, keep-alive is default, // so closing connection without Connection: close header means // that server is broken or not configured properly. - e->poolSocket(req, createProxyRequest(), socket); + getDownloadEngine()->poolSocket + (getRequest(), createProxyRequest(), getSocket()); } // The request was sent assuming that server supported pipelining, but // it turned out that server didn't support it. // We detect this situation by comparing the end byte in range header // of the response with the end byte of segment. // If it is the same, HTTP negotiation is necessary for the next request. - if(!req->isPipeliningEnabled() && req->isPipeliningHint() && + if(!getRequest()->isPipeliningEnabled() && + getRequest()->isPipeliningHint() && !downloadFinished) { - const SharedHandle<Segment>& segment = _segments.front(); + const SharedHandle<Segment>& segment = getSegments().front(); - off_t lastOffset =_fileEntry->gtoloff - (std::min(static_cast<off_t>(segment->getPosition()+segment->getLength()), - _fileEntry->getLastOffset())); + off_t lastOffset =getFileEntry()->gtoloff + (std::min(static_cast<off_t> + (segment->getPosition()+segment->getLength()), + getFileEntry()->getLastOffset())); if(lastOffset == _httpResponse->getHttpHeader()->getRange()->getEndByte()+1) { diff --git a/src/HttpInitiateConnectionCommand.cc b/src/HttpInitiateConnectionCommand.cc index c940a071..822e6c24 100644 --- a/src/HttpInitiateConnectionCommand.cc +++ b/src/HttpInitiateConnectionCommand.cc @@ -73,32 +73,39 @@ Command* HttpInitiateConnectionCommand::createNextCommand Command* command; if(!proxyRequest.isNull()) { SharedHandle<SocketCore> pooledSocket = - e->popPooledSocket(req->getHost(), req->getPort(), - proxyRequest->getHost(), proxyRequest->getPort()); - std::string proxyMethod = resolveProxyMethod(req->getProtocol()); + getDownloadEngine()->popPooledSocket + (getRequest()->getHost(), getRequest()->getPort(), + proxyRequest->getHost(), proxyRequest->getPort()); + std::string proxyMethod = resolveProxyMethod(getRequest()->getProtocol()); if(pooledSocket.isNull()) { if(getLogger()->info()) { getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), addr.c_str(), port); } - socket.reset(new SocketCore()); - socket->establishConnection(addr, port); + createSocket(); + getSocket()->establishConnection(addr, port); if(proxyMethod == V_TUNNEL) { HttpProxyRequestCommand* c = - new HttpProxyRequestCommand(getCuid(), req, _fileEntry, - _requestGroup, e, - proxyRequest, socket); + new HttpProxyRequestCommand(getCuid(), + getRequest(), + getFileEntry(), + getRequestGroup(), + getDownloadEngine(), + proxyRequest, + getSocket()); c->setConnectedAddr(hostname, addr, port); command = c; } else if(proxyMethod == V_GET) { SharedHandle<HttpConnection> httpConnection - (new HttpConnection(getCuid(), socket, getOption().get())); - HttpRequestCommand* c = new HttpRequestCommand(getCuid(), req, - _fileEntry, - _requestGroup, - httpConnection, e, - socket); + (new HttpConnection(getCuid(), getSocket(), getOption().get())); + HttpRequestCommand* c = new HttpRequestCommand(getCuid(), + getRequest(), + getFileEntry(), + getRequestGroup(), + httpConnection, + getDownloadEngine(), + getSocket()); c->setConnectedAddr(hostname, addr, port); c->setProxyRequest(proxyRequest); command = c; @@ -109,10 +116,12 @@ Command* HttpInitiateConnectionCommand::createNextCommand } else { SharedHandle<HttpConnection> httpConnection (new HttpConnection(getCuid(), pooledSocket, getOption().get())); - HttpRequestCommand* c = new HttpRequestCommand(getCuid(), req, - _fileEntry, - _requestGroup, - httpConnection, e, + HttpRequestCommand* c = new HttpRequestCommand(getCuid(), + getRequest(), + getFileEntry(), + getRequestGroup(), + httpConnection, + getDownloadEngine(), pooledSocket); if(proxyMethod == V_GET) { c->setProxyRequest(proxyRequest); @@ -121,22 +130,26 @@ Command* HttpInitiateConnectionCommand::createNextCommand } } else { SharedHandle<SocketCore> pooledSocket = - e->popPooledSocket(resolvedAddresses, req->getPort()); + getDownloadEngine()->popPooledSocket + (resolvedAddresses, getRequest()->getPort()); if(pooledSocket.isNull()) { if(getLogger()->info()) { getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), addr.c_str(), port); } - socket.reset(new SocketCore()); - socket->establishConnection(addr, port); + createSocket(); + getSocket()->establishConnection(addr, port); } else { - socket = pooledSocket; + setSocket(pooledSocket); } SharedHandle<HttpConnection> httpConnection - (new HttpConnection(getCuid(), socket, getOption().get())); + (new HttpConnection(getCuid(), getSocket(), getOption().get())); HttpRequestCommand* c = - new HttpRequestCommand(getCuid(), req, _fileEntry, _requestGroup, - httpConnection, e, socket); + new HttpRequestCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), + httpConnection, + getDownloadEngine(), + getSocket()); if(pooledSocket.isNull()) { c->setConnectedAddr(hostname, addr, port); } diff --git a/src/HttpProxyRequestCommand.cc b/src/HttpProxyRequestCommand.cc index 7de74682..90cd0298 100644 --- a/src/HttpProxyRequestCommand.cc +++ b/src/HttpProxyRequestCommand.cc @@ -58,7 +58,8 @@ HttpProxyRequestCommand::~HttpProxyRequestCommand() {} Command* HttpProxyRequestCommand::getNextCommand() { return new HttpProxyResponseCommand - (getCuid(), req, _fileEntry, _requestGroup, httpConnection, e, socket); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), + getHttpConnection(), getDownloadEngine(), getSocket()); } } // namespace aria2 diff --git a/src/HttpProxyResponseCommand.cc b/src/HttpProxyResponseCommand.cc index b577017f..e0a23c36 100644 --- a/src/HttpProxyResponseCommand.cc +++ b/src/HttpProxyResponseCommand.cc @@ -59,8 +59,9 @@ HttpProxyResponseCommand::~HttpProxyResponseCommand() {} Command* HttpProxyResponseCommand::getNextCommand() { - return new HttpRequestCommand(getCuid(), req, _fileEntry, - _requestGroup, httpConnection, e, socket); + return new HttpRequestCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), getHttpConnection(), + getDownloadEngine(), getSocket()); } } // namespace aria2 diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc index 85b2a244..9e598adb 100644 --- a/src/HttpRequestCommand.cc +++ b/src/HttpRequestCommand.cc @@ -73,7 +73,7 @@ HttpRequestCommand::HttpRequestCommand { setTimeout(getOption()->getAsInt(PREF_CONNECT_TIMEOUT)); disableReadCheckSocket(); - setWriteCheckSocket(socket); + setWriteCheckSocket(getSocket()); } HttpRequestCommand::~HttpRequestCommand() {} @@ -115,47 +115,48 @@ createHttpRequest(const SharedHandle<Request>& req, bool HttpRequestCommand::executeInternal() { //socket->setBlockingMode(); - if(req->getProtocol() == Request::PROTO_HTTPS) { - socket->prepareSecureConnection(); - if(!socket->initiateSecureConnection(req->getHost())) { - setReadCheckSocketIf(socket, socket->wantRead()); - setWriteCheckSocketIf(socket, socket->wantWrite()); - e->addCommand(this); + if(getRequest()->getProtocol() == Request::PROTO_HTTPS) { + getSocket()->prepareSecureConnection(); + if(!getSocket()->initiateSecureConnection(getRequest()->getHost())) { + setReadCheckSocketIf(getSocket(), getSocket()->wantRead()); + setWriteCheckSocketIf(getSocket(), getSocket()->wantWrite()); + getDownloadEngine()->addCommand(this); return false; } } if(_httpConnection->sendBufferIsEmpty()) { if(!checkIfConnectionEstablished - (socket, _connectedHostname, _connectedAddr, _connectedPort)) { + (getSocket(), _connectedHostname, _connectedAddr, _connectedPort)) { return true; } - if(_segments.empty()) { + if(getSegments().empty()) { SharedHandle<HttpRequest> httpRequest - (createHttpRequest(req, - _fileEntry, + (createHttpRequest(getRequest(), + getFileEntry(), SharedHandle<Segment>(), - _requestGroup->getTotalLength(), + getRequestGroup()->getTotalLength(), getOption(), - _requestGroup, - e->getCookieStorage(), - e->getAuthConfigFactory(), + getRequestGroup(), + getDownloadEngine()->getCookieStorage(), + getDownloadEngine()->getAuthConfigFactory(), _proxyRequest)); _httpConnection->sendRequest(httpRequest); } else { for(std::vector<SharedHandle<Segment> >::const_iterator itr = - _segments.begin(), eoi = _segments.end(); itr != eoi; ++itr) { + getSegments().begin(), eoi = getSegments().end(); + itr != eoi; ++itr) { const SharedHandle<Segment>& segment = *itr; if(!_httpConnection->isIssued(segment)) { SharedHandle<HttpRequest> httpRequest - (createHttpRequest(req, - _fileEntry, + (createHttpRequest(getRequest(), + getFileEntry(), segment, - _requestGroup->getTotalLength(), + getRequestGroup()->getTotalLength(), getOption(), - _requestGroup, - e->getCookieStorage(), - e->getAuthConfigFactory(), + getRequestGroup(), + getDownloadEngine()->getCookieStorage(), + getDownloadEngine()->getAuthConfigFactory(), _proxyRequest)); _httpConnection->sendRequest(httpRequest); } @@ -165,15 +166,19 @@ bool HttpRequestCommand::executeInternal() { _httpConnection->sendPendingData(); } if(_httpConnection->sendBufferIsEmpty()) { - Command* command = new HttpResponseCommand(getCuid(), req, _fileEntry, - _requestGroup, - _httpConnection, e, socket); - e->addCommand(command); + Command* command = new HttpResponseCommand(getCuid(), + getRequest(), + getFileEntry(), + getRequestGroup(), + _httpConnection, + getDownloadEngine(), + getSocket()); + getDownloadEngine()->addCommand(command); return true; } else { - setReadCheckSocketIf(socket, socket->wantRead()); - setWriteCheckSocketIf(socket, socket->wantWrite()); - e->addCommand(this); + setReadCheckSocketIf(getSocket(), getSocket()->wantRead()); + setWriteCheckSocketIf(getSocket(), getSocket()->wantWrite()); + getDownloadEngine()->addCommand(this); return false; } } diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc index 02991f7d..30f7045a 100644 --- a/src/HttpResponseCommand.cc +++ b/src/HttpResponseCommand.cc @@ -87,21 +87,21 @@ HttpResponseCommand::HttpResponseCommand DownloadEngine* e, const SocketHandle& s) :AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - httpConnection(httpConnection) + _httpConnection(httpConnection) {} HttpResponseCommand::~HttpResponseCommand() {} bool HttpResponseCommand::executeInternal() { - SharedHandle<HttpRequest> httpRequest = httpConnection->getFirstHttpRequest(); - SharedHandle<HttpResponse> httpResponse = httpConnection->receiveResponse(); + SharedHandle<HttpRequest> httpRequest =_httpConnection->getFirstHttpRequest(); + SharedHandle<HttpResponse> httpResponse = _httpConnection->receiveResponse(); if(httpResponse.isNull()) { // The server has not responded to our request yet. // For socket->wantRead() == true, setReadCheckSocket(socket) is already // done in the constructor. - setWriteCheckSocketIf(socket, socket->wantWrite()); - e->addCommand(this); + setWriteCheckSocketIf(getSocket(), getSocket()->wantWrite()); + getDownloadEngine()->addCommand(this); return false; } // check HTTP status number @@ -112,39 +112,40 @@ bool HttpResponseCommand::executeInternal() // Disable persistent connection if: // Connection: close is received or the remote server is not HTTP/1.1. // We don't care whether non-HTTP/1.1 server returns Connection: keep-alive. - req->supportsPersistentConnection + getRequest()->supportsPersistentConnection (httpResponse->supportsPersistentConnection()); - if(req->isPipeliningEnabled()) { - req->setMaxPipelinedRequest + if(getRequest()->isPipeliningEnabled()) { + getRequest()->setMaxPipelinedRequest (getOption()->getAsInt(PREF_MAX_HTTP_PIPELINING)); } if(httpResponse->getResponseStatus() >= HttpHeader::S300) { if(httpResponse->getResponseStatus() == HttpHeader::S404) { - _requestGroup->increaseAndValidateFileNotFoundCount(); + getRequestGroup()->increaseAndValidateFileNotFoundCount(); } return skipResponseBody(httpResponse); } - if(!_fileEntry->isSingleHostMultiConnectionEnabled()) { + if(!getFileEntry()->isSingleHostMultiConnectionEnabled()) { // TODO redirection should be considered here. We need to parse // original URI to get hostname. - _fileEntry->removeURIWhoseHostnameIs(req->getHost()); + getFileEntry()->removeURIWhoseHostnameIs(getRequest()->getHost()); } - if(_requestGroup->getPieceStorage().isNull()) { + if(getPieceStorage().isNull()) { uint64_t totalLength = httpResponse->getEntityLength(); - _fileEntry->setLength(totalLength); - if(_fileEntry->getPath().empty()) { - _fileEntry->setPath + getFileEntry()->setLength(totalLength); + if(getFileEntry()->getPath().empty()) { + getFileEntry()->setPath (util::applyDir (getDownloadContext()->getDir(), util::fixTaintedBasename(httpResponse->determinFilename()))); } - _fileEntry->setContentType(httpResponse->getContentType()); - _requestGroup->preDownloadProcessing(); - if(e->getRequestGroupMan()->isSameFileBeingDownloaded(_requestGroup)) { + getFileEntry()->setContentType(httpResponse->getContentType()); + getRequestGroup()->preDownloadProcessing(); + if(getDownloadEngine()->getRequestGroupMan()-> + isSameFileBeingDownloaded(getRequestGroup())) { throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat(EX_DUPLICATE_FILE_DOWNLOAD, - _requestGroup->getFirstFilePath().c_str()).str()); + getRequestGroup()->getFirstFilePath().c_str()).str()); } // update last modified time updateLastModifiedTime(httpResponse->getLastModifiedTime()); @@ -153,8 +154,8 @@ bool HttpResponseCommand::executeInternal() // assume we can do segmented downloading if(totalLength == 0 || shouldInflateContentEncoding(httpResponse)) { // we ignore content-length when inflate is required - _fileEntry->setLength(0); - if(req->getMethod() == Request::METHOD_GET && + getFileEntry()->setLength(0); + if(getRequest()->getMethod() == Request::METHOD_GET && (totalLength != 0 || !httpResponse->getHttpHeader()->defined(HttpHeader::CONTENT_LENGTH))){ // DownloadContext::knowsTotalLength() == true only when @@ -167,22 +168,22 @@ bool HttpResponseCommand::executeInternal() } } else { // validate totalsize - _requestGroup->validateTotalLength(_fileEntry->getLength(), + getRequestGroup()->validateTotalLength(getFileEntry()->getLength(), httpResponse->getEntityLength()); // update last modified time updateLastModifiedTime(httpResponse->getLastModifiedTime()); - if(_requestGroup->getTotalLength() == 0) { + if(getRequestGroup()->getTotalLength() == 0) { // Since total length is unknown, the file size in previously // failed download could be larger than the size this time. // Also we can't resume in this case too. So truncate the file // anyway. - _requestGroup->getPieceStorage()->getDiskAdaptor()->truncate(0); - e->addCommand + getPieceStorage()->getDiskAdaptor()->truncate(0); + getDownloadEngine()->addCommand (createHttpDownloadCommand(httpResponse, getTransferEncodingDecoder(httpResponse), getContentEncodingDecoder(httpResponse))); } else { - e->addCommand(createHttpDownloadCommand + getDownloadEngine()->addCommand(createHttpDownloadCommand (httpResponse, getTransferEncodingDecoder(httpResponse))); } return true; @@ -192,7 +193,7 @@ bool HttpResponseCommand::executeInternal() void HttpResponseCommand::updateLastModifiedTime(const Time& lastModified) { if(getOption()->getAsBool(PREF_REMOTE_TIME)) { - _requestGroup->updateLastModifiedTime(lastModified); + getRequestGroup()->updateLastModifiedTime(lastModified); } } @@ -215,12 +216,12 @@ bool HttpResponseCommand::handleDefaultEncoding (const SharedHandle<HttpResponse>& httpResponse) { SharedHandle<HttpRequest> httpRequest = httpResponse->getHttpRequest(); - _requestGroup->adjustFilename + getRequestGroup()->adjustFilename (SharedHandle<BtProgressInfoFile>(new DefaultBtProgressInfoFile - (_requestGroup->getDownloadContext(), + (getDownloadContext(), SharedHandle<PieceStorage>(), getOption().get()))); - _requestGroup->initPieceStorage(); + getRequestGroup()->initPieceStorage(); if(getOption()->getAsBool(PREF_DRY_RUN)) { onDryRunFileFound(); @@ -228,47 +229,44 @@ bool HttpResponseCommand::handleDefaultEncoding } BtProgressInfoFileHandle infoFile - (new DefaultBtProgressInfoFile(_requestGroup->getDownloadContext(), - _requestGroup->getPieceStorage(), + (new DefaultBtProgressInfoFile(getDownloadContext(), + getPieceStorage(), getOption().get())); - if(!infoFile->exists() && _requestGroup->downloadFinishedByFileLength()) { - _requestGroup->getPieceStorage()->markAllPiecesDone(); - + if(!infoFile->exists() && getRequestGroup()->downloadFinishedByFileLength()) { + getPieceStorage()->markAllPiecesDone(); getLogger()->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, - util::itos(_requestGroup->getGID()).c_str(), - _requestGroup->getFirstFilePath().c_str()); - + util::itos(getRequestGroup()->getGID()).c_str(), + getRequestGroup()->getFirstFilePath().c_str()); return true; } - _requestGroup->loadAndOpenFile(infoFile); - File file(_requestGroup->getFirstFilePath()); + getRequestGroup()->loadAndOpenFile(infoFile); + File file(getRequestGroup()->getFirstFilePath()); // We have to make sure that command that has Request object must // have segment after PieceStorage is initialized. See // AbstractCommand::execute() - SharedHandle<Segment> segment = - _requestGroup->getSegmentMan()->getSegment(getCuid(), 0); + SharedHandle<Segment> segment = getSegmentMan()->getSegment(getCuid(), 0); // pipelining requires implicit range specified. But the request for // this response most likely dones't contains range header. This means // we can't continue to use this socket because server sends all entity // body instead of a segment. // Therefore, we shutdown the socket here if pipelining is enabled. DownloadCommand* command = 0; - if(req->getMethod() == Request::METHOD_GET && + if(getRequest()->getMethod() == Request::METHOD_GET && !segment.isNull() && segment->getPositionToWrite() == 0 && - !req->isPipeliningEnabled()) { + !getRequest()->isPipeliningEnabled()) { command = createHttpDownloadCommand (httpResponse, getTransferEncodingDecoder(httpResponse)); } else { - _requestGroup->getSegmentMan()->cancelSegment(getCuid()); - _fileEntry->poolRequest(req); + getSegmentMan()->cancelSegment(getCuid()); + getFileEntry()->poolRequest(getRequest()); } // After command is passed to prepareForNextAction(), it is managed // by CheckIntegrityEntry. prepareForNextAction(command); command = 0; - if(req->getMethod() == Request::METHOD_HEAD) { + if(getRequest()->getMethod() == Request::METHOD_HEAD) { poolConnection(); - req->setMethod(Request::METHOD_GET); + getRequest()->setMethod(Request::METHOD_GET); } return true; } @@ -314,47 +312,43 @@ bool HttpResponseCommand::handleOtherEncoding SharedHandle<HttpRequest> httpRequest = httpResponse->getHttpRequest(); if(getOption()->getAsBool(PREF_DRY_RUN)) { - _requestGroup->initPieceStorage(); + getRequestGroup()->initPieceStorage(); onDryRunFileFound(); return true; } - if(req->getMethod() == Request::METHOD_HEAD) { + if(getRequest()->getMethod() == Request::METHOD_HEAD) { poolConnection(); - req->setMethod(Request::METHOD_GET); + getRequest()->setMethod(Request::METHOD_GET); return prepareForRetry(0); } // For zero-length file, check existing file comparing its size - if(_requestGroup->downloadFinishedByFileLength()) { - _requestGroup->initPieceStorage(); - _requestGroup->getPieceStorage()->markAllPiecesDone(); - + if(getRequestGroup()->downloadFinishedByFileLength()) { + getRequestGroup()->initPieceStorage(); + getPieceStorage()->markAllPiecesDone(); getLogger()->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, - util::itos(_requestGroup->getGID()).c_str(), - _requestGroup->getFirstFilePath().c_str()); - + util::itos(getRequestGroup()->getGID()).c_str(), + getRequestGroup()->getFirstFilePath().c_str()); poolConnection(); return true; } - _requestGroup->shouldCancelDownloadForSafety(); - _requestGroup->initPieceStorage(); - - _requestGroup->getPieceStorage()->getDiskAdaptor()->initAndOpenFile(); - + getRequestGroup()->shouldCancelDownloadForSafety(); + getRequestGroup()->initPieceStorage(); + getPieceStorage()->getDiskAdaptor()->initAndOpenFile(); // In this context, knowsTotalLength() is true only when the file is // really zero-length. - if(_requestGroup->getDownloadContext()->knowsTotalLength()) { + if(getDownloadContext()->knowsTotalLength()) { poolConnection(); return true; } // We have to make sure that command that has Request object must // have segment after PieceStorage is initialized. See // AbstractCommand::execute() - _requestGroup->getSegmentMan()->getSegment(getCuid(), 0); + getSegmentMan()->getSegment(getCuid(), 0); - e->addCommand + getDownloadEngine()->addCommand (createHttpDownloadCommand(httpResponse, getTransferEncodingDecoder(httpResponse), getContentEncodingDecoder(httpResponse))); @@ -369,22 +363,23 @@ bool HttpResponseCommand::skipResponseBody // thrown away. HttpSkipResponseCommand* command = new HttpSkipResponseCommand - (getCuid(), req, _fileEntry, _requestGroup, httpConnection, httpResponse, - e, socket); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), + _httpConnection, httpResponse, + getDownloadEngine(), getSocket()); command->setTransferEncodingDecoder(decoder); // If request method is HEAD or the response body is zero-length, // set command's status to real time so that avoid read check blocking - if(req->getMethod() == Request::METHOD_HEAD || + if(getRequest()->getMethod() == Request::METHOD_HEAD || (httpResponse->getEntityLength() == 0 && !httpResponse->isTransferEncodingSpecified())) { command->setStatusRealtime(); // If entity length == 0, then socket read/write check must be disabled. command->disableSocketCheck(); - e->setNoWait(true); + getDownloadEngine()->setNoWait(true); } - e->addCommand(command); + getDownloadEngine()->addCommand(command); return true; } @@ -395,8 +390,10 @@ HttpDownloadCommand* HttpResponseCommand::createHttpDownloadCommand { HttpDownloadCommand* command = - new HttpDownloadCommand(getCuid(), req, _fileEntry, _requestGroup, - httpResponse, httpConnection, e, socket); + new HttpDownloadCommand(getCuid(), getRequest(), getFileEntry(), + getRequestGroup(), + httpResponse, _httpConnection, + getDownloadEngine(), getSocket()); command->setStartupIdleTime(getOption()->getAsInt(PREF_STARTUP_IDLE_TIME)); command->setLowestDownloadSpeedLimit (getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT)); @@ -407,25 +404,26 @@ HttpDownloadCommand* HttpResponseCommand::createHttpDownloadCommand // Since the compressed file's length are returned in the response header // and the decompressed file size is unknown at this point, disable file // allocation here. - _requestGroup->setFileAllocationEnabled(false); + getRequestGroup()->setFileAllocationEnabled(false); } - _requestGroup->getURISelector()->tuneDownloadCommand - (_fileEntry->getRemainingUris(), command); + getRequestGroup()->getURISelector()->tuneDownloadCommand + (getFileEntry()->getRemainingUris(), command); return command; } void HttpResponseCommand::poolConnection() { - if(req->supportsPersistentConnection()) { - e->poolSocket(req, createProxyRequest(), socket); + if(getRequest()->supportsPersistentConnection()) { + getDownloadEngine()->poolSocket(getRequest(), createProxyRequest(), + getSocket()); } } void HttpResponseCommand::onDryRunFileFound() { - _requestGroup->getPieceStorage()->markAllPiecesDone(); + getPieceStorage()->markAllPiecesDone(); poolConnection(); } diff --git a/src/HttpResponseCommand.h b/src/HttpResponseCommand.h index 20371905..a62a7331 100644 --- a/src/HttpResponseCommand.h +++ b/src/HttpResponseCommand.h @@ -48,7 +48,7 @@ class SocketCore; class HttpResponseCommand : public AbstractCommand { private: - SharedHandle<HttpConnection> httpConnection; + SharedHandle<HttpConnection> _httpConnection; bool handleDefaultEncoding(const SharedHandle<HttpResponse>& httpResponse); bool handleOtherEncoding(const SharedHandle<HttpResponse>& httpResponse); diff --git a/src/HttpSkipResponseCommand.cc b/src/HttpSkipResponseCommand.cc index 974b4a82..7818d5f0 100644 --- a/src/HttpSkipResponseCommand.cc +++ b/src/HttpSkipResponseCommand.cc @@ -87,13 +87,13 @@ void HttpSkipResponseCommand::setTransferEncodingDecoder bool HttpSkipResponseCommand::executeInternal() { - if(req->getMethod() == Request::METHOD_HEAD || + if(getRequest()->getMethod() == Request::METHOD_HEAD || (_totalLength == 0 && _transferEncodingDecoder.isNull())) { // If request method is HEAD or content-length header is present and // it's value is 0, then pool socket for reuse. // If content-length header is not present, then EOF is expected in the end. // In this case, the content is thrown away and socket cannot be pooled. - if(req->getMethod() == Request::METHOD_HEAD || + if(getRequest()->getMethod() == Request::METHOD_HEAD || _httpResponse->getHttpHeader()->defined(HttpHeader::CONTENT_LENGTH)) { poolConnection(); } @@ -104,7 +104,7 @@ bool HttpSkipResponseCommand::executeInternal() size_t bufSize = BUFSIZE; try { - socket->readData(buf, bufSize); + getSocket()->readData(buf, bufSize); if(_transferEncodingDecoder.isNull()) { _receivedBytes += bufSize; @@ -114,7 +114,7 @@ bool HttpSkipResponseCommand::executeInternal() _transferEncodingDecoder->decode(buf, bufSize); } if(_totalLength != 0 && bufSize == 0 && - !socket->wantRead() && !socket->wantWrite()) { + !getSocket()->wantRead() && !getSocket()->wantWrite()) { throw DL_RETRY_EX(EX_GOT_EOF); } } catch(RecoverableException& e) { @@ -127,7 +127,7 @@ bool HttpSkipResponseCommand::executeInternal() bool finished = false; if(_transferEncodingDecoder.isNull()) { if(bufSize == 0) { - if(!socket->wantRead() && !socket->wantWrite()) { + if(!getSocket()->wantRead() && !getSocket()->wantWrite()) { return processResponse(); } } else { @@ -140,16 +140,17 @@ bool HttpSkipResponseCommand::executeInternal() poolConnection(); return processResponse(); } else { - setWriteCheckSocketIf(socket, socket->wantWrite()); - e->addCommand(this); + setWriteCheckSocketIf(getSocket(), getSocket()->wantWrite()); + getDownloadEngine()->addCommand(this); return false; } } void HttpSkipResponseCommand::poolConnection() const { - if(req->supportsPersistentConnection()) { - e->poolSocket(req, createProxyRequest(), socket); + if(getRequest()->supportsPersistentConnection()) { + getDownloadEngine()->poolSocket + (getRequest(), createProxyRequest(), getSocket()); } } @@ -159,7 +160,8 @@ bool HttpSkipResponseCommand::processResponse() unsigned int rnum = _httpResponse->getHttpRequest()->getRequest()->getRedirectCount(); if(rnum >= Request::MAX_REDIRECT) { - throw DL_ABORT_EX(StringFormat("Too many redirects: count=%u", rnum).str()); + throw DL_ABORT_EX + (StringFormat("Too many redirects: count=%u", rnum).str()); } _httpResponse->processRedirect(); return prepareForRetry(0); @@ -167,8 +169,8 @@ bool HttpSkipResponseCommand::processResponse() if(_httpResponse->getResponseStatus() == HttpHeader::S401) { if(getOption()->getAsBool(PREF_HTTP_AUTH_CHALLENGE) && !_httpResponse->getHttpRequest()->authenticationUsed() && - e->getAuthConfigFactory()->activateBasicCred - (req->getHost(), req->getDir(), getOption().get())) { + getDownloadEngine()->getAuthConfigFactory()->activateBasicCred + (getRequest()->getHost(), getRequest()->getDir(), getOption().get())) { return prepareForRetry(0); } else { throw DL_ABORT_EX(EX_AUTH_FAILED); @@ -177,7 +179,10 @@ bool HttpSkipResponseCommand::processResponse() throw DL_ABORT_EX2(MSG_RESOURCE_NOT_FOUND, downloadresultcode::RESOURCE_NOT_FOUND); } else { - throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, util::parseUInt(_httpResponse->getResponseStatus())).str()); + throw DL_ABORT_EX + (StringFormat + (EX_BAD_STATUS, + util::parseUInt(_httpResponse->getResponseStatus())).str()); } } else { return prepareForRetry(0); diff --git a/src/InitiateConnectionCommand.cc b/src/InitiateConnectionCommand.cc index 6ef9e9c2..8b57e18e 100644 --- a/src/InitiateConnectionCommand.cc +++ b/src/InitiateConnectionCommand.cc @@ -77,8 +77,8 @@ bool InitiateConnectionCommand::executeInternal() { uint16_t port; SharedHandle<Request> proxyRequest = createProxyRequest(); if(proxyRequest.isNull()) { - hostname = req->getHost(); - port = req->getPort(); + hostname = getRequest()->getHost(); + port = getRequest()->getPort(); } else { hostname = proxyRequest->getHost(); port = proxyRequest->getPort(); @@ -86,21 +86,21 @@ bool InitiateConnectionCommand::executeInternal() { std::vector<std::string> addrs; std::string ipaddr = resolveHostname(addrs, hostname, port); if(ipaddr.empty()) { - e->addCommand(this); + getDownloadEngine()->addCommand(this); return false; } try { Command* command = createNextCommand(hostname, ipaddr, port, addrs, proxyRequest); - e->addCommand(command); + getDownloadEngine()->addCommand(command); return true; } catch(RecoverableException& ex) { // Catch exception and retry another address. // See also AbstractCommand::checkIfConnectionEstablished // TODO ipaddr might not be used if pooled sockt was found. - e->markBadIPAddress(hostname, ipaddr, port); - if(!e->findCachedIPAddress(hostname, port).empty()) { + getDownloadEngine()->markBadIPAddress(hostname, ipaddr, port); + if(!getDownloadEngine()->findCachedIPAddress(hostname, port).empty()) { if(getLogger()->info()) { getLogger()->info(EX_EXCEPTION_CAUGHT, ex); getLogger()->info(MSG_CONNECT_FAILED_AND_RETRY, @@ -108,12 +108,13 @@ bool InitiateConnectionCommand::executeInternal() { } Command* command = InitiateConnectionCommandFactory::createInitiateConnectionCommand - (getCuid(), req, _fileEntry, _requestGroup, e); - e->setNoWait(true); - e->addCommand(command); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), + getDownloadEngine()); + getDownloadEngine()->setNoWait(true); + getDownloadEngine()->addCommand(command); return true; } - e->removeCachedIPAddress(hostname, port); + getDownloadEngine()->removeCachedIPAddress(hostname, port); throw; } } |