diff options
| author | Tatsuhiro Tsujikawa <tatsuhiro.t@gmail.com> | 2010-06-21 13:51:56 +0000 |
|---|---|---|
| committer | Tatsuhiro Tsujikawa <tatsuhiro.t@gmail.com> | 2010-06-21 13:51:56 +0000 |
| commit | ca4940622c05e50a50f77c621ade914029663446 (patch) | |
| tree | 2715d87c6b4faa669ae317f6f95d9694630cd4a0 | |
| parent | ae957baa98d4f97ea2437596db5073f9c33d22ae (diff) | |
2010-06-21 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Changed naming standards for class member variable: now it looks
like var_ instead of _var.
550 files changed, 10270 insertions, 10265 deletions
@@ -1,3 +1,8 @@ +2010-06-21 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> + + Changed naming standards for class member variable: now it looks + like var_ instead of _var. + 2010-06-20 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> When wrong type DHT reply message is received for a transaction diff --git a/src/AbstractAuthResolver.cc b/src/AbstractAuthResolver.cc index 3a58333c..94d2e7d6 100644 --- a/src/AbstractAuthResolver.cc +++ b/src/AbstractAuthResolver.cc @@ -43,12 +43,12 @@ AbstractAuthResolver::~AbstractAuthResolver() {} void AbstractAuthResolver::setUserDefinedAuthConfig(const AuthConfigHandle& authConfig) { - _userDefinedAuthConfig = authConfig; + userDefinedAuthConfig_ = authConfig; } void AbstractAuthResolver::setDefaultAuthConfig(const AuthConfigHandle& authConfig) { - _defaultAuthConfig = authConfig; + defaultAuthConfig_ = authConfig; } } // namespace aria2 diff --git a/src/AbstractAuthResolver.h b/src/AbstractAuthResolver.h index 23b5908a..19876962 100644 --- a/src/AbstractAuthResolver.h +++ b/src/AbstractAuthResolver.h @@ -41,9 +41,9 @@ namespace aria2 { class AbstractAuthResolver : public AuthResolver { private: - SharedHandle<AuthConfig> _userDefinedAuthConfig; + SharedHandle<AuthConfig> userDefinedAuthConfig_; - SharedHandle<AuthConfig> _defaultAuthConfig; + SharedHandle<AuthConfig> defaultAuthConfig_; public: AbstractAuthResolver(); @@ -53,14 +53,14 @@ public: const SharedHandle<AuthConfig>& getUserDefinedAuthConfig() const { - return _userDefinedAuthConfig; + return userDefinedAuthConfig_; } void setDefaultAuthConfig(const SharedHandle<AuthConfig>& authConfig); const SharedHandle<AuthConfig>& getDefaultAuthConfig() const { - return _defaultAuthConfig; + return defaultAuthConfig_; } }; diff --git a/src/AbstractBtMessage.cc b/src/AbstractBtMessage.cc index 4ec8106c..38c15be6 100644 --- a/src/AbstractBtMessage.cc +++ b/src/AbstractBtMessage.cc @@ -43,59 +43,59 @@ namespace aria2 { AbstractBtMessage::AbstractBtMessage(uint8_t id, const std::string& name): BtMessage(id), - _sendingInProgress(false), - _invalidate(false), - _uploading(false), - _cuid(0), - _name(name), - _metadataGetMode(false), - _logger(LogFactory::getInstance()) + sendingInProgress_(false), + invalidate_(false), + uploading_(false), + cuid_(0), + name_(name), + metadataGetMode_(false), + logger_(LogFactory::getInstance()) {} AbstractBtMessage::~AbstractBtMessage() {} void AbstractBtMessage::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } void AbstractBtMessage::validate() { - if(!_validator.isNull()) { - _validator->validate(); + if(!validator_.isNull()) { + validator_->validate(); } } void AbstractBtMessage::setBtMessageValidator(const SharedHandle<BtMessageValidator>& validator) { - _validator = validator; + validator_ = validator; } void AbstractBtMessage::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void AbstractBtMessage::setBtMessageDispatcher (const WeakHandle<BtMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void AbstractBtMessage::setPeerConnection(const WeakHandle<PeerConnection>& peerConnection) { - _peerConnection = peerConnection; + peerConnection_ = peerConnection; } void AbstractBtMessage::setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } void AbstractBtMessage::setBtRequestFactory(const WeakHandle<BtRequestFactory>& factory) { - _requestFactory = factory; + requestFactory_ = factory; } } // namespace aria2 diff --git a/src/AbstractBtMessage.h b/src/AbstractBtMessage.h index accb56a2..b6fef8ad 100644 --- a/src/AbstractBtMessage.h +++ b/src/AbstractBtMessage.h @@ -51,64 +51,64 @@ class Logger; class AbstractBtMessage : public BtMessage { private: - bool _sendingInProgress; - bool _invalidate; - bool _uploading; - cuid_t _cuid; + bool sendingInProgress_; + bool invalidate_; + bool uploading_; + cuid_t cuid_; - std::string _name; + std::string name_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; - WeakHandle<BtMessageFactory> _messageFactory; + WeakHandle<BtMessageFactory> messageFactory_; - WeakHandle<BtRequestFactory> _requestFactory; + WeakHandle<BtRequestFactory> requestFactory_; - WeakHandle<PeerConnection> _peerConnection; + WeakHandle<PeerConnection> peerConnection_; - SharedHandle<BtMessageValidator> _validator; + SharedHandle<BtMessageValidator> validator_; - bool _metadataGetMode; + bool metadataGetMode_; - Logger* _logger; + Logger* logger_; protected: Logger* getLogger() const { - return _logger; + return logger_; } const SharedHandle<PieceStorage>& getPieceStorage() const { - return _pieceStorage; + return pieceStorage_; } const WeakHandle<PeerConnection>& getPeerConnection() const { - return _peerConnection; + return peerConnection_; } const WeakHandle<BtMessageDispatcher>& getBtMessageDispatcher() const { - return _dispatcher; + return dispatcher_; } const WeakHandle<BtRequestFactory>& getBtRequestFactory() const { - return _requestFactory; + return requestFactory_; } const WeakHandle<BtMessageFactory>& getBtMessageFactory() const { - return _messageFactory; + return messageFactory_; } bool isMetadataGetMode() const { - return _metadataGetMode; + return metadataGetMode_; } public: AbstractBtMessage(uint8_t id, const std::string& name); @@ -116,40 +116,40 @@ public: virtual ~AbstractBtMessage(); virtual bool isSendingInProgress() { - return _sendingInProgress; + return sendingInProgress_; } void setSendingInProgress(bool sendingInProgress) { - _sendingInProgress = sendingInProgress; + sendingInProgress_ = sendingInProgress; } virtual bool isInvalidate() { - return _invalidate; + return invalidate_; } void setInvalidate(bool invalidate) { - _invalidate = invalidate; + invalidate_ = invalidate; } virtual bool isUploading() { - return _uploading; + return uploading_; } void setUploading(bool uploading) { - _uploading = uploading; + uploading_ = uploading; } cuid_t getCuid() const { - return _cuid; + return cuid_; } void setCuid(cuid_t cuid) { - _cuid = cuid; + cuid_ = cuid; } const SharedHandle<Peer>& getPeer() const { - return _peer; + return peer_; } void setPeer(const SharedHandle<Peer>& peer); @@ -183,12 +183,12 @@ public: const std::string& getName() const { - return _name; + return name_; } void enableMetadataGetMode() { - _metadataGetMode = true; + metadataGetMode_ = true; } }; diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc index e8bd53c3..305c238a 100644 --- a/src/AbstractCommand.cc +++ b/src/AbstractCommand.cc @@ -77,28 +77,28 @@ AbstractCommand::AbstractCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e, const SocketHandle& s): - Command(cuid), _checkPoint(global::wallclock), - _timeout(requestGroup->getTimeout()), - _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_); } - _requestGroup->increaseStreamConnection(); - _requestGroup->increaseNumCommand(); + requestGroup_->increaseStreamConnection(); + requestGroup_->increaseNumCommand(); } AbstractCommand::~AbstractCommand() { disableReadCheckSocket(); disableWriteCheckSocket(); #ifdef ENABLE_ASYNC_DNS - disableNameResolverCheck(_asyncNameResolver); + disableNameResolverCheck(asyncNameResolver_); #endif // ENABLE_ASYNC_DNS - _requestGroup->decreaseNumCommand(); - _requestGroup->decreaseStreamConnection(); + requestGroup_->decreaseNumCommand(); + requestGroup_->decreaseStreamConnection(); } bool AbstractCommand::execute() { @@ -111,22 +111,22 @@ bool AbstractCommand::execute() { errorEventEnabled()); } try { - if(_requestGroup->downloadFinished() || _requestGroup->isHaltRequested()) { + 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 && + if(!req_.isNull() && fileEntry_->countPooledRequest() > 0 && !getPieceStorage()->hasMissingUnusedPiece()) { - SharedHandle<Request> fasterRequest = _fileEntry->findFasterRequest(_req); + SharedHandle<Request> fasterRequest = fileEntry_->findFasterRequest(req_); if(!fasterRequest.isNull()) { if(getLogger()->info()) { getLogger()->info("CUID#%s - Use faster Request hostname=%s, port=%u", @@ -135,28 +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; + (!checkSocketIsReadable_ && !checkSocketIsWritable_ && + !nameResolverCheck_)) { + checkPoint_ = global::wallclock; if(!getPieceStorage().isNull()) { - _segments.clear(); - getSegmentMan()->getInFlightSegment(_segments, getCuid()); - if(!_req.isNull() && _segments.empty()) { + segments_.clear(); + 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,16 +166,16 @@ bool AbstractCommand::execute() { } return prepareForRetry(0); } - if(_req.isNull() || _req->getMaxPipelinedRequest() == 1 || + if(req_.isNull() || req_->getMaxPipelinedRequest() == 1 || getDownloadContext()->getFileEntries().size() == 1) { - if(_segments.empty()) { + if(segments_.empty()) { SharedHandle<Segment> segment = getSegmentMan()->getSegment(getCuid()); if(!segment.isNull()) { - _segments.push_back(segment); + segments_.push_back(segment); } } - if(_segments.empty()) { + if(segments_.empty()) { // TODO socket could be pooled here if pipelining is enabled... if(getLogger()->info()) { getLogger()->info(MSG_NO_SEGMENT_AVAILABLE, @@ -193,12 +193,12 @@ bool AbstractCommand::execute() { } } } else { - size_t maxSegments = _req->getMaxPipelinedRequest(); - if(_segments.size() < maxSegments) { + size_t maxSegments = req_->getMaxPipelinedRequest(); + if(segments_.size() < maxSegments) { getSegmentMan()->getSegment - (_segments, getCuid(), _fileEntry, maxSegments); + (segments_, getCuid(), fileEntry_, maxSegments); } - if(_segments.empty()) { + if(segments_.empty()) { return prepareForRetry(0); } } @@ -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,43 +231,43 @@ 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(); + requestGroup_->increaseResumeFailureCount(); } } onAbort(); 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(); + requestGroup_->increaseResumeFailureCount(); } onAbort(); tryReserved(); @@ -277,11 +277,11 @@ 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); + requestGroup_->setHaltRequested(true); return true; } } @@ -308,45 +308,45 @@ 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(!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(!getSegmentMan().isNull()) { - getSegmentMan()->recognizeSegmentFor(_fileEntry); + 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", @@ -358,13 +358,13 @@ void AbstractCommand::onAbort() { // in DownloadContext is more than 1. The latter condition is // limitation of current implementation. if(!getOption()->getAsBool(PREF_ALWAYS_RESUME) && - !_fileEntry.isNull() && + !fileEntry_.isNull() && getSegmentMan()->calculateSessionDownloadLength() == 0 && - !_requestGroup->p2pInvolved() && + !requestGroup_->p2pInvolved() && getDownloadContext()->getFileEntries().size() == 1) { const int maxTries = getOption()->getAsInt(PREF_MAX_RESUME_FAILURE_TRIES); - if((maxTries > 0 && _requestGroup->getResumeFailureCount() >= maxTries)|| - _fileEntry->emptyRequestUri()) { + if((maxTries > 0 && requestGroup_->getResumeFailureCount() >= maxTries)|| + fileEntry_->emptyRequestUri()) { // Local file exists, but given servers(or at least contacted // ones) doesn't support resume. Let's restart download from // scratch. @@ -380,7 +380,7 @@ void AbstractCommand::onAbort() { // process. getOption()->put(PREF_ALWAYS_RESUME, V_TRUE); std::deque<URIResult> res; - _fileEntry->extractURIResult(res, downloadresultcode::CANNOT_RESUME); + fileEntry_->extractURIResult(res, downloadresultcode::CANNOT_RESUME); if(!res.empty()) { getSegmentMan()->cancelAllSegments(); getSegmentMan()->eraseSegmentWrittenLengthMemo(); @@ -394,8 +394,8 @@ void AbstractCommand::onAbort() { util::itos(getCuid()).c_str(), static_cast<unsigned long int>(uris.size())); } - _fileEntry->addUris(uris.begin(), uris.end()); - getSegmentMan()->recognizeSegmentFor(_fileEntry); + fileEntry_->addUris(uris.begin(), uris.end()); + getSegmentMan()->recognizeSegmentFor(fileEntry_); } } } @@ -403,10 +403,10 @@ void AbstractCommand::onAbort() { } void AbstractCommand::disableReadCheckSocket() { - if(_checkSocketIsReadable) { - _e->deleteSocketForReadCheck(_readCheckTarget, this); - _checkSocketIsReadable = false; - _readCheckTarget.reset(); + if(checkSocketIsReadable_) { + e_->deleteSocketForReadCheck(readCheckTarget_, this); + checkSocketIsReadable_ = false; + readCheckTarget_.reset(); } } @@ -414,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; } } } @@ -439,10 +439,10 @@ void AbstractCommand::setReadCheckSocketIf } void AbstractCommand::disableWriteCheckSocket() { - if(_checkSocketIsWritable) { - _e->deleteSocketForWriteCheck(_writeCheckTarget, this); - _checkSocketIsWritable = false; - _writeCheckTarget.reset(); + if(checkSocketIsWritable_) { + e_->deleteSocketForWriteCheck(writeCheckTarget_, this); + checkSocketIsWritable_ = false; + writeCheckTarget_.reset(); } } @@ -450,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; } } } @@ -512,16 +512,16 @@ static bool isProxyRequest class DomainMatch { private: - std::string _hostname; + std::string hostname_; public: - DomainMatch(const std::string& hostname):_hostname(hostname) {} + DomainMatch(const std::string& hostname):hostname_(hostname) {} bool operator()(const std::string& domain) const { if(util::startsWith(domain, A2STR::DOT_C)) { - return util::endsWith(_hostname, domain); + return util::endsWith(hostname_, domain); } else { - return util::endsWith(_hostname, A2STR::DOT_C+domain); + return util::endsWith(hostname_, A2STR::DOT_C+domain); } } }; @@ -569,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)) { @@ -602,37 +602,37 @@ SharedHandle<Request> AbstractCommand::createProxyRequest() const bool AbstractCommand::isAsyncNameResolverInitialized() const { - return !_asyncNameResolver.isNull(); + return !asyncNameResolver_.isNull(); } void AbstractCommand::initAsyncNameResolver(const std::string& hostname) { - _asyncNameResolver.reset(new AsyncNameResolver()); + asyncNameResolver_.reset(new AsyncNameResolver()); if(getLogger()->info()) { getLogger()->info(MSG_RESOLVING_HOSTNAME, util::itos(getCuid()).c_str(), hostname.c_str()); } - _asyncNameResolver->resolve(hostname); - setNameResolverCheck(_asyncNameResolver); + asyncNameResolver_->resolve(hostname); + setNameResolverCheck(asyncNameResolver_); } bool AbstractCommand::asyncResolveHostname() { - switch(_asyncNameResolver->getStatus()) { + switch(asyncNameResolver_->getStatus()) { case AsyncNameResolver::STATUS_SUCCESS: - disableNameResolverCheck(_asyncNameResolver); + disableNameResolverCheck(asyncNameResolver_); return true; case AsyncNameResolver::STATUS_ERROR: - disableNameResolverCheck(_asyncNameResolver); - if(!isProxyRequest(_req->getProtocol(), getOption())) { - _e->getRequestGroupMan()->getOrCreateServerStat - (_req->getHost(), _req->getProtocol())->setError(); + disableNameResolverCheck(asyncNameResolver_); + if(!isProxyRequest(req_->getProtocol(), getOption())) { + e_->getRequestGroupMan()->getOrCreateServerStat + (req_->getHost(), req_->getProtocol())->setError(); } throw DL_ABORT_EX (StringFormat(MSG_NAME_RESOLUTION_FAILED, util::itos(getCuid()).c_str(), - _asyncNameResolver->getHostname().c_str(), - _asyncNameResolver->getError().c_str()).str()); + asyncNameResolver_->getHostname().c_str(), + asyncNameResolver_->getError().c_str()).str()); default: return false; } @@ -640,36 +640,36 @@ bool AbstractCommand::asyncResolveHostname() const std::vector<std::string>& AbstractCommand::getResolvedAddresses() { - return _asyncNameResolver->getResolvedAddresses(); + return asyncNameResolver_->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); } } bool AbstractCommand::nameResolveFinished() const { return - _asyncNameResolver->getStatus() == AsyncNameResolver::STATUS_SUCCESS || - _asyncNameResolver->getStatus() == AsyncNameResolver::STATUS_ERROR; + asyncNameResolver_->getStatus() == AsyncNameResolver::STATUS_SUCCESS || + asyncNameResolver_->getStatus() == AsyncNameResolver::STATUS_ERROR; } #endif // ENABLE_ASYNC_DNS 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 @@ -687,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); @@ -700,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()) { @@ -720,14 +720,14 @@ std::string AbstractCommand::resolveHostname void AbstractCommand::prepareForNextAction(Command* nextCommand) { SharedHandle<CheckIntegrityEntry> entry - (new StreamCheckIntegrityEntry(_requestGroup, nextCommand)); + (new StreamCheckIntegrityEntry(requestGroup_, nextCommand)); std::vector<Command*>* commands = new std::vector<Command*>(); auto_delete_container<std::vector<Command*> > commandsDel(commands); - _requestGroup->processCheckIntegrityEntry(*commands, entry, _e); - _e->addCommand(*commands); + requestGroup_->processCheckIntegrityEntry(*commands, entry, e_); + e_->addCommand(*commands); commands->clear(); - _e->setNoWait(true); + e_->setNoWait(true); } bool AbstractCommand::checkIfConnectionEstablished @@ -740,8 +740,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(), @@ -749,17 +749,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()); @@ -781,12 +781,12 @@ const std::string& AbstractCommand::resolveProxyMethod const SharedHandle<Option>& AbstractCommand::getOption() const { - return _requestGroup->getOption(); + return requestGroup_->getOption(); } void AbstractCommand::createSocket() { - _socket.reset(new SocketCore()); + socket_.reset(new SocketCore()); } } // namespace aria2 diff --git a/src/AbstractCommand.h b/src/AbstractCommand.h index 577eeedc..619e6af7 100644 --- a/src/AbstractCommand.h +++ b/src/AbstractCommand.h @@ -55,25 +55,25 @@ class AsyncNameResolver; class AbstractCommand : public Command { private: - Timer _checkPoint; - time_t _timeout; + Timer checkPoint_; + time_t timeout_; - RequestGroup* _requestGroup; - SharedHandle<Request> _req; - SharedHandle<FileEntry> _fileEntry; - DownloadEngine* _e; - SharedHandle<SocketCore> _socket; - std::vector<SharedHandle<Segment> > _segments; + RequestGroup* requestGroup_; + SharedHandle<Request> req_; + SharedHandle<FileEntry> fileEntry_; + DownloadEngine* e_; + SharedHandle<SocketCore> socket_; + std::vector<SharedHandle<Segment> > segments_; #ifdef ENABLE_ASYNC_DNS - SharedHandle<AsyncNameResolver> _asyncNameResolver; + SharedHandle<AsyncNameResolver> asyncNameResolver_; #endif // ENABLE_ASYNC_DNS - bool _checkSocketIsReadable; - bool _checkSocketIsWritable; - SharedHandle<SocketCore> _readCheckTarget; - SharedHandle<SocketCore> _writeCheckTarget; - bool _nameResolverCheck; + bool checkSocketIsReadable_; + bool checkSocketIsWritable_; + SharedHandle<SocketCore> readCheckTarget_; + SharedHandle<SocketCore> writeCheckTarget_; + bool nameResolverCheck_; #ifdef ENABLE_ASYNC_DNS void setNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver); @@ -86,49 +86,49 @@ private: protected: RequestGroup* getRequestGroup() const { - return _requestGroup; + return requestGroup_; } const SharedHandle<Request>& getRequest() const { - return _req; + return req_; } void setRequest(const SharedHandle<Request>& request) { - _req = request; + req_ = request; } const SharedHandle<FileEntry>& getFileEntry() const { - return _fileEntry; + return fileEntry_; } void setFileEntry(const SharedHandle<FileEntry>& fileEntry) { - _fileEntry = fileEntry; + fileEntry_ = fileEntry; } DownloadEngine* getDownloadEngine() const { - return _e; + return e_; } const SharedHandle<SocketCore>& getSocket() const { - return _socket; + return socket_; } void setSocket(const SharedHandle<SocketCore>& s) { - _socket = s; + socket_ = s; } void createSocket(); const std::vector<SharedHandle<Segment> >& getSegments() const { - return _segments; + return segments_; } #ifdef ENABLE_ASYNC_DNS @@ -170,7 +170,7 @@ protected: */ void setWriteCheckSocketIf(const SharedHandle<SocketCore>& socket, bool pred); - void setTimeout(time_t timeout) { _timeout = timeout; } + void setTimeout(time_t timeout) { timeout_ = timeout; } void prepareForNextAction(Command* nextCommand = 0); @@ -205,17 +205,17 @@ protected: const SharedHandle<DownloadContext>& getDownloadContext() const { - return _requestGroup->getDownloadContext(); + return requestGroup_->getDownloadContext(); } const SharedHandle<SegmentMan>& getSegmentMan() const { - return _requestGroup->getSegmentMan(); + return requestGroup_->getSegmentMan(); } const SharedHandle<PieceStorage>& getPieceStorage() const { - return _requestGroup->getPieceStorage(); + return requestGroup_->getPieceStorage(); } public: AbstractCommand(cuid_t cuid, const SharedHandle<Request>& req, diff --git a/src/AbstractDiskWriter.cc b/src/AbstractDiskWriter.cc index 5c9d8a0f..e06e4732 100644 --- a/src/AbstractDiskWriter.cc +++ b/src/AbstractDiskWriter.cc @@ -57,11 +57,11 @@ namespace aria2 { AbstractDiskWriter::AbstractDiskWriter(const std::string& filename): - _filename(filename), - _fd(-1), - _readOnly(false), - _directIOAllowed(false), - _logger(LogFactory::getInstance()) {} + filename_(filename), + fd_(-1), + readOnly_(false), + directIOAllowed_(false), + logger_(LogFactory::getInstance()) {} AbstractDiskWriter::~AbstractDiskWriter() { @@ -70,7 +70,7 @@ AbstractDiskWriter::~AbstractDiskWriter() void AbstractDiskWriter::openFile(uint64_t totalLength) { - if(File(_filename).exists()) { + if(File(filename_).exists()) { openExistingFile(totalLength); } else { initAndOpenFile(totalLength); @@ -79,40 +79,40 @@ void AbstractDiskWriter::openFile(uint64_t totalLength) void AbstractDiskWriter::closeFile() { - if(_fd >= 0) { - close(_fd); - _fd = -1; + if(fd_ >= 0) { + close(fd_); + fd_ = -1; } } void AbstractDiskWriter::openExistingFile(uint64_t totalLength) { - if(!File(_filename).exists()) { + if(!File(filename_).exists()) { throw DL_ABORT_EX - (StringFormat(EX_FILE_OPEN, _filename.c_str(), MSG_FILE_NOT_FOUND).str()); + (StringFormat(EX_FILE_OPEN, filename_.c_str(), MSG_FILE_NOT_FOUND).str()); } int flags = O_BINARY; - if(_readOnly) { + if(readOnly_) { flags |= O_RDONLY; } else { flags |= O_RDWR; } - if((_fd = open(_filename.c_str(), flags, OPEN_MODE)) < 0) { + if((fd_ = open(filename_.c_str(), flags, OPEN_MODE)) < 0) { throw DL_ABORT_EX - (StringFormat(EX_FILE_OPEN, _filename.c_str(), strerror(errno)).str()); + (StringFormat(EX_FILE_OPEN, filename_.c_str(), strerror(errno)).str()); } } void AbstractDiskWriter::createFile(int addFlags) { - assert(!_filename.empty()); - util::mkdirs(File(_filename).getDirname()); - if((_fd = open(_filename.c_str(), O_CREAT|O_RDWR|O_TRUNC|O_BINARY|addFlags, + assert(!filename_.empty()); + util::mkdirs(File(filename_).getDirname()); + if((fd_ = open(filename_.c_str(), O_CREAT|O_RDWR|O_TRUNC|O_BINARY|addFlags, OPEN_MODE)) < 0) { throw DL_ABORT_EX(StringFormat(EX_FILE_OPEN, - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } } @@ -121,7 +121,7 @@ ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, size_t ssize_t writtenLength = 0; while((size_t)writtenLength < len) { ssize_t ret = 0; - while((ret = write(_fd, data+writtenLength, len-writtenLength)) == -1 && errno == EINTR); + while((ret = write(fd_, data+writtenLength, len-writtenLength)) == -1 && errno == EINTR); if(ret == -1) { return -1; } @@ -133,15 +133,15 @@ ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, size_t ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len) { ssize_t ret = 0; - while((ret = read(_fd, data, len)) == -1 && errno == EINTR); + while((ret = read(fd_, data, len)) == -1 && errno == EINTR); return ret; } void AbstractDiskWriter::seek(off_t offset) { - if(a2lseek(_fd, offset, SEEK_SET) == (off_t)-1) { + if(a2lseek(fd_, offset, SEEK_SET) == (off_t)-1) { throw DL_ABORT_EX - (StringFormat(EX_FILE_SEEK, _filename.c_str(), strerror(errno)).str()); + (StringFormat(EX_FILE_SEEK, filename_.c_str(), strerror(errno)).str()); } } @@ -153,10 +153,10 @@ void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, off_t // DownloadFailureException and abort download instantly. if(errno == ENOSPC) { throw DOWNLOAD_FAILURE_EXCEPTION - (StringFormat(EX_FILE_WRITE, _filename.c_str(), strerror(errno)).str()); + (StringFormat(EX_FILE_WRITE, filename_.c_str(), strerror(errno)).str()); } throw DL_ABORT_EX(StringFormat(EX_FILE_WRITE, - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } } @@ -166,27 +166,27 @@ ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offs seek(offset); if((ret = readDataInternal(data, len)) < 0) { throw DL_ABORT_EX(StringFormat(EX_FILE_READ, - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } return ret; } void AbstractDiskWriter::truncate(uint64_t length) { - if(_fd == -1) { + if(fd_ == -1) { throw DL_ABORT_EX("File not opened."); } #ifdef __MINGW32__ // Since mingw32's ftruncate cannot handle over 2GB files, we use SetEndOfFile // instead. - HANDLE handle = LongToHandle(_get_osfhandle(_fd)); + HANDLE handle = LongToHandle(_get_osfhandle(fd_)); seek(length); if(SetEndOfFile(handle) == 0) { throw DL_ABORT_EX(StringFormat("SetEndOfFile failed. cause: %s", GetLastError()).str()); } #else - if(ftruncate(_fd, length) == -1) { + if(ftruncate(fd_, length) == -1) { throw DL_ABORT_EX(StringFormat("ftruncate failed. cause: %s", strerror(errno)).str()); } @@ -196,10 +196,10 @@ void AbstractDiskWriter::truncate(uint64_t length) #ifdef HAVE_POSIX_FALLOCATE void AbstractDiskWriter::allocate(off_t offset, uint64_t length) { - if(_fd == -1) { + if(fd_ == -1) { throw DL_ABORT_EX("File not yet opened."); } - int r = posix_fallocate(_fd, offset, length); + int r = posix_fallocate(fd_, offset, length); if(r != 0) { throw DL_ABORT_EX(StringFormat("posix_fallocate failed. cause: %s", strerror(r)).str()); @@ -209,16 +209,16 @@ void AbstractDiskWriter::allocate(off_t offset, uint64_t length) uint64_t AbstractDiskWriter::size() { - return File(_filename).size(); + return File(filename_).size(); } void AbstractDiskWriter::enableDirectIO() { #ifdef ENABLE_DIRECT_IO - if(_directIOAllowed) { + if(directIOAllowed_) { int flg; - while((flg = fcntl(_fd, F_GETFL)) == -1 && errno == EINTR); - while(fcntl(_fd, F_SETFL, flg|O_DIRECT) == -1 && errno == EINTR); + while((flg = fcntl(fd_, F_GETFL)) == -1 && errno == EINTR); + while(fcntl(fd_, F_SETFL, flg|O_DIRECT) == -1 && errno == EINTR); } #endif // ENABLE_DIRECT_IO } @@ -227,19 +227,19 @@ void AbstractDiskWriter::disableDirectIO() { #ifdef ENABLE_DIRECT_IO int flg; - while((flg = fcntl(_fd, F_GETFL)) == -1 && errno == EINTR); - while(fcntl(_fd, F_SETFL, flg&(~O_DIRECT)) == -1 && errno == EINTR); + while((flg = fcntl(fd_, F_GETFL)) == -1 && errno == EINTR); + while(fcntl(fd_, F_SETFL, flg&(~O_DIRECT)) == -1 && errno == EINTR); #endif // ENABLE_DIRECT_IO } void AbstractDiskWriter::enableReadOnly() { - _readOnly = true; + readOnly_ = true; } void AbstractDiskWriter::disableReadOnly() { - _readOnly = false; + readOnly_ = false; } } // namespace aria2 diff --git a/src/AbstractDiskWriter.h b/src/AbstractDiskWriter.h index f9f312b0..89c5a64b 100644 --- a/src/AbstractDiskWriter.h +++ b/src/AbstractDiskWriter.h @@ -44,14 +44,14 @@ class Logger; class AbstractDiskWriter : public DiskWriter { private: - std::string _filename; - int _fd; + std::string filename_; + int fd_; - bool _readOnly; + bool readOnly_; - bool _directIOAllowed; + bool directIOAllowed_; - Logger* _logger; + Logger* logger_; ssize_t writeDataInternal(const unsigned char* data, size_t len); ssize_t readDataInternal(unsigned char* data, size_t len); @@ -86,7 +86,7 @@ public: virtual void disableDirectIO(); - virtual void allowDirectIO() { _directIOAllowed = true; } + virtual void allowDirectIO() { directIOAllowed_ = true; } virtual void enableReadOnly(); diff --git a/src/AbstractProxyRequestCommand.cc b/src/AbstractProxyRequestCommand.cc index 76771360..339e8fed 100644 --- a/src/AbstractProxyRequestCommand.cc +++ b/src/AbstractProxyRequestCommand.cc @@ -63,8 +63,8 @@ AbstractProxyRequestCommand::AbstractProxyRequestCommand const SocketHandle& s) : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - _proxyRequest(proxyRequest), - _httpConnection(new HttpConnection(cuid, s)) + proxyRequest_(proxyRequest), + httpConnection_(new HttpConnection(cuid, s)) { setTimeout(getOption()->getAsInt(PREF_CONNECT_TIMEOUT)); disableReadCheckSocket(); @@ -75,21 +75,21 @@ AbstractProxyRequestCommand::~AbstractProxyRequestCommand() {} bool AbstractProxyRequestCommand::executeInternal() { //socket->setBlockingMode(); - if(_httpConnection->sendBufferIsEmpty()) { + if(httpConnection_->sendBufferIsEmpty()) { if(!checkIfConnectionEstablished - (getSocket(), _connectedHostname, _connectedAddr, _connectedPort)) { + (getSocket(), connectedHostname_, connectedAddr_, connectedPort_)) { return true; } SharedHandle<HttpRequest> httpRequest(new HttpRequest()); httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT)); httpRequest->setRequest(getRequest()); - httpRequest->setProxyRequest(_proxyRequest); + httpRequest->setProxyRequest(proxyRequest_); - _httpConnection->sendProxyRequest(httpRequest); + httpConnection_->sendProxyRequest(httpRequest); } else { - _httpConnection->sendPendingData(); + httpConnection_->sendPendingData(); } - if(_httpConnection->sendBufferIsEmpty()) { + if(httpConnection_->sendBufferIsEmpty()) { getDownloadEngine()->addCommand(getNextCommand()); return true; } else { diff --git a/src/AbstractProxyRequestCommand.h b/src/AbstractProxyRequestCommand.h index 0dfabbd3..c90cebd5 100644 --- a/src/AbstractProxyRequestCommand.h +++ b/src/AbstractProxyRequestCommand.h @@ -44,19 +44,19 @@ class SocketCore; class AbstractProxyRequestCommand : public AbstractCommand { private: - SharedHandle<Request> _proxyRequest; + SharedHandle<Request> proxyRequest_; - SharedHandle<HttpConnection> _httpConnection; + SharedHandle<HttpConnection> httpConnection_; - std::string _connectedHostname; - std::string _connectedAddr; - uint16_t _connectedPort; + std::string connectedHostname_; + std::string connectedAddr_; + uint16_t connectedPort_; protected: virtual bool executeInternal(); const SharedHandle<HttpConnection>& getHttpConnection() const { - return _httpConnection; + return httpConnection_; } public: AbstractProxyRequestCommand(cuid_t cuid, @@ -74,9 +74,9 @@ public: void setConnectedAddr (const std::string& hostname, const std::string& addr, uint16_t port) { - _connectedHostname = hostname; - _connectedAddr = addr; - _connectedPort = port; + connectedHostname_ = hostname; + connectedAddr_ = addr; + connectedPort_ = port; } }; diff --git a/src/AbstractProxyResponseCommand.cc b/src/AbstractProxyResponseCommand.cc index 3806507c..8df05995 100644 --- a/src/AbstractProxyResponseCommand.cc +++ b/src/AbstractProxyResponseCommand.cc @@ -62,12 +62,12 @@ 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. getDownloadEngine()->addCommand(this); diff --git a/src/AbstractProxyResponseCommand.h b/src/AbstractProxyResponseCommand.h index 8e391574..881cee95 100644 --- a/src/AbstractProxyResponseCommand.h +++ b/src/AbstractProxyResponseCommand.h @@ -44,13 +44,13 @@ class SocketCore; class AbstractProxyResponseCommand : public AbstractCommand { private: - SharedHandle<HttpConnection> _httpConnection; + SharedHandle<HttpConnection> httpConnection_; protected: virtual bool executeInternal(); const SharedHandle<HttpConnection>& getHttpConnection() const { - return _httpConnection; + return httpConnection_; } public: AbstractProxyResponseCommand diff --git a/src/AbstractSingleDiskAdaptor.cc b/src/AbstractSingleDiskAdaptor.cc index 03aab03b..8a5be61b 100644 --- a/src/AbstractSingleDiskAdaptor.cc +++ b/src/AbstractSingleDiskAdaptor.cc @@ -44,40 +44,40 @@ namespace aria2 { AbstractSingleDiskAdaptor::AbstractSingleDiskAdaptor(): - _totalLength(0), _readOnly(false) {} + totalLength_(0), readOnly_(false) {} AbstractSingleDiskAdaptor::~AbstractSingleDiskAdaptor() {} void AbstractSingleDiskAdaptor::initAndOpenFile() { - _diskWriter->initAndOpenFile(_totalLength); + diskWriter_->initAndOpenFile(totalLength_); } void AbstractSingleDiskAdaptor::openFile() { - _diskWriter->openFile(_totalLength); + diskWriter_->openFile(totalLength_); } void AbstractSingleDiskAdaptor::closeFile() { - _diskWriter->closeFile(); + diskWriter_->closeFile(); } void AbstractSingleDiskAdaptor::openExistingFile() { - _diskWriter->openExistingFile(_totalLength); + diskWriter_->openExistingFile(totalLength_); } void AbstractSingleDiskAdaptor::writeData (const unsigned char* data, size_t len, off_t offset) { - _diskWriter->writeData(data, len, offset); + diskWriter_->writeData(data, len, offset); } ssize_t AbstractSingleDiskAdaptor::readData (unsigned char* data, size_t len, off_t offset) { - return _diskWriter->readData(data, len, offset); + return diskWriter_->readData(data, len, offset); } bool AbstractSingleDiskAdaptor::fileExists() @@ -92,7 +92,7 @@ uint64_t AbstractSingleDiskAdaptor::size() void AbstractSingleDiskAdaptor::truncate(uint64_t length) { - _diskWriter->truncate(length); + diskWriter_->truncate(length); } FileAllocationIteratorHandle @@ -102,14 +102,14 @@ AbstractSingleDiskAdaptor::fileAllocationIterator() if(doesFallocate()) { SharedHandle<FallocFileAllocationIterator> h (new FallocFileAllocationIterator - (_diskWriter.get(), size() ,_totalLength)); + (diskWriter_.get(), size() ,totalLength_)); return h; } else #endif // HAVE_POSIX_FALLOCATE { SingleFileAllocationIteratorHandle h (new SingleFileAllocationIterator - (_diskWriter.get(), size(), _totalLength)); + (diskWriter_.get(), size(), totalLength_)); h->init(); return h; } @@ -117,42 +117,42 @@ AbstractSingleDiskAdaptor::fileAllocationIterator() void AbstractSingleDiskAdaptor::enableDirectIO() { - _diskWriter->enableDirectIO(); + diskWriter_->enableDirectIO(); } void AbstractSingleDiskAdaptor::disableDirectIO() { - _diskWriter->disableDirectIO(); + diskWriter_->disableDirectIO(); } void AbstractSingleDiskAdaptor::enableReadOnly() { - _diskWriter->enableReadOnly(); - _readOnly = true; + diskWriter_->enableReadOnly(); + readOnly_ = true; } void AbstractSingleDiskAdaptor::disableReadOnly() { - _diskWriter->disableReadOnly(); - _readOnly = false; + diskWriter_->disableReadOnly(); + readOnly_ = false; } void AbstractSingleDiskAdaptor::cutTrailingGarbage() { - if(File(getFilePath()).size() > _totalLength) { - _diskWriter->truncate(_totalLength); + if(File(getFilePath()).size() > totalLength_) { + diskWriter_->truncate(totalLength_); } } void AbstractSingleDiskAdaptor::setDiskWriter (const DiskWriterHandle& diskWriter) { - _diskWriter = diskWriter; + diskWriter_ = diskWriter; } void AbstractSingleDiskAdaptor::setTotalLength(const uint64_t& totalLength) { - _totalLength = totalLength; + totalLength_ = totalLength; } } // namespace aria2 diff --git a/src/AbstractSingleDiskAdaptor.h b/src/AbstractSingleDiskAdaptor.h index fe7f364c..18dd2b3f 100644 --- a/src/AbstractSingleDiskAdaptor.h +++ b/src/AbstractSingleDiskAdaptor.h @@ -44,9 +44,9 @@ class FileAllocationIterator; class AbstractSingleDiskAdaptor : public DiskAdaptor { private: - SharedHandle<DiskWriter> _diskWriter; - uint64_t _totalLength; - bool _readOnly; + SharedHandle<DiskWriter> diskWriter_; + uint64_t totalLength_; + bool readOnly_; public: AbstractSingleDiskAdaptor(); @@ -83,7 +83,7 @@ public: // Make sure that DiskWriter is set before calling this function. virtual void disableReadOnly(); - virtual bool isReadOnlyEnabled() const { return _readOnly; } + virtual bool isReadOnlyEnabled() const { return readOnly_; } virtual void cutTrailingGarbage(); @@ -93,14 +93,14 @@ public: const SharedHandle<DiskWriter>& getDiskWriter() const { - return _diskWriter; + return diskWriter_; } void setTotalLength(const uint64_t& totalLength); uint64_t getTotalLength() const { - return _totalLength; + return totalLength_; } }; diff --git a/src/ActivePeerConnectionCommand.cc b/src/ActivePeerConnectionCommand.cc index f7bfc79b..5a92c301 100644 --- a/src/ActivePeerConnectionCommand.cc +++ b/src/ActivePeerConnectionCommand.cc @@ -65,34 +65,34 @@ ActivePeerConnectionCommand::ActivePeerConnectionCommand time_t interval) : Command(cuid), - _requestGroup(requestGroup), - _interval(interval), - _e(e), - _numNewConnection(5) + requestGroup_(requestGroup), + interval_(interval), + e_(e), + numNewConnection_(5) { - _requestGroup->increaseNumCommand(); + requestGroup_->increaseNumCommand(); } ActivePeerConnectionCommand::~ActivePeerConnectionCommand() { - _requestGroup->decreaseNumCommand(); + requestGroup_->decreaseNumCommand(); } bool ActivePeerConnectionCommand::execute() { - if(_btRuntime->isHalt()) { + if(btRuntime_->isHalt()) { return true; } - if(_checkPoint.difference(global::wallclock) >= _interval) { - _checkPoint = global::wallclock; - TransferStat tstat = _requestGroup->calculateStat(); + if(checkPoint_.difference(global::wallclock) >= interval_) { + checkPoint_ = global::wallclock; + TransferStat tstat = requestGroup_->calculateStat(); const unsigned int maxDownloadLimit = - _requestGroup->getMaxDownloadSpeedLimit(); - const unsigned int maxUploadLimit = _requestGroup->getMaxUploadSpeedLimit(); + requestGroup_->getMaxDownloadSpeedLimit(); + const unsigned int maxUploadLimit = requestGroup_->getMaxUploadSpeedLimit(); unsigned int thresholdSpeed; if(!bittorrent::getTorrentAttrs - (_requestGroup->getDownloadContext())->metadata.empty()) { + (requestGroup_->getDownloadContext())->metadata.empty()) { thresholdSpeed = - _requestGroup->getOption()->getAsInt(PREF_BT_REQUEST_PEER_SPEED_LIMIT); + requestGroup_->getOption()->getAsInt(PREF_BT_REQUEST_PEER_SPEED_LIMIT); } else { thresholdSpeed = 0; } @@ -100,36 +100,36 @@ bool ActivePeerConnectionCommand::execute() { thresholdSpeed = std::min(maxDownloadLimit, thresholdSpeed); } if(// for seeder state - (_pieceStorage->downloadFinished() && _btRuntime->lessThanMaxPeers() && + (pieceStorage_->downloadFinished() && btRuntime_->lessThanMaxPeers() && (maxUploadLimit == 0 || tstat.getUploadSpeed() < maxUploadLimit*0.8)) || // for leecher state - (!_pieceStorage->downloadFinished() && + (!pieceStorage_->downloadFinished() && (tstat.getDownloadSpeed() < thresholdSpeed || - _btRuntime->lessThanMinPeers()))) { + btRuntime_->lessThanMinPeers()))) { unsigned int numConnection = 0; - if(_pieceStorage->downloadFinished()) { - if(_btRuntime->getMaxPeers() > _btRuntime->getConnections()) { + if(pieceStorage_->downloadFinished()) { + if(btRuntime_->getMaxPeers() > btRuntime_->getConnections()) { numConnection = - std::min(_numNewConnection, - _btRuntime->getMaxPeers()-_btRuntime->getConnections()); + std::min(numNewConnection_, + btRuntime_->getMaxPeers()-btRuntime_->getConnections()); } } else { - numConnection = _numNewConnection; + numConnection = numNewConnection_; } for(unsigned int numAdd = numConnection; - numAdd > 0 && _peerStorage->isPeerAvailable(); --numAdd) { - SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); + numAdd > 0 && peerStorage_->isPeerAvailable(); --numAdd) { + SharedHandle<Peer> peer = peerStorage_->getUnusedPeer(); connectToPeer(peer); } - if(_btRuntime->getConnections() == 0 && - !_pieceStorage->downloadFinished()) { - _btAnnounce->overrideMinInterval(BtAnnounce::DEFAULT_ANNOUNCE_INTERVAL); + if(btRuntime_->getConnections() == 0 && + !pieceStorage_->downloadFinished()) { + btAnnounce_->overrideMinInterval(BtAnnounce::DEFAULT_ANNOUNCE_INTERVAL); } } } - _e->addCommand(this); + e_->addCommand(this); return false; } @@ -138,13 +138,13 @@ void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer) if(peer.isNull()) { return; } - peer->usedBy(_e->newCUID()); + peer->usedBy(e_->newCUID()); PeerInitiateConnectionCommand* command = - new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, _e, - _btRuntime); - command->setPeerStorage(_peerStorage); - command->setPieceStorage(_pieceStorage); - _e->addCommand(command); + new PeerInitiateConnectionCommand(peer->usedBy(), requestGroup_, peer, e_, + btRuntime_); + command->setPeerStorage(peerStorage_); + command->setPieceStorage(pieceStorage_); + e_->addCommand(command); if(getLogger()->info()) { getLogger()->info(MSG_CONNECTING_TO_PEER, util::itos(getCuid()).c_str(), @@ -155,25 +155,25 @@ void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer) void ActivePeerConnectionCommand::setBtRuntime (const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void ActivePeerConnectionCommand::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void ActivePeerConnectionCommand::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void ActivePeerConnectionCommand::setBtAnnounce (const SharedHandle<BtAnnounce>& btAnnounce) { - _btAnnounce = btAnnounce; + btAnnounce_ = btAnnounce; } } // namespace aria2 diff --git a/src/ActivePeerConnectionCommand.h b/src/ActivePeerConnectionCommand.h index c4464425..6a7e16f8 100644 --- a/src/ActivePeerConnectionCommand.h +++ b/src/ActivePeerConnectionCommand.h @@ -51,16 +51,16 @@ class BtAnnounce; class ActivePeerConnectionCommand : public Command { private: - RequestGroup* _requestGroup; - SharedHandle<BtRuntime> _btRuntime; - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<PeerStorage> _peerStorage; - SharedHandle<BtAnnounce> _btAnnounce; + RequestGroup* requestGroup_; + SharedHandle<BtRuntime> btRuntime_; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<PeerStorage> peerStorage_; + SharedHandle<BtAnnounce> btAnnounce_; - time_t _interval; // UNIT: sec - DownloadEngine* _e; - Timer _checkPoint; - unsigned int _numNewConnection; // the number of the connection to establish. + time_t interval_; // UNIT: sec + DownloadEngine* e_; + Timer checkPoint_; + unsigned int numNewConnection_; // the number of the connection to establish. public: ActivePeerConnectionCommand(cuid_t cuid, RequestGroup* requestGroup, @@ -75,7 +75,7 @@ public: void setNumNewConnection(size_t numNewConnection) { - _numNewConnection = numNewConnection; + numNewConnection_ = numNewConnection; } void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime); diff --git a/src/AdaptiveURISelector.cc b/src/AdaptiveURISelector.cc index fb0c83e6..5c48259a 100644 --- a/src/AdaptiveURISelector.cc +++ b/src/AdaptiveURISelector.cc @@ -63,9 +63,9 @@ namespace aria2 { AdaptiveURISelector::AdaptiveURISelector (const SharedHandle<ServerStatMan>& serverStatMan, RequestGroup* requestGroup): - _serverStatMan(serverStatMan), - _requestGroup(requestGroup), - _logger(LogFactory::getInstance()) + serverStatMan_(serverStatMan), + requestGroup_(requestGroup), + logger_(LogFactory::getInstance()) { resetCounters(); } @@ -74,12 +74,12 @@ AdaptiveURISelector::~AdaptiveURISelector() {} std::string AdaptiveURISelector::select(FileEntry* fileEntry) { - if(_logger->debug()) { - _logger->debug("AdaptiveURISelector: called %d", - _requestGroup->getNumConnection()); + if(logger_->debug()) { + logger_->debug("AdaptiveURISelector: called %d", + requestGroup_->getNumConnection()); } std::deque<std::string>& uris = fileEntry->getRemainingUris(); - if (uris.empty() && _requestGroup->getNumConnection() <= 1) { + if (uris.empty() && requestGroup_->getNumConnection() <= 1) { // here we know the download will fail, trying to find previously // failed uris that may succeed with more permissive values mayRetryWithIncreasedTimeout(fileEntry); @@ -95,8 +95,8 @@ std::string AdaptiveURISelector::select(FileEntry* fileEntry) void AdaptiveURISelector::mayRetryWithIncreasedTimeout(FileEntry* fileEntry) { - if (_requestGroup->getTimeout()*2 >= MAX_TIMEOUT) return; - _requestGroup->setTimeout(_requestGroup->getTimeout()*2); + if (requestGroup_->getTimeout()*2 >= MAX_TIMEOUT) return; + requestGroup_->setTimeout(requestGroup_->getTimeout()*2); std::deque<std::string>& uris = fileEntry->getRemainingUris(); // looking for retries @@ -105,12 +105,12 @@ void AdaptiveURISelector::mayRetryWithIncreasedTimeout(FileEntry* fileEntry) std::transform(timeouts.begin(), timeouts.end(), std::back_inserter(uris), std::mem_fun_ref(&URIResult::getURI)); - if(_logger->debug()) { + if(logger_->debug()) { for(std::deque<std::string>::const_iterator i = uris.begin(), eoi = uris.end(); i != eoi; ++i) { - _logger->debug("AdaptiveURISelector: will retry server with increased" + logger_->debug("AdaptiveURISelector: will retry server with increased" " timeout (%d s): %s", - _requestGroup->getTimeout(), (*i).c_str()); + requestGroup_->getTimeout(), (*i).c_str()); } } } @@ -122,48 +122,48 @@ std::string AdaptiveURISelector::selectOne(const std::deque<std::string>& uris) return A2STR::NIL; } else { const unsigned int numPieces = - _requestGroup->getDownloadContext()->getNumPieces(); + requestGroup_->getDownloadContext()->getNumPieces(); bool reservedContext = numPieces > 0 && - _nbConnections > std::min(numPieces, - _requestGroup->getNumConcurrentCommand()); + nbConnections_ > std::min(numPieces, + requestGroup_->getNumConcurrentCommand()); bool selectBest = numPieces == 0 || reservedContext; if(numPieces > 0) - ++_nbConnections; + ++nbConnections_; /* At least, 3 mirrors must be tested */ if(getNbTestedServers(uris) < 3) { std::string notTested = getFirstNotTestedUri(uris); if(notTested != A2STR::NIL) { - if(_logger->debug()) { - _logger->debug("AdaptiveURISelector: choosing the first non tested" + if(logger_->debug()) { + logger_->debug("AdaptiveURISelector: choosing the first non tested" " mirror: %s", notTested.c_str()); } - --_nbServerToEvaluate; + --nbServerToEvaluate_; return notTested; } } - if(!selectBest && _nbConnections > 1 && _nbServerToEvaluate > 0) { - _nbServerToEvaluate--; + if(!selectBest && nbConnections_ > 1 && nbServerToEvaluate_ > 0) { + nbServerToEvaluate_--; std::string notTested = getFirstNotTestedUri(uris); if(notTested != A2STR::NIL) { /* Here we return the first untested mirror */ - if(_logger->debug()) { - _logger->debug("AdaptiveURISelector: choosing non tested mirror %s" + if(logger_->debug()) { + logger_->debug("AdaptiveURISelector: choosing non tested mirror %s" " for connection #%d", - notTested.c_str(), _nbConnections); + notTested.c_str(), nbConnections_); } return notTested; } else { /* Here we return a mirror which need to be tested again */ std::string toReTest = getFirstToTestUri(uris); if(toReTest != A2STR::NIL) { - if(_logger->debug()) { - _logger->debug("AdaptiveURISelector: choosing mirror %s which has" + if(logger_->debug()) { + logger_->debug("AdaptiveURISelector: choosing mirror %s which has" " not been tested recently for connection #%d", - toReTest.c_str(), _nbConnections); + toReTest.c_str(), nbConnections_); } return toReTest; } else { @@ -187,16 +187,16 @@ std::string AdaptiveURISelector::getBestMirror if (bests.size() < 2) { std::string uri = getMaxDownloadSpeedUri(uris); - if(_logger->debug()) { - _logger->debug("AdaptiveURISelector: choosing the best mirror :" + if(logger_->debug()) { + logger_->debug("AdaptiveURISelector: choosing the best mirror :" " %.2fKB/s %s (other mirrors are at least 25%% slower)", (float) max/1024, uri.c_str()); } return uri; } else { std::string uri = selectRandomUri(bests); - if(_logger->debug()) { - _logger->debug("AdaptiveURISelector: choosing randomly one of the best" + if(logger_->debug()) { + logger_->debug("AdaptiveURISelector: choosing randomly one of the best" " mirrors (range [%.2fKB/s, %.2fKB/s]): %s", (float) min/1024, (float) max/1024, uri.c_str()); } @@ -206,9 +206,9 @@ std::string AdaptiveURISelector::getBestMirror void AdaptiveURISelector::resetCounters() { - _nbConnections = 1; - _nbServerToEvaluate = - _requestGroup->getOption()->getAsInt(PREF_METALINK_SERVERS) - 1; + nbConnections_ = 1; + nbServerToEvaluate_ = + requestGroup_->getOption()->getAsInt(PREF_METALINK_SERVERS) - 1; } void AdaptiveURISelector::tuneDownloadCommand @@ -221,16 +221,16 @@ void AdaptiveURISelector::adjustLowestSpeedLimit (const std::deque<std::string>& uris, DownloadCommand* command) const { unsigned int lowest = - _requestGroup->getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT); + requestGroup_->getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT); if (lowest > 0) { unsigned int low_lowest = 4 * 1024; unsigned int max = getMaxDownloadSpeed(uris); if (max > 0 && lowest > max / 4) { - _logger->notice("Lowering lowest-speed-limit since known max speed is too" + logger_->notice("Lowering lowest-speed-limit since known max speed is too" " near (new:%d was:%d max:%d)", max / 4, lowest, max); command->setLowestDownloadSpeedLimit(max / 4); } else if (max == 0 && lowest > low_lowest) { - _logger->notice("Lowering lowest-speed-limit since we have no clue about" + logger_->notice("Lowering lowest-speed-limit since we have no clue about" " available speed (now:%d was:%d)", low_lowest, lowest); command->setLowestDownloadSpeedLimit(low_lowest); } @@ -341,7 +341,7 @@ SharedHandle<ServerStat> AdaptiveURISelector::getServerStats { Request r; r.setUri(uri); - return _serverStatMan->find(r.getHost(), r.getProtocol()); + return serverStatMan_->find(r.getHost(), r.getProtocol()); } unsigned int AdaptiveURISelector::getNbTestedServers diff --git a/src/AdaptiveURISelector.h b/src/AdaptiveURISelector.h index 92550f4a..aeb07ecd 100644 --- a/src/AdaptiveURISelector.h +++ b/src/AdaptiveURISelector.h @@ -47,15 +47,15 @@ class Logger; class AdaptiveURISelector:public URISelector { private: - SharedHandle<ServerStatMan> _serverStatMan; - // No need to delete _requestGroup - RequestGroup* _requestGroup; - unsigned int _nbServerToEvaluate; - unsigned int _nbConnections; + SharedHandle<ServerStatMan> serverStatMan_; + // No need to delete requestGroup_ + RequestGroup* requestGroup_; + unsigned int nbServerToEvaluate_; + unsigned int nbConnections_; static const time_t MAX_TIMEOUT = 60; - Logger* _logger; + Logger* logger_; void mayRetryWithIncreasedTimeout(FileEntry* fileEntry); diff --git a/src/AlphaNumberDecorator.h b/src/AlphaNumberDecorator.h index c8ad33dd..9f550f4d 100644 --- a/src/AlphaNumberDecorator.h +++ b/src/AlphaNumberDecorator.h @@ -45,14 +45,14 @@ class AlphaNumberDecorator : public NumberDecorator { private: - size_t _width; + size_t width_; - char _zero; + char zero_; std::string widen(const std::string& s, size_t width) { std::string t = s; - std::string zero(1, _zero); + std::string zero(1, zero_); while(t.size() < width) { t.insert(0, zero); } @@ -61,14 +61,14 @@ private: public: AlphaNumberDecorator(size_t width, bool uppercase = false): - _width(width), _zero(uppercase?'A':'a') {} + width_(width), zero_(uppercase?'A':'a') {} virtual ~AlphaNumberDecorator() {} virtual std::string decorate(unsigned int number) { if(number == 0) { - return widen(std::string(1, _zero), _width); + return widen(std::string(1, zero_), width_); } int base = 26; @@ -77,12 +77,12 @@ public: do { unsigned int quot = number/base; unsigned int rem = number%base; - u[index++] = _zero+rem; + u[index++] = zero_+rem; number = quot; } while(number); std::reverse(&u[0], &u[index]); - return widen(std::string(&u[0], &u[index]), _width); + return widen(std::string(&u[0], &u[index]), width_); } }; diff --git a/src/AnnounceList.cc b/src/AnnounceList.cc index fa0ccf65..339a6c2d 100644 --- a/src/AnnounceList.cc +++ b/src/AnnounceList.cc @@ -50,13 +50,13 @@ const std::string AnnounceList::COMPLETED("completed"); AnnounceList::AnnounceList (const std::vector<std::vector<std::string> >& announceList): - _currentTrackerInitialized(false) { + currentTrackerInitialized_(false) { reconfigure(announceList); } AnnounceList::AnnounceList (const std::deque<SharedHandle<AnnounceTier> >& announceTiers): - _tiers(announceTiers), _currentTrackerInitialized(false) { + tiers_(announceTiers), currentTrackerInitialized_(false) { resetIterator(); } @@ -70,7 +70,7 @@ void AnnounceList::reconfigure } std::deque<std::string> urls((*itr).begin(), (*itr).end()); SharedHandle<AnnounceTier> tier(new AnnounceTier(urls)); - _tiers.push_back(tier); + tiers_.push_back(tier); } resetIterator(); } @@ -78,72 +78,72 @@ void AnnounceList::reconfigure void AnnounceList::reconfigure(const std::string& url) { std::deque<std::string> urls; urls.push_back(url); - _tiers.push_back(SharedHandle<AnnounceTier>(new AnnounceTier(urls))); + tiers_.push_back(SharedHandle<AnnounceTier>(new AnnounceTier(urls))); resetIterator(); } void AnnounceList::resetIterator() { - _currentTier = _tiers.begin(); - if(_currentTier != _tiers.end() && (*_currentTier)->urls.size()) { - _currentTracker = (*_currentTier)->urls.begin(); - _currentTrackerInitialized = true; + currentTier_ = tiers_.begin(); + if(currentTier_ != tiers_.end() && (*currentTier_)->urls.size()) { + currentTracker_ = (*currentTier_)->urls.begin(); + currentTrackerInitialized_ = true; } else { - _currentTrackerInitialized = false; + currentTrackerInitialized_ = false; } } std::string AnnounceList::getAnnounce() const { - if(_currentTrackerInitialized) { - return *_currentTracker; + if(currentTrackerInitialized_) { + return *currentTracker_; } else { return A2STR::NIL; } } void AnnounceList::announceSuccess() { - if(_currentTrackerInitialized) { - (*_currentTier)->nextEvent(); - std::string url = *_currentTracker; - (*_currentTier)->urls.erase(_currentTracker); - (*_currentTier)->urls.push_front(url); - _currentTier = _tiers.begin(); - _currentTracker = (*_currentTier)->urls.begin(); + if(currentTrackerInitialized_) { + (*currentTier_)->nextEvent(); + std::string url = *currentTracker_; + (*currentTier_)->urls.erase(currentTracker_); + (*currentTier_)->urls.push_front(url); + currentTier_ = tiers_.begin(); + currentTracker_ = (*currentTier_)->urls.begin(); } } void AnnounceList::announceFailure() { - if(_currentTrackerInitialized) { - ++_currentTracker; - if(_currentTracker == (*_currentTier)->urls.end()) { + if(currentTrackerInitialized_) { + ++currentTracker_; + if(currentTracker_ == (*currentTier_)->urls.end()) { // force next event - (*_currentTier)->nextEventIfAfterStarted(); - ++_currentTier; - if(_currentTier == _tiers.end()) { - _currentTrackerInitialized = false; + (*currentTier_)->nextEventIfAfterStarted(); + ++currentTier_; + if(currentTier_ == tiers_.end()) { + currentTrackerInitialized_ = false; } else { - _currentTracker = (*_currentTier)->urls.begin(); + currentTracker_ = (*currentTier_)->urls.begin(); } } } } AnnounceTier::AnnounceEvent AnnounceList::getEvent() const { - if(_currentTrackerInitialized) { - return (*_currentTier)->event; + if(currentTrackerInitialized_) { + return (*currentTier_)->event; } else { return AnnounceTier::STARTED; } } void AnnounceList::setEvent(AnnounceTier::AnnounceEvent event) { - if(_currentTrackerInitialized) { - (*_currentTier)->event = event; + if(currentTrackerInitialized_) { + (*currentTier_)->event = event; } } std::string AnnounceList::getEventString() const { - if(_currentTrackerInitialized) { - switch((*_currentTier)->event) { + if(currentTrackerInitialized_) { + switch((*currentTier_)->event) { case AnnounceTier::STARTED: case AnnounceTier::STARTED_AFTER_COMPLETION: return STARTED; @@ -188,18 +188,18 @@ public: }; size_t AnnounceList::countStoppedAllowedTier() const { - return count_if(_tiers.begin(), _tiers.end(), FindStoppedAllowedTier()); + return count_if(tiers_.begin(), tiers_.end(), FindStoppedAllowedTier()); } size_t AnnounceList::countCompletedAllowedTier() const { - return count_if(_tiers.begin(), _tiers.end(), FindCompletedAllowedTier()); + return count_if(tiers_.begin(), tiers_.end(), FindCompletedAllowedTier()); } void AnnounceList::setCurrentTier (const std::deque<SharedHandle<AnnounceTier> >::iterator& itr) { - if(itr != _tiers.end()) { - _currentTier = itr; - _currentTracker = (*_currentTier)->urls.begin(); + if(itr != tiers_.end()) { + currentTier_ = itr; + currentTracker_ = (*currentTier_)->urls.begin(); } } @@ -216,23 +216,23 @@ find_wrap_if(InputIterator first, InputIterator last, void AnnounceList::moveToStoppedAllowedTier() { std::deque<SharedHandle<AnnounceTier> >::iterator itr = - find_wrap_if(_tiers.begin(), _tiers.end(), - _currentTier, + find_wrap_if(tiers_.begin(), tiers_.end(), + currentTier_, FindStoppedAllowedTier()); setCurrentTier(itr); } void AnnounceList::moveToCompletedAllowedTier() { std::deque<SharedHandle<AnnounceTier> >::iterator itr = - find_wrap_if(_tiers.begin(), _tiers.end(), - _currentTier, + find_wrap_if(tiers_.begin(), tiers_.end(), + currentTier_, FindCompletedAllowedTier()); setCurrentTier(itr); } void AnnounceList::shuffle() { for(std::deque<SharedHandle<AnnounceTier> >::const_iterator itr = - _tiers.begin(), eoi = _tiers.end(); itr != eoi; ++itr) { + tiers_.begin(), eoi = tiers_.end(); itr != eoi; ++itr) { std::deque<std::string>& urls = (*itr)->urls; std::random_shuffle(urls.begin(), urls.end(), *(SimpleRandomizer::getInstance().get())); @@ -241,7 +241,7 @@ void AnnounceList::shuffle() { bool AnnounceList::allTiersFailed() const { - return _currentTier == _tiers.end(); + return currentTier_ == tiers_.end(); } void AnnounceList::resetTier() @@ -251,8 +251,8 @@ void AnnounceList::resetTier() bool AnnounceList::currentTierAcceptsStoppedEvent() const { - if(_currentTrackerInitialized) { - return FindStoppedAllowedTier()(*_currentTier); + if(currentTrackerInitialized_) { + return FindStoppedAllowedTier()(*currentTier_); } else { return false; } @@ -260,8 +260,8 @@ bool AnnounceList::currentTierAcceptsStoppedEvent() const bool AnnounceList::currentTierAcceptsCompletedEvent() const { - if(_currentTrackerInitialized) { - return FindCompletedAllowedTier()(*_currentTier); + if(currentTrackerInitialized_) { + return FindCompletedAllowedTier()(*currentTier_); } else { return false; } diff --git a/src/AnnounceList.h b/src/AnnounceList.h index 394475c9..4976d580 100644 --- a/src/AnnounceList.h +++ b/src/AnnounceList.h @@ -45,16 +45,16 @@ namespace aria2 { class AnnounceList { public: private: - std::deque<SharedHandle<AnnounceTier> > _tiers; - std::deque<SharedHandle<AnnounceTier> >::iterator _currentTier; - std::deque<std::string>::iterator _currentTracker; - bool _currentTrackerInitialized; + std::deque<SharedHandle<AnnounceTier> > tiers_; + std::deque<SharedHandle<AnnounceTier> >::iterator currentTier_; + std::deque<std::string>::iterator currentTracker_; + bool currentTrackerInitialized_; void resetIterator(); void setCurrentTier (const std::deque<SharedHandle<AnnounceTier> >::iterator& itr); public: - AnnounceList():_currentTrackerInitialized(false) {} + AnnounceList():currentTrackerInitialized_(false) {} AnnounceList(const std::vector<std::vector<std::string> >& announceList); AnnounceList(const std::deque<SharedHandle<AnnounceTier> >& tiers); @@ -62,7 +62,7 @@ public: void reconfigure(const std::string& url); size_t countTier() const { - return _tiers.size(); + return tiers_.size(); } /** diff --git a/src/AsyncNameResolver.cc b/src/AsyncNameResolver.cc index 58be22aa..ae904e7b 100644 --- a/src/AsyncNameResolver.cc +++ b/src/AsyncNameResolver.cc @@ -48,58 +48,58 @@ void callback(void* arg, int status, int timeouts, struct hostent* host) { AsyncNameResolver* resolverPtr = reinterpret_cast<AsyncNameResolver*>(arg); if(status != ARES_SUCCESS) { - resolverPtr->_error = ares_strerror(status); - resolverPtr->_status = AsyncNameResolver::STATUS_ERROR; + resolverPtr->error_ = ares_strerror(status); + resolverPtr->status_ = AsyncNameResolver::STATUS_ERROR; return; } for(char** ap = host->h_addr_list; *ap; ++ap) { struct in_addr addr; memcpy(&addr, *ap, sizeof(in_addr)); - resolverPtr->_resolvedAddresses.push_back(inet_ntoa(addr)); + resolverPtr->resolvedAddresses_.push_back(inet_ntoa(addr)); } - resolverPtr->_status = AsyncNameResolver::STATUS_SUCCESS; + resolverPtr->status_ = AsyncNameResolver::STATUS_SUCCESS; } AsyncNameResolver::AsyncNameResolver(): - _status(STATUS_READY) + status_(STATUS_READY) { // TODO evaluate return value - ares_init(&_channel); + ares_init(&channel_); } AsyncNameResolver::~AsyncNameResolver() { - ares_destroy(_channel); + ares_destroy(channel_); } void AsyncNameResolver::resolve(const std::string& name) { - _hostname = name; - _status = STATUS_QUERYING; - ares_gethostbyname(_channel, name.c_str(), AF_INET, callback, this); + hostname_ = name; + status_ = STATUS_QUERYING; + ares_gethostbyname(channel_, name.c_str(), AF_INET, callback, this); } int AsyncNameResolver::getFds(fd_set* rfdsPtr, fd_set* wfdsPtr) const { - return ares_fds(_channel, rfdsPtr, wfdsPtr); + return ares_fds(channel_, rfdsPtr, wfdsPtr); } void AsyncNameResolver::process(fd_set* rfdsPtr, fd_set* wfdsPtr) { - ares_process(_channel, rfdsPtr, wfdsPtr); + ares_process(channel_, rfdsPtr, wfdsPtr); } #ifdef HAVE_LIBCARES int AsyncNameResolver::getsock(sock_t* sockets) const { - return ares_getsock(_channel, reinterpret_cast<ares_socket_t*>(sockets), + return ares_getsock(channel_, reinterpret_cast<ares_socket_t*>(sockets), ARES_GETSOCK_MAXNUM); } void AsyncNameResolver::process(ares_socket_t readfd, ares_socket_t writefd) { - ares_process_fd(_channel, readfd, writefd); + ares_process_fd(channel_, readfd, writefd); } #endif // HAVE_LIBCARES @@ -111,12 +111,12 @@ bool AsyncNameResolver::operator==(const AsyncNameResolver& resolver) const void AsyncNameResolver::reset() { - _hostname = A2STR::NIL; - _resolvedAddresses.clear(); - _status = STATUS_READY; - ares_destroy(_channel); + hostname_ = A2STR::NIL; + resolvedAddresses_.clear(); + status_ = STATUS_READY; + ares_destroy(channel_); // TODO evaluate return value - ares_init(&_channel); + ares_init(&channel_); } } // namespace aria2 diff --git a/src/AsyncNameResolver.h b/src/AsyncNameResolver.h index 61d06980..ad284ec1 100644 --- a/src/AsyncNameResolver.h +++ b/src/AsyncNameResolver.h @@ -62,12 +62,12 @@ public: STATUS_ERROR, }; private: - STATUS _status; - ares_channel _channel; + STATUS status_; + ares_channel channel_; - std::vector<std::string> _resolvedAddresses; - std::string _error; - std::string _hostname; + std::vector<std::string> resolvedAddresses_; + std::string error_; + std::string hostname_; public: AsyncNameResolver(); @@ -77,17 +77,17 @@ public: const std::vector<std::string>& getResolvedAddresses() const { - return _resolvedAddresses; + return resolvedAddresses_; } const std::string& getError() const { - return _error; + return error_; } STATUS getStatus() const { - return _status; + return status_; } int getFds(fd_set* rfdsPtr, fd_set* wfdsPtr) const; @@ -110,7 +110,7 @@ public: const std::string& getHostname() const { - return _hostname; + return hostname_; } }; diff --git a/src/AuthConfig.h b/src/AuthConfig.h index e8e751b1..a241fc83 100644 --- a/src/AuthConfig.h +++ b/src/AuthConfig.h @@ -47,28 +47,28 @@ namespace aria2 { class AuthConfig { private: - std::string _authScheme; - std::string _user; - std::string _password; + std::string authScheme_; + std::string user_; + std::string password_; public: AuthConfig() {} AuthConfig(const std::string& user, const std::string& password): - _user(user), _password(password) {} + user_(user), password_(password) {} std::string getAuthText() const { - return strconcat(_user, ":", _password); + return strconcat(user_, ":", password_); } const std::string& getUser() const { - return _user; + return user_; } const std::string& getPassword() const { - return _password; + return password_; } }; diff --git a/src/AuthConfigFactory.cc b/src/AuthConfigFactory.cc index 876405ba..25032e10 100644 --- a/src/AuthConfigFactory.cc +++ b/src/AuthConfigFactory.cc @@ -71,10 +71,10 @@ AuthConfigFactory::createAuthConfig } std::deque<BasicCred>::const_iterator i = findBasicCred(request->getHost(), request->getDir()); - if(i == _basicCreds.end()) { + if(i == basicCreds_.end()) { return SharedHandle<AuthConfig>(); } else { - return createAuthConfig((*i)._user, (*i)._password); + return createAuthConfig((*i).user_, (*i).password_); } } else { if(!request->getUsername().empty()) { @@ -93,7 +93,7 @@ AuthConfigFactory::createAuthConfig // First, check we have password corresponding to host and // username NetrcAuthResolver authResolver; - authResolver.setNetrc(_netrc); + authResolver.setNetrc(netrc_); SharedHandle<AuthConfig> ac = authResolver.resolveAuthConfig(request->getHost()); @@ -133,7 +133,7 @@ AuthResolverHandle AuthConfigFactory::createHttpAuthResolver resolver.reset(new DefaultAuthResolver()); } else { NetrcAuthResolverHandle authResolver(new NetrcAuthResolver()); - authResolver->setNetrc(_netrc); + authResolver->setNetrc(netrc_); authResolver->ignoreDefault(); resolver = authResolver; } @@ -150,7 +150,7 @@ AuthResolverHandle AuthConfigFactory::createFtpAuthResolver resolver.reset(new DefaultAuthResolver()); } else { NetrcAuthResolverHandle authResolver(new NetrcAuthResolver()); - authResolver->setNetrc(_netrc); + authResolver->setNetrc(netrc_); resolver = authResolver; } resolver->setUserDefinedAuthConfig @@ -164,18 +164,18 @@ AuthResolverHandle AuthConfigFactory::createFtpAuthResolver void AuthConfigFactory::setNetrc(const SharedHandle<Netrc>& netrc) { - _netrc = netrc; + netrc_ = netrc; } void AuthConfigFactory::updateBasicCred(const BasicCred& basicCred) { std::deque<BasicCred>::iterator i = - std::lower_bound(_basicCreds.begin(), _basicCreds.end(), basicCred); + std::lower_bound(basicCreds_.begin(), basicCreds_.end(), basicCred); - if(i != _basicCreds.end() && (*i) == basicCred) { + if(i != basicCreds_.end() && (*i) == basicCred) { (*i) = basicCred; } else { - _basicCreds.insert(i, basicCred); + basicCreds_.insert(i, basicCred); } } @@ -184,7 +184,7 @@ bool AuthConfigFactory::activateBasicCred { std::deque<BasicCred>::iterator i = findBasicCred(host, path); - if(i == _basicCreds.end()) { + if(i == basicCreds_.end()) { SharedHandle<AuthConfig> authConfig = createHttpAuthResolver(op)->resolveAuthConfig(host); if(authConfig.isNull()) { @@ -192,8 +192,8 @@ bool AuthConfigFactory::activateBasicCred } else { BasicCred bc(authConfig->getUser(), authConfig->getPassword(), host, path, true); - i = std::lower_bound(_basicCreds.begin(), _basicCreds.end(), bc); - _basicCreds.insert(i, bc); + i = std::lower_bound(basicCreds_.begin(), basicCreds_.end(), bc); + basicCreds_.insert(i, bc); return true; } } else { @@ -206,34 +206,34 @@ AuthConfigFactory::BasicCred::BasicCred (const std::string& user, const std::string& password, const std::string& host, const std::string& path, bool activated): - _user(user), _password(password), - _host(host), _path(path), _activated(activated) + user_(user), password_(password), + host_(host), path_(path), activated_(activated) { - if(!util::endsWith(_path, "/")) { - _path += "/"; + if(!util::endsWith(path_, "/")) { + path_ += "/"; } } void AuthConfigFactory::BasicCred::activate() { - _activated = true; + activated_ = true; } bool AuthConfigFactory::BasicCred::isActivated() const { - return _activated; + return activated_; } bool AuthConfigFactory::BasicCred::operator==(const BasicCred& cred) const { - return _host == cred._host && _path == cred._path; + return host_ == cred.host_ && path_ == cred.path_; } bool AuthConfigFactory::BasicCred::operator<(const BasicCred& cred) const { - int c = _host.compare(cred._host); + int c = host_.compare(cred.host_); if(c == 0) { - return _path > cred._path; + return path_ > cred.path_; } else { return c < 0; } @@ -245,13 +245,13 @@ AuthConfigFactory::findBasicCred(const std::string& host, { BasicCred bc("", "", host, path); std::deque<BasicCred>::iterator i = - std::lower_bound(_basicCreds.begin(), _basicCreds.end(), bc); - for(; i != _basicCreds.end() && (*i)._host == host; ++i) { - if(util::startsWith(bc._path, (*i)._path)) { + std::lower_bound(basicCreds_.begin(), basicCreds_.end(), bc); + for(; i != basicCreds_.end() && (*i).host_ == host; ++i) { + if(util::startsWith(bc.path_, (*i).path_)) { return i; } } - return _basicCreds.end(); + return basicCreds_.end(); } } // namespace aria2 diff --git a/src/AuthConfigFactory.h b/src/AuthConfigFactory.h index ea6dc711..f3221800 100644 --- a/src/AuthConfigFactory.h +++ b/src/AuthConfigFactory.h @@ -53,7 +53,7 @@ class AuthResolver; class AuthConfigFactory { private: - SharedHandle<Netrc> _netrc; + SharedHandle<Netrc> netrc_; SharedHandle<AuthConfig> createAuthConfig(const std::string& user, const std::string& password) const; @@ -64,11 +64,11 @@ private: public: class BasicCred { public: - std::string _user; - std::string _password; - std::string _host; - std::string _path; - bool _activated; + std::string user_; + std::string password_; + std::string host_; + std::string path_; + bool activated_; BasicCred(const std::string& user, const std::string& password, const std::string& host, const std::string& path, @@ -83,7 +83,7 @@ public: bool operator<(const BasicCred& cred) const; }; private: - std::deque<BasicCred> _basicCreds; + std::deque<BasicCred> basicCreds_; public: AuthConfigFactory(); @@ -109,13 +109,13 @@ public: (const std::string& host, const std::string& path, const Option* op); // Find a BasicCred using host and path and return the iterator - // pointing to it. If not found, then return _basicCreds.end(). + // pointing to it. If not found, then return basicCreds_.end(). std::deque<AuthConfigFactory::BasicCred>::iterator findBasicCred(const std::string& host, const std::string& path); // If the same BasicCred is already added, then it is replaced with // given basicCred. Otherwise, insert given basicCred to - // _basicCreds. + // basicCreds_. void updateBasicCred(const BasicCred& basicCred); static const std::string ANONYMOUS; diff --git a/src/BNode.cc b/src/BNode.cc index fdc3c436..adfb8028 100644 --- a/src/BNode.cc +++ b/src/BNode.cc @@ -43,45 +43,45 @@ namespace aria2 { BNode::BNode(const SharedHandle<DHTBucket>& bucket): - _bucket(bucket), - _up(0), - _left(0), - _right(0) {} + bucket_(bucket), + up_(0), + left_(0), + right_(0) {} BNode::~BNode() { - delete _left; - delete _right; + delete left_; + delete right_; } void BNode::setLeft(BNode* left) { - _left = left; - _left->_up = this; + left_ = left; + left_->up_ = this; } void BNode::setRight(BNode* right) { - _right = right; - _right->_up = this; + right_ = right; + right_->up_ = this; } void BNode::setUp(BNode* up) { - _up = up; + up_ = up; } void BNode::setBucket(const SharedHandle<DHTBucket>& bucket) { - _bucket = bucket; + bucket_ = bucket; } bool BNode::isInRange(const unsigned char* key) const { - if(_bucket.isNull()) { - return _left->isInRange(key) || _right->isInRange(key); + if(bucket_.isNull()) { + return left_->isInRange(key) || right_->isInRange(key); } else { - return _bucket->isInRange(key); + return bucket_->isInRange(key); } } diff --git a/src/BNode.h b/src/BNode.h index dfcb601b..a194399c 100644 --- a/src/BNode.h +++ b/src/BNode.h @@ -48,13 +48,13 @@ class DHTNode; class BNode { private: - SharedHandle<DHTBucket> _bucket; + SharedHandle<DHTBucket> bucket_; - BNode* _up; + BNode* up_; - BNode* _left; + BNode* left_; - BNode* _right; + BNode* right_; public: BNode(const SharedHandle<DHTBucket>& bucket = SharedHandle<DHTBucket>()); @@ -63,28 +63,28 @@ public: const SharedHandle<DHTBucket>& getBucket() const { - return _bucket; + return bucket_; } void setBucket(const SharedHandle<DHTBucket>& bucket); BNode* getLeft() const { - return _left; + return left_; } void setLeft(BNode* left); BNode* getRight() const { - return _right; + return right_; } void setRight(BNode* right); BNode* getUp() const { - return _up; + return up_; } void setUp(BNode* up); diff --git a/src/BitfieldMan.cc b/src/BitfieldMan.cc index b0daa7d4..907a05ce 100644 --- a/src/BitfieldMan.cc +++ b/src/BitfieldMan.cc @@ -46,51 +46,51 @@ using namespace aria2::expr; namespace aria2 { BitfieldMan::BitfieldMan(size_t blockLength, uint64_t totalLength) - :_blockLength(blockLength), - _totalLength(totalLength), - _bitfieldLength(0), - _blocks(0), - _filterEnabled(false), - _bitfield(0), - _useBitfield(0), - _filterBitfield(0), - _cachedNumMissingBlock(0), - _cachedNumFilteredBlock(0), - _cachedCompletedLength(0), - _cachedFilteredCompletedLength(0), - _cachedFilteredTotalLength(0) + :blockLength_(blockLength), + totalLength_(totalLength), + bitfieldLength_(0), + blocks_(0), + filterEnabled_(false), + bitfield_(0), + useBitfield_(0), + filterBitfield_(0), + cachedNumMissingBlock_(0), + cachedNumFilteredBlock_(0), + cachedCompletedLength_(0), + cachedFilteredCompletedLength_(0), + cachedFilteredTotalLength_(0) { - if(_blockLength > 0 && _totalLength > 0) { - _blocks = _totalLength/_blockLength+(_totalLength%_blockLength ? 1 : 0); - _bitfieldLength = _blocks/8+(_blocks%8 ? 1 : 0); - _bitfield = new unsigned char[_bitfieldLength]; - _useBitfield = new unsigned char[_bitfieldLength]; - memset(_bitfield, 0, _bitfieldLength); - memset(_useBitfield, 0, _bitfieldLength); + if(blockLength_ > 0 && totalLength_ > 0) { + blocks_ = totalLength_/blockLength_+(totalLength_%blockLength_ ? 1 : 0); + bitfieldLength_ = blocks_/8+(blocks_%8 ? 1 : 0); + bitfield_ = new unsigned char[bitfieldLength_]; + useBitfield_ = new unsigned char[bitfieldLength_]; + memset(bitfield_, 0, bitfieldLength_); + memset(useBitfield_, 0, bitfieldLength_); updateCache(); } } BitfieldMan::BitfieldMan(const BitfieldMan& bitfieldMan) - :_blockLength(bitfieldMan._blockLength), - _totalLength(bitfieldMan._totalLength), - _bitfieldLength(bitfieldMan._bitfieldLength), - _blocks(bitfieldMan._blocks), - _filterEnabled(bitfieldMan._filterEnabled), - _bitfield(new unsigned char[_bitfieldLength]), - _useBitfield(new unsigned char[_bitfieldLength]), - _filterBitfield(0), - _cachedNumMissingBlock(0), - _cachedNumFilteredBlock(0), - _cachedCompletedLength(0), - _cachedFilteredCompletedLength(0), - _cachedFilteredTotalLength(0) + :blockLength_(bitfieldMan.blockLength_), + totalLength_(bitfieldMan.totalLength_), + bitfieldLength_(bitfieldMan.bitfieldLength_), + blocks_(bitfieldMan.blocks_), + filterEnabled_(bitfieldMan.filterEnabled_), + bitfield_(new unsigned char[bitfieldLength_]), + useBitfield_(new unsigned char[bitfieldLength_]), + filterBitfield_(0), + cachedNumMissingBlock_(0), + cachedNumFilteredBlock_(0), + cachedCompletedLength_(0), + cachedFilteredCompletedLength_(0), + cachedFilteredTotalLength_(0) { - memcpy(_bitfield, bitfieldMan._bitfield, _bitfieldLength); - memcpy(_useBitfield, bitfieldMan._useBitfield, _bitfieldLength); - if(_filterEnabled) { - _filterBitfield = new unsigned char[_bitfieldLength]; - memcpy(_filterBitfield, bitfieldMan._filterBitfield, _bitfieldLength); + memcpy(bitfield_, bitfieldMan.bitfield_, bitfieldLength_); + memcpy(useBitfield_, bitfieldMan.useBitfield_, bitfieldLength_); + if(filterEnabled_) { + filterBitfield_ = new unsigned char[bitfieldLength_]; + memcpy(filterBitfield_, bitfieldMan.filterBitfield_, bitfieldLength_); } updateCache(); } @@ -98,26 +98,26 @@ BitfieldMan::BitfieldMan(const BitfieldMan& bitfieldMan) BitfieldMan& BitfieldMan::operator=(const BitfieldMan& bitfieldMan) { if(this != &bitfieldMan) { - _blockLength = bitfieldMan._blockLength; - _totalLength = bitfieldMan._totalLength; - _blocks = bitfieldMan._blocks; - _bitfieldLength = bitfieldMan._bitfieldLength; - _filterEnabled = bitfieldMan._filterEnabled; - - delete [] _bitfield; - _bitfield = new unsigned char[_bitfieldLength]; - memcpy(_bitfield, bitfieldMan._bitfield, _bitfieldLength); - - delete [] _useBitfield; - _useBitfield = new unsigned char[_bitfieldLength]; - memcpy(_useBitfield, bitfieldMan._useBitfield, _bitfieldLength); - - delete [] _filterBitfield; - if(_filterEnabled) { - _filterBitfield = new unsigned char[_bitfieldLength]; - memcpy(_filterBitfield, bitfieldMan._filterBitfield, _bitfieldLength); + blockLength_ = bitfieldMan.blockLength_; + totalLength_ = bitfieldMan.totalLength_; + blocks_ = bitfieldMan.blocks_; + bitfieldLength_ = bitfieldMan.bitfieldLength_; + filterEnabled_ = bitfieldMan.filterEnabled_; + + delete [] bitfield_; + bitfield_ = new unsigned char[bitfieldLength_]; + memcpy(bitfield_, bitfieldMan.bitfield_, bitfieldLength_); + + delete [] useBitfield_; + useBitfield_ = new unsigned char[bitfieldLength_]; + memcpy(useBitfield_, bitfieldMan.useBitfield_, bitfieldLength_); + + delete [] filterBitfield_; + if(filterEnabled_) { + filterBitfield_ = new unsigned char[bitfieldLength_]; + memcpy(filterBitfield_, bitfieldMan.filterBitfield_, bitfieldLength_); } else { - _filterBitfield = 0; + filterBitfield_ = 0; } updateCache(); @@ -126,16 +126,16 @@ BitfieldMan& BitfieldMan::operator=(const BitfieldMan& bitfieldMan) } BitfieldMan::~BitfieldMan() { - delete [] _bitfield; - delete [] _useBitfield; - delete [] _filterBitfield; + delete [] bitfield_; + delete [] useBitfield_; + delete [] filterBitfield_; } size_t BitfieldMan::getBlockLength(size_t index) const { - if(index == _blocks-1) { + if(index == blocks_-1) { return getLastBlockLength(); - } else if(index < _blocks-1) { + } else if(index < blocks_-1) { return getBlockLength(); } else { return 0; @@ -145,14 +145,14 @@ size_t BitfieldMan::getBlockLength(size_t index) const bool BitfieldMan::hasMissingPiece (const unsigned char* peerBitfield, size_t length) const { - if(_bitfieldLength != length) { + if(bitfieldLength_ != length) { return false; } bool retval = false; - for(size_t i = 0; i < _bitfieldLength; ++i) { - unsigned char temp = peerBitfield[i] & ~_bitfield[i]; - if(_filterEnabled) { - temp &= _filterBitfield[i]; + for(size_t i = 0; i < bitfieldLength_; ++i) { + unsigned char temp = peerBitfield[i] & ~bitfield_[i]; + if(filterEnabled_) { + temp &= filterBitfield_[i]; } if(temp&0xff) { retval = true; @@ -164,37 +164,37 @@ bool BitfieldMan::hasMissingPiece bool BitfieldMan::getFirstMissingUnusedIndex(size_t& index) const { - if(_filterEnabled) { + if(filterEnabled_) { return bitfield::getFirstMissingIndex - (index, ~array(_bitfield)&~array(_useBitfield)&array(_filterBitfield), - _blocks); + (index, ~array(bitfield_)&~array(useBitfield_)&array(filterBitfield_), + blocks_); } else { return bitfield::getFirstMissingIndex - (index, ~array(_bitfield)&~array(_useBitfield), _blocks); + (index, ~array(bitfield_)&~array(useBitfield_), blocks_); } } size_t BitfieldMan::getFirstNMissingUnusedIndex (std::vector<size_t>& out, size_t n) const { - if(_filterEnabled) { + if(filterEnabled_) { return bitfield::getFirstNMissingIndex (std::back_inserter(out), n, - ~array(_bitfield)&~array(_useBitfield)&array(_filterBitfield), _blocks); + ~array(bitfield_)&~array(useBitfield_)&array(filterBitfield_), blocks_); } else { return bitfield::getFirstNMissingIndex (std::back_inserter(out), n, - ~array(_bitfield)&~array(_useBitfield), _blocks); + ~array(bitfield_)&~array(useBitfield_), blocks_); } } bool BitfieldMan::getFirstMissingIndex(size_t& index) const { - if(_filterEnabled) { + if(filterEnabled_) { return bitfield::getFirstMissingIndex - (index, ~array(_bitfield)&array(_filterBitfield), _blocks); + (index, ~array(bitfield_)&array(filterBitfield_), blocks_); } else { - return bitfield::getFirstMissingIndex(index, ~array(_bitfield), _blocks); + return bitfield::getFirstMissingIndex(index, ~array(bitfield_), blocks_); } } @@ -262,14 +262,14 @@ bool BitfieldMan::getSparseMissingUnusedIndex const unsigned char* ignoreBitfield, size_t ignoreBitfieldLength) const { - if(_filterEnabled) { + if(filterEnabled_) { return aria2::getSparseMissingUnusedIndex - (index, array(ignoreBitfield)|~array(_filterBitfield)|array(_bitfield)|array(_useBitfield), - _useBitfield, _blocks); + (index, array(ignoreBitfield)|~array(filterBitfield_)|array(bitfield_)|array(useBitfield_), + useBitfield_, blocks_); } else { return aria2::getSparseMissingUnusedIndex - (index, array(ignoreBitfield)|array(_bitfield)|array(_useBitfield), - _useBitfield, _blocks); + (index, array(ignoreBitfield)|array(bitfield_)|array(useBitfield_), + useBitfield_, blocks_); } } @@ -290,12 +290,12 @@ static bool copyBitfield(unsigned char* dst, const Array& src, size_t blocks) bool BitfieldMan::getAllMissingIndexes(unsigned char* misbitfield, size_t len) const { - assert(len == _bitfieldLength); - if(_filterEnabled) { + assert(len == bitfieldLength_); + if(filterEnabled_) { return copyBitfield - (misbitfield, ~array(_bitfield)&array(_filterBitfield), _blocks); + (misbitfield, ~array(bitfield_)&array(filterBitfield_), blocks_); } else { - return copyBitfield(misbitfield, ~array(_bitfield), _blocks); + return copyBitfield(misbitfield, ~array(bitfield_), blocks_); } } @@ -303,19 +303,19 @@ bool BitfieldMan::getAllMissingIndexes(unsigned char* misbitfield, size_t len, const unsigned char* peerBitfield, size_t peerBitfieldLength) const { - assert(len == _bitfieldLength); - if(_bitfieldLength != peerBitfieldLength) { + assert(len == bitfieldLength_); + if(bitfieldLength_ != peerBitfieldLength) { return false; } - if(_filterEnabled) { + if(filterEnabled_) { return copyBitfield (misbitfield, - ~array(_bitfield)&array(peerBitfield)&array(_filterBitfield), - _blocks); + ~array(bitfield_)&array(peerBitfield)&array(filterBitfield_), + blocks_); } else { return copyBitfield - (misbitfield, ~array(_bitfield)&array(peerBitfield), - _blocks); + (misbitfield, ~array(bitfield_)&array(peerBitfield), + blocks_); } } @@ -324,52 +324,52 @@ bool BitfieldMan::getAllMissingUnusedIndexes(unsigned char* misbitfield, const unsigned char* peerBitfield, size_t peerBitfieldLength) const { - assert(len == _bitfieldLength); - if(_bitfieldLength != peerBitfieldLength) { + assert(len == bitfieldLength_); + if(bitfieldLength_ != peerBitfieldLength) { return false; } - if(_filterEnabled) { + if(filterEnabled_) { return copyBitfield (misbitfield, - ~array(_bitfield)&~array(_useBitfield)&array(peerBitfield)& - array(_filterBitfield), - _blocks); + ~array(bitfield_)&~array(useBitfield_)&array(peerBitfield)& + array(filterBitfield_), + blocks_); } else { return copyBitfield (misbitfield, - ~array(_bitfield)&~array(_useBitfield)&array(peerBitfield), - _blocks); + ~array(bitfield_)&~array(useBitfield_)&array(peerBitfield), + blocks_); } } size_t BitfieldMan::countMissingBlock() const { - return _cachedNumMissingBlock; + return cachedNumMissingBlock_; } size_t BitfieldMan::countMissingBlockNow() const { - if(_filterEnabled) { - array_ptr<unsigned char> temp(new unsigned char[_bitfieldLength]); - for(size_t i = 0; i < _bitfieldLength; ++i) { - temp[i] = _bitfield[i]&_filterBitfield[i]; + if(filterEnabled_) { + array_ptr<unsigned char> temp(new unsigned char[bitfieldLength_]); + for(size_t i = 0; i < bitfieldLength_; ++i) { + temp[i] = bitfield_[i]&filterBitfield_[i]; } - size_t count = bitfield::countSetBit(_filterBitfield, _blocks)- - bitfield::countSetBit(temp, _blocks); + size_t count = bitfield::countSetBit(filterBitfield_, blocks_)- + bitfield::countSetBit(temp, blocks_); return count; } else { - return _blocks-bitfield::countSetBit(_bitfield, _blocks); + return blocks_-bitfield::countSetBit(bitfield_, blocks_); } } size_t BitfieldMan::countFilteredBlockNow() const { - if(_filterEnabled) { - return bitfield::countSetBit(_filterBitfield, _blocks); + if(filterEnabled_) { + return bitfield::countSetBit(filterBitfield_, blocks_); } else { return 0; } } bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on) { - if(_blocks <= index) { return false; } + if(blocks_ <= index) { return false; } unsigned char mask = 128 >> (index%8); if(on) { bitfield[index/8] |= mask; @@ -380,29 +380,29 @@ bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on) } bool BitfieldMan::setUseBit(size_t index) { - return setBitInternal(_useBitfield, index, true); + return setBitInternal(useBitfield_, index, true); } bool BitfieldMan::unsetUseBit(size_t index) { - return setBitInternal(_useBitfield, index, false); + return setBitInternal(useBitfield_, index, false); } bool BitfieldMan::setBit(size_t index) { - bool b = setBitInternal(_bitfield, index, true); + bool b = setBitInternal(bitfield_, index, true); updateCache(); return b; } bool BitfieldMan::unsetBit(size_t index) { - bool b = setBitInternal(_bitfield, index, false); + bool b = setBitInternal(bitfield_, index, false); updateCache(); return b; } bool BitfieldMan::isFilteredAllBitSet() const { - if(_filterEnabled) { - for(size_t i = 0; i < _bitfieldLength; ++i) { - if((_bitfield[i]&_filterBitfield[i]) != _filterBitfield[i]) { + if(filterEnabled_) { + for(size_t i = 0; i < bitfieldLength_; ++i) { + if((bitfield_[i]&filterBitfield_[i]) != filterBitfield_[i]) { return false; } } @@ -428,77 +428,77 @@ static bool testAllBitSet bool BitfieldMan::isAllBitSet() const { - return testAllBitSet(_bitfield, _bitfieldLength, _blocks); + return testAllBitSet(bitfield_, bitfieldLength_, blocks_); } bool BitfieldMan::isAllFilterBitSet() const { - if(!_filterBitfield) { + if(!filterBitfield_) { return false; } - return testAllBitSet(_filterBitfield, _bitfieldLength, _blocks); + return testAllBitSet(filterBitfield_, bitfieldLength_, blocks_); } bool BitfieldMan::isBitSet(size_t index) const { - return bitfield::test(_bitfield, _blocks, index); + return bitfield::test(bitfield_, blocks_, index); } bool BitfieldMan::isUseBitSet(size_t index) const { - return bitfield::test(_useBitfield, _blocks, index); + return bitfield::test(useBitfield_, blocks_, index); } void BitfieldMan::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) { - if(_bitfieldLength != bitfieldLength) { + if(bitfieldLength_ != bitfieldLength) { return; } - memcpy(_bitfield, bitfield, _bitfieldLength); - memset(_useBitfield, 0, _bitfieldLength); + memcpy(bitfield_, bitfield, bitfieldLength_); + memset(useBitfield_, 0, bitfieldLength_); updateCache(); } void BitfieldMan::clearAllBit() { - memset(_bitfield, 0, _bitfieldLength); + memset(bitfield_, 0, bitfieldLength_); updateCache(); } void BitfieldMan::setAllBit() { - for(size_t i = 0; i < _blocks; ++i) { - setBitInternal(_bitfield, i, true); + for(size_t i = 0; i < blocks_; ++i) { + setBitInternal(bitfield_, i, true); } updateCache(); } void BitfieldMan::clearAllUseBit() { - memset(_useBitfield, 0, _bitfieldLength); + memset(useBitfield_, 0, bitfieldLength_); updateCache(); } void BitfieldMan::setAllUseBit() { - for(size_t i = 0; i < _blocks; ++i) { - setBitInternal(_useBitfield, i, true); + for(size_t i = 0; i < blocks_; ++i) { + setBitInternal(useBitfield_, i, true); } } bool BitfieldMan::setFilterBit(size_t index) { - return setBitInternal(_filterBitfield, index, true); + return setBitInternal(filterBitfield_, index, true); } void BitfieldMan::ensureFilterBitfield() { - if(!_filterBitfield) { - _filterBitfield = new unsigned char[_bitfieldLength]; - memset(_filterBitfield, 0, _bitfieldLength); + if(!filterBitfield_) { + filterBitfield_ = new unsigned char[bitfieldLength_]; + memset(filterBitfield_, 0, bitfieldLength_); } } void BitfieldMan::addFilter(uint64_t offset, uint64_t length) { ensureFilterBitfield(); if(length > 0) { - size_t startBlock = offset/_blockLength; - size_t endBlock = (offset+length-1)/_blockLength; - for(size_t i = startBlock; i <= endBlock && i < _blocks; i++) { + size_t startBlock = offset/blockLength_; + size_t endBlock = (offset+length-1)/blockLength_; + for(size_t i = startBlock; i <= endBlock && i < blocks_; i++) { setFilterBit(i); } } @@ -508,10 +508,10 @@ void BitfieldMan::addFilter(uint64_t offset, uint64_t length) { void BitfieldMan::removeFilter(uint64_t offset, uint64_t length) { ensureFilterBitfield(); if(length > 0) { - size_t startBlock = offset/_blockLength; - size_t endBlock = (offset+length-1)/_blockLength; - for(size_t i = startBlock; i <= endBlock && i < _blocks; i++) { - setBitInternal(_filterBitfield, i, false); + size_t startBlock = offset/blockLength_; + size_t endBlock = (offset+length-1)/blockLength_; + for(size_t i = startBlock; i <= endBlock && i < blocks_; i++) { + setBitInternal(filterBitfield_, i, false); } } updateCache(); @@ -520,16 +520,16 @@ void BitfieldMan::removeFilter(uint64_t offset, uint64_t length) { void BitfieldMan::addNotFilter(uint64_t offset, uint64_t length) { ensureFilterBitfield(); - if(length > 0 && _blocks > 0) { - size_t startBlock = offset/_blockLength; - if(_blocks <= startBlock) { - startBlock = _blocks; + if(length > 0 && blocks_ > 0) { + size_t startBlock = offset/blockLength_; + if(blocks_ <= startBlock) { + startBlock = blocks_; } - size_t endBlock = (offset+length-1)/_blockLength; + size_t endBlock = (offset+length-1)/blockLength_; for(size_t i = 0; i < startBlock; ++i) { setFilterBit(i); } - for(size_t i = endBlock+1; i < _blocks; ++i) { + for(size_t i = endBlock+1; i < blocks_; ++i) { setFilterBit(i); } } @@ -538,61 +538,61 @@ void BitfieldMan::addNotFilter(uint64_t offset, uint64_t length) void BitfieldMan::enableFilter() { ensureFilterBitfield(); - _filterEnabled = true; + filterEnabled_ = true; updateCache(); } void BitfieldMan::disableFilter() { - _filterEnabled = false; + filterEnabled_ = false; updateCache(); } void BitfieldMan::clearFilter() { - if(_filterBitfield) { - delete [] _filterBitfield; - _filterBitfield = 0; + if(filterBitfield_) { + delete [] filterBitfield_; + filterBitfield_ = 0; } - _filterEnabled = false; + filterEnabled_ = false; updateCache(); } uint64_t BitfieldMan::getFilteredTotalLengthNow() const { - if(!_filterBitfield) { + if(!filterBitfield_) { return 0; } - size_t filteredBlocks = bitfield::countSetBit(_filterBitfield, _blocks); + size_t filteredBlocks = bitfield::countSetBit(filterBitfield_, blocks_); if(filteredBlocks == 0) { return 0; } - if(bitfield::test(_filterBitfield, _blocks, _blocks-1)) { - return ((uint64_t)filteredBlocks-1)*_blockLength+getLastBlockLength(); + if(bitfield::test(filterBitfield_, blocks_, blocks_-1)) { + return ((uint64_t)filteredBlocks-1)*blockLength_+getLastBlockLength(); } else { - return ((uint64_t)filteredBlocks)*_blockLength; + return ((uint64_t)filteredBlocks)*blockLength_; } } uint64_t BitfieldMan::getCompletedLength(bool useFilter) const { unsigned char* temp; if(useFilter) { - temp = new unsigned char[_bitfieldLength]; - for(size_t i = 0; i < _bitfieldLength; ++i) { - temp[i] = _bitfield[i]; - if(_filterEnabled) { - temp[i] &= _filterBitfield[i]; + temp = new unsigned char[bitfieldLength_]; + for(size_t i = 0; i < bitfieldLength_; ++i) { + temp[i] = bitfield_[i]; + if(filterEnabled_) { + temp[i] &= filterBitfield_[i]; } } } else { - temp = _bitfield; + temp = bitfield_; } - size_t completedBlocks = bitfield::countSetBit(temp, _blocks); + size_t completedBlocks = bitfield::countSetBit(temp, blocks_); uint64_t completedLength = 0; if(completedBlocks == 0) { completedLength = 0; } else { - if(bitfield::test(temp, _blocks, _blocks-1)) { - completedLength = ((uint64_t)completedBlocks-1)*_blockLength+getLastBlockLength(); + if(bitfield::test(temp, blocks_, blocks_-1)) { + completedLength = ((uint64_t)completedBlocks-1)*blockLength_+getLastBlockLength(); } else { - completedLength = ((uint64_t)completedBlocks)*_blockLength; + completedLength = ((uint64_t)completedBlocks)*blockLength_; } } if(useFilter) { @@ -611,11 +611,11 @@ uint64_t BitfieldMan::getFilteredCompletedLengthNow() const { void BitfieldMan::updateCache() { - _cachedNumMissingBlock = countMissingBlockNow(); - _cachedNumFilteredBlock = countFilteredBlockNow(); - _cachedFilteredTotalLength = getFilteredTotalLengthNow(); - _cachedCompletedLength = getCompletedLengthNow(); - _cachedFilteredCompletedLength = getFilteredCompletedLengthNow(); + cachedNumMissingBlock_ = countMissingBlockNow(); + cachedNumFilteredBlock_ = countFilteredBlockNow(); + cachedFilteredTotalLength_ = getFilteredTotalLengthNow(); + cachedCompletedLength_ = getCompletedLengthNow(); + cachedFilteredCompletedLength_ = getFilteredCompletedLengthNow(); } bool BitfieldMan::isBitRangeSet(size_t startIndex, size_t endIndex) const @@ -649,14 +649,14 @@ bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const if(length <= 0) { return false; } - if(_totalLength <= offset) { + if(totalLength_ <= offset) { return false; } - if(_totalLength < offset+length) { - length = _totalLength-offset; + if(totalLength_ < offset+length) { + length = totalLength_-offset; } - size_t startBlock = offset/_blockLength; - size_t endBlock = (offset+length-1)/_blockLength; + size_t startBlock = offset/blockLength_; + size_t endBlock = (offset+length-1)/blockLength_; for(size_t i = startBlock; i <= endBlock; i++) { if(!isBitSet(i)) { return false; @@ -667,11 +667,11 @@ bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const uint64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const { - if(startingIndex < 0 || _blocks <= startingIndex) { + if(startingIndex < 0 || blocks_ <= startingIndex) { return 0; } uint64_t length = 0; - for(size_t i = startingIndex; i < _blocks; ++i) { + for(size_t i = startingIndex; i < blocks_; ++i) { if(isBitSet(i) || isUseBitSet(i)) { break; } diff --git a/src/BitfieldMan.h b/src/BitfieldMan.h index 6001684d..c08812e8 100644 --- a/src/BitfieldMan.h +++ b/src/BitfieldMan.h @@ -45,21 +45,21 @@ namespace aria2 { class BitfieldMan { private: - size_t _blockLength; - uint64_t _totalLength; - size_t _bitfieldLength; - size_t _blocks; - bool _filterEnabled; - unsigned char* _bitfield; - unsigned char* _useBitfield; - unsigned char* _filterBitfield; + size_t blockLength_; + uint64_t totalLength_; + size_t bitfieldLength_; + size_t blocks_; + bool filterEnabled_; + unsigned char* bitfield_; + unsigned char* useBitfield_; + unsigned char* filterBitfield_; // for caching - size_t _cachedNumMissingBlock; - size_t _cachedNumFilteredBlock; - uint64_t _cachedCompletedLength; - uint64_t _cachedFilteredCompletedLength; - uint64_t _cachedFilteredTotalLength; + size_t cachedNumMissingBlock_; + size_t cachedNumFilteredBlock_; + uint64_t cachedCompletedLength_; + uint64_t cachedFilteredCompletedLength_; + uint64_t cachedFilteredTotalLength_; bool setBitInternal(unsigned char* bitfield, size_t index, bool on); bool setFilterBit(size_t index); @@ -69,7 +69,7 @@ private: uint64_t getCompletedLength(bool useFilter) const; - // If _filterBitfield is 0, allocate _bitfieldLength bytes to it and + // If filterBitfield_ is 0, allocate bitfieldLength_ bytes to it and // set 0 to all bytes. void ensureFilterBitfield(); public: @@ -102,19 +102,19 @@ public: size_t getBlockLength() const { - return _blockLength; + return blockLength_; } size_t getLastBlockLength() const { - return _totalLength-_blockLength*(_blocks-1); + return totalLength_-blockLength_*(blocks_-1); } size_t getBlockLength(size_t index) const; - uint64_t getTotalLength() const { return _totalLength; } + uint64_t getTotalLength() const { return totalLength_; } - // Returns true iff there is a bit index which is set in _bitfield, + // Returns true iff there is a bit index which is set in bitfield_, // but not set in this object. // // affected by filter @@ -181,23 +181,23 @@ public: const unsigned char* getBitfield() const { - return _bitfield; + return bitfield_; } size_t getBitfieldLength() const { - return _bitfieldLength; + return bitfieldLength_; } // affected by filter size_t countFilteredBlock() const { - return _cachedNumFilteredBlock; + return cachedNumFilteredBlock_; } size_t countBlock() const { - return _blocks; + return blocks_; } // affected by filter @@ -205,7 +205,7 @@ public: size_t getMaxIndex() const { - return _blocks-1; + return blocks_-1; } void setBitfield(const unsigned char* bitfield, size_t bitfieldLength); @@ -228,13 +228,13 @@ public: void disableFilter(); bool isFilterEnabled() const { - return _filterEnabled; + return filterEnabled_; } // affected by filter uint64_t getFilteredTotalLength() const { - return _cachedFilteredTotalLength; + return cachedFilteredTotalLength_; } // affected by filter @@ -242,7 +242,7 @@ public: uint64_t getCompletedLength() const { - return _cachedCompletedLength; + return cachedCompletedLength_; } uint64_t getCompletedLengthNow() const; @@ -250,7 +250,7 @@ public: // affected by filter uint64_t getFilteredCompletedLength() const { - return _cachedFilteredCompletedLength; + return cachedFilteredCompletedLength_; } // affected by filter @@ -270,7 +270,7 @@ public: const unsigned char* getFilterBitfield() const { - return _filterBitfield; + return filterBitfield_; } }; diff --git a/src/BtAbortOutstandingRequestEvent.h b/src/BtAbortOutstandingRequestEvent.h index ef43ebd4..8b147d0c 100644 --- a/src/BtAbortOutstandingRequestEvent.h +++ b/src/BtAbortOutstandingRequestEvent.h @@ -43,12 +43,12 @@ namespace aria2 { class BtAbortOutstandingRequestEvent { private: - SharedHandle<Piece> _piece; + SharedHandle<Piece> piece_; public: BtAbortOutstandingRequestEvent(const SharedHandle<Piece>& piece): - _piece(piece) {} + piece_(piece) {} - const SharedHandle<Piece>& getPiece() const { return _piece; } + const SharedHandle<Piece>& getPiece() const { return piece_; } }; } // namespace aria2 diff --git a/src/BtBitfieldMessage.cc b/src/BtBitfieldMessage.cc index a4df38da..0aca2d32 100644 --- a/src/BtBitfieldMessage.cc +++ b/src/BtBitfieldMessage.cc @@ -50,33 +50,33 @@ namespace aria2 { const std::string BtBitfieldMessage::NAME("bitfield"); BtBitfieldMessage::BtBitfieldMessage():SimpleBtMessage(ID, NAME), - _bitfield(0), - _bitfieldLength(0) + bitfield_(0), + bitfieldLength_(0) {} BtBitfieldMessage::BtBitfieldMessage (const unsigned char* bitfield, size_t bitfieldLength): SimpleBtMessage(ID, NAME), - _bitfield(0), - _bitfieldLength(0) + bitfield_(0), + bitfieldLength_(0) { setBitfield(bitfield, bitfieldLength); } BtBitfieldMessage::~BtBitfieldMessage() { - delete [] _bitfield; + delete [] bitfield_; } void BtBitfieldMessage::setBitfield (const unsigned char* bitfield, size_t bitfieldLength) { - if(_bitfield == bitfield) { + if(bitfield_ == bitfield) { return; } - delete [] _bitfield; - _bitfieldLength = bitfieldLength; - _bitfield = new unsigned char[_bitfieldLength]; - memcpy(_bitfield, bitfield, _bitfieldLength); + delete [] bitfield_; + bitfieldLength_ = bitfieldLength; + bitfield_ = new unsigned char[bitfieldLength_]; + memcpy(bitfield_, bitfield, bitfieldLength_); } BtBitfieldMessageHandle @@ -93,9 +93,9 @@ void BtBitfieldMessage::doReceivedAction() { if(isMetadataGetMode()) { return; } - getPieceStorage()->updatePieceStats(_bitfield, _bitfieldLength, + getPieceStorage()->updatePieceStats(bitfield_, bitfieldLength_, getPeer()->getBitfield()); - getPeer()->setBitfield(_bitfield, _bitfieldLength); + getPeer()->setBitfield(bitfield_, bitfieldLength_); if(getPeer()->isSeeder() && getPieceStorage()->downloadFinished()) { throw DL_ABORT_EX(MSG_GOOD_BYE_SEEDER); } @@ -108,19 +108,19 @@ unsigned char* BtBitfieldMessage::createMessage() { * bitfield --- bitfield, len bytes * total: 5+len bytes */ - const size_t msgLength = 5+_bitfieldLength; + const size_t msgLength = 5+bitfieldLength_; unsigned char* msg = new unsigned char[msgLength]; - bittorrent::createPeerMessageString(msg, msgLength, 1+_bitfieldLength, ID); - memcpy(msg+5, _bitfield, _bitfieldLength); + bittorrent::createPeerMessageString(msg, msgLength, 1+bitfieldLength_, ID); + memcpy(msg+5, bitfield_, bitfieldLength_); return msg; } size_t BtBitfieldMessage::getMessageLength() { - return 5+_bitfieldLength; + return 5+bitfieldLength_; } std::string BtBitfieldMessage::toString() const { - return strconcat(NAME, " ", util::toHex(_bitfield, _bitfieldLength)); + return strconcat(NAME, " ", util::toHex(bitfield_, bitfieldLength_)); } } // namespace aria2 diff --git a/src/BtBitfieldMessage.h b/src/BtBitfieldMessage.h index b7f6d207..7b526de0 100644 --- a/src/BtBitfieldMessage.h +++ b/src/BtBitfieldMessage.h @@ -45,8 +45,8 @@ typedef SharedHandle<BtBitfieldMessage> BtBitfieldMessageHandle; class BtBitfieldMessage : public SimpleBtMessage { private: - unsigned char* _bitfield; - size_t _bitfieldLength; + unsigned char* bitfield_; + size_t bitfieldLength_; public: BtBitfieldMessage(); @@ -60,9 +60,9 @@ public: void setBitfield(const unsigned char* bitfield, size_t bitfieldLength); - const unsigned char* getBitfield() const { return _bitfield; } + const unsigned char* getBitfield() const { return bitfield_; } - size_t getBitfieldLength() const { return _bitfieldLength; } + size_t getBitfieldLength() const { return bitfieldLength_; } static BtBitfieldMessageHandle create (const unsigned char* data, size_t dataLength); diff --git a/src/BtBitfieldMessageValidator.h b/src/BtBitfieldMessageValidator.h index 6b4fc9c8..63099e65 100644 --- a/src/BtBitfieldMessageValidator.h +++ b/src/BtBitfieldMessageValidator.h @@ -43,19 +43,19 @@ namespace aria2 { class BtBitfieldMessageValidator : public BtMessageValidator { private: - const BtBitfieldMessage* _message; - size_t _numPiece; + const BtBitfieldMessage* message_; + size_t numPiece_; public: BtBitfieldMessageValidator(const BtBitfieldMessage* message, size_t numPiece): - _message(message), - _numPiece(numPiece) {} + message_(message), + numPiece_(numPiece) {} virtual void validate() { - bittorrent::checkBitfield(_message->getBitfield(), - _message->getBitfieldLength(), - _numPiece); + bittorrent::checkBitfield(message_->getBitfield(), + message_->getBitfieldLength(), + numPiece_); } }; diff --git a/src/BtCancelSendingPieceEvent.h b/src/BtCancelSendingPieceEvent.h index 0c592999..260bb723 100644 --- a/src/BtCancelSendingPieceEvent.h +++ b/src/BtCancelSendingPieceEvent.h @@ -41,18 +41,18 @@ namespace aria2 { class BtCancelSendingPieceEvent { private: - size_t _index; - uint32_t _begin; - size_t _length; + size_t index_; + uint32_t begin_; + size_t length_; public: BtCancelSendingPieceEvent(size_t index, uint32_t begin, size_t length): - _index(index), _begin(begin), _length(length) {} + index_(index), begin_(begin), length_(length) {} - size_t getIndex() const { return _index; } + size_t getIndex() const { return index_; } - uint32_t getBegin() const { return _begin; } + uint32_t getBegin() const { return begin_; } - size_t getLength() const { return _length; } + size_t getLength() const { return length_; } }; } // namespace aria2 diff --git a/src/BtDependency.cc b/src/BtDependency.cc index 54ac6125..61719ffd 100644 --- a/src/BtDependency.cc +++ b/src/BtDependency.cc @@ -53,9 +53,9 @@ namespace aria2 { BtDependency::BtDependency(const WeakHandle<RequestGroup>& dependant, const SharedHandle<RequestGroup>& dependee): - _dependant(dependant), - _dependee(dependee), - _logger(LogFactory::getInstance()) {} + dependant_(dependant), + dependee_(dependee), + logger_(LogFactory::getInstance()) {} BtDependency::~BtDependency() {} @@ -73,12 +73,12 @@ static void copyValues(const SharedHandle<FileEntry>& d, bool BtDependency::resolve() { - if(_dependee->getNumCommand() == 0 && _dependee->downloadFinished()) { - SharedHandle<RequestGroup> dependee = _dependee; + if(dependee_->getNumCommand() == 0 && dependee_->downloadFinished()) { + SharedHandle<RequestGroup> dependee = dependee_; // cut reference here - _dependee.reset(); + dependee_.reset(); SharedHandle<DownloadContext> context(new DownloadContext()); - context->setDir(_dependant->getDownloadContext()->getDir()); + context->setDir(dependant_->getDownloadContext()->getDir()); try { SharedHandle<DiskAdaptor> diskAdaptor = dependee->getPieceStorage()->getDiskAdaptor(); @@ -96,7 +96,7 @@ bool BtDependency::resolve() const std::vector<SharedHandle<FileEntry> >& fileEntries = context->getFileEntries(); const std::vector<SharedHandle<FileEntry> >& dependantFileEntries = - _dependant->getDownloadContext()->getFileEntries(); + dependant_->getDownloadContext()->getFileEntries(); // If dependant's FileEntry::getOriginalName() is empty, we // assume that torrent is single file. In Metalink3, this is // always assumed. @@ -106,9 +106,9 @@ bool BtDependency::resolve() } else { std::for_each(fileEntries.begin(), fileEntries.end(), std::bind2nd(mem_fun_sh(&FileEntry::setRequested),false)); - // Copy file path in _dependant's FileEntries to newly created + // Copy file path in dependant_'s FileEntries to newly created // context's FileEntries to endorse the path structure of - // _dependant. URIs and singleHostMultiConnection are also copied. + // dependant_. URIs and singleHostMultiConnection are also copied. std::vector<SharedHandle<FileEntry> >::const_iterator ctxFilesEnd = fileEntries.end(); for(std::vector<SharedHandle<FileEntry> >::const_iterator s = @@ -130,26 +130,26 @@ bool BtDependency::resolve() } } } catch(RecoverableException& e) { - _logger->error(EX_EXCEPTION_CAUGHT, e); - if(_logger->info()) { - _logger->info("BtDependency for GID#%s failed. Go without Bt.", - util::itos(_dependant->getGID()).c_str()); + logger_->error(EX_EXCEPTION_CAUGHT, e); + if(logger_->info()) { + logger_->info("BtDependency for GID#%s failed. Go without Bt.", + util::itos(dependant_->getGID()).c_str()); } return true; } - if(_logger->info()) { - _logger->info("Dependency resolved for GID#%s", - util::itos(_dependant->getGID()).c_str()); + if(logger_->info()) { + logger_->info("Dependency resolved for GID#%s", + util::itos(dependant_->getGID()).c_str()); } - _dependant->setDownloadContext(context); + dependant_->setDownloadContext(context); return true; - } else if(_dependee->getNumCommand() == 0) { - // _dependee's download failed. + } else if(dependee_->getNumCommand() == 0) { + // dependee_'s download failed. // cut reference here - _dependee.reset(); - if(_logger->info()) { - _logger->info("BtDependency for GID#%s failed. Go without Bt.", - util::itos(_dependant->getGID()).c_str()); + dependee_.reset(); + if(logger_->info()) { + logger_->info("BtDependency for GID#%s failed. Go without Bt.", + util::itos(dependant_->getGID()).c_str()); } return true; } else { diff --git a/src/BtDependency.h b/src/BtDependency.h index a59424b8..98d61670 100644 --- a/src/BtDependency.h +++ b/src/BtDependency.h @@ -46,9 +46,9 @@ class Logger; class BtDependency : public Dependency { private: - WeakHandle<RequestGroup> _dependant; - SharedHandle<RequestGroup> _dependee; - Logger* _logger; + WeakHandle<RequestGroup> dependant_; + SharedHandle<RequestGroup> dependee_; + Logger* logger_; public: BtDependency(const WeakHandle<RequestGroup>& dependant, const SharedHandle<RequestGroup>& dependee); diff --git a/src/BtExtendedMessage.cc b/src/BtExtendedMessage.cc index 714f4bcc..480888d8 100644 --- a/src/BtExtendedMessage.cc +++ b/src/BtExtendedMessage.cc @@ -54,8 +54,8 @@ const std::string BtExtendedMessage::NAME("extended"); BtExtendedMessage::BtExtendedMessage (const ExtensionMessageHandle& extensionMessage): SimpleBtMessage(ID, NAME), - _extensionMessage(extensionMessage), - _msgLength(0) + extensionMessage_(extensionMessage), + msgLength_(0) {} unsigned char* BtExtendedMessage::createMessage() @@ -67,20 +67,20 @@ unsigned char* BtExtendedMessage::createMessage() * extpayload --- extpayload, nbytes * total: 6+extpayload.length bytes */ - std::string payload = _extensionMessage->getPayload(); - _msgLength = 6+payload.size(); - unsigned char* msg = new unsigned char[_msgLength]; - bittorrent::createPeerMessageString(msg, _msgLength, 2+payload.size(), ID); - *(msg+5) = _extensionMessage->getExtensionMessageID(); + std::string payload = extensionMessage_->getPayload(); + msgLength_ = 6+payload.size(); + unsigned char* msg = new unsigned char[msgLength_]; + bittorrent::createPeerMessageString(msg, msgLength_, 2+payload.size(), ID); + *(msg+5) = extensionMessage_->getExtensionMessageID(); memcpy(msg+6, payload.data(), payload.size()); return msg; } size_t BtExtendedMessage::getMessageLength() { - if(!_msgLength) { - _msgLength = 6+_extensionMessage->getPayload().size(); + if(!msgLength_) { + msgLength_ = 6+extensionMessage_->getPayload().size(); } - return _msgLength; + return msgLength_; } bool BtExtendedMessage::sendPredicate() const @@ -89,7 +89,7 @@ bool BtExtendedMessage::sendPredicate() const } std::string BtExtendedMessage::toString() const { - return strconcat(NAME, " ", _extensionMessage->toString()); + return strconcat(NAME, " ", extensionMessage_->toString()); } BtExtendedMessageHandle @@ -108,8 +108,8 @@ BtExtendedMessage::create(const SharedHandle<ExtensionMessageFactory>& factory, void BtExtendedMessage::doReceivedAction() { - if(!_extensionMessage.isNull()) { - _extensionMessage->doReceivedAction(); + if(!extensionMessage_.isNull()) { + extensionMessage_->doReceivedAction(); } } diff --git a/src/BtExtendedMessage.h b/src/BtExtendedMessage.h index a4bcdc03..62cb7fc1 100644 --- a/src/BtExtendedMessage.h +++ b/src/BtExtendedMessage.h @@ -47,9 +47,9 @@ typedef SharedHandle<BtExtendedMessage> BtExtendedMessageHandle; class BtExtendedMessage:public SimpleBtMessage { private: - SharedHandle<ExtensionMessage> _extensionMessage; + SharedHandle<ExtensionMessage> extensionMessage_; - size_t _msgLength; + size_t msgLength_; public: BtExtendedMessage(const SharedHandle<ExtensionMessage>& extensionMessage = SharedHandle<ExtensionMessage>()); @@ -76,7 +76,7 @@ public: const SharedHandle<ExtensionMessage>& getExtensionMessage() const { - return _extensionMessage; + return extensionMessage_; } }; diff --git a/src/BtHandshakeMessage.cc b/src/BtHandshakeMessage.cc index 40d7a29b..bd209250 100644 --- a/src/BtHandshakeMessage.cc +++ b/src/BtHandshakeMessage.cc @@ -57,44 +57,44 @@ BtHandshakeMessage::BtHandshakeMessage(const unsigned char* infoHash, SimpleBtMessage(ID, NAME) { init(); - memcpy(_infoHash, infoHash, INFO_HASH_LENGTH); - memcpy(_peerId, peerId, PEER_ID_LENGTH); + memcpy(infoHash_, infoHash, INFO_HASH_LENGTH); + memcpy(peerId_, peerId, PEER_ID_LENGTH); } void BtHandshakeMessage::init() { - _pstrlen = 19; - _pstr = new unsigned char[PSTR_LENGTH]; - _reserved = new unsigned char[RESERVED_LENGTH]; - _infoHash = new unsigned char[INFO_HASH_LENGTH]; - _peerId = new unsigned char[PEER_ID_LENGTH]; - memcpy(_pstr, BT_PSTR, PSTR_LENGTH); - memset(_reserved, 0, RESERVED_LENGTH); + pstrlen_ = 19; + pstr_ = new unsigned char[PSTR_LENGTH]; + reserved_ = new unsigned char[RESERVED_LENGTH]; + infoHash_ = new unsigned char[INFO_HASH_LENGTH]; + peerId_ = new unsigned char[PEER_ID_LENGTH]; + memcpy(pstr_, BT_PSTR, PSTR_LENGTH); + memset(reserved_, 0, RESERVED_LENGTH); // fast extension - _reserved[7] |= 0x04; + reserved_[7] |= 0x04; // extended messaging - _reserved[5] |= 0x10; + reserved_[5] |= 0x10; } SharedHandle<BtHandshakeMessage> BtHandshakeMessage::create(const unsigned char* data, size_t dataLength) { SharedHandle<BtHandshakeMessage> message(new BtHandshakeMessage()); - message->_pstrlen = data[0]; - memcpy(message->_pstr, &data[1], PSTR_LENGTH); - memcpy(message->_reserved, &data[20], RESERVED_LENGTH); - memcpy(message->_infoHash, &data[28], INFO_HASH_LENGTH); - memcpy(message->_peerId, &data[48], PEER_ID_LENGTH); + message->pstrlen_ = data[0]; + memcpy(message->pstr_, &data[1], PSTR_LENGTH); + memcpy(message->reserved_, &data[20], RESERVED_LENGTH); + memcpy(message->infoHash_, &data[28], INFO_HASH_LENGTH); + memcpy(message->peerId_, &data[48], PEER_ID_LENGTH); return message; } unsigned char* BtHandshakeMessage::createMessage() { unsigned char* msg = new unsigned char[MESSAGE_LENGTH]; - msg[0] = _pstrlen; - memcpy(msg+1, _pstr, PSTR_LENGTH); - memcpy(msg+20, _reserved, RESERVED_LENGTH); - memcpy(msg+28, _infoHash, INFO_HASH_LENGTH); - memcpy(msg+48, _peerId, PEER_ID_LENGTH); + msg[0] = pstrlen_; + memcpy(msg+1, pstr_, PSTR_LENGTH); + memcpy(msg+20, reserved_, RESERVED_LENGTH); + memcpy(msg+28, infoHash_, INFO_HASH_LENGTH); + memcpy(msg+48, peerId_, PEER_ID_LENGTH); return msg; } @@ -104,33 +104,33 @@ size_t BtHandshakeMessage::getMessageLength() { std::string BtHandshakeMessage::toString() const { return strconcat(NAME, " peerId=", - util::percentEncode(_peerId, PEER_ID_LENGTH), + util::percentEncode(peerId_, PEER_ID_LENGTH), ", reserved=", - util::toHex(_reserved, RESERVED_LENGTH)); + util::toHex(reserved_, RESERVED_LENGTH)); } bool BtHandshakeMessage::isFastExtensionSupported() const { - return _reserved[7]&0x04; + return reserved_[7]&0x04; } bool BtHandshakeMessage::isExtendedMessagingEnabled() const { - return _reserved[5]&0x10; + return reserved_[5]&0x10; } bool BtHandshakeMessage::isDHTEnabled() const { - return _reserved[7]&0x01; + return reserved_[7]&0x01; } void BtHandshakeMessage::setInfoHash(const unsigned char* infoHash) { - memcpy(_infoHash, infoHash, INFO_HASH_LENGTH); + memcpy(infoHash_, infoHash, INFO_HASH_LENGTH); } void BtHandshakeMessage::setPeerId(const unsigned char* peerId) { - memcpy(_peerId, peerId, PEER_ID_LENGTH); + memcpy(peerId_, peerId, PEER_ID_LENGTH); } } // namespace aria2 diff --git a/src/BtHandshakeMessage.h b/src/BtHandshakeMessage.h index 5ff52d72..b52b10f8 100644 --- a/src/BtHandshakeMessage.h +++ b/src/BtHandshakeMessage.h @@ -46,11 +46,11 @@ public: static const size_t RESERVED_LENGTH = 8; static const size_t MESSAGE_LENGTH = 68; private: - uint8_t _pstrlen; - unsigned char* _pstr; - unsigned char* _reserved; - unsigned char* _infoHash; - unsigned char* _peerId; + uint8_t pstrlen_; + unsigned char* pstr_; + unsigned char* reserved_; + unsigned char* infoHash_; + unsigned char* peerId_; void init(); public: BtHandshakeMessage(); @@ -64,10 +64,10 @@ public: create(const unsigned char* data, size_t dataLength); virtual ~BtHandshakeMessage() { - delete [] _pstr; - delete [] _reserved; - delete [] _infoHash; - delete [] _peerId; + delete [] pstr_; + delete [] reserved_; + delete [] infoHash_; + delete [] peerId_; } static const uint8_t ID = INT8_MAX; @@ -91,32 +91,32 @@ public: void setDHTEnabled(bool enabled) { if(enabled) { - _reserved[7] |= 0x01; + reserved_[7] |= 0x01; } else { - _reserved[7] &= ~0x01; + reserved_[7] &= ~0x01; } } uint8_t getPstrlen() const { - return _pstrlen; + return pstrlen_; } const unsigned char* getPstr() const { - return _pstr; + return pstr_; } const unsigned char* getReserved() const { - return _reserved; + return reserved_; } const unsigned char* getInfoHash() const { - return _infoHash; + return infoHash_; } void setInfoHash(const unsigned char* infoHash); const unsigned char* getPeerId() const { - return _peerId; + return peerId_; } void setPeerId(const unsigned char* peerId); diff --git a/src/BtHandshakeMessageValidator.h b/src/BtHandshakeMessageValidator.h index 28f51694..49aef027 100644 --- a/src/BtHandshakeMessageValidator.h +++ b/src/BtHandshakeMessageValidator.h @@ -48,33 +48,33 @@ namespace aria2 { class BtHandshakeMessageValidator : public BtMessageValidator { private: - const BtHandshakeMessage* _message; - unsigned char _infoHash[INFO_HASH_LENGTH]; + const BtHandshakeMessage* message_; + unsigned char infoHash_[INFO_HASH_LENGTH]; public: BtHandshakeMessageValidator(const BtHandshakeMessage* message, const unsigned char* infoHash): - _message(message) + message_(message) { - memcpy(_infoHash, infoHash, sizeof(_infoHash)); + memcpy(infoHash_, infoHash, sizeof(infoHash_)); } virtual void validate() { - if(_message->getPstrlen() != 19) { + if(message_->getPstrlen() != 19) { throw DL_ABORT_EX(StringFormat("invalid handshake pstrlen=%u", - _message->getPstrlen()).str()); + message_->getPstrlen()).str()); } - if(memcmp(BtHandshakeMessage::BT_PSTR, _message->getPstr(), 19) != 0) { + if(memcmp(BtHandshakeMessage::BT_PSTR, message_->getPstr(), 19) != 0) { throw DL_ABORT_EX (StringFormat("invalid handshake pstr=%s", util::percentEncode - (_message->getPstr(), 19).c_str()).str()); + (message_->getPstr(), 19).c_str()).str()); } - if(memcmp(_infoHash, _message->getInfoHash(), sizeof(_infoHash)) != 0) { + if(memcmp(infoHash_, message_->getInfoHash(), sizeof(infoHash_)) != 0) { throw DL_ABORT_EX (StringFormat("invalid handshake info hash: expected:%s, actual:%s", - util::toHex(_infoHash, sizeof(_infoHash)).c_str(), - util::toHex(_message->getInfoHash(), + util::toHex(infoHash_, sizeof(infoHash_)).c_str(), + util::toHex(message_->getInfoHash(), INFO_HASH_LENGTH).c_str()).str()); } } diff --git a/src/BtInterestedMessage.cc b/src/BtInterestedMessage.cc index f3308669..683769f5 100644 --- a/src/BtInterestedMessage.cc +++ b/src/BtInterestedMessage.cc @@ -55,7 +55,7 @@ void BtInterestedMessage::doReceivedAction() } getPeer()->peerInterested(true); if(!getPeer()->amChoking()) { - _peerStorage->executeChoke(); + peerStorage_->executeChoke(); } } @@ -71,7 +71,7 @@ void BtInterestedMessage::onSendComplete() { void BtInterestedMessage::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } } // namespace aria2 diff --git a/src/BtInterestedMessage.h b/src/BtInterestedMessage.h index 1b3a1d40..af31d74f 100644 --- a/src/BtInterestedMessage.h +++ b/src/BtInterestedMessage.h @@ -46,7 +46,7 @@ typedef SharedHandle<BtInterestedMessage> BtInterestedMessageHandle; class BtInterestedMessage : public ZeroBtMessage { private: - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; public: BtInterestedMessage(); diff --git a/src/BtLeecherStateChoke.cc b/src/BtLeecherStateChoke.cc index f211eeba..23b44f76 100644 --- a/src/BtLeecherStateChoke.cc +++ b/src/BtLeecherStateChoke.cc @@ -45,77 +45,77 @@ namespace aria2 { BtLeecherStateChoke::BtLeecherStateChoke(): - _round(0), - _lastRound(0), - _logger(LogFactory::getInstance()) {} + round_(0), + lastRound_(0), + logger_(LogFactory::getInstance()) {} BtLeecherStateChoke::~BtLeecherStateChoke() {} BtLeecherStateChoke::PeerEntry::PeerEntry(const SharedHandle<Peer>& peer): - _peer(peer), _downloadSpeed(peer->calculateDownloadSpeed()), + peer_(peer), downloadSpeed_(peer->calculateDownloadSpeed()), // peer must be interested to us and sent block in the last 30 seconds - _regularUnchoker + regularUnchoker_ (peer->peerInterested() && peer->getLastDownloadUpdate().difference(global::wallclock) < 30) {} const SharedHandle<Peer>& BtLeecherStateChoke::PeerEntry::getPeer() const { - return _peer; + return peer_; } unsigned int BtLeecherStateChoke::PeerEntry::getDownloadSpeed() const { - return _downloadSpeed; + return downloadSpeed_; } bool BtLeecherStateChoke::PeerEntry::isRegularUnchoker() const { - return _regularUnchoker; + return regularUnchoker_; } void BtLeecherStateChoke::PeerEntry::enableChokingRequired() { - _peer->chokingRequired(true); + peer_->chokingRequired(true); } void BtLeecherStateChoke::PeerEntry::disableChokingRequired() { - _peer->chokingRequired(false); + peer_->chokingRequired(false); } void BtLeecherStateChoke::PeerEntry::enableOptUnchoking() { - _peer->optUnchoking(true); + peer_->optUnchoking(true); } void BtLeecherStateChoke::PeerEntry::disableOptUnchoking() { - _peer->optUnchoking(false); + peer_->optUnchoking(false); } bool BtLeecherStateChoke::PeerEntry::isSnubbing() const { - return _peer->snubbing(); + return peer_->snubbing(); } bool BtLeecherStateChoke::PeerEntry::operator<(const PeerEntry& peerEntry) const { - return _downloadSpeed > peerEntry._downloadSpeed; + return downloadSpeed_ > peerEntry.downloadSpeed_; } class PeerFilter { private: - bool _amChoking; - bool _peerInterested; + bool amChoking_; + bool peerInterested_; public: PeerFilter(bool amChoking, bool peerInterested): - _amChoking(amChoking), - _peerInterested(peerInterested) {} + amChoking_(amChoking), + peerInterested_(peerInterested) {} bool operator()(const BtLeecherStateChoke::PeerEntry& peerEntry) const { - return peerEntry.getPeer()->amChoking() == _amChoking && - peerEntry.getPeer()->peerInterested() == _peerInterested; + return peerEntry.getPeer()->amChoking() == amChoking_ && + peerEntry.getPeer()->peerInterested() == peerInterested_; } }; @@ -132,7 +132,7 @@ void BtLeecherStateChoke::plannedOptimisticUnchoke std::random_shuffle(peerEntries.begin(), i, *(SimpleRandomizer::getInstance().get())); (*peerEntries.begin()).enableOptUnchoking(); - _logger->info + logger_->info ("POU: %s", (*peerEntries.begin()).getPeer()->getIPAddress().c_str()); } } @@ -152,7 +152,7 @@ void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries) std::vector<PeerEntry>::iterator peerIter = peerEntries.begin(); for(;peerIter != rest && count; ++peerIter, --count) { (*peerIter).disableChokingRequired(); - _logger->info("RU: %s, dlspd=%u", + logger_->info("RU: %s, dlspd=%u", (*peerIter).getPeer()->getIPAddress().c_str(), (*peerIter).getDownloadSpeed()); if((*peerIter).getPeer()->optUnchoking()) { @@ -167,11 +167,11 @@ void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries) eoi = peerEntries.end(); i != eoi; ++i) { if((*i).getPeer()->peerInterested()) { (*i).enableOptUnchoking(); - _logger->info("OU: %s", (*i).getPeer()->getIPAddress().c_str()); + logger_->info("OU: %s", (*i).getPeer()->getIPAddress().c_str()); break; } else { (*i).disableChokingRequired(); - _logger->info("OU: %s", (*i).getPeer()->getIPAddress().c_str()); + logger_->info("OU: %s", (*i).getPeer()->getIPAddress().c_str()); } } } @@ -190,8 +190,8 @@ void BtLeecherStateChoke::executeChoke (const std::vector<SharedHandle<Peer> >& peerSet) { - _logger->info("Leecher state, %d choke round started", _round); - _lastRound = global::wallclock; + logger_->info("Leecher state, %d choke round started", round_); + lastRound_ = global::wallclock; std::vector<PeerEntry> peerEntries; std::transform(peerSet.begin(), peerSet.end(), @@ -206,19 +206,19 @@ BtLeecherStateChoke::executeChoke std::mem_fun_ref(&PeerEntry::enableChokingRequired)); // planned optimistic unchoke - if(_round == 0) { + if(round_ == 0) { plannedOptimisticUnchoke(peerEntries); } regularUnchoke(peerEntries); - if(++_round == 3) { - _round = 0; + if(++round_ == 3) { + round_ = 0; } } const Timer& BtLeecherStateChoke::getLastRound() const { - return _lastRound; + return lastRound_; } } // namespace aria2 diff --git a/src/BtLeecherStateChoke.h b/src/BtLeecherStateChoke.h index 89914bec..43762efd 100644 --- a/src/BtLeecherStateChoke.h +++ b/src/BtLeecherStateChoke.h @@ -49,17 +49,17 @@ class Logger; class BtLeecherStateChoke { private: - int _round; + int round_; - Timer _lastRound; + Timer lastRound_; - Logger* _logger; + Logger* logger_; class PeerEntry { private: - SharedHandle<Peer> _peer; - unsigned int _downloadSpeed; - bool _regularUnchoker; + SharedHandle<Peer> peer_; + unsigned int downloadSpeed_; + bool regularUnchoker_; public: PeerEntry(const SharedHandle<Peer>& peer); diff --git a/src/BtMessage.h b/src/BtMessage.h index 970e7514..1c3503fd 100644 --- a/src/BtMessage.h +++ b/src/BtMessage.h @@ -50,9 +50,9 @@ class BtEvent; class BtMessage { private: - uint8_t _id; + uint8_t id_; public: - BtMessage(uint8_t id):_id(id) {} + BtMessage(uint8_t id):id_(id) {} virtual ~BtMessage() {} @@ -62,7 +62,7 @@ public: virtual bool isUploading() = 0; - uint8_t getId() { return _id; } + uint8_t getId() { return id_; } virtual void doReceivedAction() = 0; diff --git a/src/BtNotInterestedMessage.cc b/src/BtNotInterestedMessage.cc index c0adb3a3..c3cdd305 100644 --- a/src/BtNotInterestedMessage.cc +++ b/src/BtNotInterestedMessage.cc @@ -55,7 +55,7 @@ void BtNotInterestedMessage::doReceivedAction() } getPeer()->peerInterested(false); if(!getPeer()->amChoking()) { - _peerStorage->executeChoke(); + peerStorage_->executeChoke(); } } @@ -71,7 +71,7 @@ void BtNotInterestedMessage::onSendComplete() { void BtNotInterestedMessage::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } } // namespace aria2 diff --git a/src/BtNotInterestedMessage.h b/src/BtNotInterestedMessage.h index a3761dfd..67d64945 100644 --- a/src/BtNotInterestedMessage.h +++ b/src/BtNotInterestedMessage.h @@ -46,7 +46,7 @@ typedef SharedHandle<BtNotInterestedMessage> BtNotInterestedMessageHandle; class BtNotInterestedMessage : public ZeroBtMessage { private: - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; public: BtNotInterestedMessage(); diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc index f14ef6d3..a0355d58 100644 --- a/src/BtPieceMessage.cc +++ b/src/BtPieceMessage.cc @@ -62,25 +62,25 @@ const std::string BtPieceMessage::NAME("piece"); BtPieceMessage::BtPieceMessage (size_t index, uint32_t begin, size_t blockLength): AbstractBtMessage(ID, NAME), - _index(index), - _begin(begin), - _blockLength(blockLength), - _block(0), - _rawData(0) + index_(index), + begin_(begin), + blockLength_(blockLength), + block_(0), + rawData_(0) { setUploading(true); } BtPieceMessage::~BtPieceMessage() { - delete [] _rawData; + delete [] rawData_; } void BtPieceMessage::setRawMessage(unsigned char* data) { - delete [] _rawData; - _rawData = data; - _block = data+9; + delete [] rawData_; + rawData_ = data; + block_ = data+9; } BtPieceMessageHandle BtPieceMessage::create @@ -101,27 +101,27 @@ void BtPieceMessage::doReceivedAction() return; } RequestSlot slot = getBtMessageDispatcher()->getOutstandingRequest - (_index, _begin, _blockLength); - getPeer()->updateDownloadLength(_blockLength); + (index_, begin_, blockLength_); + getPeer()->updateDownloadLength(blockLength_); if(!RequestSlot::isNull(slot)) { getPeer()->snubbing(false); - SharedHandle<Piece> piece = getPieceStorage()->getPiece(_index); - off_t offset = (off_t)_index*_downloadContext->getPieceLength()+_begin; + SharedHandle<Piece> piece = getPieceStorage()->getPiece(index_); + off_t offset = (off_t)index_*downloadContext_->getPieceLength()+begin_; if(getLogger()->debug()) { getLogger()->debug(MSG_PIECE_RECEIVED, util::itos(getCuid()).c_str(), - _index, _begin, _blockLength, offset, + index_, begin_, blockLength_, offset, slot.getBlockIndex()); } getPieceStorage()->getDiskAdaptor()->writeData - (_block, _blockLength, offset); + (block_, blockLength_, offset); piece->completeBlock(slot.getBlockIndex()); if(getLogger()->debug()) { getLogger()->debug(MSG_PIECE_BITFIELD, util::itos(getCuid()).c_str(), util::toHex(piece->getBitfield(), piece->getBitfieldLength()).c_str()); } - piece->updateHash(_begin, _block, _blockLength); + piece->updateHash(begin_, block_, blockLength_); getBtMessageDispatcher()->removeOutstandingRequest(slot); if(piece->pieceComplete()) { if(checkPieceHash(piece)) { @@ -133,7 +133,7 @@ void BtPieceMessage::doReceivedAction() } else { if(getLogger()->debug()) { getLogger()->debug("CUID#%s - RequestSlot not found, index=%d, begin=%d", - util::itos(getCuid()).c_str(), _index, _begin); + util::itos(getCuid()).c_str(), index_, begin_); } } } @@ -151,9 +151,9 @@ unsigned char* BtPieceMessage::createMessageHeader() */ unsigned char* msgHeader = new unsigned char[MESSAGE_HEADER_LENGTH]; bittorrent::createPeerMessageString(msgHeader, MESSAGE_HEADER_LENGTH, - 9+_blockLength, ID); - bittorrent::setIntParam(&msgHeader[5], _index); - bittorrent::setIntParam(&msgHeader[9], _begin); + 9+blockLength_, ID); + bittorrent::setIntParam(&msgHeader[5], index_); + bittorrent::setIntParam(&msgHeader[9], begin_); return msgHeader; } @@ -180,13 +180,13 @@ void BtPieceMessage::send() size_t msgHdrLen = getMessageHeaderLength(); if(getLogger()->debug()) { getLogger()->debug("msglength = %lu bytes", - static_cast<unsigned long>(msgHdrLen+_blockLength)); + static_cast<unsigned long>(msgHdrLen+blockLength_)); } getPeerConnection()->pushBytes(msgHdr, msgHdrLen); getPeerConnection()->sendPendingData(); off_t pieceDataOffset = - (off_t)_index*_downloadContext->getPieceLength()+_begin; - writtenLength = sendPieceData(pieceDataOffset, _blockLength); + (off_t)index_*downloadContext_->getPieceLength()+begin_; + writtenLength = sendPieceData(pieceDataOffset, blockLength_); } else { writtenLength = getPeerConnection()->sendPendingData(); } @@ -215,8 +215,8 @@ size_t BtPieceMessage::sendPieceData(off_t offset, size_t length) const std::string BtPieceMessage::toString() const { - return strconcat(NAME, " index=", util::itos(_index), ", begin=", - util::itos(_begin), ", length=", util::itos(_blockLength)); + return strconcat(NAME, " index=", util::itos(index_), ", begin=", + util::itos(begin_), ", length=", util::itos(blockLength_)); } bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece) @@ -227,13 +227,13 @@ bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece) static_cast<unsigned long>(piece->getIndex())); } return - piece->getHashString()==_downloadContext->getPieceHash(piece->getIndex()); + piece->getHashString()==downloadContext_->getPieceHash(piece->getIndex()); } else { - off_t offset = (off_t)piece->getIndex()*_downloadContext->getPieceLength(); + off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength(); return MessageDigestHelper::staticSHA1Digest (getPieceStorage()->getDiskAdaptor(), offset, piece->getLength()) - == _downloadContext->getPieceHash(piece->getIndex()); + == downloadContext_->getPieceHash(piece->getIndex()); } } @@ -264,7 +264,7 @@ void BtPieceMessage::erasePieceOnDisk(const SharedHandle<Piece>& piece) size_t BUFSIZE = 4096; unsigned char buf[BUFSIZE]; memset(buf, 0, BUFSIZE); - off_t offset = (off_t)piece->getIndex()*_downloadContext->getPieceLength(); + off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength(); div_t res = div(piece->getLength(), BUFSIZE); for(int i = 0; i < res.quot; ++i) { getPieceStorage()->getDiskAdaptor()->writeData(buf, BUFSIZE, offset); @@ -279,16 +279,16 @@ void BtPieceMessage::onChokingEvent(const BtChokingEvent& event) { if(!isInvalidate() && !isSendingInProgress() && - !getPeer()->isInAmAllowedIndexSet(_index)) { + !getPeer()->isInAmAllowedIndexSet(index_)) { if(getLogger()->debug()) { getLogger()->debug(MSG_REJECT_PIECE_CHOKED, util::itos(getCuid()).c_str(), - _index, _begin, _blockLength); + index_, begin_, blockLength_); } if(getPeer()->isFastExtensionEnabled()) { BtMessageHandle rej = getBtMessageFactory()->createRejectMessage - (_index, _begin, _blockLength); + (index_, begin_, blockLength_); getBtMessageDispatcher()->addMessageToQueue(rej); } setInvalidate(true); @@ -300,18 +300,18 @@ void BtPieceMessage::onCancelSendingPieceEvent { if(!isInvalidate() && !isSendingInProgress() && - _index == event.getIndex() && - _begin == event.getBegin() && - _blockLength == event.getLength()) { + index_ == event.getIndex() && + begin_ == event.getBegin() && + blockLength_ == event.getLength()) { if(getLogger()->debug()) { getLogger()->debug(MSG_REJECT_PIECE_CANCEL, util::itos(getCuid()).c_str(), - _index, _begin, _blockLength); + index_, begin_, blockLength_); } if(getPeer()->isFastExtensionEnabled()) { BtMessageHandle rej = getBtMessageFactory()->createRejectMessage - (_index, _begin, _blockLength); + (index_, begin_, blockLength_); getBtMessageDispatcher()->addMessageToQueue(rej); } setInvalidate(true); @@ -321,7 +321,7 @@ void BtPieceMessage::onCancelSendingPieceEvent void BtPieceMessage::setDownloadContext (const SharedHandle<DownloadContext>& downloadContext) { - _downloadContext = downloadContext; + downloadContext_ = downloadContext; } } // namespace aria2 diff --git a/src/BtPieceMessage.h b/src/BtPieceMessage.h index 5b106935..7f83ae68 100644 --- a/src/BtPieceMessage.h +++ b/src/BtPieceMessage.h @@ -47,12 +47,12 @@ typedef SharedHandle<BtPieceMessage> BtPieceMessageHandle; class BtPieceMessage : public AbstractBtMessage { private: - size_t _index; - uint32_t _begin; - uint32_t _blockLength; - unsigned char* _block; - unsigned char* _rawData; - SharedHandle<DownloadContext> _downloadContext; + size_t index_; + uint32_t begin_; + uint32_t blockLength_; + unsigned char* block_; + unsigned char* rawData_; + SharedHandle<DownloadContext> downloadContext_; static size_t MESSAGE_HEADER_LENGTH; @@ -74,24 +74,24 @@ public: static const std::string NAME; - size_t getIndex() const { return _index; } + size_t getIndex() const { return index_; } - void setIndex(size_t index) { _index = index; } + void setIndex(size_t index) { index_ = index; } - uint32_t getBegin() const { return _begin; } + uint32_t getBegin() const { return begin_; } - void setBegin(uint32_t begin) { _begin = begin; } + void setBegin(uint32_t begin) { begin_ = begin; } - const unsigned char* getBlock() const { return _block; } + const unsigned char* getBlock() const { return block_; } - size_t getBlockLength() const { return _blockLength; } + size_t getBlockLength() const { return blockLength_; } // Stores raw message data. After this function call, this object // has ownership of data. Caller must not be free or alter data. // Member block is pointed to block starting position in data. void setRawMessage(unsigned char* data); - void setBlockLength(size_t blockLength) { _blockLength = blockLength; } + void setBlockLength(size_t blockLength) { blockLength_ = blockLength; } void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext); diff --git a/src/BtPieceMessageValidator.h b/src/BtPieceMessageValidator.h index abc202db..2560b8bd 100644 --- a/src/BtPieceMessageValidator.h +++ b/src/BtPieceMessageValidator.h @@ -43,21 +43,21 @@ namespace aria2 { class BtPieceMessageValidator : public BtMessageValidator { private: - const BtPieceMessage* _message; - size_t _numPiece; - size_t _pieceLength; + const BtPieceMessage* message_; + size_t numPiece_; + size_t pieceLength_; public: BtPieceMessageValidator(const BtPieceMessage* message, size_t numPiece, size_t pieceLength): - _message(message), - _numPiece(numPiece), - _pieceLength(pieceLength) {} + message_(message), + numPiece_(numPiece), + pieceLength_(pieceLength) {} virtual void validate() { - bittorrent::checkIndex(_message->getIndex(), _numPiece); - bittorrent::checkBegin(_message->getBegin(), _pieceLength); + bittorrent::checkIndex(message_->getIndex(), numPiece_); + bittorrent::checkBegin(message_->getBegin(), pieceLength_); } }; diff --git a/src/BtPortMessage.cc b/src/BtPortMessage.cc index fffd16b9..881a4cb8 100644 --- a/src/BtPortMessage.cc +++ b/src/BtPortMessage.cc @@ -52,7 +52,7 @@ namespace aria2 { const std::string BtPortMessage::NAME("port"); BtPortMessage::BtPortMessage(uint16_t port): - SimpleBtMessage(ID, NAME), _port(port) {} + SimpleBtMessage(ID, NAME), port_(port) {} SharedHandle<BtPortMessage> BtPortMessage::create (const unsigned char* data, size_t dataLength) @@ -66,8 +66,8 @@ SharedHandle<BtPortMessage> BtPortMessage::create void BtPortMessage::doReceivedAction() { - if(!_taskFactory.isNull() && !_taskQueue.isNull()) { - if(_port == 0) { + if(!taskFactory_.isNull() && !taskQueue_.isNull()) { + if(port_ == 0) { if(getLogger()->debug()) { getLogger()->debug("Ignored port 0."); } @@ -77,16 +77,16 @@ void BtPortMessage::doReceivedAction() // instance created with proper node ID and is added to a routing table. SharedHandle<DHTNode> node(new DHTNode()); node->setIPAddress(getPeer()->getIPAddress()); - node->setPort(_port); + node->setPort(port_); { - SharedHandle<DHTTask> task = _taskFactory->createPingTask(node); - _taskQueue->addImmediateTask(task); + SharedHandle<DHTTask> task = taskFactory_->createPingTask(node); + taskQueue_->addImmediateTask(task); } - if(_routingTable->countBucket() == 1) { + if(routingTable_->countBucket() == 1) { // initiate bootstrap getLogger()->info("Dispatch node_lookup since too few buckets."); - _taskQueue->addImmediateTask - (_taskFactory->createNodeLookupTask(_localNode->getID())); + taskQueue_->addImmediateTask + (taskFactory_->createNodeLookupTask(localNode_->getID())); } } else { getLogger()->info @@ -104,7 +104,7 @@ unsigned char* BtPortMessage::createMessage() */ unsigned char* msg = new unsigned char[MESSAGE_LENGTH]; bittorrent::createPeerMessageString(msg, MESSAGE_LENGTH, 3, ID); - bittorrent::setShortIntParam(&msg[5], _port); + bittorrent::setShortIntParam(&msg[5], port_); return msg; } @@ -113,27 +113,27 @@ size_t BtPortMessage::getMessageLength() { } std::string BtPortMessage::toString() const { - return strconcat(NAME, " port=", util::uitos(_port)); + return strconcat(NAME, " port=", util::uitos(port_)); } void BtPortMessage::setLocalNode(const WeakHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } void BtPortMessage::setRoutingTable(const WeakHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void BtPortMessage::setTaskQueue(const WeakHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void BtPortMessage::setTaskFactory(const WeakHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } } // namespace aria2 diff --git a/src/BtPortMessage.h b/src/BtPortMessage.h index 6faa4185..e91c2dfd 100644 --- a/src/BtPortMessage.h +++ b/src/BtPortMessage.h @@ -46,16 +46,16 @@ class DHTTaskFactory; class BtPortMessage : public SimpleBtMessage { private: - uint16_t _port; + uint16_t port_; static const size_t MESSAGE_LENGTH = 7; - WeakHandle<DHTNode> _localNode; + WeakHandle<DHTNode> localNode_; - WeakHandle<DHTRoutingTable> _routingTable; + WeakHandle<DHTRoutingTable> routingTable_; - WeakHandle<DHTTaskQueue> _taskQueue; + WeakHandle<DHTTaskQueue> taskQueue_; - WeakHandle<DHTTaskFactory> _taskFactory; + WeakHandle<DHTTaskFactory> taskFactory_; public: BtPortMessage(uint16_t port); @@ -63,7 +63,7 @@ public: static const std::string NAME; - uint16_t getPort() const { return _port; } + uint16_t getPort() const { return port_; } static SharedHandle<BtPortMessage> create (const unsigned char* data, size_t dataLength); diff --git a/src/BtRegistry.cc b/src/BtRegistry.cc index debfb0b1..e6b938c9 100644 --- a/src/BtRegistry.cc +++ b/src/BtRegistry.cc @@ -47,18 +47,18 @@ namespace aria2 { SharedHandle<DownloadContext> BtRegistry::getDownloadContext(gid_t gid) const { - return get(gid)._downloadContext; + return get(gid).downloadContext_; } SharedHandle<DownloadContext> BtRegistry::getDownloadContext(const std::string& infoHash) const { SharedHandle<DownloadContext> dctx; - for(std::map<gid_t, BtObject>::const_iterator i = _pool.begin(), - eoi = _pool.end(); i != eoi; ++i) { - if(bittorrent::getTorrentAttrs((*i).second._downloadContext)->infoHash == + for(std::map<gid_t, BtObject>::const_iterator i = pool_.begin(), + eoi = pool_.end(); i != eoi; ++i) { + if(bittorrent::getTorrentAttrs((*i).second.downloadContext_)->infoHash == infoHash) { - dctx = (*i).second._downloadContext; + dctx = (*i).second.downloadContext_; break; } } @@ -67,13 +67,13 @@ BtRegistry::getDownloadContext(const std::string& infoHash) const void BtRegistry::put(gid_t gid, const BtObject& obj) { - _pool[gid] = obj; + pool_[gid] = obj; } BtObject BtRegistry::get(gid_t gid) const { - std::map<gid_t, BtObject>::const_iterator i = _pool.find(gid); - if(i == _pool.end()) { + std::map<gid_t, BtObject>::const_iterator i = pool_.find(gid); + if(i == pool_.end()) { return BtObject(); } else { return (*i).second; @@ -82,11 +82,11 @@ BtObject BtRegistry::get(gid_t gid) const bool BtRegistry::remove(gid_t gid) { - return _pool.erase(gid); + return pool_.erase(gid); } void BtRegistry::removeAll() { - _pool.clear(); + pool_.clear(); } } // namespace aria2 diff --git a/src/BtRegistry.h b/src/BtRegistry.h index cb6c0707..36e27d53 100644 --- a/src/BtRegistry.h +++ b/src/BtRegistry.h @@ -52,12 +52,12 @@ class BtProgressInfoFile; class DownloadContext; struct BtObject { - SharedHandle<DownloadContext> _downloadContext; - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<PeerStorage> _peerStorage; - SharedHandle<BtAnnounce> _btAnnounce; - SharedHandle<BtRuntime> _btRuntime; - SharedHandle<BtProgressInfoFile> _btProgressInfoFile; + SharedHandle<DownloadContext> downloadContext_; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<PeerStorage> peerStorage_; + SharedHandle<BtAnnounce> btAnnounce_; + SharedHandle<BtRuntime> btRuntime_; + SharedHandle<BtProgressInfoFile> btProgressInfoFile_; BtObject(const SharedHandle<DownloadContext>& downloadContext, const SharedHandle<PieceStorage>& pieceStorage, @@ -65,29 +65,29 @@ struct BtObject { const SharedHandle<BtAnnounce>& btAnnounce, const SharedHandle<BtRuntime>& btRuntime, const SharedHandle<BtProgressInfoFile>& btProgressInfoFile): - _downloadContext(downloadContext), - _pieceStorage(pieceStorage), - _peerStorage(peerStorage), - _btAnnounce(btAnnounce), - _btRuntime(btRuntime), - _btProgressInfoFile(btProgressInfoFile) {} + downloadContext_(downloadContext), + pieceStorage_(pieceStorage), + peerStorage_(peerStorage), + btAnnounce_(btAnnounce), + btRuntime_(btRuntime), + btProgressInfoFile_(btProgressInfoFile) {} BtObject() {} bool isNull() const { - return _downloadContext.isNull() && - _pieceStorage.isNull() && - _peerStorage.isNull() && - _btAnnounce.isNull() && - _btRuntime.isNull() && - _btProgressInfoFile.isNull(); + return downloadContext_.isNull() && + pieceStorage_.isNull() && + peerStorage_.isNull() && + btAnnounce_.isNull() && + btRuntime_.isNull() && + btProgressInfoFile_.isNull(); } }; class BtRegistry { private: - std::map<gid_t, BtObject> _pool; + std::map<gid_t, BtObject> pool_; public: SharedHandle<DownloadContext> getDownloadContext(gid_t gid) const; @@ -102,9 +102,9 @@ public: template<typename OutputIterator> OutputIterator getAllDownloadContext(OutputIterator dest) { - for(std::map<gid_t, BtObject>::const_iterator i = _pool.begin(), - eoi = _pool.end(); i != eoi; ++i) { - *dest++ = (*i).second._downloadContext; + for(std::map<gid_t, BtObject>::const_iterator i = pool_.begin(), + eoi = pool_.end(); i != eoi; ++i) { + *dest++ = (*i).second.downloadContext_; } return dest; } diff --git a/src/BtRequestMessage.cc b/src/BtRequestMessage.cc index fc4e0df3..e09f7007 100644 --- a/src/BtRequestMessage.cc +++ b/src/BtRequestMessage.cc @@ -46,7 +46,7 @@ const std::string BtRequestMessage::NAME("request"); BtRequestMessage::BtRequestMessage (size_t index, uint32_t begin, uint32_t length, size_t blockIndex): RangeBtMessage(ID, NAME, index, begin, length), - _blockIndex(blockIndex) {} + blockIndex_(blockIndex) {} SharedHandle<BtRequestMessage> BtRequestMessage::create (const unsigned char* data, size_t dataLength) @@ -79,7 +79,7 @@ void BtRequestMessage::doReceivedAction() void BtRequestMessage::onQueued() { - RequestSlot requestSlot(getIndex(), getBegin(), getLength(), _blockIndex, + RequestSlot requestSlot(getIndex(), getBegin(), getLength(), blockIndex_, getPieceStorage()->getPiece(getIndex())); getBtMessageDispatcher()->addOutstandingRequest(requestSlot); } diff --git a/src/BtRequestMessage.h b/src/BtRequestMessage.h index bc0daa2c..c74f4d29 100644 --- a/src/BtRequestMessage.h +++ b/src/BtRequestMessage.h @@ -45,7 +45,7 @@ typedef SharedHandle<BtRequestMessage> BtRequestMessageHandle; class BtRequestMessage : public RangeBtMessage { private: - size_t _blockIndex; + size_t blockIndex_; public: BtRequestMessage(size_t index = 0, uint32_t begin = 0, @@ -56,8 +56,8 @@ public: static const std::string NAME; - size_t getBlockIndex() const { return _blockIndex; } - void setBlockIndex(size_t blockIndex) { _blockIndex = blockIndex; } + size_t getBlockIndex() const { return blockIndex_; } + void setBlockIndex(size_t blockIndex) { blockIndex_ = blockIndex; } static SharedHandle<BtRequestMessage> create (const unsigned char* data, size_t dataLength); diff --git a/src/BtRuntime.h b/src/BtRuntime.h index 1349eb5c..838ab77d 100644 --- a/src/BtRuntime.h +++ b/src/BtRuntime.h @@ -42,90 +42,90 @@ namespace aria2 { class BtRuntime { private: - uint64_t _uploadLengthAtStartup; - uint16_t _port; - bool _halt; - unsigned int _connections; - bool _ready; + uint64_t uploadLengthAtStartup_; + uint16_t port_; + bool halt_; + unsigned int connections_; + bool ready_; // Maximum number of peers to hold connections at the same time. // 0 means unlimited. - unsigned int _maxPeers; + unsigned int maxPeers_; // Minimum number of peers. This value is used for getting more peers from // tracker. 0 means always the number of peers is under minimum. - unsigned int _minPeers; + unsigned int minPeers_; static const unsigned int DEFAULT_MIN_PEERS = 40; public: BtRuntime(): - _uploadLengthAtStartup(0), - _port(0), - _halt(false), - _connections(0), - _ready(false), - _maxPeers(DEFAULT_MAX_PEERS), - _minPeers(DEFAULT_MIN_PEERS) + uploadLengthAtStartup_(0), + port_(0), + halt_(false), + connections_(0), + ready_(false), + maxPeers_(DEFAULT_MAX_PEERS), + minPeers_(DEFAULT_MIN_PEERS) {} ~BtRuntime() {} uint64_t getUploadLengthAtStartup() const { - return _uploadLengthAtStartup; + return uploadLengthAtStartup_; } void setUploadLengthAtStartup(uint64_t length) { - _uploadLengthAtStartup = length; + uploadLengthAtStartup_ = length; } void setListenPort(uint16_t port) { - _port = port; + port_ = port; } - uint16_t getListenPort() const { return _port; } + uint16_t getListenPort() const { return port_; } - bool isHalt() const { return _halt; } + bool isHalt() const { return halt_; } void setHalt(bool halt) { - _halt = halt; + halt_ = halt; } - unsigned int getConnections() const { return _connections; } + unsigned int getConnections() const { return connections_; } - void increaseConnections() { ++_connections; } + void increaseConnections() { ++connections_; } - void decreaseConnections() { --_connections; } + void decreaseConnections() { --connections_; } bool lessThanMaxPeers() const { - return _maxPeers == 0 || _connections < _maxPeers; + return maxPeers_ == 0 || connections_ < maxPeers_; } bool lessThanMinPeers() const { - return _minPeers == 0 || _connections < _minPeers; + return minPeers_ == 0 || connections_ < minPeers_; } bool lessThanEqMinPeers() const { - return _minPeers == 0 || _connections <= _minPeers; + return minPeers_ == 0 || connections_ <= minPeers_; } - bool ready() { return _ready; } + bool ready() { return ready_; } - void setReady(bool go) { _ready = go; } + void setReady(bool go) { ready_ = go; } void setMaxPeers(unsigned int maxPeers) { - _maxPeers = maxPeers; - _minPeers = static_cast<unsigned int>(maxPeers*0.8); - if(_minPeers == 0 && maxPeers != 0) { - _minPeers = maxPeers; + maxPeers_ = maxPeers; + minPeers_ = static_cast<unsigned int>(maxPeers*0.8); + if(minPeers_ == 0 && maxPeers != 0) { + minPeers_ = maxPeers; } } unsigned int getMaxPeers() const { - return _maxPeers; + return maxPeers_; } static const unsigned int DEFAULT_MAX_PEERS = 55; diff --git a/src/BtSeederStateChoke.cc b/src/BtSeederStateChoke.cc index 3d31b5e7..253df636 100644 --- a/src/BtSeederStateChoke.cc +++ b/src/BtSeederStateChoke.cc @@ -45,48 +45,48 @@ namespace aria2 { BtSeederStateChoke::BtSeederStateChoke(): - _round(0), - _lastRound(0), - _logger(LogFactory::getInstance()) {} + round_(0), + lastRound_(0), + logger_(LogFactory::getInstance()) {} BtSeederStateChoke::~BtSeederStateChoke() {} BtSeederStateChoke::PeerEntry::PeerEntry (const SharedHandle<Peer>& peer): - _peer(peer), - _outstandingUpload(peer->countOutstandingUpload()), - _lastAmUnchoking(peer->getLastAmUnchoking()), - _recentUnchoking(_lastAmUnchoking.difference(global::wallclock) < TIME_FRAME), - _uploadSpeed(peer->calculateUploadSpeed()) + peer_(peer), + outstandingUpload_(peer->countOutstandingUpload()), + lastAmUnchoking_(peer->getLastAmUnchoking()), + recentUnchoking_(lastAmUnchoking_.difference(global::wallclock) < TIME_FRAME), + uploadSpeed_(peer->calculateUploadSpeed()) {} bool BtSeederStateChoke::PeerEntry::operator<(const PeerEntry& rhs) const { - if(this->_outstandingUpload && !rhs._outstandingUpload) { + if(this->outstandingUpload_ && !rhs.outstandingUpload_) { return true; - } else if(!this->_outstandingUpload && rhs._outstandingUpload) { + } else if(!this->outstandingUpload_ && rhs.outstandingUpload_) { return false; } - if(this->_recentUnchoking && - (this->_lastAmUnchoking > rhs._lastAmUnchoking)) { + if(this->recentUnchoking_ && + (this->lastAmUnchoking_ > rhs.lastAmUnchoking_)) { return true; - } else if(rhs._recentUnchoking) { + } else if(rhs.recentUnchoking_) { return false; } else { - return this->_uploadSpeed > rhs._uploadSpeed; + return this->uploadSpeed_ > rhs.uploadSpeed_; } } void BtSeederStateChoke::PeerEntry::disableOptUnchoking() { - _peer->optUnchoking(false); + peer_->optUnchoking(false); } void BtSeederStateChoke::unchoke (std::vector<BtSeederStateChoke::PeerEntry>& peers) { - int count = (_round == 2) ? 4 : 3; + int count = (round_ == 2) ? 4 : 3; std::sort(peers.begin(), peers.end()); @@ -94,18 +94,18 @@ void BtSeederStateChoke::unchoke for(std::vector<PeerEntry>::iterator eoi = peers.end(); r != eoi && count; ++r, --count) { (*r).getPeer()->chokingRequired(false); - _logger->info("RU: %s, ulspd=%u", (*r).getPeer()->getIPAddress().c_str(), + logger_->info("RU: %s, ulspd=%u", (*r).getPeer()->getIPAddress().c_str(), (*r).getUploadSpeed()); } - if(_round < 2) { + if(round_ < 2) { std::for_each(peers.begin(), peers.end(), std::mem_fun_ref(&PeerEntry::disableOptUnchoking)); if(r != peers.end()) { std::random_shuffle(r, peers.end(), *(SimpleRandomizer::getInstance().get())); (*r).getPeer()->optUnchoking(true); - _logger->info("POU: %s", (*r).getPeer()->getIPAddress().c_str()); + logger_->info("POU: %s", (*r).getPeer()->getIPAddress().c_str()); } } } @@ -138,8 +138,8 @@ void BtSeederStateChoke::executeChoke (const std::vector<SharedHandle<Peer> >& peerSet) { - _logger->info("Seeder state, %d choke round started", _round); - _lastRound = global::wallclock; + logger_->info("Seeder state, %d choke round started", round_); + lastRound_ = global::wallclock; std::vector<PeerEntry> peerEntries; @@ -154,8 +154,8 @@ BtSeederStateChoke::executeChoke unchoke(peerEntries); - if(++_round == 3) { - _round = 0; + if(++round_ == 3) { + round_ = 0; } } diff --git a/src/BtSeederStateChoke.h b/src/BtSeederStateChoke.h index 932bc3f5..877be8e4 100644 --- a/src/BtSeederStateChoke.h +++ b/src/BtSeederStateChoke.h @@ -49,19 +49,19 @@ class Logger; class BtSeederStateChoke { private: - int _round; + int round_; - Timer _lastRound; + Timer lastRound_; - Logger* _logger; + Logger* logger_; class PeerEntry { private: - SharedHandle<Peer> _peer; - size_t _outstandingUpload; - Timer _lastAmUnchoking; - bool _recentUnchoking; - unsigned int _uploadSpeed; + SharedHandle<Peer> peer_; + size_t outstandingUpload_; + Timer lastAmUnchoking_; + bool recentUnchoking_; + unsigned int uploadSpeed_; const static time_t TIME_FRAME = 20; public: @@ -69,9 +69,9 @@ private: bool operator<(const PeerEntry& rhs) const; - const SharedHandle<Peer>& getPeer() const { return _peer; } + const SharedHandle<Peer>& getPeer() const { return peer_; } - unsigned int getUploadSpeed() const { return _uploadSpeed; } + unsigned int getUploadSpeed() const { return uploadSpeed_; } void disableOptUnchoking(); }; @@ -87,7 +87,7 @@ public: void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet); - const Timer& getLastRound() const { return _lastRound; } + const Timer& getLastRound() const { return lastRound_; } }; } // namespace aria2 diff --git a/src/BtSetup.cc b/src/BtSetup.cc index d3e0115f..f17757e5 100644 --- a/src/BtSetup.cc +++ b/src/BtSetup.cc @@ -77,7 +77,7 @@ namespace aria2 { -BtSetup::BtSetup():_logger(LogFactory::getInstance()) {} +BtSetup::BtSetup():logger_(LogFactory::getInstance()) {} void BtSetup::setup(std::vector<Command*>& commands, RequestGroup* requestGroup, @@ -91,10 +91,10 @@ void BtSetup::setup(std::vector<Command*>& commands, bittorrent::getTorrentAttrs(requestGroup->getDownloadContext()); bool metadataGetMode = torrentAttrs->metadata.empty(); BtObject btObject = e->getBtRegistry()->get(requestGroup->getGID()); - SharedHandle<PieceStorage> pieceStorage = btObject._pieceStorage; - SharedHandle<PeerStorage> peerStorage = btObject._peerStorage; - SharedHandle<BtRuntime> btRuntime = btObject._btRuntime; - SharedHandle<BtAnnounce> btAnnounce = btObject._btAnnounce; + SharedHandle<PieceStorage> pieceStorage = btObject.pieceStorage_; + SharedHandle<PeerStorage> peerStorage = btObject.peerStorage_; + SharedHandle<BtRuntime> btRuntime = btObject.btRuntime_; + SharedHandle<BtAnnounce> btAnnounce = btObject.btAnnounce_; // commands { TrackerWatcherCommand* c = @@ -182,7 +182,7 @@ void BtSetup::setup(std::vector<Command*>& commands, if(option->getAsBool(PREF_BT_ENABLE_LPD) && (metadataGetMode || !torrentAttrs->privateTorrent)) { if(LpdReceiveMessageCommand::getNumInstance() == 0) { - _logger->info("Initializing LpdMessageReceiver."); + logger_->info("Initializing LpdMessageReceiver."); SharedHandle<LpdMessageReceiver> receiver (new LpdMessageReceiver(LPD_MULTICAST_ADDR, LPD_MULTICAST_PORT)); bool initialized = false; @@ -206,7 +206,7 @@ void BtSetup::setup(std::vector<Command*>& commands, } } if(initialized) { - _logger->info("LpdMessageReceiver initialized. multicastAddr=%s:%u," + logger_->info("LpdMessageReceiver initialized. multicastAddr=%s:%u," " localAddr=%s", LPD_MULTICAST_ADDR, LPD_MULTICAST_PORT, receiver->getLocalAddress().c_str()); @@ -214,7 +214,7 @@ void BtSetup::setup(std::vector<Command*>& commands, LpdReceiveMessageCommand::getInstance(e, receiver); e->addCommand(cmd); } else { - _logger->info("LpdMessageReceiver not initialized."); + logger_->info("LpdMessageReceiver not initialized."); } } if(LpdReceiveMessageCommand::getNumInstance()) { @@ -222,20 +222,20 @@ void BtSetup::setup(std::vector<Command*>& commands, bittorrent::getInfoHash(requestGroup->getDownloadContext()); SharedHandle<LpdMessageReceiver> receiver = LpdReceiveMessageCommand::getInstance()->getLpdMessageReceiver(); - _logger->info("Initializing LpdMessageDispatcher."); + logger_->info("Initializing LpdMessageDispatcher."); SharedHandle<LpdMessageDispatcher> dispatcher (new LpdMessageDispatcher (std::string(&infoHash[0], &infoHash[INFO_HASH_LENGTH]), btRuntime->getListenPort(), LPD_MULTICAST_ADDR, LPD_MULTICAST_PORT)); if(dispatcher->init(receiver->getLocalAddress(), /*ttl*/1, /*loop*/0)) { - _logger->info("LpdMessageDispatcher initialized."); + logger_->info("LpdMessageDispatcher initialized."); LpdDispatchMessageCommand* cmd = new LpdDispatchMessageCommand(e->newCUID(), dispatcher, e); cmd->setBtRuntime(btRuntime); e->addCommand(cmd); } else { - _logger->info("LpdMessageDispatcher not initialized."); + logger_->info("LpdMessageDispatcher not initialized."); } } } diff --git a/src/BtSetup.h b/src/BtSetup.h index 2d22fcc9..42e1ae82 100644 --- a/src/BtSetup.h +++ b/src/BtSetup.h @@ -48,7 +48,7 @@ class Command; class BtSetup { private: - Logger* _logger; + Logger* logger_; public: BtSetup(); diff --git a/src/BtStopDownloadCommand.cc b/src/BtStopDownloadCommand.cc index eead280e..867417f5 100644 --- a/src/BtStopDownloadCommand.cc +++ b/src/BtStopDownloadCommand.cc @@ -50,28 +50,28 @@ BtStopDownloadCommand::BtStopDownloadCommand DownloadEngine* e, time_t timeout): TimeBasedCommand(cuid, e, 1), - _requestGroup(requestGroup), - _timeout(timeout) + requestGroup_(requestGroup), + timeout_(timeout) {} void BtStopDownloadCommand::preProcess() { - if(_btRuntime->isHalt() || _pieceStorage->downloadFinished()) { + if(btRuntime_->isHalt() || pieceStorage_->downloadFinished()) { enableExit(); } - if(_checkPoint.difference(global::wallclock) >= _timeout) { + if(checkPoint_.difference(global::wallclock) >= timeout_) { getLogger()->notice("GID#%s Stop downloading torrent due to" " --bt-stop-timeout option.", - util::itos(_requestGroup->getGID()).c_str()); - _requestGroup->setHaltRequested(true); + util::itos(requestGroup_->getGID()).c_str()); + requestGroup_->setHaltRequested(true); enableExit(); } } void BtStopDownloadCommand::process() { - if(_requestGroup->calculateStat().getDownloadSpeed() > 0) { - _checkPoint = global::wallclock; + if(requestGroup_->calculateStat().getDownloadSpeed() > 0) { + checkPoint_ = global::wallclock; } } diff --git a/src/BtStopDownloadCommand.h b/src/BtStopDownloadCommand.h index 715ccbcc..14f1a48e 100644 --- a/src/BtStopDownloadCommand.h +++ b/src/BtStopDownloadCommand.h @@ -44,19 +44,19 @@ class RequestGroup; class PieceStorage; class BtRuntime; -// Stop downloading torrent if in consecutive _timeout seconds, +// Stop downloading torrent if in consecutive timeout_ seconds, // download speed is zero and the number of seeder is 0. class BtStopDownloadCommand:public TimeBasedCommand { private: - RequestGroup* _requestGroup; + RequestGroup* requestGroup_; - time_t _timeout; + time_t timeout_; - Timer _checkPoint; + Timer checkPoint_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; public: BtStopDownloadCommand (cuid_t cuid, @@ -70,12 +70,12 @@ public: void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } }; diff --git a/src/ByteArrayDiskWriter.cc b/src/ByteArrayDiskWriter.cc index 45173d41..b1b1008b 100644 --- a/src/ByteArrayDiskWriter.cc +++ b/src/ByteArrayDiskWriter.cc @@ -44,7 +44,7 @@ ByteArrayDiskWriter::~ByteArrayDiskWriter() {} void ByteArrayDiskWriter::clear() { - _buf.str(A2STR::NIL); + buf_.str(A2STR::NIL); } void ByteArrayDiskWriter::initAndOpenFile(uint64_t totalLength) @@ -65,29 +65,29 @@ void ByteArrayDiskWriter::writeData(const unsigned char* data, size_t dataLength { uint64_t length = size(); if(length < (uint64_t)position) { - _buf.seekp(length, std::ios::beg); + buf_.seekp(length, std::ios::beg); for(uint64_t i = length; i < (uint64_t)position; ++i) { - _buf.put('\0'); + buf_.put('\0'); } } else { - _buf.seekp(position, std::ios::beg); + buf_.seekp(position, std::ios::beg); } - _buf.write(reinterpret_cast<const char*>(data), dataLength); + buf_.write(reinterpret_cast<const char*>(data), dataLength); } ssize_t ByteArrayDiskWriter::readData(unsigned char* data, size_t len, off_t position) { - _buf.seekg(position, std::ios::beg); - _buf.read(reinterpret_cast<char*>(data), len); - _buf.clear(); - return _buf.gcount(); + buf_.seekg(position, std::ios::beg); + buf_.read(reinterpret_cast<char*>(data), len); + buf_.clear(); + return buf_.gcount(); } uint64_t ByteArrayDiskWriter::size() { - _buf.seekg(0, std::ios::end); - _buf.clear(); - return _buf.tellg(); + buf_.seekg(0, std::ios::end); + buf_.clear(); + return buf_.tellg(); } } // namespace aria2 diff --git a/src/ByteArrayDiskWriter.h b/src/ByteArrayDiskWriter.h index b38c9c99..760859ec 100644 --- a/src/ByteArrayDiskWriter.h +++ b/src/ByteArrayDiskWriter.h @@ -42,7 +42,7 @@ namespace aria2 { class ByteArrayDiskWriter : public DiskWriter { private: - std::stringstream _buf; + std::stringstream buf_; void clear(); public: @@ -68,12 +68,12 @@ public: void setString(const std::string& s) { - _buf.str(s); + buf_.str(s); } std::string getString() const { - return _buf.str(); + return buf_.str(); } }; diff --git a/src/CUIDCounter.h b/src/CUIDCounter.h index a6c43b16..1e628a06 100644 --- a/src/CUIDCounter.h +++ b/src/CUIDCounter.h @@ -42,18 +42,18 @@ namespace aria2 { class CUIDCounter { private: - cuid_t _count; + cuid_t count_; public: - CUIDCounter():_count(0) {} + CUIDCounter():count_(0) {} ~CUIDCounter() {} cuid_t newID() { - if(_count == INT64_MAX) { - _count = 0; + if(count_ == INT64_MAX) { + count_ = 0; } - return ++_count; + return ++count_; } }; diff --git a/src/CheckIntegrityCommand.cc b/src/CheckIntegrityCommand.cc index 72087520..6ab47c2c 100644 --- a/src/CheckIntegrityCommand.cc +++ b/src/CheckIntegrityCommand.cc @@ -53,7 +53,7 @@ CheckIntegrityCommand::CheckIntegrityCommand (cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e, const SharedHandle<CheckIntegrityEntry>& entry): RealtimeCommand(cuid, requestGroup, e), - _entry(entry) + entry_(entry) {} CheckIntegrityCommand::~CheckIntegrityCommand() {} @@ -64,8 +64,8 @@ bool CheckIntegrityCommand::executeInternal() getDownloadEngine()->getCheckIntegrityMan()->dropPickedEntry(); return true; } - _entry->validateChunk(); - if(_entry->finished()) { + entry_->validateChunk(); + if(entry_->finished()) { getDownloadEngine()->getCheckIntegrityMan()->dropPickedEntry(); // Enable control file saving here. See also // RequestGroup::processCheckIntegrityEntry() to know why this is @@ -77,7 +77,7 @@ bool CheckIntegrityCommand::executeInternal() getRequestGroup()->getDownloadContext()->getBasePath().c_str()); std::vector<Command*>* commands = new std::vector<Command*>(); auto_delete_container<std::vector<Command*> > commandsDel(commands); - _entry->onDownloadFinished(*commands, getDownloadEngine()); + entry_->onDownloadFinished(*commands, getDownloadEngine()); getDownloadEngine()->addCommand(*commands); commands->clear(); } else { @@ -86,7 +86,7 @@ bool CheckIntegrityCommand::executeInternal() getRequestGroup()->getDownloadContext()->getBasePath().c_str()); std::vector<Command*>* commands = new std::vector<Command*>(); auto_delete_container<std::vector<Command*> > commandsDel(commands); - _entry->onDownloadIncomplete(*commands, getDownloadEngine()); + entry_->onDownloadIncomplete(*commands, getDownloadEngine()); getDownloadEngine()->addCommand(*commands); commands->clear(); } diff --git a/src/CheckIntegrityCommand.h b/src/CheckIntegrityCommand.h index 7f48c725..96f44e32 100644 --- a/src/CheckIntegrityCommand.h +++ b/src/CheckIntegrityCommand.h @@ -44,7 +44,7 @@ class CheckIntegrityEntry; class CheckIntegrityCommand : public RealtimeCommand { private: - SharedHandle<CheckIntegrityEntry> _entry; + SharedHandle<CheckIntegrityEntry> entry_; public: CheckIntegrityCommand(cuid_t cuid, RequestGroup* requestGroup, diff --git a/src/CheckIntegrityEntry.cc b/src/CheckIntegrityEntry.cc index 643cb540..764c0984 100644 --- a/src/CheckIntegrityEntry.cc +++ b/src/CheckIntegrityEntry.cc @@ -56,30 +56,30 @@ CheckIntegrityEntry::~CheckIntegrityEntry() {} void CheckIntegrityEntry::validateChunk() { - _validator->validateChunk(); + validator_->validateChunk(); } uint64_t CheckIntegrityEntry::getTotalLength() { - if(_validator.isNull()) { + if(validator_.isNull()) { return 0; } else { - return _validator->getTotalLength(); + return validator_->getTotalLength(); } } off_t CheckIntegrityEntry::getCurrentLength() { - if(_validator.isNull()) { + if(validator_.isNull()) { return 0; } else { - return _validator->getCurrentOffset(); + return validator_->getCurrentOffset(); } } bool CheckIntegrityEntry::finished() { - return _validator->finished(); + return validator_->finished(); } void CheckIntegrityEntry::cutTrailingGarbage() @@ -106,7 +106,7 @@ void CheckIntegrityEntry::proceedFileAllocation void CheckIntegrityEntry::setValidator (const SharedHandle<IteratableValidator>& validator) { - _validator = validator; + validator_ = validator; } } // namespace aria2 diff --git a/src/CheckIntegrityEntry.h b/src/CheckIntegrityEntry.h index ea322412..9bd1595d 100644 --- a/src/CheckIntegrityEntry.h +++ b/src/CheckIntegrityEntry.h @@ -49,7 +49,7 @@ class FileAllocationEntry; class CheckIntegrityEntry : public RequestGroupEntry, public ProgressAwareEntry { private: - SharedHandle<IteratableValidator> _validator; + SharedHandle<IteratableValidator> validator_; protected: void setValidator(const SharedHandle<IteratableValidator>& validator); diff --git a/src/Checksum.h b/src/Checksum.h index e51dfcc9..38f9c628 100644 --- a/src/Checksum.h +++ b/src/Checksum.h @@ -46,34 +46,34 @@ namespace aria2 { class Checksum { private: - std::string _algo; - std::string _messageDigest; + std::string algo_; + std::string messageDigest_; public: - // _messageDigest is ascii hexadecimal notation. + // messageDigest_ is ascii hexadecimal notation. Checksum(const std::string& algo, const std::string& messageDigest): - _algo(algo), _messageDigest(messageDigest) {} + algo_(algo), messageDigest_(messageDigest) {} Checksum(): - _algo(MessageDigestContext::SHA1) {} + algo_(MessageDigestContext::SHA1) {} ~Checksum() {} bool isEmpty() const { - return _messageDigest.empty(); + return messageDigest_.empty(); } void setMessageDigest(const std::string& md) { - this->_messageDigest = md; + this->messageDigest_ = md; } const std::string& getMessageDigest() const { - return _messageDigest; + return messageDigest_; } void setAlgo(const std::string& algo) { - this->_algo = algo; + this->algo_ = algo; } const std::string& getAlgo() const { - return _algo; + return algo_; } }; diff --git a/src/ChunkChecksum.h b/src/ChunkChecksum.h index 8fba7a9c..38d4b846 100644 --- a/src/ChunkChecksum.h +++ b/src/ChunkChecksum.h @@ -47,23 +47,23 @@ namespace aria2 { class ChunkChecksum { private: - std::string _algo; - std::vector<std::string> _checksums; - size_t _checksumLength; + std::string algo_; + std::vector<std::string> checksums_; + size_t checksumLength_; public: - ChunkChecksum():_checksumLength(0) {} + ChunkChecksum():checksumLength_(0) {} ChunkChecksum(const std::string& algo, const std::vector<std::string>& checksums, size_t checksumLength): - _algo(algo), - _checksums(checksums), - _checksumLength(checksumLength) {} + algo_(algo), + checksums_(checksums), + checksumLength_(checksumLength) {} bool validateChunk(const std::string& actualChecksum, size_t checksumIndex) const { - if(checksumIndex < _checksums.size()) { + if(checksumIndex < checksums_.size()) { return actualChecksum == getChecksum(checksumIndex); } else { return false; @@ -72,18 +72,18 @@ public: uint64_t getEstimatedDataLength() const { - return ((uint64_t)_checksumLength)*_checksums.size(); + return ((uint64_t)checksumLength_)*checksums_.size(); } size_t countChecksum() const { - return _checksums.size(); + return checksums_.size(); } const std::string& getChecksum(size_t index) const { - if(index < _checksums.size()) { - return _checksums[index]; + if(index < checksums_.size()) { + return checksums_[index]; } else { return A2STR::NIL; } @@ -91,32 +91,32 @@ public: const std::vector<std::string>& getChecksums() const { - return _checksums; + return checksums_; } size_t getChecksumLength() const { - return _checksumLength; + return checksumLength_; } const std::string& getAlgo() const { - return _algo; + return algo_; } void setAlgo(const std::string& algo) { - _algo = algo; + algo_ = algo; } void setChecksumLength(size_t length) { - _checksumLength = length; + checksumLength_ = length; } void setChecksums(const std::vector<std::string>& mds) { - _checksums = mds; + checksums_ = mds; } }; diff --git a/src/ChunkedDecoder.cc b/src/ChunkedDecoder.cc index 63cf8d09..57f1d722 100644 --- a/src/ChunkedDecoder.cc +++ b/src/ChunkedDecoder.cc @@ -43,7 +43,7 @@ namespace aria2 { const std::string ChunkedDecoder::NAME("ChunkedDecoder"); -ChunkedDecoder::ChunkedDecoder():_chunkSize(0), _state(READ_SIZE) {} +ChunkedDecoder::ChunkedDecoder():chunkSize_(0), state_(READ_SIZE) {} ChunkedDecoder::~ChunkedDecoder() {} @@ -84,24 +84,24 @@ static bool readData(std::string& out, uint64_t& chunkSize, std::string& in) std::string ChunkedDecoder::decode(const unsigned char* inbuf, size_t inlen) { - _buf.append(&inbuf[0], &inbuf[inlen]); + buf_.append(&inbuf[0], &inbuf[inlen]); std::string outbuf; while(1) { - if(_state == READ_SIZE) { - if(readChunkSize(_chunkSize, _buf)) { - if(_chunkSize == 0) { - _state = STREAM_END; + if(state_ == READ_SIZE) { + if(readChunkSize(chunkSize_, buf_)) { + if(chunkSize_ == 0) { + state_ = STREAM_END; break; } else { - _state = READ_DATA; + state_ = READ_DATA; } } else { break; } - } else if(_state == READ_DATA) { - if(readData(outbuf, _chunkSize, _buf)) { - _state = READ_SIZE; + } else if(state_ == READ_DATA) { + if(readData(outbuf, chunkSize_, buf_)) { + state_ = READ_SIZE; } else { break; } @@ -112,7 +112,7 @@ std::string ChunkedDecoder::decode(const unsigned char* inbuf, size_t inlen) bool ChunkedDecoder::finished() { - return _state == STREAM_END; + return state_ == STREAM_END; } void ChunkedDecoder::release() {} diff --git a/src/ChunkedDecoder.h b/src/ChunkedDecoder.h index fc33dead..1a5fcc7f 100644 --- a/src/ChunkedDecoder.h +++ b/src/ChunkedDecoder.h @@ -47,11 +47,11 @@ private: STREAM_END }; - std::string _buf; + std::string buf_; - uint64_t _chunkSize; + uint64_t chunkSize_; - STATE _state; + STATE state_; static const std::string NAME; diff --git a/src/Command.cc b/src/Command.cc index 52d3c192..8758f334 100644 --- a/src/Command.cc +++ b/src/Command.cc @@ -38,55 +38,55 @@ namespace aria2 { -Command::Command(cuid_t cuid):_status(STATUS_INACTIVE), - _cuid(cuid), - _logger(LogFactory::getInstance()), - _readEvent(false), - _writeEvent(false), - _errorEvent(false), - _hupEvent(false) {} +Command::Command(cuid_t cuid):status_(STATUS_INACTIVE), + cuid_(cuid), + logger_(LogFactory::getInstance()), + readEvent_(false), + writeEvent_(false), + errorEvent_(false), + hupEvent_(false) {} void Command::transitStatus() { - switch(_status) { + switch(status_) { case STATUS_REALTIME: break; default: - _status = STATUS_INACTIVE; + status_ = STATUS_INACTIVE; } } void Command::setStatus(STATUS status) { - _status = status; + status_ = status; } void Command::readEventReceived() { - _readEvent = true; + readEvent_ = true; } void Command::writeEventReceived() { - _writeEvent = true; + writeEvent_ = true; } void Command::errorEventReceived() { - _errorEvent = true; + errorEvent_ = true; } void Command::hupEventReceived() { - _hupEvent = true; + hupEvent_ = true; } void Command::clearIOEvents() { - _readEvent = false; - _writeEvent = false; - _errorEvent = false; - _hupEvent = false; + readEvent_ = false; + writeEvent_ = false; + errorEvent_ = false; + hupEvent_ = false; } } // namespace aria2 diff --git a/src/Command.h b/src/Command.h index 1fd2cdb2..2ac67beb 100644 --- a/src/Command.h +++ b/src/Command.h @@ -54,39 +54,39 @@ public: STATUS_ONESHOT_REALTIME }; private: - STATUS _status; + STATUS status_; - cuid_t _cuid; - Logger* _logger; + cuid_t cuid_; + Logger* logger_; - bool _readEvent; - bool _writeEvent; - bool _errorEvent; - bool _hupEvent; + bool readEvent_; + bool writeEvent_; + bool errorEvent_; + bool hupEvent_; protected: Logger* getLogger() const { - return _logger; + return logger_; } bool readEventEnabled() const { - return _readEvent; + return readEvent_; } bool writeEventEnabled() const { - return _writeEvent; + return writeEvent_; } bool errorEventEnabled() const { - return _errorEvent; + return errorEvent_; } bool hupEventEnabled() const { - return _hupEvent; + return hupEvent_; } public: Command(cuid_t cuid); @@ -95,19 +95,19 @@ public: virtual bool execute() = 0; - cuid_t getCuid() const { return _cuid; } + cuid_t getCuid() const { return cuid_; } - void setStatusActive() { _status = STATUS_ACTIVE; } + void setStatusActive() { status_ = STATUS_ACTIVE; } - void setStatusInactive() { _status = STATUS_INACTIVE; } + void setStatusInactive() { status_ = STATUS_INACTIVE; } - void setStatusRealtime() { _status = STATUS_REALTIME; } + void setStatusRealtime() { status_ = STATUS_REALTIME; } void setStatus(STATUS status); bool statusMatch(Command::STATUS statusFilter) const { - return statusFilter <= _status; + return statusFilter <= status_; } void transitStatus(); diff --git a/src/ConsoleStatCalc.cc b/src/ConsoleStatCalc.cc index 29c55c40..e9f5556c 100644 --- a/src/ConsoleStatCalc.cc +++ b/src/ConsoleStatCalc.cc @@ -119,7 +119,7 @@ static void printProgress << rg->getNumConnection(); #ifdef ENABLE_BITTORRENT SharedHandle<PeerStorage> ps = - e->getBtRegistry()->get(rg->getGID())._peerStorage; + e->getBtRegistry()->get(rg->getGID()).peerStorage_; if(!ps.isNull()) { std::vector<SharedHandle<Peer> > peers; ps->getActivePeers(peers); @@ -150,19 +150,19 @@ static void printProgress class PrintSummary { private: - size_t _cols; - const DownloadEngine* _e; - const SizeFormatter& _sizeFormatter; + size_t cols_; + const DownloadEngine* e_; + const SizeFormatter& sizeFormatter_; public: PrintSummary (size_t cols, const DownloadEngine* e, const SizeFormatter& sizeFormatter): - _cols(cols), _e(e), _sizeFormatter(sizeFormatter) {} + cols_(cols), e_(e), sizeFormatter_(sizeFormatter) {} void operator()(const SharedHandle<RequestGroup>& rg) { const char SEP_CHAR = '-'; - printProgress(std::cout, rg, _e, _sizeFormatter); + printProgress(std::cout, rg, e_, sizeFormatter_); const std::vector<SharedHandle<FileEntry> >& fileEntries = rg->getDownloadContext()->getFileEntries(); std::cout << "\n" @@ -170,7 +170,7 @@ public: writeFilePath(fileEntries.begin(), fileEntries.end(), std::cout, rg->inMemoryDownload()); std::cout << "\n" - << std::setfill(SEP_CHAR) << std::setw(_cols) << SEP_CHAR << "\n"; + << std::setfill(SEP_CHAR) << std::setw(cols_) << SEP_CHAR << "\n"; } }; @@ -203,23 +203,23 @@ static void printProgressSummary } ConsoleStatCalc::ConsoleStatCalc(time_t summaryInterval, bool humanReadable): - _summaryInterval(summaryInterval) + summaryInterval_(summaryInterval) { if(humanReadable) { - _sizeFormatter.reset(new AbbrevSizeFormatter()); + sizeFormatter_.reset(new AbbrevSizeFormatter()); } else { - _sizeFormatter.reset(new PlainSizeFormatter()); + sizeFormatter_.reset(new PlainSizeFormatter()); } } void ConsoleStatCalc::calculateStat(const DownloadEngine* e) { - if(_cp.difference(global::wallclock) < 1) { + if(cp_.difference(global::wallclock) < 1) { return; } - _cp = global::wallclock; - const SizeFormatter& sizeFormatter = *_sizeFormatter.get(); + cp_ = global::wallclock; + const SizeFormatter& sizeFormatter = *sizeFormatter_.get(); #ifdef __MINGW32__ bool isTTY = true; @@ -243,9 +243,9 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e) } std::ostringstream o; if(e->getRequestGroupMan()->countRequestGroup() > 0) { - if((_summaryInterval > 0) && - _lastSummaryNotified.difference(global::wallclock) >= _summaryInterval) { - _lastSummaryNotified = global::wallclock; + if((summaryInterval_ > 0) && + lastSummaryNotified_.difference(global::wallclock) >= summaryInterval_) { + lastSummaryNotified_ = global::wallclock; printProgressSummary(e->getRequestGroupMan()->getRequestGroups(), cols, e, sizeFormatter); std::cout << "\n"; diff --git a/src/ConsoleStatCalc.h b/src/ConsoleStatCalc.h index 62db9fe2..6ffc9634 100644 --- a/src/ConsoleStatCalc.h +++ b/src/ConsoleStatCalc.h @@ -72,13 +72,13 @@ protected: class ConsoleStatCalc:public StatCalc { private: - Timer _cp; + Timer cp_; - Timer _lastSummaryNotified; + Timer lastSummaryNotified_; - time_t _summaryInterval; + time_t summaryInterval_; - SharedHandle<SizeFormatter> _sizeFormatter; + SharedHandle<SizeFormatter> sizeFormatter_; public: ConsoleStatCalc(time_t summaryInterval, bool humanReadable = true); diff --git a/src/ContentTypeRequestGroupCriteria.cc b/src/ContentTypeRequestGroupCriteria.cc index ec49b6a1..ef1e2f00 100644 --- a/src/ContentTypeRequestGroupCriteria.cc +++ b/src/ContentTypeRequestGroupCriteria.cc @@ -61,14 +61,14 @@ bool ContentTypeRequestGroupCriteria::match if(requestGroup->getDownloadContext()->getFileEntries().size() != 1) { return false; } - if(tailMatch(_extensions.begin(), _extensions.end(), + if(tailMatch(extensions_.begin(), extensions_.end(), requestGroup->getFirstFilePath())) { return true; } else { return - std::find(_contentTypes.begin(), _contentTypes.end(), + std::find(contentTypes_.begin(), contentTypes_.end(), requestGroup->getDownloadContext()->getFirstFileEntry()-> - getContentType()) != _contentTypes.end(); + getContentType()) != contentTypes_.end(); } } diff --git a/src/ContentTypeRequestGroupCriteria.h b/src/ContentTypeRequestGroupCriteria.h index 4a20182f..43dbb73c 100644 --- a/src/ContentTypeRequestGroupCriteria.h +++ b/src/ContentTypeRequestGroupCriteria.h @@ -44,16 +44,16 @@ namespace aria2 { class ContentTypeRequestGroupCriteria:public RequestGroupCriteria { private: - std::vector<std::string> _contentTypes; - std::vector<std::string> _extensions; + std::vector<std::string> contentTypes_; + std::vector<std::string> extensions_; public: template<typename InputIterator> ContentTypeRequestGroupCriteria(InputIterator contentTypeFirst, InputIterator contentTypeLast, InputIterator extensionFirst, InputIterator extensionLast): - _contentTypes(contentTypeFirst, contentTypeLast), - _extensions(extensionFirst, extensionLast) {} + contentTypes_(contentTypeFirst, contentTypeLast), + extensions_(extensionFirst, extensionLast) {} virtual bool match(const RequestGroup* requestGroup) const; }; diff --git a/src/Cookie.cc b/src/Cookie.cc index e91ca5e0..6ae29a3c 100644 --- a/src/Cookie.cc +++ b/src/Cookie.cc @@ -74,41 +74,41 @@ Cookie::Cookie(const std::string& name, const std::string& path, const std::string& domain, bool secure): - _name(name), - _value(value), - _expiry(expiry), - _path(path), - _domain(normalizeDomain(domain)), - _secure(secure), - _creationTime(time(0)), - _lastAccess(_creationTime) {} + name_(name), + value_(value), + expiry_(expiry), + path_(path), + domain_(normalizeDomain(domain)), + secure_(secure), + creationTime_(time(0)), + lastAccess_(creationTime_) {} Cookie::Cookie(const std::string& name, const std::string& value, const std::string& path, const std::string& domain, bool secure): - _name(name), - _value(value), - _expiry(0), - _path(path), - _domain(normalizeDomain(domain)), - _secure(secure), - _creationTime(time(0)), - _lastAccess(_creationTime) {} + name_(name), + value_(value), + expiry_(0), + path_(path), + domain_(normalizeDomain(domain)), + secure_(secure), + creationTime_(time(0)), + lastAccess_(creationTime_) {} -Cookie::Cookie():_expiry(0), _secure(false), _lastAccess(time(0)) {} +Cookie::Cookie():expiry_(0), secure_(false), lastAccess_(time(0)) {} Cookie::~Cookie() {} std::string Cookie::toString() const { - return strconcat(_name, "=", _value); + return strconcat(name_, "=", value_); } bool Cookie::good() const { - return !_name.empty(); + return !name_.empty(); } static bool pathInclude(const std::string& requestPath, const std::string& path) @@ -138,7 +138,7 @@ static bool domainMatch(const std::string& normReqHost, // // Also original Netscape implementation behaves exactly the same. - // _domain always starts ".". See Cookie::Cookie(). + // domain_ always starts ".". See Cookie::Cookie(). return util::endsWith(normReqHost, domain); } @@ -146,11 +146,11 @@ bool Cookie::match(const std::string& requestHost, const std::string& requestPath, time_t date, bool secure) const { - if((secure || (!_secure && !secure)) && - (requestHost == _domain || // For default domain or IP address - domainMatch(normalizeDomain(requestHost), _domain)) && - pathInclude(requestPath, _path) && - (isSessionCookie() || (date < _expiry))) { + if((secure || (!secure_ && !secure)) && + (requestHost == domain_ || // For default domain or IP address + domainMatch(normalizeDomain(requestHost), domain_)) && + pathInclude(requestPath, path_) && + (isSessionCookie() || (date < expiry_))) { return true; } else { return false; @@ -160,25 +160,25 @@ bool Cookie::match(const std::string& requestHost, bool Cookie::validate(const std::string& requestHost, const std::string& requestPath) const { - // If _domain doesn't start with "." or it is IP address, then it + // If domain_ doesn't start with "." or it is IP address, then it // must equal to requestHost. Otherwise, do domain tail match. - if(requestHost != _domain) { + if(requestHost != domain_) { std::string normReqHost = normalizeDomain(requestHost); - if(normReqHost != _domain) { + if(normReqHost != domain_) { // domain must start with '.' - if(*_domain.begin() != '.') { + if(*domain_.begin() != '.') { return false; } // domain must not end with '.' - if(*_domain.rbegin() == '.') { + if(*domain_.rbegin() == '.') { return false; } // domain must include at least one embeded '.' - if(_domain.size() < 4 || - _domain.find(A2STR::DOT_C, 1) == std::string::npos) { + if(domain_.size() < 4 || + domain_.find(A2STR::DOT_C, 1) == std::string::npos) { return false; } - if(!util::endsWith(normReqHost, _domain)) { + if(!util::endsWith(normReqHost, domain_)) { return false; } // From RFC2965 3.3.2 Rejecting Cookies @@ -187,16 +187,16 @@ bool Cookie::validate(const std::string& requestHost, // that contains one or more dots. size_t dotCount = std::count(normReqHost.begin(), normReqHost.begin()+ - (normReqHost.size()-_domain.size()), '.'); + (normReqHost.size()-domain_.size()), '.'); if(dotCount > 1 || (dotCount == 1 && normReqHost[0] != '.')) { return false; } } } - if(requestPath != _path) { + if(requestPath != path_) { // From RFC2965 3.3.2 Rejecting Cookies // * The value for the Path attribute is not a prefix of the request-URI. - if(!pathInclude(requestPath, _path)) { + if(!pathInclude(requestPath, path_)) { return false; } } @@ -205,48 +205,48 @@ bool Cookie::validate(const std::string& requestHost, bool Cookie::operator==(const Cookie& cookie) const { - return _domain == cookie._domain && _path == cookie._path && - _name == cookie._name; + return domain_ == cookie.domain_ && path_ == cookie.path_ && + name_ == cookie.name_; } bool Cookie::isExpired() const { - return !_expiry == 0 && Time().getTime() >= _expiry; + return !expiry_ == 0 && Time().getTime() >= expiry_; } std::string Cookie::toNsCookieFormat() const { std::stringstream ss; - ss << _domain << "\t"; - if(util::startsWith(_domain, A2STR::DOT_C)) { + ss << domain_ << "\t"; + if(util::startsWith(domain_, A2STR::DOT_C)) { ss << "TRUE"; } else { ss << "FALSE"; } ss << "\t"; - ss << _path << "\t"; - if(_secure) { + ss << path_ << "\t"; + if(secure_) { ss << "TRUE"; } else { ss << "FALSE"; } ss << "\t"; - ss << _expiry << "\t"; - ss << _name << "\t"; - ss << _value; + ss << expiry_ << "\t"; + ss << name_ << "\t"; + ss << value_; return ss.str(); } void Cookie::markOriginServerOnly() { - if(util::startsWith(_domain, A2STR::DOT_C)) { - _domain.erase(_domain.begin(), _domain.begin()+1); + if(util::startsWith(domain_, A2STR::DOT_C)) { + domain_.erase(domain_.begin(), domain_.begin()+1); } } void Cookie::updateLastAccess() { - _lastAccess = time(0); + lastAccess_ = time(0); } } // namespace aria2 diff --git a/src/Cookie.h b/src/Cookie.h index 04acc8de..02a34054 100644 --- a/src/Cookie.h +++ b/src/Cookie.h @@ -45,19 +45,19 @@ namespace aria2 { class Cookie { private: - std::string _name; - std::string _value; - time_t _expiry; - std::string _path; - std::string _domain; - bool _secure; - time_t _creationTime; - time_t _lastAccess; + std::string name_; + std::string value_; + time_t expiry_; + std::string path_; + std::string domain_; + bool secure_; + time_t creationTime_; + time_t lastAccess_; public: /* * If expires = 0 is given, then the cookie becomes session cookie. * domain is normalized using normalizeDomain() function and - * assigned to _domain. If domain is not specified in cookie, call + * assigned to domain_. If domain is not specified in cookie, call * markOriginServerOnly() after construction. */ Cookie(const std::string& name, @@ -70,7 +70,7 @@ public: /* * Creates session cookie. This is equivalent to Cookie(name, value, * 0, path, domain, secure); domain is normalized using - * normalizeDomain() function and assigned to _domain. If domain is + * normalizeDomain() function and assigned to domain_. If domain is * not specified in cookie, call markOriginServerOnly() after * construction. */ @@ -100,55 +100,55 @@ public: const std::string& getName() const { - return _name; + return name_; } const std::string& getValue() const { - return _value; + return value_; } const std::string& getPath() const { - return _path; + return path_; } const std::string& getDomain() const { - return _domain; + return domain_; } time_t getExpiry() const { - return _expiry; + return expiry_; } bool isSecureCookie() const { - return _secure; + return secure_; } bool isSessionCookie() const { - return _expiry == 0; + return expiry_ == 0; } std::string toNsCookieFormat() const; // Makes this Cookie only sent to the origin server. This function - // removes first "." from _domain if _domain starts with ".". + // removes first "." from domain_ if domain_ starts with ".". void markOriginServerOnly(); time_t getCreationTime() const { - return _creationTime; + return creationTime_; } void updateLastAccess(); time_t getLastAccess() const { - return _lastAccess; + return lastAccess_; } static std::string normalizeDomain(const std::string& domain); diff --git a/src/CookieStorage.cc b/src/CookieStorage.cc index 1e8f8f5f..53679cef 100644 --- a/src/CookieStorage.cc +++ b/src/CookieStorage.cc @@ -54,36 +54,36 @@ namespace aria2 { CookieStorage::DomainEntry::DomainEntry -(const std::string& domain):_key(domain) +(const std::string& domain):key_(domain) { - std::reverse(_key.begin(), _key.end()); + std::reverse(key_.begin(), key_.end()); } void CookieStorage::DomainEntry::updateLastAccess() { - _lastAccess = time(0); + lastAccess_ = time(0); } bool CookieStorage::DomainEntry::addCookie(const Cookie& cookie) { updateLastAccess(); - std::deque<Cookie>::iterator i = std::find(_cookies.begin(), _cookies.end(), + std::deque<Cookie>::iterator i = std::find(cookies_.begin(), cookies_.end(), cookie); - if(i == _cookies.end()) { + if(i == cookies_.end()) { if(cookie.isExpired()) { return false; } else { - if(_cookies.size() >= CookieStorage::MAX_COOKIE_PER_DOMAIN) { + if(cookies_.size() >= CookieStorage::MAX_COOKIE_PER_DOMAIN) { std::deque<Cookie>::iterator m = std::min_element - (_cookies.begin(), _cookies.end(), LeastRecentAccess<Cookie>()); + (cookies_.begin(), cookies_.end(), LeastRecentAccess<Cookie>()); *m = cookie; } else { - _cookies.push_back(cookie); + cookies_.push_back(cookie); } return true; } } else if(cookie.isExpired()) { - _cookies.erase(i); + cookies_.erase(i); return false; } else { *i = cookie; @@ -93,18 +93,18 @@ bool CookieStorage::DomainEntry::addCookie(const Cookie& cookie) bool CookieStorage::DomainEntry::contains(const Cookie& cookie) const { - return std::find(_cookies.begin(), _cookies.end(), cookie) != _cookies.end(); + return std::find(cookies_.begin(), cookies_.end(), cookie) != cookies_.end(); } void CookieStorage::DomainEntry::writeCookie(std::ostream& o) const { - for(std::deque<Cookie>::const_iterator i = _cookies.begin(), - eoi = _cookies.end(); i != eoi; ++i) { + for(std::deque<Cookie>::const_iterator i = cookies_.begin(), + eoi = cookies_.end(); i != eoi; ++i) { o << (*i).toNsCookieFormat() << "\n"; } } -CookieStorage::CookieStorage():_logger(LogFactory::getInstance()) {} +CookieStorage::CookieStorage():logger_(LogFactory::getInstance()) {} CookieStorage::~CookieStorage() {} @@ -118,23 +118,23 @@ bool CookieStorage::store(const Cookie& cookie) if(!cookie.good()) { return false; } - if(_domains.size() >= DOMAIN_EVICTION_TRIGGER) { - std::sort(_domains.begin(), _domains.end(), + if(domains_.size() >= DOMAIN_EVICTION_TRIGGER) { + std::sort(domains_.begin(), domains_.end(), LeastRecentAccess<DomainEntry>()); - size_t delnum = (size_t)(_domains.size()*DOMAIN_EVICTION_RATE); - _domains.erase(_domains.begin(), _domains.begin()+delnum); - std::sort(_domains.begin(), _domains.end()); + size_t delnum = (size_t)(domains_.size()*DOMAIN_EVICTION_RATE); + domains_.erase(domains_.begin(), domains_.begin()+delnum); + std::sort(domains_.begin(), domains_.end()); } DomainEntry v(cookie.getDomain()); std::deque<DomainEntry>::iterator i = - std::lower_bound(_domains.begin(), _domains.end(), v); + std::lower_bound(domains_.begin(), domains_.end(), v); bool added = false; - if(i != _domains.end() && (*i).getKey() == v.getKey()) { + if(i != domains_.end() && (*i).getKey() == v.getKey()) { added = (*i).addCookie(cookie); } else { added = v.addCookie(cookie); if(added) { - _domains.insert(i, v); + domains_.insert(i, v); } } return added; @@ -144,7 +144,7 @@ bool CookieStorage::parseAndStore(const std::string& setCookieString, const std::string& requestHost, const std::string& requestPath) { - Cookie cookie = _parser.parse(setCookieString, requestHost, requestPath); + Cookie cookie = parser_.parse(setCookieString, requestHost, requestPath); if(cookie.validate(requestHost, requestPath)) { return store(cookie); } else { @@ -153,13 +153,13 @@ bool CookieStorage::parseAndStore(const std::string& setCookieString, } struct CookiePathDivider { - Cookie _cookie; - int _pathDepth; - CookiePathDivider(const Cookie& cookie):_cookie(cookie) + Cookie cookie_; + int pathDepth_; + CookiePathDivider(const Cookie& cookie):cookie_(cookie) { std::vector<std::string> paths; - util::split(_cookie.getPath(), std::back_inserter(paths), A2STR::SLASH_C); - _pathDepth = paths.size(); + util::split(cookie_.getPath(), std::back_inserter(paths), A2STR::SLASH_C); + pathDepth_ = paths.size(); } }; @@ -172,7 +172,7 @@ public: Cookie operator()(const CookiePathDivider& cookiePathDivider) const { - return cookiePathDivider._cookie; + return cookiePathDivider.cookie_; } }; @@ -194,9 +194,9 @@ public: // "name1=foo" with a path mapping of "/" should be sent after a // cookie "name1=foo2" with a path mapping of "/bar" if they are // both to be sent. - int comp = lhs._pathDepth-rhs._pathDepth; + int comp = lhs.pathDepth_-rhs.pathDepth_; if(comp == 0) { - return lhs._cookie.getCreationTime() < rhs._cookie.getCreationTime(); + return lhs.cookie_.getCreationTime() < rhs.cookie_.getCreationTime(); } else { return comp > 0; } @@ -224,8 +224,8 @@ bool CookieStorage::contains(const Cookie& cookie) const { CookieStorage::DomainEntry v(cookie.getDomain()); std::deque<CookieStorage::DomainEntry>::const_iterator i = - std::lower_bound(_domains.begin(), _domains.end(), v); - if(i != _domains.end() && (*i).getKey() == v.getKey()) { + std::lower_bound(domains_.begin(), domains_.end(), v); + if(i != domains_.end() && (*i).getKey() == v.getKey()) { return (*i).contains(cookie); } else { return false; @@ -241,7 +241,7 @@ std::vector<Cookie> CookieStorage::criteriaFind(const std::string& requestHost, searchCookieByDomainSuffix ((!numericHost && requestHost.find(A2STR::DOT_C) == std::string::npos)? requestHost+".local":requestHost, - _domains.begin(), _domains.end(), + domains_.begin(), domains_.end(), std::back_inserter(res), requestHost, requestPath, date, secure); if(!numericHost) { @@ -259,7 +259,7 @@ std::vector<Cookie> CookieStorage::criteriaFind(const std::string& requestHost, domainComponents.begin()+1, eoi = domainComponents.end(); di != eoi; ++di) { domain = strconcat(A2STR::DOT_C, *di, domain); - searchCookieByDomainSuffix(domain, _domains.begin(), _domains.end(), + searchCookieByDomainSuffix(domain, domains_.begin(), domains_.end(), std::back_inserter(res), normRequestHost, requestPath, date, secure); } @@ -276,8 +276,8 @@ std::vector<Cookie> CookieStorage::criteriaFind(const std::string& requestHost, size_t CookieStorage::size() const { size_t numCookie = 0; - for(std::deque<DomainEntry>::const_iterator i = _domains.begin(), - eoi = _domains.end(); i != eoi; ++i) { + for(std::deque<DomainEntry>::const_iterator i = domains_.begin(), + eoi = domains_.end(); i != eoi; ++i) { numCookie += (*i).countCookie(); } return numCookie; @@ -288,12 +288,12 @@ bool CookieStorage::load(const std::string& filename) char header[16]; // "SQLite format 3" plus \0 std::ifstream s(filename.c_str(), std::ios::binary); if(!s) { - _logger->error("Failed to open cookie file %s", filename.c_str()); + logger_->error("Failed to open cookie file %s", filename.c_str()); return false; } s.get(header, sizeof(header)); if(!s) { - _logger->error("Failed to read header of cookie file %s", + logger_->error("Failed to read header of cookie file %s", filename.c_str()); return false; } @@ -313,7 +313,7 @@ bool CookieStorage::load(const std::string& filename) } return true; } catch(RecoverableException& e) { - _logger->error("Failed to load cookies from %s", filename.c_str()); + logger_->error("Failed to load cookies from %s", filename.c_str()); return false; } } @@ -324,17 +324,17 @@ bool CookieStorage::saveNsFormat(const std::string& filename) { std::ofstream o(tempfilename.c_str(), std::ios::binary); if(!o) { - _logger->error("Cannot create cookie file %s, cause %s", + logger_->error("Cannot create cookie file %s, cause %s", filename.c_str(), strerror(errno)); return false; } - for(std::deque<DomainEntry>::const_iterator i = _domains.begin(), - eoi = _domains.end(); i != eoi; ++i) { + for(std::deque<DomainEntry>::const_iterator i = domains_.begin(), + eoi = domains_.end(); i != eoi; ++i) { (*i).writeCookie(o); } o.flush(); if(!o) { - _logger->error("Failed to save cookies to %s, cause %s", + logger_->error("Failed to save cookies to %s, cause %s", filename.c_str(), strerror(errno)); return false; } @@ -342,7 +342,7 @@ bool CookieStorage::saveNsFormat(const std::string& filename) if(File(tempfilename).renameTo(filename)) { return true; } else { - _logger->error("Could not rename file %s as %s", + logger_->error("Could not rename file %s as %s", tempfilename.c_str(), filename.c_str()); return false; } diff --git a/src/CookieStorage.h b/src/CookieStorage.h index 8195353f..4e03b99b 100644 --- a/src/CookieStorage.h +++ b/src/CookieStorage.h @@ -57,17 +57,17 @@ public: class DomainEntry { private: - std::string _key; + std::string key_; - time_t _lastAccess; + time_t lastAccess_; - std::deque<Cookie> _cookies; + std::deque<Cookie> cookies_; public: DomainEntry(const std::string& domain); const std::string& getKey() const { - return _key; + return key_; } template<typename OutputIterator> @@ -77,8 +77,8 @@ public: const std::string& requestPath, time_t date, bool secure) { - for(std::deque<Cookie>::iterator i = _cookies.begin(); - i != _cookies.end(); ++i) { + for(std::deque<Cookie>::iterator i = cookies_.begin(); + i != cookies_.end(); ++i) { if((*i).match(requestHost, requestPath, date, secure)) { (*i).updateLastAccess(); out++ = *i; @@ -89,7 +89,7 @@ public: size_t countCookie() const { - return _cookies.size(); + return cookies_.size(); } bool addCookie(const Cookie& cookie); @@ -98,7 +98,7 @@ public: time_t getLastAccess() const { - return _lastAccess; + return lastAccess_; } void writeCookie(std::ostream& o) const; @@ -108,20 +108,20 @@ public: template<typename OutputIterator> OutputIterator dumpCookie(OutputIterator out) const { - return std::copy(_cookies.begin(), _cookies.end(), out); + return std::copy(cookies_.begin(), cookies_.end(), out); } bool operator<(const DomainEntry& de) const { - return _key < de._key; + return key_ < de.key_; } }; private: - std::deque<DomainEntry> _domains; + std::deque<DomainEntry> domains_; - CookieParser _parser; + CookieParser parser_; - Logger* _logger; + Logger* logger_; template<typename InputIterator> void storeCookies(InputIterator first, InputIterator last) @@ -146,7 +146,7 @@ public: const std::string& requestPath); // Finds cookies matched with given criteria and returns them. - // Matched cookies' _lastAccess property is updated. + // Matched cookies' lastAccess_ property is updated. std::vector<Cookie> criteriaFind(const std::string& requestHost, const std::string& requestPath, time_t date, bool secure); @@ -173,8 +173,8 @@ public: template<typename OutputIterator> OutputIterator dumpCookie(OutputIterator out) const { - for(std::deque<DomainEntry>::const_iterator i = _domains.begin(), - eoi = _domains.end(); i != eoi; ++i) { + for(std::deque<DomainEntry>::const_iterator i = domains_.begin(), + eoi = domains_.end(); i != eoi; ++i) { out = (*i).dumpCookie(out); } return out; diff --git a/src/DHTAbstractMessage.cc b/src/DHTAbstractMessage.cc index ee0c41f1..96e849b9 100644 --- a/src/DHTAbstractMessage.cc +++ b/src/DHTAbstractMessage.cc @@ -66,7 +66,7 @@ std::string DHTAbstractMessage::getBencodedMessage() bool DHTAbstractMessage::send() { std::string message = getBencodedMessage(); - ssize_t r = _connection->sendMessage + ssize_t r = connection_->sendMessage (reinterpret_cast<const unsigned char*>(message.c_str()), message.size(), getRemoteNode()->getIPAddress(), @@ -78,25 +78,25 @@ bool DHTAbstractMessage::send() void DHTAbstractMessage::setConnection (const WeakHandle<DHTConnection>& connection) { - _connection = connection; + connection_ = connection; } void DHTAbstractMessage::setMessageDispatcher (const WeakHandle<DHTMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DHTAbstractMessage::setMessageFactory (const WeakHandle<DHTMessageFactory>& factory) { - _factory = factory; + factory_ = factory; } void DHTAbstractMessage::setRoutingTable (const WeakHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } } // namespace aria2 diff --git a/src/DHTAbstractMessage.h b/src/DHTAbstractMessage.h index 18c6809a..85fd91e8 100644 --- a/src/DHTAbstractMessage.h +++ b/src/DHTAbstractMessage.h @@ -48,13 +48,13 @@ class DHTRoutingTable; class DHTAbstractMessage:public DHTMessage { private: - WeakHandle<DHTConnection> _connection; + WeakHandle<DHTConnection> connection_; - WeakHandle<DHTMessageDispatcher> _dispatcher; + WeakHandle<DHTMessageDispatcher> dispatcher_; - WeakHandle<DHTMessageFactory> _factory; + WeakHandle<DHTMessageFactory> factory_; - WeakHandle<DHTRoutingTable> _routingTable; + WeakHandle<DHTRoutingTable> routingTable_; public: DHTAbstractMessage(const SharedHandle<DHTNode>& localNode, const SharedHandle<DHTNode>& remoteNode, @@ -72,28 +72,28 @@ public: const WeakHandle<DHTConnection>& getConnection() const { - return _connection; + return connection_; } void setConnection(const WeakHandle<DHTConnection>& connection); const WeakHandle<DHTMessageDispatcher>& getMessageDispatcher() const { - return _dispatcher; + return dispatcher_; } void setMessageDispatcher(const WeakHandle<DHTMessageDispatcher>& dispatcher); const WeakHandle<DHTMessageFactory>& getMessageFactory() const { - return _factory; + return factory_; } void setMessageFactory(const WeakHandle<DHTMessageFactory>& factory); const WeakHandle<DHTRoutingTable>& getRoutingTable() const { - return _routingTable; + return routingTable_; } void setRoutingTable(const WeakHandle<DHTRoutingTable>& routingTable); diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h index 70089cd2..01dae7f6 100644 --- a/src/DHTAbstractNodeLookupTask.h +++ b/src/DHTAbstractNodeLookupTask.h @@ -63,11 +63,11 @@ class DHTMessage; template<class ResponseMessage> class DHTAbstractNodeLookupTask:public DHTAbstractTask { private: - unsigned char _targetID[DHT_ID_LENGTH]; + unsigned char targetID_[DHT_ID_LENGTH]; - std::deque<SharedHandle<DHTNodeLookupEntry> > _entries; + std::deque<SharedHandle<DHTNodeLookupEntry> > entries_; - size_t _inFlightMessage; + size_t inFlightMessage_; template<typename Container> void toEntries @@ -83,10 +83,10 @@ private: void sendMessage() { for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i = - _entries.begin(), eoi = _entries.end(); - i != eoi && _inFlightMessage < ALPHA; ++i) { + entries_.begin(), eoi = entries_.end(); + i != eoi && inFlightMessage_ < ALPHA; ++i) { if((*i)->used == false) { - ++_inFlightMessage; + ++inFlightMessage_; (*i)->used = true; SharedHandle<DHTMessage> m = createMessage((*i)->node); SharedHandle<DHTMessageCallback> callback(createCallback()); @@ -100,10 +100,10 @@ private: if(needsAdditionalOutgoingMessage()) { sendMessage(); } - if(_inFlightMessage == 0) { + if(inFlightMessage_ == 0) { if(getLogger()->debug()) { getLogger()->debug("Finished node_lookup for node ID %s", - util::toHex(_targetID, DHT_ID_LENGTH).c_str()); + util::toHex(targetID_, DHT_ID_LENGTH).c_str()); } onFinish(); updateBucket(); @@ -111,8 +111,8 @@ private: } else { if(getLogger()->debug()) { getLogger()->debug("%d in flight message for node ID %s", - _inFlightMessage, - util::toHex(_targetID, DHT_ID_LENGTH).c_str()); + inFlightMessage_, + util::toHex(targetID_, DHT_ID_LENGTH).c_str()); } } } @@ -121,12 +121,12 @@ private: protected: const unsigned char* getTargetID() const { - return _targetID; + return targetID_; } const std::deque<SharedHandle<DHTNodeLookupEntry> >& getEntries() const { - return _entries; + return entries_; } virtual void getNodesFromMessage @@ -146,9 +146,9 @@ protected: virtual SharedHandle<DHTMessageCallback> createCallback() = 0; public: DHTAbstractNodeLookupTask(const unsigned char* targetID): - _inFlightMessage(0) + inFlightMessage_(0) { - memcpy(_targetID, targetID, DHT_ID_LENGTH); + memcpy(targetID_, targetID, DHT_ID_LENGTH); } static const size_t ALPHA = 3; @@ -156,16 +156,16 @@ public: virtual void startup() { std::vector<SharedHandle<DHTNode> > nodes; - getRoutingTable()->getClosestKNodes(nodes, _targetID); - _entries.clear(); - toEntries(_entries, nodes); - if(_entries.empty()) { + getRoutingTable()->getClosestKNodes(nodes, targetID_); + entries_.clear(); + toEntries(entries_, nodes); + if(entries_.empty()) { setFinished(true); } else { // TODO use RTT here - _inFlightMessage = 0; + inFlightMessage_ = 0; sendMessage(); - if(_inFlightMessage == 0) { + if(inFlightMessage_ == 0) { if(getLogger()->debug()) { getLogger()->debug("No message was sent in this lookup stage. Finished."); } @@ -176,7 +176,7 @@ public: void onReceived(const ResponseMessage* message) { - --_inFlightMessage; + --inFlightMessage_; onReceivedInternal(message); std::vector<SharedHandle<DHTNode> > nodes; getNodesFromMessage(nodes, message); @@ -188,7 +188,7 @@ public: newEntries.begin(), eoi = newEntries.end(); i != eoi; ++i) { if(memcmp(getLocalNode()->getID(), (*i)->node->getID(), DHT_ID_LENGTH) != 0) { - _entries.push_front(*i); + entries_.push_front(*i); ++count; if(getLogger()->debug()) { getLogger()->debug("Received nodes: id=%s, ip=%s", @@ -201,13 +201,13 @@ public: if(getLogger()->debug()) { getLogger()->debug("%u node lookup entries added.", count); } - std::stable_sort(_entries.begin(), _entries.end(), DHTIDCloser(_targetID)); - _entries.erase(std::unique(_entries.begin(), _entries.end()), _entries.end()); + std::stable_sort(entries_.begin(), entries_.end(), DHTIDCloser(targetID_)); + entries_.erase(std::unique(entries_.begin(), entries_.end()), entries_.end()); if(getLogger()->debug()) { - getLogger()->debug("%u node lookup entries are unique.", _entries.size()); + getLogger()->debug("%u node lookup entries are unique.", entries_.size()); } - if(_entries.size() > DHTBucket::K) { - _entries.erase(_entries.begin()+DHTBucket::K, _entries.end()); + if(entries_.size() > DHTBucket::K) { + entries_.erase(entries_.begin()+DHTBucket::K, entries_.end()); } sendMessageAndCheckFinish(); } @@ -218,11 +218,11 @@ public: getLogger()->debug("node lookup message timeout for node ID=%s", util::toHex(node->getID(), DHT_ID_LENGTH).c_str()); } - --_inFlightMessage; + --inFlightMessage_; for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i = - _entries.begin(), eoi = _entries.end(); i != eoi; ++i) { + entries_.begin(), eoi = entries_.end(); i != eoi; ++i) { if((*i)->node == node) { - _entries.erase(i); + entries_.erase(i); break; } } diff --git a/src/DHTAbstractTask.cc b/src/DHTAbstractTask.cc index dfddeb8d..706ab5de 100644 --- a/src/DHTAbstractTask.cc +++ b/src/DHTAbstractTask.cc @@ -47,38 +47,38 @@ namespace aria2 { DHTAbstractTask::DHTAbstractTask(): - _finished(false), - _logger(LogFactory::getInstance()) + finished_(false), + logger_(LogFactory::getInstance()) {} bool DHTAbstractTask::finished() { - return _finished; + return finished_; } void DHTAbstractTask::setRoutingTable(const WeakHandle<DHTRoutingTable> routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DHTAbstractTask::setMessageDispatcher(const WeakHandle<DHTMessageDispatcher> dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DHTAbstractTask::setMessageFactory(const WeakHandle<DHTMessageFactory> factory) { - _factory = factory; + factory_ = factory; } void DHTAbstractTask::setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTAbstractTask::setLocalNode(const SharedHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } } // namespace aria2 diff --git a/src/DHTAbstractTask.h b/src/DHTAbstractTask.h index 5154dd69..55a6225b 100644 --- a/src/DHTAbstractTask.h +++ b/src/DHTAbstractTask.h @@ -52,28 +52,28 @@ class Logger; class DHTAbstractTask:public DHTTask { private: - bool _finished; + bool finished_; - Logger* _logger; + Logger* logger_; - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - WeakHandle<DHTRoutingTable> _routingTable; + WeakHandle<DHTRoutingTable> routingTable_; - WeakHandle<DHTMessageDispatcher> _dispatcher; + WeakHandle<DHTMessageDispatcher> dispatcher_; - WeakHandle<DHTMessageFactory> _factory; + WeakHandle<DHTMessageFactory> factory_; - WeakHandle<DHTTaskQueue> _taskQueue; + WeakHandle<DHTTaskQueue> taskQueue_; protected: void setFinished(bool f) { - _finished = f; + finished_ = f; } Logger* getLogger() const { - return _logger; + return logger_; } public: DHTAbstractTask(); @@ -82,35 +82,35 @@ public: const WeakHandle<DHTRoutingTable>& getRoutingTable() const { - return _routingTable; + return routingTable_; } void setRoutingTable(const WeakHandle<DHTRoutingTable> routingTable); const WeakHandle<DHTMessageDispatcher>& getMessageDispatcher() const { - return _dispatcher; + return dispatcher_; } void setMessageDispatcher(const WeakHandle<DHTMessageDispatcher> dispatcher); const WeakHandle<DHTMessageFactory>& getMessageFactory() const { - return _factory; + return factory_; } void setMessageFactory(const WeakHandle<DHTMessageFactory> factory); const WeakHandle<DHTTaskQueue>& getTaskQueue() const { - return _taskQueue; + return taskQueue_; } void setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue); const SharedHandle<DHTNode>& getLocalNode() const { - return _localNode; + return localNode_; } void setLocalNode(const SharedHandle<DHTNode>& localNode); diff --git a/src/DHTAnnouncePeerMessage.cc b/src/DHTAnnouncePeerMessage.cc index f89afacf..592eb4bf 100644 --- a/src/DHTAnnouncePeerMessage.cc +++ b/src/DHTAnnouncePeerMessage.cc @@ -67,18 +67,18 @@ DHTAnnouncePeerMessage::DHTAnnouncePeerMessage const std::string& token, const std::string& transactionID): DHTQueryMessage(localNode, remoteNode, transactionID), - _token(token), - _tcpPort(tcpPort) + token_(token), + tcpPort_(tcpPort) { - memcpy(_infoHash, infoHash, DHT_ID_LENGTH); + memcpy(infoHash_, infoHash, DHT_ID_LENGTH); } DHTAnnouncePeerMessage::~DHTAnnouncePeerMessage() {} void DHTAnnouncePeerMessage::doReceivedAction() { - _peerAnnounceStorage->addPeerAnnounce - (_infoHash, getRemoteNode()->getIPAddress(), _tcpPort); + peerAnnounceStorage_->addPeerAnnounce + (infoHash_, getRemoteNode()->getIPAddress(), tcpPort_); SharedHandle<DHTMessage> reply = getMessageFactory()->createAnnouncePeerReplyMessage @@ -90,9 +90,9 @@ SharedHandle<Dict> DHTAnnouncePeerMessage::getArgument() { SharedHandle<Dict> aDict = Dict::g(); aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH)); - aDict->put(INFO_HASH, String::g(_infoHash, DHT_ID_LENGTH)); - aDict->put(PORT, Integer::g(_tcpPort)); - aDict->put(TOKEN, _token); + aDict->put(INFO_HASH, String::g(infoHash_, DHT_ID_LENGTH)); + aDict->put(PORT, Integer::g(tcpPort_)); + aDict->put(TOKEN, token_); return aDict; } @@ -103,12 +103,12 @@ const std::string& DHTAnnouncePeerMessage::getMessageType() const void DHTAnnouncePeerMessage::validate() const { - if(!_tokenTracker->validateToken(_token, _infoHash, + if(!tokenTracker_->validateToken(token_, infoHash_, getRemoteNode()->getIPAddress(), getRemoteNode()->getPort())) { throw DL_ABORT_EX (StringFormat("Invalid token=%s from %s:%u", - util::toHex(_token).c_str(), + util::toHex(token_).c_str(), getRemoteNode()->getIPAddress().c_str(), getRemoteNode()->getPort()).str()); } @@ -117,20 +117,20 @@ void DHTAnnouncePeerMessage::validate() const void DHTAnnouncePeerMessage::setPeerAnnounceStorage (const WeakHandle<DHTPeerAnnounceStorage>& storage) { - _peerAnnounceStorage = storage; + peerAnnounceStorage_ = storage; } void DHTAnnouncePeerMessage::setTokenTracker (const WeakHandle<DHTTokenTracker>& tokenTracker) { - _tokenTracker = tokenTracker; + tokenTracker_ = tokenTracker; } std::string DHTAnnouncePeerMessage::toStringOptional() const { - return strconcat("token=", util::toHex(_token), - ", info_hash=", util::toHex(_infoHash, INFO_HASH_LENGTH), - ", tcpPort=", util::uitos(_tcpPort)); + return strconcat("token=", util::toHex(token_), + ", info_hash=", util::toHex(infoHash_, INFO_HASH_LENGTH), + ", tcpPort=", util::uitos(tcpPort_)); } } // namespace aria2 diff --git a/src/DHTAnnouncePeerMessage.h b/src/DHTAnnouncePeerMessage.h index 9011ab75..493106ec 100644 --- a/src/DHTAnnouncePeerMessage.h +++ b/src/DHTAnnouncePeerMessage.h @@ -46,15 +46,15 @@ class DHTTokenTracker; class DHTAnnouncePeerMessage:public DHTQueryMessage { private: - std::string _token; + std::string token_; - unsigned char _infoHash[DHT_ID_LENGTH]; + unsigned char infoHash_[DHT_ID_LENGTH]; - uint16_t _tcpPort; + uint16_t tcpPort_; - WeakHandle<DHTPeerAnnounceStorage> _peerAnnounceStorage; + WeakHandle<DHTPeerAnnounceStorage> peerAnnounceStorage_; - WeakHandle<DHTTokenTracker> _tokenTracker; + WeakHandle<DHTTokenTracker> tokenTracker_; protected: virtual std::string toStringOptional() const; public: @@ -77,17 +77,17 @@ public: const unsigned char* getInfoHash() const { - return _infoHash; + return infoHash_; } const std::string& getToken() const { - return _token; + return token_; } uint16_t getTCPPort() const { - return _tcpPort; + return tcpPort_; } void setPeerAnnounceStorage(const WeakHandle<DHTPeerAnnounceStorage>& storage); diff --git a/src/DHTAutoSaveCommand.cc b/src/DHTAutoSaveCommand.cc index 5a908457..f5ae60ec 100644 --- a/src/DHTAutoSaveCommand.cc +++ b/src/DHTAutoSaveCommand.cc @@ -107,7 +107,7 @@ void DHTAutoSaveCommand::save() } std::vector<SharedHandle<DHTNode> > nodes; std::vector<SharedHandle<DHTBucket> > buckets; - _routingTable->getBuckets(buckets); + routingTable_->getBuckets(buckets); for(std::vector<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin(), eoi = buckets.end(); i != eoi; ++i) { const SharedHandle<DHTBucket>& bucket = *i; @@ -117,7 +117,7 @@ void DHTAutoSaveCommand::save() } DHTRoutingTableSerializer serializer; - serializer.setLocalNode(_localNode); + serializer.setLocalNode(localNode_); serializer.setNodes(nodes); try { @@ -142,13 +142,13 @@ void DHTAutoSaveCommand::save() void DHTAutoSaveCommand::setLocalNode(const SharedHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } void DHTAutoSaveCommand::setRoutingTable (const SharedHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } } // namespace aria2 diff --git a/src/DHTAutoSaveCommand.h b/src/DHTAutoSaveCommand.h index 1a672849..f7a0ad5a 100644 --- a/src/DHTAutoSaveCommand.h +++ b/src/DHTAutoSaveCommand.h @@ -46,9 +46,9 @@ class DHTNode; class DHTAutoSaveCommand : public TimeBasedCommand { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - SharedHandle<DHTRoutingTable> _routingTable; + SharedHandle<DHTRoutingTable> routingTable_; void save(); public: diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc index 1f31e4cf..e8d2bacc 100644 --- a/src/DHTBucket.cc +++ b/src/DHTBucket.cc @@ -53,46 +53,46 @@ namespace aria2 { DHTBucket::DHTBucket(size_t prefixLength, const unsigned char* max, const unsigned char* min, const SharedHandle<DHTNode>& localNode): - _prefixLength(prefixLength), - _localNode(localNode), - _lastUpdated(global::wallclock), - _logger(LogFactory::getInstance()) + prefixLength_(prefixLength), + localNode_(localNode), + lastUpdated_(global::wallclock), + logger_(LogFactory::getInstance()) { - memcpy(_max, max, DHT_ID_LENGTH); - memcpy(_min, min, DHT_ID_LENGTH); + memcpy(max_, max, DHT_ID_LENGTH); + memcpy(min_, min, DHT_ID_LENGTH); } DHTBucket::DHTBucket(const SharedHandle<DHTNode>& localNode): - _prefixLength(0), - _localNode(localNode), - _lastUpdated(global::wallclock), - _logger(LogFactory::getInstance()) + prefixLength_(0), + localNode_(localNode), + lastUpdated_(global::wallclock), + logger_(LogFactory::getInstance()) { - memset(_max, 0xff, DHT_ID_LENGTH); - memset(_min, 0, DHT_ID_LENGTH); + memset(max_, 0xff, DHT_ID_LENGTH); + memset(min_, 0, DHT_ID_LENGTH); } DHTBucket::~DHTBucket() {} void DHTBucket::getRandomNodeID(unsigned char* nodeID) const { - if(_prefixLength == 0) { + if(prefixLength_ == 0) { util::generateRandomKey(nodeID); } else { - size_t lastByteIndex = (_prefixLength-1)/8; + size_t lastByteIndex = (prefixLength_-1)/8; util::generateRandomKey(nodeID); - memcpy(nodeID, _min, lastByteIndex+1); + memcpy(nodeID, min_, lastByteIndex+1); } } bool DHTBucket::isInRange(const SharedHandle<DHTNode>& node) const { - return isInRange(node->getID(), _max, _min); + return isInRange(node->getID(), max_, min_); } bool DHTBucket::isInRange(const unsigned char* nodeID) const { - return isInRange(nodeID, _max, _min); + return isInRange(nodeID, max_, min_); } // Returns true if nodeID is in [min, max] (inclusive). @@ -111,45 +111,45 @@ bool DHTBucket::addNode(const SharedHandle<DHTNode>& node) { notifyUpdate(); std::deque<SharedHandle<DHTNode> >::iterator itr = - std::find(_nodes.begin(), _nodes.end(), node); - if(itr == _nodes.end()) { - if(_nodes.size() < K) { - _nodes.push_back(node); + std::find(nodes_.begin(), nodes_.end(), node); + if(itr == nodes_.end()) { + if(nodes_.size() < K) { + nodes_.push_back(node); return true; } else { - if(_nodes.front()->isBad()) { - _nodes.erase(_nodes.begin()); - _nodes.push_back(node); + if(nodes_.front()->isBad()) { + nodes_.erase(nodes_.begin()); + nodes_.push_back(node); return true; } else { return false; } } } else { - _nodes.erase(itr); - _nodes.push_back(node); + nodes_.erase(itr); + nodes_.push_back(node); return true; } } void DHTBucket::cacheNode(const SharedHandle<DHTNode>& node) { - // _cachedNodes are sorted by last time seen - _cachedNodes.push_front(node); - if(_cachedNodes.size() > CACHE_SIZE) { - _cachedNodes.resize(CACHE_SIZE, SharedHandle<DHTNode>()); + // cachedNodes_ are sorted by last time seen + cachedNodes_.push_front(node); + if(cachedNodes_.size() > CACHE_SIZE) { + cachedNodes_.resize(CACHE_SIZE, SharedHandle<DHTNode>()); } } void DHTBucket::dropNode(const SharedHandle<DHTNode>& node) { - if(_cachedNodes.size()) { + if(cachedNodes_.size()) { std::deque<SharedHandle<DHTNode> >::iterator itr = - find(_nodes.begin(), _nodes.end(), node); - if(itr != _nodes.end()) { - _nodes.erase(itr); - _nodes.push_back(_cachedNodes.front()); - _cachedNodes.erase(_cachedNodes.begin()); + find(nodes_.begin(), nodes_.end(), node); + if(itr != nodes_.end()) { + nodes_.erase(itr); + nodes_.push_back(cachedNodes_.front()); + cachedNodes_.erase(cachedNodes_.begin()); } } } @@ -157,26 +157,26 @@ void DHTBucket::dropNode(const SharedHandle<DHTNode>& node) void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node) { std::deque<SharedHandle<DHTNode> >::iterator itr = - std::find(_nodes.begin(), _nodes.end(), node); - if(itr != _nodes.end()) { - _nodes.erase(itr); - _nodes.push_front(node); + std::find(nodes_.begin(), nodes_.end(), node); + if(itr != nodes_.end()) { + nodes_.erase(itr); + nodes_.push_front(node); } } void DHTBucket::moveToTail(const SharedHandle<DHTNode>& node) { std::deque<SharedHandle<DHTNode> >::iterator itr = - std::find(_nodes.begin(), _nodes.end(), node); - if(itr != _nodes.end()) { - _nodes.erase(itr); - _nodes.push_back(node); + std::find(nodes_.begin(), nodes_.end(), node); + if(itr != nodes_.end()) { + nodes_.erase(itr); + nodes_.push_back(node); } } bool DHTBucket::splitAllowed() const { - return _prefixLength < DHT_ID_LENGTH*8-1 && isInRange(_localNode); + return prefixLength_ < DHT_ID_LENGTH*8-1 && isInRange(localNode_); } SharedHandle<DHTBucket> DHTBucket::split() @@ -184,35 +184,35 @@ SharedHandle<DHTBucket> DHTBucket::split() assert(splitAllowed()); unsigned char rMax[DHT_ID_LENGTH]; - memcpy(rMax, _max, DHT_ID_LENGTH); - bitfield::flipBit(rMax, DHT_ID_LENGTH, _prefixLength); + memcpy(rMax, max_, DHT_ID_LENGTH); + bitfield::flipBit(rMax, DHT_ID_LENGTH, prefixLength_); unsigned char rMin[DHT_ID_LENGTH]; - memcpy(rMin, _min, DHT_ID_LENGTH); + memcpy(rMin, min_, DHT_ID_LENGTH); - bitfield::flipBit(_min, DHT_ID_LENGTH, _prefixLength); + bitfield::flipBit(min_, DHT_ID_LENGTH, prefixLength_); - ++_prefixLength; - SharedHandle<DHTBucket> rBucket(new DHTBucket(_prefixLength, - rMax, rMin, _localNode)); + ++prefixLength_; + SharedHandle<DHTBucket> rBucket(new DHTBucket(prefixLength_, + rMax, rMin, localNode_)); std::deque<SharedHandle<DHTNode> > lNodes; - for(std::deque<SharedHandle<DHTNode> >::iterator i = _nodes.begin(), - eoi = _nodes.end(); i != eoi; ++i) { + for(std::deque<SharedHandle<DHTNode> >::iterator i = nodes_.begin(), + eoi = nodes_.end(); i != eoi; ++i) { if(rBucket->isInRange(*i)) { assert(rBucket->addNode(*i)); } else { lNodes.push_back(*i); } } - _nodes = lNodes; + nodes_ = lNodes; // TODO create toString() and use it. - if(_logger->debug()) { - _logger->debug("New bucket. prefixLength=%u, Range:%s-%s", + if(logger_->debug()) { + logger_->debug("New bucket. prefixLength=%u, Range:%s-%s", static_cast<unsigned int>(rBucket->getPrefixLength()), util::toHex(rBucket->getMinID(), DHT_ID_LENGTH).c_str(), util::toHex(rBucket->getMaxID(), DHT_ID_LENGTH).c_str()); - _logger->debug("Existing bucket. prefixLength=%u, Range:%s-%s", - static_cast<unsigned int>(_prefixLength), + logger_->debug("Existing bucket. prefixLength=%u, Range:%s-%s", + static_cast<unsigned int>(prefixLength_), util::toHex(getMinID(), DHT_ID_LENGTH).c_str(), util::toHex(getMaxID(), DHT_ID_LENGTH).c_str()); } @@ -222,7 +222,7 @@ SharedHandle<DHTBucket> DHTBucket::split() void DHTBucket::getGoodNodes (std::vector<SharedHandle<DHTNode> >& goodNodes) const { - goodNodes.insert(goodNodes.end(), _nodes.begin(), _nodes.end()); + goodNodes.insert(goodNodes.end(), nodes_.begin(), nodes_.end()); goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(), mem_fun_sh(&DHTNode::isBad)), goodNodes.end()); } @@ -233,8 +233,8 @@ SharedHandle<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std: node->setIPAddress(ipaddr); node->setPort(port); std::deque<SharedHandle<DHTNode> >::const_iterator itr = - std::find(_nodes.begin(), _nodes.end(), node); - if(itr == _nodes.end()) { + std::find(nodes_.begin(), nodes_.end(), node); + if(itr == nodes_.end()) { return SharedHandle<DHTNode>(); } else { return *itr; @@ -243,19 +243,19 @@ SharedHandle<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std: bool DHTBucket::operator==(const DHTBucket& bucket) const { - return memcmp(_max, bucket._max, DHT_ID_LENGTH) == 0 && - memcmp(_min, bucket._min, DHT_ID_LENGTH) == 0; + return memcmp(max_, bucket.max_, DHT_ID_LENGTH) == 0 && + memcmp(min_, bucket.min_, DHT_ID_LENGTH) == 0; } bool DHTBucket::needsRefresh() const { - return _nodes.size() < K || - _lastUpdated.difference(global::wallclock) >= DHT_BUCKET_REFRESH_INTERVAL; + return nodes_.size() < K || + lastUpdated_.difference(global::wallclock) >= DHT_BUCKET_REFRESH_INTERVAL; } void DHTBucket::notifyUpdate() { - _lastUpdated = global::wallclock; + lastUpdated_ = global::wallclock; } class FindQuestionableNode { @@ -268,14 +268,14 @@ public: bool DHTBucket::containsQuestionableNode() const { - return std::find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode()) != _nodes.end(); + return std::find_if(nodes_.begin(), nodes_.end(), FindQuestionableNode()) != nodes_.end(); } SharedHandle<DHTNode> DHTBucket::getLRUQuestionableNode() const { std::deque<SharedHandle<DHTNode> >::const_iterator i = - std::find_if(_nodes.begin(), _nodes.end(), FindQuestionableNode()); - if(i == _nodes.end()) { + std::find_if(nodes_.begin(), nodes_.end(), FindQuestionableNode()); + if(i == nodes_.end()) { return SharedHandle<DHTNode>(); } else { return *i; diff --git a/src/DHTBucket.h b/src/DHTBucket.h index 4b55d490..709722d5 100644 --- a/src/DHTBucket.h +++ b/src/DHTBucket.h @@ -52,25 +52,25 @@ class Logger; class DHTBucket { private: - size_t _prefixLength; + size_t prefixLength_; - // this bucket contains nodes of distance between [_min, _max](inclusive). - unsigned char _min[DHT_ID_LENGTH]; + // this bucket contains nodes of distance between [min_, max_](inclusive). + unsigned char min_[DHT_ID_LENGTH]; - unsigned char _max[DHT_ID_LENGTH]; + unsigned char max_[DHT_ID_LENGTH]; - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; // sorted in ascending order - std::deque<SharedHandle<DHTNode> > _nodes; + std::deque<SharedHandle<DHTNode> > nodes_; // a replacement cache. The maximum size is specified by CACHE_SIZE. // This is sorted by last time seen. - std::deque<SharedHandle<DHTNode> > _cachedNodes; + std::deque<SharedHandle<DHTNode> > cachedNodes_; - Timer _lastUpdated; + Timer lastUpdated_; - Logger* _logger; + Logger* logger_; bool isInRange(const unsigned char* nodeID, const unsigned char* max, const unsigned char* min) const; @@ -103,27 +103,27 @@ public: size_t getPrefixLength() const { - return _prefixLength; + return prefixLength_; } const unsigned char* getMaxID() const { - return _max; + return max_; } const unsigned char* getMinID() const { - return _min; + return min_; } size_t countNode() const { - return _nodes.size(); + return nodes_.size(); } const std::deque<SharedHandle<DHTNode> >& getNodes() const { - return _nodes; + return nodes_; } void getGoodNodes(std::vector<SharedHandle<DHTNode> >& nodes) const; @@ -150,7 +150,7 @@ public: const std::deque<SharedHandle<DHTNode> >& getCachedNodes() const { - return _cachedNodes; + return cachedNodes_; } }; diff --git a/src/DHTBucketRefreshCommand.cc b/src/DHTBucketRefreshCommand.cc index 85ba9552..5c155872 100644 --- a/src/DHTBucketRefreshCommand.cc +++ b/src/DHTBucketRefreshCommand.cc @@ -62,25 +62,25 @@ void DHTBucketRefreshCommand::preProcess() void DHTBucketRefreshCommand::process() { - _taskQueue->addPeriodicTask1(_taskFactory->createBucketRefreshTask()); + taskQueue_->addPeriodicTask1(taskFactory_->createBucketRefreshTask()); } void DHTBucketRefreshCommand::setRoutingTable (const SharedHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DHTBucketRefreshCommand::setTaskQueue (const SharedHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTBucketRefreshCommand::setTaskFactory (const SharedHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } } // namespace aria2 diff --git a/src/DHTBucketRefreshCommand.h b/src/DHTBucketRefreshCommand.h index b408f1e6..34711475 100644 --- a/src/DHTBucketRefreshCommand.h +++ b/src/DHTBucketRefreshCommand.h @@ -46,11 +46,11 @@ class DHTTaskFactory; class DHTBucketRefreshCommand:public TimeBasedCommand { private: - SharedHandle<DHTRoutingTable> _routingTable; + SharedHandle<DHTRoutingTable> routingTable_; - SharedHandle<DHTTaskQueue> _taskQueue; + SharedHandle<DHTTaskQueue> taskQueue_; - SharedHandle<DHTTaskFactory> _taskFactory; + SharedHandle<DHTTaskFactory> taskFactory_; public: DHTBucketRefreshCommand(cuid_t cuid, DownloadEngine* e, time_t interval); diff --git a/src/DHTBucketRefreshTask.cc b/src/DHTBucketRefreshTask.cc index 84ddc49e..e95c3dc2 100644 --- a/src/DHTBucketRefreshTask.cc +++ b/src/DHTBucketRefreshTask.cc @@ -46,7 +46,7 @@ namespace aria2 { DHTBucketRefreshTask::DHTBucketRefreshTask(): - _forceRefresh(false) {} + forceRefresh_(false) {} DHTBucketRefreshTask::~DHTBucketRefreshTask() {} @@ -56,7 +56,7 @@ void DHTBucketRefreshTask::startup() getRoutingTable()->getBuckets(buckets); for(std::vector<SharedHandle<DHTBucket> >::iterator i = buckets.begin(), eoi = buckets.end(); i != eoi; ++i) { - if(_forceRefresh || (*i)->needsRefresh()) { + if(forceRefresh_ || (*i)->needsRefresh()) { (*i)->notifyUpdate(); unsigned char targetID[DHT_ID_LENGTH]; (*i)->getRandomNodeID(targetID); @@ -77,7 +77,7 @@ void DHTBucketRefreshTask::startup() void DHTBucketRefreshTask::setForceRefresh(bool forceRefresh) { - _forceRefresh = forceRefresh; + forceRefresh_ = forceRefresh; } } // namespace aria2 diff --git a/src/DHTBucketRefreshTask.h b/src/DHTBucketRefreshTask.h index 3f680d99..fbd73153 100644 --- a/src/DHTBucketRefreshTask.h +++ b/src/DHTBucketRefreshTask.h @@ -41,7 +41,7 @@ namespace aria2 { class DHTBucketRefreshTask:public DHTAbstractTask { private: - bool _forceRefresh; + bool forceRefresh_; public: DHTBucketRefreshTask(); diff --git a/src/DHTConnectionImpl.cc b/src/DHTConnectionImpl.cc index 2e27c79d..26bd31ce 100644 --- a/src/DHTConnectionImpl.cc +++ b/src/DHTConnectionImpl.cc @@ -46,8 +46,8 @@ namespace aria2 { -DHTConnectionImpl::DHTConnectionImpl():_socket(new SocketCore(SOCK_DGRAM)), - _logger(LogFactory::getInstance()) {} +DHTConnectionImpl::DHTConnectionImpl():socket_(new SocketCore(SOCK_DGRAM)), + logger_(LogFactory::getInstance()) {} DHTConnectionImpl::~DHTConnectionImpl() {} @@ -73,15 +73,15 @@ bool DHTConnectionImpl::bind(uint16_t& port, IntSequence& ports) bool DHTConnectionImpl::bind(uint16_t& port) { try { - _socket->bind(port); - _socket->setNonBlockingMode(); + socket_->bind(port); + socket_->setNonBlockingMode(); std::pair<std::string, uint16_t> svaddr; - _socket->getAddrInfo(svaddr); + socket_->getAddrInfo(svaddr); port = svaddr.second; - _logger->notice("DHT: listening to port %d", port); + logger_->notice("DHT: listening to port %d", port); return true; } catch(RecoverableException& e) { - _logger->error("Failed to bind for DHT. port=%u", e, port); + logger_->error("Failed to bind for DHT. port=%u", e, port); } return false; } @@ -90,7 +90,7 @@ ssize_t DHTConnectionImpl::receiveMessage(unsigned char* data, size_t len, std::string& host, uint16_t& port) { std::pair<std::string, uint16_t> remoteHost; - ssize_t length = _socket->readDataFrom(data, len, remoteHost); + ssize_t length = socket_->readDataFrom(data, len, remoteHost); if(length == 0) { return length; } else { @@ -103,7 +103,7 @@ ssize_t DHTConnectionImpl::receiveMessage(unsigned char* data, size_t len, ssize_t DHTConnectionImpl::sendMessage(const unsigned char* data, size_t len, const std::string& host, uint16_t port) { - return _socket->writeData(data, len, host, port); + return socket_->writeData(data, len, host, port); } } // namespace aria2 diff --git a/src/DHTConnectionImpl.h b/src/DHTConnectionImpl.h index 2e1b8713..24099edd 100644 --- a/src/DHTConnectionImpl.h +++ b/src/DHTConnectionImpl.h @@ -46,9 +46,9 @@ class Logger; class DHTConnectionImpl:public DHTConnection { private: - SharedHandle<SocketCore> _socket; + SharedHandle<SocketCore> socket_; - Logger* _logger; + Logger* logger_; public: DHTConnectionImpl(); @@ -79,7 +79,7 @@ public: const SharedHandle<SocketCore>& getSocket() const { - return _socket; + return socket_; } }; diff --git a/src/DHTEntryPointNameResolveCommand.cc b/src/DHTEntryPointNameResolveCommand.cc index 38ed3b36..5d25f26c 100644 --- a/src/DHTEntryPointNameResolveCommand.cc +++ b/src/DHTEntryPointNameResolveCommand.cc @@ -62,75 +62,75 @@ DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand (cuid_t cuid, DownloadEngine* e, const std::vector<std::pair<std::string, uint16_t> >& entryPoints): Command(cuid), - _e(e), - _entryPoints(entryPoints.begin(), entryPoints.end()), - _bootstrapEnabled(false) + e_(e), + entryPoints_(entryPoints.begin(), entryPoints.end()), + bootstrapEnabled_(false) {} DHTEntryPointNameResolveCommand::~DHTEntryPointNameResolveCommand() { #ifdef ENABLE_ASYNC_DNS - disableNameResolverCheck(_resolver); + disableNameResolverCheck(resolver_); #endif // ENABLE_ASYNC_DNS } bool DHTEntryPointNameResolveCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } #ifdef ENABLE_ASYNC_DNS - if(_resolver.isNull()) { - _resolver.reset(new AsyncNameResolver()); + if(resolver_.isNull()) { + resolver_.reset(new AsyncNameResolver()); } #endif // ENABLE_ASYNC_DNS try { #ifdef ENABLE_ASYNC_DNS - if(_e->getOption()->getAsBool(PREF_ASYNC_DNS)) { - while(!_entryPoints.empty()) { - std::string hostname = _entryPoints.front().first; + if(e_->getOption()->getAsBool(PREF_ASYNC_DNS)) { + while(!entryPoints_.empty()) { + std::string hostname = entryPoints_.front().first; try { - if(resolveHostname(hostname, _resolver)) { - hostname = _resolver->getResolvedAddresses().front(); + if(resolveHostname(hostname, resolver_)) { + hostname = resolver_->getResolvedAddresses().front(); std::pair<std::string, uint16_t> p(hostname, - _entryPoints.front().second); - _resolvedEntryPoints.push_back(p); + entryPoints_.front().second); + resolvedEntryPoints_.push_back(p); addPingTask(p); } else { - _e->addCommand(this); + e_->addCommand(this); return false; } } catch(RecoverableException& e) { getLogger()->error(EX_EXCEPTION_CAUGHT, e); } - _resolver->reset(); - _entryPoints.pop_front(); + resolver_->reset(); + entryPoints_.pop_front(); } } else #endif // ENABLE_ASYNC_DNS { NameResolver res; res.setSocktype(SOCK_DGRAM); - while(!_entryPoints.empty()) { - std::string hostname = _entryPoints.front().first; + while(!entryPoints_.empty()) { + std::string hostname = entryPoints_.front().first; try { std::vector<std::string> addrs; res.resolve(addrs, hostname); std::pair<std::string, uint16_t> p(addrs.front(), - _entryPoints.front().second); - _resolvedEntryPoints.push_back(p); + entryPoints_.front().second); + resolvedEntryPoints_.push_back(p); addPingTask(p); } catch(RecoverableException& e) { getLogger()->error(EX_EXCEPTION_CAUGHT, e); } - _entryPoints.pop_front(); + entryPoints_.pop_front(); } } - if(_bootstrapEnabled && _resolvedEntryPoints.size()) { - _taskQueue->addPeriodicTask1(_taskFactory->createNodeLookupTask - (_localNode->getID())); - _taskQueue->addPeriodicTask1(_taskFactory->createBucketRefreshTask()); + if(bootstrapEnabled_ && resolvedEntryPoints_.size()) { + taskQueue_->addPeriodicTask1(taskFactory_->createNodeLookupTask + (localNode_->getID())); + taskQueue_->addPeriodicTask1(taskFactory_->createBucketRefreshTask()); } } catch(RecoverableException& e) { getLogger()->error(EX_EXCEPTION_CAUGHT, e); @@ -145,7 +145,7 @@ void DHTEntryPointNameResolveCommand::addPingTask entryNode->setIPAddress(addr.first); entryNode->setPort(addr.second); - _taskQueue->addPeriodicTask1(_taskFactory->createPingTask(entryNode, 10)); + taskQueue_->addPeriodicTask1(taskFactory_->createPingTask(entryNode, 10)); } #ifdef ENABLE_ASYNC_DNS @@ -186,43 +186,43 @@ bool DHTEntryPointNameResolveCommand::resolveHostname void DHTEntryPointNameResolveCommand::setNameResolverCheck (const SharedHandle<AsyncNameResolver>& resolver) { - _e->addNameResolverCheck(resolver, this); + e_->addNameResolverCheck(resolver, this); } void DHTEntryPointNameResolveCommand::disableNameResolverCheck (const SharedHandle<AsyncNameResolver>& resolver) { - _e->deleteNameResolverCheck(resolver, this); + e_->deleteNameResolverCheck(resolver, this); } #endif // ENABLE_ASYNC_DNS void DHTEntryPointNameResolveCommand::setBootstrapEnabled(bool f) { - _bootstrapEnabled = f; + bootstrapEnabled_ = f; } void DHTEntryPointNameResolveCommand::setTaskQueue (const SharedHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTEntryPointNameResolveCommand::setTaskFactory (const SharedHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } void DHTEntryPointNameResolveCommand::setRoutingTable (const SharedHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DHTEntryPointNameResolveCommand::setLocalNode (const SharedHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } } // namespace aria2 diff --git a/src/DHTEntryPointNameResolveCommand.h b/src/DHTEntryPointNameResolveCommand.h index 9c0c61a0..4e228d46 100644 --- a/src/DHTEntryPointNameResolveCommand.h +++ b/src/DHTEntryPointNameResolveCommand.h @@ -56,25 +56,25 @@ class AsyncNameResolver; class DHTEntryPointNameResolveCommand:public Command { private: - DownloadEngine* _e; + DownloadEngine* e_; #ifdef ENABLE_ASYNC_DNS - SharedHandle<AsyncNameResolver> _resolver; + SharedHandle<AsyncNameResolver> resolver_; #endif // ENABLE_ASYNC_DNS - SharedHandle<DHTTaskQueue> _taskQueue; + SharedHandle<DHTTaskQueue> taskQueue_; - SharedHandle<DHTTaskFactory> _taskFactory; + SharedHandle<DHTTaskFactory> taskFactory_; - SharedHandle<DHTRoutingTable> _routingTable; + SharedHandle<DHTRoutingTable> routingTable_; - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - std::deque<std::pair<std::string, uint16_t> > _entryPoints; + std::deque<std::pair<std::string, uint16_t> > entryPoints_; - std::vector<std::pair<std::string, uint16_t> > _resolvedEntryPoints; + std::vector<std::pair<std::string, uint16_t> > resolvedEntryPoints_; - bool _bootstrapEnabled; + bool bootstrapEnabled_; void addPingTask(const std::pair<std::string, uint16_t>& addr); diff --git a/src/DHTFindNodeMessage.cc b/src/DHTFindNodeMessage.cc index 7fbe5639..ede5f57f 100644 --- a/src/DHTFindNodeMessage.cc +++ b/src/DHTFindNodeMessage.cc @@ -55,7 +55,7 @@ DHTFindNodeMessage::DHTFindNodeMessage(const SharedHandle<DHTNode>& localNode, const std::string& transactionID): DHTQueryMessage(localNode, remoteNode, transactionID) { - memcpy(_targetNodeID, targetNodeID, DHT_ID_LENGTH); + memcpy(targetNodeID_, targetNodeID, DHT_ID_LENGTH); } DHTFindNodeMessage::~DHTFindNodeMessage() {} @@ -63,7 +63,7 @@ DHTFindNodeMessage::~DHTFindNodeMessage() {} void DHTFindNodeMessage::doReceivedAction() { std::vector<SharedHandle<DHTNode> > nodes; - getRoutingTable()->getClosestKNodes(nodes, _targetNodeID); + getRoutingTable()->getClosestKNodes(nodes, targetNodeID_); SharedHandle<DHTMessage> reply = getMessageFactory()->createFindNodeReplyMessage (getRemoteNode(), nodes, getTransactionID()); @@ -74,7 +74,7 @@ SharedHandle<Dict> DHTFindNodeMessage::getArgument() { SharedHandle<Dict> aDict = Dict::g(); aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH)); - aDict->put(TARGET_NODE, String::g(_targetNodeID, DHT_ID_LENGTH)); + aDict->put(TARGET_NODE, String::g(targetNodeID_, DHT_ID_LENGTH)); return aDict; } @@ -85,7 +85,7 @@ const std::string& DHTFindNodeMessage::getMessageType() const std::string DHTFindNodeMessage::toStringOptional() const { - return "targetNodeID="+util::toHex(_targetNodeID, DHT_ID_LENGTH); + return "targetNodeID="+util::toHex(targetNodeID_, DHT_ID_LENGTH); } } // namespace aria2 diff --git a/src/DHTFindNodeMessage.h b/src/DHTFindNodeMessage.h index 2df5d86e..7f3c24ae 100644 --- a/src/DHTFindNodeMessage.h +++ b/src/DHTFindNodeMessage.h @@ -42,7 +42,7 @@ namespace aria2 { class DHTFindNodeMessage:public DHTQueryMessage { private: - unsigned char _targetNodeID[DHT_ID_LENGTH]; + unsigned char targetNodeID_[DHT_ID_LENGTH]; protected: virtual std::string toStringOptional() const; public: @@ -61,7 +61,7 @@ public: const unsigned char* getTargetNodeID() const { - return _targetNodeID; + return targetNodeID_; } static const std::string FIND_NODE; diff --git a/src/DHTFindNodeReplyMessage.cc b/src/DHTFindNodeReplyMessage.cc index bdd186ef..9bd3fcb6 100644 --- a/src/DHTFindNodeReplyMessage.cc +++ b/src/DHTFindNodeReplyMessage.cc @@ -61,8 +61,8 @@ DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {} void DHTFindNodeReplyMessage::doReceivedAction() { - for(std::vector<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin(), - eoi = _closestKNodes.end(); i != eoi; ++i) { + for(std::vector<SharedHandle<DHTNode> >::iterator i = closestKNodes_.begin(), + eoi = closestKNodes_.end(); i != eoi; ++i) { if(memcmp((*i)->getID(), getLocalNode()->getID(), DHT_ID_LENGTH) != 0) { getRoutingTable()->addNode(*i); } @@ -75,9 +75,9 @@ SharedHandle<Dict> DHTFindNodeReplyMessage::getResponse() aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH)); size_t offset = 0; unsigned char buffer[DHTBucket::K*26]; - // TODO if _closestKNodes.size() > DHTBucket::K ?? + // TODO if closestKNodes_.size() > DHTBucket::K ?? for(std::vector<SharedHandle<DHTNode> >::const_iterator i = - _closestKNodes.begin(), eoi = _closestKNodes.end(); + closestKNodes_.begin(), eoi = closestKNodes_.end(); i != eoi && offset < DHTBucket::K*26; ++i) { SharedHandle<DHTNode> node = *i; memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH); @@ -103,12 +103,12 @@ void DHTFindNodeReplyMessage::accept(DHTMessageCallback* callback) void DHTFindNodeReplyMessage::setClosestKNodes (const std::vector<SharedHandle<DHTNode> >& closestKNodes) { - _closestKNodes = closestKNodes; + closestKNodes_ = closestKNodes; } std::string DHTFindNodeReplyMessage::toStringOptional() const { - return "nodes="+util::uitos(_closestKNodes.size()); + return "nodes="+util::uitos(closestKNodes_.size()); } } // namespace aria2 diff --git a/src/DHTFindNodeReplyMessage.h b/src/DHTFindNodeReplyMessage.h index 0bc408e1..9e14bd2c 100644 --- a/src/DHTFindNodeReplyMessage.h +++ b/src/DHTFindNodeReplyMessage.h @@ -42,7 +42,7 @@ namespace aria2 { class DHTFindNodeReplyMessage:public DHTResponseMessage { private: - std::vector<SharedHandle<DHTNode> > _closestKNodes; + std::vector<SharedHandle<DHTNode> > closestKNodes_; protected: virtual std::string toStringOptional() const; public: @@ -62,7 +62,7 @@ public: const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const { - return _closestKNodes; + return closestKNodes_; } void setClosestKNodes diff --git a/src/DHTGetPeersCommand.cc b/src/DHTGetPeersCommand.cc index 298f81e3..1ab987e8 100644 --- a/src/DHTGetPeersCommand.cc +++ b/src/DHTGetPeersCommand.cc @@ -58,68 +58,68 @@ DHTGetPeersCommand::DHTGetPeersCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e): Command(cuid), - _requestGroup(requestGroup), - _e(e), - _numRetry(0), - _lastGetPeerTime(0) + requestGroup_(requestGroup), + e_(e), + numRetry_(0), + lastGetPeerTime_(0) { - _requestGroup->increaseNumCommand(); + requestGroup_->increaseNumCommand(); } DHTGetPeersCommand::~DHTGetPeersCommand() { - _requestGroup->decreaseNumCommand(); + requestGroup_->decreaseNumCommand(); } bool DHTGetPeersCommand::execute() { - if(_btRuntime->isHalt()) { + if(btRuntime_->isHalt()) { return true; } - if(_task.isNull() && - ((_numRetry > 0 && - _lastGetPeerTime.difference(global::wallclock) >= (time_t)_numRetry*5) || - _lastGetPeerTime.difference(global::wallclock) >= GET_PEER_INTERVAL)) { + if(task_.isNull() && + ((numRetry_ > 0 && + lastGetPeerTime_.difference(global::wallclock) >= (time_t)numRetry_*5) || + lastGetPeerTime_.difference(global::wallclock) >= GET_PEER_INTERVAL)) { if(getLogger()->debug()) { getLogger()->debug("Issuing PeerLookup for infoHash=%s", bittorrent::getInfoHashString - (_requestGroup->getDownloadContext()).c_str()); + (requestGroup_->getDownloadContext()).c_str()); } - _task = _taskFactory->createPeerLookupTask - (_requestGroup->getDownloadContext(), _btRuntime, _peerStorage); - _taskQueue->addPeriodicTask2(_task); - } else if(!_task.isNull() && _task->finished()) { - _lastGetPeerTime = global::wallclock; - if(_numRetry < MAX_RETRIES && _btRuntime->lessThanMinPeers()) { - ++_numRetry; + task_ = taskFactory_->createPeerLookupTask + (requestGroup_->getDownloadContext(), btRuntime_, peerStorage_); + taskQueue_->addPeriodicTask2(task_); + } else if(!task_.isNull() && task_->finished()) { + lastGetPeerTime_ = global::wallclock; + if(numRetry_ < MAX_RETRIES && btRuntime_->lessThanMinPeers()) { + ++numRetry_; } else { - _numRetry = 0; + numRetry_ = 0; } - _task.reset(); + task_.reset(); } - _e->addCommand(this); + e_->addCommand(this); return false; } void DHTGetPeersCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTGetPeersCommand::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } void DHTGetPeersCommand::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void DHTGetPeersCommand::setPeerStorage(const SharedHandle<PeerStorage>& ps) { - _peerStorage = ps; + peerStorage_ = ps; } } // namespace aria2 diff --git a/src/DHTGetPeersCommand.h b/src/DHTGetPeersCommand.h index 753dfda5..553450a0 100644 --- a/src/DHTGetPeersCommand.h +++ b/src/DHTGetPeersCommand.h @@ -56,23 +56,23 @@ private: static const size_t MAX_RETRIES = 10; - RequestGroup* _requestGroup; + RequestGroup* requestGroup_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - DownloadEngine* _e; + DownloadEngine* e_; - SharedHandle<DHTTaskQueue> _taskQueue; + SharedHandle<DHTTaskQueue> taskQueue_; - SharedHandle<DHTTaskFactory> _taskFactory; + SharedHandle<DHTTaskFactory> taskFactory_; - SharedHandle<DHTTask> _task; + SharedHandle<DHTTask> task_; - size_t _numRetry; + size_t numRetry_; - Timer _lastGetPeerTime; + Timer lastGetPeerTime_; public: DHTGetPeersCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e); diff --git a/src/DHTGetPeersMessage.cc b/src/DHTGetPeersMessage.cc index 608646b2..9f838a05 100644 --- a/src/DHTGetPeersMessage.cc +++ b/src/DHTGetPeersMessage.cc @@ -58,22 +58,22 @@ DHTGetPeersMessage::DHTGetPeersMessage(const SharedHandle<DHTNode>& localNode, const std::string& transactionID): DHTQueryMessage(localNode, remoteNode, transactionID) { - memcpy(_infoHash, infoHash, DHT_ID_LENGTH); + memcpy(infoHash_, infoHash, DHT_ID_LENGTH); } DHTGetPeersMessage::~DHTGetPeersMessage() {} void DHTGetPeersMessage::doReceivedAction() { - std::string token = _tokenTracker->generateToken - (_infoHash, getRemoteNode()->getIPAddress(), getRemoteNode()->getPort()); + std::string token = tokenTracker_->generateToken + (infoHash_, getRemoteNode()->getIPAddress(), getRemoteNode()->getPort()); // Check to see localhost has the contents which has same infohash std::vector<SharedHandle<Peer> > peers; - _peerAnnounceStorage->getPeers(peers, _infoHash); + peerAnnounceStorage_->getPeers(peers, infoHash_); SharedHandle<DHTMessage> reply; if(peers.empty()) { std::vector<SharedHandle<DHTNode> > nodes; - getRoutingTable()->getClosestKNodes(nodes, _infoHash); + getRoutingTable()->getClosestKNodes(nodes, infoHash_); reply = getMessageFactory()->createGetPeersReplyMessage (getRemoteNode(), nodes, token, getTransactionID()); @@ -89,7 +89,7 @@ SharedHandle<Dict> DHTGetPeersMessage::getArgument() { SharedHandle<Dict> aDict = Dict::g(); aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH)); - aDict->put(INFO_HASH, String::g(_infoHash, DHT_ID_LENGTH)); + aDict->put(INFO_HASH, String::g(infoHash_, DHT_ID_LENGTH)); return aDict; } @@ -101,18 +101,18 @@ const std::string& DHTGetPeersMessage::getMessageType() const void DHTGetPeersMessage::setPeerAnnounceStorage (const WeakHandle<DHTPeerAnnounceStorage>& storage) { - _peerAnnounceStorage = storage; + peerAnnounceStorage_ = storage; } void DHTGetPeersMessage::setTokenTracker (const WeakHandle<DHTTokenTracker>& tokenTracker) { - _tokenTracker = tokenTracker; + tokenTracker_ = tokenTracker; } std::string DHTGetPeersMessage::toStringOptional() const { - return "info_hash="+util::toHex(_infoHash, INFO_HASH_LENGTH); + return "info_hash="+util::toHex(infoHash_, INFO_HASH_LENGTH); } } // namespace aria2 diff --git a/src/DHTGetPeersMessage.h b/src/DHTGetPeersMessage.h index a0a8a94b..3b3d25e4 100644 --- a/src/DHTGetPeersMessage.h +++ b/src/DHTGetPeersMessage.h @@ -46,11 +46,11 @@ class DHTTokenTracker; class DHTGetPeersMessage:public DHTQueryMessage { private: - unsigned char _infoHash[DHT_ID_LENGTH]; + unsigned char infoHash_[DHT_ID_LENGTH]; - WeakHandle<DHTPeerAnnounceStorage> _peerAnnounceStorage; + WeakHandle<DHTPeerAnnounceStorage> peerAnnounceStorage_; - WeakHandle<DHTTokenTracker> _tokenTracker; + WeakHandle<DHTTokenTracker> tokenTracker_; protected: virtual std::string toStringOptional() const; public: @@ -69,7 +69,7 @@ public: const unsigned char* getInfoHash() const { - return _infoHash; + return infoHash_; } void setPeerAnnounceStorage diff --git a/src/DHTGetPeersReplyMessage.cc b/src/DHTGetPeersReplyMessage.cc index ff621a69..a7ead1b0 100644 --- a/src/DHTGetPeersReplyMessage.cc +++ b/src/DHTGetPeersReplyMessage.cc @@ -63,7 +63,7 @@ DHTGetPeersReplyMessage::DHTGetPeersReplyMessage const std::string& token, const std::string& transactionID): DHTResponseMessage(localNode, remoteNode, transactionID), - _token(token) {} + token_(token) {} DHTGetPeersReplyMessage::~DHTGetPeersReplyMessage() {} @@ -76,12 +76,12 @@ SharedHandle<Dict> DHTGetPeersReplyMessage::getResponse() { SharedHandle<Dict> rDict = Dict::g(); rDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH)); - rDict->put(TOKEN, _token); - if(_values.empty()) { + rDict->put(TOKEN, token_); + if(values_.empty()) { size_t offset = 0; unsigned char buffer[DHTBucket::K*26]; for(std::vector<SharedHandle<DHTNode> >::const_iterator i = - _closestKNodes.begin(), eoi = _closestKNodes.end(); + closestKNodes_.begin(), eoi = closestKNodes_.end(); i != eoi && offset < DHTBucket::K*26; ++i) { SharedHandle<DHTNode> node = *i; memcpy(buffer+offset, node->getID(), DHT_ID_LENGTH); @@ -113,8 +113,8 @@ SharedHandle<Dict> DHTGetPeersReplyMessage::getResponse() // number of peer info that a message can carry. static const size_t MAX_VALUES_SIZE = 100; SharedHandle<List> valuesList = List::g(); - for(std::vector<SharedHandle<Peer> >::const_iterator i = _values.begin(), - eoi = _values.end(); i != eoi && valuesList->size() < MAX_VALUES_SIZE; + for(std::vector<SharedHandle<Peer> >::const_iterator i = values_.begin(), + eoi = values_.end(); i != eoi && valuesList->size() < MAX_VALUES_SIZE; ++i) { const SharedHandle<Peer>& peer = *i; unsigned char buffer[6]; @@ -140,9 +140,9 @@ void DHTGetPeersReplyMessage::accept(DHTMessageCallback* callback) std::string DHTGetPeersReplyMessage::toStringOptional() const { - return strconcat("token=", util::toHex(_token), - ", values=", util::uitos(_values.size()), - ", nodes=", util::uitos(_closestKNodes.size())); + return strconcat("token=", util::toHex(token_), + ", values=", util::uitos(values_.size()), + ", nodes=", util::uitos(closestKNodes_.size())); } } // namespace aria2 diff --git a/src/DHTGetPeersReplyMessage.h b/src/DHTGetPeersReplyMessage.h index 63045803..b15a41c4 100644 --- a/src/DHTGetPeersReplyMessage.h +++ b/src/DHTGetPeersReplyMessage.h @@ -47,11 +47,11 @@ class Peer; class DHTGetPeersReplyMessage:public DHTResponseMessage { private: - std::string _token; + std::string token_; - std::vector<SharedHandle<DHTNode> > _closestKNodes; + std::vector<SharedHandle<DHTNode> > closestKNodes_; - std::vector<SharedHandle<Peer> > _values; + std::vector<SharedHandle<Peer> > values_; protected: virtual std::string toStringOptional() const; public: @@ -72,28 +72,28 @@ public: const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const { - return _closestKNodes; + return closestKNodes_; } const std::vector<SharedHandle<Peer> >& getValues() const { - return _values; + return values_; } void setClosestKNodes (const std::vector<SharedHandle<DHTNode> >& closestKNodes) { - _closestKNodes = closestKNodes; + closestKNodes_ = closestKNodes; } void setValues(const std::vector<SharedHandle<Peer> >& peers) { - _values = peers; + values_ = peers; } const std::string& getToken() const { - return _token; + return token_; } static const std::string GET_PEERS; diff --git a/src/DHTIDCloser.h b/src/DHTIDCloser.h index beccd001..18bb2c1f 100644 --- a/src/DHTIDCloser.h +++ b/src/DHTIDCloser.h @@ -44,16 +44,16 @@ namespace aria2 { class DHTIDCloser { private: - const unsigned char* _targetID; + const unsigned char* targetID_; - XORCloser _closer; + XORCloser closer_; public: - DHTIDCloser(const unsigned char* targetID):_closer(targetID, DHT_ID_LENGTH) {} + DHTIDCloser(const unsigned char* targetID):closer_(targetID, DHT_ID_LENGTH) {} bool operator()(const SharedHandle<DHTNodeLookupEntry>& m1, const SharedHandle<DHTNodeLookupEntry>& m2) const { - return _closer(m1->node->getID(), m2->node->getID()); + return closer_(m1->node->getID(), m2->node->getID()); } }; diff --git a/src/DHTInteractionCommand.cc b/src/DHTInteractionCommand.cc index 2302cc17..347b8ec9 100644 --- a/src/DHTInteractionCommand.cc +++ b/src/DHTInteractionCommand.cc @@ -54,61 +54,61 @@ namespace aria2 { DHTInteractionCommand::DHTInteractionCommand(cuid_t cuid, DownloadEngine* e): Command(cuid), - _e(e) {} + e_(e) {} DHTInteractionCommand::~DHTInteractionCommand() { - disableReadCheckSocket(_readCheckSocket); + disableReadCheckSocket(readCheckSocket_); } void DHTInteractionCommand::setReadCheckSocket(const SocketHandle& socket) { - _readCheckSocket = socket; - _e->addSocketForReadCheck(socket, this); + readCheckSocket_ = socket; + e_->addSocketForReadCheck(socket, this); } void DHTInteractionCommand::disableReadCheckSocket(const SocketHandle& socket) { - _e->deleteSocketForReadCheck(socket, this); + e_->deleteSocketForReadCheck(socket, this); } bool DHTInteractionCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } - _taskQueue->executeTask(); + taskQueue_->executeTask(); for(size_t i = 0; i < 20; ++i) { - SharedHandle<DHTMessage> m = _receiver->receiveMessage(); + SharedHandle<DHTMessage> m = receiver_->receiveMessage(); if(m.isNull()) { break; } } - _receiver->handleTimeout(); + receiver_->handleTimeout(); try { - _dispatcher->sendMessages(); + dispatcher_->sendMessages(); } catch(RecoverableException& e) { getLogger()->error(EX_EXCEPTION_CAUGHT, e); } - _e->addCommand(this); + e_->addCommand(this); return false; } void DHTInteractionCommand::setMessageDispatcher(const SharedHandle<DHTMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DHTInteractionCommand::setMessageReceiver(const SharedHandle<DHTMessageReceiver>& receiver) { - _receiver = receiver; + receiver_ = receiver; } void DHTInteractionCommand::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } } // namespace aria2 diff --git a/src/DHTInteractionCommand.h b/src/DHTInteractionCommand.h index 4afc014a..9845a5e3 100644 --- a/src/DHTInteractionCommand.h +++ b/src/DHTInteractionCommand.h @@ -48,11 +48,11 @@ class SocketCore; class DHTInteractionCommand:public Command { private: - DownloadEngine* _e; - SharedHandle<DHTMessageDispatcher> _dispatcher; - SharedHandle<DHTMessageReceiver> _receiver; - SharedHandle<DHTTaskQueue> _taskQueue; - SharedHandle<SocketCore> _readCheckSocket; + DownloadEngine* e_; + SharedHandle<DHTMessageDispatcher> dispatcher_; + SharedHandle<DHTMessageReceiver> receiver_; + SharedHandle<DHTTaskQueue> taskQueue_; + SharedHandle<SocketCore> readCheckSocket_; public: DHTInteractionCommand(cuid_t cuid, DownloadEngine* e); diff --git a/src/DHTMessage.cc b/src/DHTMessage.cc index ce033ea2..d6357f90 100644 --- a/src/DHTMessage.cc +++ b/src/DHTMessage.cc @@ -49,7 +49,7 @@ const std::string DHTMessage::ID("id"); DHTMessage::DHTMessage(const SharedHandle<DHTNode>& localNode, const SharedHandle<DHTNode>& remoteNode, const std::string& transactionID): - _localNode(localNode), _remoteNode(remoteNode), _transactionID(transactionID) + localNode_(localNode), remoteNode_(remoteNode), transactionID_(transactionID) { if(transactionID.empty()) { generateTransactionID(); @@ -62,7 +62,7 @@ void DHTMessage::generateTransactionID() { unsigned char tid[DHT_TRANSACTION_ID_LENGTH]; util::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH); - _transactionID = std::string(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); + transactionID_ = std::string(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]); } } // namespace aria2 diff --git a/src/DHTMessage.h b/src/DHTMessage.h index c2c46eed..34d38e11 100644 --- a/src/DHTMessage.h +++ b/src/DHTMessage.h @@ -48,13 +48,13 @@ class DHTNode; class DHTMessage { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - SharedHandle<DHTNode> _remoteNode; + SharedHandle<DHTNode> remoteNode_; - std::string _transactionID; + std::string transactionID_; - std::string _version; + std::string version_; void generateTransactionID(); public: @@ -66,17 +66,17 @@ public: const std::string& getTransactionID() const { - return _transactionID; + return transactionID_; } const SharedHandle<DHTNode>& getLocalNode() const { - return _localNode; + return localNode_; } const SharedHandle<DHTNode>& getRemoteNode() const { - return _remoteNode; + return remoteNode_; } virtual void doReceivedAction() = 0; @@ -93,12 +93,12 @@ public: const std::string& getVersion() const { - return _version; + return version_; } void setVersion(const std::string& version) { - _version = version; + version_ = version; } static const std::string Y; diff --git a/src/DHTMessageDispatcherImpl.cc b/src/DHTMessageDispatcherImpl.cc index 2ea04c16..f786b5fb 100644 --- a/src/DHTMessageDispatcherImpl.cc +++ b/src/DHTMessageDispatcherImpl.cc @@ -48,9 +48,9 @@ namespace aria2 { DHTMessageDispatcherImpl::DHTMessageDispatcherImpl (const SharedHandle<DHTMessageTracker>& tracker): - _tracker(tracker), - _timeout(DHT_MESSAGE_TIMEOUT), - _logger(LogFactory::getInstance()) {} + tracker_(tracker), + timeout_(DHT_MESSAGE_TIMEOUT), + logger_(LogFactory::getInstance()) {} DHTMessageDispatcherImpl::~DHTMessageDispatcherImpl() {} @@ -62,7 +62,7 @@ DHTMessageDispatcherImpl::addMessageToQueue { SharedHandle<DHTMessageEntry> e (new DHTMessageEntry(message, timeout, callback)); - _messageQueue.push_back(e); + messageQueue_.push_back(e); } void @@ -70,7 +70,7 @@ DHTMessageDispatcherImpl::addMessageToQueue (const SharedHandle<DHTMessage>& message, const SharedHandle<DHTMessageCallback>& callback) { - addMessageToQueue(message, _timeout, callback); + addMessageToQueue(message, timeout_, callback); } bool @@ -80,23 +80,23 @@ DHTMessageDispatcherImpl::sendMessage try { if(entry->message->send()) { if(!entry->message->isReply()) { - _tracker->addMessage(entry->message, entry->timeout, entry->callback); + tracker_->addMessage(entry->message, entry->timeout, entry->callback); } - if(_logger->info()) { - _logger->info("Message sent: %s", entry->message->toString().c_str()); + if(logger_->info()) { + logger_->info("Message sent: %s", entry->message->toString().c_str()); } } else { return false; } } catch(RecoverableException& e) { - _logger->info("Failed to send message: %s", + logger_->info("Failed to send message: %s", e, entry->message->toString().c_str()); // Add message to DHTMessageTracker with timeout 0 to treat it as // time out. Without this, we have untracked message and some of // DHTTask(such as DHTAbstractNodeLookupTask) don't finish // forever. if(!entry->message->isReply()) { - _tracker->addMessage(entry->message, 0, entry->callback); + tracker_->addMessage(entry->message, 0, entry->callback); } } return true; @@ -107,22 +107,22 @@ void DHTMessageDispatcherImpl::sendMessages() // TODO I can't use bind1st and mem_fun here because bind1st cannot bind a // function which takes a reference as an argument.. std::deque<SharedHandle<DHTMessageEntry> >::iterator itr = - _messageQueue.begin(); - for(; itr != _messageQueue.end(); ++itr) { + messageQueue_.begin(); + for(; itr != messageQueue_.end(); ++itr) { if(!sendMessage(*itr)) { break; } } - _messageQueue.erase(_messageQueue.begin(), itr); - if(_logger->debug()) { - _logger->debug("%lu dht messages remaining in the queue.", - static_cast<unsigned long>(_messageQueue.size())); + messageQueue_.erase(messageQueue_.begin(), itr); + if(logger_->debug()) { + logger_->debug("%lu dht messages remaining in the queue.", + static_cast<unsigned long>(messageQueue_.size())); } } size_t DHTMessageDispatcherImpl::countMessageInQueue() const { - return _messageQueue.size(); + return messageQueue_.size(); } } // namespace aria2 diff --git a/src/DHTMessageDispatcherImpl.h b/src/DHTMessageDispatcherImpl.h index 650030d7..c306e7cc 100644 --- a/src/DHTMessageDispatcherImpl.h +++ b/src/DHTMessageDispatcherImpl.h @@ -46,13 +46,13 @@ class Logger; class DHTMessageDispatcherImpl:public DHTMessageDispatcher { private: - SharedHandle<DHTMessageTracker> _tracker; + SharedHandle<DHTMessageTracker> tracker_; - std::deque<SharedHandle<DHTMessageEntry> > _messageQueue; + std::deque<SharedHandle<DHTMessageEntry> > messageQueue_; - time_t _timeout; + time_t timeout_; - Logger* _logger; + Logger* logger_; bool sendMessage(const SharedHandle<DHTMessageEntry>& msg); public: @@ -77,7 +77,7 @@ public: void setTimeout(time_t timeout) { - _timeout = timeout; + timeout_ = timeout; } }; diff --git a/src/DHTMessageFactoryImpl.cc b/src/DHTMessageFactoryImpl.cc index 5c1c51cb..1bd803c2 100644 --- a/src/DHTMessageFactoryImpl.cc +++ b/src/DHTMessageFactoryImpl.cc @@ -65,7 +65,7 @@ namespace aria2 { DHTMessageFactoryImpl::DHTMessageFactoryImpl(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} DHTMessageFactoryImpl::~DHTMessageFactoryImpl() {} @@ -73,7 +73,7 @@ SharedHandle<DHTNode> DHTMessageFactoryImpl::getRemoteNode (const unsigned char* id, const std::string& ipaddr, uint16_t port) const { - SharedHandle<DHTNode> node = _routingTable->getNode(id, ipaddr, port); + SharedHandle<DHTNode> node = routingTable_->getNode(id, ipaddr, port); if(node.isNull()) { node.reset(new DHTNode(id)); node->setIPAddress(ipaddr); @@ -235,14 +235,14 @@ DHTMessageFactoryImpl::createResponseMessage // for now, just report error message arrived and throw exception. const List* e = getList(dict, DHTUnknownMessage::E); if(e->size() == 2) { - if(_logger->info()) { - _logger->info("Received Error DHT message. code=%s, msg=%s", + if(logger_->info()) { + logger_->info("Received Error DHT message. code=%s, msg=%s", util::itos(getInteger(e, 0)->i()).c_str(), util::percentEncode(getString(e, 1)->s()).c_str()); } } else { - if(_logger->debug()) { - _logger->debug("e doesn't have 2 elements."); + if(logger_->debug()) { + logger_->debug("e doesn't have 2 elements."); } } throw DL_ABORT_EX("Received Error DHT message."); @@ -302,9 +302,9 @@ static const std::string& getDefaultVersion() void DHTMessageFactoryImpl::setCommonProperty (const SharedHandle<DHTAbstractMessage>& m) { - m->setConnection(_connection); - m->setMessageDispatcher(_dispatcher); - m->setRoutingTable(_routingTable); + m->setConnection(connection_); + m->setMessageDispatcher(dispatcher_); + m->setRoutingTable(routingTable_); WeakHandle<DHTMessageFactory> factory(this); m->setMessageFactory(factory); m->setVersion(getDefaultVersion()); @@ -314,7 +314,7 @@ SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createPingMessage (const SharedHandle<DHTNode>& remoteNode, const std::string& transactionID) { SharedHandle<DHTPingMessage> m - (new DHTPingMessage(_localNode, remoteNode, transactionID)); + (new DHTPingMessage(localNode_, remoteNode, transactionID)); setCommonProperty(m); return m; } @@ -325,7 +325,7 @@ SharedHandle<DHTResponseMessage> DHTMessageFactoryImpl::createPingReplyMessage const std::string& transactionID) { SharedHandle<DHTPingReplyMessage> m - (new DHTPingReplyMessage(_localNode, remoteNode, id, transactionID)); + (new DHTPingReplyMessage(localNode_, remoteNode, id, transactionID)); setCommonProperty(m); return m; } @@ -337,7 +337,7 @@ SharedHandle<DHTQueryMessage> DHTMessageFactoryImpl::createFindNodeMessage { SharedHandle<DHTFindNodeMessage> m (new DHTFindNodeMessage - (_localNode, remoteNode, targetNodeID, transactionID)); + (localNode_, remoteNode, targetNodeID, transactionID)); setCommonProperty(m); return m; } @@ -349,7 +349,7 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage const std::string& transactionID) { SharedHandle<DHTFindNodeReplyMessage> m - (new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID)); + (new DHTFindNodeReplyMessage(localNode_, remoteNode, transactionID)); m->setClosestKNodes(closestKNodes); setCommonProperty(m); return m; @@ -397,9 +397,9 @@ DHTMessageFactoryImpl::createGetPeersMessage const std::string& transactionID) { SharedHandle<DHTGetPeersMessage> m - (new DHTGetPeersMessage(_localNode, remoteNode, infoHash, transactionID)); - m->setPeerAnnounceStorage(_peerAnnounceStorage); - m->setTokenTracker(_tokenTracker); + (new DHTGetPeersMessage(localNode_, remoteNode, infoHash, transactionID)); + m->setPeerAnnounceStorage(peerAnnounceStorage_); + m->setTokenTracker(tokenTracker_); setCommonProperty(m); return m; } @@ -427,7 +427,7 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage const std::string& transactionID) { SharedHandle<DHTGetPeersReplyMessage> m - (new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID)); + (new DHTGetPeersReplyMessage(localNode_, remoteNode, token, transactionID)); m->setClosestKNodes(closestKNodes); setCommonProperty(m); return m; @@ -466,7 +466,7 @@ DHTMessageFactoryImpl::createGetPeersReplyMessage const std::string& transactionID) { SharedHandle<DHTGetPeersReplyMessage> m - (new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID)); + (new DHTGetPeersReplyMessage(localNode_, remoteNode, token, transactionID)); m->setValues(values); setCommonProperty(m); return m; @@ -482,9 +482,9 @@ DHTMessageFactoryImpl::createAnnouncePeerMessage { SharedHandle<DHTAnnouncePeerMessage> m (new DHTAnnouncePeerMessage - (_localNode, remoteNode, infoHash, tcpPort, token, transactionID)); - m->setPeerAnnounceStorage(_peerAnnounceStorage); - m->setTokenTracker(_tokenTracker); + (localNode_, remoteNode, infoHash, tcpPort, token, transactionID)); + m->setPeerAnnounceStorage(peerAnnounceStorage_); + m->setTokenTracker(tokenTracker_); setCommonProperty(m); return m; } @@ -494,7 +494,7 @@ DHTMessageFactoryImpl::createAnnouncePeerReplyMessage (const SharedHandle<DHTNode>& remoteNode, const std::string& transactionID) { SharedHandle<DHTAnnouncePeerReplyMessage> m - (new DHTAnnouncePeerReplyMessage(_localNode, remoteNode, transactionID)); + (new DHTAnnouncePeerReplyMessage(localNode_, remoteNode, transactionID)); setCommonProperty(m); return m; } @@ -506,44 +506,44 @@ DHTMessageFactoryImpl::createUnknownMessage { SharedHandle<DHTUnknownMessage> m - (new DHTUnknownMessage(_localNode, data, length, ipaddr, port)); + (new DHTUnknownMessage(localNode_, data, length, ipaddr, port)); return m; } void DHTMessageFactoryImpl::setRoutingTable (const WeakHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DHTMessageFactoryImpl::setConnection (const WeakHandle<DHTConnection>& connection) { - _connection = connection; + connection_ = connection; } void DHTMessageFactoryImpl::setMessageDispatcher (const WeakHandle<DHTMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DHTMessageFactoryImpl::setPeerAnnounceStorage (const WeakHandle<DHTPeerAnnounceStorage>& storage) { - _peerAnnounceStorage = storage; + peerAnnounceStorage_ = storage; } void DHTMessageFactoryImpl::setTokenTracker (const WeakHandle<DHTTokenTracker>& tokenTracker) { - _tokenTracker = tokenTracker; + tokenTracker_ = tokenTracker; } void DHTMessageFactoryImpl::setLocalNode (const SharedHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } } // namespace aria2 diff --git a/src/DHTMessageFactoryImpl.h b/src/DHTMessageFactoryImpl.h index 2d01297e..d7b639bf 100644 --- a/src/DHTMessageFactoryImpl.h +++ b/src/DHTMessageFactoryImpl.h @@ -51,19 +51,19 @@ class DHTAbstractMessage; class DHTMessageFactoryImpl:public DHTMessageFactory { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - WeakHandle<DHTConnection> _connection; + WeakHandle<DHTConnection> connection_; - WeakHandle<DHTMessageDispatcher> _dispatcher; + WeakHandle<DHTMessageDispatcher> dispatcher_; - WeakHandle<DHTRoutingTable> _routingTable; + WeakHandle<DHTRoutingTable> routingTable_; - WeakHandle<DHTPeerAnnounceStorage> _peerAnnounceStorage; + WeakHandle<DHTPeerAnnounceStorage> peerAnnounceStorage_; - WeakHandle<DHTTokenTracker> _tokenTracker; + WeakHandle<DHTTokenTracker> tokenTracker_; - Logger* _logger; + Logger* logger_; // search node in routingTable. If it is not found, create new one. SharedHandle<DHTNode> getRemoteNode diff --git a/src/DHTMessageReceiver.cc b/src/DHTMessageReceiver.cc index 273d35ad..3883272b 100644 --- a/src/DHTMessageReceiver.cc +++ b/src/DHTMessageReceiver.cc @@ -56,8 +56,8 @@ namespace aria2 { DHTMessageReceiver::DHTMessageReceiver(const SharedHandle<DHTMessageTracker>& tracker): - _tracker(tracker), - _logger(LogFactory::getInstance()) + tracker_(tracker), + logger_(LogFactory::getInstance()) {} DHTMessageReceiver::~DHTMessageReceiver() {} @@ -68,7 +68,7 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage() uint16_t remotePort; unsigned char data[64*1024]; try { - ssize_t length = _connection->receiveMessage(data, sizeof(data), + ssize_t length = connection_->receiveMessage(data, sizeof(data), remoteAddr, remotePort); if(length <= 0) { @@ -84,19 +84,19 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage() isReply = true; } } else { - _logger->info("Malformed DHT message. Missing 'y' key. From:%s:%u", + logger_->info("Malformed DHT message. Missing 'y' key. From:%s:%u", remoteAddr.c_str(), remotePort); return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort); } } else { - _logger->info("Malformed DHT message. This is not a bencoded directory." + logger_->info("Malformed DHT message. This is not a bencoded directory." " From:%s:%u", remoteAddr.c_str(), remotePort); return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort); } if(isReply) { std::pair<SharedHandle<DHTResponseMessage>, SharedHandle<DHTMessageCallback> > p = - _tracker->messageArrived(dict, remoteAddr, remotePort); + tracker_->messageArrived(dict, remoteAddr, remotePort); if(p.first.isNull()) { // timeout or malicious? message return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort); @@ -108,17 +108,17 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage() return p.first; } else { SharedHandle<DHTQueryMessage> message = - _factory->createQueryMessage(dict, remoteAddr, remotePort); + factory_->createQueryMessage(dict, remoteAddr, remotePort); if(message->getLocalNode() == message->getRemoteNode()) { // drop message from localnode - _logger->info("Received DHT message from localnode."); + logger_->info("Received DHT message from localnode."); return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort); } onMessageReceived(message); return message; } } catch(RecoverableException& e) { - _logger->info("Exception thrown while receiving DHT message.", e); + logger_->info("Exception thrown while receiving DHT message.", e); return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort); } } @@ -126,19 +126,19 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage() void DHTMessageReceiver::onMessageReceived (const SharedHandle<DHTMessage>& message) { - if(_logger->info()) { - _logger->info("Message received: %s", message->toString().c_str()); + if(logger_->info()) { + logger_->info("Message received: %s", message->toString().c_str()); } message->validate(); message->doReceivedAction(); message->getRemoteNode()->markGood(); message->getRemoteNode()->updateLastContact(); - _routingTable->addGoodNode(message->getRemoteNode()); + routingTable_->addGoodNode(message->getRemoteNode()); } void DHTMessageReceiver::handleTimeout() { - _tracker->handleTimeout(); + tracker_->handleTimeout(); } SharedHandle<DHTMessage> @@ -148,26 +148,26 @@ DHTMessageReceiver::handleUnknownMessage(const unsigned char* data, uint16_t remotePort) { SharedHandle<DHTMessage> m = - _factory->createUnknownMessage(data, length, remoteAddr, remotePort); - if(_logger->info()) { - _logger->info("Message received: %s", m->toString().c_str()); + factory_->createUnknownMessage(data, length, remoteAddr, remotePort); + if(logger_->info()) { + logger_->info("Message received: %s", m->toString().c_str()); } return m; } void DHTMessageReceiver::setConnection(const SharedHandle<DHTConnection>& connection) { - _connection = connection; + connection_ = connection; } void DHTMessageReceiver::setMessageFactory(const SharedHandle<DHTMessageFactory>& factory) { - _factory = factory; + factory_ = factory; } void DHTMessageReceiver::setRoutingTable(const SharedHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } } // namespace aria2 diff --git a/src/DHTMessageReceiver.h b/src/DHTMessageReceiver.h index 46945209..67f8a7a0 100644 --- a/src/DHTMessageReceiver.h +++ b/src/DHTMessageReceiver.h @@ -50,15 +50,15 @@ class Logger; class DHTMessageReceiver { private: - SharedHandle<DHTMessageTracker> _tracker; + SharedHandle<DHTMessageTracker> tracker_; - SharedHandle<DHTConnection> _connection; + SharedHandle<DHTConnection> connection_; - SharedHandle<DHTMessageFactory> _factory; + SharedHandle<DHTMessageFactory> factory_; - SharedHandle<DHTRoutingTable> _routingTable; + SharedHandle<DHTRoutingTable> routingTable_; - Logger* _logger; + Logger* logger_; SharedHandle<DHTMessage> handleUnknownMessage(const unsigned char* data, size_t length, @@ -76,12 +76,12 @@ public: const SharedHandle<DHTConnection>& getConnection() const { - return _connection; + return connection_; } const SharedHandle<DHTMessageTracker>& getMessageTracker() const { - return _tracker; + return tracker_; } void setConnection(const SharedHandle<DHTConnection>& connection); diff --git a/src/DHTMessageTracker.cc b/src/DHTMessageTracker.cc index edd3163a..ebbc8a9e 100644 --- a/src/DHTMessageTracker.cc +++ b/src/DHTMessageTracker.cc @@ -52,14 +52,14 @@ namespace aria2 { DHTMessageTracker::DHTMessageTracker(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} DHTMessageTracker::~DHTMessageTracker() {} void DHTMessageTracker::addMessage(const SharedHandle<DHTMessage>& message, time_t timeout, const SharedHandle<DHTMessageCallback>& callback) { SharedHandle<DHTMessageTrackerEntry> e(new DHTMessageTrackerEntry(message, timeout, callback)); - _entries.push_back(e); + entries_.push_back(e); } std::pair<SharedHandle<DHTResponseMessage>, SharedHandle<DHTMessageCallback> > @@ -71,36 +71,36 @@ DHTMessageTracker::messageArrived throw DL_ABORT_EX(StringFormat("Malformed DHT message. From:%s:%u", ipaddr.c_str(), port).str()); } - if(_logger->debug()) { - _logger->debug("Searching tracker entry for TransactionID=%s, Remote=%s:%u", + if(logger_->debug()) { + logger_->debug("Searching tracker entry for TransactionID=%s, Remote=%s:%u", util::toHex(tid->s()).c_str(), ipaddr.c_str(), port); } for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i = - _entries.begin(), eoi = _entries.end(); i != eoi; ++i) { + entries_.begin(), eoi = entries_.end(); i != eoi; ++i) { if((*i)->match(tid->s(), ipaddr, port)) { SharedHandle<DHTMessageTrackerEntry> entry = *i; - _entries.erase(i); - if(_logger->debug()) { - _logger->debug("Tracker entry found."); + entries_.erase(i); + if(logger_->debug()) { + logger_->debug("Tracker entry found."); } SharedHandle<DHTNode> targetNode = entry->getTargetNode(); SharedHandle<DHTResponseMessage> message = - _factory->createResponseMessage(entry->getMessageType(), dict, + factory_->createResponseMessage(entry->getMessageType(), dict, targetNode->getIPAddress(), targetNode->getPort()); int64_t rtt = entry->getElapsedMillis(); - if(_logger->debug()) { - _logger->debug("RTT is %s", util::itos(rtt).c_str()); + if(logger_->debug()) { + logger_->debug("RTT is %s", util::itos(rtt).c_str()); } message->getRemoteNode()->updateRTT(rtt); SharedHandle<DHTMessageCallback> callback = entry->getCallback(); return std::make_pair(message, callback); } } - if(_logger->debug()) { - _logger->debug("Tracker entry not found."); + if(logger_->debug()) { + logger_->debug("Tracker entry not found."); } return std::pair<SharedHandle<DHTResponseMessage>, SharedHandle<DHTMessageCallback> >(); @@ -109,32 +109,32 @@ DHTMessageTracker::messageArrived void DHTMessageTracker::handleTimeout() { for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::iterator i = - _entries.begin(), eoi = _entries.end(); i != eoi;) { + entries_.begin(), eoi = entries_.end(); i != eoi;) { if((*i)->isTimeout()) { try { SharedHandle<DHTMessageTrackerEntry> entry = *i; - i = _entries.erase(i); - eoi = _entries.end(); + i = entries_.erase(i); + eoi = entries_.end(); SharedHandle<DHTNode> node = entry->getTargetNode(); - if(_logger->debug()) { - _logger->debug("Message timeout: To:%s:%u", + if(logger_->debug()) { + logger_->debug("Message timeout: To:%s:%u", node->getIPAddress().c_str(), node->getPort()); } node->updateRTT(entry->getElapsedMillis()); node->timeout(); if(node->isBad()) { - if(_logger->debug()) { - _logger->debug("Marked bad: %s:%u", + if(logger_->debug()) { + logger_->debug("Marked bad: %s:%u", node->getIPAddress().c_str(), node->getPort()); } - _routingTable->dropNode(node); + routingTable_->dropNode(node); } SharedHandle<DHTMessageCallback> callback = entry->getCallback(); if(!callback.isNull()) { callback->onTimeout(node); } } catch(RecoverableException& e) { - _logger->info("Exception thrown while handling timeouts.", e); + logger_->info("Exception thrown while handling timeouts.", e); } } else { ++i; @@ -146,7 +146,7 @@ SharedHandle<DHTMessageTrackerEntry> DHTMessageTracker::getEntryFor(const SharedHandle<DHTMessage>& message) const { for(std::deque<SharedHandle<DHTMessageTrackerEntry> >::const_iterator i = - _entries.begin(), eoi = _entries.end(); i != eoi; ++i) { + entries_.begin(), eoi = entries_.end(); i != eoi; ++i) { if((*i)->match(message->getTransactionID(), message->getRemoteNode()->getIPAddress(), message->getRemoteNode()->getPort())) { @@ -158,19 +158,19 @@ DHTMessageTracker::getEntryFor(const SharedHandle<DHTMessage>& message) const size_t DHTMessageTracker::countEntry() const { - return _entries.size(); + return entries_.size(); } void DHTMessageTracker::setRoutingTable (const SharedHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DHTMessageTracker::setMessageFactory (const SharedHandle<DHTMessageFactory>& factory) { - _factory = factory; + factory_ = factory; } } // namespace aria2 diff --git a/src/DHTMessageTracker.h b/src/DHTMessageTracker.h index c8c73b72..befcd577 100644 --- a/src/DHTMessageTracker.h +++ b/src/DHTMessageTracker.h @@ -56,13 +56,13 @@ class Logger; class DHTMessageTracker { private: - std::deque<SharedHandle<DHTMessageTrackerEntry> > _entries; + std::deque<SharedHandle<DHTMessageTrackerEntry> > entries_; - SharedHandle<DHTRoutingTable> _routingTable; + SharedHandle<DHTRoutingTable> routingTable_; - SharedHandle<DHTMessageFactory> _factory; + SharedHandle<DHTMessageFactory> factory_; - Logger* _logger; + Logger* logger_; public: DHTMessageTracker(); diff --git a/src/DHTMessageTrackerEntry.cc b/src/DHTMessageTrackerEntry.cc index 97a1608c..f5042440 100644 --- a/src/DHTMessageTrackerEntry.cc +++ b/src/DHTMessageTrackerEntry.cc @@ -45,17 +45,17 @@ namespace aria2 { DHTMessageTrackerEntry::DHTMessageTrackerEntry(const SharedHandle<DHTMessage>& sentMessage, time_t timeout, const SharedHandle<DHTMessageCallback>& callback): - _targetNode(sentMessage->getRemoteNode()), - _transactionID(sentMessage->getTransactionID()), - _messageType(sentMessage->getMessageType()), - _callback(callback), - _dispatchedTime(global::wallclock), - _timeout(timeout) + targetNode_(sentMessage->getRemoteNode()), + transactionID_(sentMessage->getTransactionID()), + messageType_(sentMessage->getMessageType()), + callback_(callback), + dispatchedTime_(global::wallclock), + timeout_(timeout) {} bool DHTMessageTrackerEntry::isTimeout() const { - return _dispatchedTime.difference(global::wallclock) >= _timeout; + return dispatchedTime_.difference(global::wallclock) >= timeout_; } void DHTMessageTrackerEntry::extendTimeout() @@ -63,16 +63,16 @@ void DHTMessageTrackerEntry::extendTimeout() bool DHTMessageTrackerEntry::match(const std::string& transactionID, const std::string& ipaddr, uint16_t port) const { - if(_transactionID != transactionID || _targetNode->getPort() != port) { + if(transactionID_ != transactionID || targetNode_->getPort() != port) { return false; } - if(_targetNode->getIPAddress() == ipaddr) { + if(targetNode_->getIPAddress() == ipaddr) { return true; } - if(util::endsWith(_targetNode->getIPAddress(), ipaddr)) { - return _targetNode->getIPAddress() == "::ffff:"+ipaddr; - } else if(util::endsWith(ipaddr, _targetNode->getIPAddress())) { - return ipaddr == "::ffff:"+_targetNode->getIPAddress(); + if(util::endsWith(targetNode_->getIPAddress(), ipaddr)) { + return targetNode_->getIPAddress() == "::ffff:"+ipaddr; + } else if(util::endsWith(ipaddr, targetNode_->getIPAddress())) { + return ipaddr == "::ffff:"+targetNode_->getIPAddress(); } return false; } diff --git a/src/DHTMessageTrackerEntry.h b/src/DHTMessageTrackerEntry.h index 9a0b5d6b..41123acd 100644 --- a/src/DHTMessageTrackerEntry.h +++ b/src/DHTMessageTrackerEntry.h @@ -52,17 +52,17 @@ class DHTMessageCallback; class DHTMessageTrackerEntry { private: - SharedHandle<DHTNode> _targetNode; + SharedHandle<DHTNode> targetNode_; - std::string _transactionID; + std::string transactionID_; - std::string _messageType; + std::string messageType_; - SharedHandle<DHTMessageCallback> _callback; + SharedHandle<DHTMessageCallback> callback_; - Timer _dispatchedTime; + Timer dispatchedTime_; - time_t _timeout; + time_t timeout_; public: DHTMessageTrackerEntry(const SharedHandle<DHTMessage>& sentMessage, time_t timeout, @@ -77,22 +77,22 @@ public: const SharedHandle<DHTNode>& getTargetNode() const { - return _targetNode; + return targetNode_; } const std::string& getMessageType() const { - return _messageType; + return messageType_; } const SharedHandle<DHTMessageCallback>& getCallback() const { - return _callback; + return callback_; } int64_t getElapsedMillis() const { - return _dispatchedTime.differenceInMillis(global::wallclock); + return dispatchedTime_.differenceInMillis(global::wallclock); } }; diff --git a/src/DHTNode.cc b/src/DHTNode.cc index c0064a39..1bb48927 100644 --- a/src/DHTNode.cc +++ b/src/DHTNode.cc @@ -43,32 +43,32 @@ namespace aria2 { -DHTNode::DHTNode():_port(0), _rtt(0), _condition(0), _lastContact(0) +DHTNode::DHTNode():port_(0), rtt_(0), condition_(0), lastContact_(0) { generateID(); } -DHTNode::DHTNode(const unsigned char* id):_port(0), _rtt(0), _condition(1), _lastContact(0) +DHTNode::DHTNode(const unsigned char* id):port_(0), rtt_(0), condition_(1), lastContact_(0) { - memcpy(_id, id, DHT_ID_LENGTH); + memcpy(id_, id, DHT_ID_LENGTH); } void DHTNode::generateID() { - util::generateRandomKey(_id); + util::generateRandomKey(id_); } bool DHTNode::operator==(const DHTNode& node) const { - return memcmp(_id, node._id, DHT_ID_LENGTH) == 0; + return memcmp(id_, node.id_, DHT_ID_LENGTH) == 0; } bool DHTNode::operator<(const DHTNode& node) const { for(size_t i = 0; i < DHT_ID_LENGTH; ++i) { - if(_id[i] > node._id[i]) { + if(id_[i] > node.id_[i]) { return false; - } else if(_id[i] < node._id[i]) { + } else if(id_[i] < node.id_[i]) { return true; } } @@ -84,46 +84,46 @@ bool DHTNode::isGood() const bool DHTNode::isBad() const { - return _condition >= BAD_CONDITION; + return condition_ >= BAD_CONDITION; } bool DHTNode::isQuestionable() const { return !isBad() && - _lastContact.difference(global::wallclock) >= DHT_NODE_CONTACT_INTERVAL; + lastContact_.difference(global::wallclock) >= DHT_NODE_CONTACT_INTERVAL; } void DHTNode::markGood() { - _condition = 0; + condition_ = 0; } void DHTNode::markBad() { - _condition = BAD_CONDITION; + condition_ = BAD_CONDITION; } void DHTNode::updateLastContact() { - _lastContact = global::wallclock; + lastContact_ = global::wallclock; } void DHTNode::timeout() { - ++_condition; + ++condition_; } std::string DHTNode::toString() const { - return strconcat("DHTNode ID=", util::toHex(_id, DHT_ID_LENGTH), - ", Host=", _ipaddr, ":", util::uitos(_port), - ", Condition=", util::uitos(_condition), - ", RTT=", util::uitos(_rtt)); + return strconcat("DHTNode ID=", util::toHex(id_, DHT_ID_LENGTH), + ", Host=", ipaddr_, ":", util::uitos(port_), + ", Condition=", util::uitos(condition_), + ", RTT=", util::uitos(rtt_)); } void DHTNode::setID(const unsigned char* id) { - memcpy(_id, id, DHT_ID_LENGTH); + memcpy(id_, id, DHT_ID_LENGTH); } } // namespace aria2 diff --git a/src/DHTNode.h b/src/DHTNode.h index 1418c956..06d90e4a 100644 --- a/src/DHTNode.h +++ b/src/DHTNode.h @@ -45,18 +45,18 @@ namespace aria2 { class DHTNode { private: - unsigned char _id[DHT_ID_LENGTH]; + unsigned char id_[DHT_ID_LENGTH]; - std::string _ipaddr; + std::string ipaddr_; - uint16_t _port; + uint16_t port_; // in milli sec - unsigned int _rtt; + unsigned int rtt_; - unsigned int _condition; + unsigned int condition_; - Timer _lastContact; + Timer lastContact_; public: DHTNode(); @@ -69,34 +69,34 @@ public: const unsigned char* getID() const { - return _id; + return id_; } void updateRTT(unsigned int millisec) { - _rtt = millisec; + rtt_ = millisec; } const std::string& getIPAddress() const { - return _ipaddr; + return ipaddr_; } void setIPAddress(const std::string& ipaddr) { - _ipaddr = ipaddr; + ipaddr_ = ipaddr; } void setID(const unsigned char* id); uint16_t getPort() const { - return _port; + return port_; } void setPort(uint16_t port) { - _port = port; + port_ = port; } bool isGood() const; diff --git a/src/DHTNodeLookupTaskCallback.cc b/src/DHTNodeLookupTaskCallback.cc index 0c2c3009..e73fe6cb 100644 --- a/src/DHTNodeLookupTaskCallback.cc +++ b/src/DHTNodeLookupTaskCallback.cc @@ -42,7 +42,7 @@ namespace aria2 { DHTNodeLookupTaskCallback::DHTNodeLookupTaskCallback(DHTNodeLookupTask* task): - _task(task) {} + task_(task) {} void DHTNodeLookupTaskCallback::visit (const DHTAnnouncePeerReplyMessage* message) @@ -53,7 +53,7 @@ void DHTNodeLookupTaskCallback::visit void DHTNodeLookupTaskCallback::visit(const DHTFindNodeReplyMessage* message) { - _task->onReceived(message); + task_->onReceived(message); } void DHTNodeLookupTaskCallback::visit(const DHTGetPeersReplyMessage* message) @@ -71,7 +71,7 @@ void DHTNodeLookupTaskCallback::visit(const DHTPingReplyMessage* message) void DHTNodeLookupTaskCallback::onTimeout (const SharedHandle<DHTNode>& remoteNode) { - _task->onTimeout(remoteNode); + task_->onTimeout(remoteNode); } diff --git a/src/DHTNodeLookupTaskCallback.h b/src/DHTNodeLookupTaskCallback.h index 64ecc84e..7a7f3e08 100644 --- a/src/DHTNodeLookupTaskCallback.h +++ b/src/DHTNodeLookupTaskCallback.h @@ -43,7 +43,7 @@ class DHTNodeLookupTask; class DHTNodeLookupTaskCallback:public DHTMessageCallback { private: - DHTNodeLookupTask* _task; + DHTNodeLookupTask* task_; public: DHTNodeLookupTaskCallback(DHTNodeLookupTask* task); diff --git a/src/DHTPeerAnnounceCommand.cc b/src/DHTPeerAnnounceCommand.cc index 1aa16b41..43f67183 100644 --- a/src/DHTPeerAnnounceCommand.cc +++ b/src/DHTPeerAnnounceCommand.cc @@ -63,7 +63,7 @@ void DHTPeerAnnounceCommand::preProcess() void DHTPeerAnnounceCommand::process() { try { - _peerAnnounceStorage->handleTimeout(); + peerAnnounceStorage_->handleTimeout(); } catch(RecoverableException& e) { getLogger()->error(EX_EXCEPTION_CAUGHT, e); } @@ -72,7 +72,7 @@ void DHTPeerAnnounceCommand::process() void DHTPeerAnnounceCommand::setPeerAnnounceStorage (const SharedHandle<DHTPeerAnnounceStorage>& storage) { - _peerAnnounceStorage = storage; + peerAnnounceStorage_ = storage; } } // namespace aria2 diff --git a/src/DHTPeerAnnounceCommand.h b/src/DHTPeerAnnounceCommand.h index 35abdbbc..d03773f8 100644 --- a/src/DHTPeerAnnounceCommand.h +++ b/src/DHTPeerAnnounceCommand.h @@ -44,7 +44,7 @@ class DHTPeerAnnounceStorage; class DHTPeerAnnounceCommand:public TimeBasedCommand { private: - SharedHandle<DHTPeerAnnounceStorage> _peerAnnounceStorage; + SharedHandle<DHTPeerAnnounceStorage> peerAnnounceStorage_; public: DHTPeerAnnounceCommand(cuid_t cuid, DownloadEngine* e, time_t interval); diff --git a/src/DHTPeerAnnounceEntry.cc b/src/DHTPeerAnnounceEntry.cc index 666087de..49348ace 100644 --- a/src/DHTPeerAnnounceEntry.cc +++ b/src/DHTPeerAnnounceEntry.cc @@ -44,7 +44,7 @@ namespace aria2 { DHTPeerAnnounceEntry::DHTPeerAnnounceEntry(const unsigned char* infoHash) { - memcpy(_infoHash, infoHash, DHT_ID_LENGTH); + memcpy(infoHash_, infoHash, DHT_ID_LENGTH); } DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {} @@ -52,9 +52,9 @@ DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {} void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry) { std::vector<PeerAddrEntry>::iterator i = - std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry); - if(i == _peerAddrEntries.end()) { - _peerAddrEntries.push_back(entry); + std::find(peerAddrEntries_.begin(), peerAddrEntries_.end(), entry); + if(i == peerAddrEntries_.end()) { + peerAddrEntries_.push_back(entry); } else { (*i).notifyUpdate(); } @@ -63,18 +63,18 @@ void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry) size_t DHTPeerAnnounceEntry::countPeerAddrEntry() const { - return _peerAddrEntries.size(); + return peerAddrEntries_.size(); } class FindStaleEntry { private: - time_t _timeout; + time_t timeout_; public: - FindStaleEntry(time_t timeout):_timeout(timeout) {} + FindStaleEntry(time_t timeout):timeout_(timeout) {} bool operator()(const PeerAddrEntry& entry) const { - if(entry.getLastUpdated().difference(global::wallclock) >= _timeout) { + if(entry.getLastUpdated().difference(global::wallclock) >= timeout_) { return true; } else { return false; @@ -84,20 +84,20 @@ public: void DHTPeerAnnounceEntry::removeStalePeerAddrEntry(time_t timeout) { - _peerAddrEntries.erase(std::remove_if(_peerAddrEntries.begin(), _peerAddrEntries.end(), - FindStaleEntry(timeout)), _peerAddrEntries.end()); + peerAddrEntries_.erase(std::remove_if(peerAddrEntries_.begin(), peerAddrEntries_.end(), + FindStaleEntry(timeout)), peerAddrEntries_.end()); } bool DHTPeerAnnounceEntry::empty() const { - return _peerAddrEntries.empty(); + return peerAddrEntries_.empty(); } void DHTPeerAnnounceEntry::getPeers (std::vector<SharedHandle<Peer> >& peers) const { - for(std::vector<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin(), - eoi = _peerAddrEntries.end(); i != eoi; ++i) { + for(std::vector<PeerAddrEntry>::const_iterator i = peerAddrEntries_.begin(), + eoi = peerAddrEntries_.end(); i != eoi; ++i) { SharedHandle<Peer> peer(new Peer((*i).getIPAddress(), (*i).getPort())); peers.push_back(peer); } @@ -105,7 +105,7 @@ void DHTPeerAnnounceEntry::getPeers void DHTPeerAnnounceEntry::notifyUpdate() { - _lastUpdated = global::wallclock; + lastUpdated_ = global::wallclock; } } // namespace aria2 diff --git a/src/DHTPeerAnnounceEntry.h b/src/DHTPeerAnnounceEntry.h index 0bd8e318..9a12b552 100644 --- a/src/DHTPeerAnnounceEntry.h +++ b/src/DHTPeerAnnounceEntry.h @@ -50,11 +50,11 @@ class Peer; class DHTPeerAnnounceEntry { private: - unsigned char _infoHash[DHT_ID_LENGTH]; + unsigned char infoHash_[DHT_ID_LENGTH]; - std::vector<PeerAddrEntry> _peerAddrEntries; + std::vector<PeerAddrEntry> peerAddrEntries_; - Timer _lastUpdated; + Timer lastUpdated_; public: DHTPeerAnnounceEntry(const unsigned char* infoHash); @@ -68,7 +68,7 @@ public: const std::vector<PeerAddrEntry>& getPeerAddrEntries() const { - return _peerAddrEntries; + return peerAddrEntries_; } void removeStalePeerAddrEntry(time_t timeout); @@ -77,14 +77,14 @@ public: const Timer& getLastUpdated() const { - return _lastUpdated; + return lastUpdated_; } void notifyUpdate(); const unsigned char* getInfoHash() const { - return _infoHash; + return infoHash_; } void getPeers(std::vector<SharedHandle<Peer> >& peers) const; diff --git a/src/DHTPeerAnnounceStorage.cc b/src/DHTPeerAnnounceStorage.cc index d4371f58..479fb317 100644 --- a/src/DHTPeerAnnounceStorage.cc +++ b/src/DHTPeerAnnounceStorage.cc @@ -52,7 +52,7 @@ namespace aria2 { DHTPeerAnnounceStorage::DHTPeerAnnounceStorage(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} DHTPeerAnnounceStorage::~DHTPeerAnnounceStorage() {} @@ -72,13 +72,13 @@ DHTPeerAnnounceStorage::getPeerAnnounceEntry(const unsigned char* infoHash) SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash)); std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = - std::lower_bound(_entries.begin(), _entries.end(), entry, InfoHashLess()); + std::lower_bound(entries_.begin(), entries_.end(), entry, InfoHashLess()); - if(i != _entries.end() && + if(i != entries_.end() && memcmp(infoHash, (*i)->getInfoHash(), DHT_ID_LENGTH) == 0) { entry = *i; } else { - _entries.insert(i, entry); + entries_.insert(i, entry); } return entry; } @@ -87,8 +87,8 @@ void DHTPeerAnnounceStorage::addPeerAnnounce(const unsigned char* infoHash, const std::string& ipaddr, uint16_t port) { - if(_logger->debug()) { - _logger->debug("Adding %s:%u to peer announce list: infoHash=%s", + if(logger_->debug()) { + logger_->debug("Adding %s:%u to peer announce list: infoHash=%s", ipaddr.c_str(), port, util::toHex(infoHash, DHT_ID_LENGTH).c_str()); } @@ -99,7 +99,7 @@ bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const { SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash)); return - std::binary_search(_entries.begin(), _entries.end(), entry, InfoHashLess()); + std::binary_search(entries_.begin(), entries_.end(), entry, InfoHashLess()); } void DHTPeerAnnounceStorage::getPeers(std::vector<SharedHandle<Peer> >& peers, @@ -108,8 +108,8 @@ void DHTPeerAnnounceStorage::getPeers(std::vector<SharedHandle<Peer> >& peers, SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash)); std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = - std::lower_bound(_entries.begin(), _entries.end(), entry, InfoHashLess()); - if(i != _entries.end() && + std::lower_bound(entries_.begin(), entries_.end(), entry, InfoHashLess()); + if(i != entries_.end() && memcmp(infoHash, (*i)->getInfoHash(), DHT_ID_LENGTH) == 0 && !(*i)->empty()) { (*i)->getPeers(peers); @@ -127,35 +127,35 @@ public: void DHTPeerAnnounceStorage::handleTimeout() { - if(_logger->debug()) { - _logger->debug("Now purge peer announces(%lu entries) which are timed out.", - static_cast<unsigned long>(_entries.size())); + if(logger_->debug()) { + logger_->debug("Now purge peer announces(%lu entries) which are timed out.", + static_cast<unsigned long>(entries_.size())); } - std::for_each(_entries.begin(), _entries.end(), RemoveStalePeerAddrEntry()); - _entries.erase(std::remove_if(_entries.begin(), _entries.end(), + std::for_each(entries_.begin(), entries_.end(), RemoveStalePeerAddrEntry()); + entries_.erase(std::remove_if(entries_.begin(), entries_.end(), mem_fun_sh(&DHTPeerAnnounceEntry::empty)), - _entries.end()); - if(_logger->debug()) { - _logger->debug("Currently %lu peer announce entries", - static_cast<unsigned long>(_entries.size())); + entries_.end()); + if(logger_->debug()) { + logger_->debug("Currently %lu peer announce entries", + static_cast<unsigned long>(entries_.size())); } } void DHTPeerAnnounceStorage::announcePeer() { - if(_logger->debug()) { - _logger->debug("Now announcing peer."); + if(logger_->debug()) { + logger_->debug("Now announcing peer."); } for(std::deque<SharedHandle<DHTPeerAnnounceEntry> >::iterator i = - _entries.begin(), eoi = _entries.end(); i != eoi; ++i) { + entries_.begin(), eoi = entries_.end(); i != eoi; ++i) { if((*i)->getLastUpdated(). difference(global::wallclock) >= DHT_PEER_ANNOUNCE_INTERVAL) { (*i)->notifyUpdate(); SharedHandle<DHTTask> task = - _taskFactory->createPeerAnnounceTask((*i)->getInfoHash()); - _taskQueue->addPeriodicTask2(task); - if(_logger->debug()) { - _logger->debug("Added 1 peer announce: infoHash=%s", + taskFactory_->createPeerAnnounceTask((*i)->getInfoHash()); + taskQueue_->addPeriodicTask2(task); + if(logger_->debug()) { + logger_->debug("Added 1 peer announce: infoHash=%s", util::toHex((*i)->getInfoHash(), DHT_ID_LENGTH).c_str()); } } @@ -164,12 +164,12 @@ void DHTPeerAnnounceStorage::announcePeer() void DHTPeerAnnounceStorage::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTPeerAnnounceStorage::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } } // namespace aria2 diff --git a/src/DHTPeerAnnounceStorage.h b/src/DHTPeerAnnounceStorage.h index 29d5ecba..da829933 100644 --- a/src/DHTPeerAnnounceStorage.h +++ b/src/DHTPeerAnnounceStorage.h @@ -52,15 +52,15 @@ class Logger; class DHTPeerAnnounceStorage { private: - std::deque<SharedHandle<DHTPeerAnnounceEntry> > _entries; + std::deque<SharedHandle<DHTPeerAnnounceEntry> > entries_; SharedHandle<DHTPeerAnnounceEntry> getPeerAnnounceEntry(const unsigned char* infoHash); - SharedHandle<DHTTaskQueue> _taskQueue; + SharedHandle<DHTTaskQueue> taskQueue_; - SharedHandle<DHTTaskFactory> _taskFactory; + SharedHandle<DHTTaskFactory> taskFactory_; - Logger* _logger; + Logger* logger_; public: DHTPeerAnnounceStorage(); diff --git a/src/DHTPeerLookupTask.cc b/src/DHTPeerLookupTask.cc index 9cb5eeff..938ff644 100644 --- a/src/DHTPeerLookupTask.cc +++ b/src/DHTPeerLookupTask.cc @@ -70,10 +70,10 @@ void DHTPeerLookupTask::onReceivedInternal (const DHTGetPeersReplyMessage* message) { SharedHandle<DHTNode> remoteNode = message->getRemoteNode(); - _tokenStorage[util::toHex(remoteNode->getID(), DHT_ID_LENGTH)] = + tokenStorage_[util::toHex(remoteNode->getID(), DHT_ID_LENGTH)] = message->getToken(); - _peerStorage->addPeer(message->getValues()); - _peers.insert(_peers.end(), + peerStorage_->addPeer(message->getValues()); + peers_.insert(peers_.end(), message->getValues().begin(), message->getValues().end()); getLogger()->info("Received %u peers.", message->getValues().size()); } @@ -103,8 +103,8 @@ void DHTPeerLookupTask::onFinish() getMessageFactory()->createAnnouncePeerMessage (node, getTargetID(), // this is infoHash - _btRuntime->getListenPort(), - _tokenStorage[util::toHex(node->getID(), DHT_ID_LENGTH)]); + btRuntime_->getListenPort(), + tokenStorage_[util::toHex(node->getID(), DHT_ID_LENGTH)]); getMessageDispatcher()->addMessageToQueue(m); } } @@ -112,12 +112,12 @@ void DHTPeerLookupTask::onFinish() void DHTPeerLookupTask::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void DHTPeerLookupTask::setPeerStorage(const SharedHandle<PeerStorage>& ps) { - _peerStorage = ps; + peerStorage_ = ps; } } // namespace aria2 diff --git a/src/DHTPeerLookupTask.h b/src/DHTPeerLookupTask.h index 5ead514a..3b5d365f 100644 --- a/src/DHTPeerLookupTask.h +++ b/src/DHTPeerLookupTask.h @@ -49,13 +49,13 @@ class DHTGetPeersReplyMessage; class DHTPeerLookupTask: public DHTAbstractNodeLookupTask<DHTGetPeersReplyMessage> { private: - std::map<std::string, std::string> _tokenStorage; + std::map<std::string, std::string> tokenStorage_; - std::vector<SharedHandle<Peer> > _peers; + std::vector<SharedHandle<Peer> > peers_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; public: DHTPeerLookupTask(const SharedHandle<DownloadContext>& downloadContext); @@ -74,7 +74,7 @@ public: const std::vector<SharedHandle<Peer> >& getPeers() const { - return _peers; + return peers_; } void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime); diff --git a/src/DHTPeerLookupTaskCallback.cc b/src/DHTPeerLookupTaskCallback.cc index 49a9827a..e6656473 100644 --- a/src/DHTPeerLookupTaskCallback.cc +++ b/src/DHTPeerLookupTaskCallback.cc @@ -42,7 +42,7 @@ namespace aria2 { DHTPeerLookupTaskCallback::DHTPeerLookupTaskCallback(DHTPeerLookupTask* task): - _task(task) {} + task_(task) {} void DHTPeerLookupTaskCallback::visit (const DHTAnnouncePeerReplyMessage* message) @@ -57,7 +57,7 @@ void DHTPeerLookupTaskCallback::visit(const DHTFindNodeReplyMessage* message) void DHTPeerLookupTaskCallback::visit(const DHTGetPeersReplyMessage* message) { - _task->onReceived(message); + task_->onReceived(message); } void DHTPeerLookupTaskCallback::visit(const DHTPingReplyMessage* message) @@ -68,7 +68,7 @@ void DHTPeerLookupTaskCallback::visit(const DHTPingReplyMessage* message) void DHTPeerLookupTaskCallback::onTimeout (const SharedHandle<DHTNode>& remoteNode) { - _task->onTimeout(remoteNode); + task_->onTimeout(remoteNode); } } // namespace aria2 diff --git a/src/DHTPeerLookupTaskCallback.h b/src/DHTPeerLookupTaskCallback.h index 35b25774..6926ca14 100644 --- a/src/DHTPeerLookupTaskCallback.h +++ b/src/DHTPeerLookupTaskCallback.h @@ -43,7 +43,7 @@ class DHTPeerLookupTask; class DHTPeerLookupTaskCallback:public DHTMessageCallback { private: - DHTPeerLookupTask* _task; + DHTPeerLookupTask* task_; public: DHTPeerLookupTaskCallback(DHTPeerLookupTask* task); diff --git a/src/DHTPingReplyMessage.cc b/src/DHTPingReplyMessage.cc index 7420fd2a..d0a89b58 100644 --- a/src/DHTPingReplyMessage.cc +++ b/src/DHTPingReplyMessage.cc @@ -50,7 +50,7 @@ DHTPingReplyMessage::DHTPingReplyMessage const std::string& transactionID): DHTResponseMessage(localNode, remoteNode, transactionID) { - memcpy(_id, id, DHT_ID_LENGTH); + memcpy(id_, id, DHT_ID_LENGTH); } DHTPingReplyMessage::~DHTPingReplyMessage() {} @@ -60,7 +60,7 @@ void DHTPingReplyMessage::doReceivedAction() {} SharedHandle<Dict> DHTPingReplyMessage::getResponse() { SharedHandle<Dict> rDict = Dict::g(); - rDict->put(DHTMessage::ID, String::g(_id, DHT_ID_LENGTH)); + rDict->put(DHTMessage::ID, String::g(id_, DHT_ID_LENGTH)); return rDict; } diff --git a/src/DHTPingReplyMessage.h b/src/DHTPingReplyMessage.h index d9660bd5..2d1b0ab8 100644 --- a/src/DHTPingReplyMessage.h +++ b/src/DHTPingReplyMessage.h @@ -42,7 +42,7 @@ namespace aria2 { class DHTPingReplyMessage:public DHTResponseMessage { private: - unsigned char _id[DHT_ID_LENGTH]; + unsigned char id_[DHT_ID_LENGTH]; public: DHTPingReplyMessage(const SharedHandle<DHTNode>& localNode, const SharedHandle<DHTNode>& remoteNode, @@ -61,7 +61,7 @@ public: const unsigned char* getRemoteID() { - return _id; + return id_; } static const std::string PING; diff --git a/src/DHTPingReplyMessageCallback.h b/src/DHTPingReplyMessageCallback.h index eb6e16c4..1781a0b6 100644 --- a/src/DHTPingReplyMessageCallback.h +++ b/src/DHTPingReplyMessageCallback.h @@ -46,9 +46,9 @@ namespace aria2 { template<class Task> class DHTPingReplyMessageCallback:public DHTMessageCallback { private: - Task* _task; + Task* task_; public: - DHTPingReplyMessageCallback(Task* task):_task(task) {} + DHTPingReplyMessageCallback(Task* task):task_(task) {} virtual void visit(const DHTAnnouncePeerReplyMessage* message) { @@ -67,12 +67,12 @@ public: virtual void visit(const DHTPingReplyMessage* message) { - _task->onReceived(message); + task_->onReceived(message); } virtual void onTimeout(const SharedHandle<DHTNode>& remoteNode) { - _task->onTimeout(remoteNode); + task_->onTimeout(remoteNode); } }; diff --git a/src/DHTPingTask.cc b/src/DHTPingTask.cc index f58b9067..fcc0750e 100644 --- a/src/DHTPingTask.cc +++ b/src/DHTPingTask.cc @@ -45,11 +45,11 @@ namespace aria2 { DHTPingTask::DHTPingTask (const SharedHandle<DHTNode>& remoteNode, size_t numMaxRetry): - _remoteNode(remoteNode), - _numMaxRetry(numMaxRetry), - _numRetry(0), - _pingSuccessful(false), - _timeout(DHT_MESSAGE_TIMEOUT) + remoteNode_(remoteNode), + numMaxRetry_(numMaxRetry), + numRetry_(0), + pingSuccessful_(false), + timeout_(DHT_MESSAGE_TIMEOUT) {} DHTPingTask::~DHTPingTask() {} @@ -57,10 +57,10 @@ DHTPingTask::~DHTPingTask() {} void DHTPingTask::addMessage() { SharedHandle<DHTMessage> m = - getMessageFactory()->createPingMessage(_remoteNode); + getMessageFactory()->createPingMessage(remoteNode_); SharedHandle<DHTMessageCallback> callback (new DHTPingReplyMessageCallback<DHTPingTask>(this)); - getMessageDispatcher()->addMessageToQueue(m, _timeout, callback); + getMessageDispatcher()->addMessageToQueue(m, timeout_, callback); } void DHTPingTask::startup() @@ -70,15 +70,15 @@ void DHTPingTask::startup() void DHTPingTask::onReceived(const DHTPingReplyMessage* message) { - _pingSuccessful = true; + pingSuccessful_ = true; setFinished(true); } void DHTPingTask::onTimeout(const SharedHandle<DHTNode>& node) { - ++_numRetry; - if(_numRetry >= _numMaxRetry) { - _pingSuccessful = false; + ++numRetry_; + if(numRetry_ >= numMaxRetry_) { + pingSuccessful_ = false; setFinished(true); } else { addMessage(); @@ -87,7 +87,7 @@ void DHTPingTask::onTimeout(const SharedHandle<DHTNode>& node) bool DHTPingTask::isPingSuccessful() const { - return _pingSuccessful; + return pingSuccessful_; } } // namespace aria2 diff --git a/src/DHTPingTask.h b/src/DHTPingTask.h index 65719f21..5a940495 100644 --- a/src/DHTPingTask.h +++ b/src/DHTPingTask.h @@ -44,15 +44,15 @@ class DHTPingReplyMessage; class DHTPingTask:public DHTAbstractTask { private: - SharedHandle<DHTNode> _remoteNode; + SharedHandle<DHTNode> remoteNode_; - size_t _numMaxRetry; + size_t numMaxRetry_; - size_t _numRetry; + size_t numRetry_; - bool _pingSuccessful; + bool pingSuccessful_; - time_t _timeout; + time_t timeout_; void addMessage(); public: @@ -68,7 +68,7 @@ public: void setTimeout(time_t timeout) { - _timeout = timeout; + timeout_ = timeout; } bool isPingSuccessful() const; diff --git a/src/DHTRegistry.cc b/src/DHTRegistry.cc index 782c12d9..909225e2 100644 --- a/src/DHTRegistry.cc +++ b/src/DHTRegistry.cc @@ -47,19 +47,19 @@ namespace aria2 { -DHTRegistry::Data DHTRegistry::_data; +DHTRegistry::Data DHTRegistry::data_; void DHTRegistry::clearData() { - _data.localNode.reset(); - _data.routingTable.reset(); - _data.taskQueue.reset(); - _data.taskFactory.reset(); - _data.peerAnnounceStorage.reset(); - _data.tokenTracker.reset(); - _data.messageDispatcher.reset(); - _data.messageReceiver.reset(); - _data.messageFactory.reset(); + data_.localNode.reset(); + data_.routingTable.reset(); + data_.taskQueue.reset(); + data_.taskFactory.reset(); + data_.peerAnnounceStorage.reset(); + data_.tokenTracker.reset(); + data_.messageDispatcher.reset(); + data_.messageReceiver.reset(); + data_.messageFactory.reset(); } } // namespace aria2 diff --git a/src/DHTRegistry.h b/src/DHTRegistry.h index 44dae9e2..5248d710 100644 --- a/src/DHTRegistry.h +++ b/src/DHTRegistry.h @@ -72,17 +72,17 @@ private: SharedHandle<DHTMessageFactory> messageFactory; }; - static Data _data; + static Data data_; DHTRegistry(); public: static const Data& getData() { - return _data; + return data_; } static Data& getMutableData() { - return _data; + return data_; } static void clearData(); diff --git a/src/DHTReplaceNodeTask.cc b/src/DHTReplaceNodeTask.cc index 84c7d37f..a70f91f7 100644 --- a/src/DHTReplaceNodeTask.cc +++ b/src/DHTReplaceNodeTask.cc @@ -46,10 +46,10 @@ namespace aria2 { DHTReplaceNodeTask::DHTReplaceNodeTask(const SharedHandle<DHTBucket>& bucket, const SharedHandle<DHTNode>& newNode): - _bucket(bucket), - _newNode(newNode), - _numRetry(0), - _timeout(DHT_MESSAGE_TIMEOUT) + bucket_(bucket), + newNode_(newNode), + numRetry_(0), + timeout_(DHT_MESSAGE_TIMEOUT) {} DHTReplaceNodeTask::~DHTReplaceNodeTask() {} @@ -61,7 +61,7 @@ void DHTReplaceNodeTask::startup() void DHTReplaceNodeTask::sendMessage() { - SharedHandle<DHTNode> questionableNode = _bucket->getLRUQuestionableNode(); + SharedHandle<DHTNode> questionableNode = bucket_->getLRUQuestionableNode(); if(questionableNode.isNull()) { setFinished(true); } else { @@ -69,7 +69,7 @@ void DHTReplaceNodeTask::sendMessage() getMessageFactory()->createPingMessage(questionableNode); SharedHandle<DHTMessageCallback> callback (new DHTPingReplyMessageCallback<DHTReplaceNodeTask>(this)); - getMessageDispatcher()->addMessageToQueue(m, _timeout, callback); + getMessageDispatcher()->addMessageToQueue(m, timeout_, callback); } } @@ -82,13 +82,13 @@ void DHTReplaceNodeTask::onReceived(const DHTPingReplyMessage* message) void DHTReplaceNodeTask::onTimeout(const SharedHandle<DHTNode>& node) { - ++_numRetry; - if(_numRetry >= MAX_RETRY) { + ++numRetry_; + if(numRetry_ >= MAX_RETRY) { getLogger()->info("ReplaceNode: Ping failed %u times. Replace %s with %s.", - _numRetry, node->toString().c_str(), - _newNode->toString().c_str()); + numRetry_, node->toString().c_str(), + newNode_->toString().c_str()); node->markBad(); - _bucket->addNode(_newNode); + bucket_->addNode(newNode_); setFinished(true); } else { getLogger()->info("ReplaceNode: Ping reply timeout from %s. Try once more.", diff --git a/src/DHTReplaceNodeTask.h b/src/DHTReplaceNodeTask.h index 4cd3dfea..d21c5dc0 100644 --- a/src/DHTReplaceNodeTask.h +++ b/src/DHTReplaceNodeTask.h @@ -45,15 +45,15 @@ class DHTPingReplyMessage; class DHTReplaceNodeTask:public DHTAbstractTask { private: - SharedHandle<DHTBucket> _bucket; + SharedHandle<DHTBucket> bucket_; - SharedHandle<DHTNode> _newNode; + SharedHandle<DHTNode> newNode_; static const size_t MAX_RETRY = 2; - size_t _numRetry; + size_t numRetry_; - time_t _timeout; + time_t timeout_; void sendMessage(); public: @@ -70,7 +70,7 @@ public: void setTimeout(time_t timeout) { - _timeout = timeout; + timeout_ = timeout; } }; diff --git a/src/DHTRoutingTable.cc b/src/DHTRoutingTable.cc index f996698e..f7876082 100644 --- a/src/DHTRoutingTable.cc +++ b/src/DHTRoutingTable.cc @@ -49,17 +49,17 @@ namespace aria2 { DHTRoutingTable::DHTRoutingTable(const SharedHandle<DHTNode>& localNode): - _localNode(localNode), - _numBucket(1), - _logger(LogFactory::getInstance()) + localNode_(localNode), + numBucket_(1), + logger_(LogFactory::getInstance()) { - SharedHandle<DHTBucket> bucket(new DHTBucket(_localNode)); - _root = new BNode(bucket); + SharedHandle<DHTBucket> bucket(new DHTBucket(localNode_)); + root_ = new BNode(bucket); } DHTRoutingTable::~DHTRoutingTable() { - delete _root; + delete root_; } bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node) @@ -74,27 +74,27 @@ bool DHTRoutingTable::addGoodNode(const SharedHandle<DHTNode>& node) bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good) { - if(_logger->debug()) { - _logger->debug("Trying to add node:%s", node->toString().c_str()); + if(logger_->debug()) { + logger_->debug("Trying to add node:%s", node->toString().c_str()); } - if(_localNode == node) { - if(_logger->debug()) { - _logger->debug("Adding node with the same ID with localnode is not" + if(localNode_ == node) { + if(logger_->debug()) { + logger_->debug("Adding node with the same ID with localnode is not" " allowed."); } return false; } - BNode* bnode = BNode::findBNodeFor(_root, node->getID()); + BNode* bnode = BNode::findBNodeFor(root_, node->getID()); SharedHandle<DHTBucket> bucket = bnode->getBucket(); while(1) { if(bucket->addNode(node)) { - if(_logger->debug()) { - _logger->debug("Added DHTNode."); + if(logger_->debug()) { + logger_->debug("Added DHTNode."); } return true; } else if(bucket->splitAllowed()) { - if(_logger->debug()) { - _logger->debug("Splitting bucket. Range:%s-%s", + if(logger_->debug()) { + logger_->debug("Splitting bucket. Range:%s-%s", util::toHex(bucket->getMinID(), DHT_ID_LENGTH).c_str(), util::toHex(bucket->getMaxID(), DHT_ID_LENGTH).c_str()); } @@ -105,7 +105,7 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good) BNode* rbnode = new BNode(r); bnode->setLeft(lbnode); bnode->setRight(rbnode); - ++_numBucket; + ++numBucket_; if(r->isInRange(node)) { bucket = r; @@ -116,8 +116,8 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good) } else { if(good) { bucket->cacheNode(node); - if(_logger->debug()) { - _logger->debug("Cached node=%s", node->toString().c_str()); + if(logger_->debug()) { + logger_->debug("Cached node=%s", node->toString().c_str()); } } return false; @@ -130,17 +130,17 @@ void DHTRoutingTable::getClosestKNodes (std::vector<SharedHandle<DHTNode> >& nodes, const unsigned char* key) const { - BNode::findClosestKNodes(nodes, _root, key); + BNode::findClosestKNodes(nodes, root_, key); } size_t DHTRoutingTable::countBucket() const { - return _numBucket; + return numBucket_; } void DHTRoutingTable::showBuckets() const {/* - for(std::deque<SharedHandle<DHTBucket> >::const_iterator itr = _buckets.begin(); itr != _buckets.end(); ++itr) { + for(std::deque<SharedHandle<DHTBucket> >::const_iterator itr = buckets_.begin(); itr != buckets_.end(); ++itr) { cerr << "prefix = " << (*itr)->getPrefixLength() << ", " << "nodes = " << (*itr)->countNode() << endl; } @@ -149,7 +149,7 @@ void DHTRoutingTable::showBuckets() const SharedHandle<DHTBucket> DHTRoutingTable::getBucketFor(const unsigned char* nodeID) const { - return BNode::findBucketFor(_root, nodeID); + return BNode::findBucketFor(root_, nodeID); } SharedHandle<DHTBucket> DHTRoutingTable::getBucketFor(const SharedHandle<DHTNode>& node) const @@ -181,17 +181,17 @@ void DHTRoutingTable::moveBucketTail(const SharedHandle<DHTNode>& node) void DHTRoutingTable::getBuckets (std::vector<SharedHandle<DHTBucket> >& buckets) const { - BNode::enumerateBucket(buckets, _root); + BNode::enumerateBucket(buckets, root_); } void DHTRoutingTable::setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTRoutingTable::setTaskFactory(const SharedHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } } // namespace aria2 diff --git a/src/DHTRoutingTable.h b/src/DHTRoutingTable.h index e9c4ae73..91405761 100644 --- a/src/DHTRoutingTable.h +++ b/src/DHTRoutingTable.h @@ -53,17 +53,17 @@ class Logger; class DHTRoutingTable { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - BNode* _root; + BNode* root_; - size_t _numBucket; + size_t numBucket_; - SharedHandle<DHTTaskQueue> _taskQueue; + SharedHandle<DHTTaskQueue> taskQueue_; - SharedHandle<DHTTaskFactory> _taskFactory; + SharedHandle<DHTTaskFactory> taskFactory_; - Logger* _logger; + Logger* logger_; bool addNode(const SharedHandle<DHTNode>& node, bool good); public: diff --git a/src/DHTRoutingTableDeserializer.cc b/src/DHTRoutingTableDeserializer.cc index fe52e911..df43c5c5 100644 --- a/src/DHTRoutingTableDeserializer.cc +++ b/src/DHTRoutingTableDeserializer.cc @@ -127,14 +127,14 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in) if(version == 2) { in.read(reinterpret_cast<char*>(&temp32), sizeof(temp32)); CHECK_STREAM(in, sizeof(temp32)); - _serializedTime.setTimeInSec(ntohl(temp32)); + serializedTime_.setTimeInSec(ntohl(temp32)); // 4bytes reserved readBytes(buf, buf.size(), in, 4); CHECK_STREAM(in, 4); } else { in.read(reinterpret_cast<char*>(&temp64), sizeof(temp64)); CHECK_STREAM(in, sizeof(temp64)); - _serializedTime.setTimeInSec(ntoh64(temp64)); + serializedTime_.setTimeInSec(ntoh64(temp64)); } // localnode @@ -208,8 +208,8 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in) nodes.push_back(node); } - _localNode = localNode; - _nodes = nodes; + localNode_ = localNode; + nodes_ = nodes; } } // namespace aria2 diff --git a/src/DHTRoutingTableDeserializer.h b/src/DHTRoutingTableDeserializer.h index b0ceae07..efa55a76 100644 --- a/src/DHTRoutingTableDeserializer.h +++ b/src/DHTRoutingTableDeserializer.h @@ -49,11 +49,11 @@ class DHTNode; class DHTRoutingTableDeserializer { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - std::vector<SharedHandle<DHTNode> > _nodes; + std::vector<SharedHandle<DHTNode> > nodes_; - Time _serializedTime; + Time serializedTime_; public: DHTRoutingTableDeserializer(); @@ -61,17 +61,17 @@ public: const SharedHandle<DHTNode>& getLocalNode() const { - return _localNode; + return localNode_; } const std::vector<SharedHandle<DHTNode> >& getNodes() const { - return _nodes; + return nodes_; } Time getSerializedTime() const { - return _serializedTime; + return serializedTime_; } void deserialize(std::istream& in); diff --git a/src/DHTRoutingTableSerializer.cc b/src/DHTRoutingTableSerializer.cc index 8af78793..8038a739 100644 --- a/src/DHTRoutingTableSerializer.cc +++ b/src/DHTRoutingTableSerializer.cc @@ -57,13 +57,13 @@ DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {} void DHTRoutingTableSerializer::setLocalNode (const SharedHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } void DHTRoutingTableSerializer::setNodes (const std::vector<SharedHandle<DHTNode> >& nodes) { - _nodes = nodes; + nodes_ = nodes; } void DHTRoutingTableSerializer::serialize(std::ostream& o) @@ -91,19 +91,19 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o) // 8bytes reserved o.write(zero, 8); // 20bytes localnode ID - o.write(reinterpret_cast<const char*>(_localNode->getID()), DHT_ID_LENGTH); + o.write(reinterpret_cast<const char*>(localNode_->getID()), DHT_ID_LENGTH); // 4bytes reserved o.write(zero, 4); // number of nodes - uint32_t numNodes = htonl(_nodes.size()); + uint32_t numNodes = htonl(nodes_.size()); o.write(reinterpret_cast<const char*>(&numNodes), sizeof(uint32_t)); // 4bytes reserved o.write(zero, 4); // nodes - for(std::vector<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin(), - eoi = _nodes.end(); i != eoi; ++i) { + for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes_.begin(), + eoi = nodes_.end(); i != eoi; ++i) { const SharedHandle<DHTNode>& node = *i; // Currently, only IPv4 address and IPv4-mapped address are saved. // 6bytes: write IP address + port in Compact IP-address/port info form. diff --git a/src/DHTRoutingTableSerializer.h b/src/DHTRoutingTableSerializer.h index bcc44d61..352bc08a 100644 --- a/src/DHTRoutingTableSerializer.h +++ b/src/DHTRoutingTableSerializer.h @@ -48,9 +48,9 @@ class DHTNode; class DHTRoutingTableSerializer { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - std::vector<SharedHandle<DHTNode> > _nodes; + std::vector<SharedHandle<DHTNode> > nodes_; public: DHTRoutingTableSerializer(); diff --git a/src/DHTSetup.cc b/src/DHTSetup.cc index 2db5189f..c6e623e8 100644 --- a/src/DHTSetup.cc +++ b/src/DHTSetup.cc @@ -80,15 +80,15 @@ namespace aria2 { // TODO DownloadEngine should hold this flag. -bool DHTSetup::_initialized = false; +bool DHTSetup::initialized_ = false; -DHTSetup::DHTSetup():_logger(LogFactory::getInstance()) {} +DHTSetup::DHTSetup():logger_(LogFactory::getInstance()) {} DHTSetup::~DHTSetup() {} void DHTSetup::setup(std::vector<Command*>& commands, DownloadEngine* e) { - if(_initialized) { + if(initialized_) { return; } try { @@ -108,7 +108,7 @@ void DHTSetup::setup(std::vector<Command*>& commands, DownloadEngine* e) deserializer.deserialize(in); localNode = deserializer.getLocalNode(); } catch(RecoverableException& e) { - _logger->error("Exception caught while loading DHT routing table from %s", + logger_->error("Exception caught while loading DHT routing table from %s", e, dhtFile.c_str()); } if(localNode.isNull()) { @@ -125,8 +125,8 @@ void DHTSetup::setup(std::vector<Command*>& commands, DownloadEngine* e) } localNode->setPort(port); } - if(_logger->debug()) { - _logger->debug("Initialized local node ID=%s", + if(logger_->debug()) { + logger_->debug("Initialized local node ID=%s", util::toHex(localNode->getID(), DHT_ID_LENGTH).c_str()); } SharedHandle<DHTRoutingTable> routingTable(new DHTRoutingTable(localNode)); @@ -223,7 +223,7 @@ void DHTSetup::setup(std::vector<Command*>& commands, DownloadEngine* e) tempCommands->push_back(command); } } else { - _logger->info("No DHT entry point specified."); + logger_->info("No DHT entry point specified."); } { DHTInteractionCommand* command = @@ -263,11 +263,11 @@ void DHTSetup::setup(std::vector<Command*>& commands, DownloadEngine* e) command->setRoutingTable(routingTable); tempCommands->push_back(command); } - _initialized = true; + initialized_ = true; commands.insert(commands.end(), tempCommands->begin(), tempCommands->end()); tempCommands->clear(); } catch(RecoverableException& e) { - _logger->error("Exception caught while initializing DHT functionality." + logger_->error("Exception caught while initializing DHT functionality." " DHT is disabled.", e); DHTRegistry::clearData(); } @@ -275,7 +275,7 @@ void DHTSetup::setup(std::vector<Command*>& commands, DownloadEngine* e) bool DHTSetup::initialized() { - return _initialized; + return initialized_; } } // namespace aria2 diff --git a/src/DHTSetup.h b/src/DHTSetup.h index 7678b631..ca932554 100644 --- a/src/DHTSetup.h +++ b/src/DHTSetup.h @@ -45,9 +45,9 @@ class Command; class DHTSetup { private: - static bool _initialized; + static bool initialized_; - Logger* _logger; + Logger* logger_; public: DHTSetup(); diff --git a/src/DHTTaskFactoryImpl.cc b/src/DHTTaskFactoryImpl.cc index 77fb9514..b95a462b 100644 --- a/src/DHTTaskFactoryImpl.cc +++ b/src/DHTTaskFactoryImpl.cc @@ -54,8 +54,8 @@ namespace aria2 { DHTTaskFactoryImpl::DHTTaskFactoryImpl(): - _timeout(DHT_MESSAGE_TIMEOUT), - _logger(LogFactory::getInstance()) {} + timeout_(DHT_MESSAGE_TIMEOUT), + logger_(LogFactory::getInstance()) {} DHTTaskFactoryImpl::~DHTTaskFactoryImpl() {} @@ -64,7 +64,7 @@ DHTTaskFactoryImpl::createPingTask(const SharedHandle<DHTNode>& remoteNode, size_t numRetry) { SharedHandle<DHTPingTask> task(new DHTPingTask(remoteNode, numRetry)); - task->setTimeout(_timeout); + task->setTimeout(timeout_); setCommonProperty(task); return task; } @@ -111,43 +111,43 @@ DHTTaskFactoryImpl::createReplaceNodeTask(const SharedHandle<DHTBucket>& bucket, const SharedHandle<DHTNode>& newNode) { SharedHandle<DHTReplaceNodeTask> task(new DHTReplaceNodeTask(bucket, newNode)); - task->setTimeout(_timeout); + task->setTimeout(timeout_); setCommonProperty(task); return task; } void DHTTaskFactoryImpl::setCommonProperty(const SharedHandle<DHTAbstractTask>& task) { - task->setRoutingTable(_routingTable); - task->setMessageDispatcher(_dispatcher); - task->setMessageFactory(_factory); - task->setTaskQueue(_taskQueue); - task->setLocalNode(_localNode); + task->setRoutingTable(routingTable_); + task->setMessageDispatcher(dispatcher_); + task->setMessageFactory(factory_); + task->setTaskQueue(taskQueue_); + task->setLocalNode(localNode_); } void DHTTaskFactoryImpl::setRoutingTable(const WeakHandle<DHTRoutingTable> routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DHTTaskFactoryImpl::setMessageDispatcher(const WeakHandle<DHTMessageDispatcher> dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DHTTaskFactoryImpl::setMessageFactory(const WeakHandle<DHTMessageFactory> factory) { - _factory = factory; + factory_ = factory; } void DHTTaskFactoryImpl::setTaskQueue(const WeakHandle<DHTTaskQueue> taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DHTTaskFactoryImpl::setLocalNode(const SharedHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } } // namespace aria2 diff --git a/src/DHTTaskFactoryImpl.h b/src/DHTTaskFactoryImpl.h index c0076a75..5bf38b55 100644 --- a/src/DHTTaskFactoryImpl.h +++ b/src/DHTTaskFactoryImpl.h @@ -50,19 +50,19 @@ class Logger; class DHTTaskFactoryImpl:public DHTTaskFactory { private: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; - WeakHandle<DHTRoutingTable> _routingTable; + WeakHandle<DHTRoutingTable> routingTable_; - WeakHandle<DHTMessageDispatcher> _dispatcher; + WeakHandle<DHTMessageDispatcher> dispatcher_; - WeakHandle<DHTMessageFactory> _factory; + WeakHandle<DHTMessageFactory> factory_; - WeakHandle<DHTTaskQueue> _taskQueue; + WeakHandle<DHTTaskQueue> taskQueue_; - time_t _timeout; + time_t timeout_; - Logger* _logger; + Logger* logger_; void setCommonProperty(const SharedHandle<DHTAbstractTask>& task); public: @@ -103,7 +103,7 @@ public: void setTimeout(time_t timeout) { - _timeout = timeout; + timeout_ = timeout; } }; diff --git a/src/DHTTaskQueueImpl.cc b/src/DHTTaskQueueImpl.cc index a7ccae9b..65cff073 100644 --- a/src/DHTTaskQueueImpl.cc +++ b/src/DHTTaskQueueImpl.cc @@ -61,24 +61,24 @@ void DHTTaskQueueImpl::executeTask(SharedHandle<DHTTask>& task, void DHTTaskQueueImpl::executeTask() { - executeTask(_periodicTask1, _periodicTaskQueue1); - executeTask(_periodicTask2, _periodicTaskQueue2); - executeTask(_immediateTask, _immediateTaskQueue); + executeTask(periodicTask1_, periodicTaskQueue1_); + executeTask(periodicTask2_, periodicTaskQueue2_); + executeTask(immediateTask_, immediateTaskQueue_); } void DHTTaskQueueImpl::addPeriodicTask1(const SharedHandle<DHTTask>& task) { - _periodicTaskQueue1.push_back(task); + periodicTaskQueue1_.push_back(task); } void DHTTaskQueueImpl::addPeriodicTask2(const SharedHandle<DHTTask>& task) { - _periodicTaskQueue2.push_back(task); + periodicTaskQueue2_.push_back(task); } void DHTTaskQueueImpl::addImmediateTask(const SharedHandle<DHTTask>& task) { - _immediateTaskQueue.push_back(task); + immediateTaskQueue_.push_back(task); } } // namespace aria2 diff --git a/src/DHTTaskQueueImpl.h b/src/DHTTaskQueueImpl.h index 12c85d66..53edd078 100644 --- a/src/DHTTaskQueueImpl.h +++ b/src/DHTTaskQueueImpl.h @@ -43,17 +43,17 @@ namespace aria2 { class DHTTaskQueueImpl:public DHTTaskQueue { private: - SharedHandle<DHTTask> _periodicTask1; + SharedHandle<DHTTask> periodicTask1_; - SharedHandle<DHTTask> _periodicTask2; + SharedHandle<DHTTask> periodicTask2_; - SharedHandle<DHTTask> _immediateTask; + SharedHandle<DHTTask> immediateTask_; - std::deque<SharedHandle<DHTTask> > _periodicTaskQueue1; + std::deque<SharedHandle<DHTTask> > periodicTaskQueue1_; - std::deque<SharedHandle<DHTTask> > _periodicTaskQueue2; + std::deque<SharedHandle<DHTTask> > periodicTaskQueue2_; - std::deque<SharedHandle<DHTTask> > _immediateTaskQueue; + std::deque<SharedHandle<DHTTask> > immediateTaskQueue_; void executeTask(SharedHandle<DHTTask>& task, std::deque<SharedHandle<DHTTask> >& taskQueue); public: diff --git a/src/DHTTokenTracker.cc b/src/DHTTokenTracker.cc index 760551bf..6583e69e 100644 --- a/src/DHTTokenTracker.cc +++ b/src/DHTTokenTracker.cc @@ -47,14 +47,14 @@ namespace aria2 { DHTTokenTracker::DHTTokenTracker() { - util::generateRandomData(_secret[0], SECRET_SIZE); - memcpy(_secret[1], _secret[0], SECRET_SIZE); + util::generateRandomData(secret_[0], SECRET_SIZE); + memcpy(secret_[1], secret_[0], SECRET_SIZE); } DHTTokenTracker::DHTTokenTracker(const unsigned char* initialSecret) { - memcpy(_secret[0], initialSecret, SECRET_SIZE); - memcpy(_secret[1], initialSecret, SECRET_SIZE); + memcpy(secret_[0], initialSecret, SECRET_SIZE); + memcpy(secret_[1], initialSecret, SECRET_SIZE); } DHTTokenTracker::~DHTTokenTracker() {} @@ -79,7 +79,7 @@ std::string DHTTokenTracker::generateToken(const unsigned char* infoHash, std::string DHTTokenTracker::generateToken(const unsigned char* infoHash, const std::string& ipaddr, uint16_t port) const { - return generateToken(infoHash, ipaddr, port, _secret[0]); + return generateToken(infoHash, ipaddr, port, secret_[0]); } bool DHTTokenTracker::validateToken(const std::string& token, @@ -87,7 +87,7 @@ bool DHTTokenTracker::validateToken(const std::string& token, const std::string& ipaddr, uint16_t port) const { for(int i = 0; i < 2; ++i) { - if(generateToken(infoHash, ipaddr, port, _secret[i]) == token) { + if(generateToken(infoHash, ipaddr, port, secret_[i]) == token) { return true; } } @@ -96,8 +96,8 @@ bool DHTTokenTracker::validateToken(const std::string& token, void DHTTokenTracker::updateTokenSecret() { - memcpy(_secret[1], _secret[0], SECRET_SIZE); - util::generateRandomData(_secret[0], SECRET_SIZE); + memcpy(secret_[1], secret_[0], SECRET_SIZE); + util::generateRandomData(secret_[0], SECRET_SIZE); } } // namespace aria2 diff --git a/src/DHTTokenTracker.h b/src/DHTTokenTracker.h index a1453aab..d0d835d6 100644 --- a/src/DHTTokenTracker.h +++ b/src/DHTTokenTracker.h @@ -44,7 +44,7 @@ class DHTTokenTracker { private: static const size_t SECRET_SIZE = 4; - unsigned char _secret[2][SECRET_SIZE]; + unsigned char secret_[2][SECRET_SIZE]; std::string generateToken(const unsigned char* infoHash, const std::string& ipaddr, uint16_t port, diff --git a/src/DHTTokenUpdateCommand.cc b/src/DHTTokenUpdateCommand.cc index af80654a..4c6fab32 100644 --- a/src/DHTTokenUpdateCommand.cc +++ b/src/DHTTokenUpdateCommand.cc @@ -64,7 +64,7 @@ void DHTTokenUpdateCommand::preProcess() void DHTTokenUpdateCommand::process() { try { - _tokenTracker->updateTokenSecret(); + tokenTracker_->updateTokenSecret(); } catch(RecoverableException& e) { getLogger()->error(EX_EXCEPTION_CAUGHT, e); } @@ -72,7 +72,7 @@ void DHTTokenUpdateCommand::process() void DHTTokenUpdateCommand::setTokenTracker(const SharedHandle<DHTTokenTracker>& tokenTracker) { - _tokenTracker = tokenTracker; + tokenTracker_ = tokenTracker; } } // namespace aria2 diff --git a/src/DHTTokenUpdateCommand.h b/src/DHTTokenUpdateCommand.h index 9ba2242d..3f1a7a58 100644 --- a/src/DHTTokenUpdateCommand.h +++ b/src/DHTTokenUpdateCommand.h @@ -44,7 +44,7 @@ class DHTTokenTracker; class DHTTokenUpdateCommand:public TimeBasedCommand { private: - SharedHandle<DHTTokenTracker> _tokenTracker; + SharedHandle<DHTTokenTracker> tokenTracker_; public: DHTTokenUpdateCommand(cuid_t cuid, DownloadEngine* e, time_t interval); diff --git a/src/DHTUnknownMessage.cc b/src/DHTUnknownMessage.cc index 81127741..b5facb43 100644 --- a/src/DHTUnknownMessage.cc +++ b/src/DHTUnknownMessage.cc @@ -51,21 +51,21 @@ DHTUnknownMessage::DHTUnknownMessage(const SharedHandle<DHTNode>& localNode, const unsigned char* data, size_t length, const std::string& ipaddr, uint16_t port): DHTMessage(localNode, SharedHandle<DHTNode>()), - _length(length), - _ipaddr(ipaddr), - _port(port) + length_(length), + ipaddr_(ipaddr), + port_(port) { - if(_length == 0) { - _data = 0; + if(length_ == 0) { + data_ = 0; } else { - _data = new unsigned char[length]; - memcpy(_data, data, length); + data_ = new unsigned char[length]; + memcpy(data_, data, length); } } DHTUnknownMessage::~DHTUnknownMessage() { - delete [] _data; + delete [] data_; } void DHTUnknownMessage::doReceivedAction() {} @@ -85,13 +85,13 @@ const std::string& DHTUnknownMessage::getMessageType() const std::string DHTUnknownMessage::toString() const { size_t sampleLength = 8; - if(_length < sampleLength) { - sampleLength = _length; + if(length_ < sampleLength) { + sampleLength = length_; } - std::string sample(&_data[0], &_data[sampleLength]); + std::string sample(&data_[0], &data_[sampleLength]); - return strconcat("dht unknown Remote:", _ipaddr, ":", util::uitos(_port), - " length=", util::uitos(_length), + return strconcat("dht unknown Remote:", ipaddr_, ":", util::uitos(port_), + " length=", util::uitos(length_), ", first 8 bytes(hex)=", util::toHex(sample)); } diff --git a/src/DHTUnknownMessage.h b/src/DHTUnknownMessage.h index 7cac8d4b..b1a11c64 100644 --- a/src/DHTUnknownMessage.h +++ b/src/DHTUnknownMessage.h @@ -41,10 +41,10 @@ namespace aria2 { class DHTUnknownMessage:public DHTMessage { private: - unsigned char* _data; - size_t _length; - std::string _ipaddr; - uint16_t _port; + unsigned char* data_; + size_t length_; + std::string ipaddr_; + uint16_t port_; public: // _remoteNode is always null DHTUnknownMessage(const SharedHandle<DHTNode>& localNode, diff --git a/src/DNSCache.h b/src/DNSCache.h index 66459075..fc242f59 100644 --- a/src/DNSCache.h +++ b/src/DNSCache.h @@ -49,59 +49,59 @@ namespace aria2 { class DNSCache { private: struct AddrEntry { - std::string _addr; - bool _good; + std::string addr_; + bool good_; - AddrEntry(const std::string& addr):_addr(addr), _good(true) {} + AddrEntry(const std::string& addr):addr_(addr), good_(true) {} }; struct CacheEntry { - std::string _hostname; - uint16_t _port; - std::vector<AddrEntry> _addrEntries; + std::string hostname_; + uint16_t port_; + std::vector<AddrEntry> addrEntries_; CacheEntry (const std::string& hostname, uint16_t port): - _hostname(hostname), _port(port) {} + hostname_(hostname), port_(port) {} void add(const std::string& addr) { - _addrEntries.push_back(AddrEntry(addr)); + addrEntries_.push_back(AddrEntry(addr)); } std::vector<AddrEntry>::iterator find(const std::string& addr) { - for(std::vector<AddrEntry>::iterator i = _addrEntries.begin(), - eoi = _addrEntries.end(); i != eoi; ++i) { - if((*i)._addr == addr) { + for(std::vector<AddrEntry>::iterator i = addrEntries_.begin(), + eoi = addrEntries_.end(); i != eoi; ++i) { + if((*i).addr_ == addr) { return i; } } - return _addrEntries.end(); + return addrEntries_.end(); } std::vector<AddrEntry>::const_iterator find(const std::string& addr) const { - for(std::vector<AddrEntry>::const_iterator i = _addrEntries.begin(), - eoi = _addrEntries.end(); i != eoi; ++i) { - if((*i)._addr == addr) { + for(std::vector<AddrEntry>::const_iterator i = addrEntries_.begin(), + eoi = addrEntries_.end(); i != eoi; ++i) { + if((*i).addr_ == addr) { return i; } } - return _addrEntries.end(); + return addrEntries_.end(); } bool contains(const std::string& addr) const { - return find(addr) != _addrEntries.end(); + return find(addr) != addrEntries_.end(); } const std::string& getGoodAddr() const { - for(std::vector<AddrEntry>::const_iterator i = _addrEntries.begin(), - eoi = _addrEntries.end(); i != eoi; ++i) { - if((*i)._good) { - return (*i)._addr; + for(std::vector<AddrEntry>::const_iterator i = addrEntries_.begin(), + eoi = addrEntries_.end(); i != eoi; ++i) { + if((*i).good_) { + return (*i).addr_; } } return A2STR::NIL; @@ -110,10 +110,10 @@ private: template<typename OutputIterator> void getAllGoodAddrs(OutputIterator out) const { - for(std::vector<AddrEntry>::const_iterator i = _addrEntries.begin(), - eoi = _addrEntries.end(); i != eoi; ++i) { - if((*i)._good) { - *out++ = (*i)._addr; + for(std::vector<AddrEntry>::const_iterator i = addrEntries_.begin(), + eoi = addrEntries_.end(); i != eoi; ++i) { + if((*i).good_) { + *out++ = (*i).addr_; } } } @@ -121,35 +121,35 @@ private: void markBad(const std::string& addr) { std::vector<AddrEntry>::iterator i = find(addr); - if(i != _addrEntries.end()) { - (*i)._good = false; + if(i != addrEntries_.end()) { + (*i).good_ = false; } } bool operator<(const CacheEntry& e) const { - int r = _hostname.compare(e._hostname); + int r = hostname_.compare(e.hostname_); if(r != 0) { return r < 0; } - return _port < e._port; + return port_ < e.port_; } bool operator==(const CacheEntry& e) const { - return _hostname == e._hostname && _port == e._port; + return hostname_ == e.hostname_ && port_ == e.port_; } }; - std::deque<CacheEntry> _entries; + std::deque<CacheEntry> entries_; public: const std::string& find(const std::string& hostname, uint16_t port) const { CacheEntry target(hostname, port); std::deque<CacheEntry>::const_iterator i = - std::lower_bound(_entries.begin(), _entries.end(), target); - if(i != _entries.end() && (*i) == target) { + std::lower_bound(entries_.begin(), entries_.end(), target); + if(i != entries_.end() && (*i) == target) { return (*i).getGoodAddr(); } return A2STR::NIL; @@ -161,8 +161,8 @@ public: { CacheEntry target(hostname, port); std::deque<CacheEntry>::const_iterator i = - std::lower_bound(_entries.begin(), _entries.end(), target); - if(i != _entries.end() && (*i) == target) { + std::lower_bound(entries_.begin(), entries_.end(), target); + if(i != entries_.end() && (*i) == target) { (*i).getAllGoodAddrs(out); } } @@ -172,10 +172,10 @@ public: { CacheEntry target(hostname, port); std::deque<CacheEntry>::iterator i = - std::lower_bound(_entries.begin(), _entries.end(), target); - if(i == _entries.end() || !((*i) == target)) { + std::lower_bound(entries_.begin(), entries_.end(), target); + if(i == entries_.end() || !((*i) == target)) { target.add(ipaddr); - _entries.insert(i, target); + entries_.insert(i, target); } else { if(!(*i).contains(ipaddr)) { (*i).add(ipaddr); @@ -188,8 +188,8 @@ public: { CacheEntry target(hostname, port); std::deque<CacheEntry>::iterator i = - std::lower_bound(_entries.begin(), _entries.end(), target); - if(i != _entries.end() && (*i) == target) { + std::lower_bound(entries_.begin(), entries_.end(), target); + if(i != entries_.end() && (*i) == target) { (*i).markBad(ipaddr); } } @@ -198,9 +198,9 @@ public: { CacheEntry target(hostname, port); std::deque<CacheEntry>::iterator i = - std::lower_bound(_entries.begin(), _entries.end(), target); - if(i != _entries.end() && (*i) == target) { - _entries.erase(i); + std::lower_bound(entries_.begin(), entries_.end(), target); + if(i != entries_.end() && (*i) == target) { + entries_.erase(i); } } }; diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc index f9bb0deb..b6f58709 100644 --- a/src/DefaultBtAnnounce.cc +++ b/src/DefaultBtAnnounce.cc @@ -58,18 +58,18 @@ namespace aria2 { DefaultBtAnnounce::DefaultBtAnnounce (const SharedHandle<DownloadContext>& downloadContext, const Option* option): - _downloadContext(downloadContext), - _trackers(0), - _prevAnnounceTimer(0), - _interval(DEFAULT_ANNOUNCE_INTERVAL), - _minInterval(DEFAULT_ANNOUNCE_INTERVAL), - _userDefinedInterval(0), - _complete(0), - _incomplete(0), - _announceList(bittorrent::getTorrentAttrs(downloadContext)->announceList), - _option(option), - _logger(LogFactory::getInstance()), - _randomizer(SimpleRandomizer::getInstance()) + downloadContext_(downloadContext), + trackers_(0), + prevAnnounceTimer_(0), + interval_(DEFAULT_ANNOUNCE_INTERVAL), + minInterval_(DEFAULT_ANNOUNCE_INTERVAL), + userDefinedInterval_(0), + complete_(0), + incomplete_(0), + announceList_(bittorrent::getTorrentAttrs(downloadContext)->announceList), + option_(option), + logger_(LogFactory::getInstance()), + randomizer_(SimpleRandomizer::getInstance()) {} DefaultBtAnnounce::~DefaultBtAnnounce() { @@ -77,23 +77,23 @@ DefaultBtAnnounce::~DefaultBtAnnounce() { bool DefaultBtAnnounce::isDefaultAnnounceReady() { return - (_trackers == 0 && - _prevAnnounceTimer. - difference(global::wallclock) >= (_userDefinedInterval==0? - _minInterval:_userDefinedInterval) && - !_announceList.allTiersFailed()); + (trackers_ == 0 && + prevAnnounceTimer_. + difference(global::wallclock) >= (userDefinedInterval_==0? + minInterval_:userDefinedInterval_) && + !announceList_.allTiersFailed()); } bool DefaultBtAnnounce::isStoppedAnnounceReady() { - return (_trackers == 0 && - _btRuntime->isHalt() && - _announceList.countStoppedAllowedTier()); + return (trackers_ == 0 && + btRuntime_->isHalt() && + announceList_.countStoppedAllowedTier()); } bool DefaultBtAnnounce::isCompletedAnnounceReady() { - return (_trackers == 0 && - _pieceStorage->allDownloadFinished() && - _announceList.countCompletedAllowedTier()); + return (trackers_ == 0 && + pieceStorage_->allDownloadFinished() && + announceList_.countCompletedAllowedTier()); } bool DefaultBtAnnounce::isAnnounceReady() { @@ -112,37 +112,37 @@ static bool uriHasQuery(const std::string& uri) std::string DefaultBtAnnounce::getAnnounceUrl() { if(isStoppedAnnounceReady()) { - if(!_announceList.currentTierAcceptsStoppedEvent()) { - _announceList.moveToStoppedAllowedTier(); + if(!announceList_.currentTierAcceptsStoppedEvent()) { + announceList_.moveToStoppedAllowedTier(); } - _announceList.setEvent(AnnounceTier::STOPPED); + announceList_.setEvent(AnnounceTier::STOPPED); } else if(isCompletedAnnounceReady()) { - if(!_announceList.currentTierAcceptsCompletedEvent()) { - _announceList.moveToCompletedAllowedTier(); + if(!announceList_.currentTierAcceptsCompletedEvent()) { + announceList_.moveToCompletedAllowedTier(); } - _announceList.setEvent(AnnounceTier::COMPLETED); + announceList_.setEvent(AnnounceTier::COMPLETED); } else if(isDefaultAnnounceReady()) { // If download completed before "started" event is sent to a tracker, // we change the event to something else to prevent us from // sending "completed" event. - if(_pieceStorage->allDownloadFinished() && - _announceList.getEvent() == AnnounceTier::STARTED) { - _announceList.setEvent(AnnounceTier::STARTED_AFTER_COMPLETION); + if(pieceStorage_->allDownloadFinished() && + announceList_.getEvent() == AnnounceTier::STARTED) { + announceList_.setEvent(AnnounceTier::STARTED_AFTER_COMPLETION); } } else { return A2STR::NIL; } unsigned int numWant = 50; - if(!_btRuntime->lessThanMinPeers() || _btRuntime->isHalt()) { + if(!btRuntime_->lessThanMinPeers() || btRuntime_->isHalt()) { numWant = 0; } - TransferStat stat = _peerStorage->calculateStat(); + TransferStat stat = peerStorage_->calculateStat(); uint64_t left = - _pieceStorage->getTotalLength()-_pieceStorage->getCompletedLength(); - std::string uri = _announceList.getAnnounce(); + pieceStorage_->getTotalLength()-pieceStorage_->getCompletedLength(); + std::string uri = announceList_.getAnnounce(); uri += uriHasQuery(uri) ? "&" : "?"; uri += "info_hash="; - uri += util::torrentPercentEncode(bittorrent::getInfoHash(_downloadContext), + uri += util::torrentPercentEncode(bittorrent::getInfoHash(downloadContext_), INFO_HASH_LENGTH); uri += "&peer_id="; uri += util::torrentPercentEncode(bittorrent::getStaticPeerId(), @@ -162,59 +162,59 @@ std::string DefaultBtAnnounce::getAnnounceUrl() { uri += "&numwant="; uri += util::uitos(numWant); uri += "&no_peer_id=1"; - if(_btRuntime->getListenPort() > 0) { + if(btRuntime_->getListenPort() > 0) { uri += "&port="; - uri += util::uitos(_btRuntime->getListenPort()); + uri += util::uitos(btRuntime_->getListenPort()); } - std::string event = _announceList.getEventString(); + std::string event = announceList_.getEventString(); if(!event.empty()) { uri += "&event="; uri += event; } - if(!_trackerId.empty()) { - uri += "&trackerid="+util::torrentPercentEncode(_trackerId); + if(!trackerId_.empty()) { + uri += "&trackerid="+util::torrentPercentEncode(trackerId_); } - if(_option->getAsBool(PREF_BT_REQUIRE_CRYPTO)) { + if(option_->getAsBool(PREF_BT_REQUIRE_CRYPTO)) { uri += "&requirecrypto=1"; } else { uri += "&supportcrypto=1"; } - if(!_option->blank(PREF_BT_EXTERNAL_IP)) { + if(!option_->blank(PREF_BT_EXTERNAL_IP)) { uri += "&ip="; - uri += _option->get(PREF_BT_EXTERNAL_IP); + uri += option_->get(PREF_BT_EXTERNAL_IP); } return uri; } void DefaultBtAnnounce::announceStart() { - ++_trackers; + ++trackers_; } void DefaultBtAnnounce::announceSuccess() { - _trackers = 0; - _announceList.announceSuccess(); + trackers_ = 0; + announceList_.announceSuccess(); } void DefaultBtAnnounce::announceFailure() { - _trackers = 0; - _announceList.announceFailure(); + trackers_ = 0; + announceList_.announceFailure(); } bool DefaultBtAnnounce::isAllAnnounceFailed() { - return _announceList.allTiersFailed(); + return announceList_.allTiersFailed(); } void DefaultBtAnnounce::resetAnnounce() { - _prevAnnounceTimer = global::wallclock; - _announceList.resetTier(); + prevAnnounceTimer_ = global::wallclock; + announceList_.resetTier(); } void DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse, size_t trackerResponseLength) { - if(_logger->debug()) { - _logger->debug("Now processing tracker response."); + if(logger_->debug()) { + logger_->debug("Now processing tracker response."); } SharedHandle<ValueBase> decodedValue = bencode2::decode(trackerResponse, trackerResponseLength); @@ -229,92 +229,92 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse, } const String* warn = asString(dict->get(BtAnnounce::WARNING_MESSAGE)); if(warn) { - _logger->warn(MSG_TRACKER_WARNING_MESSAGE, warn->s().c_str()); + logger_->warn(MSG_TRACKER_WARNING_MESSAGE, warn->s().c_str()); } const String* tid = asString(dict->get(BtAnnounce::TRACKER_ID)); if(tid) { - _trackerId = tid->s(); - if(_logger->debug()) { - _logger->debug("Tracker ID:%s", _trackerId.c_str()); + trackerId_ = tid->s(); + if(logger_->debug()) { + logger_->debug("Tracker ID:%s", trackerId_.c_str()); } } const Integer* ival = asInteger(dict->get(BtAnnounce::INTERVAL)); if(ival && ival->i() > 0) { - _interval = ival->i(); - if(_logger->debug()) { - _logger->debug("Interval:%d", _interval); + interval_ = ival->i(); + if(logger_->debug()) { + logger_->debug("Interval:%d", interval_); } } const Integer* mival = asInteger(dict->get(BtAnnounce::MIN_INTERVAL)); if(mival && mival->i() > 0) { - _minInterval = mival->i(); - if(_logger->debug()) { - _logger->debug("Min interval:%d", _minInterval); + minInterval_ = mival->i(); + if(logger_->debug()) { + logger_->debug("Min interval:%d", minInterval_); } - _minInterval = std::min(_minInterval, _interval); + minInterval_ = std::min(minInterval_, interval_); } else { // Use interval as a minInterval if minInterval is not supplied. - _minInterval = _interval; + minInterval_ = interval_; } const Integer* comp = asInteger(dict->get(BtAnnounce::COMPLETE)); if(comp) { - _complete = comp->i(); - if(_logger->debug()) { - _logger->debug("Complete:%d", _complete); + complete_ = comp->i(); + if(logger_->debug()) { + logger_->debug("Complete:%d", complete_); } } const Integer* incomp = asInteger(dict->get(BtAnnounce::INCOMPLETE)); if(incomp) { - _incomplete = incomp->i(); - if(_logger->debug()) { - _logger->debug("Incomplete:%d", _incomplete); + incomplete_ = incomp->i(); + if(logger_->debug()) { + logger_->debug("Incomplete:%d", incomplete_); } } const SharedHandle<ValueBase>& peerData = dict->get(BtAnnounce::PEERS); if(peerData.isNull()) { - _logger->info(MSG_NO_PEER_LIST_RECEIVED); + logger_->info(MSG_NO_PEER_LIST_RECEIVED); } else { - if(!_btRuntime->isHalt() && _btRuntime->lessThanMinPeers()) { + if(!btRuntime_->isHalt() && btRuntime_->lessThanMinPeers()) { std::vector<SharedHandle<Peer> > peers; bittorrent::extractPeer(peerData, std::back_inserter(peers)); - _peerStorage->addPeer(peers); + peerStorage_->addPeer(peers); } } } bool DefaultBtAnnounce::noMoreAnnounce() { - return (_trackers == 0 && - _btRuntime->isHalt() && - !_announceList.countStoppedAllowedTier()); + return (trackers_ == 0 && + btRuntime_->isHalt() && + !announceList_.countStoppedAllowedTier()); } void DefaultBtAnnounce::shuffleAnnounce() { - _announceList.shuffle(); + announceList_.shuffle(); } void DefaultBtAnnounce::setRandomizer(const RandomizerHandle& randomizer) { - _randomizer = randomizer; + randomizer_ = randomizer; } void DefaultBtAnnounce::setBtRuntime(const BtRuntimeHandle& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void DefaultBtAnnounce::setPieceStorage(const PieceStorageHandle& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void DefaultBtAnnounce::setPeerStorage(const PeerStorageHandle& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void DefaultBtAnnounce::overrideMinInterval(time_t interval) { - _minInterval = interval; + minInterval_ = interval; } } // namespace aria2 diff --git a/src/DefaultBtAnnounce.h b/src/DefaultBtAnnounce.h index 98f78d55..42d58600 100644 --- a/src/DefaultBtAnnounce.h +++ b/src/DefaultBtAnnounce.h @@ -51,22 +51,22 @@ class Randomizer; class DefaultBtAnnounce : public BtAnnounce { private: - SharedHandle<DownloadContext> _downloadContext; - unsigned int _trackers; - Timer _prevAnnounceTimer; - time_t _interval; - time_t _minInterval; - time_t _userDefinedInterval; - unsigned int _complete; - unsigned int _incomplete; - AnnounceList _announceList; - std::string _trackerId; - const Option* _option; - Logger* _logger; - SharedHandle<Randomizer> _randomizer; - SharedHandle<BtRuntime> _btRuntime; - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<DownloadContext> downloadContext_; + unsigned int trackers_; + Timer prevAnnounceTimer_; + time_t interval_; + time_t minInterval_; + time_t userDefinedInterval_; + unsigned int complete_; + unsigned int incomplete_; + AnnounceList announceList_; + std::string trackerId_; + const Option* option_; + Logger* logger_; + SharedHandle<Randomizer> randomizer_; + SharedHandle<BtRuntime> btRuntime_; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<PeerStorage> peerStorage_; public: DefaultBtAnnounce(const SharedHandle<DownloadContext>& downloadContext, const Option* option); @@ -77,21 +77,21 @@ public: const SharedHandle<BtRuntime>& getBtRuntime() const { - return _btRuntime; + return btRuntime_; } void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage); const SharedHandle<PieceStorage>& getPieceStorage() const { - return _pieceStorage; + return pieceStorage_; } void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage); const SharedHandle<PeerStorage>& getPeerStorage() const { - return _peerStorage; + return peerStorage_; } bool isDefaultAnnounceReady(); @@ -127,32 +127,32 @@ public: time_t getInterval() const { - return _interval; + return interval_; } time_t getMinInterval() const { - return _minInterval; + return minInterval_; } unsigned int getComplete() const { - return _complete; + return complete_; } unsigned int getIncomplete() const { - return _incomplete; + return incomplete_; } const std::string& getTrackerID() const { - return _trackerId; + return trackerId_; } void setUserDefinedInterval(time_t interval) { - _userDefinedInterval = interval; + userDefinedInterval_ = interval; } }; diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc index 8589ae63..b00c25d2 100644 --- a/src/DefaultBtInteractive.cc +++ b/src/DefaultBtInteractive.cc @@ -80,37 +80,37 @@ DefaultBtInteractive::DefaultBtInteractive (const SharedHandle<DownloadContext>& downloadContext, const SharedHandle<Peer>& peer) : - _downloadContext(downloadContext), - _peer(peer), - _metadataGetMode(false), - _logger(LogFactory::getInstance()), - _allowedFastSetSize(10), - _haveTimer(global::wallclock), - _keepAliveTimer(global::wallclock), - _floodingTimer(global::wallclock), - _inactiveTimer(global::wallclock), - _pexTimer(global::wallclock), - _perSecTimer(global::wallclock), - _keepAliveInterval(120), - _utPexEnabled(false), - _dhtEnabled(false), - _numReceivedMessage(0), - _maxOutstandingRequest(DEFAULT_MAX_OUTSTANDING_REQUEST) + downloadContext_(downloadContext), + peer_(peer), + metadataGetMode_(false), + logger_(LogFactory::getInstance()), + allowedFastSetSize_(10), + haveTimer_(global::wallclock), + keepAliveTimer_(global::wallclock), + floodingTimer_(global::wallclock), + inactiveTimer_(global::wallclock), + pexTimer_(global::wallclock), + perSecTimer_(global::wallclock), + keepAliveInterval_(120), + utPexEnabled_(false), + dhtEnabled_(false), + numReceivedMessage_(0), + maxOutstandingRequest_(DEFAULT_MAX_OUTSTANDING_REQUEST) {} DefaultBtInteractive::~DefaultBtInteractive() {} void DefaultBtInteractive::initiateHandshake() { SharedHandle<BtMessage> message = - _messageFactory->createHandshakeMessage - (bittorrent::getInfoHash(_downloadContext), bittorrent::getStaticPeerId()); - _dispatcher->addMessageToQueue(message); - _dispatcher->sendMessages(); + messageFactory_->createHandshakeMessage + (bittorrent::getInfoHash(downloadContext_), bittorrent::getStaticPeerId()); + dispatcher_->addMessageToQueue(message); + dispatcher_->sendMessages(); } BtMessageHandle DefaultBtInteractive::receiveHandshake(bool quickReply) { SharedHandle<BtHandshakeMessage> message = - _btMessageReceiver->receiveHandshake(quickReply); + btMessageReceiver_->receiveHandshake(quickReply); if(message.isNull()) { return SharedHandle<BtMessage>(); } @@ -119,46 +119,46 @@ BtMessageHandle DefaultBtInteractive::receiveHandshake(bool quickReply) { throw DL_ABORT_EX (StringFormat ("CUID#%s - Drop connection from the same Peer ID", - util::itos(_cuid).c_str()).str()); + util::itos(cuid_).c_str()).str()); } std::vector<SharedHandle<Peer> > activePeers; - _peerStorage->getActivePeers(activePeers); + peerStorage_->getActivePeers(activePeers); for(std::vector<SharedHandle<Peer> >::const_iterator i = activePeers.begin(), eoi = activePeers.end(); i != eoi; ++i) { if(memcmp((*i)->getPeerId(), message->getPeerId(), PEER_ID_LENGTH) == 0) { throw DL_ABORT_EX (StringFormat ("CUID#%s - Same Peer ID has been already seen.", - util::itos(_cuid).c_str()).str()); + util::itos(cuid_).c_str()).str()); } } - _peer->setPeerId(message->getPeerId()); + peer_->setPeerId(message->getPeerId()); if(message->isFastExtensionSupported()) { - _peer->setFastExtensionEnabled(true); - if(_logger->info()) { - _logger->info(MSG_FAST_EXTENSION_ENABLED, util::itos(_cuid).c_str()); + peer_->setFastExtensionEnabled(true); + if(logger_->info()) { + logger_->info(MSG_FAST_EXTENSION_ENABLED, util::itos(cuid_).c_str()); } } if(message->isExtendedMessagingEnabled()) { - _peer->setExtendedMessagingEnabled(true); - if(!_utPexEnabled) { - _extensionMessageRegistry->removeExtension("ut_pex"); + peer_->setExtendedMessagingEnabled(true); + if(!utPexEnabled_) { + extensionMessageRegistry_->removeExtension("ut_pex"); } - if(_logger->info()) { - _logger->info(MSG_EXTENDED_MESSAGING_ENABLED, util::itos(_cuid).c_str()); + if(logger_->info()) { + logger_->info(MSG_EXTENDED_MESSAGING_ENABLED, util::itos(cuid_).c_str()); } } if(message->isDHTEnabled()) { - _peer->setDHTEnabled(true); - if(_logger->info()) { - _logger->info(MSG_DHT_ENABLED_PEER, util::itos(_cuid).c_str()); + peer_->setDHTEnabled(true); + if(logger_->info()) { + logger_->info(MSG_DHT_ENABLED_PEER, util::itos(cuid_).c_str()); } } - if(_logger->info()) { - _logger->info(MSG_RECEIVE_PEER_MESSAGE, util::itos(_cuid).c_str(), - _peer->getIPAddress().c_str(), _peer->getPort(), + if(logger_->info()) { + logger_->info(MSG_RECEIVE_PEER_MESSAGE, util::itos(cuid_).c_str(), + peer_->getIPAddress().c_str(), peer_->getPort(), message->toString().c_str()); } return message; @@ -170,20 +170,20 @@ BtMessageHandle DefaultBtInteractive::receiveAndSendHandshake() { void DefaultBtInteractive::doPostHandshakeProcessing() { // Set time 0 to haveTimer to cache http/ftp download piece completion - _haveTimer.reset(0); - _keepAliveTimer = global::wallclock; - _floodingTimer = global::wallclock; - _pexTimer.reset(0); - if(_peer->isExtendedMessagingEnabled()) { + haveTimer_.reset(0); + keepAliveTimer_ = global::wallclock; + floodingTimer_ = global::wallclock; + pexTimer_.reset(0); + if(peer_->isExtendedMessagingEnabled()) { addHandshakeExtendedMessageToQueue(); } - if(!_metadataGetMode) { + if(!metadataGetMode_) { addBitfieldMessageToQueue(); } - if(_peer->isDHTEnabled() && _dhtEnabled) { + if(peer_->isDHTEnabled() && dhtEnabled_) { addPortMessageToQueue(); } - if(!_metadataGetMode) { + if(!metadataGetMode_) { addAllowedFastMessageToQueue(); } sendPendingMessage(); @@ -191,8 +191,8 @@ void DefaultBtInteractive::doPostHandshakeProcessing() { void DefaultBtInteractive::addPortMessageToQueue() { - _dispatcher->addMessageToQueue - (_messageFactory->createPortMessage(_localNode->getPort())); + dispatcher_->addMessageToQueue + (messageFactory_->createPortMessage(localNode_->getPort())); } void DefaultBtInteractive::addHandshakeExtendedMessageToQueue() @@ -200,174 +200,174 @@ void DefaultBtInteractive::addHandshakeExtendedMessageToQueue() static const std::string CLIENT_ARIA2("aria2/"PACKAGE_VERSION); HandshakeExtensionMessageHandle m(new HandshakeExtensionMessage()); m->setClientVersion(CLIENT_ARIA2); - m->setTCPPort(_btRuntime->getListenPort()); - m->setExtensions(_extensionMessageRegistry->getExtensions()); + m->setTCPPort(btRuntime_->getListenPort()); + m->setExtensions(extensionMessageRegistry_->getExtensions()); SharedHandle<TorrentAttribute> attrs = - bittorrent::getTorrentAttrs(_downloadContext); + bittorrent::getTorrentAttrs(downloadContext_); if(!attrs->metadata.empty()) { m->setMetadataSize(attrs->metadataSize); } - SharedHandle<BtMessage> msg = _messageFactory->createBtExtendedMessage(m); - _dispatcher->addMessageToQueue(msg); + SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m); + dispatcher_->addMessageToQueue(msg); } void DefaultBtInteractive::addBitfieldMessageToQueue() { - if(_peer->isFastExtensionEnabled()) { - if(_pieceStorage->allDownloadFinished()) { - _dispatcher->addMessageToQueue(_messageFactory->createHaveAllMessage()); - } else if(_pieceStorage->getCompletedLength() > 0) { - _dispatcher->addMessageToQueue(_messageFactory->createBitfieldMessage()); + if(peer_->isFastExtensionEnabled()) { + if(pieceStorage_->allDownloadFinished()) { + dispatcher_->addMessageToQueue(messageFactory_->createHaveAllMessage()); + } else if(pieceStorage_->getCompletedLength() > 0) { + dispatcher_->addMessageToQueue(messageFactory_->createBitfieldMessage()); } else { - _dispatcher->addMessageToQueue(_messageFactory->createHaveNoneMessage()); + dispatcher_->addMessageToQueue(messageFactory_->createHaveNoneMessage()); } } else { - if(_pieceStorage->getCompletedLength() > 0) { - _dispatcher->addMessageToQueue(_messageFactory->createBitfieldMessage()); + if(pieceStorage_->getCompletedLength() > 0) { + dispatcher_->addMessageToQueue(messageFactory_->createBitfieldMessage()); } } } void DefaultBtInteractive::addAllowedFastMessageToQueue() { - if(_peer->isFastExtensionEnabled()) { + if(peer_->isFastExtensionEnabled()) { std::vector<size_t> fastSet; - bittorrent::computeFastSet(fastSet, _peer->getIPAddress(), - _downloadContext->getNumPieces(), - bittorrent::getInfoHash(_downloadContext), - _allowedFastSetSize); + bittorrent::computeFastSet(fastSet, peer_->getIPAddress(), + downloadContext_->getNumPieces(), + bittorrent::getInfoHash(downloadContext_), + allowedFastSetSize_); for(std::vector<size_t>::const_iterator itr = fastSet.begin(), eoi = fastSet.end(); itr != eoi; ++itr) { - _dispatcher->addMessageToQueue - (_messageFactory->createAllowedFastMessage(*itr)); + dispatcher_->addMessageToQueue + (messageFactory_->createAllowedFastMessage(*itr)); } } } void DefaultBtInteractive::decideChoking() { - if(_peer->shouldBeChoking()) { - if(!_peer->amChoking()) { - _dispatcher->addMessageToQueue(_messageFactory->createChokeMessage()); + if(peer_->shouldBeChoking()) { + if(!peer_->amChoking()) { + dispatcher_->addMessageToQueue(messageFactory_->createChokeMessage()); } } else { - if(_peer->amChoking()) { - _dispatcher->addMessageToQueue(_messageFactory->createUnchokeMessage()); + if(peer_->amChoking()) { + dispatcher_->addMessageToQueue(messageFactory_->createUnchokeMessage()); } } } void DefaultBtInteractive::checkHave() { std::vector<size_t> indexes; - _pieceStorage->getAdvertisedPieceIndexes(indexes, _cuid, _haveTimer); - _haveTimer = global::wallclock; + pieceStorage_->getAdvertisedPieceIndexes(indexes, cuid_, haveTimer_); + haveTimer_ = global::wallclock; if(indexes.size() >= 20) { - if(_peer->isFastExtensionEnabled() && - _pieceStorage->allDownloadFinished()) { - _dispatcher->addMessageToQueue(_messageFactory->createHaveAllMessage()); + if(peer_->isFastExtensionEnabled() && + pieceStorage_->allDownloadFinished()) { + dispatcher_->addMessageToQueue(messageFactory_->createHaveAllMessage()); } else { - _dispatcher->addMessageToQueue(_messageFactory->createBitfieldMessage()); + dispatcher_->addMessageToQueue(messageFactory_->createBitfieldMessage()); } } else { for(std::vector<size_t>::const_iterator itr = indexes.begin(), eoi = indexes.end(); itr != eoi; ++itr) { - _dispatcher->addMessageToQueue(_messageFactory->createHaveMessage(*itr)); + dispatcher_->addMessageToQueue(messageFactory_->createHaveMessage(*itr)); } } } void DefaultBtInteractive::sendKeepAlive() { - if(_keepAliveTimer.difference(global::wallclock) >= _keepAliveInterval) { - _dispatcher->addMessageToQueue(_messageFactory->createKeepAliveMessage()); - _dispatcher->sendMessages(); - _keepAliveTimer = global::wallclock; + if(keepAliveTimer_.difference(global::wallclock) >= keepAliveInterval_) { + dispatcher_->addMessageToQueue(messageFactory_->createKeepAliveMessage()); + dispatcher_->sendMessages(); + keepAliveTimer_ = global::wallclock; } } size_t DefaultBtInteractive::receiveMessages() { - size_t countOldOutstandingRequest = _dispatcher->countOutstandingRequest(); + size_t countOldOutstandingRequest = dispatcher_->countOutstandingRequest(); size_t msgcount = 0; for(int i = 0; i < 50; ++i) { - if(_requestGroupMan->doesOverallDownloadSpeedExceed() || - _downloadContext->getOwnerRequestGroup()->doesDownloadSpeedExceed()) { + if(requestGroupMan_->doesOverallDownloadSpeedExceed() || + downloadContext_->getOwnerRequestGroup()->doesDownloadSpeedExceed()) { break; } - BtMessageHandle message = _btMessageReceiver->receiveMessage(); + BtMessageHandle message = btMessageReceiver_->receiveMessage(); if(message.isNull()) { break; } ++msgcount; - if(_logger->info()) { - _logger->info(MSG_RECEIVE_PEER_MESSAGE, util::itos(_cuid).c_str(), - _peer->getIPAddress().c_str(), _peer->getPort(), + if(logger_->info()) { + logger_->info(MSG_RECEIVE_PEER_MESSAGE, util::itos(cuid_).c_str(), + peer_->getIPAddress().c_str(), peer_->getPort(), message->toString().c_str()); } message->doReceivedAction(); switch(message->getId()) { case BtKeepAliveMessage::ID: - _floodingStat.incKeepAliveCount(); + floodingStat_.incKeepAliveCount(); break; case BtChokeMessage::ID: - if(!_peer->peerChoking()) { - _floodingStat.incChokeUnchokeCount(); + if(!peer_->peerChoking()) { + floodingStat_.incChokeUnchokeCount(); } break; case BtUnchokeMessage::ID: - if(_peer->peerChoking()) { - _floodingStat.incChokeUnchokeCount(); + if(peer_->peerChoking()) { + floodingStat_.incChokeUnchokeCount(); } break; case BtPieceMessage::ID: - _peerStorage->updateTransferStatFor(_peer); + peerStorage_->updateTransferStatFor(peer_); // pass through case BtRequestMessage::ID: - _inactiveTimer = global::wallclock; + inactiveTimer_ = global::wallclock; break; } } if(countOldOutstandingRequest > 0 && - _dispatcher->countOutstandingRequest() == 0){ - _maxOutstandingRequest = std::min((size_t)UB_MAX_OUTSTANDING_REQUEST, - _maxOutstandingRequest*2); + dispatcher_->countOutstandingRequest() == 0){ + maxOutstandingRequest_ = std::min((size_t)UB_MAX_OUTSTANDING_REQUEST, + maxOutstandingRequest_*2); } return msgcount; } void DefaultBtInteractive::decideInterest() { - if(_pieceStorage->hasMissingPiece(_peer)) { - if(!_peer->amInterested()) { - if(_logger->debug()) { - _logger->debug(MSG_PEER_INTERESTED, util::itos(_cuid).c_str()); + if(pieceStorage_->hasMissingPiece(peer_)) { + if(!peer_->amInterested()) { + if(logger_->debug()) { + logger_->debug(MSG_PEER_INTERESTED, util::itos(cuid_).c_str()); } - _dispatcher-> - addMessageToQueue(_messageFactory->createInterestedMessage()); + dispatcher_-> + addMessageToQueue(messageFactory_->createInterestedMessage()); } } else { - if(_peer->amInterested()) { - if(_logger->debug()) { - _logger->debug(MSG_PEER_NOT_INTERESTED, util::itos(_cuid).c_str()); + if(peer_->amInterested()) { + if(logger_->debug()) { + logger_->debug(MSG_PEER_NOT_INTERESTED, util::itos(cuid_).c_str()); } - _dispatcher-> - addMessageToQueue(_messageFactory->createNotInterestedMessage()); + dispatcher_-> + addMessageToQueue(messageFactory_->createNotInterestedMessage()); } } } void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) { - if(_pieceStorage->hasMissingPiece(_peer)) { + if(pieceStorage_->hasMissingPiece(peer_)) { - size_t numMissingBlock = _btRequestFactory->countMissingBlock(); + size_t numMissingBlock = btRequestFactory_->countMissingBlock(); - if(_peer->peerChoking()) { - if(_peer->isFastExtensionEnabled()) { + if(peer_->peerChoking()) { + if(peer_->isFastExtensionEnabled()) { std::vector<size_t> excludedIndexes; - excludedIndexes.reserve(_btRequestFactory->countTargetPiece()); - _btRequestFactory->getTargetPieceIndexes(excludedIndexes); + excludedIndexes.reserve(btRequestFactory_->countTargetPiece()); + btRequestFactory_->getTargetPieceIndexes(excludedIndexes); while(numMissingBlock < maxMissingBlock) { SharedHandle<Piece> piece = - _pieceStorage->getMissingFastPiece(_peer, excludedIndexes); + pieceStorage_->getMissingFastPiece(peer_, excludedIndexes); if(piece.isNull()) { break; } else { - _btRequestFactory->addTargetPiece(piece); + btRequestFactory_->addTargetPiece(piece); numMissingBlock += piece->countMissingBlock(); excludedIndexes.push_back(piece->getIndex()); } @@ -375,15 +375,15 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) { } } else { std::vector<size_t> excludedIndexes; - excludedIndexes.reserve(_btRequestFactory->countTargetPiece()); - _btRequestFactory->getTargetPieceIndexes(excludedIndexes); + excludedIndexes.reserve(btRequestFactory_->countTargetPiece()); + btRequestFactory_->getTargetPieceIndexes(excludedIndexes); while(numMissingBlock < maxMissingBlock) { SharedHandle<Piece> piece = - _pieceStorage->getMissingPiece(_peer, excludedIndexes); + pieceStorage_->getMissingPiece(peer_, excludedIndexes); if(piece.isNull()) { break; } else { - _btRequestFactory->addTargetPiece(piece); + btRequestFactory_->addTargetPiece(piece); numMissingBlock += piece->countMissingBlock(); excludedIndexes.push_back(piece->getIndex()); } @@ -393,63 +393,63 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) { } void DefaultBtInteractive::addRequests() { - fillPiece(_maxOutstandingRequest); + fillPiece(maxOutstandingRequest_); size_t reqNumToCreate = - _maxOutstandingRequest <= _dispatcher->countOutstandingRequest() ? - 0 : _maxOutstandingRequest-_dispatcher->countOutstandingRequest(); + maxOutstandingRequest_ <= dispatcher_->countOutstandingRequest() ? + 0 : maxOutstandingRequest_-dispatcher_->countOutstandingRequest(); if(reqNumToCreate > 0) { std::vector<SharedHandle<BtMessage> > requests; requests.reserve(reqNumToCreate); - if(_pieceStorage->isEndGame()) { - _btRequestFactory->createRequestMessagesOnEndGame(requests,reqNumToCreate); + if(pieceStorage_->isEndGame()) { + btRequestFactory_->createRequestMessagesOnEndGame(requests,reqNumToCreate); } else { - _btRequestFactory->createRequestMessages(requests, reqNumToCreate); + btRequestFactory_->createRequestMessages(requests, reqNumToCreate); } - _dispatcher->addMessageToQueue(requests); + dispatcher_->addMessageToQueue(requests); } } void DefaultBtInteractive::cancelAllPiece() { - _btRequestFactory->removeAllTargetPiece(); - if(_metadataGetMode && _downloadContext->getTotalLength() > 0) { + btRequestFactory_->removeAllTargetPiece(); + if(metadataGetMode_ && downloadContext_->getTotalLength() > 0) { std::vector<size_t> metadataRequests = - _utMetadataRequestTracker->getAllTrackedIndex(); + utMetadataRequestTracker_->getAllTrackedIndex(); for(std::vector<size_t>::const_iterator i = metadataRequests.begin(), eoi = metadataRequests.end(); i != eoi; ++i) { - if(_logger->debug()) { - _logger->debug("Cancel metadata: piece=%lu", + if(logger_->debug()) { + logger_->debug("Cancel metadata: piece=%lu", static_cast<unsigned long>(*i)); } - _pieceStorage->cancelPiece(_pieceStorage->getPiece(*i)); + pieceStorage_->cancelPiece(pieceStorage_->getPiece(*i)); } } } void DefaultBtInteractive::sendPendingMessage() { - _dispatcher->sendMessages(); + dispatcher_->sendMessages(); } void DefaultBtInteractive::detectMessageFlooding() { - if(_floodingTimer. + if(floodingTimer_. difference(global::wallclock) >= FLOODING_CHECK_INTERVAL) { - if(_floodingStat.getChokeUnchokeCount() >= 2 || - _floodingStat.getKeepAliveCount() >= 2) { + if(floodingStat_.getChokeUnchokeCount() >= 2 || + floodingStat_.getKeepAliveCount() >= 2) { throw DL_ABORT_EX(EX_FLOODING_DETECTED); } else { - _floodingStat.reset(); + floodingStat_.reset(); } - _floodingTimer = global::wallclock; + floodingTimer_ = global::wallclock; } } void DefaultBtInteractive::checkActiveInteraction() { - time_t inactiveTime = _inactiveTimer.difference(global::wallclock); + time_t inactiveTime = inactiveTimer_.difference(global::wallclock); // To allow aria2 to accept mutially interested peer, disconnect unintersted // peer. { const time_t interval = 30; - if(!_peer->amInterested() && !_peer->peerInterested() && + if(!peer_->amInterested() && !peer_->peerInterested() && inactiveTime >= interval) { // TODO change the message throw DL_ABORT_EX @@ -471,16 +471,16 @@ void DefaultBtInteractive::checkActiveInteraction() void DefaultBtInteractive::addPeerExchangeMessage() { - if(_pexTimer. + if(pexTimer_. difference(global::wallclock) >= UTPexExtensionMessage::DEFAULT_INTERVAL) { UTPexExtensionMessageHandle m - (new UTPexExtensionMessage(_peer->getExtensionMessageID("ut_pex"))); - const std::deque<SharedHandle<Peer> >& peers = _peerStorage->getPeers(); + (new UTPexExtensionMessage(peer_->getExtensionMessageID("ut_pex"))); + const std::deque<SharedHandle<Peer> >& peers = peerStorage_->getPeers(); { for(std::deque<SharedHandle<Peer> >::const_iterator i = peers.begin(), eoi = peers.end(); i != eoi && !m->freshPeersAreFull(); ++i) { - if(_peer->getIPAddress() != (*i)->getIPAddress()) { + if(peer_->getIPAddress() != (*i)->getIPAddress()) { m->addFreshPeer(*i); } } @@ -490,46 +490,46 @@ void DefaultBtInteractive::addPeerExchangeMessage() peers.rbegin(), eoi = peers.rend(); i != eoi && !m->droppedPeersAreFull(); ++i) { - if(_peer->getIPAddress() != (*i)->getIPAddress()) { + if(peer_->getIPAddress() != (*i)->getIPAddress()) { m->addDroppedPeer(*i); } } } - BtMessageHandle msg = _messageFactory->createBtExtendedMessage(m); - _dispatcher->addMessageToQueue(msg); - _pexTimer = global::wallclock; + BtMessageHandle msg = messageFactory_->createBtExtendedMessage(m); + dispatcher_->addMessageToQueue(msg); + pexTimer_ = global::wallclock; } } void DefaultBtInteractive::doInteractionProcessing() { - if(_metadataGetMode) { + if(metadataGetMode_) { sendKeepAlive(); - _numReceivedMessage = receiveMessages(); + numReceivedMessage_ = receiveMessages(); // PieceStorage is re-initialized with metadata_size in // HandshakeExtensionMessage::doReceivedAction(). - _pieceStorage = - _downloadContext->getOwnerRequestGroup()->getPieceStorage(); - if(_peer->getExtensionMessageID("ut_metadata") && - _downloadContext->getTotalLength() > 0) { - size_t num = _utMetadataRequestTracker->avail(); + pieceStorage_ = + downloadContext_->getOwnerRequestGroup()->getPieceStorage(); + if(peer_->getExtensionMessageID("ut_metadata") && + downloadContext_->getTotalLength() > 0) { + size_t num = utMetadataRequestTracker_->avail(); if(num > 0) { std::vector<SharedHandle<BtMessage> > requests; - _utMetadataRequestFactory->create(requests, num, _pieceStorage); - _dispatcher->addMessageToQueue(requests); + utMetadataRequestFactory_->create(requests, num, pieceStorage_); + dispatcher_->addMessageToQueue(requests); } - if(_perSecTimer.difference(global::wallclock) >= 1) { - _perSecTimer = global::wallclock; + if(perSecTimer_.difference(global::wallclock) >= 1) { + perSecTimer_ = global::wallclock; // Drop timeout request after queuing message to give a chance // to other connection to request piece. std::vector<size_t> indexes = - _utMetadataRequestTracker->removeTimeoutEntry(); + utMetadataRequestTracker_->removeTimeoutEntry(); for(std::vector<size_t>::const_iterator i = indexes.begin(), eoi = indexes.end(); i != eoi; ++i) { - _pieceStorage->cancelPiece(_pieceStorage->getPiece(*i)); + pieceStorage_->cancelPiece(pieceStorage_->getPiece(*i)); } } - if(_pieceStorage->downloadFinished()) { - _downloadContext->getOwnerRequestGroup()->setForceHaltRequested + if(pieceStorage_->downloadFinished()) { + downloadContext_->getOwnerRequestGroup()->setForceHaltRequested (true, RequestGroup::NONE); } } @@ -537,20 +537,20 @@ void DefaultBtInteractive::doInteractionProcessing() { checkActiveInteraction(); decideChoking(); detectMessageFlooding(); - if(_perSecTimer.difference(global::wallclock) >= 1) { - _perSecTimer = global::wallclock; - _dispatcher->checkRequestSlotAndDoNecessaryThing(); + if(perSecTimer_.difference(global::wallclock) >= 1) { + perSecTimer_ = global::wallclock; + dispatcher_->checkRequestSlotAndDoNecessaryThing(); } checkHave(); sendKeepAlive(); - _numReceivedMessage = receiveMessages(); - _btRequestFactory->removeCompletedPiece(); + numReceivedMessage_ = receiveMessages(); + btRequestFactory_->removeCompletedPiece(); decideInterest(); - if(!_pieceStorage->downloadFinished()) { + if(!pieceStorage_->downloadFinished()) { addRequests(); } } - if(_peer->getExtensionMessageID("ut_pex") && _utPexEnabled) { + if(peer_->getExtensionMessageID("ut_pex") && utPexEnabled_) { addPeerExchangeMessage(); } @@ -559,96 +559,96 @@ void DefaultBtInteractive::doInteractionProcessing() { void DefaultBtInteractive::setLocalNode(const WeakHandle<DHTNode>& node) { - _localNode = node; + localNode_ = node; } size_t DefaultBtInteractive::countPendingMessage() { - return _dispatcher->countMessageInQueue(); + return dispatcher_->countMessageInQueue(); } bool DefaultBtInteractive::isSendingMessageInProgress() { - return _dispatcher->isSendingInProgress(); + return dispatcher_->isSendingInProgress(); } size_t DefaultBtInteractive::countReceivedMessageInIteration() const { - return _numReceivedMessage; + return numReceivedMessage_; } size_t DefaultBtInteractive::countOutstandingRequest() { - if(_metadataGetMode) { - return _utMetadataRequestTracker->count(); + if(metadataGetMode_) { + return utMetadataRequestTracker_->count(); } else { - return _dispatcher->countOutstandingRequest(); + return dispatcher_->countOutstandingRequest(); } } void DefaultBtInteractive::setBtRuntime (const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void DefaultBtInteractive::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void DefaultBtInteractive::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void DefaultBtInteractive::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } void DefaultBtInteractive::setBtMessageReceiver (const SharedHandle<BtMessageReceiver>& receiver) { - _btMessageReceiver = receiver; + btMessageReceiver_ = receiver; } void DefaultBtInteractive::setDispatcher (const SharedHandle<BtMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DefaultBtInteractive::setBtRequestFactory (const SharedHandle<BtRequestFactory>& factory) { - _btRequestFactory = factory; + btRequestFactory_ = factory; } void DefaultBtInteractive::setPeerConnection (const SharedHandle<PeerConnection>& peerConnection) { - _peerConnection = peerConnection; + peerConnection_ = peerConnection; } void DefaultBtInteractive::setExtensionMessageFactory (const SharedHandle<ExtensionMessageFactory>& factory) { - _extensionMessageFactory = factory; + extensionMessageFactory_ = factory; } void DefaultBtInteractive::setBtMessageFactory (const SharedHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } void DefaultBtInteractive::setRequestGroupMan (const WeakHandle<RequestGroupMan>& rgman) { - _requestGroupMan = rgman; + requestGroupMan_ = rgman; } } // namespace aria2 diff --git a/src/DefaultBtInteractive.h b/src/DefaultBtInteractive.h index 7d982dc8..b8635f9b 100644 --- a/src/DefaultBtInteractive.h +++ b/src/DefaultBtInteractive.h @@ -98,52 +98,52 @@ public: class DefaultBtInteractive : public BtInteractive { private: - cuid_t _cuid; + cuid_t cuid_; - SharedHandle<DownloadContext> _downloadContext; + SharedHandle<DownloadContext> downloadContext_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; - SharedHandle<BtMessageReceiver> _btMessageReceiver; - SharedHandle<BtMessageDispatcher> _dispatcher; - SharedHandle<BtRequestFactory> _btRequestFactory; - // Although _peerStorage is not used in this class, this object - // holds the reference so that _peerConnection is not deleted. - SharedHandle<PeerConnection> _peerConnection; - SharedHandle<BtMessageFactory> _messageFactory; - SharedHandle<ExtensionMessageFactory> _extensionMessageFactory; - SharedHandle<ExtensionMessageRegistry> _extensionMessageRegistry; - SharedHandle<UTMetadataRequestFactory> _utMetadataRequestFactory; - SharedHandle<UTMetadataRequestTracker> _utMetadataRequestTracker; + SharedHandle<BtMessageReceiver> btMessageReceiver_; + SharedHandle<BtMessageDispatcher> dispatcher_; + SharedHandle<BtRequestFactory> btRequestFactory_; + // Although peerStorage_ is not used in this class, this object + // holds the reference so that peerConnection_ is not deleted. + SharedHandle<PeerConnection> peerConnection_; + SharedHandle<BtMessageFactory> messageFactory_; + SharedHandle<ExtensionMessageFactory> extensionMessageFactory_; + SharedHandle<ExtensionMessageRegistry> extensionMessageRegistry_; + SharedHandle<UTMetadataRequestFactory> utMetadataRequestFactory_; + SharedHandle<UTMetadataRequestTracker> utMetadataRequestTracker_; - bool _metadataGetMode; + bool metadataGetMode_; - WeakHandle<DHTNode> _localNode; + WeakHandle<DHTNode> localNode_; - Logger* _logger; - size_t _allowedFastSetSize; - Timer _haveTimer; - Timer _keepAliveTimer; - Timer _floodingTimer; - FloodingStat _floodingStat; - Timer _inactiveTimer; - Timer _pexTimer; - Timer _perSecTimer; - time_t _keepAliveInterval; - bool _utPexEnabled; - bool _dhtEnabled; + Logger* logger_; + size_t allowedFastSetSize_; + Timer haveTimer_; + Timer keepAliveTimer_; + Timer floodingTimer_; + FloodingStat floodingStat_; + Timer inactiveTimer_; + Timer pexTimer_; + Timer perSecTimer_; + time_t keepAliveInterval_; + bool utPexEnabled_; + bool dhtEnabled_; - size_t _numReceivedMessage; + size_t numReceivedMessage_; - size_t _maxOutstandingRequest; + size_t maxOutstandingRequest_; - WeakHandle<RequestGroupMan> _requestGroupMan; + WeakHandle<RequestGroupMan> requestGroupMan_; static const time_t FLOODING_CHECK_INTERVAL = 5; @@ -193,7 +193,7 @@ public: void setCuid(cuid_t cuid) { - _cuid = cuid; + cuid_ = cuid; } void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime); @@ -220,23 +220,23 @@ public: void setExtensionMessageRegistry (const SharedHandle<ExtensionMessageRegistry>& registry) { - _extensionMessageRegistry = registry; + extensionMessageRegistry_ = registry; } void setKeepAliveInterval(time_t keepAliveInterval) { - _keepAliveInterval = keepAliveInterval; + keepAliveInterval_ = keepAliveInterval; } void setUTPexEnabled(bool f) { - _utPexEnabled = f; + utPexEnabled_ = f; } void setLocalNode(const WeakHandle<DHTNode>& node); void setDHTEnabled(bool f) { - _dhtEnabled = f; + dhtEnabled_ = f; } void setRequestGroupMan(const WeakHandle<RequestGroupMan>& rgman); @@ -244,18 +244,18 @@ public: void setUTMetadataRequestTracker (const SharedHandle<UTMetadataRequestTracker>& tracker) { - _utMetadataRequestTracker = tracker; + utMetadataRequestTracker_ = tracker; } void setUTMetadataRequestFactory (const SharedHandle<UTMetadataRequestFactory>& factory) { - _utMetadataRequestFactory = factory; + utMetadataRequestFactory_ = factory; } void enableMetadataGetMode() { - _metadataGetMode = true; + metadataGetMode_ = true; } }; diff --git a/src/DefaultBtMessageDispatcher.cc b/src/DefaultBtMessageDispatcher.cc index 3d21aa58..3d01f668 100644 --- a/src/DefaultBtMessageDispatcher.cc +++ b/src/DefaultBtMessageDispatcher.cc @@ -60,13 +60,13 @@ namespace aria2 { DefaultBtMessageDispatcher::DefaultBtMessageDispatcher(): cuid(0), - _requestTimeout(0), - _logger(LogFactory::getInstance()) {} + requestTimeout_(0), + logger_(LogFactory::getInstance()) {} DefaultBtMessageDispatcher::~DefaultBtMessageDispatcher() { - if(_logger->debug()) { - _logger->debug("DefaultBtMessageDispatcher::deleted"); + if(logger_->debug()) { + logger_->debug("DefaultBtMessageDispatcher::deleted"); } } @@ -74,7 +74,7 @@ void DefaultBtMessageDispatcher::addMessageToQueue (const BtMessageHandle& btMessage) { btMessage->onQueued(); - _messageQueue.push_back(btMessage); + messageQueue_.push_back(btMessage); } void DefaultBtMessageDispatcher::addMessageToQueue @@ -88,33 +88,33 @@ void DefaultBtMessageDispatcher::addMessageToQueue void DefaultBtMessageDispatcher::sendMessages() { std::vector<SharedHandle<BtMessage> > tempQueue; - while(!_messageQueue.empty()) { - BtMessageHandle msg = _messageQueue.front(); - _messageQueue.pop_front(); + while(!messageQueue_.empty()) { + BtMessageHandle msg = messageQueue_.front(); + messageQueue_.pop_front(); if(msg->isUploading() && !msg->isSendingInProgress()) { - if(_requestGroupMan->doesOverallUploadSpeedExceed() || - _downloadContext->getOwnerRequestGroup()->doesUploadSpeedExceed()) { + if(requestGroupMan_->doesOverallUploadSpeedExceed() || + downloadContext_->getOwnerRequestGroup()->doesUploadSpeedExceed()) { tempQueue.push_back(msg); continue; } } msg->send(); if(msg->isUploading()) { - _peerStorage->updateTransferStatFor(_peer); + peerStorage_->updateTransferStatFor(peer_); } if(msg->isSendingInProgress()) { - _messageQueue.push_front(msg); + messageQueue_.push_front(msg); break; } } if(!tempQueue.empty()) { // Insert pending message to the front, so that message is likely sent in // the same order as it is queued. - if(!_messageQueue.empty() && _messageQueue.front()->isSendingInProgress()) { - _messageQueue.insert(_messageQueue.begin()+1, + if(!messageQueue_.empty() && messageQueue_.front()->isSendingInProgress()) { + messageQueue_.insert(messageQueue_.begin()+1, tempQueue.begin(), tempQueue.end()); } else { - _messageQueue.insert(_messageQueue.begin(), + messageQueue_.insert(messageQueue_.begin(), tempQueue.begin(), tempQueue.end()); } } @@ -127,7 +127,7 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction BtCancelSendingPieceEvent event(index, begin, length); std::vector<SharedHandle<BtMessage> > tempQueue - (_messageQueue.begin(), _messageQueue.end()); + (messageQueue_.begin(), messageQueue_.end()); forEachMemFunSH(tempQueue.begin(), tempQueue.end(), &BtMessage::onCancelSendingPieceEvent, event); @@ -142,25 +142,25 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction class AbortOutstandingRequest { private: - SharedHandle<Piece> _piece; - cuid_t _cuid; - Logger* _logger; + SharedHandle<Piece> piece_; + cuid_t cuid_; + Logger* logger_; public: AbortOutstandingRequest(const SharedHandle<Piece>& piece, cuid_t cuid): - _piece(piece), - _cuid(cuid), - _logger(LogFactory::getInstance()) {} + piece_(piece), + cuid_(cuid), + logger_(LogFactory::getInstance()) {} void operator()(const RequestSlot& slot) const { - if(_logger->debug()) { - _logger->debug(MSG_DELETING_REQUEST_SLOT, - util::itos(_cuid).c_str(), + if(logger_->debug()) { + logger_->debug(MSG_DELETING_REQUEST_SLOT, + util::itos(cuid_).c_str(), slot.getIndex(), slot.getBlockIndex()); - _logger->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); + logger_->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); } - _piece->cancelBlock(slot.getBlockIndex()); + piece_->cancelBlock(slot.getBlockIndex()); } }; @@ -169,49 +169,49 @@ void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction (const SharedHandle<Piece>& piece) { RequestSlot rs(piece->getIndex(), 0, 0, 0); std::deque<RequestSlot>::iterator first = - std::lower_bound(_requestSlots.begin(), _requestSlots.end(), rs); + std::lower_bound(requestSlots_.begin(), requestSlots_.end(), rs); rs.setIndex(piece->getIndex()+1); std::deque<RequestSlot>::iterator last = - std::lower_bound(_requestSlots.begin(), _requestSlots.end(), rs); + std::lower_bound(requestSlots_.begin(), requestSlots_.end(), rs); std::for_each(first, last, AbortOutstandingRequest(piece, cuid)); - _requestSlots.erase(first, last); + requestSlots_.erase(first, last); BtAbortOutstandingRequestEvent event(piece); std::vector<SharedHandle<BtMessage> > tempQueue - (_messageQueue.begin(), _messageQueue.end()); + (messageQueue_.begin(), messageQueue_.end()); forEachMemFunSH(tempQueue.begin(), tempQueue.end(), &BtMessage::onAbortOutstandingRequestEvent, event); } class ProcessChokedRequestSlot { private: - cuid_t _cuid; - SharedHandle<Peer> _peer; - SharedHandle<PieceStorage> _pieceStorage; - Logger* _logger; + cuid_t cuid_; + SharedHandle<Peer> peer_; + SharedHandle<PieceStorage> pieceStorage_; + Logger* logger_; public: ProcessChokedRequestSlot(cuid_t cuid, const SharedHandle<Peer>& peer, const SharedHandle<PieceStorage>& pieceStorage): - _cuid(cuid), - _peer(peer), - _pieceStorage(pieceStorage), - _logger(LogFactory::getInstance()) {} + cuid_(cuid), + peer_(peer), + pieceStorage_(pieceStorage), + logger_(LogFactory::getInstance()) {} void operator()(const RequestSlot& slot) const { - if(!_peer->isInPeerAllowedIndexSet(slot.getIndex())) { - if(_logger->debug()) { - _logger->debug(MSG_DELETING_REQUEST_SLOT_CHOKED, - util::itos(_cuid).c_str(), + if(!peer_->isInPeerAllowedIndexSet(slot.getIndex())) { + if(logger_->debug()) { + logger_->debug(MSG_DELETING_REQUEST_SLOT_CHOKED, + util::itos(cuid_).c_str(), slot.getIndex(), slot.getBlockIndex()); - _logger->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); + logger_->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); } - SharedHandle<Piece> piece = _pieceStorage->getPiece(slot.getIndex()); + SharedHandle<Piece> piece = pieceStorage_->getPiece(slot.getIndex()); piece->cancelBlock(slot.getBlockIndex()); } } @@ -220,26 +220,26 @@ public: class FindChokedRequestSlot { private: - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; public: FindChokedRequestSlot(const SharedHandle<Peer>& peer): - _peer(peer) {} + peer_(peer) {} bool operator()(const RequestSlot& slot) const { - return !_peer->isInPeerAllowedIndexSet(slot.getIndex()); + return !peer_->isInPeerAllowedIndexSet(slot.getIndex()); } }; // localhost received choke message from the peer. void DefaultBtMessageDispatcher::doChokedAction() { - std::for_each(_requestSlots.begin(), _requestSlots.end(), - ProcessChokedRequestSlot(cuid, _peer, _pieceStorage)); + std::for_each(requestSlots_.begin(), requestSlots_.end(), + ProcessChokedRequestSlot(cuid, peer_, pieceStorage_)); - _requestSlots.erase(std::remove_if(_requestSlots.begin(), _requestSlots.end(), - FindChokedRequestSlot(_peer)), - _requestSlots.end()); + requestSlots_.erase(std::remove_if(requestSlots_.begin(), requestSlots_.end(), + FindChokedRequestSlot(peer_)), + requestSlots_.end()); } // localhost dispatched choke message to the peer. @@ -248,54 +248,54 @@ void DefaultBtMessageDispatcher::doChokingAction() BtChokingEvent event; std::vector<SharedHandle<BtMessage> > tempQueue - (_messageQueue.begin(), _messageQueue.end()); + (messageQueue_.begin(), messageQueue_.end()); forEachMemFunSH(tempQueue.begin(), tempQueue.end(), &BtMessage::onChokingEvent, event); } class ProcessStaleRequestSlot { private: - cuid_t _cuid; - SharedHandle<Peer> _peer; - SharedHandle<PieceStorage> _pieceStorage; - BtMessageDispatcher* _messageDispatcher; - WeakHandle<BtMessageFactory> _messageFactory; - time_t _requestTimeout; - Logger* _logger; + cuid_t cuid_; + SharedHandle<Peer> peer_; + SharedHandle<PieceStorage> pieceStorage_; + BtMessageDispatcher* messageDispatcher_; + WeakHandle<BtMessageFactory> messageFactory_; + time_t requestTimeout_; + Logger* logger_; public: ProcessStaleRequestSlot(cuid_t cuid, const SharedHandle<Peer>& peer, const SharedHandle<PieceStorage>& pieceStorage, BtMessageDispatcher* dispatcher, const WeakHandle<BtMessageFactory>& factory, time_t requestTimeout): - _cuid(cuid), - _peer(peer), - _pieceStorage(pieceStorage), - _messageDispatcher(dispatcher), - _messageFactory(factory), - _requestTimeout(requestTimeout), - _logger(LogFactory::getInstance()) {} + cuid_(cuid), + peer_(peer), + pieceStorage_(pieceStorage), + messageDispatcher_(dispatcher), + messageFactory_(factory), + requestTimeout_(requestTimeout), + logger_(LogFactory::getInstance()) {} void operator()(const RequestSlot& slot) { - if(slot.isTimeout(_requestTimeout)) { - if(_logger->debug()) { - _logger->debug(MSG_DELETING_REQUEST_SLOT_TIMEOUT, - util::itos(_cuid).c_str(), + if(slot.isTimeout(requestTimeout_)) { + if(logger_->debug()) { + logger_->debug(MSG_DELETING_REQUEST_SLOT_TIMEOUT, + util::itos(cuid_).c_str(), slot.getBlockIndex()); - _logger->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); + logger_->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); } slot.getPiece()->cancelBlock(slot.getBlockIndex()); - _peer->snubbing(true); + peer_->snubbing(true); } else if(slot.getPiece()->hasBlock(slot.getBlockIndex())) { - if(_logger->debug()) { - _logger->debug(MSG_DELETING_REQUEST_SLOT_ACQUIRED, - util::itos(_cuid).c_str(), + if(logger_->debug()) { + logger_->debug(MSG_DELETING_REQUEST_SLOT_ACQUIRED, + util::itos(cuid_).c_str(), slot.getBlockIndex()); - _logger->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); + logger_->debug("index=%d, begin=%d", slot.getIndex(), slot.getBegin()); } - _messageDispatcher->addMessageToQueue - (_messageFactory->createCancelMessage(slot.getIndex(), + messageDispatcher_->addMessageToQueue + (messageFactory_->createCancelMessage(slot.getIndex(), slot.getBegin(), slot.getLength())); } @@ -304,17 +304,17 @@ public: class FindStaleRequestSlot { private: - SharedHandle<PieceStorage> _pieceStorage; - time_t _requestTimeout; + SharedHandle<PieceStorage> pieceStorage_; + time_t requestTimeout_; public: FindStaleRequestSlot(const SharedHandle<PieceStorage>& pieceStorage, time_t requestTimeout): - _pieceStorage(pieceStorage), - _requestTimeout(requestTimeout) {} + pieceStorage_(pieceStorage), + requestTimeout_(requestTimeout) {} bool operator()(const RequestSlot& slot) { - if(slot.isTimeout(_requestTimeout)) { + if(slot.isTimeout(requestTimeout_)) { return true; } else { if(slot.getPiece()->hasBlock(slot.getBlockIndex())) { @@ -328,25 +328,25 @@ public: void DefaultBtMessageDispatcher::checkRequestSlotAndDoNecessaryThing() { - std::for_each(_requestSlots.begin(), _requestSlots.end(), + std::for_each(requestSlots_.begin(), requestSlots_.end(), ProcessStaleRequestSlot(cuid, - _peer, - _pieceStorage, + peer_, + pieceStorage_, this, - _messageFactory, - _requestTimeout)); - _requestSlots.erase(std::remove_if(_requestSlots.begin(), _requestSlots.end(), - FindStaleRequestSlot(_pieceStorage, - _requestTimeout)), - _requestSlots.end()); + messageFactory_, + requestTimeout_)); + requestSlots_.erase(std::remove_if(requestSlots_.begin(), requestSlots_.end(), + FindStaleRequestSlot(pieceStorage_, + requestTimeout_)), + requestSlots_.end()); } bool DefaultBtMessageDispatcher::isSendingInProgress() { - if(_messageQueue.empty()) { + if(messageQueue_.empty()) { return false; } else { - return _messageQueue.front()->isSendingInProgress(); + return messageQueue_.front()->isSendingInProgress(); } } @@ -367,9 +367,9 @@ bool DefaultBtMessageDispatcher::isOutstandingRequest RequestSlot rs(index, 0, 0, blockIndex); std::deque<RequestSlot>::iterator i = - std::lower_bound(_requestSlots.begin(), _requestSlots.end(), + std::lower_bound(requestSlots_.begin(), requestSlots_.end(), rs, BlockIndexLess()); - return i != _requestSlots.end() && + return i != requestSlots_.end() && (*i).getIndex() == index && (*i).getBlockIndex() == blockIndex; } @@ -380,8 +380,8 @@ DefaultBtMessageDispatcher::getOutstandingRequest RequestSlot ret; RequestSlot rs(index, begin, length, 0); std::deque<RequestSlot>::iterator i = - std::lower_bound(_requestSlots.begin(), _requestSlots.end(), rs); - if(i != _requestSlots.end() && (*i) == rs) { + std::lower_bound(requestSlots_.begin(), requestSlots_.end(), rs); + if(i != requestSlots_.end() && (*i) == rs) { ret = *i; } else { ret = RequestSlot::nullSlot; @@ -393,10 +393,10 @@ void DefaultBtMessageDispatcher::removeOutstandingRequest (const RequestSlot& slot) { std::deque<RequestSlot>::iterator i = - std::lower_bound(_requestSlots.begin(), _requestSlots.end(), slot); - if(i != _requestSlots.end() && (*i) == slot) { + std::lower_bound(requestSlots_.begin(), requestSlots_.end(), slot); + if(i != requestSlots_.end() && (*i) == slot) { AbortOutstandingRequest(slot.getPiece(), cuid)(*i); - _requestSlots.erase(i); + requestSlots_.erase(i); } } @@ -404,51 +404,51 @@ void DefaultBtMessageDispatcher::addOutstandingRequest (const RequestSlot& slot) { std::deque<RequestSlot>::iterator i = - std::lower_bound(_requestSlots.begin(), _requestSlots.end(), slot); - if(i == _requestSlots.end() || (*i) != slot) { - _requestSlots.insert(i, slot); + std::lower_bound(requestSlots_.begin(), requestSlots_.end(), slot); + if(i == requestSlots_.end() || (*i) != slot) { + requestSlots_.insert(i, slot); } } size_t DefaultBtMessageDispatcher::countOutstandingUpload() { - return std::count_if(_messageQueue.begin(), _messageQueue.end(), + return std::count_if(messageQueue_.begin(), messageQueue_.end(), mem_fun_sh(&BtMessage::isUploading)); } void DefaultBtMessageDispatcher::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } void DefaultBtMessageDispatcher::setDownloadContext (const SharedHandle<DownloadContext>& downloadContext) { - _downloadContext = downloadContext; + downloadContext_ = downloadContext; } void DefaultBtMessageDispatcher::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void DefaultBtMessageDispatcher::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void DefaultBtMessageDispatcher::setBtMessageFactory (const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } void DefaultBtMessageDispatcher::setRequestGroupMan (const WeakHandle<RequestGroupMan>& rgman) { - _requestGroupMan = rgman; + requestGroupMan_ = rgman; } } // namespace aria2 diff --git a/src/DefaultBtMessageDispatcher.h b/src/DefaultBtMessageDispatcher.h index 4dafe5c6..3df8df13 100644 --- a/src/DefaultBtMessageDispatcher.h +++ b/src/DefaultBtMessageDispatcher.h @@ -57,16 +57,16 @@ class RequestGroupMan; class DefaultBtMessageDispatcher : public BtMessageDispatcher { private: cuid_t cuid; - std::deque<SharedHandle<BtMessage> > _messageQueue; - std::deque<RequestSlot> _requestSlots; - SharedHandle<DownloadContext> _downloadContext; - SharedHandle<PeerStorage> _peerStorage; - SharedHandle<PieceStorage> _pieceStorage; - WeakHandle<BtMessageFactory> _messageFactory; - SharedHandle<Peer> _peer; - WeakHandle<RequestGroupMan> _requestGroupMan; - time_t _requestTimeout; - Logger* _logger; + std::deque<SharedHandle<BtMessage> > messageQueue_; + std::deque<RequestSlot> requestSlots_; + SharedHandle<DownloadContext> downloadContext_; + SharedHandle<PeerStorage> peerStorage_; + SharedHandle<PieceStorage> pieceStorage_; + WeakHandle<BtMessageFactory> messageFactory_; + SharedHandle<Peer> peer_; + WeakHandle<RequestGroupMan> requestGroupMan_; + time_t requestTimeout_; + Logger* logger_; public: DefaultBtMessageDispatcher(); @@ -94,12 +94,12 @@ public: virtual bool isSendingInProgress(); virtual size_t countMessageInQueue() { - return _messageQueue.size(); + return messageQueue_.size(); } virtual size_t countOutstandingRequest() { - return _requestSlots.size(); + return requestSlots_.size(); } virtual bool isOutstandingRequest(size_t index, size_t blockIndex); @@ -114,12 +114,12 @@ public: const std::deque<SharedHandle<BtMessage> >& getMessageQueue() const { - return _messageQueue; + return messageQueue_; } const std::deque<RequestSlot>& getRequestSlots() const { - return _requestSlots; + return requestSlots_; } void setPeer(const SharedHandle<Peer>& peer); @@ -140,7 +140,7 @@ public: } void setRequestTimeout(time_t requestTimeout) { - _requestTimeout = requestTimeout; + requestTimeout_ = requestTimeout; } }; diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc index 3a2713c7..88f3dbe4 100644 --- a/src/DefaultBtMessageFactory.cc +++ b/src/DefaultBtMessageFactory.cc @@ -70,9 +70,9 @@ namespace aria2 { -DefaultBtMessageFactory::DefaultBtMessageFactory():_cuid(0), - _dhtEnabled(false), - _metadataGetMode(false) +DefaultBtMessageFactory::DefaultBtMessageFactory():cuid_(0), + dhtEnabled_(false), + metadataGetMode_(false) {} DefaultBtMessageFactory::~DefaultBtMessageFactory() {} @@ -98,7 +98,7 @@ DefaultBtMessageFactory::createBtMessage { SharedHandle<BtInterestedMessage> m = BtInterestedMessage::create(data, dataLength); - m->setPeerStorage(_peerStorage); + m->setPeerStorage(peerStorage_); msg = m; } break; @@ -106,17 +106,17 @@ DefaultBtMessageFactory::createBtMessage { SharedHandle<BtNotInterestedMessage> m = BtNotInterestedMessage::create(data, dataLength); - m->setPeerStorage(_peerStorage); + m->setPeerStorage(peerStorage_); msg = m; } break; case BtHaveMessage::ID: msg = BtHaveMessage::create(data, dataLength); { - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> v (new IndexBtMessageValidator(static_cast<BtHaveMessage*>(msg.get()), - _downloadContext->getNumPieces())); + downloadContext_->getNumPieces())); msg->setBtMessageValidator(v); } } @@ -124,23 +124,23 @@ DefaultBtMessageFactory::createBtMessage case BtBitfieldMessage::ID: msg = BtBitfieldMessage::create(data, dataLength); { - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> v (new BtBitfieldMessageValidator (static_cast<BtBitfieldMessage*>(msg.get()), - _downloadContext->getNumPieces())); + downloadContext_->getNumPieces())); msg->setBtMessageValidator(v); } } break; case BtRequestMessage::ID: { BtRequestMessageHandle temp = BtRequestMessage::create(data, dataLength); - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> validator (new RangeBtMessageValidator (temp.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(temp->getIndex()))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(temp->getIndex()))); temp->setBtMessageValidator(validator); } msg = temp; @@ -148,12 +148,12 @@ DefaultBtMessageFactory::createBtMessage } case BtCancelMessage::ID: { BtCancelMessageHandle temp = BtCancelMessage::create(data, dataLength); - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> validator (new RangeBtMessageValidator (temp.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(temp->getIndex()))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(temp->getIndex()))); temp->setBtMessageValidator(validator); } msg = temp; @@ -161,15 +161,15 @@ DefaultBtMessageFactory::createBtMessage } case BtPieceMessage::ID: { BtPieceMessageHandle temp = BtPieceMessage::create(data, dataLength); - if(!_metadataGetMode) { + if(!metadataGetMode_) { BtMessageValidatorHandle validator (new BtPieceMessageValidator (temp.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(temp->getIndex()))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(temp->getIndex()))); temp->setBtMessageValidator(validator); } - temp->setDownloadContext(_downloadContext); + temp->setDownloadContext(downloadContext_); msg = temp; break; } @@ -181,12 +181,12 @@ DefaultBtMessageFactory::createBtMessage break; case BtRejectMessage::ID: { BtRejectMessageHandle temp = BtRejectMessage::create(data, dataLength); - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> validator (new RangeBtMessageValidator (temp.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(temp->getIndex()))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(temp->getIndex()))); temp->setBtMessageValidator(validator); } msg = temp; @@ -195,10 +195,10 @@ DefaultBtMessageFactory::createBtMessage case BtSuggestPieceMessage::ID: { BtSuggestPieceMessageHandle temp = BtSuggestPieceMessage::create(data, dataLength); - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> validator (new IndexBtMessageValidator(temp.get(), - _downloadContext->getNumPieces())); + downloadContext_->getNumPieces())); temp->setBtMessageValidator(validator); } msg = temp; @@ -207,10 +207,10 @@ DefaultBtMessageFactory::createBtMessage case BtAllowedFastMessage::ID: { BtAllowedFastMessageHandle temp = BtAllowedFastMessage::create(data, dataLength); - if(!_metadataGetMode) { + if(!metadataGetMode_) { SharedHandle<BtMessageValidator> validator (new IndexBtMessageValidator(temp.get(), - _downloadContext->getNumPieces())); + downloadContext_->getNumPieces())); temp->setBtMessageValidator(validator); } msg = temp; @@ -219,17 +219,17 @@ DefaultBtMessageFactory::createBtMessage case BtPortMessage::ID: { SharedHandle<BtPortMessage> temp = BtPortMessage::create(data, dataLength); - temp->setLocalNode(_localNode); - temp->setRoutingTable(_routingTable); - temp->setTaskQueue(_taskQueue); - temp->setTaskFactory(_taskFactory); + temp->setLocalNode(localNode_); + temp->setRoutingTable(routingTable_); + temp->setTaskQueue(taskQueue_); + temp->setTaskFactory(taskFactory_); msg = temp; break; } case BtExtendedMessage::ID: { - if(_peer->isExtendedMessagingEnabled()) { - msg = BtExtendedMessage::create(_extensionMessageFactory, - _peer, data, dataLength); + if(peer_->isExtendedMessagingEnabled()) { + msg = BtExtendedMessage::create(extensionMessageFactory_, + peer_, data, dataLength); } else { throw DL_ABORT_EX("Received extended message from peer during" " a session with extended messaging disabled."); @@ -246,14 +246,14 @@ DefaultBtMessageFactory::createBtMessage void DefaultBtMessageFactory::setCommonProperty (const AbstractBtMessageHandle& msg) { - msg->setCuid(_cuid); - msg->setPeer(_peer); - msg->setPieceStorage(_pieceStorage); - msg->setBtMessageDispatcher(_dispatcher); - msg->setBtRequestFactory(_requestFactory); + msg->setCuid(cuid_); + msg->setPeer(peer_); + msg->setPieceStorage(pieceStorage_); + msg->setBtMessageDispatcher(dispatcher_); + msg->setBtRequestFactory(requestFactory_); msg->setBtMessageFactory(WeakHandle<BtMessageFactory>(this)); - msg->setPeerConnection(_peerConnection); - if(_metadataGetMode) { + msg->setPeerConnection(peerConnection_); + if(metadataGetMode_) { msg->enableMetadataGetMode(); } } @@ -266,7 +266,7 @@ DefaultBtMessageFactory::createHandshakeMessage BtHandshakeMessage::create(data, dataLength); BtMessageValidatorHandle validator (new BtHandshakeMessageValidator - (msg.get(), bittorrent::getInfoHash(_downloadContext))); + (msg.get(), bittorrent::getInfoHash(downloadContext_))); msg->setBtMessageValidator(validator); setCommonProperty(msg); return msg; @@ -280,9 +280,9 @@ DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash, (new BtHandshakeMessage(infoHash, peerId)); BtMessageValidatorHandle validator (new BtHandshakeMessageValidator - (msg.get(), bittorrent::getInfoHash(_downloadContext))); + (msg.get(), bittorrent::getInfoHash(downloadContext_))); msg->setBtMessageValidator(validator); - msg->setDHTEnabled(_dhtEnabled); + msg->setDHTEnabled(dhtEnabled_); setCommonProperty(msg); return msg; } @@ -299,8 +299,8 @@ DefaultBtMessageFactory::createRequestMessage SharedHandle<BtMessageValidator> validator (new RangeBtMessageValidator (msg.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(msg->getIndex()))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(msg->getIndex()))); msg->setBtMessageValidator(validator); setCommonProperty(msg); return msg; @@ -314,8 +314,8 @@ DefaultBtMessageFactory::createCancelMessage SharedHandle<BtMessageValidator> validator (new RangeBtMessageValidator (msg.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(index))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(index))); msg->setBtMessageValidator(validator); setCommonProperty(msg); return msg; @@ -328,10 +328,10 @@ DefaultBtMessageFactory::createPieceMessage BtPieceMessageHandle msg(new BtPieceMessage(index, begin, length)); BtMessageValidatorHandle validator (new BtPieceMessageValidator(msg.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(index))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(index))); msg->setBtMessageValidator(validator); - msg->setDownloadContext(_downloadContext); + msg->setDownloadContext(downloadContext_); setCommonProperty(msg); return msg; } @@ -341,7 +341,7 @@ DefaultBtMessageFactory::createHaveMessage(size_t index) { BtHaveMessageHandle msg(new BtHaveMessage(index)); SharedHandle<BtMessageValidator> v - (new IndexBtMessageValidator(msg.get(), _downloadContext->getNumPieces())); + (new IndexBtMessageValidator(msg.get(), downloadContext_->getNumPieces())); msg->setBtMessageValidator(v); setCommonProperty(msg); return msg; @@ -383,11 +383,11 @@ BtMessageHandle DefaultBtMessageFactory::createBitfieldMessage() { BtBitfieldMessageHandle msg - (new BtBitfieldMessage(_pieceStorage->getBitfield(), - _pieceStorage->getBitfieldLength())); + (new BtBitfieldMessage(pieceStorage_->getBitfield(), + pieceStorage_->getBitfieldLength())); SharedHandle<BtMessageValidator> v (new BtBitfieldMessageValidator(msg.get(), - _downloadContext->getNumPieces())); + downloadContext_->getNumPieces())); msg->setBtMessageValidator(v); setCommonProperty(msg); return msg; @@ -425,8 +425,8 @@ DefaultBtMessageFactory::createRejectMessage SharedHandle<BtMessageValidator> validator (new RangeBtMessageValidator (msg.get(), - _downloadContext->getNumPieces(), - _pieceStorage->getPieceLength(index))); + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(index))); msg->setBtMessageValidator(validator); setCommonProperty(msg); return msg; @@ -437,7 +437,7 @@ DefaultBtMessageFactory::createAllowedFastMessage(size_t index) { BtAllowedFastMessageHandle msg(new BtAllowedFastMessage(index)); SharedHandle<BtMessageValidator> validator - (new IndexBtMessageValidator(msg.get(), _downloadContext->getNumPieces())); + (new IndexBtMessageValidator(msg.get(), downloadContext_->getNumPieces())); msg->setBtMessageValidator(validator); setCommonProperty(msg); return msg; @@ -463,71 +463,71 @@ DefaultBtMessageFactory::createBtExtendedMessage void DefaultBtMessageFactory::setTaskQueue (const WeakHandle<DHTTaskQueue>& taskQueue) { - _taskQueue = taskQueue; + taskQueue_ = taskQueue; } void DefaultBtMessageFactory::setTaskFactory (const WeakHandle<DHTTaskFactory>& taskFactory) { - _taskFactory = taskFactory; + taskFactory_ = taskFactory; } void DefaultBtMessageFactory::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } void DefaultBtMessageFactory::setDownloadContext (const SharedHandle<DownloadContext>& downloadContext) { - _downloadContext = downloadContext; + downloadContext_ = downloadContext; } void DefaultBtMessageFactory::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void DefaultBtMessageFactory::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void DefaultBtMessageFactory::setBtMessageDispatcher (const WeakHandle<BtMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DefaultBtMessageFactory::setExtensionMessageFactory (const SharedHandle<ExtensionMessageFactory>& factory) { - _extensionMessageFactory = factory; + extensionMessageFactory_ = factory; } void DefaultBtMessageFactory::setLocalNode(const WeakHandle<DHTNode>& localNode) { - _localNode = localNode; + localNode_ = localNode; } void DefaultBtMessageFactory::setRoutingTable (const WeakHandle<DHTRoutingTable>& routingTable) { - _routingTable = routingTable; + routingTable_ = routingTable; } void DefaultBtMessageFactory::setBtRequestFactory (const WeakHandle<BtRequestFactory>& factory) { - _requestFactory = factory; + requestFactory_ = factory; } void DefaultBtMessageFactory::setPeerConnection (const WeakHandle<PeerConnection>& connection) { - _peerConnection = connection; + peerConnection_ = connection; } } // namespace aria2 diff --git a/src/DefaultBtMessageFactory.h b/src/DefaultBtMessageFactory.h index bf0103f5..c0f3def9 100644 --- a/src/DefaultBtMessageFactory.h +++ b/src/DefaultBtMessageFactory.h @@ -56,31 +56,31 @@ class DHTTaskFactory; class DefaultBtMessageFactory : public BtMessageFactory { private: - cuid_t _cuid; - SharedHandle<DownloadContext> _downloadContext; - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<PeerStorage> _peerStorage; - SharedHandle<Peer> _peer; + cuid_t cuid_; + SharedHandle<DownloadContext> downloadContext_; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<PeerStorage> peerStorage_; + SharedHandle<Peer> peer_; - bool _dhtEnabled; + bool dhtEnabled_; - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; - WeakHandle<BtRequestFactory> _requestFactory; + WeakHandle<BtRequestFactory> requestFactory_; - WeakHandle<PeerConnection> _peerConnection; + WeakHandle<PeerConnection> peerConnection_; - SharedHandle<ExtensionMessageFactory> _extensionMessageFactory; + SharedHandle<ExtensionMessageFactory> extensionMessageFactory_; - WeakHandle<DHTNode> _localNode; + WeakHandle<DHTNode> localNode_; - WeakHandle<DHTRoutingTable> _routingTable; + WeakHandle<DHTRoutingTable> routingTable_; - WeakHandle<DHTTaskQueue> _taskQueue; + WeakHandle<DHTTaskQueue> taskQueue_; - WeakHandle<DHTTaskFactory> _taskFactory; + WeakHandle<DHTTaskFactory> taskFactory_; - bool _metadataGetMode; + bool metadataGetMode_; void setCommonProperty(const SharedHandle<AbstractBtMessage>& msg); public: @@ -145,11 +145,11 @@ public: void setCuid(cuid_t cuid) { - _cuid = cuid; + cuid_ = cuid; } void setDHTEnabled(bool enabled) { - _dhtEnabled = enabled; + dhtEnabled_ = enabled; } void setBtMessageDispatcher @@ -172,7 +172,7 @@ public: void enableMetadataGetMode() { - _metadataGetMode = true; + metadataGetMode_ = true; } }; diff --git a/src/DefaultBtMessageReceiver.cc b/src/DefaultBtMessageReceiver.cc index 15ce0bf9..a57852b1 100644 --- a/src/DefaultBtMessageReceiver.cc +++ b/src/DefaultBtMessageReceiver.cc @@ -51,7 +51,7 @@ namespace aria2 { DefaultBtMessageReceiver::DefaultBtMessageReceiver(): - _handshakeSent(false) + handshakeSent_(false) {} SharedHandle<BtHandshakeMessage> @@ -59,12 +59,12 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply) { unsigned char data[BtHandshakeMessage::MESSAGE_LENGTH]; size_t dataLength = BtHandshakeMessage::MESSAGE_LENGTH; - bool retval = _peerConnection->receiveHandshake(data, dataLength); + bool retval = peerConnection_->receiveHandshake(data, dataLength); // To handle tracker's NAT-checking feature - if(!_handshakeSent && quickReply && dataLength >= 48) { - _handshakeSent = true; + if(!handshakeSent_ && quickReply && dataLength >= 48) { + handshakeSent_ = true; // check info_hash - if(memcmp(bittorrent::getInfoHash(_downloadContext), &data[28], + if(memcmp(bittorrent::getInfoHash(downloadContext_), &data[28], INFO_HASH_LENGTH) == 0) { sendHandshake(); } @@ -73,7 +73,7 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply) return SharedHandle<BtHandshakeMessage>(); } SharedHandle<BtHandshakeMessage> msg = - _messageFactory->createHandshakeMessage(data, dataLength); + messageFactory_->createHandshakeMessage(data, dataLength); msg->validate(); return msg; } @@ -86,25 +86,25 @@ DefaultBtMessageReceiver::receiveAndSendHandshake() void DefaultBtMessageReceiver::sendHandshake() { SharedHandle<BtMessage> msg = - _messageFactory->createHandshakeMessage - (bittorrent::getInfoHash(_downloadContext), bittorrent::getStaticPeerId()); - _dispatcher->addMessageToQueue(msg); - _dispatcher->sendMessages(); + messageFactory_->createHandshakeMessage + (bittorrent::getInfoHash(downloadContext_), bittorrent::getStaticPeerId()); + dispatcher_->addMessageToQueue(msg); + dispatcher_->sendMessages(); } BtMessageHandle DefaultBtMessageReceiver::receiveMessage() { size_t dataLength = 0; // Give 0 to PeerConnection::receiveMessage() to prevent memcpy. - if(!_peerConnection->receiveMessage(0, dataLength)) { + if(!peerConnection_->receiveMessage(0, dataLength)) { return SharedHandle<BtMessage>(); } BtMessageHandle msg = - _messageFactory->createBtMessage(_peerConnection->getBuffer(), dataLength); + messageFactory_->createBtMessage(peerConnection_->getBuffer(), dataLength); msg->validate(); if(msg->getId() == BtPieceMessage::ID) { SharedHandle<BtPieceMessage> piecemsg = static_pointer_cast<BtPieceMessage>(msg); - piecemsg->setRawMessage(_peerConnection->detachBuffer()); + piecemsg->setRawMessage(peerConnection_->detachBuffer()); } return msg; } @@ -112,25 +112,25 @@ BtMessageHandle DefaultBtMessageReceiver::receiveMessage() { void DefaultBtMessageReceiver::setDownloadContext (const SharedHandle<DownloadContext>& downloadContext) { - _downloadContext = downloadContext; + downloadContext_ = downloadContext; } void DefaultBtMessageReceiver::setPeerConnection (const WeakHandle<PeerConnection>& peerConnection) { - _peerConnection = peerConnection; + peerConnection_ = peerConnection; } void DefaultBtMessageReceiver::setDispatcher (const WeakHandle<BtMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DefaultBtMessageReceiver::setBtMessageFactory (const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } } // namespace aria2 diff --git a/src/DefaultBtMessageReceiver.h b/src/DefaultBtMessageReceiver.h index 2d2d4dc4..beffd358 100644 --- a/src/DefaultBtMessageReceiver.h +++ b/src/DefaultBtMessageReceiver.h @@ -49,11 +49,11 @@ class Logger; class DefaultBtMessageReceiver : public BtMessageReceiver { private: - bool _handshakeSent; - SharedHandle<DownloadContext> _downloadContext; - WeakHandle<PeerConnection> _peerConnection; - WeakHandle<BtMessageDispatcher> _dispatcher; - WeakHandle<BtMessageFactory> _messageFactory; + bool handshakeSent_; + SharedHandle<DownloadContext> downloadContext_; + WeakHandle<PeerConnection> peerConnection_; + WeakHandle<BtMessageDispatcher> dispatcher_; + WeakHandle<BtMessageFactory> messageFactory_; void sendHandshake(); public: diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc index e36bdb37..65b300c5 100644 --- a/src/DefaultBtProgressInfoFile.cc +++ b/src/DefaultBtProgressInfoFile.cc @@ -78,24 +78,24 @@ DefaultBtProgressInfoFile::DefaultBtProgressInfoFile (const SharedHandle<DownloadContext>& dctx, const PieceStorageHandle& pieceStorage, const Option* option): - _dctx(dctx), - _pieceStorage(pieceStorage), - _option(option), - _logger(LogFactory::getInstance()), - _filename(createFilename(_dctx, getSuffix())) + dctx_(dctx), + pieceStorage_(pieceStorage), + option_(option), + logger_(LogFactory::getInstance()), + filename_(createFilename(dctx_, getSuffix())) {} DefaultBtProgressInfoFile::~DefaultBtProgressInfoFile() {} void DefaultBtProgressInfoFile::updateFilename() { - _filename = createFilename(_dctx, getSuffix()); + filename_ = createFilename(dctx_, getSuffix()); } bool DefaultBtProgressInfoFile::isTorrentDownload() { #ifdef ENABLE_BITTORRENT - return !_btRuntime.isNull(); + return !btRuntime_.isNull(); #else // !ENABLE_BITTORRENT return false; #endif // !ENABLE_BITTORRENT @@ -104,13 +104,13 @@ bool DefaultBtProgressInfoFile::isTorrentDownload() // Since version 0001, Integers are saved in binary form, network byte order. void DefaultBtProgressInfoFile::save() { - _logger->info(MSG_SAVING_SEGMENT_FILE, _filename.c_str()); - std::string filenameTemp = _filename+"__temp"; + logger_->info(MSG_SAVING_SEGMENT_FILE, filename_.c_str()); + std::string filenameTemp = filename_+"__temp"; { std::ofstream o(filenameTemp.c_str(), std::ios::out|std::ios::binary); if(!o) { throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_WRITE, - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } #ifdef ENABLE_BITTORRENT bool torrentDownload = isTorrentDownload(); @@ -135,7 +135,7 @@ void DefaultBtProgressInfoFile::save() #ifdef ENABLE_BITTORRENT // infoHashLength: // length: 32 bits - const unsigned char* infoHash = bittorrent::getInfoHash(_dctx); + const unsigned char* infoHash = bittorrent::getInfoHash(dctx_); uint32_t infoHashLengthNL = htonl(INFO_HASH_LENGTH); o.write(reinterpret_cast<const char*>(&infoHashLengthNL), sizeof(infoHashLengthNL)); @@ -150,38 +150,38 @@ void DefaultBtProgressInfoFile::save() sizeof(infoHashLength)); } // pieceLength: 32 bits - uint32_t pieceLengthNL = htonl(_dctx->getPieceLength()); + uint32_t pieceLengthNL = htonl(dctx_->getPieceLength()); o.write(reinterpret_cast<const char*>(&pieceLengthNL), sizeof(pieceLengthNL)); // totalLength: 64 bits - uint64_t totalLengthNL = hton64(_dctx->getTotalLength()); + uint64_t totalLengthNL = hton64(dctx_->getTotalLength()); o.write(reinterpret_cast<const char*>(&totalLengthNL), sizeof(totalLengthNL)); // uploadLength: 64 bits uint64_t uploadLengthNL = 0; #ifdef ENABLE_BITTORRENT if(torrentDownload) { - TransferStat stat = _peerStorage->calculateStat(); + TransferStat stat = peerStorage_->calculateStat(); uploadLengthNL = hton64(stat.getAllTimeUploadLength()); } #endif // ENABLE_BITTORRENT o.write(reinterpret_cast<const char*>(&uploadLengthNL), sizeof(uploadLengthNL)); // bitfieldLength: 32 bits - uint32_t bitfieldLengthNL = htonl(_pieceStorage->getBitfieldLength()); + uint32_t bitfieldLengthNL = htonl(pieceStorage_->getBitfieldLength()); o.write(reinterpret_cast<const char*>(&bitfieldLengthNL), sizeof(bitfieldLengthNL)); // bitfield - o.write(reinterpret_cast<const char*>(_pieceStorage->getBitfield()), - _pieceStorage->getBitfieldLength()); + o.write(reinterpret_cast<const char*>(pieceStorage_->getBitfield()), + pieceStorage_->getBitfieldLength()); // the number of in-flight piece: 32 bits // TODO implement this - uint32_t numInFlightPieceNL = htonl(_pieceStorage->countInFlightPiece()); + uint32_t numInFlightPieceNL = htonl(pieceStorage_->countInFlightPiece()); o.write(reinterpret_cast<const char*>(&numInFlightPieceNL), sizeof(numInFlightPieceNL)); std::vector<SharedHandle<Piece> > inFlightPieces; - inFlightPieces.reserve(_pieceStorage->countInFlightPiece()); - _pieceStorage->getInFlightPieces(inFlightPieces); + inFlightPieces.reserve(pieceStorage_->countInFlightPiece()); + pieceStorage_->getInFlightPieces(inFlightPieces); for(std::vector<SharedHandle<Piece> >::const_iterator itr = inFlightPieces.begin(), eoi = inFlightPieces.end(); itr != eoi; ++itr) { @@ -198,24 +198,24 @@ void DefaultBtProgressInfoFile::save() o.flush(); if(!o) { throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_WRITE, - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } - _logger->info(MSG_SAVED_SEGMENT_FILE); + logger_->info(MSG_SAVED_SEGMENT_FILE); } - if(!File(filenameTemp).renameTo(_filename)) { + if(!File(filenameTemp).renameTo(filename_)) { throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_WRITE, - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } } #define CHECK_STREAM(in, length) \ if(in.gcount() != length) { \ throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_READ, \ - _filename.c_str(),"Unexpected EOF").str()); \ + filename_.c_str(),"Unexpected EOF").str()); \ } \ if(!in) { \ throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_READ, \ - _filename.c_str(), strerror(errno)).str()); \ + filename_.c_str(), strerror(errno)).str()); \ } // It is assumed that integers are saved as: @@ -223,11 +223,11 @@ void DefaultBtProgressInfoFile::save() // 2) network byte order if version == 0001 void DefaultBtProgressInfoFile::load() { - _logger->info(MSG_LOADING_SEGMENT_FILE, _filename.c_str()); - std::ifstream in(_filename.c_str(), std::ios::in|std::ios::binary); + logger_->info(MSG_LOADING_SEGMENT_FILE, filename_.c_str()); + std::ifstream in(filename_.c_str(), std::ios::in|std::ios::binary); if(!in) { \ throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_READ, \ - _filename.c_str(), strerror(errno)).str()); + filename_.c_str(), strerror(errno)).str()); } unsigned char versionBuf[2]; in.read(reinterpret_cast<char*>(versionBuf), sizeof(versionBuf)); @@ -249,8 +249,8 @@ void DefaultBtProgressInfoFile::load() bool infoHashCheckEnabled = false; if(extension[3]&1 && isTorrentDownload()) { infoHashCheckEnabled = true; - if(_logger->debug()) { - _logger->debug("InfoHash checking enabled."); + if(logger_->debug()) { + logger_->debug("InfoHash checking enabled."); } } @@ -272,7 +272,7 @@ void DefaultBtProgressInfoFile::load() CHECK_STREAM(in, static_cast<int>(infoHashLength)); #ifdef ENABLE_BITTORRENT if(infoHashCheckEnabled) { - const unsigned char* infoHash = bittorrent::getInfoHash(_dctx); + const unsigned char* infoHash = bittorrent::getInfoHash(dctx_); if(infoHashLength != INFO_HASH_LENGTH || memcmp(savedInfoHash, infoHash, INFO_HASH_LENGTH) != 0) { throw DL_ABORT_EX @@ -298,10 +298,10 @@ void DefaultBtProgressInfoFile::load() if(version >= 1) { totalLength = ntoh64(totalLength); } - if(totalLength != _dctx->getTotalLength()) { + if(totalLength != dctx_->getTotalLength()) { throw DL_ABORT_EX (StringFormat("total length mismatch. expected: %s, actual: %s", - util::itos(_dctx->getTotalLength()).c_str(), + util::itos(dctx_->getTotalLength()).c_str(), util::itos(totalLength).c_str()).str()); } uint64_t uploadLength; @@ -312,7 +312,7 @@ void DefaultBtProgressInfoFile::load() } #ifdef ENABLE_BITTORRENT if(isTorrentDownload()) { - _btRuntime->setUploadLengthAtStartup(uploadLength); + btRuntime_->setUploadLengthAtStartup(uploadLength); } #endif // ENABLE_BITTORRENT // TODO implement the conversion mechanism between different piece length. @@ -335,8 +335,8 @@ void DefaultBtProgressInfoFile::load() in.read(reinterpret_cast<char*> (static_cast<unsigned char*>(savedBitfield)), bitfieldLength); CHECK_STREAM(in, static_cast<int>(bitfieldLength)); - if(pieceLength == _dctx->getPieceLength()) { - _pieceStorage->setBitfield(savedBitfield, bitfieldLength); + if(pieceLength == dctx_->getPieceLength()) { + pieceStorage_->setBitfield(savedBitfield, bitfieldLength); uint32_t numInFlightPiece; in.read(reinterpret_cast<char*>(&numInFlightPiece), @@ -354,7 +354,7 @@ void DefaultBtProgressInfoFile::load() if(version >= 1) { index = ntohl(index); } - if(!(index < _dctx->getNumPieces())) { + if(!(index < dctx_->getNumPieces())) { throw DL_ABORT_EX (StringFormat("piece index out of range: %u", index).str()); } @@ -364,7 +364,7 @@ void DefaultBtProgressInfoFile::load() if(version >= 1) { length = ntohl(length); } - if(!(length <=_dctx->getPieceLength())) { + if(!(length <=dctx_->getPieceLength())) { throw DL_ABORT_EX (StringFormat("piece length out of range: %u", length).str()); } @@ -391,13 +391,13 @@ void DefaultBtProgressInfoFile::load() #ifdef ENABLE_MESSAGE_DIGEST - piece->setHashAlgo(_dctx->getPieceHashAlgo()); + piece->setHashAlgo(dctx_->getPieceHashAlgo()); #endif // ENABLE_MESSAGE_DIGEST inFlightPieces.push_back(piece); } - _pieceStorage->addInFlightPiece(inFlightPieces); + pieceStorage_->addInFlightPiece(inFlightPieces); } else { uint32_t numInFlightPiece; in.read(reinterpret_cast<char*>(&numInFlightPiece), @@ -409,35 +409,35 @@ void DefaultBtProgressInfoFile::load() BitfieldMan src(pieceLength, totalLength); src.setBitfield(savedBitfield, bitfieldLength); if((src.getCompletedLength() || numInFlightPiece) && - !_option->getAsBool(PREF_ALLOW_PIECE_LENGTH_CHANGE)) { + !option_->getAsBool(PREF_ALLOW_PIECE_LENGTH_CHANGE)) { throw DOWNLOAD_FAILURE_EXCEPTION ("WARNING: Detected a change in piece length. You can proceed with" " --allow-piece-length-change=true, but you may lose some download" " progress."); } - BitfieldMan dest(_dctx->getPieceLength(), totalLength); + BitfieldMan dest(dctx_->getPieceLength(), totalLength); util::convertBitfield(&dest, &src); - _pieceStorage->setBitfield(dest.getBitfield(), dest.getBitfieldLength()); + pieceStorage_->setBitfield(dest.getBitfield(), dest.getBitfieldLength()); } - _logger->info(MSG_LOADED_SEGMENT_FILE); + logger_->info(MSG_LOADED_SEGMENT_FILE); } void DefaultBtProgressInfoFile::removeFile() { if(exists()) { - File f(_filename); + File f(filename_); f.remove(); } } bool DefaultBtProgressInfoFile::exists() { - File f(_filename); + File f(filename_); if(f.isFile()) { - _logger->info(MSG_SEGMENT_FILE_EXISTS, _filename.c_str()); + logger_->info(MSG_SEGMENT_FILE_EXISTS, filename_.c_str()); return true; } else { - _logger->info(MSG_SEGMENT_FILE_DOES_NOT_EXIST, _filename.c_str()); + logger_->info(MSG_SEGMENT_FILE_DOES_NOT_EXIST, filename_.c_str()); return false; } } @@ -446,13 +446,13 @@ bool DefaultBtProgressInfoFile::exists() void DefaultBtProgressInfoFile::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void DefaultBtProgressInfoFile::setBtRuntime (const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } #endif // ENABLE_BITTORRENT diff --git a/src/DefaultBtProgressInfoFile.h b/src/DefaultBtProgressInfoFile.h index e868a32a..8ec62b3f 100644 --- a/src/DefaultBtProgressInfoFile.h +++ b/src/DefaultBtProgressInfoFile.h @@ -48,15 +48,15 @@ class Option; class DefaultBtProgressInfoFile : public BtProgressInfoFile { private: - SharedHandle<DownloadContext> _dctx; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<DownloadContext> dctx_; + SharedHandle<PieceStorage> pieceStorage_; #ifdef ENABLE_BITTORRENT - SharedHandle<PeerStorage> _peerStorage; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<PeerStorage> peerStorage_; + SharedHandle<BtRuntime> btRuntime_; #endif // ENABLE_BITTORRENT - const Option* _option; - Logger* _logger; - std::string _filename; + const Option* option_; + Logger* logger_; + std::string filename_; bool isTorrentDownload(); @@ -69,7 +69,7 @@ public: virtual ~DefaultBtProgressInfoFile(); - virtual std::string getFilename() { return _filename; } + virtual std::string getFilename() { return filename_; } virtual bool exists(); @@ -79,7 +79,7 @@ public: virtual void removeFile(); - // re-set filename using current _dctx. + // re-set filename using current dctx_. virtual void updateFilename(); #ifdef ENABLE_BITTORRENT diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc index 36c34c5e..333562eb 100644 --- a/src/DefaultBtRequestFactory.cc +++ b/src/DefaultBtRequestFactory.cc @@ -51,104 +51,104 @@ namespace aria2 { DefaultBtRequestFactory::DefaultBtRequestFactory(): - _logger(LogFactory::getInstance()) + logger_(LogFactory::getInstance()) { - if(_logger->debug()) { - _logger->debug("DefaultBtRequestFactory::instantiated"); + if(logger_->debug()) { + logger_->debug("DefaultBtRequestFactory::instantiated"); } } DefaultBtRequestFactory::~DefaultBtRequestFactory() { - if(_logger->debug()) { - _logger->debug("DefaultBtRequestFactory::deleted"); + if(logger_->debug()) { + logger_->debug("DefaultBtRequestFactory::deleted"); } } void DefaultBtRequestFactory::addTargetPiece(const SharedHandle<Piece>& piece) { - _pieces.push_back(piece); + pieces_.push_back(piece); } class AbortCompletedPieceRequest { private: - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; public: AbortCompletedPieceRequest(const WeakHandle<BtMessageDispatcher>& dispatcher): - _dispatcher(dispatcher) {} + dispatcher_(dispatcher) {} void operator()(const SharedHandle<Piece>& piece) { if(piece->pieceComplete()) { - _dispatcher->doAbortOutstandingRequestAction(piece); + dispatcher_->doAbortOutstandingRequestAction(piece); } } }; void DefaultBtRequestFactory::removeCompletedPiece() { - std::for_each(_pieces.begin(), _pieces.end(), - AbortCompletedPieceRequest(_dispatcher)); - _pieces.erase(std::remove_if(_pieces.begin(), _pieces.end(), + std::for_each(pieces_.begin(), pieces_.end(), + AbortCompletedPieceRequest(dispatcher_)); + pieces_.erase(std::remove_if(pieces_.begin(), pieces_.end(), mem_fun_sh(&Piece::pieceComplete)), - _pieces.end()); + pieces_.end()); } void DefaultBtRequestFactory::removeTargetPiece (const SharedHandle<Piece>& piece) { - _pieces.erase(std::remove(_pieces.begin(), _pieces.end(), piece), - _pieces.end()); - _dispatcher->doAbortOutstandingRequestAction(piece); - _pieceStorage->cancelPiece(piece); + pieces_.erase(std::remove(pieces_.begin(), pieces_.end(), piece), + pieces_.end()); + dispatcher_->doAbortOutstandingRequestAction(piece); + pieceStorage_->cancelPiece(piece); } class ProcessChokedPiece { private: - SharedHandle<Peer> _peer; - WeakHandle<PieceStorage> _pieceStorage; + SharedHandle<Peer> peer_; + WeakHandle<PieceStorage> pieceStorage_; public: ProcessChokedPiece(const SharedHandle<Peer>& peer, const WeakHandle<PieceStorage>& pieceStorage): - _peer(peer), - _pieceStorage(pieceStorage) {} + peer_(peer), + pieceStorage_(pieceStorage) {} void operator()(const SharedHandle<Piece>& piece) { - if(!_peer->isInPeerAllowedIndexSet(piece->getIndex())) { - _pieceStorage->cancelPiece(piece); + if(!peer_->isInPeerAllowedIndexSet(piece->getIndex())) { + pieceStorage_->cancelPiece(piece); } } }; class FindChokedPiece { private: - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; public: - FindChokedPiece(const SharedHandle<Peer>& peer):_peer(peer) {} + FindChokedPiece(const SharedHandle<Peer>& peer):peer_(peer) {} bool operator()(const SharedHandle<Piece>& piece) { - return !_peer->isInPeerAllowedIndexSet(piece->getIndex()); + return !peer_->isInPeerAllowedIndexSet(piece->getIndex()); } }; void DefaultBtRequestFactory::doChokedAction() { - std::for_each(_pieces.begin(), _pieces.end(), - ProcessChokedPiece(_peer, _pieceStorage)); - _pieces.erase(std::remove_if(_pieces.begin(), _pieces.end(), - FindChokedPiece(_peer)), - _pieces.end()); + std::for_each(pieces_.begin(), pieces_.end(), + ProcessChokedPiece(peer_, pieceStorage_)); + pieces_.erase(std::remove_if(pieces_.begin(), pieces_.end(), + FindChokedPiece(peer_)), + pieces_.end()); } void DefaultBtRequestFactory::removeAllTargetPiece() { - for(std::deque<SharedHandle<Piece> >::iterator itr = _pieces.begin(), - eoi = _pieces.end(); itr != eoi; ++itr) { - _dispatcher->doAbortOutstandingRequestAction(*itr); - _pieceStorage->cancelPiece(*itr); + for(std::deque<SharedHandle<Piece> >::iterator itr = pieces_.begin(), + eoi = pieces_.end(); itr != eoi; ++itr) { + dispatcher_->doAbortOutstandingRequestAction(*itr); + pieceStorage_->cancelPiece(*itr); } - _pieces.clear(); + pieces_.clear(); } void DefaultBtRequestFactory::createRequestMessages @@ -160,22 +160,22 @@ void DefaultBtRequestFactory::createRequestMessages size_t getnum = max-requests.size(); std::vector<size_t> blockIndexes; blockIndexes.reserve(getnum); - for(std::deque<SharedHandle<Piece> >::iterator itr = _pieces.begin(), - eoi = _pieces.end(); itr != eoi && getnum; ++itr) { + for(std::deque<SharedHandle<Piece> >::iterator itr = pieces_.begin(), + eoi = pieces_.end(); itr != eoi && getnum; ++itr) { SharedHandle<Piece>& piece = *itr; if(piece->getMissingUnusedBlockIndex(blockIndexes, getnum)) { getnum -= blockIndexes.size(); for(std::vector<size_t>::const_iterator i = blockIndexes.begin(), eoi2 = blockIndexes.end(); i != eoi2; ++i) { - if(_logger->debug()) { - _logger->debug("Creating RequestMessage index=%u, begin=%u," + if(logger_->debug()) { + logger_->debug("Creating RequestMessage index=%u, begin=%u," " blockIndex=%u", piece->getIndex(), (*i)*piece->getBlockLength(), (*i)); } requests.push_back - (_messageFactory->createRequestMessage(piece, *i)); + (messageFactory_->createRequestMessage(piece, *i)); } blockIndexes.clear(); } @@ -185,8 +185,8 @@ void DefaultBtRequestFactory::createRequestMessages void DefaultBtRequestFactory::createRequestMessagesOnEndGame (std::vector<SharedHandle<BtMessage> >& requests, size_t max) { - for(std::deque<SharedHandle<Piece> >::iterator itr = _pieces.begin(), - eoi = _pieces.end(); itr != eoi && requests.size() < max; ++itr) { + for(std::deque<SharedHandle<Piece> >::iterator itr = pieces_.begin(), + eoi = pieces_.end(); itr != eoi && requests.size() < max; ++itr) { SharedHandle<Piece>& piece = *itr; const size_t mislen = piece->getBitfieldLength(); array_ptr<unsigned char> misbitfield(new unsigned char[mislen]); @@ -210,16 +210,16 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame eoi2 = missingBlockIndexes.end(); bitr != eoi2 && requests.size() < max; ++bitr) { const size_t& blockIndex = *bitr; - if(!_dispatcher->isOutstandingRequest(piece->getIndex(), + if(!dispatcher_->isOutstandingRequest(piece->getIndex(), blockIndex)) { - if(_logger->debug()) { - _logger->debug("Creating RequestMessage index=%u, begin=%u," + if(logger_->debug()) { + logger_->debug("Creating RequestMessage index=%u, begin=%u," " blockIndex=%u", piece->getIndex(), blockIndex*piece->getBlockLength(), blockIndex); } - requests.push_back(_messageFactory->createRequestMessage + requests.push_back(messageFactory_->createRequestMessage (piece, blockIndex)); } } @@ -229,55 +229,55 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame class CountMissingBlock { private: - size_t _numMissingBlock; + size_t numMissingBlock_; public: - CountMissingBlock():_numMissingBlock(0) {} + CountMissingBlock():numMissingBlock_(0) {} size_t getNumMissingBlock() { - return _numMissingBlock; + return numMissingBlock_; } void operator()(const SharedHandle<Piece>& piece) { - _numMissingBlock += piece->countMissingBlock(); + numMissingBlock_ += piece->countMissingBlock(); } }; size_t DefaultBtRequestFactory::countMissingBlock() { - return std::for_each(_pieces.begin(), _pieces.end(), + return std::for_each(pieces_.begin(), pieces_.end(), CountMissingBlock()).getNumMissingBlock(); } void DefaultBtRequestFactory::getTargetPieceIndexes (std::vector<size_t>& indexes) const { - std::transform(_pieces.begin(), _pieces.end(), std::back_inserter(indexes), + std::transform(pieces_.begin(), pieces_.end(), std::back_inserter(indexes), mem_fun_sh(&Piece::getIndex)); } void DefaultBtRequestFactory::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void DefaultBtRequestFactory::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } void DefaultBtRequestFactory::setBtMessageDispatcher (const WeakHandle<BtMessageDispatcher>& dispatcher) { - _dispatcher = dispatcher; + dispatcher_ = dispatcher; } void DefaultBtRequestFactory::setBtMessageFactory (const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } } // namespace aria2 diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h index 24cd152c..43c68f16 100644 --- a/src/DefaultBtRequestFactory.h +++ b/src/DefaultBtRequestFactory.h @@ -52,12 +52,12 @@ class Logger; class DefaultBtRequestFactory : public BtRequestFactory { private: - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<Peer> _peer; - WeakHandle<BtMessageDispatcher> _dispatcher; - WeakHandle<BtMessageFactory> _messageFactory; - std::deque<SharedHandle<Piece> > _pieces; - Logger* _logger; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<Peer> peer_; + WeakHandle<BtMessageDispatcher> dispatcher_; + WeakHandle<BtMessageFactory> messageFactory_; + std::deque<SharedHandle<Piece> > pieces_; + Logger* logger_; public: DefaultBtRequestFactory(); @@ -70,7 +70,7 @@ public: virtual void removeAllTargetPiece(); virtual size_t countTargetPiece() { - return _pieces.size(); + return pieces_.size(); } virtual size_t countMissingBlock(); @@ -89,7 +89,7 @@ public: std::deque<SharedHandle<Piece> >& getTargetPieces() { - return _pieces; + return pieces_; } void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage); diff --git a/src/DefaultExtensionMessageFactory.cc b/src/DefaultExtensionMessageFactory.cc index 805a56b6..5070f986 100644 --- a/src/DefaultExtensionMessageFactory.cc +++ b/src/DefaultExtensionMessageFactory.cc @@ -57,14 +57,14 @@ namespace aria2 { DefaultExtensionMessageFactory::DefaultExtensionMessageFactory(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} DefaultExtensionMessageFactory::DefaultExtensionMessageFactory (const SharedHandle<Peer>& peer, const SharedHandle<ExtensionMessageRegistry>& registry): - _peer(peer), - _registry(registry), - _logger(LogFactory::getInstance()) {} + peer_(peer), + registry_(registry), + logger_(LogFactory::getInstance()) {} DefaultExtensionMessageFactory::~DefaultExtensionMessageFactory() {} @@ -76,11 +76,11 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t // handshake HandshakeExtensionMessageHandle m = HandshakeExtensionMessage::create(data, length); - m->setPeer(_peer); - m->setDownloadContext(_dctx); + m->setPeer(peer_); + m->setDownloadContext(dctx_); return m; } else { - std::string extensionName = _registry->getExtensionName(extensionMessageID); + std::string extensionName = registry_->getExtensionName(extensionMessageID); if(extensionName.empty()) { throw DL_ABORT_EX (StringFormat("No extension registered for extended message ID %u", @@ -90,7 +90,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t // uTorrent compatible Peer-Exchange UTPexExtensionMessageHandle m = UTPexExtensionMessage::create(data, length); - m->setPeerStorage(_peerStorage); + m->setPeerStorage(peerStorage_); return m; } else if(extensionName == "ut_metadata") { if(length == 0) { @@ -116,10 +116,10 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t SharedHandle<UTMetadataRequestExtensionMessage> m (new UTMetadataRequestExtensionMessage(extensionMessageID)); m->setIndex(index->i()); - m->setDownloadContext(_dctx); - m->setPeer(_peer); - m->setBtMessageFactory(_messageFactory); - m->setBtMessageDispatcher(_dispatcher); + m->setDownloadContext(dctx_); + m->setPeer(peer_); + m->setBtMessageFactory(messageFactory_); + m->setBtMessageDispatcher(dispatcher_); return m; } case 1: { @@ -135,9 +135,9 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t m->setIndex(index->i()); m->setTotalSize(totalSize->i()); m->setData(std::string(&data[1+end], &data[length])); - m->setUTMetadataRequestTracker(_tracker); - m->setPieceStorage(_dctx->getOwnerRequestGroup()->getPieceStorage()); - m->setDownloadContext(_dctx); + m->setUTMetadataRequestTracker(tracker_); + m->setPieceStorage(dctx_->getOwnerRequestGroup()->getPieceStorage()); + m->setDownloadContext(dctx_); return m; } case 2: { @@ -163,12 +163,12 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t void DefaultExtensionMessageFactory::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void DefaultExtensionMessageFactory::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } } // namespace aria2 diff --git a/src/DefaultExtensionMessageFactory.h b/src/DefaultExtensionMessageFactory.h index 9fa36213..c79a2a26 100644 --- a/src/DefaultExtensionMessageFactory.h +++ b/src/DefaultExtensionMessageFactory.h @@ -50,21 +50,21 @@ class UTMetadataRequestTracker; class DefaultExtensionMessageFactory:public ExtensionMessageFactory { private: - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; - SharedHandle<ExtensionMessageRegistry> _registry; + SharedHandle<ExtensionMessageRegistry> registry_; - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - WeakHandle<BtMessageFactory> _messageFactory; + WeakHandle<BtMessageFactory> messageFactory_; - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; - WeakHandle<UTMetadataRequestTracker> _tracker; + WeakHandle<UTMetadataRequestTracker> tracker_; - Logger* _logger; + Logger* logger_; public: DefaultExtensionMessageFactory(); @@ -85,28 +85,28 @@ public: void setExtensionMessageRegistry (const SharedHandle<ExtensionMessageRegistry>& registry) { - _registry = registry; + registry_ = registry; } void setDownloadContext(const SharedHandle<DownloadContext>& dctx) { - _dctx = dctx; + dctx_ = dctx; } void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& disp) { - _dispatcher = disp; + dispatcher_ = disp; } void setUTMetadataRequestTracker (const WeakHandle<UTMetadataRequestTracker>& tracker) { - _tracker = tracker; + tracker_ = tracker; } }; diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc index 680afb6b..a22ffc83 100644 --- a/src/DefaultPeerStorage.cc +++ b/src/DefaultPeerStorage.cc @@ -51,37 +51,37 @@ namespace aria2 { static const int MAX_PEER_LIST_SIZE = 1024; DefaultPeerStorage::DefaultPeerStorage(): - _logger(LogFactory::getInstance()), - _removedPeerSessionDownloadLength(0), - _removedPeerSessionUploadLength(0), - _seederStateChoke(new BtSeederStateChoke()), - _leecherStateChoke(new BtLeecherStateChoke()), - _lastTransferStatMapUpdated(0) + logger_(LogFactory::getInstance()), + removedPeerSessionDownloadLength_(0), + removedPeerSessionUploadLength_(0), + seederStateChoke_(new BtSeederStateChoke()), + leecherStateChoke_(new BtLeecherStateChoke()), + lastTransferStatMapUpdated_(0) {} DefaultPeerStorage::~DefaultPeerStorage() { - delete _seederStateChoke; - delete _leecherStateChoke; + delete seederStateChoke_; + delete leecherStateChoke_; } class FindIdenticalPeer { private: - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; public: - FindIdenticalPeer(const SharedHandle<Peer>& peer):_peer(peer) {} + FindIdenticalPeer(const SharedHandle<Peer>& peer):peer_(peer) {} bool operator()(const SharedHandle<Peer>& peer) const { - return (_peer == peer) || - ((_peer->getIPAddress() == peer->getIPAddress()) && - (_peer->getPort() == peer->getPort())); + return (peer_ == peer) || + ((peer_->getIPAddress() == peer->getIPAddress()) && + (peer_->getPort() == peer->getPort())); } }; bool DefaultPeerStorage::isPeerAlreadyAdded(const SharedHandle<Peer>& peer) { - return std::find_if(_peers.begin(), _peers.end(), - FindIdenticalPeer(peer)) != _peers.end(); + return std::find_if(peers_.begin(), peers_.end(), + FindIdenticalPeer(peer)) != peers_.end(); } static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime) @@ -96,17 +96,17 @@ static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime) bool DefaultPeerStorage::addPeer(const SharedHandle<Peer>& peer) { if(isPeerAlreadyAdded(peer)) { - if(_logger->debug()) { - _logger->debug("Adding %s:%u is rejected because it has been already" + if(logger_->debug()) { + logger_->debug("Adding %s:%u is rejected because it has been already" " added.", peer->getIPAddress().c_str(), peer->getPort()); } return false; } - size_t maxPeerListSize = calculateMaxPeerListSize(_btRuntime); - if(_peers.size() >= maxPeerListSize) { - deleteUnusedPeer(_peers.size()-maxPeerListSize+1); + size_t maxPeerListSize = calculateMaxPeerListSize(btRuntime_); + if(peers_.size() >= maxPeerListSize) { + deleteUnusedPeer(peers_.size()-maxPeerListSize+1); } - _peers.push_front(peer); + peers_.push_front(peer); return true; } @@ -116,8 +116,8 @@ void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers) eoi = peers.end(); itr != eoi; ++itr) { const SharedHandle<Peer>& peer = *itr; if(addPeer(peer)) { - if(_logger->debug()) { - _logger->debug(MSG_ADDING_PEER, + if(logger_->debug()) { + logger_->debug(MSG_ADDING_PEER, peer->getIPAddress().c_str(), peer->getPort()); } } @@ -126,7 +126,7 @@ void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers) const std::deque<SharedHandle<Peer> >& DefaultPeerStorage::getPeers() { - return _peers; + return peers_; } class FindFinePeer { @@ -138,8 +138,8 @@ public: SharedHandle<Peer> DefaultPeerStorage::getUnusedPeer() { std::deque<SharedHandle<Peer> >::const_iterator itr = - std::find_if(_peers.begin(), _peers.end(), FindFinePeer()); - if(itr == _peers.end()) { + std::find_if(peers_.begin(), peers_.end(), FindFinePeer()); + if(itr == peers_.end()) { return SharedHandle<Peer>(); } else { return *itr; @@ -162,8 +162,8 @@ public: SharedHandle<Peer> DefaultPeerStorage::getPeer(const std::string& ipaddr, uint16_t port) const { std::deque<SharedHandle<Peer> >::const_iterator itr = - std::find_if(_peers.begin(), _peers.end(), FindPeer(ipaddr, port)); - if(itr == _peers.end()) { + std::find_if(peers_.begin(), peers_.end(), FindPeer(ipaddr, port)); + if(itr == peers_.end()) { return SharedHandle<Peer>(); } else { return *itr; @@ -171,7 +171,7 @@ SharedHandle<Peer> DefaultPeerStorage::getPeer(const std::string& ipaddr, } size_t DefaultPeerStorage::countPeer() const { - return _peers.size(); + return peers_.size(); } bool DefaultPeerStorage::isPeerAvailable() { @@ -180,15 +180,15 @@ bool DefaultPeerStorage::isPeerAvailable() { class CollectActivePeer { private: - std::vector<SharedHandle<Peer> >& _activePeers; + std::vector<SharedHandle<Peer> >& activePeers_; public: CollectActivePeer(std::vector<SharedHandle<Peer> >& activePeers): - _activePeers(activePeers) {} + activePeers_(activePeers) {} void operator()(const SharedHandle<Peer>& peer) { if(peer->isActive()) { - _activePeers.push_back(peer); + activePeers_.push_back(peer); } } }; @@ -196,7 +196,7 @@ public: void DefaultPeerStorage::getActivePeers (std::vector<SharedHandle<Peer> >& activePeers) { - std::for_each(_peers.begin(), _peers.end(), CollectActivePeer(activePeers)); + std::for_each(peers_.begin(), peers_.end(), CollectActivePeer(activePeers)); } static TransferStat calculateStatFor(const SharedHandle<Peer>& peer) @@ -212,12 +212,12 @@ static TransferStat calculateStatFor(const SharedHandle<Peer>& peer) TransferStat DefaultPeerStorage::calculateStat() { TransferStat stat; - if(_lastTransferStatMapUpdated.differenceInMillis(global::wallclock) >= 250) { - if(_logger->debug()) { - _logger->debug("Updating TransferStat of PeerStorage"); + if(lastTransferStatMapUpdated_.differenceInMillis(global::wallclock) >= 250) { + if(logger_->debug()) { + logger_->debug("Updating TransferStat of PeerStorage"); } - _lastTransferStatMapUpdated = global::wallclock; - _peerTransferStatMap.clear(); + lastTransferStatMapUpdated_ = global::wallclock; + peerTransferStatMap_.clear(); std::vector<SharedHandle<Peer> > activePeers; getActivePeers(activePeers); for(std::vector<SharedHandle<Peer> >::const_iterator i = @@ -228,33 +228,33 @@ TransferStat DefaultPeerStorage::calculateStat() s.sessionDownloadLength = (*i)->getSessionDownloadLength(); s.sessionUploadLength = (*i)->getSessionUploadLength(); - _peerTransferStatMap[(*i)->getID()] = calculateStatFor(*i); + peerTransferStatMap_[(*i)->getID()] = calculateStatFor(*i); stat += s; } - _cachedTransferStat = stat; + cachedTransferStat_ = stat; } else { - stat = _cachedTransferStat; + stat = cachedTransferStat_; } - stat.sessionDownloadLength += _removedPeerSessionDownloadLength; - stat.sessionUploadLength += _removedPeerSessionUploadLength; - stat.setAllTimeUploadLength(_btRuntime->getUploadLengthAtStartup()+ + stat.sessionDownloadLength += removedPeerSessionDownloadLength_; + stat.sessionUploadLength += removedPeerSessionUploadLength_; + stat.setAllTimeUploadLength(btRuntime_->getUploadLengthAtStartup()+ stat.getSessionUploadLength()); return stat; } void DefaultPeerStorage::updateTransferStatFor(const SharedHandle<Peer>& peer) { - if(_logger->debug()) { - _logger->debug("Updating TransferStat for peer %s", peer->getID().c_str()); + if(logger_->debug()) { + logger_->debug("Updating TransferStat for peer %s", peer->getID().c_str()); } std::map<std::string, TransferStat>::iterator itr = - _peerTransferStatMap.find(peer->getID()); - if(itr == _peerTransferStatMap.end()) { + peerTransferStatMap_.find(peer->getID()); + if(itr == peerTransferStatMap_.end()) { return; } - _cachedTransferStat -= (*itr).second; + cachedTransferStat_ -= (*itr).second; TransferStat s = calculateStatFor(peer); - _cachedTransferStat += s; + cachedTransferStat_ += s; (*itr).second = s; } @@ -262,8 +262,8 @@ TransferStat DefaultPeerStorage::getTransferStatFor (const SharedHandle<Peer>& peer) { std::map<std::string, TransferStat>::const_iterator itr = - _peerTransferStatMap.find(peer->getID()); - if(itr == _peerTransferStatMap.end()) { + peerTransferStatMap_.find(peer->getID()); + if(itr == peerTransferStatMap_.end()) { return TransferStat(); } else { return (*itr).second; @@ -273,7 +273,7 @@ TransferStat DefaultPeerStorage::getTransferStatFor void DefaultPeerStorage::deleteUnusedPeer(size_t delSize) { std::deque<SharedHandle<Peer> > temp; for(std::deque<SharedHandle<Peer> >::const_reverse_iterator itr = - _peers.rbegin(), eoi = _peers.rend(); itr != eoi; ++itr) { + peers_.rbegin(), eoi = peers_.rend(); itr != eoi; ++itr) { const SharedHandle<Peer>& p = *itr; if(p->unused() && delSize > 0) { onErasingPeer(p); @@ -282,7 +282,7 @@ void DefaultPeerStorage::deleteUnusedPeer(size_t delSize) { temp.push_front(p); } } - _peers.swap(temp); + peers_.swap(temp); } void DefaultPeerStorage::onErasingPeer(const SharedHandle<Peer>& peer) {} @@ -291,9 +291,9 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer) { if(peer->isActive()) { TransferStat removedStat(calculateStatFor(peer)); - _removedPeerSessionDownloadLength += removedStat.getSessionDownloadLength(); - _removedPeerSessionUploadLength += removedStat.getSessionUploadLength(); - _cachedTransferStat -= removedStat; + removedPeerSessionDownloadLength_ += removedStat.getSessionDownloadLength(); + removedPeerSessionUploadLength_ += removedStat.getSessionUploadLength(); + cachedTransferStat_ -= removedStat; // Execute choking algorithm if unchoked and interested peer is // disconnected. @@ -306,14 +306,14 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer) void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer) { std::deque<SharedHandle<Peer> >::iterator itr = - std::find(_peers.begin(), _peers.end(), peer); - if(itr == _peers.end()) { - if(_logger->debug()) { - _logger->debug("Cannot find peer %s:%u in PeerStorage.", + std::find(peers_.begin(), peers_.end(), peer); + if(itr == peers_.end()) { + if(logger_->debug()) { + logger_->debug("Cannot find peer %s:%u in PeerStorage.", peer->getIPAddress().c_str(), peer->getPort()); } } else { - _peers.erase(itr); + peers_.erase(itr); onReturningPeer(peer); onErasingPeer(peer); @@ -323,11 +323,11 @@ void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer) bool DefaultPeerStorage::chokeRoundIntervalElapsed() { const time_t CHOKE_ROUND_INTERVAL = 10; - if(_pieceStorage->downloadFinished()) { - return _seederStateChoke->getLastRound(). + if(pieceStorage_->downloadFinished()) { + return seederStateChoke_->getLastRound(). difference(global::wallclock) >= CHOKE_ROUND_INTERVAL; } else { - return _leecherStateChoke->getLastRound(). + return leecherStateChoke_->getLastRound(). difference(global::wallclock) >= CHOKE_ROUND_INTERVAL; } } @@ -336,21 +336,21 @@ void DefaultPeerStorage::executeChoke() { std::vector<SharedHandle<Peer> > activePeers; getActivePeers(activePeers); - if(_pieceStorage->downloadFinished()) { - return _seederStateChoke->executeChoke(activePeers); + if(pieceStorage_->downloadFinished()) { + return seederStateChoke_->executeChoke(activePeers); } else { - return _leecherStateChoke->executeChoke(activePeers); + return leecherStateChoke_->executeChoke(activePeers); } } void DefaultPeerStorage::setPieceStorage(const SharedHandle<PieceStorage>& ps) { - _pieceStorage = ps; + pieceStorage_ = ps; } void DefaultPeerStorage::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } } // namespace aria2 diff --git a/src/DefaultPeerStorage.h b/src/DefaultPeerStorage.h index d4082a1b..44b0159d 100644 --- a/src/DefaultPeerStorage.h +++ b/src/DefaultPeerStorage.h @@ -51,21 +51,21 @@ class PieceStorage; class DefaultPeerStorage : public PeerStorage { private: - SharedHandle<BtRuntime> _btRuntime; - SharedHandle<PieceStorage> _pieceStorage; - std::deque<SharedHandle<Peer> > _peers; - Logger* _logger; - uint64_t _removedPeerSessionDownloadLength; - uint64_t _removedPeerSessionUploadLength; + SharedHandle<BtRuntime> btRuntime_; + SharedHandle<PieceStorage> pieceStorage_; + std::deque<SharedHandle<Peer> > peers_; + Logger* logger_; + uint64_t removedPeerSessionDownloadLength_; + uint64_t removedPeerSessionUploadLength_; - BtSeederStateChoke* _seederStateChoke; - BtLeecherStateChoke* _leecherStateChoke; + BtSeederStateChoke* seederStateChoke_; + BtLeecherStateChoke* leecherStateChoke_; - std::map<std::string, TransferStat> _peerTransferStatMap; + std::map<std::string, TransferStat> peerTransferStatMap_; - Timer _lastTransferStatMapUpdated; + Timer lastTransferStatMapUpdated_; - TransferStat _cachedTransferStat; + TransferStat cachedTransferStat_; bool isPeerAlreadyAdded(const SharedHandle<Peer>& peer); public: diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc index 2cb6a1d4..40e90ca4 100644 --- a/src/DefaultPieceStorage.cc +++ b/src/DefaultPieceStorage.cc @@ -64,44 +64,44 @@ namespace aria2 { DefaultPieceStorage::DefaultPieceStorage (const SharedHandle<DownloadContext>& downloadContext, const Option* option): - _downloadContext(downloadContext), - _bitfieldMan(new BitfieldMan(downloadContext->getPieceLength(), + downloadContext_(downloadContext), + bitfieldMan_(new BitfieldMan(downloadContext->getPieceLength(), downloadContext->getTotalLength())), - _diskWriterFactory(new DefaultDiskWriterFactory()), - _endGamePieceNum(END_GAME_PIECE_NUM), - _logger(LogFactory::getInstance()), - _option(option), - _pieceStatMan(new PieceStatMan(downloadContext->getNumPieces(), true)), - _pieceSelector(new RarestPieceSelector(_pieceStatMan)) + diskWriterFactory_(new DefaultDiskWriterFactory()), + endGamePieceNum_(END_GAME_PIECE_NUM), + logger_(LogFactory::getInstance()), + option_(option), + pieceStatMan_(new PieceStatMan(downloadContext->getNumPieces(), true)), + pieceSelector_(new RarestPieceSelector(pieceStatMan_)) {} DefaultPieceStorage::~DefaultPieceStorage() { - delete _bitfieldMan; + delete bitfieldMan_; } bool DefaultPieceStorage::isEndGame() { - return _bitfieldMan->countMissingBlock() <= _endGamePieceNum; + return bitfieldMan_->countMissingBlock() <= endGamePieceNum_; } bool DefaultPieceStorage::getMissingPieceIndex(size_t& index, const unsigned char* bitfield, size_t length) { - const size_t mislen = _bitfieldMan->getBitfieldLength(); + const size_t mislen = bitfieldMan_->getBitfieldLength(); array_ptr<unsigned char> misbitfield(new unsigned char[mislen]); bool r; if(isEndGame()) { - r = _bitfieldMan->getAllMissingIndexes(misbitfield, mislen, + r = bitfieldMan_->getAllMissingIndexes(misbitfield, mislen, bitfield, length); } else { - r = _bitfieldMan->getAllMissingUnusedIndexes(misbitfield, mislen, + r = bitfieldMan_->getAllMissingUnusedIndexes(misbitfield, mislen, bitfield, length); } if(r) { // We assume indexes is sorted using comparator less. return - _pieceSelector->select(index, misbitfield,_bitfieldMan->countBlock()); + pieceSelector_->select(index, misbitfield,bitfieldMan_->countBlock()); } else { return false; } @@ -109,15 +109,15 @@ bool DefaultPieceStorage::getMissingPieceIndex(size_t& index, SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index) { - _bitfieldMan->setUseBit(index); + bitfieldMan_->setUseBit(index); SharedHandle<Piece> piece = findUsedPiece(index); if(piece.isNull()) { - piece.reset(new Piece(index, _bitfieldMan->getBlockLength(index))); + piece.reset(new Piece(index, bitfieldMan_->getBlockLength(index))); #ifdef ENABLE_MESSAGE_DIGEST - piece->setHashAlgo(_downloadContext->getPieceHashAlgo()); + piece->setHashAlgo(downloadContext_->getPieceHashAlgo()); #endif // ENABLE_MESSAGE_DIGEST @@ -135,10 +135,10 @@ SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index) SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index) { SharedHandle<Piece> piece; - if(0 <= index && index <= _bitfieldMan->getMaxIndex()) { + if(0 <= index && index <= bitfieldMan_->getMaxIndex()) { piece = findUsedPiece(index); if(piece.isNull()) { - piece.reset(new Piece(index, _bitfieldMan->getBlockLength(index))); + piece.reset(new Piece(index, bitfieldMan_->getBlockLength(index))); if(hasPiece(index)) { piece->setAllBlock(); } @@ -150,11 +150,11 @@ SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index) void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece) { std::deque<SharedHandle<Piece> >::iterator i = - std::lower_bound(_usedPieces.begin(), _usedPieces.end(), piece); - _usedPieces.insert(i, piece); - if(_logger->debug()) { - _logger->debug("_usedPieces.size()=%lu", - static_cast<unsigned long>(_usedPieces.size())); + std::lower_bound(usedPieces_.begin(), usedPieces_.end(), piece); + usedPieces_.insert(i, piece); + if(logger_->debug()) { + logger_->debug("usedPieces_.size()=%lu", + static_cast<unsigned long>(usedPieces_.size())); } } @@ -164,8 +164,8 @@ SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const p->setIndex(index); std::deque<SharedHandle<Piece> >::const_iterator i = - std::lower_bound(_usedPieces.begin(), _usedPieces.end(), p); - if(i != _usedPieces.end() && (*i) == p) { + std::lower_bound(usedPieces_.begin(), usedPieces_.end(), p); + if(i != usedPieces_.end() && (*i) == p) { return *i; } else { p.reset(0); @@ -194,7 +194,7 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer) { - return _bitfieldMan->hasMissingPiece(peer->getBitfield(), + return bitfieldMan_->hasMissingPiece(peer->getBitfield(), peer->getBitfieldLength()); } @@ -210,7 +210,7 @@ void DefaultPieceStorage::createFastIndexBitfield for(std::vector<size_t>::const_iterator itr = peer->getPeerAllowedIndexSet().begin(), eoi = peer->getPeerAllowedIndexSet().end(); itr != eoi; ++itr) { - if(!_bitfieldMan->isBitSet(*itr) && peer->hasPiece(*itr)) { + if(!bitfieldMan_->isBitSet(*itr) && peer->hasPiece(*itr)) { bitfield.setBit(*itr); } } @@ -220,8 +220,8 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece (const SharedHandle<Peer>& peer) { if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) { - BitfieldMan tempBitfield(_bitfieldMan->getBlockLength(), - _bitfieldMan->getTotalLength()); + BitfieldMan tempBitfield(bitfieldMan_->getBlockLength(), + bitfieldMan_->getTotalLength()); createFastIndexBitfield(tempBitfield, peer); return getMissingPiece(tempBitfield); } else { @@ -239,8 +239,8 @@ static void unsetExcludedIndexes(BitfieldMan& bitfield, SharedHandle<Piece> DefaultPieceStorage::getMissingPiece (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes) { - BitfieldMan tempBitfield(_bitfieldMan->getBlockLength(), - _bitfieldMan->getTotalLength()); + BitfieldMan tempBitfield(bitfieldMan_->getBlockLength(), + bitfieldMan_->getTotalLength()); tempBitfield.setBitfield(peer->getBitfield(), peer->getBitfieldLength()); unsetExcludedIndexes(tempBitfield, excludedIndexes); return getMissingPiece(tempBitfield); @@ -250,8 +250,8 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes) { if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) { - BitfieldMan tempBitfield(_bitfieldMan->getBlockLength(), - _bitfieldMan->getTotalLength()); + BitfieldMan tempBitfield(bitfieldMan_->getBlockLength(), + bitfieldMan_->getTotalLength()); createFastIndexBitfield(tempBitfield, peer); unsetExcludedIndexes(tempBitfield, excludedIndexes); return getMissingPiece(tempBitfield); @@ -265,14 +265,14 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece bool DefaultPieceStorage::hasMissingUnusedPiece() { size_t index; - return _bitfieldMan->getFirstMissingUnusedIndex(index); + return bitfieldMan_->getFirstMissingUnusedIndex(index); } SharedHandle<Piece> DefaultPieceStorage::getSparseMissingUnusedPiece (const unsigned char* ignoreBitfield, size_t length) { size_t index; - if(_bitfieldMan->getSparseMissingUnusedIndex(index, ignoreBitfield, length)) { + if(bitfieldMan_->getSparseMissingUnusedIndex(index, ignoreBitfield, length)) { return checkOutPiece(index); } else { return SharedHandle<Piece>(); @@ -294,9 +294,9 @@ void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece) return; } std::deque<SharedHandle<Piece> >::iterator i = - std::lower_bound(_usedPieces.begin(), _usedPieces.end(), piece); - if(i != _usedPieces.end() && (*i) == piece) { - _usedPieces.erase(i); + std::lower_bound(usedPieces_.begin(), usedPieces_.end(), piece); + if(i != usedPieces_.end() && (*i) == piece) { + usedPieces_.erase(i); } } @@ -348,25 +348,25 @@ void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece) if(allDownloadFinished()) { return; } - _bitfieldMan->setBit(piece->getIndex()); - _bitfieldMan->unsetUseBit(piece->getIndex()); + bitfieldMan_->setBit(piece->getIndex()); + bitfieldMan_->unsetUseBit(piece->getIndex()); addPieceStats(piece->getIndex()); if(downloadFinished()) { - _downloadContext->resetDownloadStopTime(); + downloadContext_->resetDownloadStopTime(); if(isSelectiveDownloadingMode()) { - _logger->notice(MSG_SELECTIVE_DOWNLOAD_COMPLETED); + logger_->notice(MSG_SELECTIVE_DOWNLOAD_COMPLETED); // following line was commented out in order to stop sending request // message after user-specified files were downloaded. //finishSelectiveDownloadingMode(); } else { - _logger->info(MSG_DOWNLOAD_COMPLETED); + logger_->info(MSG_DOWNLOAD_COMPLETED); } } } bool DefaultPieceStorage::isSelectiveDownloadingMode() { - return _bitfieldMan->isFilterEnabled(); + return bitfieldMan_->isFilterEnabled(); } // not unittested @@ -375,7 +375,7 @@ void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece) if(piece.isNull()) { return; } - _bitfieldMan->unsetUseBit(piece->getIndex()); + bitfieldMan_->unsetUseBit(piece->getIndex()); if(!isEndGame()) { if(piece->getCompletedLength() == 0) { deleteUsedPiece(piece); @@ -385,28 +385,28 @@ void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece) bool DefaultPieceStorage::hasPiece(size_t index) { - return _bitfieldMan->isBitSet(index); + return bitfieldMan_->isBitSet(index); } bool DefaultPieceStorage::isPieceUsed(size_t index) { - return _bitfieldMan->isUseBitSet(index); + return bitfieldMan_->isUseBitSet(index); } uint64_t DefaultPieceStorage::getTotalLength() { - return _bitfieldMan->getTotalLength(); + return bitfieldMan_->getTotalLength(); } uint64_t DefaultPieceStorage::getFilteredTotalLength() { - return _bitfieldMan->getFilteredTotalLength(); + return bitfieldMan_->getFilteredTotalLength(); } uint64_t DefaultPieceStorage::getCompletedLength() { uint64_t completedLength = - _bitfieldMan->getCompletedLength()+getInFlightPieceCompletedLength(); + bitfieldMan_->getCompletedLength()+getInFlightPieceCompletedLength(); uint64_t totalLength = getTotalLength(); if(completedLength > totalLength) { completedLength = totalLength; @@ -416,13 +416,13 @@ uint64_t DefaultPieceStorage::getCompletedLength() uint64_t DefaultPieceStorage::getFilteredCompletedLength() { - return _bitfieldMan->getFilteredCompletedLength()+ + return bitfieldMan_->getFilteredCompletedLength()+ getInFlightPieceCompletedLength(); } size_t DefaultPieceStorage::getInFlightPieceCompletedLength() const { - return std::accumulate(_usedPieces.begin(), _usedPieces.end(), + return std::accumulate(usedPieces_.begin(), usedPieces_.end(), 0, adopt2nd(std::plus<size_t>(), mem_fun_sh(&Piece::getCompletedLength))); } @@ -431,7 +431,7 @@ size_t DefaultPieceStorage::getInFlightPieceCompletedLength() const void DefaultPieceStorage::setupFileFilter() { const std::vector<SharedHandle<FileEntry> >& fileEntries = - _downloadContext->getFileEntries(); + downloadContext_->getFileEntries(); bool allSelected = true; for(std::vector<SharedHandle<FileEntry> >::const_iterator i = fileEntries.begin(), eoi = fileEntries.end(); @@ -447,16 +447,16 @@ void DefaultPieceStorage::setupFileFilter() for(std::vector<SharedHandle<FileEntry> >::const_iterator i = fileEntries.begin(), eoi = fileEntries.end(); i != eoi; ++i) { if((*i)->isRequested()) { - _bitfieldMan->addFilter((*i)->getOffset(), (*i)->getLength()); + bitfieldMan_->addFilter((*i)->getOffset(), (*i)->getLength()); } } - _bitfieldMan->enableFilter(); + bitfieldMan_->enableFilter(); } // not unittested void DefaultPieceStorage::clearFileFilter() { - _bitfieldMan->clearFilter(); + bitfieldMan_->clearFilter(); } // not unittested @@ -464,54 +464,54 @@ bool DefaultPieceStorage::downloadFinished() { // TODO iterate all requested FileEntry and Call // bitfieldMan->isBitSetOffsetRange() - return _bitfieldMan->isFilteredAllBitSet(); + return bitfieldMan_->isFilteredAllBitSet(); } // not unittested bool DefaultPieceStorage::allDownloadFinished() { - return _bitfieldMan->isAllBitSet(); + return bitfieldMan_->isAllBitSet(); } // not unittested void DefaultPieceStorage::initStorage() { - if(_downloadContext->getFileEntries().size() == 1) { - if(_logger->debug()) { - _logger->debug("Instantiating DirectDiskAdaptor"); + if(downloadContext_->getFileEntries().size() == 1) { + if(logger_->debug()) { + logger_->debug("Instantiating DirectDiskAdaptor"); } DirectDiskAdaptorHandle directDiskAdaptor(new DirectDiskAdaptor()); - directDiskAdaptor->setTotalLength(_downloadContext->getTotalLength()); + directDiskAdaptor->setTotalLength(downloadContext_->getTotalLength()); directDiskAdaptor->setFileEntries - (_downloadContext->getFileEntries().begin(), - _downloadContext->getFileEntries().end()); + (downloadContext_->getFileEntries().begin(), + downloadContext_->getFileEntries().end()); DiskWriterHandle writer = - _diskWriterFactory->newDiskWriter(directDiskAdaptor->getFilePath()); - if(_option->getAsBool(PREF_ENABLE_DIRECT_IO)) { + diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath()); + if(option_->getAsBool(PREF_ENABLE_DIRECT_IO)) { writer->allowDirectIO(); } directDiskAdaptor->setDiskWriter(writer); - _diskAdaptor = directDiskAdaptor; + diskAdaptor_ = directDiskAdaptor; } else { - if(_logger->debug()) { - _logger->debug("Instantiating MultiDiskAdaptor"); + if(logger_->debug()) { + logger_->debug("Instantiating MultiDiskAdaptor"); } MultiDiskAdaptorHandle multiDiskAdaptor(new MultiDiskAdaptor()); - multiDiskAdaptor->setFileEntries(_downloadContext->getFileEntries().begin(), - _downloadContext->getFileEntries().end()); - if(_option->getAsBool(PREF_ENABLE_DIRECT_IO)) { + multiDiskAdaptor->setFileEntries(downloadContext_->getFileEntries().begin(), + downloadContext_->getFileEntries().end()); + if(option_->getAsBool(PREF_ENABLE_DIRECT_IO)) { multiDiskAdaptor->allowDirectIO(); } - multiDiskAdaptor->setPieceLength(_downloadContext->getPieceLength()); + multiDiskAdaptor->setPieceLength(downloadContext_->getPieceLength()); multiDiskAdaptor->setMaxOpenFiles - (_option->getAsInt(PREF_BT_MAX_OPEN_FILES)); - _diskAdaptor = multiDiskAdaptor; + (option_->getAsInt(PREF_BT_MAX_OPEN_FILES)); + diskAdaptor_ = multiDiskAdaptor; } #ifdef HAVE_POSIX_FALLOCATE - if(_option->get(PREF_FILE_ALLOCATION) == V_FALLOC) { - _diskAdaptor->enableFallocate(); + if(option_->get(PREF_FILE_ALLOCATION) == V_FALLOC) { + diskAdaptor_->enableFallocate(); } #endif // HAVE_POSIX_FALLOCATE } @@ -519,33 +519,33 @@ void DefaultPieceStorage::initStorage() void DefaultPieceStorage::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) { - _bitfieldMan->setBitfield(bitfield, bitfieldLength); + bitfieldMan_->setBitfield(bitfield, bitfieldLength); addPieceStats(bitfield, bitfieldLength); } size_t DefaultPieceStorage::getBitfieldLength() { - return _bitfieldMan->getBitfieldLength(); + return bitfieldMan_->getBitfieldLength(); } const unsigned char* DefaultPieceStorage::getBitfield() { - return _bitfieldMan->getBitfield(); + return bitfieldMan_->getBitfield(); } DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() { - return _diskAdaptor; + return diskAdaptor_; } size_t DefaultPieceStorage::getPieceLength(size_t index) { - return _bitfieldMan->getBlockLength(index); + return bitfieldMan_->getBlockLength(index); } void DefaultPieceStorage::advertisePiece(cuid_t cuid, size_t index) { HaveEntry entry(cuid, index, global::wallclock); - _haves.push_front(entry); + haves_.push_front(entry); } void @@ -553,8 +553,8 @@ DefaultPieceStorage::getAdvertisedPieceIndexes(std::vector<size_t>& indexes, cuid_t myCuid, const Timer& lastCheckTime) { - for(std::deque<HaveEntry>::const_iterator itr = _haves.begin(), - eoi = _haves.end(); itr != eoi; ++itr) { + for(std::deque<HaveEntry>::const_iterator itr = haves_.begin(), + eoi = haves_.end(); itr != eoi; ++itr) { const HaveEntry& have = *itr; if(have.getCuid() == myCuid) { continue; @@ -585,37 +585,37 @@ public: void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed) { std::deque<HaveEntry>::iterator itr = - std::find_if(_haves.begin(), _haves.end(), FindElapsedHave(elapsed)); - if(itr != _haves.end()) { - if(_logger->debug()) { - _logger->debug(MSG_REMOVED_HAVE_ENTRY, _haves.end()-itr); + std::find_if(haves_.begin(), haves_.end(), FindElapsedHave(elapsed)); + if(itr != haves_.end()) { + if(logger_->debug()) { + logger_->debug(MSG_REMOVED_HAVE_ENTRY, haves_.end()-itr); } - _haves.erase(itr, _haves.end()); + haves_.erase(itr, haves_.end()); } } void DefaultPieceStorage::markAllPiecesDone() { - _bitfieldMan->setAllBit(); + bitfieldMan_->setAllBit(); } void DefaultPieceStorage::markPiecesDone(uint64_t length) { - if(length == _bitfieldMan->getTotalLength()) { - _bitfieldMan->setAllBit(); + if(length == bitfieldMan_->getTotalLength()) { + bitfieldMan_->setAllBit(); } else if(length == 0) { // TODO this would go to markAllPiecesUndone() - _bitfieldMan->clearAllBit(); - _usedPieces.clear(); + bitfieldMan_->clearAllBit(); + usedPieces_.clear(); } else { - size_t numPiece = length/_bitfieldMan->getBlockLength(); + size_t numPiece = length/bitfieldMan_->getBlockLength(); if(numPiece > 0) { - _bitfieldMan->setBitRange(0, numPiece-1); + bitfieldMan_->setBitRange(0, numPiece-1); } - size_t r = (length%_bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH; + size_t r = (length%bitfieldMan_->getBlockLength())/Piece::BLOCK_LENGTH; if(r > 0) { SharedHandle<Piece> p - (new Piece(numPiece, _bitfieldMan->getBlockLength(numPiece))); + (new Piece(numPiece, bitfieldMan_->getBlockLength(numPiece))); for(size_t i = 0; i < r; ++i) { p->completeBlock(i); @@ -623,7 +623,7 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length) #ifdef ENABLE_MESSAGE_DIGEST - p->setHashAlgo(_downloadContext->getPieceHashAlgo()); + p->setHashAlgo(downloadContext_->getPieceHashAlgo()); #endif // ENABLE_MESSAGE_DIGEST @@ -634,56 +634,56 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length) void DefaultPieceStorage::markPieceMissing(size_t index) { - _bitfieldMan->unsetBit(index); + bitfieldMan_->unsetBit(index); } void DefaultPieceStorage::addInFlightPiece (const std::vector<SharedHandle<Piece> >& pieces) { - _usedPieces.insert(_usedPieces.end(), pieces.begin(), pieces.end()); - std::sort(_usedPieces.begin(), _usedPieces.end()); + usedPieces_.insert(usedPieces_.end(), pieces.begin(), pieces.end()); + std::sort(usedPieces_.begin(), usedPieces_.end()); } size_t DefaultPieceStorage::countInFlightPiece() { - return _usedPieces.size(); + return usedPieces_.size(); } void DefaultPieceStorage::getInFlightPieces (std::vector<SharedHandle<Piece> >& pieces) { - pieces.insert(pieces.end(), _usedPieces.begin(), _usedPieces.end()); + pieces.insert(pieces.end(), usedPieces_.begin(), usedPieces_.end()); } void DefaultPieceStorage::setDiskWriterFactory (const DiskWriterFactoryHandle& diskWriterFactory) { - _diskWriterFactory = diskWriterFactory; + diskWriterFactory_ = diskWriterFactory; } void DefaultPieceStorage::addPieceStats(const unsigned char* bitfield, size_t bitfieldLength) { - _pieceStatMan->addPieceStats(bitfield, bitfieldLength); + pieceStatMan_->addPieceStats(bitfield, bitfieldLength); } void DefaultPieceStorage::subtractPieceStats(const unsigned char* bitfield, size_t bitfieldLength) { - _pieceStatMan->subtractPieceStats(bitfield, bitfieldLength); + pieceStatMan_->subtractPieceStats(bitfield, bitfieldLength); } void DefaultPieceStorage::updatePieceStats(const unsigned char* newBitfield, size_t newBitfieldLength, const unsigned char* oldBitfield) { - _pieceStatMan->updatePieceStats(newBitfield, newBitfieldLength, + pieceStatMan_->updatePieceStats(newBitfield, newBitfieldLength, oldBitfield); } void DefaultPieceStorage::addPieceStats(size_t index) { - _pieceStatMan->addPieceStats(index); + pieceStatMan_->addPieceStats(index); } } // namespace aria2 diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h index ab3d5457..f282deb4 100644 --- a/src/DefaultPieceStorage.h +++ b/src/DefaultPieceStorage.h @@ -54,38 +54,38 @@ class PieceSelector; class HaveEntry { private: - cuid_t _cuid; - size_t _index; - Timer _registeredTime; + cuid_t cuid_; + size_t index_; + Timer registeredTime_; public: HaveEntry(cuid_t cuid, size_t index, const Timer& registeredTime): - _cuid(cuid), - _index(index), - _registeredTime(registeredTime) {} + cuid_(cuid), + index_(index), + registeredTime_(registeredTime) {} - cuid_t getCuid() const { return _cuid; } + cuid_t getCuid() const { return cuid_; } - size_t getIndex() const { return _index; } + size_t getIndex() const { return index_; } - const Timer& getRegisteredTime() const { return _registeredTime; } + const Timer& getRegisteredTime() const { return registeredTime_; } }; class DefaultPieceStorage : public PieceStorage { private: - SharedHandle<DownloadContext> _downloadContext; - BitfieldMan* _bitfieldMan; - SharedHandle<DiskAdaptor> _diskAdaptor; - SharedHandle<DiskWriterFactory> _diskWriterFactory; - std::deque<SharedHandle<Piece> > _usedPieces; + SharedHandle<DownloadContext> downloadContext_; + BitfieldMan* bitfieldMan_; + SharedHandle<DiskAdaptor> diskAdaptor_; + SharedHandle<DiskWriterFactory> diskWriterFactory_; + std::deque<SharedHandle<Piece> > usedPieces_; - size_t _endGamePieceNum; - Logger* _logger; - const Option* _option; - std::deque<HaveEntry> _haves; + size_t endGamePieceNum_; + Logger* logger_; + const Option* option_; + std::deque<HaveEntry> haves_; - SharedHandle<PieceStatMan> _pieceStatMan; + SharedHandle<PieceStatMan> pieceStatMan_; - SharedHandle<PieceSelector> _pieceSelector; + SharedHandle<PieceSelector> pieceSelector_; bool getMissingPieceIndex(size_t& index, const unsigned char* bitfield, size_t length); @@ -178,11 +178,11 @@ public: virtual const unsigned char* getBitfield(); virtual void setEndGamePieceNum(size_t num) { - _endGamePieceNum = num; + endGamePieceNum_ = num; } size_t getEndGamePieceNum() const { - return _endGamePieceNum; + return endGamePieceNum_; } virtual bool isSelectiveDownloadingMode(); @@ -237,17 +237,17 @@ public: const SharedHandle<PieceStatMan>& getPieceStatMan() const { - return _pieceStatMan; + return pieceStatMan_; } void setPieceSelector(const SharedHandle<PieceSelector>& pieceSelector) { - _pieceSelector = pieceSelector; + pieceSelector_ = pieceSelector; } const SharedHandle<PieceSelector>& getPieceSelector() const { - return _pieceSelector; + return pieceSelector_; } }; diff --git a/src/DiskAdaptor.cc b/src/DiskAdaptor.cc index 54e1e1b4..8c910c5f 100644 --- a/src/DiskAdaptor.cc +++ b/src/DiskAdaptor.cc @@ -41,8 +41,8 @@ namespace aria2 { DiskAdaptor::DiskAdaptor(): #ifdef HAVE_POSIX_FALLOCATE - _fallocate(false), + fallocate_(false), #endif // HAVE_POSIX_FALLOCATE - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} } // namespace aria2 diff --git a/src/DiskAdaptor.h b/src/DiskAdaptor.h index e3473c9b..8dde24ea 100644 --- a/src/DiskAdaptor.h +++ b/src/DiskAdaptor.h @@ -50,15 +50,15 @@ class FileAllocationIterator; class DiskAdaptor:public BinaryStream { private: - std::vector<SharedHandle<FileEntry> > _fileEntries; + std::vector<SharedHandle<FileEntry> > fileEntries_; #ifdef HAVE_POSIX_FALLOCATE - bool _fallocate; + bool fallocate_; #endif // HAVE_POSIX_FALLOCATE - Logger* _logger; + Logger* logger_; protected: Logger* getLogger() const { - return _logger; + return logger_; } public: DiskAdaptor(); @@ -79,12 +79,12 @@ public: template<typename InputIterator> void setFileEntries(InputIterator first, InputIterator last) { - _fileEntries.assign(first, last); + fileEntries_.assign(first, last); } const std::vector<SharedHandle<FileEntry> >& getFileEntries() const { - return _fileEntries; + return fileEntries_; } virtual SharedHandle<FileAllocationIterator> fileAllocationIterator() = 0; @@ -113,17 +113,17 @@ public: #ifdef HAVE_POSIX_FALLOCATE void enableFallocate() { - _fallocate = true; + fallocate_ = true; } void disableFallocate() { - _fallocate = false; + fallocate_ = false; } bool doesFallocate() const { - return _fallocate; + return fallocate_; } #endif // HAVE_POSIX_FALLOCATE }; diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc index a9cfd24a..122cf26a 100644 --- a/src/DownloadCommand.cc +++ b/src/DownloadCommand.cc @@ -76,11 +76,11 @@ DownloadCommand::DownloadCommand(cuid_t cuid, DownloadEngine* e, const SocketHandle& s): AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - _buf(new unsigned char[BUFSIZE]), - _startupIdleTime(10), - _lowestDownloadSpeedLimit(0) + buf_(new unsigned char[BUFSIZE]), + startupIdleTime_(10), + lowestDownloadSpeedLimit_(0) #ifdef ENABLE_MESSAGE_DIGEST - , _pieceHashValidationEnabled(false) + , pieceHashValidationEnabled_(false) #endif // ENABLE_MESSAGE_DIGEST { #ifdef ENABLE_MESSAGE_DIGEST @@ -88,25 +88,25 @@ DownloadCommand::DownloadCommand(cuid_t cuid, if(getOption()->getAsBool(PREF_REALTIME_CHUNK_CHECKSUM)) { const std::string& algo = getDownloadContext()->getPieceHashAlgo(); if(MessageDigestContext::supports(algo)) { - _messageDigestContext.reset(new MessageDigestContext()); - _messageDigestContext->trySetAlgo(algo); - _messageDigestContext->digestInit(); + messageDigestContext_.reset(new MessageDigestContext()); + messageDigestContext_->trySetAlgo(algo); + messageDigestContext_->digestInit(); - _pieceHashValidationEnabled = true; + pieceHashValidationEnabled_ = true; } } } #endif // ENABLE_MESSAGE_DIGEST - _peerStat = req->initPeerStat(); - _peerStat->downloadStart(); - getSegmentMan()->registerPeerStat(_peerStat); + peerStat_ = req->initPeerStat(); + peerStat_->downloadStart(); + getSegmentMan()->registerPeerStat(peerStat_); } DownloadCommand::~DownloadCommand() { - _peerStat->downloadStop(); - getSegmentMan()->updateFastestPeerStat(_peerStat); - delete [] _buf; + peerStat_->downloadStop(); + getSegmentMan()->updateFastestPeerStat(peerStat_); + delete [] buf_; } bool DownloadCommand::executeInternal() { @@ -135,7 +135,7 @@ bool DownloadCommand::executeInternal() { } else { bufSize = BUFSIZE; } - getSocket()->readData(_buf, bufSize); + getSocket()->readData(buf_, bufSize); const SharedHandle<DiskAdaptor>& diskAdaptor = getPieceStorage()->getDiskAdaptor(); @@ -144,21 +144,21 @@ bool DownloadCommand::executeInternal() { size_t bufSizeFinal; std::string decoded; - if(_transferEncodingDecoder.isNull()) { - bufFinal = _buf; + if(transferEncodingDecoder_.isNull()) { + bufFinal = buf_; bufSizeFinal = bufSize; } else { - decoded = _transferEncodingDecoder->decode(_buf, bufSize); + decoded = transferEncodingDecoder_->decode(buf_, bufSize); bufFinal = reinterpret_cast<const unsigned char*>(decoded.c_str()); bufSizeFinal = decoded.size(); } - if(_contentEncodingDecoder.isNull()) { + if(contentEncodingDecoder_.isNull()) { diskAdaptor->writeData(bufFinal, bufSizeFinal, segment->getPositionToWrite()); } else { - std::string out = _contentEncodingDecoder->decode(bufFinal, bufSizeFinal); + std::string out = contentEncodingDecoder_->decode(bufFinal, bufSizeFinal); diskAdaptor->writeData(reinterpret_cast<const unsigned char*>(out.data()), out.size(), segment->getPositionToWrite()); @@ -167,7 +167,7 @@ bool DownloadCommand::executeInternal() { #ifdef ENABLE_MESSAGE_DIGEST - if(_pieceHashValidationEnabled) { + if(pieceHashValidationEnabled_) { segment->updateHash(segment->getWrittenLength(), bufFinal, bufSizeFinal); } @@ -175,11 +175,11 @@ bool DownloadCommand::executeInternal() { if(bufSizeFinal > 0) { segment->updateWrittenLength(bufSizeFinal); } - _peerStat->updateDownloadLength(bufSize); - 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(transferEncodingDecoder_.isNull() && contentEncodingDecoder_.isNull()) { if(segment->complete() || segment->getPositionToWrite() == getFileEntry()->getLastOffset()) { segmentPartComplete = true; @@ -187,16 +187,16 @@ bool DownloadCommand::executeInternal() { !getSocket()->wantRead() && !getSocket()->wantWrite()) { segmentPartComplete = true; } - } else if(!_transferEncodingDecoder.isNull() && + } else if(!transferEncodingDecoder_.isNull() && (segment->complete() || segment->getPositionToWrite() == getFileEntry()->getLastOffset())){ // In this case, transferEncodingDecoder is used and // Content-Length is known. segmentPartComplete = true; - } else if((_transferEncodingDecoder.isNull() || - _transferEncodingDecoder->finished()) && - (_contentEncodingDecoder.isNull() || - _contentEncodingDecoder->finished())) { + } else if((transferEncodingDecoder_.isNull() || + transferEncodingDecoder_->finished()) && + (contentEncodingDecoder_.isNull() || + contentEncodingDecoder_->finished())) { segmentPartComplete = true; } @@ -219,7 +219,7 @@ bool DownloadCommand::executeInternal() { { const std::string& expectedPieceHash = getDownloadContext()->getPieceHash(segment->getIndex()); - if(_pieceHashValidationEnabled && !expectedPieceHash.empty()) { + if(pieceHashValidationEnabled_ && !expectedPieceHash.empty()) { if(segment->isHashCalculated()) { if(getLogger()->debug()) { getLogger()->debug @@ -229,11 +229,11 @@ bool DownloadCommand::executeInternal() { validatePieceHash (segment, expectedPieceHash, segment->getHashString()); } else { - _messageDigestContext->digestReset(); + messageDigestContext_->digestReset(); validatePieceHash (segment, expectedPieceHash, MessageDigestHelper::digest - (_messageDigestContext.get(), + (messageDigestContext_.get(), getPieceStorage()->getDiskAdaptor(), segment->getPosition(), segment->getLength())); @@ -266,13 +266,13 @@ 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, + lowestDownloadSpeedLimit_, getRequest()->getHost().c_str()).str(), downloadresultcode::TOO_SLOW_DOWNLOAD_SPEED); } @@ -357,13 +357,13 @@ void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment, void DownloadCommand::setTransferEncodingDecoder (const SharedHandle<Decoder>& decoder) { - this->_transferEncodingDecoder = decoder; + this->transferEncodingDecoder_ = decoder; } void DownloadCommand::setContentEncodingDecoder (const SharedHandle<Decoder>& decoder) { - _contentEncodingDecoder = decoder; + contentEncodingDecoder_ = decoder; } } // namespace aria2 diff --git a/src/DownloadCommand.h b/src/DownloadCommand.h index 1abe4b58..9e55784a 100644 --- a/src/DownloadCommand.h +++ b/src/DownloadCommand.h @@ -47,17 +47,17 @@ class MessageDigestContext; class DownloadCommand : public AbstractCommand { private: - unsigned char* _buf; + 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 - bool _pieceHashValidationEnabled; + bool pieceHashValidationEnabled_; - SharedHandle<MessageDigestContext> _messageDigestContext; + SharedHandle<MessageDigestContext> messageDigestContext_; #endif // ENABLE_MESSAGE_DIGEST @@ -67,9 +67,9 @@ private: void checkLowestDownloadSpeed() const; - SharedHandle<Decoder> _transferEncodingDecoder; + SharedHandle<Decoder> transferEncodingDecoder_; - SharedHandle<Decoder> _contentEncodingDecoder; + SharedHandle<Decoder> contentEncodingDecoder_; protected: virtual bool executeInternal(); @@ -85,26 +85,26 @@ public: const SharedHandle<Decoder>& getTransferEncodingDecoder() const { - return _transferEncodingDecoder; + return transferEncodingDecoder_; } void setTransferEncodingDecoder(const SharedHandle<Decoder>& decoder); const SharedHandle<Decoder>& getContentEncodingDecoder() const { - return _contentEncodingDecoder; + return contentEncodingDecoder_; } void setContentEncodingDecoder(const SharedHandle<Decoder>& decoder); void setStartupIdleTime(time_t startupIdleTime) { - _startupIdleTime = startupIdleTime; + startupIdleTime_ = startupIdleTime; } void setLowestDownloadSpeedLimit(unsigned int lowestDownloadSpeedLimit) { - _lowestDownloadSpeedLimit = lowestDownloadSpeedLimit; + lowestDownloadSpeedLimit_ = lowestDownloadSpeedLimit; } }; diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc index f14dd6e5..b79a5270 100644 --- a/src/DownloadContext.cc +++ b/src/DownloadContext.cc @@ -45,43 +45,43 @@ namespace aria2 { DownloadContext::DownloadContext(): - _dir(A2STR::DOT_C), - _pieceLength(0), - _knowsTotalLength(true), - _ownerRequestGroup(0), - _downloadStartTime(0), - _downloadStopTime(_downloadStartTime) {} + dir_(A2STR::DOT_C), + pieceLength_(0), + knowsTotalLength_(true), + ownerRequestGroup_(0), + downloadStartTime_(0), + downloadStopTime_(downloadStartTime_) {} DownloadContext::DownloadContext(size_t pieceLength, uint64_t totalLength, const std::string& path): - _dir(A2STR::DOT_C), - _pieceLength(pieceLength), - _knowsTotalLength(true), - _ownerRequestGroup(0), - _downloadStartTime(0), - _downloadStopTime(0) + dir_(A2STR::DOT_C), + pieceLength_(pieceLength), + knowsTotalLength_(true), + ownerRequestGroup_(0), + downloadStartTime_(0), + downloadStopTime_(0) { SharedHandle<FileEntry> fileEntry(new FileEntry(path, totalLength, 0)); - _fileEntries.push_back(fileEntry); + fileEntries_.push_back(fileEntry); } void DownloadContext::resetDownloadStartTime() { - _downloadStartTime = global::wallclock; - _downloadStopTime.reset(0); + downloadStartTime_ = global::wallclock; + downloadStopTime_.reset(0); } void DownloadContext::resetDownloadStopTime() { - _downloadStopTime = global::wallclock; + downloadStopTime_ = global::wallclock; } int64_t DownloadContext::calculateSessionTime() const { - if(_downloadStopTime > _downloadStartTime) { + if(downloadStopTime_ > downloadStartTime_) { return - _downloadStartTime.differenceInMillis(_downloadStopTime); + downloadStartTime_.differenceInMillis(downloadStopTime_); } else { return 0; } @@ -90,9 +90,9 @@ int64_t DownloadContext::calculateSessionTime() const SharedHandle<FileEntry> DownloadContext::findFileEntryByOffset(off_t offset) const { - if(_fileEntries.empty() || + if(fileEntries_.empty() || (offset > 0 && - _fileEntries.back()->getOffset()+_fileEntries.back()->getLength() <= + fileEntries_.back()->getOffset()+fileEntries_.back()->getLength() <= static_cast<uint64_t>(offset))){ return SharedHandle<FileEntry>(); } @@ -100,8 +100,8 @@ DownloadContext::findFileEntryByOffset(off_t offset) const SharedHandle<FileEntry> obj(new FileEntry()); obj->setOffset(offset); std::vector<SharedHandle<FileEntry> >::const_iterator i = - std::upper_bound(_fileEntries.begin(), _fileEntries.end(), obj); - if(i != _fileEntries.end() && (*i)->getOffset() == offset) { + std::upper_bound(fileEntries_.begin(), fileEntries_.end(), obj); + if(i != fileEntries_.end() && (*i)->getOffset() == offset) { return *i; } else { return *(--i); @@ -111,9 +111,9 @@ DownloadContext::findFileEntryByOffset(off_t offset) const void DownloadContext::setFilePathWithIndex (size_t index, const std::string& path) { - if(0 < index && index <= _fileEntries.size()) { + if(0 < index && index <= fileEntries_.size()) { // We don't escape path because path may come from users. - _fileEntries[index-1]->setPath(path); + fileEntries_[index-1]->setPath(path); } else { throw DL_ABORT_EX(StringFormat("No such file with index=%u", static_cast<unsigned int>(index)).str()); @@ -127,11 +127,11 @@ void DownloadContext::setFileFilter(IntSequence seq) fileIndexes.erase(std::unique(fileIndexes.begin(), fileIndexes.end()), fileIndexes.end()); - bool selectAll = fileIndexes.empty() || _fileEntries.size() == 1; + bool selectAll = fileIndexes.empty() || fileEntries_.size() == 1; int32_t index = 1; for(std::vector<SharedHandle<FileEntry> >::const_iterator i = - _fileEntries.begin(), eoi = _fileEntries.end(); + fileEntries_.begin(), eoi = fileEntries_.end(); i != eoi; ++i, ++index) { (*i)->setRequested (selectAll || @@ -145,7 +145,7 @@ void DownloadContext::setAttribute std::map<std::string, SharedHandle<ContextAttribute> >::value_type p = std::make_pair(key, value); std::pair<std::map<std::string, SharedHandle<ContextAttribute> >::iterator, - bool> r = _attrs.insert(p); + bool> r = attrs_.insert(p); if(!r.second) { (*r.first).second = value; } @@ -155,8 +155,8 @@ const SharedHandle<ContextAttribute>& DownloadContext::getAttribute (const std::string& key) { std::map<std::string, SharedHandle<ContextAttribute> >::const_iterator itr = - _attrs.find(key); - if(itr == _attrs.end()) { + attrs_.find(key); + if(itr == attrs_.end()) { throw DL_ABORT_EX(StringFormat("No attribute named %s", key.c_str()).str()); } else { return (*itr).second; @@ -165,43 +165,43 @@ const SharedHandle<ContextAttribute>& DownloadContext::getAttribute bool DownloadContext::hasAttribute(const std::string& key) const { - return _attrs.count(key) == 1; + return attrs_.count(key) == 1; } void DownloadContext::releaseRuntimeResource() { for(std::vector<SharedHandle<FileEntry> >::const_iterator i = - _fileEntries.begin(), eoi = _fileEntries.end(); i != eoi; ++i) { + fileEntries_.begin(), eoi = fileEntries_.end(); i != eoi; ++i) { (*i)->releaseRuntimeResource(); } } size_t DownloadContext::getNumPieces() const { - if(_pieceLength == 0) { + if(pieceLength_ == 0) { return 0; } else { - assert(!_fileEntries.empty()); - return (_fileEntries.back()->getLastOffset()+_pieceLength-1)/_pieceLength; + assert(!fileEntries_.empty()); + return (fileEntries_.back()->getLastOffset()+pieceLength_-1)/pieceLength_; } } uint64_t DownloadContext::getTotalLength() const { - if(_fileEntries.empty()) { + if(fileEntries_.empty()) { return 0; } else { - return _fileEntries.back()->getLastOffset(); + return fileEntries_.back()->getLastOffset(); } } const std::string& DownloadContext::getBasePath() const { - if(_basePath.empty()) { - assert(!_fileEntries.empty()); + if(basePath_.empty()) { + assert(!fileEntries_.empty()); return getFirstFileEntry()->getPath(); } else { - return _basePath; + return basePath_; } } diff --git a/src/DownloadContext.h b/src/DownloadContext.h index e40ea4e2..edf70227 100644 --- a/src/DownloadContext.h +++ b/src/DownloadContext.h @@ -57,33 +57,33 @@ class RequestGroup; class DownloadContext { private: - std::vector<SharedHandle<FileEntry> > _fileEntries; + std::vector<SharedHandle<FileEntry> > fileEntries_; - std::string _dir; + std::string dir_; - std::vector<std::string> _pieceHashes; + std::vector<std::string> pieceHashes_; - size_t _pieceLength; + size_t pieceLength_; - std::string _pieceHashAlgo; + std::string pieceHashAlgo_; - std::string _checksum; + std::string checksum_; - std::string _checksumHashAlgo; + std::string checksumHashAlgo_; - std::string _basePath; + std::string basePath_; - bool _knowsTotalLength; + bool knowsTotalLength_; - RequestGroup* _ownerRequestGroup; + RequestGroup* ownerRequestGroup_; - std::map<std::string, SharedHandle<ContextAttribute> > _attrs; + std::map<std::string, SharedHandle<ContextAttribute> > attrs_; - Timer _downloadStartTime; + Timer downloadStartTime_; - Timer _downloadStopTime; + Timer downloadStopTime_; - SharedHandle<Signature> _signature; + SharedHandle<Signature> signature_; public: DownloadContext(); @@ -95,8 +95,8 @@ public: const std::string& getPieceHash(size_t index) const { - if(index < _pieceHashes.size()) { - return _pieceHashes[index]; + if(index < pieceHashes_.size()) { + return pieceHashes_[index]; } else { return A2STR::NIL; } @@ -104,91 +104,91 @@ public: const std::vector<std::string>& getPieceHashes() const { - return _pieceHashes; + return pieceHashes_; } template<typename InputIterator> void setPieceHashes(InputIterator first, InputIterator last) { - _pieceHashes.assign(first, last); + pieceHashes_.assign(first, last); } uint64_t getTotalLength() const; - bool knowsTotalLength() const { return _knowsTotalLength; } + bool knowsTotalLength() const { return knowsTotalLength_; } - void markTotalLengthIsUnknown() { _knowsTotalLength = false; } + void markTotalLengthIsUnknown() { knowsTotalLength_ = false; } - void markTotalLengthIsKnown() { _knowsTotalLength = true; } + void markTotalLengthIsKnown() { knowsTotalLength_ = true; } const std::vector<SharedHandle<FileEntry> >& getFileEntries() const { - return _fileEntries; + return fileEntries_; } const SharedHandle<FileEntry>& getFirstFileEntry() const { - assert(!_fileEntries.empty()); - return _fileEntries[0]; + assert(!fileEntries_.empty()); + return fileEntries_[0]; } template<typename InputIterator> void setFileEntries(InputIterator first, InputIterator last) { - _fileEntries.assign(first, last); + fileEntries_.assign(first, last); } - size_t getPieceLength() const { return _pieceLength; } + size_t getPieceLength() const { return pieceLength_; } - void setPieceLength(size_t length) { _pieceLength = length; } + void setPieceLength(size_t length) { pieceLength_ = length; } size_t getNumPieces() const; - const std::string& getPieceHashAlgo() const { return _pieceHashAlgo; } + const std::string& getPieceHashAlgo() const { return pieceHashAlgo_; } void setPieceHashAlgo(const std::string& algo) { - _pieceHashAlgo = algo; + pieceHashAlgo_ = algo; } - const std::string& getChecksum() const { return _checksum; } + const std::string& getChecksum() const { return checksum_; } void setChecksum(const std::string& checksum) { - _checksum = checksum; + checksum_ = checksum; } - const std::string& getChecksumHashAlgo() const { return _checksumHashAlgo; } + const std::string& getChecksumHashAlgo() const { return checksumHashAlgo_; } void setChecksumHashAlgo(const std::string& algo) { - _checksumHashAlgo = algo; + checksumHashAlgo_ = algo; } // The representative path name for this context. It is used as a - // part of .aria2 control file. If _basePath is set, returns - // _basePath. Otherwise, the first FileEntry's getFilePath() is + // part of .aria2 control file. If basePath_ is set, returns + // basePath_. Otherwise, the first FileEntry's getFilePath() is // returned. const std::string& getBasePath() const; - void setBasePath(const std::string& basePath) { _basePath = basePath; } + void setBasePath(const std::string& basePath) { basePath_ = basePath; } - const std::string& getDir() const { return _dir; } + const std::string& getDir() const { return dir_; } - void setDir(const std::string& dir) { _dir = dir; } + void setDir(const std::string& dir) { dir_ = dir; } - const SharedHandle<Signature>& getSignature() const { return _signature; } + const SharedHandle<Signature>& getSignature() const { return signature_; } void setSignature(const SharedHandle<Signature>& signature) { - _signature = signature; + signature_ = signature; } - RequestGroup* getOwnerRequestGroup() { return _ownerRequestGroup; } + RequestGroup* getOwnerRequestGroup() { return ownerRequestGroup_; } void setOwnerRequestGroup(RequestGroup* owner) { - _ownerRequestGroup = owner; + ownerRequestGroup_ = owner; } void setFileFilter(IntSequence seq); @@ -213,7 +213,7 @@ public: const Timer& getDownloadStopTime() const { - return _downloadStopTime; + return downloadStopTime_; } int64_t calculateSessionTime() const; diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc index 89580d00..009b0c19 100644 --- a/src/DownloadEngine.cc +++ b/src/DownloadEngine.cc @@ -90,20 +90,20 @@ volatile sig_atomic_t globalHaltRequested = 0; } // namespace global DownloadEngine::DownloadEngine(const SharedHandle<EventPoll>& eventPoll): - _eventPoll(eventPoll), - _logger(LogFactory::getInstance()), - _haltRequested(false), - _noWait(false), - _refreshInterval(DEFAULT_REFRESH_INTERVAL), - _cookieStorage(new CookieStorage()), + eventPoll_(eventPoll), + logger_(LogFactory::getInstance()), + haltRequested_(false), + noWait_(false), + refreshInterval_(DEFAULT_REFRESH_INTERVAL), + cookieStorage_(new CookieStorage()), #ifdef ENABLE_BITTORRENT - _btRegistry(new BtRegistry()), + btRegistry_(new BtRegistry()), #endif // ENABLE_BITTORRENT - _dnsCache(new DNSCache()) + dnsCache_(new DNSCache()) { unsigned char sessionId[20]; util::generateRandomKey(sessionId); - _sessionId = std::string(&sessionId[0], & sessionId[sizeof(sessionId)]); + sessionId_ = std::string(&sessionId[0], & sessionId[sizeof(sessionId)]); } DownloadEngine::~DownloadEngine() { @@ -111,8 +111,8 @@ DownloadEngine::~DownloadEngine() { } void DownloadEngine::cleanQueue() { - std::for_each(_commands.begin(), _commands.end(), Deleter()); - _commands.clear(); + std::for_each(commands_.begin(), commands_.end(), Deleter()); + commands_.clear(); } static void executeCommand(std::deque<Command*>& commands, @@ -141,21 +141,21 @@ void DownloadEngine::run() { Timer cp; cp.reset(0); - while(!_commands.empty() || !_routineCommands.empty()) { + while(!commands_.empty() || !routineCommands_.empty()) { global::wallclock.reset(); - if(cp.difference(global::wallclock) >= _refreshInterval) { - _refreshInterval = DEFAULT_REFRESH_INTERVAL; + if(cp.difference(global::wallclock) >= refreshInterval_) { + refreshInterval_ = DEFAULT_REFRESH_INTERVAL; cp = global::wallclock; - executeCommand(_commands, Command::STATUS_ALL); + executeCommand(commands_, Command::STATUS_ALL); } else { - executeCommand(_commands, Command::STATUS_ACTIVE); + executeCommand(commands_, Command::STATUS_ACTIVE); } - executeCommand(_routineCommands, Command::STATUS_ALL); + executeCommand(routineCommands_, Command::STATUS_ALL); afterEachIteration(); - if(!_commands.empty()) { + if(!commands_.empty()) { waitData(); } - _noWait = false; + noWait_ = false; calculateStatistics(); } onEndOfRun(); @@ -164,69 +164,69 @@ void DownloadEngine::run() void DownloadEngine::waitData() { struct timeval tv; - if(_noWait) { + if(noWait_) { tv.tv_sec = tv.tv_usec = 0; } else { tv.tv_sec = 1; tv.tv_usec = 0; } - _eventPoll->poll(tv); + eventPoll_->poll(tv); } bool DownloadEngine::addSocketForReadCheck(const SocketHandle& socket, Command* command) { - return _eventPoll->addEvents(socket->getSockfd(), command, + return eventPoll_->addEvents(socket->getSockfd(), command, EventPoll::EVENT_READ); } bool DownloadEngine::deleteSocketForReadCheck(const SocketHandle& socket, Command* command) { - return _eventPoll->deleteEvents(socket->getSockfd(), command, + return eventPoll_->deleteEvents(socket->getSockfd(), command, EventPoll::EVENT_READ); } bool DownloadEngine::addSocketForWriteCheck(const SocketHandle& socket, Command* command) { - return _eventPoll->addEvents(socket->getSockfd(), command, + return eventPoll_->addEvents(socket->getSockfd(), command, EventPoll::EVENT_WRITE); } bool DownloadEngine::deleteSocketForWriteCheck(const SocketHandle& socket, Command* command) { - return _eventPoll->deleteEvents(socket->getSockfd(), command, + return eventPoll_->deleteEvents(socket->getSockfd(), command, EventPoll::EVENT_WRITE); } void DownloadEngine::calculateStatistics() { - if(!_statCalc.isNull()) { - _statCalc->calculateStat(this); + if(!statCalc_.isNull()) { + statCalc_->calculateStat(this); } } void DownloadEngine::onEndOfRun() { - _requestGroupMan->updateServerStat(); - _requestGroupMan->closeFile(); - _requestGroupMan->save(); + requestGroupMan_->updateServerStat(); + requestGroupMan_->closeFile(); + requestGroupMan_->save(); } void DownloadEngine::afterEachIteration() { - _requestGroupMan->calculateStat(); + requestGroupMan_->calculateStat(); if(global::globalHaltRequested == 1) { - _logger->notice(_("Shutdown sequence commencing..." + logger_->notice(_("Shutdown sequence commencing..." " Press Ctrl-C again for emergency shutdown.")); requestHalt(); global::globalHaltRequested = 2; setNoWait(true); setRefreshInterval(0); } else if(global::globalHaltRequested == 3) { - _logger->notice(_("Emergency shutdown sequence commencing...")); + logger_->notice(_("Emergency shutdown sequence commencing...")); requestForceHalt(); global::globalHaltRequested = 4; setNoWait(true); @@ -236,70 +236,70 @@ void DownloadEngine::afterEachIteration() void DownloadEngine::requestHalt() { - _haltRequested = true; - _requestGroupMan->halt(); + haltRequested_ = true; + requestGroupMan_->halt(); } void DownloadEngine::requestForceHalt() { - _haltRequested = true; - _requestGroupMan->forceHalt(); + haltRequested_ = true; + requestGroupMan_->forceHalt(); } void DownloadEngine::setStatCalc(const StatCalcHandle& statCalc) { - _statCalc = statCalc; + statCalc_ = statCalc; } #ifdef ENABLE_ASYNC_DNS bool DownloadEngine::addNameResolverCheck (const SharedHandle<AsyncNameResolver>& resolver, Command* command) { - return _eventPoll->addNameResolver(resolver, command); + return eventPoll_->addNameResolver(resolver, command); } bool DownloadEngine::deleteNameResolverCheck (const SharedHandle<AsyncNameResolver>& resolver, Command* command) { - return _eventPoll->deleteNameResolver(resolver, command); + return eventPoll_->deleteNameResolver(resolver, command); } #endif // ENABLE_ASYNC_DNS void DownloadEngine::setNoWait(bool b) { - _noWait = b; + noWait_ = b; } void DownloadEngine::addRoutineCommand(Command* command) { - _routineCommands.push_back(command); + routineCommands_.push_back(command); } void DownloadEngine::poolSocket(const std::string& key, const SocketPoolEntry& entry) { - _logger->info("Pool socket for %s", key.c_str()); + logger_->info("Pool socket for %s", key.c_str()); std::multimap<std::string, SocketPoolEntry>::value_type p(key, entry); - _socketPool.insert(p); + socketPool_.insert(p); - if(_lastSocketPoolScan.difference(global::wallclock) >= 60) { + if(lastSocketPoolScan_.difference(global::wallclock) >= 60) { std::multimap<std::string, SocketPoolEntry> newPool; - if(_logger->debug()) { - _logger->debug("Scaning SocketPool and erasing timed out entry."); + if(logger_->debug()) { + logger_->debug("Scaning SocketPool and erasing timed out entry."); } - _lastSocketPoolScan = global::wallclock; + lastSocketPoolScan_ = global::wallclock; for(std::multimap<std::string, SocketPoolEntry>::iterator i = - _socketPool.begin(), eoi = _socketPool.end(); i != eoi; ++i) { + socketPool_.begin(), eoi = socketPool_.end(); i != eoi; ++i) { if(!(*i).second.isTimeout()) { newPool.insert(*i); } } - if(_logger->debug()) { - _logger->debug + if(logger_->debug()) { + logger_->debug ("%lu entries removed.", - static_cast<unsigned long>(_socketPool.size()-newPool.size())); + static_cast<unsigned long>(socketPool_.size()-newPool.size())); } - _socketPool = newPool; + socketPool_ = newPool; } } @@ -395,16 +395,16 @@ DownloadEngine::findSocketPoolEntry(const std::string& key) { std::pair<std::multimap<std::string, SocketPoolEntry>::iterator, std::multimap<std::string, SocketPoolEntry>::iterator> range = - _socketPool.equal_range(key); + socketPool_.equal_range(key); for(std::multimap<std::string, SocketPoolEntry>::iterator i = range.first, eoi = range.second; i != eoi; ++i) { const SocketPoolEntry& e = (*i).second; if(!e.isTimeout()) { - _logger->info("Found socket for %s", key.c_str()); + logger_->info("Found socket for %s", key.c_str()); return i; } } - return _socketPool.end(); + return socketPool_.end(); } SharedHandle<SocketCore> @@ -416,9 +416,9 @@ DownloadEngine::popPooledSocket std::multimap<std::string, SocketPoolEntry>::iterator i = findSocketPoolEntry (createSockPoolKey(ipaddr, port, A2STR::NIL, proxyhost, proxyport)); - if(i != _socketPool.end()) { + if(i != socketPool_.end()) { s = (*i).second.getSocket(); - _socketPool.erase(i); + socketPool_.erase(i); } return s; } @@ -434,10 +434,10 @@ DownloadEngine::popPooledSocket std::multimap<std::string, SocketPoolEntry>::iterator i = findSocketPoolEntry (createSockPoolKey(ipaddr, port, username, proxyhost, proxyport)); - if(i != _socketPool.end()) { + if(i != socketPool_.end()) { s = (*i).second.getSocket(); options = (*i).second.getOptions(); - _socketPool.erase(i); + socketPool_.erase(i); } return s; } @@ -478,60 +478,60 @@ DownloadEngine::SocketPoolEntry::SocketPoolEntry (const SharedHandle<SocketCore>& socket, const std::map<std::string, std::string>& options, time_t timeout): - _socket(socket), - _options(options), - _timeout(timeout) {} + socket_(socket), + options_(options), + timeout_(timeout) {} DownloadEngine::SocketPoolEntry::SocketPoolEntry (const SharedHandle<SocketCore>& socket, time_t timeout): - _socket(socket), - _timeout(timeout) {} + socket_(socket), + timeout_(timeout) {} DownloadEngine::SocketPoolEntry::~SocketPoolEntry() {} bool DownloadEngine::SocketPoolEntry::isTimeout() const { - return _registeredTime.difference(global::wallclock) >= _timeout; + return registeredTime_.difference(global::wallclock) >= timeout_; } cuid_t DownloadEngine::newCUID() { - return _cuidCounter.newID(); + return cuidCounter_.newID(); } const std::string& DownloadEngine::findCachedIPAddress (const std::string& hostname, uint16_t port) const { - return _dnsCache->find(hostname, port); + return dnsCache_->find(hostname, port); } void DownloadEngine::cacheIPAddress (const std::string& hostname, const std::string& ipaddr, uint16_t port) { - _dnsCache->put(hostname, ipaddr, port); + dnsCache_->put(hostname, ipaddr, port); } void DownloadEngine::markBadIPAddress (const std::string& hostname, const std::string& ipaddr, uint16_t port) { - _dnsCache->markBad(hostname, ipaddr, port); + dnsCache_->markBad(hostname, ipaddr, port); } void DownloadEngine::removeCachedIPAddress (const std::string& hostname, uint16_t port) { - _dnsCache->remove(hostname, port); + dnsCache_->remove(hostname, port); } void DownloadEngine::setAuthConfigFactory (const SharedHandle<AuthConfigFactory>& factory) { - _authConfigFactory = factory; + authConfigFactory_ = factory; } void DownloadEngine::setRefreshInterval(time_t interval) { - _refreshInterval = interval; + refreshInterval_ = interval; } } // namespace aria2 diff --git a/src/DownloadEngine.h b/src/DownloadEngine.h index a7161920..670a3c8a 100644 --- a/src/DownloadEngine.h +++ b/src/DownloadEngine.h @@ -74,25 +74,25 @@ class DownloadEngine { private: void waitData(); - std::string _sessionId; + std::string sessionId_; - SharedHandle<EventPoll> _eventPoll; + SharedHandle<EventPoll> eventPoll_; - Logger* _logger; + Logger* logger_; - SharedHandle<StatCalc> _statCalc; + SharedHandle<StatCalc> statCalc_; - bool _haltRequested; + bool haltRequested_; class SocketPoolEntry { private: - SharedHandle<SocketCore> _socket; + SharedHandle<SocketCore> socket_; - std::map<std::string, std::string> _options; + std::map<std::string, std::string> options_; - time_t _timeout; + time_t timeout_; - Timer _registeredTime; + Timer registeredTime_; public: SocketPoolEntry(const SharedHandle<SocketCore>& socket, const std::map<std::string, std::string>& option, @@ -107,39 +107,39 @@ private: const SharedHandle<SocketCore>& getSocket() const { - return _socket; + return socket_; } const std::map<std::string, std::string>& getOptions() const { - return _options; + return options_; } }; // key = IP address:port, value = SocketPoolEntry - std::multimap<std::string, SocketPoolEntry> _socketPool; + std::multimap<std::string, SocketPoolEntry> socketPool_; - Timer _lastSocketPoolScan; + Timer lastSocketPoolScan_; - bool _noWait; + bool noWait_; static const time_t DEFAULT_REFRESH_INTERVAL = 1; - time_t _refreshInterval; + time_t refreshInterval_; - std::deque<Command*> _routineCommands; + std::deque<Command*> routineCommands_; - SharedHandle<CookieStorage> _cookieStorage; + SharedHandle<CookieStorage> cookieStorage_; #ifdef ENABLE_BITTORRENT - SharedHandle<BtRegistry> _btRegistry; + SharedHandle<BtRegistry> btRegistry_; #endif // ENABLE_BITTORRENT - CUIDCounter _cuidCounter; + CUIDCounter cuidCounter_; - SharedHandle<DNSCache> _dnsCache; + SharedHandle<DNSCache> dnsCache_; - SharedHandle<AuthConfigFactory> _authConfigFactory; + SharedHandle<AuthConfigFactory> authConfigFactory_; /** * Delegates to StatCalc @@ -155,11 +155,11 @@ private: std::multimap<std::string, SocketPoolEntry>::iterator findSocketPoolEntry(const std::string& key); - std::deque<Command*> _commands; - SharedHandle<RequestGroupMan> _requestGroupMan; - SharedHandle<FileAllocationMan> _fileAllocationMan; - SharedHandle<CheckIntegrityMan> _checkIntegrityMan; - Option* _option; + std::deque<Command*> commands_; + SharedHandle<RequestGroupMan> requestGroupMan_; + SharedHandle<FileAllocationMan> fileAllocationMan_; + SharedHandle<CheckIntegrityMan> checkIntegrityMan_; + Option* option_; public: DownloadEngine(const SharedHandle<EventPoll>& eventPoll); @@ -188,59 +188,59 @@ public: void addCommand(const std::vector<Command*>& commands) { - _commands.insert(_commands.end(), commands.begin(), commands.end()); + commands_.insert(commands_.end(), commands.begin(), commands.end()); } void addCommand(Command* command) { - _commands.push_back(command); + commands_.push_back(command); } const SharedHandle<RequestGroupMan>& getRequestGroupMan() const { - return _requestGroupMan; + return requestGroupMan_; } void setRequestGroupMan(const SharedHandle<RequestGroupMan>& rgman) { - _requestGroupMan = rgman; + requestGroupMan_ = rgman; } const SharedHandle<FileAllocationMan>& getFileAllocationMan() const { - return _fileAllocationMan; + return fileAllocationMan_; } void setFileAllocationMan(const SharedHandle<FileAllocationMan>& faman) { - _fileAllocationMan = faman; + fileAllocationMan_ = faman; } const SharedHandle<CheckIntegrityMan>& getCheckIntegrityMan() const { - return _checkIntegrityMan; + return checkIntegrityMan_; } void setCheckIntegrityMan(const SharedHandle<CheckIntegrityMan>& ciman) { - _checkIntegrityMan = ciman; + checkIntegrityMan_ = ciman; } Option* getOption() const { - return _option; + return option_; } void setOption(Option* op) { - _option = op; + option_ = op; } void setStatCalc(const SharedHandle<StatCalc>& statCalc); bool isHaltRequested() const { - return _haltRequested; + return haltRequested_; } void requestHalt(); @@ -300,13 +300,13 @@ public: const SharedHandle<CookieStorage>& getCookieStorage() const { - return _cookieStorage; + return cookieStorage_; } #ifdef ENABLE_BITTORRENT const SharedHandle<BtRegistry>& getBtRegistry() const { - return _btRegistry; + return btRegistry_; } #endif // ENABLE_BITTORRENT @@ -319,7 +319,7 @@ public: void findAllCachedIPAddresses (OutputIterator out, const std::string& hostname, uint16_t port) const { - _dnsCache->findAll(out, hostname, port); + dnsCache_->findAll(out, hostname, port); } void cacheIPAddress @@ -334,14 +334,14 @@ public: const SharedHandle<AuthConfigFactory>& getAuthConfigFactory() const { - return _authConfigFactory; + return authConfigFactory_; } void setRefreshInterval(time_t interval); const std::string getSessionId() const { - return _sessionId; + return sessionId_; } }; diff --git a/src/DownloadEngineFactory.cc b/src/DownloadEngineFactory.cc index fe79f35a..4af34005 100644 --- a/src/DownloadEngineFactory.cc +++ b/src/DownloadEngineFactory.cc @@ -80,7 +80,7 @@ namespace aria2 { DownloadEngineFactory::DownloadEngineFactory(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} DownloadEngineHandle DownloadEngineFactory::newDownloadEngine diff --git a/src/DownloadEngineFactory.h b/src/DownloadEngineFactory.h index c26d96f4..ab028812 100644 --- a/src/DownloadEngineFactory.h +++ b/src/DownloadEngineFactory.h @@ -50,7 +50,7 @@ class DownloadEngine; class DownloadEngineFactory { private: - Logger* _logger; + Logger* logger_; public: DownloadEngineFactory(); diff --git a/src/DownloadHandler.cc b/src/DownloadHandler.cc index 264473d1..29d9b027 100644 --- a/src/DownloadHandler.cc +++ b/src/DownloadHandler.cc @@ -41,18 +41,18 @@ namespace aria2 { -DownloadHandler::DownloadHandler():_logger(LogFactory::getInstance()) {} +DownloadHandler::DownloadHandler():logger_(LogFactory::getInstance()) {} DownloadHandler::~DownloadHandler() {} bool DownloadHandler::canHandle(const RequestGroup* requestGroup) const { - return !_criteria.isNull() && _criteria->match(requestGroup); + return !criteria_.isNull() && criteria_->match(requestGroup); } void DownloadHandler::setCriteria(const RequestGroupCriteriaHandle& criteria) { - _criteria = criteria; + criteria_ = criteria; } } // namespace aria2 diff --git a/src/DownloadHandler.h b/src/DownloadHandler.h index 37e762bd..e1e79498 100644 --- a/src/DownloadHandler.h +++ b/src/DownloadHandler.h @@ -50,13 +50,13 @@ class RequestGroupCriteria; class DownloadHandler { private: - SharedHandle<RequestGroupCriteria> _criteria; + SharedHandle<RequestGroupCriteria> criteria_; - Logger* _logger; + Logger* logger_; protected: Logger* getLogger() const { - return _logger; + return logger_; } public: DownloadHandler(); diff --git a/src/DownloadHandlerFactory.cc b/src/DownloadHandlerFactory.cc index 6c5ec97e..feb22cf4 100644 --- a/src/DownloadHandlerFactory.cc +++ b/src/DownloadHandlerFactory.cc @@ -45,23 +45,23 @@ namespace aria2 { #ifdef ENABLE_METALINK SharedHandle<MemoryBufferPreDownloadHandler> -DownloadHandlerFactory::_metalinkPreDownloadHandler; +DownloadHandlerFactory::metalinkPreDownloadHandler_; SharedHandle<MetalinkPostDownloadHandler> -DownloadHandlerFactory::_metalinkPostDownloadHandler; +DownloadHandlerFactory::metalinkPostDownloadHandler_; #endif // ENABLE_METALINK #ifdef ENABLE_BITTORRENT SharedHandle<MemoryBufferPreDownloadHandler> -DownloadHandlerFactory::_btPreDownloadHandler; +DownloadHandlerFactory::btPreDownloadHandler_; SharedHandle<BtPostDownloadHandler> -DownloadHandlerFactory::_btPostDownloadHandler; +DownloadHandlerFactory::btPostDownloadHandler_; SharedHandle<UTMetadataPostDownloadHandler> -DownloadHandlerFactory::_btMetadataPostDownloadHandler; +DownloadHandlerFactory::btMetadataPostDownloadHandler_; #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK @@ -69,8 +69,8 @@ DownloadHandlerFactory::_btMetadataPostDownloadHandler; SharedHandle<MemoryBufferPreDownloadHandler> DownloadHandlerFactory::getMetalinkPreDownloadHandler() { - if(_metalinkPreDownloadHandler.isNull()) { - _metalinkPreDownloadHandler.reset(new MemoryBufferPreDownloadHandler()); + if(metalinkPreDownloadHandler_.isNull()) { + metalinkPreDownloadHandler_.reset(new MemoryBufferPreDownloadHandler()); RequestGroupCriteriaHandle criteria (new ContentTypeRequestGroupCriteria @@ -78,18 +78,18 @@ DownloadHandlerFactory::getMetalinkPreDownloadHandler() DownloadHandlerConstants::getMetalinkContentTypes().end(), DownloadHandlerConstants::getMetalinkExtensions().begin(), DownloadHandlerConstants::getMetalinkExtensions().end())); - _metalinkPreDownloadHandler->setCriteria(criteria); + metalinkPreDownloadHandler_->setCriteria(criteria); } - return _metalinkPreDownloadHandler; + return metalinkPreDownloadHandler_; } SharedHandle<MetalinkPostDownloadHandler> DownloadHandlerFactory::getMetalinkPostDownloadHandler() { - if(_metalinkPostDownloadHandler.isNull()) { - _metalinkPostDownloadHandler.reset(new MetalinkPostDownloadHandler()); + if(metalinkPostDownloadHandler_.isNull()) { + metalinkPostDownloadHandler_.reset(new MetalinkPostDownloadHandler()); } - return _metalinkPostDownloadHandler; + return metalinkPostDownloadHandler_; } #endif // ENABLE_METALINK @@ -99,8 +99,8 @@ DownloadHandlerFactory::getMetalinkPostDownloadHandler() SharedHandle<MemoryBufferPreDownloadHandler> DownloadHandlerFactory::getBtPreDownloadHandler() { - if(_btPreDownloadHandler.isNull()) { - _btPreDownloadHandler.reset(new MemoryBufferPreDownloadHandler()); + if(btPreDownloadHandler_.isNull()) { + btPreDownloadHandler_.reset(new MemoryBufferPreDownloadHandler()); RequestGroupCriteriaHandle criteria (new ContentTypeRequestGroupCriteria @@ -108,27 +108,27 @@ DownloadHandlerFactory::getBtPreDownloadHandler() DownloadHandlerConstants::getBtContentTypes().end(), DownloadHandlerConstants::getBtExtensions().begin(), DownloadHandlerConstants::getBtExtensions().end())); - _btPreDownloadHandler->setCriteria(criteria); + btPreDownloadHandler_->setCriteria(criteria); } - return _btPreDownloadHandler; + return btPreDownloadHandler_; } SharedHandle<BtPostDownloadHandler> DownloadHandlerFactory::getBtPostDownloadHandler() { - if(_btPostDownloadHandler.isNull()) { - _btPostDownloadHandler.reset(new BtPostDownloadHandler()); + if(btPostDownloadHandler_.isNull()) { + btPostDownloadHandler_.reset(new BtPostDownloadHandler()); } - return _btPostDownloadHandler; + return btPostDownloadHandler_; } SharedHandle<UTMetadataPostDownloadHandler> DownloadHandlerFactory::getUTMetadataPostDownloadHandler() { - if(_btMetadataPostDownloadHandler.isNull()) { - _btMetadataPostDownloadHandler.reset(new UTMetadataPostDownloadHandler()); + if(btMetadataPostDownloadHandler_.isNull()) { + btMetadataPostDownloadHandler_.reset(new UTMetadataPostDownloadHandler()); } - return _btMetadataPostDownloadHandler; + return btMetadataPostDownloadHandler_; } #endif // ENABLE_BITTORRENT diff --git a/src/DownloadHandlerFactory.h b/src/DownloadHandlerFactory.h index 5bea803d..8bfb59e5 100644 --- a/src/DownloadHandlerFactory.h +++ b/src/DownloadHandlerFactory.h @@ -54,21 +54,21 @@ class DownloadHandlerFactory private: #ifdef ENABLE_METALINK static SharedHandle<MemoryBufferPreDownloadHandler> - _metalinkPreDownloadHandler; + metalinkPreDownloadHandler_; static SharedHandle<MetalinkPostDownloadHandler> - _metalinkPostDownloadHandler; + metalinkPostDownloadHandler_; #endif // ENABLE_METALINK #ifdef ENABLE_BITTORRENT static SharedHandle<MemoryBufferPreDownloadHandler> - _btPreDownloadHandler; + btPreDownloadHandler_; static SharedHandle<BtPostDownloadHandler> - _btPostDownloadHandler; + btPostDownloadHandler_; static SharedHandle<UTMetadataPostDownloadHandler> - _btMetadataPostDownloadHandler; + btMetadataPostDownloadHandler_; #endif // ENABLE_BITTORRENT public: #ifdef ENABLE_METALINK diff --git a/src/EpollEventPoll.cc b/src/EpollEventPoll.cc index c5a96c81..8d6a542f 100644 --- a/src/EpollEventPoll.cc +++ b/src/EpollEventPoll.cc @@ -61,16 +61,16 @@ struct epoll_event EpollEventPoll::KSocketEntry::getEvents() #ifdef ENABLE_ASYNC_DNS epEvent.events = - std::accumulate(_adnsEvents.begin(), - _adnsEvents.end(), - std::accumulate(_commandEvents.begin(), - _commandEvents.end(), 0, accumulateEvent), + std::accumulate(adnsEvents_.begin(), + adnsEvents_.end(), + std::accumulate(commandEvents_.begin(), + commandEvents_.end(), 0, accumulateEvent), accumulateEvent); #else // !ENABLE_ASYNC_DNS epEvent.events = - std::accumulate(_commandEvents.begin(), _commandEvents.end(), 0, + std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0, accumulateEvent); #endif // !ENABLE_ASYNC_DNS @@ -78,30 +78,30 @@ struct epoll_event EpollEventPoll::KSocketEntry::getEvents() } EpollEventPoll::EpollEventPoll(): - _epEventsSize(EPOLL_EVENTS_MAX), - _epEvents(new struct epoll_event[_epEventsSize]), - _logger(LogFactory::getInstance()) + epEventsSize_(EPOLL_EVENTS_MAX), + epEvents_(new struct epoll_event[epEventsSize_]), + logger_(LogFactory::getInstance()) { - _epfd = epoll_create(EPOLL_EVENTS_MAX); + epfd_ = epoll_create(EPOLL_EVENTS_MAX); } EpollEventPoll::~EpollEventPoll() { - if(_epfd != -1) { + if(epfd_ != -1) { int r; - while((r = close(_epfd)) == -1 && errno == EINTR); + while((r = close(epfd_)) == -1 && errno == EINTR); if(r == -1) { - _logger->error("Error occurred while closing epoll file descriptor" + logger_->error("Error occurred while closing epoll file descriptor" " %d: %s", - _epfd, strerror(errno)); + epfd_, strerror(errno)); } } - delete [] _epEvents; + delete [] epEvents_; } bool EpollEventPoll::good() const { - return _epfd != -1; + return epfd_ != -1; } void EpollEventPoll::poll(const struct timeval& tv) @@ -110,13 +110,13 @@ void EpollEventPoll::poll(const struct timeval& tv) int timeout = tv.tv_sec*1000+tv.tv_usec/1000; int res; - while((res = epoll_wait(_epfd, _epEvents, EPOLL_EVENTS_MAX, timeout)) == -1 && + while((res = epoll_wait(epfd_, epEvents_, EPOLL_EVENTS_MAX, timeout)) == -1 && errno == EINTR); if(res > 0) { for(int i = 0; i < res; ++i) { - KSocketEntry* p = reinterpret_cast<KSocketEntry*>(_epEvents[i].data.ptr); - p->processEvents(_epEvents[i].events); + KSocketEntry* p = reinterpret_cast<KSocketEntry*>(epEvents_[i].data.ptr); + p->processEvents(epEvents_[i].events); } } @@ -126,7 +126,7 @@ void EpollEventPoll::poll(const struct timeval& tv) // their API. So we call ares_process_fd for all ares_channel and // re-register their sockets. for(std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator i = - _nameResolverEntries.begin(), eoi = _nameResolverEntries.end(); + nameResolverEntries_.begin(), eoi = nameResolverEntries_.end(); i != eoi; ++i) { (*i)->processTimeout(); (*i)->removeSocketEvents(this); @@ -161,38 +161,38 @@ bool EpollEventPoll::addEvents(sock_t socket, { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); int r = 0; - if(i != _socketEntries.end() && (*i) == socketEntry) { + if(i != socketEntries_.end() && (*i) == socketEntry) { event.addSelf(*i); struct epoll_event epEvent = (*i)->getEvents(); - r = epoll_ctl(_epfd, EPOLL_CTL_MOD, (*i)->getSocket(), &epEvent); + r = epoll_ctl(epfd_, EPOLL_CTL_MOD, (*i)->getSocket(), &epEvent); if(r == -1) { // try EPOLL_CTL_ADD: There is a chance that previously socket X is // added to epoll, but it is closed and is not yet removed from // SocketEntries. In this case, EPOLL_CTL_MOD is failed with ENOENT. - r = epoll_ctl(_epfd, EPOLL_CTL_ADD, (*i)->getSocket(), + r = epoll_ctl(epfd_, EPOLL_CTL_ADD, (*i)->getSocket(), &epEvent); } } else { - _socketEntries.insert(i, socketEntry); - if(_socketEntries.size() > _epEventsSize) { - _epEventsSize *= 2; - delete [] _epEvents; - _epEvents = new struct epoll_event[_epEventsSize]; + socketEntries_.insert(i, socketEntry); + if(socketEntries_.size() > epEventsSize_) { + epEventsSize_ *= 2; + delete [] epEvents_; + epEvents_ = new struct epoll_event[epEventsSize_]; } event.addSelf(socketEntry); struct epoll_event epEvent = socketEntry->getEvents(); - r = epoll_ctl(_epfd, EPOLL_CTL_ADD, socketEntry->getSocket(), &epEvent); + r = epoll_ctl(epfd_, EPOLL_CTL_ADD, socketEntry->getSocket(), &epEvent); } if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to add socket event %d:%s", + if(logger_->debug()) { + logger_->debug("Failed to add socket event %d:%s", socket, strerror(errno)); } return false; @@ -221,8 +221,8 @@ bool EpollEventPoll::deleteEvents(sock_t socket, { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); - if(i != _socketEntries.end() && (*i) == socketEntry) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); + if(i != socketEntries_.end() && (*i) == socketEntry) { event.removeSelf(*i); @@ -231,31 +231,31 @@ bool EpollEventPoll::deleteEvents(sock_t socket, // In kernel before 2.6.9, epoll_ctl with EPOLL_CTL_DEL requires non-null // pointer of epoll_event. struct epoll_event ev = {0,{0}}; - r = epoll_ctl(_epfd, EPOLL_CTL_DEL, (*i)->getSocket(), &ev); - _socketEntries.erase(i); + r = epoll_ctl(epfd_, EPOLL_CTL_DEL, (*i)->getSocket(), &ev); + socketEntries_.erase(i); } else { // If socket is closed, then it seems it is automatically removed from // epoll, so following EPOLL_CTL_MOD may fail. struct epoll_event epEvent = (*i)->getEvents(); - r = epoll_ctl(_epfd, EPOLL_CTL_MOD, (*i)->getSocket(), &epEvent); + r = epoll_ctl(epfd_, EPOLL_CTL_MOD, (*i)->getSocket(), &epEvent); if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to delete socket event, but may be ignored:%s", + if(logger_->debug()) { + logger_->debug("Failed to delete socket event, but may be ignored:%s", strerror(errno)); } } } if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to delete socket event:%s", strerror(errno)); + if(logger_->debug()) { + logger_->debug("Failed to delete socket event:%s", strerror(errno)); } return false; } else { return true; } } else { - if(_logger->debug()) { - _logger->debug("Socket %d is not found in SocketEntries.", socket); + if(logger_->debug()) { + logger_->debug("Socket %d is not found in SocketEntries.", socket); } return false; } @@ -283,9 +283,9 @@ bool EpollEventPoll::addNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { - _nameResolverEntries.push_back(entry); + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { + nameResolverEntries_.push_back(entry); entry->addSocketEvents(this); return true; } else { @@ -299,12 +299,12 @@ bool EpollEventPoll::deleteNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { return false; } else { (*itr)->removeSocketEvents(this); - _nameResolverEntries.erase(itr); + nameResolverEntries_.erase(itr); return true; } } diff --git a/src/EpollEventPoll.h b/src/EpollEventPoll.h index eb3a4c7e..9322c9ea 100644 --- a/src/EpollEventPoll.h +++ b/src/EpollEventPoll.h @@ -71,20 +71,20 @@ private: friend int accumulateEvent(int events, const KEvent& event); private: - std::deque<SharedHandle<KSocketEntry> > _socketEntries; + std::deque<SharedHandle<KSocketEntry> > socketEntries_; #ifdef ENABLE_ASYNC_DNS - std::deque<SharedHandle<KAsyncNameResolverEntry> > _nameResolverEntries; + std::deque<SharedHandle<KAsyncNameResolverEntry> > nameResolverEntries_; #endif // ENABLE_ASYNC_DNS - int _epfd; + int epfd_; - size_t _epEventsSize; + size_t epEventsSize_; - struct epoll_event* _epEvents; + struct epoll_event* epEvents_; static const size_t EPOLL_EVENTS_MAX = 1024; - Logger* _logger; + Logger* logger_; bool addEvents(sock_t socket, const KEvent& event); diff --git a/src/Event.h b/src/Event.h index 3ec552a9..36e95467 100644 --- a/src/Event.h +++ b/src/Event.h @@ -68,59 +68,59 @@ public: template<typename SocketEntry, typename EventPoll> class CommandEvent : public Event<SocketEntry> { private: - Command* _command; - int _events; + Command* command_; + int events_; public: CommandEvent(Command* command, int events): - _command(command), _events(events) {} + command_(command), events_(events) {} Command* getCommand() const { - return _command; + return command_; } void addEvents(int events) { - _events |= events; + events_ |= events; } void removeEvents(int events) { - _events &= (~events); + events_ &= (~events); } bool eventsEmpty() const { - return _events == 0; + return events_ == 0; } bool operator==(const CommandEvent& commandEvent) const { - return _command == commandEvent._command; + return command_ == commandEvent.command_; } virtual int getEvents() const { - return _events; + return events_; } virtual void processEvents(int events) { - if((_events&events) || + if((events_&events) || ((EventPoll::IEV_ERROR|EventPoll::IEV_HUP)&events)) { - _command->setStatusActive(); + command_->setStatusActive(); } if(EventPoll::IEV_READ&events) { - _command->readEventReceived(); + command_->readEventReceived(); } if(EventPoll::IEV_WRITE&events) { - _command->writeEventReceived(); + command_->writeEventReceived(); } if(EventPoll::IEV_ERROR&events) { - _command->errorEventReceived(); + command_->errorEventReceived(); } if(EventPoll::IEV_HUP&events) { - _command->hupEventReceived(); + command_->hupEventReceived(); } } @@ -140,23 +140,23 @@ public: template<typename SocketEntry, typename EventPoll> class ADNSEvent : public Event<SocketEntry> { private: - SharedHandle<AsyncNameResolver> _resolver; - Command* _command; - sock_t _socket; - int _events; + SharedHandle<AsyncNameResolver> resolver_; + Command* command_; + sock_t socket_; + int events_; public: ADNSEvent(const SharedHandle<AsyncNameResolver>& resolver, Command* command, sock_t socket, int events): - _resolver(resolver), _command(command), _socket(socket), _events(events) {} + resolver_(resolver), command_(command), socket_(socket), events_(events) {} bool operator==(const ADNSEvent& event) const { - return _resolver == event._resolver; + return resolver_ == event.resolver_; } virtual int getEvents() const { - return _events; + return events_; } virtual void processEvents(int events) @@ -165,18 +165,18 @@ public: ares_socket_t writefd; if(events&(EventPoll::IEV_READ|EventPoll::IEV_ERROR| EventPoll::IEV_HUP)) { - readfd = _socket; + readfd = socket_; } else { readfd = ARES_SOCKET_BAD; } if(events&(EventPoll::IEV_WRITE|EventPoll::IEV_ERROR| EventPoll::IEV_HUP)) { - writefd = _socket; + writefd = socket_; } else { writefd = ARES_SOCKET_BAD; } - _resolver->process(readfd, writefd); - _command->setStatusActive(); + resolver_->process(readfd, writefd); + command_->setStatusActive(); } virtual void addSelf(const SharedHandle<SocketEntry>& socketEntry) const @@ -197,36 +197,36 @@ class ADNSEvent : public Event<SocketEntry> {}; template<typename CommandEvent, typename ADNSEvent> class SocketEntry { protected: - sock_t _socket; + sock_t socket_; - std::deque<CommandEvent> _commandEvents; + std::deque<CommandEvent> commandEvents_; #ifdef ENABLE_ASYNC_DNS - std::deque<ADNSEvent> _adnsEvents; + std::deque<ADNSEvent> adnsEvents_; #endif // ENABLE_ASYNC_DNS public: - SocketEntry(sock_t socket):_socket(socket) {} + SocketEntry(sock_t socket):socket_(socket) {} virtual ~SocketEntry() {} bool operator==(const SocketEntry& entry) const { - return _socket == entry._socket; + return socket_ == entry.socket_; } bool operator<(const SocketEntry& entry) const { - return _socket < entry._socket; + return socket_ < entry.socket_; } void addCommandEvent(const CommandEvent& cev) { typename std::deque<CommandEvent>::iterator i = - std::find(_commandEvents.begin(), _commandEvents.end(), cev); - if(i == _commandEvents.end()) { - _commandEvents.push_back(cev); + std::find(commandEvents_.begin(), commandEvents_.end(), cev); + if(i == commandEvents_.end()) { + commandEvents_.push_back(cev); } else { (*i).addEvents(cev.getEvents()); } @@ -235,13 +235,13 @@ public: void removeCommandEvent(const CommandEvent& cev) { typename std::deque<CommandEvent>::iterator i = - std::find(_commandEvents.begin(), _commandEvents.end(), cev); - if(i == _commandEvents.end()) { + std::find(commandEvents_.begin(), commandEvents_.end(), cev); + if(i == commandEvents_.end()) { // not found } else { (*i).removeEvents(cev.getEvents()); if((*i).eventsEmpty()) { - _commandEvents.erase(i); + commandEvents_.erase(i); } } } @@ -251,51 +251,51 @@ public: void addADNSEvent(const ADNSEvent& aev) { typename std::deque<ADNSEvent>::iterator i = - std::find(_adnsEvents.begin(), _adnsEvents.end(), aev); - if(i == _adnsEvents.end()) { - _adnsEvents.push_back(aev); + std::find(adnsEvents_.begin(), adnsEvents_.end(), aev); + if(i == adnsEvents_.end()) { + adnsEvents_.push_back(aev); } } void removeADNSEvent(const ADNSEvent& aev) { typename std::deque<ADNSEvent>::iterator i = - std::find(_adnsEvents.begin(), _adnsEvents.end(), aev); - if(i == _adnsEvents.end()) { + std::find(adnsEvents_.begin(), adnsEvents_.end(), aev); + if(i == adnsEvents_.end()) { // not found } else { - _adnsEvents.erase(i); + adnsEvents_.erase(i); } } #endif // ENABLE_ASYNC_DNS sock_t getSocket() const { - return _socket; + return socket_; } void setSocket(sock_t socket) { - _socket = socket; + socket_ = socket; } bool eventEmpty() const { #ifdef ENABLE_ASYNC_DNS - return _commandEvents.empty() && _adnsEvents.empty(); + return commandEvents_.empty() && adnsEvents_.empty(); #else // !ENABLE_ASYNC_DNS - return _commandEvents.empty(); + return commandEvents_.empty(); #endif // !ENABLE_ASYNC_DNS) } void processEvents(int events) { - std::for_each(_commandEvents.begin(), _commandEvents.end(), + std::for_each(commandEvents_.begin(), commandEvents_.end(), std::bind2nd(std::mem_fun_ref (&CommandEvent::processEvents), events)); #ifdef ENABLE_ASYNC_DNS - std::for_each(_adnsEvents.begin(), _adnsEvents.end(), + std::for_each(adnsEvents_.begin(), adnsEvents_.end(), std::bind2nd(std::mem_fun_ref (&ADNSEvent::processEvents), events)); @@ -308,29 +308,29 @@ public: template<typename EventPoll> class AsyncNameResolverEntry { private: - SharedHandle<AsyncNameResolver> _nameResolver; + SharedHandle<AsyncNameResolver> nameResolver_; - Command* _command; + Command* command_; - size_t _socketsSize; + size_t socketsSize_; - sock_t _sockets[ARES_GETSOCK_MAXNUM]; + sock_t sockets_[ARES_GETSOCK_MAXNUM]; public: AsyncNameResolverEntry(const SharedHandle<AsyncNameResolver>& nameResolver, Command* command): - _nameResolver(nameResolver), _command(command), _socketsSize(0) {} + nameResolver_(nameResolver), command_(command), socketsSize_(0) {} bool operator==(const AsyncNameResolverEntry& entry) { - return _nameResolver == entry._nameResolver && - _command == entry._command; + return nameResolver_ == entry.nameResolver_ && + command_ == entry.command_; } void addSocketEvents(EventPoll* e) { - _socketsSize = 0; - int mask = _nameResolver->getsock(_sockets); + socketsSize_ = 0; + int mask = nameResolver_->getsock(sockets_); if(mask == 0) { return; } @@ -347,15 +347,15 @@ public: // assume no further sockets are returned. break; } - e->addEvents(_sockets[i], _command, events, _nameResolver); + e->addEvents(sockets_[i], command_, events, nameResolver_); } - _socketsSize = i; + socketsSize_ = i; } void removeSocketEvents(EventPoll* e) { - for(size_t i = 0; i < _socketsSize; ++i) { - e->deleteEvents(_sockets[i], _command, _nameResolver); + for(size_t i = 0; i < socketsSize_; ++i) { + e->deleteEvents(sockets_[i], command_, nameResolver_); } } @@ -363,7 +363,7 @@ public: // ARES_SOCKET_BAD). void processTimeout() { - _nameResolver->process(ARES_SOCKET_BAD, ARES_SOCKET_BAD); + nameResolver_->process(ARES_SOCKET_BAD, ARES_SOCKET_BAD); } }; #else // !ENABLE_ASYNC_DNS diff --git a/src/Exception.cc b/src/Exception.cc index 81b2219b..f53c54b5 100644 --- a/src/Exception.cc +++ b/src/Exception.cc @@ -39,32 +39,32 @@ namespace aria2 { Exception::Exception(const char* file, int line, const std::string& msg): - _file(file), _line(line), _msg(msg) {} + file_(file), line_(line), msg_(msg) {} Exception::Exception(const char* file, int line, const std::string& msg, const Exception& cause): - _file(file), _line(line), _msg(msg), _cause(cause.copy()) {} + file_(file), line_(line), msg_(msg), cause_(cause.copy()) {} Exception::Exception(const char* file, int line, const Exception& e): - _file(file), _line(line), _msg(e._msg), _cause(e._cause) + file_(file), line_(line), msg_(e.msg_), cause_(e.cause_) {} Exception::~Exception() throw() {} const char* Exception::what() const throw() { - return _msg.c_str(); + return msg_.c_str(); } std::string Exception::stackTrace() const throw() { std::stringstream s; - s << "Exception: " << "[" << _file << ":" << _line << "] " << what() << "\n"; - SharedHandle<Exception> e = _cause; + s << "Exception: " << "[" << file_ << ":" << line_ << "] " << what() << "\n"; + SharedHandle<Exception> e = cause_; while(!e.isNull()) { - s << " -> " << "[" << e->_file << ":" << e->_line << "] " + s << " -> " << "[" << e->file_ << ":" << e->line_ << "] " << e->what() << "\n"; - e = e->_cause; + e = e->cause_; } return s.str(); } diff --git a/src/Exception.h b/src/Exception.h index 852457fd..57ac633f 100644 --- a/src/Exception.h +++ b/src/Exception.h @@ -43,13 +43,13 @@ namespace aria2 { class Exception:public std::exception { private: - const char* _file; + const char* file_; - int _line; + int line_; - std::string _msg; + std::string msg_; - SharedHandle<Exception> _cause; + SharedHandle<Exception> cause_; protected: virtual SharedHandle<Exception> copy() const = 0; diff --git a/src/ExpatMetalinkProcessor.cc b/src/ExpatMetalinkProcessor.cc index 7dc2c76c..af48192f 100644 --- a/src/ExpatMetalinkProcessor.cc +++ b/src/ExpatMetalinkProcessor.cc @@ -51,11 +51,11 @@ namespace aria2 { class SessionData { public: - SharedHandle<MetalinkParserStateMachine> _stm; + SharedHandle<MetalinkParserStateMachine> stm_; - std::deque<std::string> _charactersStack; + std::deque<std::string> charactersStack_; - SessionData(const SharedHandle<MetalinkParserStateMachine>& stm):_stm(stm) {} + SessionData(const SharedHandle<MetalinkParserStateMachine>& stm):stm_(stm) {} }; static void splitNsName @@ -103,9 +103,9 @@ static void mlStartElement(void* userData, const char* nsName, const char** attr std::string nsUri; splitNsName(localname, prefix, nsUri, nsName); - sd->_stm->beginElement(localname, prefix, nsUri, xmlAttrs); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.push_front(A2STR::NIL); + sd->stm_->beginElement(localname, prefix, nsUri, xmlAttrs); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.push_front(A2STR::NIL); } } @@ -118,18 +118,18 @@ static void mlEndElement(void* userData, const char* nsName) SessionData* sd = reinterpret_cast<SessionData*>(userData); std::string characters; - if(sd->_stm->needsCharactersBuffering()) { - characters = sd->_charactersStack.front(); - sd->_charactersStack.pop_front(); + if(sd->stm_->needsCharactersBuffering()) { + characters = sd->charactersStack_.front(); + sd->charactersStack_.pop_front(); } - sd->_stm->endElement(localname, prefix, nsUri, characters); + sd->stm_->endElement(localname, prefix, nsUri, characters); } static void mlCharacters(void* userData, const char* ch, int len) { SessionData* sd = reinterpret_cast<SessionData*>(userData); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.front() += std::string(&ch[0], &ch[len]); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.front() += std::string(&ch[0], &ch[len]); } } @@ -149,7 +149,7 @@ static void checkError(XML_Parser parser) } SessionData* sessionData = reinterpret_cast<SessionData*>(XML_GetUserData(parser)); - const SharedHandle<MetalinkParserStateMachine>& stm = sessionData->_stm; + const SharedHandle<MetalinkParserStateMachine>& stm = sessionData->stm_; if(!stm->finished()) { throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK); } @@ -172,10 +172,10 @@ MetalinkProcessor::parseFile(const std::string& filename) SharedHandle<Metalinker> MetalinkProcessor::parseFile(std::istream& stream) { - _stm.reset(new MetalinkParserStateMachine()); + stm_.reset(new MetalinkParserStateMachine()); char buf[4096]; - SharedHandle<SessionData> sessionData(new SessionData(_stm)); + SharedHandle<SessionData> sessionData(new SessionData(stm_)); XML_Parser parser = createParser(sessionData); auto_delete<XML_Parser> deleter(parser, XML_ParserFree); while(stream) { @@ -188,17 +188,17 @@ MetalinkProcessor::parseFile(std::istream& stream) throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK); } checkError(parser); - return _stm->getResult(); + return stm_->getResult(); } SharedHandle<Metalinker> MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binaryStream) { - _stm.reset(new MetalinkParserStateMachine()); + stm_.reset(new MetalinkParserStateMachine()); ssize_t bufSize = 4096; unsigned char buf[bufSize]; - SharedHandle<SessionData> sessionData(new SessionData(_stm)); + SharedHandle<SessionData> sessionData(new SessionData(stm_)); XML_Parser parser = createParser(sessionData); off_t readOffset = 0; while(1) { @@ -213,7 +213,7 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar readOffset += res; } checkError(parser); - return _stm->getResult(); + return stm_->getResult(); } } // namespace aria2 diff --git a/src/ExpatMetalinkProcessor.h b/src/ExpatMetalinkProcessor.h index eeecba16..5bd3fedf 100644 --- a/src/ExpatMetalinkProcessor.h +++ b/src/ExpatMetalinkProcessor.h @@ -51,7 +51,7 @@ class MetalinkParserStateMachine; class MetalinkProcessor { private: - SharedHandle<MetalinkParserStateMachine> _stm; + SharedHandle<MetalinkParserStateMachine> stm_; public: SharedHandle<Metalinker> parseFile(const std::string& filename); diff --git a/src/ExpatXmlRpcRequestProcessor.cc b/src/ExpatXmlRpcRequestProcessor.cc index df89eb10..8644a3e2 100644 --- a/src/ExpatXmlRpcRequestProcessor.cc +++ b/src/ExpatXmlRpcRequestProcessor.cc @@ -48,11 +48,11 @@ namespace aria2 { namespace xmlrpc { struct SessionData { - XmlRpcRequestParserStateMachine* _stm; + XmlRpcRequestParserStateMachine* stm_; - std::stack<std::string> _charactersStack; + std::stack<std::string> charactersStack_; - SessionData(XmlRpcRequestParserStateMachine* stm):_stm(stm) {} + SessionData(XmlRpcRequestParserStateMachine* stm):stm_(stm) {} }; static void mlStartElement(void* userData, const char* name, const char** attrs) @@ -71,9 +71,9 @@ static void mlStartElement(void* userData, const char* name, const char** attrs) attrmap[name] = value; } } - sd->_stm->beginElement(name, attrmap); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.push(std::string()); + sd->stm_->beginElement(name, attrmap); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.push(std::string()); } } @@ -81,26 +81,26 @@ static void mlEndElement(void* userData, const char* name) { SessionData* sd = reinterpret_cast<SessionData*>(userData); std::string characters; - if(sd->_stm->needsCharactersBuffering()) { - characters = util::trim(sd->_charactersStack.top()); - sd->_charactersStack.pop(); + if(sd->stm_->needsCharactersBuffering()) { + characters = util::trim(sd->charactersStack_.top()); + sd->charactersStack_.pop(); } - sd->_stm->endElement(name, characters); + sd->stm_->endElement(name, characters); } static void mlCharacters(void* userData, const char* ch, int len) { SessionData* sd = reinterpret_cast<SessionData*>(userData); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.top() += std::string(&ch[0], &ch[len]); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.top() += std::string(&ch[0], &ch[len]); } } XmlRpcRequest XmlRpcRequestProcessor::parseMemory(const std::string& xml) { - _stm.reset(new XmlRpcRequestParserStateMachine()); - SharedHandle<SessionData> sessionData(new SessionData(_stm.get())); + stm_.reset(new XmlRpcRequestParserStateMachine()); + SharedHandle<SessionData> sessionData(new SessionData(stm_.get())); XML_Parser parser = XML_ParserCreate(0); @@ -114,11 +114,11 @@ XmlRpcRequestProcessor::parseMemory(const std::string& xml) if(r == XML_STATUS_ERROR) { throw DL_ABORT_EX(MSG_CANNOT_PARSE_XML_RPC_REQUEST); } - if(!asList(_stm->getCurrentFrameValue())) { + if(!asList(stm_->getCurrentFrameValue())) { throw DL_ABORT_EX("Bad XML-RPC parameter list"); } - return XmlRpcRequest(_stm->getMethodName(), - static_pointer_cast<List>(_stm->getCurrentFrameValue())); + return XmlRpcRequest(stm_->getMethodName(), + static_pointer_cast<List>(stm_->getCurrentFrameValue())); } } // namespace xmlrpc diff --git a/src/ExpatXmlRpcRequestProcessor.h b/src/ExpatXmlRpcRequestProcessor.h index 68a685a8..78f2e82d 100644 --- a/src/ExpatXmlRpcRequestProcessor.h +++ b/src/ExpatXmlRpcRequestProcessor.h @@ -50,7 +50,7 @@ class XmlRpcRequestParserStateMachine; class XmlRpcRequestProcessor { private: - SharedHandle<XmlRpcRequestParserStateMachine> _stm; + SharedHandle<XmlRpcRequestParserStateMachine> stm_; public: XmlRpcRequest parseMemory(const std::string& xml); }; diff --git a/src/ExtensionMessageRegistry.h b/src/ExtensionMessageRegistry.h index b261a6a5..f911028e 100644 --- a/src/ExtensionMessageRegistry.h +++ b/src/ExtensionMessageRegistry.h @@ -46,24 +46,24 @@ namespace aria2 { class ExtensionMessageRegistry { private: - Extensions _extensions; + Extensions extensions_; public: ExtensionMessageRegistry() { - _extensions["ut_pex"] = 8; + extensions_["ut_pex"] = 8; // http://www.bittorrent.org/beps/bep_0009.html - _extensions["ut_metadata"] = 9; + extensions_["ut_metadata"] = 9; } const Extensions& getExtensions() const { - return _extensions; + return extensions_; } uint8_t getExtensionMessageID(const std::string& name) const { - Extensions::const_iterator itr = _extensions.find(name); - if(itr == _extensions.end()) { + Extensions::const_iterator itr = extensions_.find(name); + if(itr == extensions_.end()) { return 0; } else { return (*itr).second; @@ -72,8 +72,8 @@ public: const std::string& getExtensionName(uint8_t id) const { - for(Extensions::const_iterator itr = _extensions.begin(), - eoi = _extensions.end(); itr != eoi; ++itr) { + for(Extensions::const_iterator itr = extensions_.begin(), + eoi = extensions_.end(); itr != eoi; ++itr) { const Extensions::value_type& p = *itr; if(p.second == id) { return p.first; @@ -84,7 +84,7 @@ public: void removeExtension(const std::string& name) { - _extensions.erase(name); + extensions_.erase(name); } }; diff --git a/src/FallocFileAllocationIterator.cc b/src/FallocFileAllocationIterator.cc index 2a6adef8..1fd53d68 100644 --- a/src/FallocFileAllocationIterator.cc +++ b/src/FallocFileAllocationIterator.cc @@ -39,31 +39,31 @@ namespace aria2 { FallocFileAllocationIterator::FallocFileAllocationIterator (BinaryStream* stream, off_t offset, uint64_t totalLength): - _stream(stream), _offset(offset), _totalLength(totalLength) {} + stream_(stream), offset_(offset), totalLength_(totalLength) {} void FallocFileAllocationIterator::allocateChunk() { - if(static_cast<uint64_t>(_offset) > _totalLength) { + if(static_cast<uint64_t>(offset_) > totalLength_) { throw DL_ABORT_EX("FallocFileAllocationIterator: offset is larger than" " totalLength"); } - _stream->allocate(_offset, _totalLength-_offset); - _offset = _totalLength; + stream_->allocate(offset_, totalLength_-offset_); + offset_ = totalLength_; } bool FallocFileAllocationIterator::finished() { - return static_cast<uint64_t>(_offset) == _totalLength; + return static_cast<uint64_t>(offset_) == totalLength_; } off_t FallocFileAllocationIterator::getCurrentLength() { - return _offset; + return offset_; } uint64_t FallocFileAllocationIterator::getTotalLength() { - return _totalLength; + return totalLength_; } } // namespace aria2 diff --git a/src/FallocFileAllocationIterator.h b/src/FallocFileAllocationIterator.h index 22f7e47e..413389f1 100644 --- a/src/FallocFileAllocationIterator.h +++ b/src/FallocFileAllocationIterator.h @@ -43,9 +43,9 @@ namespace aria2 { // Allocate disk space using posix_fallocate() system call. class FallocFileAllocationIterator:public FileAllocationIterator { private: - BinaryStream* _stream; - off_t _offset; - uint64_t _totalLength; + BinaryStream* stream_; + off_t offset_; + uint64_t totalLength_; public: FallocFileAllocationIterator(BinaryStream* stream, off_t offset, uint64_t totalLength); diff --git a/src/FeatureConfig.cc b/src/FeatureConfig.cc index cdf2022c..5a4d6032 100644 --- a/src/FeatureConfig.cc +++ b/src/FeatureConfig.cc @@ -42,7 +42,7 @@ namespace aria2 { -SharedHandle<FeatureConfig> FeatureConfig::_featureConfig; +SharedHandle<FeatureConfig> FeatureConfig::featureConfig_; const std::string FeatureConfig::FEATURE_HTTPS("HTTPS"); const std::string FeatureConfig::FEATURE_BITTORRENT("BitTorrent"); @@ -102,9 +102,9 @@ const std::string FeatureConfig::FEATURE_FIREFOX3_COOKIE("Firefox3 Cookie"); #endif // !HAVE_SQLITE3 FeatureConfig::FeatureConfig() { - _defaultPorts.insert(PortMap::value_type(Request::PROTO_HTTP, 80)); - _defaultPorts.insert(PortMap::value_type(Request::PROTO_HTTPS, 443)); - _defaultPorts.insert(PortMap::value_type(Request::PROTO_FTP, 21)); + defaultPorts_.insert(PortMap::value_type(Request::PROTO_HTTP, 80)); + defaultPorts_.insert(PortMap::value_type(Request::PROTO_HTTPS, 443)); + defaultPorts_.insert(PortMap::value_type(Request::PROTO_FTP, 21)); FeatureMap::value_type featureArray[] = { FeatureMap::value_type(FEATURE_HTTPS, HTTPS_ENABLED), @@ -117,21 +117,21 @@ FeatureConfig::FeatureConfig() { FeatureMap::value_type(FEATURE_FIREFOX3_COOKIE, FIREFOX3_COOKIE_ENABLED), }; - _features.insert(vbegin(featureArray), vend(featureArray)); + features_.insert(vbegin(featureArray), vend(featureArray)); } const SharedHandle<FeatureConfig>& FeatureConfig::getInstance() { - if(_featureConfig.isNull()) { - _featureConfig.reset(new FeatureConfig()); + if(featureConfig_.isNull()) { + featureConfig_.reset(new FeatureConfig()); } - return _featureConfig; + return featureConfig_; } uint16_t FeatureConfig::getDefaultPort(const std::string& protocol) const { - PortMap::const_iterator itr = _defaultPorts.find(protocol); - if(itr == _defaultPorts.end()) { + PortMap::const_iterator itr = defaultPorts_.find(protocol); + if(itr == defaultPorts_.end()) { return 0; } else { return itr->second; @@ -140,8 +140,8 @@ uint16_t FeatureConfig::getDefaultPort(const std::string& protocol) const bool FeatureConfig::isSupported(const std::string& feature) const { - FeatureMap::const_iterator itr = _features.find(feature); - if(itr == _features.end()) { + FeatureMap::const_iterator itr = features_.find(feature); + if(itr == features_.end()) { return false; } else { return itr->second; @@ -151,7 +151,7 @@ bool FeatureConfig::isSupported(const std::string& feature) const std::string FeatureConfig::featureSummary() const { std::string s; - for(FeatureMap::const_iterator i = _features.begin(), eoi = _features.end(); + for(FeatureMap::const_iterator i = features_.begin(), eoi = features_.end(); i != eoi; ++i) { if((*i).second) { s += (*i).first; diff --git a/src/FeatureConfig.h b/src/FeatureConfig.h index 05ef542e..1ad12b6b 100644 --- a/src/FeatureConfig.h +++ b/src/FeatureConfig.h @@ -49,10 +49,10 @@ typedef std::map<std::string, bool> FeatureMap; class FeatureConfig { private: - static SharedHandle<FeatureConfig> _featureConfig; + static SharedHandle<FeatureConfig> featureConfig_; - PortMap _defaultPorts; - FeatureMap _features; + PortMap defaultPorts_; + FeatureMap features_; FeatureConfig(); public: @@ -66,7 +66,7 @@ public: const FeatureMap& getFeatures() const { - return _features; + return features_; } static const std::string FEATURE_HTTPS; diff --git a/src/FeedbackURISelector.cc b/src/FeedbackURISelector.cc index 50535f38..7dd976ea 100644 --- a/src/FeedbackURISelector.cc +++ b/src/FeedbackURISelector.cc @@ -46,7 +46,7 @@ namespace aria2 { FeedbackURISelector::FeedbackURISelector (const SharedHandle<ServerStatMan>& serverStatMan): - _serverStatMan(serverStatMan) {} + serverStatMan_(serverStatMan) {} FeedbackURISelector::~FeedbackURISelector() {} @@ -77,7 +77,7 @@ std::string FeedbackURISelector::select(FileEntry* fileEntry) i != eoi; ++i) { Request r; r.setUri(*i); - SharedHandle<ServerStat> ss = _serverStatMan->find(r.getHost(), + SharedHandle<ServerStat> ss = serverStatMan_->find(r.getHost(), r.getProtocol()); if(!ss.isNull() && ss->isOK() && ss->getDownloadSpeed() > SPEED_THRESHOLD) { cands.push_back(std::pair<SharedHandle<ServerStat>, std::string>(ss, *i)); @@ -88,7 +88,7 @@ std::string FeedbackURISelector::select(FileEntry* fileEntry) i != eoi; ++i) { Request r; r.setUri(*i); - SharedHandle<ServerStat> ss = _serverStatMan->find(r.getHost(), + SharedHandle<ServerStat> ss = serverStatMan_->find(r.getHost(), r.getProtocol()); // Skip ERROR state URI if(ss.isNull() || ss->isOK()) { diff --git a/src/FeedbackURISelector.h b/src/FeedbackURISelector.h index bb6e525e..4fae38e6 100644 --- a/src/FeedbackURISelector.h +++ b/src/FeedbackURISelector.h @@ -43,7 +43,7 @@ class ServerStatMan; class FeedbackURISelector:public URISelector { private: - SharedHandle<ServerStatMan> _serverStatMan; + SharedHandle<ServerStatMan> serverStatMan_; public: FeedbackURISelector(const SharedHandle<ServerStatMan>& serverStatMan); diff --git a/src/File.cc b/src/File.cc index d22f37ee..ee9f13cd 100644 --- a/src/File.cc +++ b/src/File.cc @@ -54,12 +54,12 @@ namespace aria2 { # include <windows.h> #endif // __MINGW32__ -File::File(const std::string& name):_name(name) {} +File::File(const std::string& name):name_(name) {} File::~File() {} int File::fillStat(a2_struct_stat& fstat) { - return a2stat(_name.c_str(), &fstat); + return a2stat(name_.c_str(), &fstat); } bool File::exists() { @@ -85,9 +85,9 @@ bool File::isDir() { bool File::remove() { if(isFile()) { - return unlink(_name.c_str()) == 0; + return unlink(name_.c_str()) == 0; } else if(isDir()) { - return rmdir(_name.c_str()) == 0; + return rmdir(name_.c_str()) == 0; } else { return false; } @@ -106,13 +106,13 @@ bool File::mkdirs() { return false; } std::vector<std::string> dirs; - util::split(_name, std::back_inserter(dirs), "/"); + util::split(name_, std::back_inserter(dirs), "/"); if(!dirs.size()) { return true; } std::string accDir; - if(util::startsWith(_name, A2STR::SLASH_C)) { + if(util::startsWith(name_, A2STR::SLASH_C)) { accDir = A2STR::SLASH_C; } for(std::vector<std::string>::const_iterator itr = dirs.begin(), @@ -139,19 +139,19 @@ mode_t File::mode() std::string File::getBasename() const { - std::string::size_type lastSlashIndex = _name.find_last_of(A2STR::SLASH_C); + std::string::size_type lastSlashIndex = name_.find_last_of(A2STR::SLASH_C); if(lastSlashIndex == std::string::npos) { - return _name; + return name_; } else { - return _name.substr(lastSlashIndex+1); + return name_.substr(lastSlashIndex+1); } } std::string File::getDirname() const { - std::string::size_type lastSlashIndex = _name.find_last_of(A2STR::SLASH_C); + std::string::size_type lastSlashIndex = name_.find_last_of(A2STR::SLASH_C); if(lastSlashIndex == std::string::npos) { - if(_name.empty()) { + if(name_.empty()) { return A2STR::NIL; } else { return A2STR::DOT_C; @@ -159,7 +159,7 @@ std::string File::getDirname() const } else if(lastSlashIndex == 0) { return A2STR::SLASH_C; } else { - return _name.substr(0, lastSlashIndex); + return name_.substr(0, lastSlashIndex); } } @@ -178,8 +178,8 @@ bool File::renameTo(const std::string& dest) } } #endif // __MINGW32__ - if(rename(_name.c_str(), dest.c_str()) == 0) { - _name = dest; + if(rename(name_.c_str(), dest.c_str()) == 0) { + name_ = dest; return true; } else { return false; @@ -191,7 +191,7 @@ bool File::utime(const Time& actime, const Time& modtime) const struct utimbuf ub; ub.actime = actime.getTime(); ub.modtime = modtime.getTime(); - return ::utime(_name.c_str(), &ub) == 0; + return ::utime(name_.c_str(), &ub) == 0; } Time File::getModifiedTime() @@ -49,7 +49,7 @@ namespace aria2 { */ class File { private: - std::string _name; + std::string name_; /** * Returns the return value of stat(...) @@ -99,7 +99,7 @@ public: const std::string& getPath() const { - return _name; + return name_; } static bool isDir(const std::string& filename); diff --git a/src/FileAllocationCommand.cc b/src/FileAllocationCommand.cc index eeb85a96..8d67a68b 100644 --- a/src/FileAllocationCommand.cc +++ b/src/FileAllocationCommand.cc @@ -56,7 +56,7 @@ FileAllocationCommand::FileAllocationCommand (cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e, const SharedHandle<FileAllocationEntry>& fileAllocationEntry): RealtimeCommand(cuid, requestGroup, e), - _fileAllocationEntry(fileAllocationEntry) {} + fileAllocationEntry_(fileAllocationEntry) {} FileAllocationCommand::~FileAllocationCommand() {} @@ -66,19 +66,19 @@ bool FileAllocationCommand::executeInternal() getDownloadEngine()->getFileAllocationMan()->dropPickedEntry(); return true; } - _fileAllocationEntry->allocateChunk(); - if(_fileAllocationEntry->finished()) { + fileAllocationEntry_->allocateChunk(); + if(fileAllocationEntry_->finished()) { if(getLogger()->debug()) { getLogger()->debug (MSG_ALLOCATION_COMPLETED, - _timer.difference(global::wallclock), + timer_.difference(global::wallclock), util::itos(getRequestGroup()->getTotalLength(), true).c_str()); } getDownloadEngine()->getFileAllocationMan()->dropPickedEntry(); std::vector<Command*>* commands = new std::vector<Command*>(); auto_delete_container<std::vector<Command*> > commandsDel(commands); - _fileAllocationEntry->prepareForNextAction(*commands, getDownloadEngine()); + fileAllocationEntry_->prepareForNextAction(*commands, getDownloadEngine()); getDownloadEngine()->addCommand(*commands); commands->clear(); getDownloadEngine()->setNoWait(true); diff --git a/src/FileAllocationCommand.h b/src/FileAllocationCommand.h index 4aaecf73..9b05f91c 100644 --- a/src/FileAllocationCommand.h +++ b/src/FileAllocationCommand.h @@ -45,8 +45,8 @@ class FileAllocationEntry; class FileAllocationCommand : public RealtimeCommand { private: - SharedHandle<FileAllocationEntry> _fileAllocationEntry; - Timer _timer; + SharedHandle<FileAllocationEntry> fileAllocationEntry_; + Timer timer_; public: FileAllocationCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e, diff --git a/src/FileAllocationEntry.cc b/src/FileAllocationEntry.cc index dc9cee6c..441363d5 100644 --- a/src/FileAllocationEntry.cc +++ b/src/FileAllocationEntry.cc @@ -47,7 +47,7 @@ namespace aria2 { FileAllocationEntry::FileAllocationEntry(RequestGroup* requestGroup, Command* nextCommand): RequestGroupEntry(requestGroup, nextCommand), - _fileAllocationIterator(requestGroup->getPieceStorage()->getDiskAdaptor()->fileAllocationIterator()) + fileAllocationIterator_(requestGroup->getPieceStorage()->getDiskAdaptor()->fileAllocationIterator()) { getRequestGroup()->getPieceStorage()->getDiskAdaptor()->enableDirectIO(); } @@ -59,22 +59,22 @@ FileAllocationEntry:: ~FileAllocationEntry() off_t FileAllocationEntry::getCurrentLength() { - return _fileAllocationIterator->getCurrentLength(); + return fileAllocationIterator_->getCurrentLength(); } uint64_t FileAllocationEntry::getTotalLength() { - return _fileAllocationIterator->getTotalLength(); + return fileAllocationIterator_->getTotalLength(); } bool FileAllocationEntry::finished() { - return _fileAllocationIterator->finished(); + return fileAllocationIterator_->finished(); } void FileAllocationEntry::allocateChunk() { - _fileAllocationIterator->allocateChunk(); + fileAllocationIterator_->allocateChunk(); } void FileAllocationEntry::disableDirectIO() diff --git a/src/FileAllocationEntry.h b/src/FileAllocationEntry.h index 7d423da2..9790fea6 100644 --- a/src/FileAllocationEntry.h +++ b/src/FileAllocationEntry.h @@ -48,7 +48,7 @@ class DownloadEngine; class FileAllocationEntry : public RequestGroupEntry, public ProgressAwareEntry { private: - SharedHandle<FileAllocationIterator> _fileAllocationIterator; + SharedHandle<FileAllocationIterator> fileAllocationIterator_; public: FileAllocationEntry(RequestGroup* requestGroup, Command* nextCommand = 0); diff --git a/src/FileEntry.cc b/src/FileEntry.cc index b20389b5..c949b0b1 100644 --- a/src/FileEntry.cc +++ b/src/FileEntry.cc @@ -48,38 +48,38 @@ FileEntry::FileEntry(const std::string& path, uint64_t length, off_t offset, const std::vector<std::string>& uris): - _path(path), _uris(uris.begin(), uris.end()), _length(length), - _offset(offset), - _requested(true), - _singleHostMultiConnection(true), - _logger(LogFactory::getInstance()) {} + path_(path), uris_(uris.begin(), uris.end()), length_(length), + offset_(offset), + requested_(true), + singleHostMultiConnection_(true), + logger_(LogFactory::getInstance()) {} FileEntry::FileEntry(): - _length(0), _offset(0), _requested(false), - _singleHostMultiConnection(true), - _logger(LogFactory::getInstance()) {} + length_(0), offset_(0), requested_(false), + singleHostMultiConnection_(true), + logger_(LogFactory::getInstance()) {} FileEntry::~FileEntry() {} void FileEntry::setupDir() { - util::mkdirs(File(_path).getDirname()); + util::mkdirs(File(path_).getDirname()); } FileEntry& FileEntry::operator=(const FileEntry& entry) { if(this != &entry) { - _path = entry._path; - _length = entry._length; - _offset = entry._offset; - _requested = entry._requested; + path_ = entry.path_; + length_ = entry.length_; + offset_ = entry.offset_; + requested_ = entry.requested_; } return *this; } bool FileEntry::operator<(const FileEntry& fileEntry) const { - return _offset < fileEntry._offset; + return offset_ < fileEntry.offset_; } bool FileEntry::exists() const @@ -89,14 +89,14 @@ bool FileEntry::exists() const off_t FileEntry::gtoloff(off_t goff) const { - assert(_offset <= goff); - return goff-_offset; + assert(offset_ <= goff); + return goff-offset_; } void FileEntry::getUris(std::vector<std::string>& uris) const { - uris.insert(uris.end(), _spentUris.begin(), _spentUris.end()); - uris.insert(uris.end(), _uris.begin(), _uris.end()); + uris.insert(uris.end(), spentUris_.begin(), spentUris_.end()); + uris.insert(uris.end(), uris_.begin(), uris_.end()); } std::string FileEntry::selectUri(const SharedHandle<URISelector>& uriSelector) @@ -125,7 +125,7 @@ FileEntry::getRequest const std::string& method) { SharedHandle<Request> req; - if(_requestPool.empty()) { + if(requestPool_.empty()) { std::vector<std::string> pending; while(1) { std::string uri = selector->select(this); @@ -134,8 +134,8 @@ FileEntry::getRequest } req.reset(new Request()); if(req->setUri(uri)) { - if(!_singleHostMultiConnection) { - if(inFlightHost(_inFlightRequests.begin(), _inFlightRequests.end(), + if(!singleHostMultiConnection_) { + if(inFlightHost(inFlightRequests_.begin(), inFlightRequests_.end(), req->getHost())) { pending.push_back(uri); req.reset(); @@ -144,18 +144,18 @@ FileEntry::getRequest } req->setReferer(referer); req->setMethod(method); - _spentUris.push_back(uri); - _inFlightRequests.push_back(req); + spentUris_.push_back(uri); + inFlightRequests_.push_back(req); break; } else { req.reset(); } } - _uris.insert(_uris.begin(), pending.begin(), pending.end()); + uris_.insert(uris_.begin(), pending.begin(), pending.end()); } else { - req = _requestPool.front(); - _requestPool.pop_front(); - _inFlightRequests.push_back(req); + req = requestPool_.front(); + requestPool_.pop_front(); + inFlightRequests_.push_back(req); } return req; } @@ -163,10 +163,10 @@ FileEntry::getRequest SharedHandle<Request> FileEntry::findFasterRequest(const SharedHandle<Request>& base) { - if(_requestPool.empty()) { + if(requestPool_.empty()) { return SharedHandle<Request>(); } - const SharedHandle<PeerStat>& fastest = _requestPool.front()->getPeerStat(); + const SharedHandle<PeerStat>& fastest = requestPool_.front()->getPeerStat(); if(fastest.isNull()) { return SharedHandle<Request>(); } @@ -178,9 +178,9 @@ FileEntry::findFasterRequest(const SharedHandle<Request>& base) difference(global::wallclock) >= startupIdleTime && fastest->getAvgDownloadSpeed()*0.8 > basestat->calculateDownloadSpeed())){ // TODO we should consider that "fastest" is very slow. - SharedHandle<Request> fastestRequest = _requestPool.front(); - _requestPool.pop_front(); - _inFlightRequests.push_back(fastestRequest); + SharedHandle<Request> fastestRequest = requestPool_.front(); + requestPool_.pop_front(); + inFlightRequests_.push_back(fastestRequest); return fastestRequest; } return SharedHandle<Request>(); @@ -211,9 +211,9 @@ void FileEntry::storePool(const SharedHandle<Request>& request) peerStat->calculateAvgDownloadSpeed(); } std::deque<SharedHandle<Request> >::iterator i = - std::lower_bound(_requestPool.begin(), _requestPool.end(), request, + std::lower_bound(requestPool_.begin(), requestPool_.end(), request, RequestFaster()); - _requestPool.insert(i, request); + requestPool_.insert(i, request); } void FileEntry::poolRequest(const SharedHandle<Request>& request) @@ -227,10 +227,10 @@ void FileEntry::poolRequest(const SharedHandle<Request>& request) bool FileEntry::removeRequest(const SharedHandle<Request>& request) { for(std::deque<SharedHandle<Request> >::iterator i = - _inFlightRequests.begin(), eoi = _inFlightRequests.end(); + inFlightRequests_.begin(), eoi = inFlightRequests_.end(); i != eoi; ++i) { if((*i).get() == request.get()) { - _inFlightRequests.erase(i); + inFlightRequests_.erase(i); return true; } } @@ -241,39 +241,39 @@ void FileEntry::removeURIWhoseHostnameIs(const std::string& hostname) { std::deque<std::string> newURIs; Request req; - for(std::deque<std::string>::const_iterator itr = _uris.begin(), - eoi = _uris.end(); itr != eoi; ++itr) { + for(std::deque<std::string>::const_iterator itr = uris_.begin(), + eoi = uris_.end(); itr != eoi; ++itr) { if(((*itr).find(hostname) == std::string::npos) || (req.setUri(*itr) && (req.getHost() != hostname))) { newURIs.push_back(*itr); } } - if(_logger->debug()) { - _logger->debug("Removed %d duplicate hostname URIs for path=%s", - _uris.size()-newURIs.size(), getPath().c_str()); + if(logger_->debug()) { + logger_->debug("Removed %d duplicate hostname URIs for path=%s", + uris_.size()-newURIs.size(), getPath().c_str()); } - _uris = newURIs; + uris_ = newURIs; } void FileEntry::removeIdenticalURI(const std::string& uri) { - _uris.erase(std::remove(_uris.begin(), _uris.end(), uri), _uris.end()); + uris_.erase(std::remove(uris_.begin(), uris_.end(), uri), uris_.end()); } void FileEntry::addURIResult(std::string uri, downloadresultcode::RESULT result) { - _uriResults.push_back(URIResult(uri, result)); + uriResults_.push_back(URIResult(uri, result)); } class FindURIResultByResult { private: - downloadresultcode::RESULT _r; + downloadresultcode::RESULT r_; public: - FindURIResultByResult(downloadresultcode::RESULT r):_r(r) {} + FindURIResultByResult(downloadresultcode::RESULT r):r_(r) {} bool operator()(const URIResult& uriResult) const { - return uriResult.getResult() == _r; + return uriResult.getResult() == r_; } }; @@ -281,20 +281,20 @@ void FileEntry::extractURIResult (std::deque<URIResult>& res, downloadresultcode::RESULT r) { std::deque<URIResult>::iterator i = - std::stable_partition(_uriResults.begin(), _uriResults.end(), + std::stable_partition(uriResults_.begin(), uriResults_.end(), FindURIResultByResult(r)); - std::copy(_uriResults.begin(), i, std::back_inserter(res)); - _uriResults.erase(_uriResults.begin(), i); + std::copy(uriResults_.begin(), i, std::back_inserter(res)); + uriResults_.erase(uriResults_.begin(), i); } void FileEntry::reuseUri(size_t num) { - std::deque<std::string> uris = _spentUris; + std::deque<std::string> uris = spentUris_; std::sort(uris.begin(), uris.end()); uris.erase(std::unique(uris.begin(), uris.end()), uris.end()); - std::vector<std::string> errorUris(_uriResults.size()); - std::transform(_uriResults.begin(), _uriResults.end(), + std::vector<std::string> errorUris(uriResults_.size()); + std::transform(uriResults_.begin(), uriResults_.end(), errorUris.begin(), std::mem_fun_ref(&URIResult::getURI)); std::sort(errorUris.begin(), errorUris.end()); errorUris.erase(std::unique(errorUris.begin(), errorUris.end()), @@ -305,32 +305,32 @@ void FileEntry::reuseUri(size_t num) errorUris.begin(), errorUris.end(), std::back_inserter(reusableURIs)); size_t ininum = reusableURIs.size(); - if(_logger->debug()) { - _logger->debug("Found %u reusable URIs", static_cast<unsigned int>(ininum)); + if(logger_->debug()) { + logger_->debug("Found %u reusable URIs", static_cast<unsigned int>(ininum)); for(std::vector<std::string>::const_iterator i = reusableURIs.begin(), eoi = reusableURIs.end(); i != eoi; ++i) { - _logger->debug("URI=%s", (*i).c_str()); + logger_->debug("URI=%s", (*i).c_str()); } } // Reuse at least num URIs here to avoid to // run this process repeatedly. if(ininum > 0) { for(size_t i = 0; i < num/ininum; ++i) { - _uris.insert(_uris.end(), reusableURIs.begin(), reusableURIs.end()); + uris_.insert(uris_.end(), reusableURIs.begin(), reusableURIs.end()); } - _uris.insert(_uris.end(), reusableURIs.begin(), + uris_.insert(uris_.end(), reusableURIs.begin(), reusableURIs.begin()+(num%ininum)); - if(_logger->debug()) { - _logger->debug("Duplication complete: now %u URIs for reuse", - static_cast<unsigned int>(_uris.size())); + if(logger_->debug()) { + logger_->debug("Duplication complete: now %u URIs for reuse", + static_cast<unsigned int>(uris_.size())); } } } void FileEntry::releaseRuntimeResource() { - _requestPool.clear(); - _inFlightRequests.clear(); + requestPool_.clear(); + inFlightRequests_.clear(); } template<typename InputIterator, typename T> @@ -348,27 +348,27 @@ static InputIterator findRequestByUri bool FileEntry::removeUri(const std::string& uri) { std::deque<std::string>::iterator itr = - std::find(_spentUris.begin(), _spentUris.end(), uri); - if(itr == _spentUris.end()) { - itr = std::find(_uris.begin(), _uris.end(), uri); - if(itr == _uris.end()) { + std::find(spentUris_.begin(), spentUris_.end(), uri); + if(itr == spentUris_.end()) { + itr = std::find(uris_.begin(), uris_.end(), uri); + if(itr == uris_.end()) { return false; } else { - _uris.erase(itr); + uris_.erase(itr); return true; } } else { - _spentUris.erase(itr); + spentUris_.erase(itr); SharedHandle<Request> req; std::deque<SharedHandle<Request> >::iterator riter = - findRequestByUri(_inFlightRequests.begin(), _inFlightRequests.end(), uri); - if(riter == _inFlightRequests.end()) { - riter = findRequestByUri(_requestPool.begin(), _requestPool.end(), uri); - if(riter == _requestPool.end()) { + findRequestByUri(inFlightRequests_.begin(), inFlightRequests_.end(), uri); + if(riter == inFlightRequests_.end()) { + riter = findRequestByUri(requestPool_.begin(), requestPool_.end(), uri); + if(riter == requestPool_.end()) { return true; } else { req = *riter; - _requestPool.erase(riter); + requestPool_.erase(riter); } } else { req = *riter; @@ -380,24 +380,24 @@ bool FileEntry::removeUri(const std::string& uri) std::string FileEntry::getBasename() const { - return File(_path).getBasename(); + return File(path_).getBasename(); } std::string FileEntry::getDirname() const { - return File(_path).getDirname(); + return File(path_).getDirname(); } size_t FileEntry::setUris(const std::vector<std::string>& uris) { - _uris.clear(); + uris_.clear(); return addUris(uris.begin(), uris.end()); } bool FileEntry::addUri(const std::string& uri) { if(Request().setUri(uri)) { - _uris.push_back(uri); + uris_.push_back(uri); return true; } else { return false; @@ -407,8 +407,8 @@ bool FileEntry::addUri(const std::string& uri) bool FileEntry::insertUri(const std::string& uri, size_t pos) { if(Request().setUri(uri)) { - pos = std::min(pos, _uris.size()); - _uris.insert(_uris.begin()+pos, uri); + pos = std::min(pos, uris_.size()); + uris_.insert(uris_.begin()+pos, uri); return true; } else { return false; diff --git a/src/FileEntry.h b/src/FileEntry.h index 8e5e2687..4328b0fb 100644 --- a/src/FileEntry.h +++ b/src/FileEntry.h @@ -57,21 +57,21 @@ class Logger; class FileEntry { private: - std::string _path; - std::deque<std::string> _uris; - std::deque<std::string> _spentUris; - uint64_t _length; - off_t _offset; - bool _requested; - std::deque<SharedHandle<Request> > _requestPool; - std::deque<SharedHandle<Request> > _inFlightRequests; - std::string _contentType; + std::string path_; + std::deque<std::string> uris_; + std::deque<std::string> spentUris_; + uint64_t length_; + off_t offset_; + bool requested_; + std::deque<SharedHandle<Request> > requestPool_; + std::deque<SharedHandle<Request> > inFlightRequests_; + std::string contentType_; // URIResult is stored in the ascending order of the time when its result is // available. - std::deque<URIResult> _uriResults; - bool _singleHostMultiConnection; - std::string _originalName; - Logger* _logger; + std::deque<URIResult> uriResults_; + bool singleHostMultiConnection_; + std::string originalName_; + Logger* logger_; void storePool(const SharedHandle<Request>& request); public: @@ -88,39 +88,39 @@ public: std::string getDirname() const; - const std::string& getPath() const { return _path; } + const std::string& getPath() const { return path_; } - void setPath(const std::string& path) { _path = path; } + void setPath(const std::string& path) { path_ = path; } - uint64_t getLength() const { return _length; } + uint64_t getLength() const { return length_; } - void setLength(uint64_t length) { _length = length; } + void setLength(uint64_t length) { length_ = length; } - off_t getOffset() const { return _offset; } + off_t getOffset() const { return offset_; } - void setOffset(off_t offset) { _offset = offset; } + void setOffset(off_t offset) { offset_ = offset; } - off_t getLastOffset() { return _offset+_length; } + off_t getLastOffset() { return offset_+length_; } - bool isRequested() const { return _requested; } + bool isRequested() const { return requested_; } - void setRequested(bool flag) { _requested = flag; } + void setRequested(bool flag) { requested_ = flag; } void setupDir(); const std::deque<std::string>& getRemainingUris() const { - return _uris; + return uris_; } std::deque<std::string>& getRemainingUris() { - return _uris; + return uris_; } const std::deque<std::string>& getSpentUris() const { - return _spentUris; + return spentUris_; } size_t setUris(const std::vector<std::string>& uris); @@ -141,15 +141,15 @@ public: bool insertUri(const std::string& uri, size_t pos); - // Inserts _uris and _spentUris into uris. + // Inserts uris_ and spentUris_ into uris. void getUris(std::vector<std::string>& uris) const; void setContentType(const std::string& contentType) { - _contentType = contentType; + contentType_ = contentType; } - const std::string& getContentType() const { return _contentType; } + const std::string& getContentType() const { return contentType_; } std::string selectUri(const SharedHandle<URISelector>& uriSelector); @@ -177,17 +177,17 @@ public: size_t countInFlightRequest() const { - return _inFlightRequests.size(); + return inFlightRequests_.size(); } size_t countPooledRequest() const { - return _requestPool.size(); + return requestPool_.size(); } const std::deque<SharedHandle<Request> >& getInFlightRequests() const { - return _inFlightRequests; + return inFlightRequests_; } bool operator<(const FileEntry& fileEntry) const; @@ -205,22 +205,22 @@ public: const std::deque<URIResult>& getURIResults() const { - return _uriResults; + return uriResults_; } // Extracts URIResult whose _result is r and stores them into res. - // The extracted URIResults are removed from _uriResults. + // The extracted URIResults are removed from uriResults_. void extractURIResult (std::deque<URIResult>& res, downloadresultcode::RESULT r); void disableSingleHostMultiConnection() { - _singleHostMultiConnection = false; + singleHostMultiConnection_ = false; } bool isSingleHostMultiConnectionEnabled() const { - return _singleHostMultiConnection; + return singleHostMultiConnection_; } // Reuse URIs which have not emitted error so far. Thie method @@ -233,19 +233,19 @@ public: void setOriginalName(const std::string& originalName) { - _originalName = originalName; + originalName_ = originalName; } const std::string& getOriginalName() const { - return _originalName; + return originalName_; } bool removeUri(const std::string& uri); bool emptyRequestUri() const { - return _uris.empty() && _inFlightRequests.empty() && _requestPool.empty(); + return uris_.empty() && inFlightRequests_.empty() && requestPool_.empty(); } }; diff --git a/src/FillRequestGroupCommand.cc b/src/FillRequestGroupCommand.cc index f9bc38b0..0934ebc8 100644 --- a/src/FillRequestGroupCommand.cc +++ b/src/FillRequestGroupCommand.cc @@ -49,7 +49,7 @@ namespace aria2 { FillRequestGroupCommand::FillRequestGroupCommand(cuid_t cuid, DownloadEngine* e): Command(cuid), - _e(e) + e_(e) { setStatusRealtime(); } @@ -58,17 +58,17 @@ FillRequestGroupCommand::~FillRequestGroupCommand() {} bool FillRequestGroupCommand::execute() { - if(_e->isHaltRequested()) { + if(e_->isHaltRequested()) { return true; } - SharedHandle<RequestGroupMan> rgman = _e->getRequestGroupMan(); + SharedHandle<RequestGroupMan> rgman = e_->getRequestGroupMan(); if(rgman->queueCheckRequested()) { try { // During adding RequestGroup, // RequestGroupMan::requestQueueCheck() might be called, so // first clear it here. rgman->clearQueueCheck(); - rgman->fillRequestGroupFromReserver(_e); + rgman->fillRequestGroupFromReserver(e_); } catch(RecoverableException& ex) { getLogger()->error(EX_EXCEPTION_CAUGHT, ex); // Re-request queue check to fulfill the requests of all @@ -79,7 +79,7 @@ bool FillRequestGroupCommand::execute() return true; } } - _e->addRoutineCommand(this); + e_->addRoutineCommand(this); return false; } diff --git a/src/FillRequestGroupCommand.h b/src/FillRequestGroupCommand.h index 55cb115b..b5064f63 100644 --- a/src/FillRequestGroupCommand.h +++ b/src/FillRequestGroupCommand.h @@ -46,7 +46,7 @@ class DownloadEngine; class FillRequestGroupCommand : public Command { private: - DownloadEngine* _e; + DownloadEngine* e_; public: FillRequestGroupCommand(cuid_t cuid, DownloadEngine* e); diff --git a/src/FixedWidthNumberDecorator.h b/src/FixedWidthNumberDecorator.h index 79e96813..7689c962 100644 --- a/src/FixedWidthNumberDecorator.h +++ b/src/FixedWidthNumberDecorator.h @@ -43,16 +43,16 @@ namespace aria2 { class FixedWidthNumberDecorator : public NumberDecorator { private: - size_t _width; + size_t width_; public: - FixedWidthNumberDecorator(size_t width):_width(width) {} + FixedWidthNumberDecorator(size_t width):width_(width) {} virtual ~FixedWidthNumberDecorator() {} virtual std::string decorate(unsigned int number) { std::string s = util::uitos(number); - while(s.size() < _width) { + while(s.size() < width_) { s.insert(0, "0"); } return s; diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc index c1b31f73..2c454a32 100644 --- a/src/FtpConnection.cc +++ b/src/FtpConnection.cc @@ -66,51 +66,51 @@ FtpConnection::FtpConnection(cuid_t cuid, const SocketHandle& socket, const SharedHandle<Request>& req, const SharedHandle<AuthConfig>& authConfig, const Option* op): - _cuid(cuid), _socket(socket), _req(req), - _authConfig(authConfig), _option(op), - _logger(LogFactory::getInstance()), - _socketBuffer(socket), - _baseWorkingDir("/") {} + cuid_(cuid), socket_(socket), req_(req), + authConfig_(authConfig), option_(op), + logger_(LogFactory::getInstance()), + socketBuffer_(socket), + baseWorkingDir_("/") {} FtpConnection::~FtpConnection() {} bool FtpConnection::sendUser() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "USER "; - request += _authConfig->getUser(); + request += authConfig_->getUser(); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(),"USER ********"); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(),"USER ********"); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendPass() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "PASS "; - request += _authConfig->getPassword(); + request += authConfig_->getPassword(); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(),"PASS ********"); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(),"PASS ********"); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendType() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string type; - if(_option->get(PREF_FTP_TYPE) == V_ASCII) { + if(option_->get(PREF_FTP_TYPE) == V_ASCII) { type = FtpConnection::A; } else { type = FtpConnection::I; @@ -118,97 +118,97 @@ bool FtpConnection::sendType() std::string request = "TYPE "; request += type; request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(),request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(),request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendPwd() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "PWD\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(),request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(),request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendCwd() { - if(_socketBuffer.sendBufferIsEmpty()) { - if(_logger->info()) { - _logger->info("CUID#%s - Using base working directory '%s'", - util::itos(_cuid).c_str(), _baseWorkingDir.c_str()); + if(socketBuffer_.sendBufferIsEmpty()) { + if(logger_->info()) { + logger_->info("CUID#%s - Using base working directory '%s'", + util::itos(cuid_).c_str(), baseWorkingDir_.c_str()); } std::string request = "CWD "; - if(_baseWorkingDir != "/") { - request += _baseWorkingDir; + if(baseWorkingDir_ != "/") { + request += baseWorkingDir_; } - request += util::percentDecode(_req->getDir()); + request += util::percentDecode(req_->getDir()); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(),request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(),request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendMdtm() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "MDTM "; - request += util::percentDecode(_req->getFile()); + request += util::percentDecode(req_->getFile()); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendSize() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "SIZE "; - request += util::percentDecode(_req->getFile()); + request += util::percentDecode(req_->getFile()); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendPasv() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { static const std::string request("PASV\r\n"); - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } SharedHandle<SocketCore> FtpConnection::createServerSocket() @@ -222,9 +222,9 @@ SharedHandle<SocketCore> FtpConnection::createServerSocket() bool FtpConnection::sendPort(const SharedHandle<SocketCore>& serverSocket) { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::pair<std::string, uint16_t> addrinfo; - _socket->getAddrInfo(addrinfo); + socket_->getAddrInfo(addrinfo); unsigned int ipaddr[4]; sscanf(addrinfo.first.c_str(), "%u.%u.%u.%u", &ipaddr[0], &ipaddr[1], &ipaddr[2], &ipaddr[3]); @@ -242,19 +242,19 @@ bool FtpConnection::sendPort(const SharedHandle<SocketCore>& serverSocket) request += ","; request += util::uitos(addrinfo.second%256); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendRest(const SharedHandle<Segment>& segment) { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "REST "; if(segment.isNull()) { request += "0"; @@ -262,30 +262,30 @@ bool FtpConnection::sendRest(const SharedHandle<Segment>& segment) request += util::itos(segment->getPositionToWrite()); } request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool FtpConnection::sendRetr() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { std::string request = "RETR "; - request += util::percentDecode(_req->getFile()); + request += util::percentDecode(req_->getFile()); request += "\r\n"; - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), request.c_str()); + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), request.c_str()); } - _socketBuffer.pushStr(request); + socketBuffer_.pushStr(request); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } unsigned int FtpConnection::getStatus(const std::string& response) const @@ -347,25 +347,25 @@ bool FtpConnection::bulkReceiveResponse (std::pair<unsigned int, std::string>& response) { char buf[1024]; - while(_socket->isReadable(0)) { + while(socket_->isReadable(0)) { size_t size = sizeof(buf); - _socket->readData(buf, size); + socket_->readData(buf, size); if(size == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return false; } throw DL_RETRY_EX(EX_GOT_EOF); } - if(_strbuf.size()+size > MAX_RECV_BUFFER) { + if(strbuf_.size()+size > MAX_RECV_BUFFER) { throw DL_RETRY_EX (StringFormat("Max FTP recv buffer reached. length=%lu", - static_cast<unsigned long>(_strbuf.size()+size)).str()); + static_cast<unsigned long>(strbuf_.size()+size)).str()); } - _strbuf.append(&buf[0], &buf[size]); + strbuf_.append(&buf[0], &buf[size]); } unsigned int status; - if(_strbuf.size() >= 4) { - status = getStatus(_strbuf); + if(strbuf_.size() >= 4) { + status = getStatus(strbuf_); if(status == 0) { throw DL_ABORT_EX(EX_INVALID_RESPONSE); } @@ -373,14 +373,14 @@ bool FtpConnection::bulkReceiveResponse return false; } std::string::size_type length; - if((length = findEndOfResponse(status, _strbuf)) != std::string::npos) { + if((length = findEndOfResponse(status, strbuf_)) != std::string::npos) { response.first = status; - response.second = _strbuf.substr(0, length); - if(_logger->info()) { - _logger->info(MSG_RECEIVE_RESPONSE, - util::itos(_cuid).c_str(), response.second.c_str()); + response.second = strbuf_.substr(0, length); + if(logger_->info()) { + logger_->info(MSG_RECEIVE_RESPONSE, + util::itos(cuid_).c_str(), response.second.c_str()); } - _strbuf.erase(0, length); + strbuf_.erase(0, length); return true; } else { // didn't receive response fully. @@ -517,12 +517,12 @@ unsigned int FtpConnection::receivePwdResponse(std::string& pwd) void FtpConnection::setBaseWorkingDir(const std::string& baseWorkingDir) { - _baseWorkingDir = baseWorkingDir; + baseWorkingDir_ = baseWorkingDir; } const std::string& FtpConnection::getUser() const { - return _authConfig->getUser(); + return authConfig_->getUser(); } } // namespace aria2 diff --git a/src/FtpConnection.h b/src/FtpConnection.h index 7407eaad..b973c597 100644 --- a/src/FtpConnection.h +++ b/src/FtpConnection.h @@ -56,20 +56,20 @@ class AuthConfig; class FtpConnection { private: - cuid_t _cuid; - SharedHandle<SocketCore> _socket; - SharedHandle<Request> _req; + cuid_t cuid_; + SharedHandle<SocketCore> socket_; + SharedHandle<Request> req_; - SharedHandle<AuthConfig> _authConfig; + SharedHandle<AuthConfig> authConfig_; - const Option* _option; - Logger* _logger; + const Option* option_; + Logger* logger_; - std::string _strbuf; + std::string strbuf_; - SocketBuffer _socketBuffer; + SocketBuffer socketBuffer_; - std::string _baseWorkingDir; + std::string baseWorkingDir_; unsigned int getStatus(const std::string& response) const; std::string::size_type findEndOfResponse(unsigned int status, @@ -117,7 +117,7 @@ public: const std::string& getBaseWorkingDir() const { - return _baseWorkingDir; + return baseWorkingDir_; } const std::string& getUser() const; diff --git a/src/FtpDownloadCommand.cc b/src/FtpDownloadCommand.cc index 02023277..4d20c3c7 100644 --- a/src/FtpDownloadCommand.cc +++ b/src/FtpDownloadCommand.cc @@ -61,8 +61,8 @@ FtpDownloadCommand::FtpDownloadCommand const SocketHandle& dataSocket, const SocketHandle& ctrlSocket) :DownloadCommand(cuid, req, fileEntry, requestGroup, e, dataSocket), - _ftpConnection(ftpConnection), - _ctrlSocket(ctrlSocket) {} + ftpConnection_(ftpConnection), + ctrlSocket_(ctrlSocket) {} FtpDownloadCommand::~FtpDownloadCommand() {} @@ -75,7 +75,7 @@ bool FtpDownloadCommand::prepareForNextSegment() getFileEntry()->getLength()) { Command* command = new FtpFinishDownloadCommand (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), - _ftpConnection, getDownloadEngine(), _ctrlSocket); + ftpConnection_, getDownloadEngine(), ctrlSocket_); getDownloadEngine()->addCommand(command); if(getRequestGroup()->downloadFinished()) { diff --git a/src/FtpDownloadCommand.h b/src/FtpDownloadCommand.h index bd5b4d0a..dd6e7196 100644 --- a/src/FtpDownloadCommand.h +++ b/src/FtpDownloadCommand.h @@ -43,9 +43,9 @@ class FtpConnection; class FtpDownloadCommand : public DownloadCommand { private: - SharedHandle<FtpConnection> _ftpConnection; + 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 f3090eec..f0436759 100644 --- a/src/FtpFinishDownloadCommand.cc +++ b/src/FtpFinishDownloadCommand.cc @@ -64,7 +64,7 @@ FtpFinishDownloadCommand::FtpFinishDownloadCommand DownloadEngine* e, const SharedHandle<SocketCore>& socket) :AbstractCommand(cuid, req, fileEntry, requestGroup, e, socket), - _ftpConnection(ftpConnection) + ftpConnection_(ftpConnection) {} // overrides AbstractCommand::execute(). @@ -75,7 +75,7 @@ bool FtpFinishDownloadCommand::execute() return true; } try { - unsigned int status = _ftpConnection->receiveResponse(); + unsigned int status = ftpConnection_->receiveResponse(); if(status == 0) { getDownloadEngine()->addCommand(this); return false; @@ -85,9 +85,9 @@ bool FtpFinishDownloadCommand::execute() } if(getOption()->getAsBool(PREF_FTP_REUSE_CONNECTION)) { std::map<std::string, std::string> options; - options["baseWorkingDir"] = _ftpConnection->getBaseWorkingDir(); + options["baseWorkingDir"] = ftpConnection_->getBaseWorkingDir(); getDownloadEngine()->poolSocket - (getRequest(), _ftpConnection->getUser(), createProxyRequest(), + (getRequest(), ftpConnection_->getUser(), createProxyRequest(), getSocket(), options); } } catch(RecoverableException& e) { diff --git a/src/FtpFinishDownloadCommand.h b/src/FtpFinishDownloadCommand.h index 2b75875b..28f970c4 100644 --- a/src/FtpFinishDownloadCommand.h +++ b/src/FtpFinishDownloadCommand.h @@ -43,7 +43,7 @@ class FtpConnection; class FtpFinishDownloadCommand : public AbstractCommand { private: - SharedHandle<FtpConnection> _ftpConnection; + SharedHandle<FtpConnection> ftpConnection_; protected: virtual bool execute(); diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc index c7fb87d4..1617ef36 100644 --- a/src/FtpNegotiationCommand.cc +++ b/src/FtpNegotiationCommand.cc @@ -86,13 +86,13 @@ FtpNegotiationCommand::FtpNegotiationCommand const SocketHandle& socket, Seq seq, const std::string& baseWorkingDir): - AbstractCommand(cuid, req, fileEntry, requestGroup, e, socket), _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)); } @@ -104,13 +104,13 @@ FtpNegotiationCommand::~FtpNegotiationCommand() {} bool FtpNegotiationCommand::executeInternal() { while(processSequence(getSegments().front())); - if(_sequence == SEQ_RETRY) { + if(sequence_ == SEQ_RETRY) { return prepareForRetry(0); - } else if(_sequence == SEQ_NEGOTIATION_COMPLETED) { + } else if(sequence_ == SEQ_NEGOTIATION_COMPLETED) { FtpDownloadCommand* command = new FtpDownloadCommand - (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), _ftp, - getDownloadEngine(), _dataSocket, getSocket()); + (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), ftp_, + getDownloadEngine(), dataSocket_, getSocket()); command->setStartupIdleTime(getOption()->getAsInt(PREF_STARTUP_IDLE_TIME)); command->setLowestDownloadSpeedLimit (getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT)); @@ -121,17 +121,17 @@ bool FtpNegotiationCommand::executeInternal() { (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 { getDownloadEngine()->addCommand(this); @@ -141,8 +141,8 @@ bool FtpNegotiationCommand::executeInternal() { bool FtpNegotiationCommand::recvGreeting() { if(!checkIfConnectionEstablished - (getSocket(), _connectedHostname, _connectedAddr, _connectedPort)) { - _sequence = SEQ_EXIT; + (getSocket(), connectedHostname_, connectedAddr_, connectedPort_)) { + sequence_ = SEQ_EXIT; return false; } setTimeout(getRequestGroup()->getTimeout()); @@ -150,22 +150,22 @@ bool FtpNegotiationCommand::recvGreeting() { disableWriteCheckSocket(); 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(getSocket()); } @@ -173,15 +173,15 @@ bool FtpNegotiationCommand::sendUser() { } 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()); @@ -190,9 +190,9 @@ bool FtpNegotiationCommand::recvUser() { } bool FtpNegotiationCommand::sendPass() { - if(_ftp->sendPass()) { + if(ftp_->sendPass()) { disableWriteCheckSocket(); - _sequence = SEQ_RECV_PASS; + sequence_ = SEQ_RECV_PASS; } else { setWriteCheckSocket(getSocket()); } @@ -200,21 +200,21 @@ bool FtpNegotiationCommand::sendPass() { } 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(getSocket()); } @@ -222,22 +222,22 @@ bool FtpNegotiationCommand::sendType() { } 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(getSocket()); } @@ -247,28 +247,28 @@ 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(getSocket()); - if(_ftp->sendCwd()) { + if(ftp_->sendCwd()) { disableWriteCheckSocket(); - _sequence = SEQ_RECV_CWD; + sequence_ = SEQ_RECV_CWD; } else { setWriteCheckSocket(getSocket()); } @@ -276,7 +276,7 @@ bool FtpNegotiationCommand::sendCwd() { } bool FtpNegotiationCommand::recvCwd() { - unsigned int status = _ftp->receiveResponse(); + unsigned int status = ftp_->receiveResponse(); if(status == 0) { return false; } @@ -290,18 +290,18 @@ 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(getSocket()); } @@ -311,7 +311,7 @@ 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; } @@ -341,14 +341,14 @@ 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(getSocket()); } @@ -375,9 +375,9 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) 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)) { @@ -389,7 +389,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) if(getRequestGroup()->downloadFinishedByFileLength()) { getRequestGroup()->initPieceStorage(); getPieceStorage()->markAllPiecesDone(); - _sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; + sequence_ = SEQ_DOWNLOAD_ALREADY_COMPLETED; getLogger()->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, util::itos(getRequestGroup()->getGID()).c_str(), @@ -405,7 +405,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) getPieceStorage()->getDiskAdaptor()->initAndOpenFile(); if(getDownloadContext()->knowsTotalLength()) { - _sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; + sequence_ = SEQ_DOWNLOAD_ALREADY_COMPLETED; poolConnection(); return false; } @@ -436,7 +436,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) getRequestGroup()->downloadFinishedByFileLength()) { getPieceStorage()->markAllPiecesDone(); - _sequence = SEQ_DOWNLOAD_ALREADY_COMPLETED; + sequence_ = SEQ_DOWNLOAD_ALREADY_COMPLETED; getLogger()->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, util::itos(getRequestGroup()->getGID()).c_str(), @@ -461,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; } @@ -474,7 +474,7 @@ bool FtpNegotiationCommand::recvSize() { } if(getPieceStorage().isNull()) { - _sequence = SEQ_FILE_PREPARATION; + sequence_ = SEQ_FILE_PREPARATION; return onFileSizeDetermined(size); } else { @@ -498,9 +498,9 @@ 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; } @@ -512,16 +512,16 @@ void FtpNegotiationCommand::afterFileAllocation() 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(getSocket()); } @@ -529,22 +529,22 @@ bool FtpNegotiationCommand::sendPort() { } 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(getSocket()); } @@ -553,7 +553,7 @@ bool FtpNegotiationCommand::sendPasv() { 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; } @@ -562,8 +562,8 @@ 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; + dataConnAddr_ = dest; + sequence_ = SEQ_RESOLVE_PROXY; return true; } else { // make a data connection to the server. @@ -572,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; } } @@ -585,33 +585,33 @@ bool FtpNegotiationCommand::resolveProxy() { SharedHandle<Request> proxyReq = createProxyRequest(); std::vector<std::string> addrs; - _proxyAddr = resolveHostname + proxyAddr_ = resolveHostname (addrs, proxyReq->getHost(), proxyReq->getPort()); - if(_proxyAddr.empty()) { + if(proxyAddr_.empty()) { return false; } if(getLogger()->info()) { getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), - _proxyAddr.c_str(), proxyReq->getPort()); + 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)); - _sequence = SEQ_SEND_TUNNEL_REQUEST; + setWriteCheckSocket(dataSocket_); + http_.reset(new HttpConnection(getCuid(), dataSocket_)); + sequence_ = SEQ_SEND_TUNNEL_REQUEST; return false; } bool FtpNegotiationCommand::sendTunnelRequest() { - if(_http->sendBufferIsEmpty()) { - if(_dataSocket->isReadable(0)) { + if(http_->sendBufferIsEmpty()) { + if(dataSocket_->isReadable(0)) { std::string error = getSocket()->getSocketError(); if(!error.empty()) { SharedHandle<Request> proxyReq = createProxyRequest(); getDownloadEngine()->markBadIPAddress(proxyReq->getHost(), - _proxyAddr,proxyReq->getPort()); + proxyAddr_,proxyReq->getPort()); std::string nextProxyAddr = getDownloadEngine()->findCachedIPAddress (proxyReq->getHost(), proxyReq->getPort()); if(nextProxyAddr.empty()) { @@ -624,15 +624,15 @@ bool FtpNegotiationCommand::sendTunnelRequest() if(getLogger()->info()) { getLogger()->info(MSG_CONNECT_FAILED_AND_RETRY, util::itos(getCuid()).c_str(), - _proxyAddr.c_str(), proxyReq->getPort()); + proxyAddr_.c_str(), proxyReq->getPort()); } - _proxyAddr = nextProxyAddr; + proxyAddr_ = nextProxyAddr; if(getLogger()->info()) { getLogger()->info(MSG_CONNECTING_TO_SERVER, util::itos(getCuid()).c_str(), - _proxyAddr.c_str(), proxyReq->getPort()); + proxyAddr_.c_str(), proxyReq->getPort()); } - _dataSocket->establishConnection(_proxyAddr, proxyReq->getPort()); + dataSocket_->establishConnection(proxyAddr_, proxyReq->getPort()); return false; } } @@ -641,49 +641,49 @@ bool FtpNegotiationCommand::sendTunnelRequest() httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT)); SharedHandle<Request> req(new Request()); // Construct fake URI in order to use HttpRequest - req->setUri(strconcat("ftp://", _dataConnAddr.first, - A2STR::COLON_C, util::uitos(_dataConnAddr.second))); + req->setUri(strconcat("ftp://", dataConnAddr_.first, + A2STR::COLON_C, util::uitos(dataConnAddr_.second))); httpRequest->setRequest(req); httpRequest->setProxyRequest(createProxyRequest()); - _http->sendProxyRequest(httpRequest); + http_->sendProxyRequest(httpRequest); } else { - _http->sendPendingData(); + http_->sendPendingData(); } - if(_http->sendBufferIsEmpty()) { + 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; } } bool FtpNegotiationCommand::recvTunnelResponse() { - SharedHandle<HttpResponse> httpResponse = _http->receiveResponse(); + SharedHandle<HttpResponse> httpResponse = http_->receiveResponse(); if(httpResponse.isNull()) { return false; } 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(); + //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(getSocket()); } @@ -691,7 +691,7 @@ bool FtpNegotiationCommand::sendRest(const SharedHandle<Segment>& segment) { } bool FtpNegotiationCommand::recvRest(const SharedHandle<Segment>& segment) { - unsigned int status = _ftp->receiveResponse(); + unsigned int status = ftp_->receiveResponse(); if(status == 0) { return false; } @@ -703,14 +703,14 @@ 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(getSocket()); } @@ -718,7 +718,7 @@ bool FtpNegotiationCommand::sendRetr() { } bool FtpNegotiationCommand::recvRetr() { - unsigned int status = _ftp->receiveResponse(); + unsigned int status = ftp_->receiveResponse(); if(status == 0) { return false; } @@ -731,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; } } @@ -745,16 +745,16 @@ bool FtpNegotiationCommand::waitConnection() { disableReadCheckSocket(); setReadCheckSocket(getSocket()); - _dataSocket.reset(_serverSocket->acceptConnection()); - _dataSocket->setNonBlockingMode(); - _sequence = SEQ_NEGOTIATION_COMPLETED; + 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: @@ -823,8 +823,8 @@ void FtpNegotiationCommand::poolConnection() const { if(getOption()->getAsBool(PREF_FTP_REUSE_CONNECTION)) { std::map<std::string, std::string> options; - options["baseWorkingDir"] = _ftp->getBaseWorkingDir(); - getDownloadEngine()->poolSocket(getRequest(), _ftp->getUser(), + options["baseWorkingDir"] = ftp_->getBaseWorkingDir(); + getDownloadEngine()->poolSocket(getRequest(), ftp_->getUser(), createProxyRequest(), getSocket(), options); } } @@ -833,7 +833,7 @@ void FtpNegotiationCommand::onDryRunFileFound() { getPieceStorage()->markAllPiecesDone(); poolConnection(); - _sequence = SEQ_HEAD_OK; + sequence_ = SEQ_HEAD_OK; } } // namespace aria2 diff --git a/src/FtpNegotiationCommand.h b/src/FtpNegotiationCommand.h index 3a9520ca..afbbd061 100644 --- a/src/FtpNegotiationCommand.h +++ b/src/FtpNegotiationCommand.h @@ -122,20 +122,20 @@ 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; + SharedHandle<HttpConnection> http_; // IP, Port pair in pasv response - std::pair<std::string, uint16_t> _dataConnAddr; + std::pair<std::string, uint16_t> dataConnAddr_; // Resolved address for proxy - std::string _proxyAddr; + std::string proxyAddr_; - std::string _connectedHostname; - std::string _connectedAddr; - uint16_t _connectedPort; + std::string connectedHostname_; + std::string connectedAddr_; + uint16_t connectedPort_; protected: virtual bool executeInternal(); public: @@ -152,9 +152,9 @@ public: void setConnectedAddr (const std::string& hostname, const std::string& addr, uint16_t port) { - _connectedHostname = hostname; - _connectedAddr = addr; - _connectedPort = port; + connectedHostname_ = hostname; + connectedAddr_ = addr; + connectedPort_ = port; } }; diff --git a/src/GZipDecoder.cc b/src/GZipDecoder.cc index afdb60cd..1038a694 100644 --- a/src/GZipDecoder.cc +++ b/src/GZipDecoder.cc @@ -40,7 +40,7 @@ namespace aria2 { const std::string GZipDecoder::NAME("GZipDecoder"); -GZipDecoder::GZipDecoder():_strm(0), _finished(false) {} +GZipDecoder::GZipDecoder():strm_(0), finished_(false) {} GZipDecoder::~GZipDecoder() { @@ -49,27 +49,27 @@ GZipDecoder::~GZipDecoder() void GZipDecoder::init() { - _finished = false; + finished_ = false; release(); - _strm = new z_stream(); - _strm->zalloc = Z_NULL; - _strm->zfree = Z_NULL; - _strm->opaque = Z_NULL; - _strm->avail_in = 0; - _strm->next_in = Z_NULL; + strm_ = new z_stream(); + strm_->zalloc = Z_NULL; + strm_->zfree = Z_NULL; + strm_->opaque = Z_NULL; + strm_->avail_in = 0; + strm_->next_in = Z_NULL; // initalize z_stream with gzip/zlib format auto detection enabled. - if(Z_OK != inflateInit2(_strm, 47)) { + if(Z_OK != inflateInit2(strm_, 47)) { throw DL_ABORT_EX("Initializing z_stream failed."); } } void GZipDecoder::release() { - if(_strm) { - inflateEnd(_strm); - delete _strm; - _strm = 0; + if(strm_) { + inflateEnd(strm_); + delete strm_; + strm_ = 0; } } @@ -81,28 +81,28 @@ std::string GZipDecoder::decode(const unsigned char* in, size_t length) return out; } - _strm->avail_in = length; - _strm->next_in = const_cast<unsigned char*>(in); + strm_->avail_in = length; + strm_->next_in = const_cast<unsigned char*>(in); unsigned char outbuf[OUTBUF_LENGTH]; while(1) { - _strm->avail_out = OUTBUF_LENGTH; - _strm->next_out = outbuf; + strm_->avail_out = OUTBUF_LENGTH; + strm_->next_out = outbuf; - int ret = ::inflate(_strm, Z_NO_FLUSH); + int ret = ::inflate(strm_, Z_NO_FLUSH); if(ret == Z_STREAM_END) { - _finished = true; + finished_ = true; } else if(ret != Z_OK) { throw DL_ABORT_EX(StringFormat("libz::inflate() failed. cause:%s", - _strm->msg).str()); + strm_->msg).str()); } - size_t produced = OUTBUF_LENGTH-_strm->avail_out; + size_t produced = OUTBUF_LENGTH-strm_->avail_out; out.append(&outbuf[0], &outbuf[produced]); - if(_strm->avail_out > 0) { + if(strm_->avail_out > 0) { break; } } @@ -111,7 +111,7 @@ std::string GZipDecoder::decode(const unsigned char* in, size_t length) bool GZipDecoder::finished() { - return _finished; + return finished_; } const std::string& GZipDecoder::getName() const diff --git a/src/GZipDecoder.h b/src/GZipDecoder.h index 8701c4ea..e9268609 100644 --- a/src/GZipDecoder.h +++ b/src/GZipDecoder.h @@ -43,9 +43,9 @@ namespace aria2 { // GZipDecoder can decode both gzip and deflate format. class GZipDecoder : public Decoder { private: - z_stream* _strm; + z_stream* strm_; - bool _finished; + bool finished_; static const size_t OUTBUF_LENGTH = 16*1024; diff --git a/src/GZipEncoder.cc b/src/GZipEncoder.cc index 9f205b0a..9b78bd4f 100644 --- a/src/GZipEncoder.cc +++ b/src/GZipEncoder.cc @@ -46,7 +46,7 @@ namespace { const int OUTBUF_LENGTH = 4096; } -GZipEncoder::GZipEncoder():_strm(0), _finished(false) {} +GZipEncoder::GZipEncoder():strm_(0), finished_(false) {} GZipEncoder::~GZipEncoder() { @@ -55,27 +55,27 @@ GZipEncoder::~GZipEncoder() void GZipEncoder::init() { - _finished = false; + finished_ = false; release(); - _strm = new z_stream(); - _strm->zalloc = Z_NULL; - _strm->zfree = Z_NULL; - _strm->opaque = Z_NULL; - _strm->avail_in = 0; - _strm->next_in = Z_NULL; + strm_ = new z_stream(); + strm_->zalloc = Z_NULL; + strm_->zfree = Z_NULL; + strm_->opaque = Z_NULL; + strm_->avail_in = 0; + strm_->next_in = Z_NULL; if(Z_OK != deflateInit2 - (_strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY)) { + (strm_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY)) { throw DL_ABORT_EX("Initializing z_stream failed."); } } void GZipEncoder::release() { - if(_strm) { - deflateEnd(_strm); - delete _strm; - _strm = 0; + if(strm_) { + deflateEnd(strm_); + delete strm_; + strm_ = 0; } } @@ -84,28 +84,28 @@ std::string GZipEncoder::encode { std::string out; - _strm->avail_in = length; - _strm->next_in = const_cast<unsigned char*>(in); + strm_->avail_in = length; + strm_->next_in = const_cast<unsigned char*>(in); unsigned char outbuf[OUTBUF_LENGTH]; while(1) { - _strm->avail_out = OUTBUF_LENGTH; - _strm->next_out = outbuf; + strm_->avail_out = OUTBUF_LENGTH; + strm_->next_out = outbuf; - int ret = ::deflate(_strm, flush); + int ret = ::deflate(strm_, flush); if(ret == Z_STREAM_END) { - _finished = true; + finished_ = true; } else if(ret != Z_OK) { throw DL_ABORT_EX(StringFormat("libz::deflate() failed. cause:%s", - _strm->msg).str()); + strm_->msg).str()); } - size_t produced = OUTBUF_LENGTH-_strm->avail_out; + size_t produced = OUTBUF_LENGTH-strm_->avail_out; out.append(&outbuf[0], &outbuf[produced]); - if(_strm->avail_out > 0) { + if(strm_->avail_out > 0) { break; } } @@ -114,24 +114,24 @@ std::string GZipEncoder::encode bool GZipEncoder::finished() { - return _finished; + return finished_; } std::string GZipEncoder::str() { - _internalBuf += encode(0, 0, Z_FINISH); - return _internalBuf; + internalBuf_ += encode(0, 0, Z_FINISH); + return internalBuf_; } GZipEncoder& GZipEncoder::operator<<(const char* s) { - _internalBuf += encode(reinterpret_cast<const unsigned char*>(s), strlen(s)); + internalBuf_ += encode(reinterpret_cast<const unsigned char*>(s), strlen(s)); return *this; } GZipEncoder& GZipEncoder::operator<<(const std::string& s) { - _internalBuf += encode + internalBuf_ += encode (reinterpret_cast<const unsigned char*>(s.data()), s.size()); return *this; } diff --git a/src/GZipEncoder.h b/src/GZipEncoder.h index 66f4451a..78908dc7 100644 --- a/src/GZipEncoder.h +++ b/src/GZipEncoder.h @@ -44,12 +44,12 @@ namespace aria2 { class GZipEncoder { private: - z_stream* _strm; + z_stream* strm_; - bool _finished; + bool finished_; // Internal buffer for deflated data. - std::string _internalBuf; + std::string internalBuf_; std::string encode(const unsigned char* in, size_t length, int flush); public: diff --git a/src/GrowSegment.cc b/src/GrowSegment.cc index 518498e7..266d05f1 100644 --- a/src/GrowSegment.cc +++ b/src/GrowSegment.cc @@ -39,15 +39,15 @@ namespace aria2 { GrowSegment::GrowSegment(const SharedHandle<Piece>& piece): - _piece(piece), _writtenLength(0) {} + piece_(piece), writtenLength_(0) {} GrowSegment::~GrowSegment() {} void GrowSegment::updateWrittenLength(size_t bytes) { - _writtenLength += bytes; - _piece->reconfigure(_writtenLength); - _piece->setAllBlock(); + writtenLength_ += bytes; + piece_->reconfigure(writtenLength_); + piece_->setAllBlock(); } #ifdef ENABLE_MESSAGE_DIGEST @@ -61,13 +61,13 @@ std::string GrowSegment::getHashString() void GrowSegment::clear() { - _writtenLength = 0; - _piece->clearAllBlock(); + writtenLength_ = 0; + piece_->clearAllBlock(); } SharedHandle<Piece> GrowSegment::getPiece() const { - return _piece; + return piece_; } } // namespace aria2 diff --git a/src/GrowSegment.h b/src/GrowSegment.h index 6fa519a5..8a5b0d12 100644 --- a/src/GrowSegment.h +++ b/src/GrowSegment.h @@ -41,8 +41,8 @@ namespace aria2 { class GrowSegment:public Segment { private: - SharedHandle<Piece> _piece; - size_t _writtenLength; + SharedHandle<Piece> piece_; + size_t writtenLength_; public: GrowSegment(const SharedHandle<Piece>& piece); @@ -65,7 +65,7 @@ public: virtual off_t getPositionToWrite() const { - return _writtenLength; + return writtenLength_; } virtual size_t getLength() const @@ -80,7 +80,7 @@ public: virtual size_t getWrittenLength() const { - return _writtenLength; + return writtenLength_; } virtual size_t getOverflowLength() const diff --git a/src/HandshakeExtensionMessage.cc b/src/HandshakeExtensionMessage.cc index 90383892..5a743de2 100644 --- a/src/HandshakeExtensionMessage.cc +++ b/src/HandshakeExtensionMessage.cc @@ -51,30 +51,30 @@ namespace aria2 { const std::string HandshakeExtensionMessage::EXTENSION_NAME = "handshake"; HandshakeExtensionMessage::HandshakeExtensionMessage(): - _tcpPort(0), - _metadataSize(0), - _logger(LogFactory::getInstance()) {} + tcpPort_(0), + metadataSize_(0), + logger_(LogFactory::getInstance()) {} HandshakeExtensionMessage::~HandshakeExtensionMessage() {} std::string HandshakeExtensionMessage::getPayload() { Dict dict; - if(!_clientVersion.empty()) { - dict.put("v", _clientVersion); + if(!clientVersion_.empty()) { + dict.put("v", clientVersion_); } - if(_tcpPort > 0) { - dict.put("p", Integer::g(_tcpPort)); + if(tcpPort_ > 0) { + dict.put("p", Integer::g(tcpPort_)); } SharedHandle<Dict> extDict = Dict::g(); - for(std::map<std::string, uint8_t>::const_iterator itr = _extensions.begin(), - eoi = _extensions.end(); itr != eoi; ++itr) { + for(std::map<std::string, uint8_t>::const_iterator itr = extensions_.begin(), + eoi = extensions_.end(); itr != eoi; ++itr) { const std::map<std::string, uint8_t>::value_type& vt = *itr; extDict->put(vt.first, Integer::g(vt.second)); } dict.put("m", extDict); - if(_metadataSize) { - dict.put("metadata_size", Integer::g(_metadataSize)); + if(metadataSize_) { + dict.put("metadata_size", Integer::g(metadataSize_)); } return bencode2::encode(&dict); } @@ -82,17 +82,17 @@ std::string HandshakeExtensionMessage::getPayload() std::string HandshakeExtensionMessage::toString() const { std::string s = getExtensionName(); - if(!_clientVersion.empty()) { - strappend(s, " client=", util::percentEncode(_clientVersion)); + if(!clientVersion_.empty()) { + strappend(s, " client=", util::percentEncode(clientVersion_)); } - if(_tcpPort > 0) { - strappend(s, ", tcpPort=", util::uitos(_tcpPort)); + if(tcpPort_ > 0) { + strappend(s, ", tcpPort=", util::uitos(tcpPort_)); } - if(_metadataSize) { - strappend(s, ", metadataSize=", util::uitos(_metadataSize)); + if(metadataSize_) { + strappend(s, ", metadataSize=", util::uitos(metadataSize_)); } - for(std::map<std::string, uint8_t>::const_iterator itr = _extensions.begin(), - eoi = _extensions.end(); itr != eoi; ++itr) { + for(std::map<std::string, uint8_t>::const_iterator itr = extensions_.begin(), + eoi = extensions_.end(); itr != eoi; ++itr) { const std::map<std::string, uint8_t>::value_type& vt = *itr; strappend(s, ", ", vt.first, "=", util::uitos(vt.second)); } @@ -101,36 +101,36 @@ std::string HandshakeExtensionMessage::toString() const void HandshakeExtensionMessage::doReceivedAction() { - if(_tcpPort > 0) { - _peer->setPort(_tcpPort); - _peer->setIncomingPeer(false); + if(tcpPort_ > 0) { + peer_->setPort(tcpPort_); + peer_->setIncomingPeer(false); } - for(std::map<std::string, uint8_t>::const_iterator itr = _extensions.begin(), - eoi = _extensions.end(); itr != eoi; ++itr) { + for(std::map<std::string, uint8_t>::const_iterator itr = extensions_.begin(), + eoi = extensions_.end(); itr != eoi; ++itr) { const std::map<std::string, uint8_t>::value_type& vt = *itr; - _peer->setExtension(vt.first, vt.second); + peer_->setExtension(vt.first, vt.second); } SharedHandle<TorrentAttribute> attrs = - bittorrent::getTorrentAttrs(_dctx); - if(attrs->metadata.empty() && !_peer->getExtensionMessageID("ut_metadata")) { + bittorrent::getTorrentAttrs(dctx_); + if(attrs->metadata.empty() && !peer_->getExtensionMessageID("ut_metadata")) { // TODO In metadataGetMode, if peer don't support metadata // transfer, should we drop connection? There is a possibility // that peer can still tell us peers using PEX. throw DL_ABORT_EX("Peer doesn't support ut_metadata extension. Goodbye."); } - if(_metadataSize > 0) { + if(metadataSize_ > 0) { if(attrs->metadataSize) { - if(_metadataSize != attrs->metadataSize) { + if(metadataSize_ != attrs->metadataSize) { throw DL_ABORT_EX("Wrong metadata_size. Which one is correct!?"); } } else { - attrs->metadataSize = _metadataSize; - _dctx->getFirstFileEntry()->setLength(_metadataSize); - _dctx->markTotalLengthIsKnown(); - _dctx->getOwnerRequestGroup()->initPieceStorage(); + attrs->metadataSize = metadataSize_; + dctx_->getFirstFileEntry()->setLength(metadataSize_); + dctx_->markTotalLengthIsKnown(); + dctx_->getOwnerRequestGroup()->initPieceStorage(); SharedHandle<PieceStorage> pieceStorage = - _dctx->getOwnerRequestGroup()->getPieceStorage(); + dctx_->getOwnerRequestGroup()->getPieceStorage(); pieceStorage->setEndGamePieceNum(0); } } else if(attrs->metadata.empty()) { @@ -141,13 +141,13 @@ void HandshakeExtensionMessage::doReceivedAction() void HandshakeExtensionMessage::setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } uint8_t HandshakeExtensionMessage::getExtensionMessageID(const std::string& name) const { - std::map<std::string, uint8_t>::const_iterator i = _extensions.find(name); - if(i == _extensions.end()) { + std::map<std::string, uint8_t>::const_iterator i = extensions_.find(name); + if(i == extensions_.end()) { return 0; } else { return (*i).second; @@ -176,11 +176,11 @@ HandshakeExtensionMessage::create(const unsigned char* data, size_t length) } const Integer* port = asInteger(dict->get("p")); if(port && 0 < port->i() && port->i() < 65536) { - msg->_tcpPort = port->i(); + msg->tcpPort_ = port->i(); } const String* version = asString(dict->get("v")); if(version) { - msg->_clientVersion = version->s(); + msg->clientVersion_ = version->s(); } const Dict* extDict = asDict(dict->get("m")); if(extDict) { @@ -188,14 +188,14 @@ HandshakeExtensionMessage::create(const unsigned char* data, size_t length) eoi = extDict->end(); i != eoi; ++i) { const Integer* extId = asInteger((*i).second); if(extId) { - msg->_extensions[(*i).first] = extId->i(); + msg->extensions_[(*i).first] = extId->i(); } } } const Integer* metadataSize = asInteger(dict->get("metadata_size")); // Only accept metadata smaller than 1MiB if(metadataSize && metadataSize->i() <= 1024*1024) { - msg->_metadataSize = metadataSize->i(); + msg->metadataSize_ = metadataSize->i(); } return msg; } diff --git a/src/HandshakeExtensionMessage.h b/src/HandshakeExtensionMessage.h index 3bb829ea..5589e0d1 100644 --- a/src/HandshakeExtensionMessage.h +++ b/src/HandshakeExtensionMessage.h @@ -49,19 +49,19 @@ class DownloadContext; class HandshakeExtensionMessage:public ExtensionMessage { private: - std::string _clientVersion; + std::string clientVersion_; - uint16_t _tcpPort; + uint16_t tcpPort_; - size_t _metadataSize; + size_t metadataSize_; - std::map<std::string, uint8_t> _extensions; + std::map<std::string, uint8_t> extensions_; - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; - Logger* _logger; + Logger* logger_; public: HandshakeExtensionMessage(); @@ -88,47 +88,47 @@ public: void setClientVersion(const std::string& version) { - _clientVersion = version; + clientVersion_ = version; } const std::string& getClientVersion() const { - return _clientVersion; + return clientVersion_; } void setTCPPort(uint16_t port) { - _tcpPort = port; + tcpPort_ = port; } uint16_t getTCPPort() const { - return _tcpPort; + return tcpPort_; } size_t getMetadataSize() { - return _metadataSize; + return metadataSize_; } void setMetadataSize(size_t size) { - _metadataSize = size; + metadataSize_ = size; } void setDownloadContext(const SharedHandle<DownloadContext>& dctx) { - _dctx = dctx; + dctx_ = dctx; } void setExtension(const std::string& name, uint8_t id) { - _extensions[name] = id; + extensions_[name] = id; } void setExtensions(const Extensions& extensions) { - _extensions = extensions; + extensions_ = extensions; } uint8_t getExtensionMessageID(const std::string& name) const; diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc index 336a7941..ff995a08 100644 --- a/src/HttpConnection.cc +++ b/src/HttpConnection.cc @@ -60,15 +60,15 @@ namespace aria2 { HttpRequestEntry::HttpRequestEntry (const SharedHandle<HttpRequest>& httpRequest): - _httpRequest(httpRequest), - _proc(new HttpHeaderProcessor()) {} + httpRequest_(httpRequest), + proc_(new HttpHeaderProcessor()) {} HttpRequestEntry::~HttpRequestEntry() {} HttpConnection::HttpConnection(cuid_t cuid, const SocketHandle& socket): - _cuid(cuid), _socket(socket), - _socketBuffer(socket), - _logger(LogFactory::getInstance()) + cuid_(cuid), socket_(socket), + socketBuffer_(socket), + logger_(LogFactory::getInstance()) {} std::string HttpConnection::eraseConfidentialInfo(const std::string& request) @@ -93,45 +93,45 @@ std::string HttpConnection::eraseConfidentialInfo(const std::string& request) void HttpConnection::sendRequest(const SharedHandle<HttpRequest>& httpRequest) { std::string request = httpRequest->createRequest(); - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), eraseConfidentialInfo(request).c_str()); } - _socketBuffer.pushStr(request); - _socketBuffer.send(); + socketBuffer_.pushStr(request); + socketBuffer_.send(); SharedHandle<HttpRequestEntry> entry(new HttpRequestEntry(httpRequest)); - _outstandingHttpRequests.push_back(entry); + outstandingHttpRequests_.push_back(entry); } void HttpConnection::sendProxyRequest (const SharedHandle<HttpRequest>& httpRequest) { std::string request = httpRequest->createProxyRequest(); - if(_logger->info()) { - _logger->info(MSG_SENDING_REQUEST, - util::itos(_cuid).c_str(), + if(logger_->info()) { + logger_->info(MSG_SENDING_REQUEST, + util::itos(cuid_).c_str(), eraseConfidentialInfo(request).c_str()); } - _socketBuffer.pushStr(request); - _socketBuffer.send(); + socketBuffer_.pushStr(request); + socketBuffer_.send(); SharedHandle<HttpRequestEntry> entry(new HttpRequestEntry(httpRequest)); - _outstandingHttpRequests.push_back(entry); + outstandingHttpRequests_.push_back(entry); } SharedHandle<HttpResponse> HttpConnection::receiveResponse() { - if(_outstandingHttpRequests.empty()) { + if(outstandingHttpRequests_.empty()) { throw DL_ABORT_EX(EX_NO_HTTP_REQUEST_ENTRY_FOUND); } - HttpRequestEntryHandle entry = _outstandingHttpRequests.front(); + HttpRequestEntryHandle entry = outstandingHttpRequests_.front(); HttpHeaderProcessorHandle proc = entry->getHttpHeaderProcessor(); unsigned char buf[512]; size_t size = sizeof(buf); - _socket->peekData(buf, size); + socket_->peekData(buf, size); if(size == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return SharedHandle<HttpResponse>(); } else { throw DL_RETRY_EX(EX_INVALID_RESPONSE); @@ -139,31 +139,31 @@ SharedHandle<HttpResponse> HttpConnection::receiveResponse() } proc->update(buf, size); if(!proc->eoh()) { - _socket->readData(buf, size); + socket_->readData(buf, size); return SharedHandle<HttpResponse>(); } size_t putbackDataLength = proc->getPutBackDataLength(); size -= putbackDataLength; - _socket->readData(buf, size); - if(_logger->info()) { - _logger->info(MSG_RECEIVE_RESPONSE, - util::itos(_cuid).c_str(), proc->getHeaderString().c_str()); + socket_->readData(buf, size); + if(logger_->info()) { + logger_->info(MSG_RECEIVE_RESPONSE, + util::itos(cuid_).c_str(), proc->getHeaderString().c_str()); } SharedHandle<HttpHeader> httpHeader = proc->getHttpResponseHeader(); SharedHandle<HttpResponse> httpResponse(new HttpResponse()); - httpResponse->setCuid(_cuid); + httpResponse->setCuid(cuid_); httpResponse->setHttpHeader(httpHeader); httpResponse->setHttpRequest(entry->getHttpRequest()); - _outstandingHttpRequests.pop_front(); + outstandingHttpRequests_.pop_front(); return httpResponse; } bool HttpConnection::isIssued(const SharedHandle<Segment>& segment) const { - for(HttpRequestEntries::const_iterator itr = _outstandingHttpRequests.begin(), - eoi = _outstandingHttpRequests.end(); itr != eoi; ++itr) { + for(HttpRequestEntries::const_iterator itr = outstandingHttpRequests_.begin(), + eoi = outstandingHttpRequests_.end(); itr != eoi; ++itr) { SharedHandle<HttpRequest> httpRequest = (*itr)->getHttpRequest(); if(httpRequest->getSegment() == segment) { return true; @@ -174,21 +174,21 @@ bool HttpConnection::isIssued(const SharedHandle<Segment>& segment) const SharedHandle<HttpRequest> HttpConnection::getFirstHttpRequest() const { - if(_outstandingHttpRequests.empty()) { + if(outstandingHttpRequests_.empty()) { return SharedHandle<HttpRequest>(); } else { - return _outstandingHttpRequests.front()->getHttpRequest(); + return outstandingHttpRequests_.front()->getHttpRequest(); } } bool HttpConnection::sendBufferIsEmpty() const { - return _socketBuffer.sendBufferIsEmpty(); + return socketBuffer_.sendBufferIsEmpty(); } void HttpConnection::sendPendingData() { - _socketBuffer.send(); + socketBuffer_.send(); } } // namespace aria2 diff --git a/src/HttpConnection.h b/src/HttpConnection.h index f9f6af16..5760ee34 100644 --- a/src/HttpConnection.h +++ b/src/HttpConnection.h @@ -56,8 +56,8 @@ class SocketCore; class HttpRequestEntry { private: - SharedHandle<HttpRequest> _httpRequest; - SharedHandle<HttpHeaderProcessor> _proc; + SharedHandle<HttpRequest> httpRequest_; + SharedHandle<HttpHeaderProcessor> proc_; public: HttpRequestEntry(const SharedHandle<HttpRequest>& httpRequest); @@ -65,12 +65,12 @@ public: const SharedHandle<HttpRequest>& getHttpRequest() const { - return _httpRequest; + return httpRequest_; } const SharedHandle<HttpHeaderProcessor>& getHttpHeaderProcessor() const { - return _proc; + return proc_; } }; @@ -79,13 +79,13 @@ typedef std::deque<HttpRequestEntryHandle> HttpRequestEntries; class HttpConnection { private: - cuid_t _cuid; - SharedHandle<SocketCore> _socket; - SocketBuffer _socketBuffer; - const Option* _option; - Logger* _logger; + cuid_t cuid_; + SharedHandle<SocketCore> socket_; + SocketBuffer socketBuffer_; + const Option* option_; + Logger* logger_; - HttpRequestEntries _outstandingHttpRequests; + HttpRequestEntries outstandingHttpRequests_; std::string eraseConfidentialInfo(const std::string& request); public: diff --git a/src/HttpDownloadCommand.cc b/src/HttpDownloadCommand.cc index 7ff66769..5727ed6f 100644 --- a/src/HttpDownloadCommand.cc +++ b/src/HttpDownloadCommand.cc @@ -65,8 +65,8 @@ HttpDownloadCommand::HttpDownloadCommand DownloadEngine* e, const SocketHandle& socket) :DownloadCommand(cuid, req, fileEntry, requestGroup, e, socket), - _httpResponse(httpResponse), - _httpConnection(httpConnection) {} + httpResponse_(httpResponse), + httpConnection_(httpConnection) {} HttpDownloadCommand::~HttpDownloadCommand() {} @@ -75,7 +75,7 @@ bool HttpDownloadCommand::prepareForNextSegment() { if(getRequest()->isPipeliningEnabled() && !downloadFinished) { HttpRequestCommand* command = new HttpRequestCommand(getCuid(), getRequest(), getFileEntry(), - getRequestGroup(), _httpConnection, + getRequestGroup(), httpConnection_, getDownloadEngine(), getSocket()); // Set proxy request here. aria2 sends the HTTP request specialized for // proxy. @@ -121,7 +121,7 @@ bool HttpDownloadCommand::prepareForNextSegment() { getFileEntry()->getLastOffset())); if(lastOffset == - _httpResponse->getHttpHeader()->getRange()->getEndByte()+1) { + httpResponse_->getHttpHeader()->getRange()->getEndByte()+1) { return prepareForRetry(0); } } diff --git a/src/HttpDownloadCommand.h b/src/HttpDownloadCommand.h index 31bb37e1..1f9ebcf2 100644 --- a/src/HttpDownloadCommand.h +++ b/src/HttpDownloadCommand.h @@ -44,8 +44,8 @@ class HttpConnection; class HttpDownloadCommand : public DownloadCommand { private: - SharedHandle<HttpResponse> _httpResponse; - SharedHandle<HttpConnection> _httpConnection; + SharedHandle<HttpResponse> httpResponse_; + SharedHandle<HttpConnection> httpConnection_; protected: virtual bool prepareForNextSegment(); public: diff --git a/src/HttpHeader.cc b/src/HttpHeader.cc index a5f135d0..d871eeb1 100644 --- a/src/HttpHeader.cc +++ b/src/HttpHeader.cc @@ -89,17 +89,17 @@ const std::string HttpHeader::S404("404"); void HttpHeader::put(const std::string& name, const std::string& value) { std::multimap<std::string, std::string>::value_type vt (util::toLower(name), value); - _table.insert(vt); + table_.insert(vt); } bool HttpHeader::defined(const std::string& name) const { - return _table.count(util::toLower(name)) >= 1; + return table_.count(util::toLower(name)) >= 1; } const std::string& HttpHeader::getFirst(const std::string& name) const { std::multimap<std::string, std::string>::const_iterator itr = - _table.find(util::toLower(name)); - if(itr == _table.end()) { + table_.find(util::toLower(name)); + if(itr == table_.end()) { return A2STR::NIL; } else { return (*itr).second; @@ -112,7 +112,7 @@ std::vector<std::string> HttpHeader::get(const std::string& name) const std::string n(util::toLower(name)); std::pair<std::multimap<std::string, std::string>::const_iterator, std::multimap<std::string, std::string>::const_iterator> itrpair = - _table.equal_range(n); + table_.equal_range(n); std::multimap<std::string, std::string>::const_iterator first = itrpair.first; while(first != itrpair.second) { v.push_back((*first).second); @@ -180,22 +180,22 @@ RangeHandle HttpHeader::getRange() const void HttpHeader::setResponseStatus(const std::string& responseStatus) { - _responseStatus = responseStatus; + responseStatus_ = responseStatus; } void HttpHeader::setVersion(const std::string& version) { - _version = version; + version_ = version; } void HttpHeader::setMethod(const std::string& method) { - _method = method; + method_ = method; } void HttpHeader::setRequestPath(const std::string& requestPath) { - _requestPath = requestPath; + requestPath_ = requestPath; } void HttpHeader::fill(std::istream& in) @@ -214,7 +214,7 @@ void HttpHeader::fill(std::istream& in) void HttpHeader::clearField() { - _table.clear(); + table_.clear(); } } // namespace aria2 diff --git a/src/HttpHeader.h b/src/HttpHeader.h index f2ceb76d..34e5dc2d 100644 --- a/src/HttpHeader.h +++ b/src/HttpHeader.h @@ -50,20 +50,20 @@ class Range; class HttpHeader { private: - std::multimap<std::string, std::string> _table; + std::multimap<std::string, std::string> table_; // for HTTP response header only // response status, e.g. "200" - std::string _responseStatus; + std::string responseStatus_; // HTTP version, e.g. HTTP/1.1 - std::string _version; + std::string version_; // HTTP Method, e.g. GET, POST, etc - std::string _method; + std::string method_; // Request Path - std::string _requestPath; + std::string requestPath_; public: HttpHeader() {} ~HttpHeader() {} @@ -79,35 +79,35 @@ public: const std::string& getResponseStatus() const { - return _responseStatus; + return responseStatus_; } void setResponseStatus(const std::string& responseStatus); const std::string& getVersion() const { - return _version; + return version_; } void setVersion(const std::string& version); const std::string& getMethod() const { - return _method; + return method_; } void setMethod(const std::string& method); const std::string& getRequestPath() const { - return _requestPath; + return requestPath_; } void setRequestPath(const std::string& requestPath); void fill(std::istream& in); - // Clears _table. _responseStatus and _version are unchanged. + // Clears table_. responseStatus_ and version_ are unchanged. void clearField(); static const std::string LOCATION; diff --git a/src/HttpHeaderProcessor.cc b/src/HttpHeaderProcessor.cc index 19ff3eca..47beae09 100644 --- a/src/HttpHeaderProcessor.cc +++ b/src/HttpHeaderProcessor.cc @@ -47,7 +47,7 @@ namespace aria2 { HttpHeaderProcessor::HttpHeaderProcessor(): - _limit(21/*lines*/*8190/*per line*/) {} + limit_(21/*lines*/*8190/*per line*/) {} // The above values come from Apache's documentation // http://httpd.apache.org/docs/2.2/en/mod/core.html: See // LimitRequestFieldSize and LimitRequestLine directive. Also the @@ -59,26 +59,26 @@ HttpHeaderProcessor::~HttpHeaderProcessor() {} void HttpHeaderProcessor::update(const unsigned char* data, size_t length) { checkHeaderLimit(length); - _buf += std::string(&data[0], &data[length]); + buf_ += std::string(&data[0], &data[length]); } void HttpHeaderProcessor::update(const std::string& data) { checkHeaderLimit(data.size()); - _buf += data; + buf_ += data; } void HttpHeaderProcessor::checkHeaderLimit(size_t incomingLength) { - if(_buf.size()+incomingLength > _limit) { + if(buf_.size()+incomingLength > limit_) { throw DL_ABORT_EX("Too large http header"); } } bool HttpHeaderProcessor::eoh() const { - if(_buf.find("\r\n\r\n") == std::string::npos && - _buf.find("\n\n") == std::string::npos) { + if(buf_.find("\r\n\r\n") == std::string::npos && + buf_.find("\n\n") == std::string::npos) { return false; } else { return true; @@ -88,10 +88,10 @@ bool HttpHeaderProcessor::eoh() const size_t HttpHeaderProcessor::getPutBackDataLength() const { std::string::size_type delimpos = std::string::npos; - if((delimpos = _buf.find("\r\n\r\n")) != std::string::npos) { - return _buf.size()-(delimpos+4); - } else if((delimpos = _buf.find("\n\n")) != std::string::npos) { - return _buf.size()-(delimpos+2); + if((delimpos = buf_.find("\r\n\r\n")) != std::string::npos) { + return buf_.size()-(delimpos+4); + } else if((delimpos = buf_.find("\n\n")) != std::string::npos) { + return buf_.size()-(delimpos+2); } else { return 0; } @@ -99,21 +99,21 @@ size_t HttpHeaderProcessor::getPutBackDataLength() const void HttpHeaderProcessor::clear() { - _buf.erase(); + buf_.erase(); } SharedHandle<HttpHeader> HttpHeaderProcessor::getHttpResponseHeader() { std::string::size_type delimpos = std::string::npos; - if(((delimpos = _buf.find("\r\n")) == std::string::npos && - (delimpos = _buf.find("\n")) == std::string::npos) || + if(((delimpos = buf_.find("\r\n")) == std::string::npos && + (delimpos = buf_.find("\n")) == std::string::npos) || delimpos < 12) { throw DL_RETRY_EX(EX_NO_STATUS_HEADER); } HttpHeaderHandle httpHeader(new HttpHeader()); - httpHeader->setVersion(_buf.substr(0, 8)); - httpHeader->setResponseStatus(_buf.substr(9, 3)); - std::istringstream strm(_buf); + httpHeader->setVersion(buf_.substr(0, 8)); + httpHeader->setResponseStatus(buf_.substr(9, 3)); + std::istringstream strm(buf_); // TODO 1st line(HTTP/1.1 200...) is also send to HttpHeader, but it should // not. httpHeader->fill(strm); @@ -126,13 +126,13 @@ SharedHandle<HttpHeader> HttpHeaderProcessor::getHttpRequestHeader() // GET / HTTP/1.x // At least 14bytes before \r\n or \n. std::string::size_type delimpos = std::string::npos; - if(((delimpos = _buf.find("\r\n")) == std::string::npos && - (delimpos = _buf.find("\n")) == std::string::npos) || + if(((delimpos = buf_.find("\r\n")) == std::string::npos && + (delimpos = buf_.find("\n")) == std::string::npos) || delimpos < 14) { throw DL_RETRY_EX(EX_NO_STATUS_HEADER); } std::vector<std::string> firstLine; - util::split(_buf.substr(0, delimpos), std::back_inserter(firstLine)," ",true); + util::split(buf_.substr(0, delimpos), std::back_inserter(firstLine)," ",true); if(firstLine.size() != 3) { throw DL_ABORT_EX("Malformed HTTP request header."); } @@ -140,7 +140,7 @@ SharedHandle<HttpHeader> HttpHeaderProcessor::getHttpRequestHeader() httpHeader->setMethod(firstLine[0]); httpHeader->setRequestPath(firstLine[1]); httpHeader->setVersion(firstLine[2]); - std::istringstream strm(_buf.substr(delimpos)); + std::istringstream strm(buf_.substr(delimpos)); httpHeader->fill(strm); return httpHeader; } @@ -148,11 +148,11 @@ SharedHandle<HttpHeader> HttpHeaderProcessor::getHttpRequestHeader() std::string HttpHeaderProcessor::getHeaderString() const { std::string::size_type delimpos = std::string::npos; - if((delimpos = _buf.find("\r\n\r\n")) == std::string::npos && - (delimpos = _buf.find("\n\n")) == std::string::npos) { - return _buf; + if((delimpos = buf_.find("\r\n\r\n")) == std::string::npos && + (delimpos = buf_.find("\n\n")) == std::string::npos) { + return buf_; } else { - return _buf.substr(0, delimpos); + return buf_.substr(0, delimpos); } } diff --git a/src/HttpHeaderProcessor.h b/src/HttpHeaderProcessor.h index ed5aac71..f277296e 100644 --- a/src/HttpHeaderProcessor.h +++ b/src/HttpHeaderProcessor.h @@ -46,8 +46,8 @@ class HttpHeader; class HttpHeaderProcessor { private: - std::string _buf; - size_t _limit; + std::string buf_; + size_t limit_; void checkHeaderLimit(size_t incomingLength); @@ -84,7 +84,7 @@ public: void setHeaderLimit(size_t limit) { - _limit = limit; + limit_ = limit; } }; diff --git a/src/HttpListenCommand.cc b/src/HttpListenCommand.cc index d690391b..701abfc6 100644 --- a/src/HttpListenCommand.cc +++ b/src/HttpListenCommand.cc @@ -52,23 +52,23 @@ namespace aria2 { HttpListenCommand::HttpListenCommand(cuid_t cuid, DownloadEngine* e): - Command(cuid),_e(e) {} + Command(cuid),e_(e) {} HttpListenCommand::~HttpListenCommand() { - if(!_serverSocket.isNull()) { - _e->deleteSocketForReadCheck(_serverSocket, this); + if(!serverSocket_.isNull()) { + e_->deleteSocketForReadCheck(serverSocket_, this); } } bool HttpListenCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } try { - if(_serverSocket->isReadable(0)) { - SharedHandle<SocketCore> socket(_serverSocket->acceptConnection()); + if(serverSocket_->isReadable(0)) { + SharedHandle<SocketCore> socket(serverSocket_->acceptConnection()); socket->setNonBlockingMode(); std::pair<std::string, uint16_t> peerInfo; @@ -78,50 +78,50 @@ bool HttpListenCommand::execute() peerInfo.first.c_str(), peerInfo.second); HttpServerCommand* c = - new HttpServerCommand(_e->newCUID(), _e, socket); - _e->setNoWait(true); - _e->addCommand(c); + new HttpServerCommand(e_->newCUID(), e_, socket); + e_->setNoWait(true); + e_->addCommand(c); } } catch(RecoverableException& e) { if(getLogger()->debug()) { getLogger()->debug(MSG_ACCEPT_FAILURE, e, util::itos(getCuid()).c_str()); } } - _e->addCommand(this); + e_->addCommand(this); return false; } bool HttpListenCommand::bindPort(uint16_t port) { - if(!_serverSocket.isNull()) { - _e->deleteSocketForReadCheck(_serverSocket, this); + if(!serverSocket_.isNull()) { + e_->deleteSocketForReadCheck(serverSocket_, this); } - _serverSocket.reset(new SocketCore()); + serverSocket_.reset(new SocketCore()); if(getLogger()->info()) { getLogger()->info("CUID#%s - Setting up HttpListenCommand", util::itos(getCuid()).c_str()); } try { int flags = 0; - if(_e->getOption()->getAsBool(PREF_XML_RPC_LISTEN_ALL)) { + if(e_->getOption()->getAsBool(PREF_XML_RPC_LISTEN_ALL)) { flags = AI_PASSIVE; } - _serverSocket->bind(port, flags); - _serverSocket->beginListen(); - _serverSocket->setNonBlockingMode(); + serverSocket_->bind(port, flags); + serverSocket_->beginListen(); + serverSocket_->setNonBlockingMode(); if(getLogger()->info()) { getLogger()->info(MSG_LISTENING_PORT, util::itos(getCuid()).c_str(), port); } - _e->addSocketForReadCheck(_serverSocket, this); + e_->addSocketForReadCheck(serverSocket_, this); return true; } catch(RecoverableException& e) { getLogger()->error(MSG_BIND_FAILURE, e, util::itos(getCuid()).c_str(), port); - if(!_serverSocket.isNull()) { - _e->deleteSocketForReadCheck(_serverSocket, this); + if(!serverSocket_.isNull()) { + e_->deleteSocketForReadCheck(serverSocket_, this); } - _serverSocket->closeConnection(); + serverSocket_->closeConnection(); } return false; } diff --git a/src/HttpListenCommand.h b/src/HttpListenCommand.h index f56babcc..6adf60ff 100644 --- a/src/HttpListenCommand.h +++ b/src/HttpListenCommand.h @@ -45,8 +45,8 @@ class SocketCore; class HttpListenCommand : public Command { private: - DownloadEngine* _e; - SharedHandle<SocketCore> _serverSocket; + DownloadEngine* e_; + SharedHandle<SocketCore> serverSocket_; public: HttpListenCommand(cuid_t cuid, DownloadEngine* e); diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc index c2400550..4fa090aa 100644 --- a/src/HttpRequest.cc +++ b/src/HttpRequest.cc @@ -55,40 +55,40 @@ namespace aria2 { const std::string HttpRequest::USER_AGENT("aria2"); -HttpRequest::HttpRequest():_contentEncodingEnabled(true), - _userAgent(USER_AGENT), - _noCache(true), - _acceptGzip(false) +HttpRequest::HttpRequest():contentEncodingEnabled_(true), + userAgent_(USER_AGENT), + noCache_(true), + acceptGzip_(false) {} void HttpRequest::setSegment(const SharedHandle<Segment>& segment) { - _segment = segment; + segment_ = segment; } void HttpRequest::setRequest(const SharedHandle<Request>& request) { - _request = request; + request_ = request; } off_t HttpRequest::getStartByte() const { - if(_segment.isNull()) { + if(segment_.isNull()) { return 0; } else { - return _fileEntry->gtoloff(_segment->getPositionToWrite()); + return fileEntry_->gtoloff(segment_->getPositionToWrite()); } } off_t HttpRequest::getEndByte() const { - if(_segment.isNull() || _request.isNull()) { + if(segment_.isNull() || request_.isNull()) { return 0; } else { - if(_request->isPipeliningEnabled()) { + if(request_->isPipeliningEnabled()) { off_t endByte = - _fileEntry->gtoloff(_segment->getPosition()+_segment->getLength()-1); - return std::min(endByte, static_cast<off_t>(_fileEntry->getLength()-1)); + fileEntry_->gtoloff(segment_->getPosition()+segment_->getLength()-1); + return std::min(endByte, static_cast<off_t>(fileEntry_->getLength()-1)); } else { return 0; } @@ -98,24 +98,24 @@ off_t HttpRequest::getEndByte() const RangeHandle HttpRequest::getRange() const { // content-length is always 0 - if(_segment.isNull()) { + if(segment_.isNull()) { return SharedHandle<Range>(new Range()); } else { return SharedHandle<Range>(new Range(getStartByte(), getEndByte(), - _fileEntry->getLength())); + fileEntry_->getLength())); } } bool HttpRequest::isRangeSatisfied(const RangeHandle& range) const { - if(_segment.isNull()) { + if(segment_.isNull()) { return true; } if((getStartByte() == range->getStartByte()) && ((getEndByte() == 0) || (getEndByte() == range->getEndByte())) && - ((_fileEntry->getLength() == 0) || - (_fileEntry->getLength() == range->getEntityLength()))) { + ((fileEntry_->getLength() == 0) || + (fileEntry_->getLength() == range->getEntityLength()))) { return true; } else { return false; @@ -133,16 +133,16 @@ static std::string getHostText(const std::string& host, uint16_t port) std::string HttpRequest::createRequest() { - _authConfig = _authConfigFactory->createAuthConfig(_request, _option); - std::string requestLine = _request->getMethod(); + authConfig_ = authConfigFactory_->createAuthConfig(request_, option_); + std::string requestLine = request_->getMethod(); requestLine += " "; - if(!_proxyRequest.isNull()) { + if(!proxyRequest_.isNull()) { if(getProtocol() == Request::PROTO_FTP && - _request->getUsername().empty() && !_authConfig.isNull()) { + request_->getUsername().empty() && !authConfig_.isNull()) { // Insert user into URI, like ftp://USER@host/ std::string uri = getCurrentURI(); assert(uri.size() >= 6); - uri.insert(6, util::percentEncode(_authConfig->getUser())+"@"); + uri.insert(6, util::percentEncode(authConfig_->getUser())+"@"); requestLine += uri; } else { requestLine += getCurrentURI(); @@ -161,17 +161,17 @@ std::string HttpRequest::createRequest() std::vector<std::pair<std::string, std::string> > builtinHds; builtinHds.reserve(20); - builtinHds.push_back(std::make_pair("User-Agent:", _userAgent)); + builtinHds.push_back(std::make_pair("User-Agent:", userAgent_)); std::string acceptTypes = "*/*"; - for(std::vector<std::string>::const_iterator i = _acceptTypes.begin(), - eoi = _acceptTypes.end(); i != eoi; ++i) { + for(std::vector<std::string>::const_iterator i = acceptTypes_.begin(), + eoi = acceptTypes_.end(); i != eoi; ++i) { strappend(acceptTypes, ",", (*i)); } builtinHds.push_back(std::make_pair("Accept:", acceptTypes)); - if(_contentEncodingEnabled) { + if(contentEncodingEnabled_) { std::string acceptableEncodings; #ifdef HAVE_LIBZ - if(_acceptGzip) { + if(acceptGzip_) { acceptableEncodings += "deflate, gzip"; } #endif // HAVE_LIBZ @@ -182,46 +182,46 @@ std::string HttpRequest::createRequest() } builtinHds.push_back (std::make_pair("Host:", getHostText(getURIHost(), getPort()))); - if(_noCache) { + if(noCache_) { builtinHds.push_back(std::make_pair("Pragma:", "no-cache")); builtinHds.push_back(std::make_pair("Cache-Control:", "no-cache")); } - if(!_request->isKeepAliveEnabled() && !_request->isPipeliningEnabled()) { + if(!request_->isKeepAliveEnabled() && !request_->isPipeliningEnabled()) { builtinHds.push_back(std::make_pair("Connection:", "close")); } - if(!_segment.isNull() && _segment->getLength() > 0 && - (_request->isPipeliningEnabled() || getStartByte() > 0)) { + if(!segment_.isNull() && segment_->getLength() > 0 && + (request_->isPipeliningEnabled() || getStartByte() > 0)) { std::string rangeHeader = "bytes="; rangeHeader += util::itos(getStartByte()); rangeHeader += "-"; - if(_request->isPipeliningEnabled()) { + if(request_->isPipeliningEnabled()) { rangeHeader += util::itos(getEndByte()); } builtinHds.push_back(std::make_pair("Range:", rangeHeader)); } - if(!_proxyRequest.isNull()) { - if(_request->isKeepAliveEnabled() || _request->isPipeliningEnabled()) { + if(!proxyRequest_.isNull()) { + if(request_->isKeepAliveEnabled() || request_->isPipeliningEnabled()) { builtinHds.push_back(std::make_pair("Proxy-Connection:", "Keep-Alive")); } else { builtinHds.push_back(std::make_pair("Proxy-Connection:", "close")); } } - if(!_proxyRequest.isNull() && !_proxyRequest->getUsername().empty()) { + if(!proxyRequest_.isNull() && !proxyRequest_->getUsername().empty()) { builtinHds.push_back(getProxyAuthString()); } - if(!_authConfig.isNull()) { + if(!authConfig_.isNull()) { builtinHds.push_back (std::make_pair("Authorization:", strconcat("Basic ", - Base64::encode(_authConfig->getAuthText())))); + Base64::encode(authConfig_->getAuthText())))); } if(getPreviousURI().size()) { builtinHds.push_back(std::make_pair("Referer:", getPreviousURI())); } - if(!_cookieStorage.isNull()) { + if(!cookieStorage_.isNull()) { std::string cookiesValue; std::vector<Cookie> cookies = - _cookieStorage->criteriaFind(getHost(), + cookieStorage_->criteriaFind(getHost(), getDir(), Time().getTime(), getProtocol() == Request::PROTO_HTTPS ? @@ -236,8 +236,8 @@ std::string HttpRequest::createRequest() } for(std::vector<std::pair<std::string, std::string> >::const_iterator i = builtinHds.begin(), eoi = builtinHds.end(); i != eoi; ++i) { - std::vector<std::string>::const_iterator j = _headers.begin(); - std::vector<std::string>::const_iterator jend = _headers.end(); + std::vector<std::string>::const_iterator j = headers_.begin(); + std::vector<std::string>::const_iterator jend = headers_.end(); for(; j != jend; ++j) { if(util::startsWith(*j, (*i).first)) { break; @@ -248,8 +248,8 @@ std::string HttpRequest::createRequest() } } // append additional headers given by user. - for(std::vector<std::string>::const_iterator i = _headers.begin(), - eoi = _headers.end(); i != eoi; ++i) { + for(std::vector<std::string>::const_iterator i = headers_.begin(), + eoi = headers_.end(); i != eoi; ++i) { strappend(requestLine, (*i), A2STR::CRLF); } requestLine += A2STR::CRLF; @@ -258,13 +258,13 @@ std::string HttpRequest::createRequest() std::string HttpRequest::createProxyRequest() const { - assert(!_proxyRequest.isNull()); + assert(!proxyRequest_.isNull()); std::string hostport = getURIHost(); strappend(hostport, ":", util::uitos(getPort())); std::string requestLine = "CONNECT "; strappend(requestLine, hostport, " HTTP/1.1\r\n"); - strappend(requestLine, "User-Agent: ", _userAgent, "\r\n"); + strappend(requestLine, "User-Agent: ", userAgent_, "\r\n"); strappend(requestLine, "Host: ", hostport, "\r\n"); // TODO Is "Proxy-Connection" needed here? // if(request->isKeepAliveEnabled() || request->isPipeliningEnabled()) { @@ -272,7 +272,7 @@ std::string HttpRequest::createProxyRequest() const // }else { // requestLine += "Proxy-Connection: close\r\n"; // } - if(!_proxyRequest->getUsername().empty()) { + if(!proxyRequest_->getUsername().empty()) { std::pair<std::string, std::string> auth = getProxyAuthString(); strappend(requestLine, auth.first, " ", auth.second, A2STR::CRLF); } @@ -285,64 +285,64 @@ std::pair<std::string, std::string> HttpRequest::getProxyAuthString() const return std::make_pair ("Proxy-Authorization:", strconcat("Basic ", - Base64::encode(strconcat(_proxyRequest->getUsername(), + Base64::encode(strconcat(proxyRequest_->getUsername(), ":", - _proxyRequest->getPassword())))); + proxyRequest_->getPassword())))); } void HttpRequest::enableContentEncoding() { - _contentEncodingEnabled = true; + contentEncodingEnabled_ = true; } void HttpRequest::disableContentEncoding() { - _contentEncodingEnabled = false; + contentEncodingEnabled_ = false; } void HttpRequest::addHeader(const std::string& headersString) { std::vector<std::string> headers; util::split(headersString, std::back_inserter(headers), "\n", true); - _headers.insert(_headers.end(), headers.begin(), headers.end()); + headers_.insert(headers_.end(), headers.begin(), headers.end()); } void HttpRequest::addAcceptType(const std::string& type) { - _acceptTypes.push_back(type); + acceptTypes_.push_back(type); } void HttpRequest::setCookieStorage (const SharedHandle<CookieStorage>& cookieStorage) { - _cookieStorage = cookieStorage; + cookieStorage_ = cookieStorage; } void HttpRequest::setAuthConfigFactory (const SharedHandle<AuthConfigFactory>& factory, const Option* option) { - _authConfigFactory = factory; - _option = option; + authConfigFactory_ = factory; + option_ = option; } void HttpRequest::setProxyRequest(const SharedHandle<Request>& proxyRequest) { - _proxyRequest = proxyRequest; + proxyRequest_ = proxyRequest; } bool HttpRequest::isProxyRequestSet() const { - return !_proxyRequest.isNull(); + return !proxyRequest_.isNull(); } bool HttpRequest::authenticationUsed() const { - return !_authConfig.isNull(); + return !authConfig_.isNull(); } const SharedHandle<AuthConfig>& HttpRequest::getAuthConfig() const { - return _authConfig; + return authConfig_; } } // namespace aria2 diff --git a/src/HttpRequest.h b/src/HttpRequest.h index cc7d763f..1bc2089e 100644 --- a/src/HttpRequest.h +++ b/src/HttpRequest.h @@ -59,33 +59,33 @@ private: static const std::string USER_AGENT; - SharedHandle<Request> _request; + SharedHandle<Request> request_; - SharedHandle<FileEntry> _fileEntry; + SharedHandle<FileEntry> fileEntry_; - SharedHandle<Segment> _segment; + SharedHandle<Segment> segment_; - bool _contentEncodingEnabled; + bool contentEncodingEnabled_; - std::string _userAgent; + std::string userAgent_; - std::vector<std::string> _headers; + std::vector<std::string> headers_; - std::vector<std::string> _acceptTypes; + std::vector<std::string> acceptTypes_; - SharedHandle<CookieStorage> _cookieStorage; + SharedHandle<CookieStorage> cookieStorage_; - SharedHandle<AuthConfigFactory> _authConfigFactory; + SharedHandle<AuthConfigFactory> authConfigFactory_; - const Option* _option; + const Option* option_; - SharedHandle<AuthConfig> _authConfig; + SharedHandle<AuthConfig> authConfig_; - SharedHandle<Request> _proxyRequest; + SharedHandle<Request> proxyRequest_; - bool _noCache; + bool noCache_; - bool _acceptGzip; + bool acceptGzip_; std::pair<std::string, std::string> getProxyAuthString() const; public: @@ -93,7 +93,7 @@ public: const SharedHandle<Segment>& getSegment() const { - return _segment; + return segment_; } void setSegment(const SharedHandle<Segment>& segment); @@ -102,58 +102,58 @@ public: uint64_t getEntityLength() const { - assert(!_fileEntry.isNull()); - return _fileEntry->getLength(); + assert(!fileEntry_.isNull()); + return fileEntry_->getLength(); } const std::string& getHost() const { - return _request->getHost(); + return request_->getHost(); } uint16_t getPort() const { - return _request->getPort(); + return request_->getPort(); } const std::string& getMethod() const { - return _request->getMethod(); + return request_->getMethod(); } const std::string& getProtocol() const { - return _request->getProtocol(); + return request_->getProtocol(); } const std::string& getCurrentURI() const { - return _request->getCurrentUri(); + return request_->getCurrentUri(); } const std::string& getDir() const { - return _request->getDir(); + return request_->getDir(); } const std::string& getFile() const { - return _request->getFile(); + return request_->getFile(); } const std::string& getQuery() const { - return _request->getQuery(); + return request_->getQuery(); } const std::string& getPreviousURI() const { - return _request->getPreviousUri(); + return request_->getPreviousUri(); } std::string getURIHost() const { - return _request->getURIHost(); + return request_->getURIHost(); } SharedHandle<Range> getRange() const; @@ -166,7 +166,7 @@ public: const SharedHandle<Request>& getRequest() const { - return _request; + return request_; } off_t getStartByte() const; @@ -176,8 +176,8 @@ public: /** * Returns string representation of http request. It usually starts * with "GET ..." and ends with "\r\n". The AuthConfig for this - * request is resolved using _authConfigFactory and stored in - * _authConfig. getAuthConfig() returns AuthConfig used in the last + * request is resolved using authConfigFactory_ and stored in + * authConfig_. getAuthConfig() returns AuthConfig used in the last * invocation of createRequest(). */ std::string createRequest(); @@ -194,7 +194,7 @@ public: void setUserAgent(const std::string& userAgent) { - _userAgent = userAgent; + userAgent_ = userAgent; } // accepts multiline headers, delimited by LF @@ -205,14 +205,14 @@ public: template<typename InputIterator> void addAcceptType(InputIterator first, InputIterator last) { - _acceptTypes.insert(_acceptTypes.end(), first, last); + acceptTypes_.insert(acceptTypes_.end(), first, last); } void setCookieStorage(const SharedHandle<CookieStorage>& cookieStorage); const SharedHandle<CookieStorage>& getCookieStorage() const { - return _cookieStorage; + return cookieStorage_; } void setAuthConfigFactory @@ -240,37 +240,37 @@ public: void setFileEntry(const SharedHandle<FileEntry>& fileEntry) { - _fileEntry = fileEntry; + fileEntry_ = fileEntry; } const SharedHandle<FileEntry>& getFileEntry() const { - return _fileEntry; + return fileEntry_; } void enableNoCache() { - _noCache = true; + noCache_ = true; } void disableNoCache() { - _noCache = false; + noCache_ = false; } void enableAcceptGZip() { - _acceptGzip = true; + acceptGzip_ = true; } void disableAcceptGZip() { - _acceptGzip = false; + acceptGzip_ = false; } bool acceptGZip() const { - return _acceptGzip; + return acceptGzip_; } }; diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc index 9e598adb..9432b6a8 100644 --- a/src/HttpRequestCommand.cc +++ b/src/HttpRequestCommand.cc @@ -69,7 +69,7 @@ HttpRequestCommand::HttpRequestCommand DownloadEngine* e, const SocketHandle& s) :AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - _httpConnection(httpConnection) + httpConnection_(httpConnection) { setTimeout(getOption()->getAsInt(PREF_CONNECT_TIMEOUT)); disableReadCheckSocket(); @@ -124,9 +124,9 @@ bool HttpRequestCommand::executeInternal() { return false; } } - if(_httpConnection->sendBufferIsEmpty()) { + if(httpConnection_->sendBufferIsEmpty()) { if(!checkIfConnectionEstablished - (getSocket(), _connectedHostname, _connectedAddr, _connectedPort)) { + (getSocket(), connectedHostname_, connectedAddr_, connectedPort_)) { return true; } @@ -140,14 +140,14 @@ bool HttpRequestCommand::executeInternal() { getRequestGroup(), getDownloadEngine()->getCookieStorage(), getDownloadEngine()->getAuthConfigFactory(), - _proxyRequest)); - _httpConnection->sendRequest(httpRequest); + proxyRequest_)); + httpConnection_->sendRequest(httpRequest); } else { for(std::vector<SharedHandle<Segment> >::const_iterator itr = getSegments().begin(), eoi = getSegments().end(); itr != eoi; ++itr) { const SharedHandle<Segment>& segment = *itr; - if(!_httpConnection->isIssued(segment)) { + if(!httpConnection_->isIssued(segment)) { SharedHandle<HttpRequest> httpRequest (createHttpRequest(getRequest(), getFileEntry(), @@ -157,20 +157,20 @@ bool HttpRequestCommand::executeInternal() { getRequestGroup(), getDownloadEngine()->getCookieStorage(), getDownloadEngine()->getAuthConfigFactory(), - _proxyRequest)); - _httpConnection->sendRequest(httpRequest); + proxyRequest_)); + httpConnection_->sendRequest(httpRequest); } } } } else { - _httpConnection->sendPendingData(); + httpConnection_->sendPendingData(); } - if(_httpConnection->sendBufferIsEmpty()) { + if(httpConnection_->sendBufferIsEmpty()) { Command* command = new HttpResponseCommand(getCuid(), getRequest(), getFileEntry(), getRequestGroup(), - _httpConnection, + httpConnection_, getDownloadEngine(), getSocket()); getDownloadEngine()->addCommand(command); @@ -186,7 +186,7 @@ bool HttpRequestCommand::executeInternal() { void HttpRequestCommand::setProxyRequest (const SharedHandle<Request>& proxyRequest) { - _proxyRequest = proxyRequest; + proxyRequest_ = proxyRequest; } } // namespace aria2 diff --git a/src/HttpRequestCommand.h b/src/HttpRequestCommand.h index 5b1166bc..821ef8e8 100644 --- a/src/HttpRequestCommand.h +++ b/src/HttpRequestCommand.h @@ -44,13 +44,13 @@ class SocketCore; class HttpRequestCommand:public AbstractCommand { private: - SharedHandle<Request> _proxyRequest; + SharedHandle<Request> proxyRequest_; - SharedHandle<HttpConnection> _httpConnection; + SharedHandle<HttpConnection> httpConnection_; - std::string _connectedHostname; - std::string _connectedAddr; - uint16_t _connectedPort; + std::string connectedHostname_; + std::string connectedAddr_; + uint16_t connectedPort_; protected: virtual bool executeInternal(); public: @@ -68,9 +68,9 @@ public: void setConnectedAddr (const std::string& hostname, const std::string& addr, uint16_t port) { - _connectedHostname = hostname; - _connectedAddr = addr; - _connectedPort = port; + connectedHostname_ = hostname; + connectedAddr_ = addr; + connectedPort_ = port; } }; diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc index a6a436a4..5a1b39fa 100644 --- a/src/HttpResponse.cc +++ b/src/HttpResponse.cc @@ -57,8 +57,8 @@ namespace aria2 { -HttpResponse::HttpResponse():_cuid(0), - _logger(LogFactory::getInstance()) +HttpResponse::HttpResponse():cuid_(0), + logger_(LogFactory::getInstance()) {} HttpResponse::~HttpResponse() {} @@ -70,21 +70,21 @@ void HttpResponse::validateResponse() const return; } if(status >= HttpHeader::S300) { - if(!_httpHeader->defined(HttpHeader::LOCATION)) { + if(!httpHeader_->defined(HttpHeader::LOCATION)) { throw DL_ABORT_EX (StringFormat(EX_LOCATION_HEADER_REQUIRED, util::parseUInt(status)).str()); } - } else if(!_httpHeader->defined(HttpHeader::TRANSFER_ENCODING)) { + } else if(!httpHeader_->defined(HttpHeader::TRANSFER_ENCODING)) { // compare the received range against the requested range - RangeHandle responseRange = _httpHeader->getRange(); - if(!_httpRequest->isRangeSatisfied(responseRange)) { + RangeHandle responseRange = httpHeader_->getRange(); + if(!httpRequest_->isRangeSatisfied(responseRange)) { throw DL_ABORT_EX2 (StringFormat (EX_INVALID_RANGE_HEADER, - util::itos(_httpRequest->getStartByte(), true).c_str(), - util::itos(_httpRequest->getEndByte(), true).c_str(), - util::uitos(_httpRequest->getEntityLength(), true).c_str(), + util::itos(httpRequest_->getStartByte(), true).c_str(), + util::itos(httpRequest_->getEndByte(), true).c_str(), + util::uitos(httpRequest_->getEntityLength(), true).c_str(), util::itos(responseRange->getStartByte(), true).c_str(), util::itos(responseRange->getEndByte(), true).c_str(), util::uitos(responseRange->getEntityLength(), true).c_str()).str(), @@ -97,18 +97,18 @@ std::string HttpResponse::determinFilename() const { std::string contentDisposition = util::getContentDispositionFilename - (_httpHeader->getFirst(HttpHeader::CONTENT_DISPOSITION)); + (httpHeader_->getFirst(HttpHeader::CONTENT_DISPOSITION)); if(contentDisposition.empty()) { - std::string file = util::percentDecode(_httpRequest->getFile()); + std::string file = util::percentDecode(httpRequest_->getFile()); if(file.empty()) { return "index.html"; } else { return file; } } else { - if(_logger->info()) { - _logger->info(MSG_CONTENT_DISPOSITION_DETECTED, - util::itos(_cuid).c_str(), contentDisposition.c_str()); + if(logger_->info()) { + logger_->info(MSG_CONTENT_DISPOSITION_DETECTED, + util::itos(cuid_).c_str(), contentDisposition.c_str()); } return contentDisposition; } @@ -116,12 +116,12 @@ std::string HttpResponse::determinFilename() const void HttpResponse::retrieveCookie() { - std::vector<std::string> v = _httpHeader->get(HttpHeader::SET_COOKIE); + std::vector<std::string> v = httpHeader_->get(HttpHeader::SET_COOKIE); for(std::vector<std::string>::const_iterator itr = v.begin(), eoi = v.end(); itr != eoi; ++itr) { - _httpRequest->getCookieStorage()->parseAndStore(*itr, - _httpRequest->getHost(), - _httpRequest->getDir()); + httpRequest_->getCookieStorage()->parseAndStore(*itr, + httpRequest_->getHost(), + httpRequest_->getDir()); } } @@ -129,39 +129,39 @@ bool HttpResponse::isRedirect() const { const std::string& status = getResponseStatus(); return HttpHeader::S300 <= status && status < HttpHeader::S400 && - _httpHeader->defined(HttpHeader::LOCATION); + httpHeader_->defined(HttpHeader::LOCATION); } void HttpResponse::processRedirect() { - if(_httpRequest->getRequest()->redirectUri(getRedirectURI())) { - if(_logger->info()) { - _logger->info(MSG_REDIRECT, util::itos(_cuid).c_str(), - _httpRequest->getRequest()->getCurrentUri().c_str()); + if(httpRequest_->getRequest()->redirectUri(getRedirectURI())) { + if(logger_->info()) { + logger_->info(MSG_REDIRECT, util::itos(cuid_).c_str(), + httpRequest_->getRequest()->getCurrentUri().c_str()); } } else { throw DL_RETRY_EX (StringFormat("CUID#%s - Redirect to %s failed. It may not be a valid" - " URI.", util::itos(_cuid).c_str(), - _httpRequest->getRequest()->getCurrentUri().c_str()).str()); + " URI.", util::itos(cuid_).c_str(), + httpRequest_->getRequest()->getCurrentUri().c_str()).str()); } } std::string HttpResponse::getRedirectURI() const { - return _httpHeader->getFirst(HttpHeader::LOCATION); + return httpHeader_->getFirst(HttpHeader::LOCATION); } bool HttpResponse::isTransferEncodingSpecified() const { - return _httpHeader->defined(HttpHeader::TRANSFER_ENCODING); + return httpHeader_->defined(HttpHeader::TRANSFER_ENCODING); } std::string HttpResponse::getTransferEncoding() const { // TODO See TODO in getTransferEncodingDecoder() - return _httpHeader->getFirst(HttpHeader::TRANSFER_ENCODING); + return httpHeader_->getFirst(HttpHeader::TRANSFER_ENCODING); } SharedHandle<Decoder> HttpResponse::getTransferEncodingDecoder() const @@ -178,12 +178,12 @@ SharedHandle<Decoder> HttpResponse::getTransferEncodingDecoder() const bool HttpResponse::isContentEncodingSpecified() const { - return _httpHeader->defined(HttpHeader::CONTENT_ENCODING); + return httpHeader_->defined(HttpHeader::CONTENT_ENCODING); } const std::string& HttpResponse::getContentEncoding() const { - return _httpHeader->getFirst(HttpHeader::CONTENT_ENCODING); + return httpHeader_->getFirst(HttpHeader::CONTENT_ENCODING); } SharedHandle<Decoder> HttpResponse::getContentEncodingDecoder() const @@ -199,75 +199,75 @@ SharedHandle<Decoder> HttpResponse::getContentEncodingDecoder() const uint64_t HttpResponse::getContentLength() const { - if(_httpHeader.isNull()) { + if(httpHeader_.isNull()) { return 0; } else { - return _httpHeader->getRange()->getContentLength(); + return httpHeader_->getRange()->getContentLength(); } } uint64_t HttpResponse::getEntityLength() const { - if(_httpHeader.isNull()) { + if(httpHeader_.isNull()) { return 0; } else { - return _httpHeader->getRange()->getEntityLength(); + return httpHeader_->getRange()->getEntityLength(); } } std::string HttpResponse::getContentType() const { - if(_httpHeader.isNull()) { + if(httpHeader_.isNull()) { return A2STR::NIL; } else { return - util::split(_httpHeader->getFirst(HttpHeader::CONTENT_TYPE), ";").first; + util::split(httpHeader_->getFirst(HttpHeader::CONTENT_TYPE), ";").first; } } void HttpResponse::setHttpHeader(const SharedHandle<HttpHeader>& httpHeader) { - _httpHeader = httpHeader; + httpHeader_ = httpHeader; } void HttpResponse::setHttpRequest(const SharedHandle<HttpRequest>& httpRequest) { - _httpRequest = httpRequest; + httpRequest_ = httpRequest; } // TODO return std::string const std::string& HttpResponse::getResponseStatus() const { - return _httpHeader->getResponseStatus(); + return httpHeader_->getResponseStatus(); } bool HttpResponse::hasRetryAfter() const { - return _httpHeader->defined(HttpHeader::RETRY_AFTER); + return httpHeader_->defined(HttpHeader::RETRY_AFTER); } time_t HttpResponse::getRetryAfter() const { - return _httpHeader->getFirstAsUInt(HttpHeader::RETRY_AFTER); + return httpHeader_->getFirstAsUInt(HttpHeader::RETRY_AFTER); } Time HttpResponse::getLastModifiedTime() const { - return Time::parseHTTPDate(_httpHeader->getFirst(HttpHeader::LAST_MODIFIED)); + return Time::parseHTTPDate(httpHeader_->getFirst(HttpHeader::LAST_MODIFIED)); } bool HttpResponse::supportsPersistentConnection() const { std::string connection = - util::toLower(_httpHeader->getFirst(HttpHeader::CONNECTION)); - std::string version = _httpHeader->getVersion(); + util::toLower(httpHeader_->getFirst(HttpHeader::CONNECTION)); + std::string version = httpHeader_->getVersion(); return connection.find(HttpHeader::CLOSE) == std::string::npos && (version == HttpHeader::HTTP_1_1 || connection.find("keep-alive") != std::string::npos) && - (!_httpRequest->isProxyRequestSet() || - util::toLower(_httpHeader->getFirst("Proxy-Connection")).find("keep-alive") + (!httpRequest_->isProxyRequestSet() || + util::toLower(httpHeader_->getFirst("Proxy-Connection")).find("keep-alive") != std::string::npos); } diff --git a/src/HttpResponse.h b/src/HttpResponse.h index 9cf5ee56..d3b96281 100644 --- a/src/HttpResponse.h +++ b/src/HttpResponse.h @@ -52,10 +52,10 @@ class Decoder; class HttpResponse { private: - cuid_t _cuid; - SharedHandle<HttpRequest> _httpRequest; - SharedHandle<HttpHeader> _httpHeader; - Logger* _logger; + cuid_t cuid_; + SharedHandle<HttpRequest> httpRequest_; + SharedHandle<HttpHeader> httpHeader_; + Logger* logger_; public: HttpResponse(); @@ -105,7 +105,7 @@ public: const SharedHandle<HttpHeader>& getHttpHeader() const { - return _httpHeader; + return httpHeader_; } const std::string& getResponseStatus() const; @@ -114,12 +114,12 @@ public: const SharedHandle<HttpRequest>& getHttpRequest() const { - return _httpRequest; + return httpRequest_; } void setCuid(cuid_t cuid) { - _cuid = cuid; + cuid_ = cuid; } bool hasRetryAfter() const; diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc index 30f7045a..c1b94848 100644 --- a/src/HttpResponseCommand.cc +++ b/src/HttpResponseCommand.cc @@ -87,15 +87,15 @@ 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 @@ -364,7 +364,7 @@ bool HttpResponseCommand::skipResponseBody HttpSkipResponseCommand* command = new HttpSkipResponseCommand (getCuid(), getRequest(), getFileEntry(), getRequestGroup(), - _httpConnection, httpResponse, + httpConnection_, httpResponse, getDownloadEngine(), getSocket()); command->setTransferEncodingDecoder(decoder); @@ -392,7 +392,7 @@ HttpDownloadCommand* HttpResponseCommand::createHttpDownloadCommand HttpDownloadCommand* command = new HttpDownloadCommand(getCuid(), getRequest(), getFileEntry(), getRequestGroup(), - httpResponse, _httpConnection, + httpResponse, httpConnection_, getDownloadEngine(), getSocket()); command->setStartupIdleTime(getOption()->getAsInt(PREF_STARTUP_IDLE_TIME)); command->setLowestDownloadSpeedLimit diff --git a/src/HttpResponseCommand.h b/src/HttpResponseCommand.h index a62a7331..79f2618b 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/HttpServer.cc b/src/HttpServer.cc index 8cce9a4e..fb577cf6 100644 --- a/src/HttpServer.cc +++ b/src/HttpServer.cc @@ -51,15 +51,15 @@ namespace aria2 { HttpServer::HttpServer(const SharedHandle<SocketCore>& socket, DownloadEngine* e): - _socket(socket), - _socketBuffer(socket), - _e(e), - _headerProcessor(new HttpHeaderProcessor()), - _logger(LogFactory::getInstance()), - _keepAlive(true), - _gzip(false), - _acceptsPersistentConnection(true), - _acceptsGZip(false) + socket_(socket), + socketBuffer_(socket), + e_(e), + headerProcessor_(new HttpHeaderProcessor()), + logger_(LogFactory::getInstance()), + keepAlive_(true), + gzip_(false), + acceptsPersistentConnection_(true), + acceptsGZip_(false) {} HttpServer::~HttpServer() {} @@ -68,41 +68,41 @@ SharedHandle<HttpHeader> HttpServer::receiveRequest() { size_t size = 512; unsigned char buf[size]; - _socket->peekData(buf, size); - if(size == 0 && !(_socket->wantRead() || _socket->wantWrite())) { + socket_->peekData(buf, size); + if(size == 0 && !(socket_->wantRead() || socket_->wantWrite())) { throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _headerProcessor->update(buf, size); - if(!_headerProcessor->eoh()) { - _socket->readData(buf, size); + headerProcessor_->update(buf, size); + if(!headerProcessor_->eoh()) { + socket_->readData(buf, size); return SharedHandle<HttpHeader>(); } - size_t putbackDataLength = _headerProcessor->getPutBackDataLength(); + size_t putbackDataLength = headerProcessor_->getPutBackDataLength(); size -= putbackDataLength; - _socket->readData(buf, size); + socket_->readData(buf, size); - SharedHandle<HttpHeader> header = _headerProcessor->getHttpRequestHeader(); + SharedHandle<HttpHeader> header = headerProcessor_->getHttpRequestHeader(); if(!header.isNull()) { - _logger->info("HTTP Server received request\n%s", - _headerProcessor->getHeaderString().c_str()); - _lastRequestHeader = header; - _lastBody.clear(); - _lastBody.str(""); - _lastContentLength = - _lastRequestHeader->getFirstAsUInt(HttpHeader::CONTENT_LENGTH); - _headerProcessor->clear(); + logger_->info("HTTP Server received request\n%s", + headerProcessor_->getHeaderString().c_str()); + lastRequestHeader_ = header; + lastBody_.clear(); + lastBody_.str(""); + lastContentLength_ = + lastRequestHeader_->getFirstAsUInt(HttpHeader::CONTENT_LENGTH); + headerProcessor_->clear(); std::string connection = - util::toLower(_lastRequestHeader->getFirst(HttpHeader::CONNECTION)); - _acceptsPersistentConnection = + util::toLower(lastRequestHeader_->getFirst(HttpHeader::CONNECTION)); + acceptsPersistentConnection_ = connection.find(HttpHeader::CLOSE) == std::string::npos && - (_lastRequestHeader->getVersion() == HttpHeader::HTTP_1_1 || + (lastRequestHeader_->getVersion() == HttpHeader::HTTP_1_1 || connection.find("keep-alive") != std::string::npos); std::vector<std::string> acceptEncodings; - util::split(_lastRequestHeader->getFirst(HttpHeader::ACCEPT_ENCODING), + util::split(lastRequestHeader_->getFirst(HttpHeader::ACCEPT_ENCODING), std::back_inserter(acceptEncodings), A2STR::COMMA_C, true); - _acceptsGZip = + acceptsGZip_ = std::find(acceptEncodings.begin(), acceptEncodings.end(), "gzip") != acceptEncodings.end(); } @@ -111,30 +111,30 @@ SharedHandle<HttpHeader> HttpServer::receiveRequest() bool HttpServer::receiveBody() { - if(_lastContentLength == 0) { + if(lastContentLength_ == 0) { return true; } const size_t BUFLEN = 4096; char buf[BUFLEN]; size_t length = std::min(BUFLEN, static_cast<size_t> - (_lastContentLength-_lastBody.tellg())); - _socket->readData(buf, length); - if(length == 0 && !(_socket->wantRead() || _socket->wantWrite())) { + (lastContentLength_-lastBody_.tellg())); + socket_->readData(buf, length); + if(length == 0 && !(socket_->wantRead() || socket_->wantWrite())) { throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _lastBody.write(buf, length); - return _lastContentLength == static_cast<uint64_t>(_lastBody.tellp()); + lastBody_.write(buf, length); + return lastContentLength_ == static_cast<uint64_t>(lastBody_.tellp()); } std::string HttpServer::getBody() const { - return _lastBody.str(); + return lastBody_.str(); } const std::string& HttpServer::getRequestPath() const { - return _lastRequestHeader->getRequestPath(); + return lastRequestHeader_->getRequestPath(); } void HttpServer::feedResponse(const std::string& text, const std::string& contentType) @@ -165,30 +165,30 @@ void HttpServer::feedResponse(const std::string& status, } header += "\r\n"; - if(_logger->debug()) { - _logger->debug("HTTP Server sends response:\n%s", header.c_str()); + if(logger_->debug()) { + logger_->debug("HTTP Server sends response:\n%s", header.c_str()); } - _socketBuffer.pushStr(header); - _socketBuffer.pushStr(text); + socketBuffer_.pushStr(header); + socketBuffer_.pushStr(text); } ssize_t HttpServer::sendResponse() { - return _socketBuffer.send(); + return socketBuffer_.send(); } bool HttpServer::sendBufferIsEmpty() const { - return _socketBuffer.sendBufferIsEmpty(); + return socketBuffer_.sendBufferIsEmpty(); } bool HttpServer::authenticate() { - if(_username.empty()) { + if(username_.empty()) { return true; } - std::string authHeader = _lastRequestHeader->getFirst("Authorization"); + std::string authHeader = lastRequestHeader_->getFirst("Authorization"); if(authHeader.empty()) { return false; } @@ -198,7 +198,7 @@ bool HttpServer::authenticate() } std::string userpass = Base64::decode(p.second); std::pair<std::string, std::string> userpassPair = util::split(userpass, ":"); - return _username == userpassPair.first && _password == userpassPair.second; + return username_ == userpassPair.first && password_ == userpassPair.second; } } // namespace aria2 diff --git a/src/HttpServer.h b/src/HttpServer.h index 604eb717..5ba7c291 100644 --- a/src/HttpServer.h +++ b/src/HttpServer.h @@ -54,20 +54,20 @@ class Logger; class HttpServer { private: - SharedHandle<SocketCore> _socket; - SocketBuffer _socketBuffer; - DownloadEngine* _e; - SharedHandle<HttpHeaderProcessor> _headerProcessor; - Logger* _logger; - SharedHandle<HttpHeader> _lastRequestHeader; - uint64_t _lastContentLength; - std::stringstream _lastBody; - bool _keepAlive; - bool _gzip; - std::string _username; - std::string _password; - bool _acceptsPersistentConnection; - bool _acceptsGZip; + SharedHandle<SocketCore> socket_; + SocketBuffer socketBuffer_; + DownloadEngine* e_; + SharedHandle<HttpHeaderProcessor> headerProcessor_; + Logger* logger_; + SharedHandle<HttpHeader> lastRequestHeader_; + uint64_t lastContentLength_; + std::stringstream lastBody_; + bool keepAlive_; + bool gzip_; + std::string username_; + std::string password_; + bool acceptsPersistentConnection_; + bool acceptsGZip_; public: HttpServer(const SharedHandle<SocketCore>& socket, DownloadEngine* e); @@ -93,8 +93,8 @@ public: void setUsernamePassword (const std::string& username, const std::string& password) { - _username = username; - _password = password; + username_ = username; + password_ = password; } ssize_t sendResponse(); @@ -103,23 +103,23 @@ public: bool supportsPersistentConnection() const { - return _keepAlive && _acceptsPersistentConnection; + return keepAlive_ && acceptsPersistentConnection_; } bool supportsGZip() const { - return _gzip && _acceptsGZip; + return gzip_ && acceptsGZip_; } - void enableKeepAlive() { _keepAlive = true; } + void enableKeepAlive() { keepAlive_ = true; } - void disableKeepAlive() { _keepAlive = false; } + void disableKeepAlive() { keepAlive_ = false; } - void enableGZip() { _gzip = true; } + void enableGZip() { gzip_ = true; } - void disableGZip() { _gzip = false; } + void disableGZip() { gzip_ = false; } - uint64_t getContentLength() const { return _lastContentLength; } + uint64_t getContentLength() const { return lastContentLength_; } }; } // namespace aria2 diff --git a/src/HttpServerBodyCommand.cc b/src/HttpServerBodyCommand.cc index c1e3d79f..22a23e2a 100644 --- a/src/HttpServerBodyCommand.cc +++ b/src/HttpServerBodyCommand.cc @@ -64,58 +64,58 @@ HttpServerBodyCommand::HttpServerBodyCommand DownloadEngine* e, const SharedHandle<SocketCore>& socket): Command(cuid), - _e(e), - _socket(socket), - _httpServer(httpServer) + e_(e), + socket_(socket), + httpServer_(httpServer) { setStatus(Command::STATUS_ONESHOT_REALTIME); - _e->addSocketForReadCheck(_socket, this); + e_->addSocketForReadCheck(socket_, this); } HttpServerBodyCommand::~HttpServerBodyCommand() { - _e->deleteSocketForReadCheck(_socket, this); + e_->deleteSocketForReadCheck(socket_, this); } bool HttpServerBodyCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } try { - if(_socket->isReadable(0) || _httpServer->getContentLength() == 0) { - _timeoutTimer = global::wallclock; + if(socket_->isReadable(0) || httpServer_->getContentLength() == 0) { + timeoutTimer_ = global::wallclock; - if(_httpServer->receiveBody()) { + if(httpServer_->receiveBody()) { // Do something for requestpath and body - if(_httpServer->getRequestPath() == "/rpc") { + if(httpServer_->getRequestPath() == "/rpc") { xmlrpc::XmlRpcRequest req = - xmlrpc::XmlRpcRequestProcessor().parseMemory(_httpServer->getBody()); + xmlrpc::XmlRpcRequestProcessor().parseMemory(httpServer_->getBody()); SharedHandle<xmlrpc::XmlRpcMethod> method = xmlrpc::XmlRpcMethodFactory::create(req.methodName); - xmlrpc::XmlRpcResponse res = method->execute(req, _e); - bool gzip = _httpServer->supportsGZip(); + xmlrpc::XmlRpcResponse res = method->execute(req, e_); + bool gzip = httpServer_->supportsGZip(); std::string responseData = res.toXml(gzip); - _httpServer->feedResponse(responseData, "text/xml"); + httpServer_->feedResponse(responseData, "text/xml"); Command* command = - new HttpServerResponseCommand(getCuid(), _httpServer, _e, _socket); - _e->addCommand(command); - _e->setNoWait(true); + new HttpServerResponseCommand(getCuid(), httpServer_, e_, socket_); + e_->addCommand(command); + e_->setNoWait(true); return true; } else { return true; } } else { - _e->addCommand(this); + e_->addCommand(this); return false; } } else { - if(_timeoutTimer.difference(global::wallclock) >= 30) { + if(timeoutTimer_.difference(global::wallclock) >= 30) { getLogger()->info("HTTP request body timeout."); return true; } else { - _e->addCommand(this); + e_->addCommand(this); return false; } } diff --git a/src/HttpServerBodyCommand.h b/src/HttpServerBodyCommand.h index b117dbc1..a9ba9676 100644 --- a/src/HttpServerBodyCommand.h +++ b/src/HttpServerBodyCommand.h @@ -47,10 +47,10 @@ class HttpServer; class HttpServerBodyCommand : public Command { private: - DownloadEngine* _e; - SharedHandle<SocketCore> _socket; - SharedHandle<HttpServer> _httpServer; - Timer _timeoutTimer; + DownloadEngine* e_; + SharedHandle<SocketCore> socket_; + SharedHandle<HttpServer> httpServer_; + Timer timeoutTimer_; public: HttpServerBodyCommand(cuid_t cuid, const SharedHandle<HttpServer>& httpServer, diff --git a/src/HttpServerCommand.cc b/src/HttpServerCommand.cc index 06521cbb..bbce79df 100644 --- a/src/HttpServerCommand.cc +++ b/src/HttpServerCommand.cc @@ -57,18 +57,18 @@ namespace aria2 { HttpServerCommand::HttpServerCommand(cuid_t cuid, DownloadEngine* e, const SharedHandle<SocketCore>& socket): Command(cuid), - _e(e), - _socket(socket), - _httpServer(new HttpServer(socket, e)) + e_(e), + socket_(socket), + httpServer_(new HttpServer(socket, e)) { setStatus(Command::STATUS_ONESHOT_REALTIME); - _e->addSocketForReadCheck(_socket, this); - _httpServer->setUsernamePassword(_e->getOption()->get(PREF_XML_RPC_USER), - _e->getOption()->get(PREF_XML_RPC_PASSWD)); + e_->addSocketForReadCheck(socket_, this); + httpServer_->setUsernamePassword(e_->getOption()->get(PREF_XML_RPC_USER), + e_->getOption()->get(PREF_XML_RPC_PASSWD)); #ifdef HAVE_LIBZ - _httpServer->enableGZip(); + httpServer_->enableGZip(); #else // !HAVE_LIBZ - _httpServer->disableGZip(); + httpServer_->disableGZip(); #endif // !HAVE_LIBZ } @@ -77,65 +77,65 @@ HttpServerCommand::HttpServerCommand(cuid_t cuid, DownloadEngine* e, const SharedHandle<SocketCore>& socket): Command(cuid), - _e(e), - _socket(socket), - _httpServer(httpServer) + e_(e), + socket_(socket), + httpServer_(httpServer) { - _e->addSocketForReadCheck(_socket, this); + e_->addSocketForReadCheck(socket_, this); } HttpServerCommand::~HttpServerCommand() { - _e->deleteSocketForReadCheck(_socket, this); + e_->deleteSocketForReadCheck(socket_, this); } bool HttpServerCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } try { - if(_socket->isReadable(0)) { - _timeoutTimer = global::wallclock; + if(socket_->isReadable(0)) { + timeoutTimer_ = global::wallclock; SharedHandle<HttpHeader> header; - header = _httpServer->receiveRequest(); + header = httpServer_->receiveRequest(); if(header.isNull()) { - _e->addCommand(this); + e_->addCommand(this); return false; } - if(!_httpServer->authenticate()) { - _httpServer->disableKeepAlive(); - _httpServer->feedResponse("401 Unauthorized", + if(!httpServer_->authenticate()) { + httpServer_->disableKeepAlive(); + httpServer_->feedResponse("401 Unauthorized", "WWW-Authenticate: Basic realm=\"aria2\"", "","text/html"); Command* command = - new HttpServerResponseCommand(getCuid(), _httpServer, _e, _socket); - _e->addCommand(command); - _e->setNoWait(true); + new HttpServerResponseCommand(getCuid(), httpServer_, e_, socket_); + e_->addCommand(command); + e_->setNoWait(true); return true; } if(static_cast<uint64_t> - (_e->getOption()->getAsInt(PREF_XML_RPC_MAX_REQUEST_SIZE)) < - _httpServer->getContentLength()) { + (e_->getOption()->getAsInt(PREF_XML_RPC_MAX_REQUEST_SIZE)) < + httpServer_->getContentLength()) { getLogger()->info("Request too long. ContentLength=%s." " See --xml-rpc-max-request-size option to loose" " this limitation.", - util::uitos(_httpServer->getContentLength()).c_str()); + util::uitos(httpServer_->getContentLength()).c_str()); return true; } - Command* command = new HttpServerBodyCommand(getCuid(), _httpServer, _e, - _socket); - _e->addCommand(command); - _e->setNoWait(true); + Command* command = new HttpServerBodyCommand(getCuid(), httpServer_, e_, + socket_); + e_->addCommand(command); + e_->setNoWait(true); return true; } else { - if(_timeoutTimer.difference(global::wallclock) >= 30) { + if(timeoutTimer_.difference(global::wallclock) >= 30) { getLogger()->info("HTTP request timeout."); return true; } else { - _e->addCommand(this); + e_->addCommand(this); return false; } } diff --git a/src/HttpServerCommand.h b/src/HttpServerCommand.h index d1d6de30..85b8c1a8 100644 --- a/src/HttpServerCommand.h +++ b/src/HttpServerCommand.h @@ -47,10 +47,10 @@ class HttpServer; class HttpServerCommand : public Command { private: - DownloadEngine* _e; - SharedHandle<SocketCore> _socket; - SharedHandle<HttpServer> _httpServer; - Timer _timeoutTimer; + DownloadEngine* e_; + SharedHandle<SocketCore> socket_; + SharedHandle<HttpServer> httpServer_; + Timer timeoutTimer_; public: HttpServerCommand(cuid_t cuid, DownloadEngine* e, const SharedHandle<SocketCore>& socket); diff --git a/src/HttpServerResponseCommand.cc b/src/HttpServerResponseCommand.cc index 4b98b193..ebdd167f 100644 --- a/src/HttpServerResponseCommand.cc +++ b/src/HttpServerResponseCommand.cc @@ -55,26 +55,26 @@ HttpServerResponseCommand::HttpServerResponseCommand DownloadEngine* e, const SharedHandle<SocketCore>& socket): Command(cuid), - _e(e), - _socket(socket), - _httpServer(httpServer) + e_(e), + socket_(socket), + httpServer_(httpServer) { setStatus(Command::STATUS_ONESHOT_REALTIME); - _e->addSocketForWriteCheck(_socket, this); + e_->addSocketForWriteCheck(socket_, this); } HttpServerResponseCommand::~HttpServerResponseCommand() { - _e->deleteSocketForWriteCheck(_socket, this); + e_->deleteSocketForWriteCheck(socket_, this); } bool HttpServerResponseCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } try { - _httpServer->sendResponse(); + httpServer_->sendResponse(); } catch(RecoverableException& e) { if(getLogger()->info()) { getLogger()->info @@ -83,29 +83,29 @@ bool HttpServerResponseCommand::execute() } return true; } - if(_httpServer->sendBufferIsEmpty()) { + if(httpServer_->sendBufferIsEmpty()) { if(getLogger()->info()) { getLogger()->info("CUID#%s - HttpServer: all response transmitted.", util::itos(getCuid()).c_str()); } - if(_httpServer->supportsPersistentConnection()) { + if(httpServer_->supportsPersistentConnection()) { if(getLogger()->info()) { getLogger()->info("CUID#%s - Persist connection.", util::itos(getCuid()).c_str()); } - _e->addCommand - (new HttpServerCommand(getCuid(), _httpServer, _e, _socket)); + e_->addCommand + (new HttpServerCommand(getCuid(), httpServer_, e_, socket_)); } return true; } else { - if(_timeoutTimer.difference(global::wallclock) >= 10) { + if(timeoutTimer_.difference(global::wallclock) >= 10) { if(getLogger()->info()) { getLogger()->info("CUID#%s - HttpServer: Timeout while trasmitting" " response.", util::itos(getCuid()).c_str()); } return true; } else { - _e->addCommand(this); + e_->addCommand(this); return false; } } diff --git a/src/HttpServerResponseCommand.h b/src/HttpServerResponseCommand.h index ad654ae3..b86ae75e 100644 --- a/src/HttpServerResponseCommand.h +++ b/src/HttpServerResponseCommand.h @@ -47,10 +47,10 @@ class HttpServer; class HttpServerResponseCommand : public Command { private: - DownloadEngine* _e; - SharedHandle<SocketCore> _socket; - SharedHandle<HttpServer> _httpServer; - Timer _timeoutTimer; + DownloadEngine* e_; + SharedHandle<SocketCore> socket_; + SharedHandle<HttpServer> httpServer_; + Timer timeoutTimer_; public: HttpServerResponseCommand(cuid_t cuid, const SharedHandle<HttpServer>& httpServer, diff --git a/src/HttpSkipResponseCommand.cc b/src/HttpSkipResponseCommand.cc index 7818d5f0..43ad841e 100644 --- a/src/HttpSkipResponseCommand.cc +++ b/src/HttpSkipResponseCommand.cc @@ -71,10 +71,10 @@ HttpSkipResponseCommand::HttpSkipResponseCommand DownloadEngine* e, const SharedHandle<SocketCore>& s): AbstractCommand(cuid, req, fileEntry, requestGroup, e, s), - _httpConnection(httpConnection), - _httpResponse(httpResponse), - _totalLength(_httpResponse->getEntityLength()), - _receivedBytes(0) + httpConnection_(httpConnection), + httpResponse_(httpResponse), + totalLength_(httpResponse_->getEntityLength()), + receivedBytes_(0) {} HttpSkipResponseCommand::~HttpSkipResponseCommand() {} @@ -82,19 +82,19 @@ HttpSkipResponseCommand::~HttpSkipResponseCommand() {} void HttpSkipResponseCommand::setTransferEncodingDecoder (const SharedHandle<Decoder>& decoder) { - _transferEncodingDecoder = decoder; + transferEncodingDecoder_ = decoder; } bool HttpSkipResponseCommand::executeInternal() { if(getRequest()->getMethod() == Request::METHOD_HEAD || - (_totalLength == 0 && _transferEncodingDecoder.isNull())) { + (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(getRequest()->getMethod() == Request::METHOD_HEAD || - _httpResponse->getHttpHeader()->defined(HttpHeader::CONTENT_LENGTH)) { + httpResponse_->getHttpHeader()->defined(HttpHeader::CONTENT_LENGTH)) { poolConnection(); } return processResponse(); @@ -106,14 +106,14 @@ bool HttpSkipResponseCommand::executeInternal() try { getSocket()->readData(buf, bufSize); - if(_transferEncodingDecoder.isNull()) { - _receivedBytes += bufSize; + if(transferEncodingDecoder_.isNull()) { + receivedBytes_ += bufSize; } else { - // _receivedBytes is not updated if transferEncoding is set. + // receivedBytes_ is not updated if transferEncoding is set. // The return value is safely ignored here. - _transferEncodingDecoder->decode(buf, bufSize); + transferEncodingDecoder_->decode(buf, bufSize); } - if(_totalLength != 0 && bufSize == 0 && + if(totalLength_ != 0 && bufSize == 0 && !getSocket()->wantRead() && !getSocket()->wantWrite()) { throw DL_RETRY_EX(EX_GOT_EOF); } @@ -125,16 +125,16 @@ bool HttpSkipResponseCommand::executeInternal() } bool finished = false; - if(_transferEncodingDecoder.isNull()) { + if(transferEncodingDecoder_.isNull()) { if(bufSize == 0) { if(!getSocket()->wantRead() && !getSocket()->wantWrite()) { return processResponse(); } } else { - finished = (_totalLength == _receivedBytes); + finished = (totalLength_ == receivedBytes_); } } else { - finished = _transferEncodingDecoder->finished(); + finished = transferEncodingDecoder_->finished(); } if(finished) { poolConnection(); @@ -156,33 +156,33 @@ void HttpSkipResponseCommand::poolConnection() const bool HttpSkipResponseCommand::processResponse() { - if(_httpResponse->isRedirect()) { + if(httpResponse_->isRedirect()) { unsigned int rnum = - _httpResponse->getHttpRequest()->getRequest()->getRedirectCount(); + httpResponse_->getHttpRequest()->getRequest()->getRedirectCount(); if(rnum >= Request::MAX_REDIRECT) { throw DL_ABORT_EX (StringFormat("Too many redirects: count=%u", rnum).str()); } - _httpResponse->processRedirect(); + httpResponse_->processRedirect(); return prepareForRetry(0); - } else if(_httpResponse->getResponseStatus() >= HttpHeader::S400) { - if(_httpResponse->getResponseStatus() == HttpHeader::S401) { + } else if(httpResponse_->getResponseStatus() >= HttpHeader::S400) { + if(httpResponse_->getResponseStatus() == HttpHeader::S401) { if(getOption()->getAsBool(PREF_HTTP_AUTH_CHALLENGE) && - !_httpResponse->getHttpRequest()->authenticationUsed() && + !httpResponse_->getHttpRequest()->authenticationUsed() && getDownloadEngine()->getAuthConfigFactory()->activateBasicCred (getRequest()->getHost(), getRequest()->getDir(), getOption().get())) { return prepareForRetry(0); } else { throw DL_ABORT_EX(EX_AUTH_FAILED); } - }else if(_httpResponse->getResponseStatus() == HttpHeader::S404) { + }else if(httpResponse_->getResponseStatus() == HttpHeader::S404) { 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()); + util::parseUInt(httpResponse_->getResponseStatus())).str()); } } else { return prepareForRetry(0); diff --git a/src/HttpSkipResponseCommand.h b/src/HttpSkipResponseCommand.h index 8de62fd0..2a865cf7 100644 --- a/src/HttpSkipResponseCommand.h +++ b/src/HttpSkipResponseCommand.h @@ -45,15 +45,15 @@ class Decoder; class HttpSkipResponseCommand : public AbstractCommand { private: - SharedHandle<HttpConnection> _httpConnection; + SharedHandle<HttpConnection> httpConnection_; - SharedHandle<HttpResponse> _httpResponse; + SharedHandle<HttpResponse> httpResponse_; - SharedHandle<Decoder> _transferEncodingDecoder; + SharedHandle<Decoder> transferEncodingDecoder_; - uint64_t _totalLength; + uint64_t totalLength_; - uint64_t _receivedBytes; + uint64_t receivedBytes_; bool processResponse(); diff --git a/src/IndexBtMessage.cc b/src/IndexBtMessage.cc index 66d5d430..2480975b 100644 --- a/src/IndexBtMessage.cc +++ b/src/IndexBtMessage.cc @@ -49,7 +49,7 @@ unsigned char* IndexBtMessage::createMessage() */ unsigned char* msg = new unsigned char[MESSAGE_LENGTH]; bittorrent::createPeerMessageString(msg, MESSAGE_LENGTH, 5, getId()); - bittorrent::setIntParam(&msg[5], _index); + bittorrent::setIntParam(&msg[5], index_); return msg; } @@ -60,7 +60,7 @@ size_t IndexBtMessage::getMessageLength() std::string IndexBtMessage::toString() const { - return strconcat(getName(), " index=", util::itos(_index)); + return strconcat(getName(), " index=", util::itos(index_)); } } // namespace aria2 diff --git a/src/IndexBtMessage.h b/src/IndexBtMessage.h index 2969917d..3c1d0529 100644 --- a/src/IndexBtMessage.h +++ b/src/IndexBtMessage.h @@ -42,7 +42,7 @@ namespace aria2 { class IndexBtMessage : public SimpleBtMessage { private: - size_t _index; + size_t index_; static const size_t MESSAGE_LENGTH = 9; protected: @@ -58,11 +58,11 @@ protected: public: IndexBtMessage(uint8_t id, const std::string& name, size_t index) :SimpleBtMessage(id, name), - _index(index) {} + index_(index) {} - void setIndex(size_t index) { _index = index; } + void setIndex(size_t index) { index_ = index; } - size_t getIndex() const { return _index; } + size_t getIndex() const { return index_; } virtual unsigned char* createMessage(); diff --git a/src/IndexBtMessageValidator.h b/src/IndexBtMessageValidator.h index 60d1dc18..d5207f29 100644 --- a/src/IndexBtMessageValidator.h +++ b/src/IndexBtMessageValidator.h @@ -43,17 +43,17 @@ namespace aria2 { class IndexBtMessageValidator : public BtMessageValidator { private: - const IndexBtMessage* _message; - size_t _numPiece; + const IndexBtMessage* message_; + size_t numPiece_; public: IndexBtMessageValidator(const IndexBtMessage* message, size_t numPiece): - _message(message), - _numPiece(numPiece) {} + message_(message), + numPiece_(numPiece) {} virtual void validate() { - bittorrent::checkIndex(_message->getIndex(), _numPiece); + bittorrent::checkIndex(message_->getIndex(), numPiece_); } }; diff --git a/src/InitiatorMSEHandshakeCommand.cc b/src/InitiatorMSEHandshakeCommand.cc index 4245f4a6..88524e1e 100644 --- a/src/InitiatorMSEHandshakeCommand.cc +++ b/src/InitiatorMSEHandshakeCommand.cc @@ -70,29 +70,29 @@ InitiatorMSEHandshakeCommand::InitiatorMSEHandshakeCommand const SharedHandle<SocketCore>& s): PeerAbstractCommand(cuid, p, e, s), - _requestGroup(requestGroup), - _btRuntime(btRuntime), - _sequence(INITIATOR_SEND_KEY), - _mseHandshake(new MSEHandshake(cuid, s, getOption().get())) + requestGroup_(requestGroup), + btRuntime_(btRuntime), + sequence_(INITIATOR_SEND_KEY), + mseHandshake_(new MSEHandshake(cuid, s, getOption().get())) { disableReadCheckSocket(); setWriteCheckSocket(getSocket()); setTimeout(getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT)); - _btRuntime->increaseConnections(); - _requestGroup->increaseNumCommand(); + btRuntime_->increaseConnections(); + requestGroup_->increaseNumCommand(); } InitiatorMSEHandshakeCommand::~InitiatorMSEHandshakeCommand() { - _requestGroup->decreaseNumCommand(); - _btRuntime->decreaseConnections(); + requestGroup_->decreaseNumCommand(); + btRuntime_->decreaseConnections(); - delete _mseHandshake; + delete mseHandshake_; } bool InitiatorMSEHandshakeCommand::executeInternal() { - switch(_sequence) { + switch(sequence_) { case INITIATOR_SEND_KEY: { if(!getSocket()->isWritable(0)) { break; @@ -101,65 +101,65 @@ bool InitiatorMSEHandshakeCommand::executeInternal() { setReadCheckSocket(getSocket()); //socket->setBlockingMode(); setTimeout(getOption()->getAsInt(PREF_BT_TIMEOUT)); - _mseHandshake->initEncryptionFacility(true); - if(_mseHandshake->sendPublicKey()) { - _sequence = INITIATOR_WAIT_KEY; + mseHandshake_->initEncryptionFacility(true); + if(mseHandshake_->sendPublicKey()) { + sequence_ = INITIATOR_WAIT_KEY; } else { setWriteCheckSocket(getSocket()); - _sequence = INITIATOR_SEND_KEY_PENDING; + sequence_ = INITIATOR_SEND_KEY_PENDING; } break; } case INITIATOR_SEND_KEY_PENDING: - if(_mseHandshake->sendPublicKey()) { + if(mseHandshake_->sendPublicKey()) { disableWriteCheckSocket(); - _sequence = INITIATOR_WAIT_KEY; + sequence_ = INITIATOR_WAIT_KEY; } break; case INITIATOR_WAIT_KEY: { - if(_mseHandshake->receivePublicKey()) { - _mseHandshake->initCipher - (bittorrent::getInfoHash(_requestGroup->getDownloadContext()));; - if(_mseHandshake->sendInitiatorStep2()) { - _sequence = INITIATOR_FIND_VC_MARKER; + if(mseHandshake_->receivePublicKey()) { + mseHandshake_->initCipher + (bittorrent::getInfoHash(requestGroup_->getDownloadContext()));; + if(mseHandshake_->sendInitiatorStep2()) { + sequence_ = INITIATOR_FIND_VC_MARKER; } else { setWriteCheckSocket(getSocket()); - _sequence = INITIATOR_SEND_STEP2_PENDING; + sequence_ = INITIATOR_SEND_STEP2_PENDING; } } break; } case INITIATOR_SEND_STEP2_PENDING: - if(_mseHandshake->sendInitiatorStep2()) { + if(mseHandshake_->sendInitiatorStep2()) { disableWriteCheckSocket(); - _sequence = INITIATOR_FIND_VC_MARKER; + sequence_ = INITIATOR_FIND_VC_MARKER; } break; case INITIATOR_FIND_VC_MARKER: { - if(_mseHandshake->findInitiatorVCMarker()) { - _sequence = INITIATOR_RECEIVE_PAD_D_LENGTH; + if(mseHandshake_->findInitiatorVCMarker()) { + sequence_ = INITIATOR_RECEIVE_PAD_D_LENGTH; } break; } case INITIATOR_RECEIVE_PAD_D_LENGTH: { - if(_mseHandshake->receiveInitiatorCryptoSelectAndPadDLength()) { - _sequence = INITIATOR_RECEIVE_PAD_D; + if(mseHandshake_->receiveInitiatorCryptoSelectAndPadDLength()) { + sequence_ = INITIATOR_RECEIVE_PAD_D; } break; } case INITIATOR_RECEIVE_PAD_D: { - if(_mseHandshake->receivePad()) { + if(mseHandshake_->receivePad()) { SharedHandle<PeerConnection> peerConnection (new PeerConnection(getCuid(), getSocket())); - if(_mseHandshake->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4){ - peerConnection->enableEncryption(_mseHandshake->getEncryptor(), - _mseHandshake->getDecryptor()); + if(mseHandshake_->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4){ + peerConnection->enableEncryption(mseHandshake_->getEncryptor(), + mseHandshake_->getDecryptor()); } PeerInteractionCommand* c = new PeerInteractionCommand - (getCuid(), _requestGroup, getPeer(), getDownloadEngine(), _btRuntime, - _pieceStorage, - _peerStorage, + (getCuid(), requestGroup_, getPeer(), getDownloadEngine(), btRuntime_, + pieceStorage_, + peerStorage_, getSocket(), PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE, peerConnection); @@ -182,14 +182,14 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait) " handshake is disabled by preference.", util::itos(getCuid()).c_str()); } - if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) { - SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); + if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) { + SharedHandle<Peer> peer = peerStorage_->getUnusedPeer(); peer->usedBy(getDownloadEngine()->newCUID()); PeerInitiateConnectionCommand* command = - new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, - getDownloadEngine(), _btRuntime); - command->setPeerStorage(_peerStorage); - command->setPieceStorage(_pieceStorage); + new PeerInitiateConnectionCommand(peer->usedBy(), requestGroup_, peer, + getDownloadEngine(), btRuntime_); + command->setPeerStorage(peerStorage_); + command->setPieceStorage(pieceStorage_); getDownloadEngine()->addCommand(command); } return true; @@ -200,10 +200,10 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait) util::itos(getCuid()).c_str()); } PeerInitiateConnectionCommand* command = - new PeerInitiateConnectionCommand(getCuid(), _requestGroup, getPeer(), - getDownloadEngine(), _btRuntime, false); - command->setPeerStorage(_peerStorage); - command->setPieceStorage(_pieceStorage); + new PeerInitiateConnectionCommand(getCuid(), requestGroup_, getPeer(), + getDownloadEngine(), btRuntime_, false); + command->setPeerStorage(peerStorage_); + command->setPieceStorage(pieceStorage_); getDownloadEngine()->addCommand(command); return true; } @@ -212,30 +212,30 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait) void InitiatorMSEHandshakeCommand::onAbort() { if(getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) { - _peerStorage->returnPeer(getPeer()); + peerStorage_->returnPeer(getPeer()); } } bool InitiatorMSEHandshakeCommand::exitBeforeExecute() { - return _btRuntime->isHalt(); + return btRuntime_->isHalt(); } void InitiatorMSEHandshakeCommand::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void InitiatorMSEHandshakeCommand::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } const SharedHandle<Option>& InitiatorMSEHandshakeCommand::getOption() const { - return _requestGroup->getOption(); + return requestGroup_->getOption(); } } // namespace aria2 diff --git a/src/InitiatorMSEHandshakeCommand.h b/src/InitiatorMSEHandshakeCommand.h index 0d0d381d..c9f882df 100644 --- a/src/InitiatorMSEHandshakeCommand.h +++ b/src/InitiatorMSEHandshakeCommand.h @@ -58,16 +58,16 @@ public: INITIATOR_RECEIVE_PAD_D, }; private: - RequestGroup* _requestGroup; + RequestGroup* requestGroup_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - Seq _sequence; - MSEHandshake* _mseHandshake; + Seq sequence_; + MSEHandshake* mseHandshake_; const SharedHandle<Option>& getOption() const; protected: diff --git a/src/IteratableChecksumValidator.cc b/src/IteratableChecksumValidator.cc index 1e36107b..a6679f5a 100644 --- a/src/IteratableChecksumValidator.cc +++ b/src/IteratableChecksumValidator.cc @@ -55,36 +55,36 @@ namespace aria2 { IteratableChecksumValidator::IteratableChecksumValidator (const SharedHandle<DownloadContext>& dctx, const PieceStorageHandle& pieceStorage): - _dctx(dctx), - _pieceStorage(pieceStorage), - _currentOffset(0), - _logger(LogFactory::getInstance()), - _buffer(0) {} + dctx_(dctx), + pieceStorage_(pieceStorage), + currentOffset_(0), + logger_(LogFactory::getInstance()), + buffer_(0) {} IteratableChecksumValidator::~IteratableChecksumValidator() { #ifdef HAVE_POSIX_MEMALIGN - free(_buffer); + free(buffer_); #else // !HAVE_POSIX_MEMALIGN - delete [] _buffer; + delete [] buffer_; #endif // !HAVE_POSIX_MEMALIGN } void IteratableChecksumValidator::validateChunk() { if(!finished()) { - size_t length = _pieceStorage->getDiskAdaptor()->readData(_buffer, + size_t length = pieceStorage_->getDiskAdaptor()->readData(buffer_, BUFSIZE, - _currentOffset); - _ctx->digestUpdate(_buffer, length); - _currentOffset += length; + currentOffset_); + ctx_->digestUpdate(buffer_, length); + currentOffset_ += length; if(finished()) { - std::string actualChecksum = util::toHex(_ctx->digestFinal()); - if(_dctx->getChecksum() == actualChecksum) { - _pieceStorage->markAllPiecesDone(); + std::string actualChecksum = util::toHex(ctx_->digestFinal()); + if(dctx_->getChecksum() == actualChecksum) { + pieceStorage_->markAllPiecesDone(); } else { - BitfieldMan bitfield(_dctx->getPieceLength(), _dctx->getTotalLength()); - _pieceStorage->setBitfield(bitfield.getBitfield(), bitfield.getBitfieldLength()); + BitfieldMan bitfield(dctx_->getPieceLength(), dctx_->getTotalLength()); + pieceStorage_->setBitfield(bitfield.getBitfield(), bitfield.getBitfieldLength()); } } } @@ -92,8 +92,8 @@ void IteratableChecksumValidator::validateChunk() bool IteratableChecksumValidator::finished() const { - if((uint64_t)_currentOffset >= _dctx->getTotalLength()) { - _pieceStorage->getDiskAdaptor()->disableDirectIO(); + if((uint64_t)currentOffset_ >= dctx_->getTotalLength()) { + pieceStorage_->getDiskAdaptor()->disableDirectIO(); return true; } else { return false; @@ -102,24 +102,24 @@ bool IteratableChecksumValidator::finished() const uint64_t IteratableChecksumValidator::getTotalLength() const { - return _dctx->getTotalLength(); + return dctx_->getTotalLength(); } void IteratableChecksumValidator::init() { #ifdef HAVE_POSIX_MEMALIGN - free(_buffer); - _buffer = reinterpret_cast<unsigned char*> + free(buffer_); + buffer_ = reinterpret_cast<unsigned char*> (util::allocateAlignedMemory(ALIGNMENT, BUFSIZE)); #else // !HAVE_POSIX_MEMALIGN - delete [] _buffer; - _buffer = new unsigned char[BUFSIZE]; + delete [] buffer_; + buffer_ = new unsigned char[BUFSIZE]; #endif // !HAVE_POSIX_MEMALIGN - _pieceStorage->getDiskAdaptor()->enableDirectIO(); - _currentOffset = 0; - _ctx.reset(new MessageDigestContext()); - _ctx->trySetAlgo(_dctx->getChecksumHashAlgo()); - _ctx->digestInit(); + pieceStorage_->getDiskAdaptor()->enableDirectIO(); + currentOffset_ = 0; + ctx_.reset(new MessageDigestContext()); + ctx_->trySetAlgo(dctx_->getChecksumHashAlgo()); + ctx_->digestInit(); } } // namespace aria2 diff --git a/src/IteratableChecksumValidator.h b/src/IteratableChecksumValidator.h index 63536717..73dc6cc9 100644 --- a/src/IteratableChecksumValidator.h +++ b/src/IteratableChecksumValidator.h @@ -47,17 +47,17 @@ class MessageDigestContext; class IteratableChecksumValidator:public IteratableValidator { private: - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - off_t _currentOffset; + off_t currentOffset_; - SharedHandle<MessageDigestContext> _ctx; + SharedHandle<MessageDigestContext> ctx_; - Logger* _logger; + Logger* logger_; - unsigned char* _buffer; + unsigned char* buffer_; public: IteratableChecksumValidator(const SharedHandle<DownloadContext>& dctx, @@ -73,7 +73,7 @@ public: virtual off_t getCurrentOffset() const { - return _currentOffset; + return currentOffset_; } virtual uint64_t getTotalLength() const; diff --git a/src/IteratableChunkChecksumValidator.cc b/src/IteratableChunkChecksumValidator.cc index 86e40334..595eb91b 100644 --- a/src/IteratableChunkChecksumValidator.cc +++ b/src/IteratableChunkChecksumValidator.cc @@ -60,19 +60,19 @@ namespace aria2 { IteratableChunkChecksumValidator:: IteratableChunkChecksumValidator(const SharedHandle<DownloadContext>& dctx, const PieceStorageHandle& pieceStorage): - _dctx(dctx), - _pieceStorage(pieceStorage), - _bitfield(new BitfieldMan(_dctx->getPieceLength(), _dctx->getTotalLength())), - _currentIndex(0), - _logger(LogFactory::getInstance()), - _buffer(0) {} + dctx_(dctx), + pieceStorage_(pieceStorage), + bitfield_(new BitfieldMan(dctx_->getPieceLength(), dctx_->getTotalLength())), + currentIndex_(0), + logger_(LogFactory::getInstance()), + buffer_(0) {} IteratableChunkChecksumValidator::~IteratableChunkChecksumValidator() { #ifdef HAVE_POSIX_MEMALIGN - free(_buffer); + free(buffer_); #else // !HAVE_POSIX_MEMALIGN - delete [] _buffer; + delete [] buffer_; #endif // !HAVE_POSIX_MEMALIGN } @@ -83,30 +83,30 @@ void IteratableChunkChecksumValidator::validateChunk() std::string actualChecksum; try { actualChecksum = calculateActualChecksum(); - if(actualChecksum == _dctx->getPieceHashes()[_currentIndex]) { - _bitfield->setBit(_currentIndex); + if(actualChecksum == dctx_->getPieceHashes()[currentIndex_]) { + bitfield_->setBit(currentIndex_); } else { - if(_logger->info()) { - _logger->info(EX_INVALID_CHUNK_CHECKSUM, - _currentIndex, + if(logger_->info()) { + logger_->info(EX_INVALID_CHUNK_CHECKSUM, + currentIndex_, util::itos(getCurrentOffset(), true).c_str(), - _dctx->getPieceHashes()[_currentIndex].c_str(), + dctx_->getPieceHashes()[currentIndex_].c_str(), actualChecksum.c_str()); } - _bitfield->unsetBit(_currentIndex); + bitfield_->unsetBit(currentIndex_); } } catch(RecoverableException& ex) { - if(_logger->debug()) { - _logger->debug("Caught exception while validating piece index=%d." + if(logger_->debug()) { + logger_->debug("Caught exception while validating piece index=%d." " Some part of file may be missing. Continue operation.", - ex, _currentIndex); + ex, currentIndex_); } - _bitfield->unsetBit(_currentIndex); + bitfield_->unsetBit(currentIndex_); } - ++_currentIndex; + ++currentIndex_; if(finished()) { - _pieceStorage->setBitfield(_bitfield->getBitfield(), _bitfield->getBitfieldLength()); + pieceStorage_->setBitfield(bitfield_->getBitfield(), bitfield_->getBitfieldLength()); } } } @@ -116,10 +116,10 @@ std::string IteratableChunkChecksumValidator::calculateActualChecksum() off_t offset = getCurrentOffset(); size_t length; // When validating last piece - if(_currentIndex+1 == _dctx->getNumPieces()) { - length = _dctx->getTotalLength()-offset; + if(currentIndex_+1 == dctx_->getNumPieces()) { + length = dctx_->getTotalLength()-offset; } else { - length = _dctx->getPieceLength(); + length = dctx_->getPieceLength(); } return digest(offset, length); } @@ -127,26 +127,26 @@ std::string IteratableChunkChecksumValidator::calculateActualChecksum() void IteratableChunkChecksumValidator::init() { #ifdef HAVE_POSIX_MEMALIGN - free(_buffer); - _buffer = reinterpret_cast<unsigned char*> + free(buffer_); + buffer_ = reinterpret_cast<unsigned char*> (util::allocateAlignedMemory(ALIGNMENT, BUFSIZE)); #else // !HAVE_POSIX_MEMALIGN - delete [] _buffer; - _buffer = new unsigned char[BUFSIZE]; + delete [] buffer_; + buffer_ = new unsigned char[BUFSIZE]; #endif // !HAVE_POSIX_MEMALIGN - if(_dctx->getFileEntries().size() == 1) { - _pieceStorage->getDiskAdaptor()->enableDirectIO(); + if(dctx_->getFileEntries().size() == 1) { + pieceStorage_->getDiskAdaptor()->enableDirectIO(); } - _ctx.reset(new MessageDigestContext()); - _ctx->trySetAlgo(_dctx->getPieceHashAlgo()); - _ctx->digestInit(); - _bitfield->clearAllBit(); - _currentIndex = 0; + ctx_.reset(new MessageDigestContext()); + ctx_->trySetAlgo(dctx_->getPieceHashAlgo()); + ctx_->digestInit(); + bitfield_->clearAllBit(); + currentIndex_ = 0; } std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length) { - _ctx->digestReset(); + ctx_->digestReset(); off_t curoffset = offset/ALIGNMENT*ALIGNMENT; off_t max = offset+length; off_t woffset; @@ -156,11 +156,11 @@ std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length woffset = 0; } while(curoffset < max) { - size_t r = _pieceStorage->getDiskAdaptor()->readData(_buffer, BUFSIZE, + size_t r = pieceStorage_->getDiskAdaptor()->readData(buffer_, BUFSIZE, curoffset); if(r == 0 || r < static_cast<size_t>(woffset)) { throw DL_ABORT_EX - (StringFormat(EX_FILE_READ, _dctx->getBasePath().c_str(), + (StringFormat(EX_FILE_READ, dctx_->getBasePath().c_str(), strerror(errno)).str()); } size_t wlength; @@ -169,18 +169,18 @@ std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length } else { wlength = r-woffset; } - _ctx->digestUpdate(_buffer+woffset, wlength); + ctx_->digestUpdate(buffer_+woffset, wlength); curoffset += r; woffset = 0; } - return util::toHex(_ctx->digestFinal()); + return util::toHex(ctx_->digestFinal()); } bool IteratableChunkChecksumValidator::finished() const { - if(_currentIndex >= _dctx->getNumPieces()) { - _pieceStorage->getDiskAdaptor()->disableDirectIO(); + if(currentIndex_ >= dctx_->getNumPieces()) { + pieceStorage_->getDiskAdaptor()->disableDirectIO(); return true; } else { return false; @@ -189,12 +189,12 @@ bool IteratableChunkChecksumValidator::finished() const off_t IteratableChunkChecksumValidator::getCurrentOffset() const { - return (off_t)_currentIndex*_dctx->getPieceLength(); + return (off_t)currentIndex_*dctx_->getPieceLength(); } uint64_t IteratableChunkChecksumValidator::getTotalLength() const { - return _dctx->getTotalLength(); + return dctx_->getTotalLength(); } } // namespace aria2 diff --git a/src/IteratableChunkChecksumValidator.h b/src/IteratableChunkChecksumValidator.h index 2b829e5d..bc72f474 100644 --- a/src/IteratableChunkChecksumValidator.h +++ b/src/IteratableChunkChecksumValidator.h @@ -48,13 +48,13 @@ class MessageDigestContext; class IteratableChunkChecksumValidator:public IteratableValidator { private: - SharedHandle<DownloadContext> _dctx; - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<BitfieldMan> _bitfield; - size_t _currentIndex; - Logger* _logger; - SharedHandle<MessageDigestContext> _ctx; - unsigned char* _buffer; + SharedHandle<DownloadContext> dctx_; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<BitfieldMan> bitfield_; + size_t currentIndex_; + Logger* logger_; + SharedHandle<MessageDigestContext> ctx_; + unsigned char* buffer_; std::string calculateActualChecksum(); diff --git a/src/KqueueEventPoll.cc b/src/KqueueEventPoll.cc index 1dc56e11..0ddc69f6 100644 --- a/src/KqueueEventPoll.cc +++ b/src/KqueueEventPoll.cc @@ -64,63 +64,63 @@ size_t KqueueEventPoll::KSocketEntry::getEvents int events; #ifdef ENABLE_ASYNC_DNS events = - std::accumulate(_adnsEvents.begin(), - _adnsEvents.end(), - std::accumulate(_commandEvents.begin(), - _commandEvents.end(), 0, accumulateEvent), + std::accumulate(adnsEvents_.begin(), + adnsEvents_.end(), + std::accumulate(commandEvents_.begin(), + commandEvents_.end(), 0, accumulateEvent), accumulateEvent); #else // !ENABLE_ASYNC_DNS events = - std::accumulate(_commandEvents.begin(), _commandEvents.end(), 0, + std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0, accumulateEvent); #endif // !ENABLE_ASYNC_DNS - EV_SET(&eventlist[0], _socket, EVFILT_READ, + EV_SET(&eventlist[0], socket_, EVFILT_READ, EV_ADD|((events&KqueueEventPoll::IEV_READ)?EV_ENABLE:EV_DISABLE), 0, 0, PTR_TO_UDATA(this)); - EV_SET(&eventlist[1], _socket, EVFILT_WRITE, + EV_SET(&eventlist[1], socket_, EVFILT_WRITE, EV_ADD|((events&KqueueEventPoll::IEV_WRITE)?EV_ENABLE:EV_DISABLE), 0, 0, PTR_TO_UDATA(this)); return 2; } KqueueEventPoll::KqueueEventPoll(): - _kqEventsSize(KQUEUE_EVENTS_MAX), - _kqEvents(new struct kevent[_kqEventsSize]), - _logger(LogFactory::getInstance()) + kqEventsSize_(KQUEUE_EVENTS_MAX), + kqEvents_(new struct kevent[kqEventsSize_]), + logger_(LogFactory::getInstance()) { - _kqfd = kqueue(); + kqfd_ = kqueue(); } KqueueEventPoll::~KqueueEventPoll() { - if(_kqfd != -1) { + if(kqfd_ != -1) { int r; - while((r = close(_kqfd)) == -1 && errno == EINTR); + while((r = close(kqfd_)) == -1 && errno == EINTR); if(r == -1) { - _logger->error("Error occurred while closing kqueue file descriptor" + logger_->error("Error occurred while closing kqueue file descriptor" " %d: %s", - _kqfd, strerror(errno)); + kqfd_, strerror(errno)); } } - delete [] _kqEvents; + delete [] kqEvents_; } bool KqueueEventPoll::good() const { - return _kqfd != -1; + return kqfd_ != -1; } void KqueueEventPoll::poll(const struct timeval& tv) { struct timespec timeout = { tv.tv_sec, tv.tv_usec*1000 }; int res; - while((res = kevent(_kqfd, _kqEvents, 0, _kqEvents, _kqEventsSize, &timeout)) + while((res = kevent(kqfd_, kqEvents_, 0, kqEvents_, kqEventsSize_, &timeout)) == -1 && errno == EINTR); if(res > 0) { for(int i = 0; i < res; ++i) { - KSocketEntry* p = reinterpret_cast<KSocketEntry*>(_kqEvents[i].udata); + KSocketEntry* p = reinterpret_cast<KSocketEntry*>(kqEvents_[i].udata); int events = 0; - int filter = _kqEvents[i].filter; + int filter = kqEvents_[i].filter; if(filter == EVFILT_READ) { events = KqueueEventPoll::IEV_READ; } else if(filter == EVFILT_WRITE) { @@ -136,7 +136,7 @@ void KqueueEventPoll::poll(const struct timeval& tv) // their API. So we call ares_process_fd for all ares_channel and // re-register their sockets. for(std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator i = - _nameResolverEntries.begin(), eoi = _nameResolverEntries.end(); + nameResolverEntries_.begin(), eoi = nameResolverEntries_.end(); i != eoi; ++i) { (*i)->processTimeout(); (*i)->removeSocketEvents(this); @@ -165,28 +165,28 @@ bool KqueueEventPoll::addEvents { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); int r = 0; struct timespec zeroTimeout = { 0, 0 }; struct kevent changelist[2]; size_t n; - if(i != _socketEntries.end() && (*i) == socketEntry) { + if(i != socketEntries_.end() && (*i) == socketEntry) { event.addSelf(*i); n = (*i)->getEvents(changelist); } else { - _socketEntries.insert(i, socketEntry); - if(_socketEntries.size() > _kqEventsSize) { - _kqEventsSize *= 2; - delete [] _kqEvents; - _kqEvents = new struct kevent[_kqEventsSize]; + socketEntries_.insert(i, socketEntry); + if(socketEntries_.size() > kqEventsSize_) { + kqEventsSize_ *= 2; + delete [] kqEvents_; + kqEvents_ = new struct kevent[kqEventsSize_]; } event.addSelf(socketEntry); n = socketEntry->getEvents(changelist); } - r = kevent(_kqfd, changelist, n, changelist, 0, &zeroTimeout); + r = kevent(kqfd_, changelist, n, changelist, 0, &zeroTimeout); if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to add socket event %d:%s", + if(logger_->debug()) { + logger_->debug("Failed to add socket event %d:%s", socket, strerror(errno)); } return false; @@ -215,28 +215,28 @@ bool KqueueEventPoll::deleteEvents(sock_t socket, { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); - if(i != _socketEntries.end() && (*i) == socketEntry) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); + if(i != socketEntries_.end() && (*i) == socketEntry) { event.removeSelf(*i); int r = 0; struct timespec zeroTimeout = { 0, 0 }; struct kevent changelist[2]; size_t n = (*i)->getEvents(changelist); - r = kevent(_kqfd, changelist, n, changelist, 0, &zeroTimeout); + r = kevent(kqfd_, changelist, n, changelist, 0, &zeroTimeout); if((*i)->eventEmpty()) { - _socketEntries.erase(i); + socketEntries_.erase(i); } if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to delete socket event:%s", strerror(errno)); + if(logger_->debug()) { + logger_->debug("Failed to delete socket event:%s", strerror(errno)); } return false; } else { return true; } } else { - if(_logger->debug()) { - _logger->debug("Socket %d is not found in SocketEntries.", socket); + if(logger_->debug()) { + logger_->debug("Socket %d is not found in SocketEntries.", socket); } return false; } @@ -264,9 +264,9 @@ bool KqueueEventPoll::addNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { - _nameResolverEntries.push_back(entry); + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { + nameResolverEntries_.push_back(entry); entry->addSocketEvents(this); return true; } else { @@ -280,12 +280,12 @@ bool KqueueEventPoll::deleteNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { return false; } else { (*itr)->removeSocketEvents(this); - _nameResolverEntries.erase(itr); + nameResolverEntries_.erase(itr); return true; } } diff --git a/src/KqueueEventPoll.h b/src/KqueueEventPoll.h index 80d2703b..1d912178 100644 --- a/src/KqueueEventPoll.h +++ b/src/KqueueEventPoll.h @@ -76,20 +76,20 @@ private: friend int accumulateEvent(int events, const KEvent& event); private: - std::deque<SharedHandle<KSocketEntry> > _socketEntries; + std::deque<SharedHandle<KSocketEntry> > socketEntries_; #ifdef ENABLE_ASYNC_DNS - std::deque<SharedHandle<KAsyncNameResolverEntry> > _nameResolverEntries; + std::deque<SharedHandle<KAsyncNameResolverEntry> > nameResolverEntries_; #endif // ENABLE_ASYNC_DNS - int _kqfd; + int kqfd_; - size_t _kqEventsSize; + size_t kqEventsSize_; - struct kevent* _kqEvents; + struct kevent* kqEvents_; static const size_t KQUEUE_EVENTS_MAX = 1024; - Logger* _logger; + Logger* logger_; bool addEvents(sock_t socket, const KEvent& event); diff --git a/src/LibgcryptARC4Context.h b/src/LibgcryptARC4Context.h index 982e17ec..d97b2ced 100644 --- a/src/LibgcryptARC4Context.h +++ b/src/LibgcryptARC4Context.h @@ -46,7 +46,7 @@ namespace aria2 { class LibgcryptARC4Context { private: - gcry_cipher_hd_t _cipherCtx; + gcry_cipher_hd_t cipherCtx_; void handleError(gcry_error_t err) const { @@ -55,39 +55,39 @@ private: gcry_strerror(err)).str()); } public: - LibgcryptARC4Context():_cipherCtx(0) {} + LibgcryptARC4Context():cipherCtx_(0) {} ~LibgcryptARC4Context() { - gcry_cipher_close(_cipherCtx); + gcry_cipher_close(cipherCtx_); } gcry_cipher_hd_t getCipherContext() const { - return _cipherCtx; + return cipherCtx_; } void init(const unsigned char* key, size_t keyLength) { - gcry_cipher_close(_cipherCtx); + gcry_cipher_close(cipherCtx_); int algo = GCRY_CIPHER_ARCFOUR; int mode = GCRY_CIPHER_MODE_STREAM; unsigned int flags = 0; { - gcry_error_t r = gcry_cipher_open(&_cipherCtx, algo, mode, flags); + gcry_error_t r = gcry_cipher_open(&cipherCtx_, algo, mode, flags); if(r) { handleError(r); } } { - gcry_error_t r = gcry_cipher_setkey(_cipherCtx, key, keyLength); + gcry_error_t r = gcry_cipher_setkey(cipherCtx_, key, keyLength); if(r) { handleError(r); } } { - gcry_error_t r = gcry_cipher_setiv(_cipherCtx, 0, 0); + gcry_error_t r = gcry_cipher_setiv(cipherCtx_, 0, 0); if(r) { handleError(r); } diff --git a/src/LibgcryptARC4Decryptor.h b/src/LibgcryptARC4Decryptor.h index 87ffca8d..1e38883b 100644 --- a/src/LibgcryptARC4Decryptor.h +++ b/src/LibgcryptARC4Decryptor.h @@ -47,7 +47,7 @@ namespace aria2 { class ARC4Decryptor { private: - LibgcryptARC4Context _ctx; + LibgcryptARC4Context ctx_; void handleError(gcry_error_t err) const { @@ -62,13 +62,13 @@ public: void init(const unsigned char* key, size_t keyLength) { - _ctx.init(key, keyLength); + ctx_.init(key, keyLength); } void decrypt(unsigned char* out, size_t outLength, const unsigned char* in, size_t inLength) { - gcry_error_t r = gcry_cipher_decrypt(_ctx.getCipherContext(), + gcry_error_t r = gcry_cipher_decrypt(ctx_.getCipherContext(), out, outLength, in, inLength); if(r) { handleError(r); diff --git a/src/LibgcryptARC4Encryptor.h b/src/LibgcryptARC4Encryptor.h index 9337ff88..554a1b10 100644 --- a/src/LibgcryptARC4Encryptor.h +++ b/src/LibgcryptARC4Encryptor.h @@ -47,7 +47,7 @@ namespace aria2 { class ARC4Encryptor { private: - LibgcryptARC4Context _ctx; + LibgcryptARC4Context ctx_; void handleError(gcry_error_t err) const { @@ -62,13 +62,13 @@ public: void init(const unsigned char* key, size_t keyLength) { - _ctx.init(key, keyLength); + ctx_.init(key, keyLength); } void encrypt(unsigned char* out, size_t outLength, const unsigned char* in, size_t inLength) { - gcry_error_t r = gcry_cipher_encrypt(_ctx.getCipherContext(), + gcry_error_t r = gcry_cipher_encrypt(ctx_.getCipherContext(), out, outLength, in, inLength); if(r) { handleError(r); diff --git a/src/LibgcryptDHKeyExchange.h b/src/LibgcryptDHKeyExchange.h index 20e68941..d695cd44 100644 --- a/src/LibgcryptDHKeyExchange.h +++ b/src/LibgcryptDHKeyExchange.h @@ -44,15 +44,15 @@ namespace aria2 { class DHKeyExchange { private: - size_t _keyLength; + size_t keyLength_; - gcry_mpi_t _prime; + gcry_mpi_t prime_; - gcry_mpi_t _generator; + gcry_mpi_t generator_; - gcry_mpi_t _privateKey; + gcry_mpi_t privateKey_; - gcry_mpi_t _publicKey; + gcry_mpi_t publicKey_; void handleError(gcry_error_t err) const { @@ -62,66 +62,66 @@ private: } public: DHKeyExchange(): - _keyLength(0), - _prime(0), - _generator(0), - _privateKey(0), - _publicKey(0) {} + keyLength_(0), + prime_(0), + generator_(0), + privateKey_(0), + publicKey_(0) {} ~DHKeyExchange() { - gcry_mpi_release(_prime); - gcry_mpi_release(_generator); - gcry_mpi_release(_privateKey); - gcry_mpi_release(_publicKey); + gcry_mpi_release(prime_); + gcry_mpi_release(generator_); + gcry_mpi_release(privateKey_); + gcry_mpi_release(publicKey_); } void init(const unsigned char* prime, size_t primeBits, const unsigned char* generator, size_t privateKeyBits) { - gcry_mpi_release(_prime); - gcry_mpi_release(_generator); - gcry_mpi_release(_privateKey); + gcry_mpi_release(prime_); + gcry_mpi_release(generator_); + gcry_mpi_release(privateKey_); { - gcry_error_t r = gcry_mpi_scan(&_prime, GCRYMPI_FMT_HEX, + gcry_error_t r = gcry_mpi_scan(&prime_, GCRYMPI_FMT_HEX, prime, 0, 0); if(r) { handleError(r); } } { - gcry_error_t r = gcry_mpi_scan(&_generator, GCRYMPI_FMT_HEX, + gcry_error_t r = gcry_mpi_scan(&generator_, GCRYMPI_FMT_HEX, generator, 0, 0); if(r) { handleError(r); } } - _privateKey = gcry_mpi_new(0); - gcry_mpi_randomize(_privateKey, privateKeyBits, GCRY_STRONG_RANDOM); - _keyLength = (primeBits+7)/8; + privateKey_ = gcry_mpi_new(0); + gcry_mpi_randomize(privateKey_, privateKeyBits, GCRY_STRONG_RANDOM); + keyLength_ = (primeBits+7)/8; } void generatePublicKey() { - gcry_mpi_release(_publicKey); - _publicKey = gcry_mpi_new(0); - gcry_mpi_powm(_publicKey, _generator, _privateKey, _prime); + gcry_mpi_release(publicKey_); + publicKey_ = gcry_mpi_new(0); + gcry_mpi_powm(publicKey_, generator_, privateKey_, prime_); } size_t getPublicKey(unsigned char* out, size_t outLength) const { - if(outLength < _keyLength) { + if(outLength < keyLength_) { throw DL_ABORT_EX (StringFormat("Insufficient buffer for public key. expect:%u, actual:%u", - _keyLength, outLength).str()); + keyLength_, outLength).str()); } memset(out, 0, outLength); - size_t publicKeyBytes = (gcry_mpi_get_nbits(_publicKey)+7)/8; - size_t offset = _keyLength-publicKeyBytes; + size_t publicKeyBytes = (gcry_mpi_get_nbits(publicKey_)+7)/8; + size_t offset = keyLength_-publicKeyBytes; size_t nwritten; gcry_error_t r = gcry_mpi_print(GCRYMPI_FMT_USG, out+offset, - outLength-offset, &nwritten, _publicKey); + outLength-offset, &nwritten, publicKey_); if(r) { handleError(r); } @@ -137,10 +137,10 @@ public: const unsigned char* peerPublicKeyData, size_t peerPublicKeyLength) const { - if(outLength < _keyLength) { + if(outLength < keyLength_) { throw DL_ABORT_EX (StringFormat("Insufficient buffer for secret. expect:%u, actual:%u", - _keyLength, outLength).str()); + keyLength_, outLength).str()); } gcry_mpi_t peerPublicKey; { @@ -151,12 +151,12 @@ public: } } gcry_mpi_t secret = gcry_mpi_new(0); - gcry_mpi_powm(secret, peerPublicKey, _privateKey, _prime); + gcry_mpi_powm(secret, peerPublicKey, privateKey_, prime_); gcry_mpi_release(peerPublicKey); memset(out, 0, outLength); size_t secretBytes = (gcry_mpi_get_nbits(secret)+7)/8; - size_t offset = _keyLength-secretBytes; + size_t offset = keyLength_-secretBytes; size_t nwritten; { gcry_error_t r = gcry_mpi_print(GCRYMPI_FMT_USG, out+offset, diff --git a/src/LibgnutlsTLSContext.cc b/src/LibgnutlsTLSContext.cc index 4e18d5a3..f4ca2baf 100644 --- a/src/LibgnutlsTLSContext.cc +++ b/src/LibgnutlsTLSContext.cc @@ -45,52 +45,52 @@ namespace aria2 { -TLSContext::TLSContext():_certCred(0), - _peerVerificationEnabled(false), - _logger(LogFactory::getInstance()) +TLSContext::TLSContext():certCred_(0), + peerVerificationEnabled_(false), + logger_(LogFactory::getInstance()) { - int r = gnutls_certificate_allocate_credentials(&_certCred); + int r = gnutls_certificate_allocate_credentials(&certCred_); if(r == GNUTLS_E_SUCCESS) { - _good = true; - gnutls_certificate_set_verify_flags(_certCred, + good_ = true; + gnutls_certificate_set_verify_flags(certCred_, GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT); } else { - _good =false; - _logger->error("gnutls_certificate_allocate_credentials() failed." + good_ =false; + logger_->error("gnutls_certificate_allocate_credentials() failed." " Cause: %s", gnutls_strerror(r)); } } TLSContext::~TLSContext() { - if(_certCred) { - gnutls_certificate_free_credentials(_certCred); + if(certCred_) { + gnutls_certificate_free_credentials(certCred_); } } bool TLSContext::good() const { - return _good; + return good_; } bool TLSContext::bad() const { - return !_good; + return !good_; } bool TLSContext::addClientKeyFile(const std::string& certfile, const std::string& keyfile) { - int ret = gnutls_certificate_set_x509_key_file(_certCred, + int ret = gnutls_certificate_set_x509_key_file(certCred_, certfile.c_str(), keyfile.c_str(), GNUTLS_X509_FMT_PEM); if(ret == GNUTLS_E_SUCCESS) { - _logger->info("Client Key File(cert=%s, key=%s) were successfully added.", + logger_->info("Client Key File(cert=%s, key=%s) were successfully added.", certfile.c_str(), keyfile.c_str()); return true; } else { - _logger->error("Failed to load client certificate from %s and" + logger_->error("Failed to load client certificate from %s and" " private key from %s. Cause: %s", certfile.c_str(), keyfile.c_str(), gnutls_strerror(ret)); @@ -100,37 +100,37 @@ bool TLSContext::addClientKeyFile(const std::string& certfile, bool TLSContext::addTrustedCACertFile(const std::string& certfile) { - int ret = gnutls_certificate_set_x509_trust_file(_certCred, + int ret = gnutls_certificate_set_x509_trust_file(certCred_, certfile.c_str(), GNUTLS_X509_FMT_PEM); if(ret < 0) { - _logger->error(MSG_LOADING_TRUSTED_CA_CERT_FAILED, + logger_->error(MSG_LOADING_TRUSTED_CA_CERT_FAILED, certfile.c_str(), gnutls_strerror(ret)); return false; } else { - _logger->info("%d certificate(s) were imported.", ret); + logger_->info("%d certificate(s) were imported.", ret); return true; } } gnutls_certificate_credentials_t TLSContext::getCertCred() const { - return _certCred; + return certCred_; } void TLSContext::enablePeerVerification() { - _peerVerificationEnabled = true; + peerVerificationEnabled_ = true; } void TLSContext::disablePeerVerification() { - _peerVerificationEnabled = false; + peerVerificationEnabled_ = false; } bool TLSContext::peerVerificationEnabled() const { - return _peerVerificationEnabled; + return peerVerificationEnabled_; } } // namespace aria2 diff --git a/src/LibgnutlsTLSContext.h b/src/LibgnutlsTLSContext.h index 5eb8fa4d..137f3f2f 100644 --- a/src/LibgnutlsTLSContext.h +++ b/src/LibgnutlsTLSContext.h @@ -49,13 +49,13 @@ class Logger; class TLSContext { private: - gnutls_certificate_credentials_t _certCred; + gnutls_certificate_credentials_t certCred_; - bool _good; + bool good_; - bool _peerVerificationEnabled; + bool peerVerificationEnabled_; - Logger* _logger; + Logger* logger_; public: TLSContext(); diff --git a/src/LibsslARC4Context.h b/src/LibsslARC4Context.h index ab36a034..9db0d729 100644 --- a/src/LibsslARC4Context.h +++ b/src/LibsslARC4Context.h @@ -47,7 +47,7 @@ namespace aria2 { class LibsslARC4Context { private: - EVP_CIPHER_CTX* _cipherCtx; + EVP_CIPHER_CTX* cipherCtx_; void handleError() const { @@ -56,39 +56,39 @@ private: ERR_error_string(ERR_get_error(), 0)).str()); } public: - LibsslARC4Context():_cipherCtx(0) {} + LibsslARC4Context():cipherCtx_(0) {} ~LibsslARC4Context() { - if(_cipherCtx) { - EVP_CIPHER_CTX_cleanup(_cipherCtx); + if(cipherCtx_) { + EVP_CIPHER_CTX_cleanup(cipherCtx_); } - delete _cipherCtx; + delete cipherCtx_; } EVP_CIPHER_CTX* getCipherContext() const { - return _cipherCtx; + return cipherCtx_; } // enc == 1: encryption // enc == 0: decryption void init(const unsigned char* key, size_t keyLength, int enc) { - if(_cipherCtx) { - EVP_CIPHER_CTX_cleanup(_cipherCtx); + if(cipherCtx_) { + EVP_CIPHER_CTX_cleanup(cipherCtx_); } - delete _cipherCtx; - _cipherCtx = new EVP_CIPHER_CTX; - EVP_CIPHER_CTX_init(_cipherCtx); + delete cipherCtx_; + cipherCtx_ = new EVP_CIPHER_CTX; + EVP_CIPHER_CTX_init(cipherCtx_); - if(!EVP_CipherInit_ex(_cipherCtx, EVP_rc4(), 0, 0, 0, enc)) { + if(!EVP_CipherInit_ex(cipherCtx_, EVP_rc4(), 0, 0, 0, enc)) { handleError(); } - if(!EVP_CIPHER_CTX_set_key_length(_cipherCtx, keyLength)) { + if(!EVP_CIPHER_CTX_set_key_length(cipherCtx_, keyLength)) { handleError(); } - if(!EVP_CipherInit_ex(_cipherCtx, 0, 0, key, 0, -1)) { + if(!EVP_CipherInit_ex(cipherCtx_, 0, 0, key, 0, -1)) { handleError(); } } diff --git a/src/LibsslARC4Decryptor.h b/src/LibsslARC4Decryptor.h index a4522d4c..95635c0c 100644 --- a/src/LibsslARC4Decryptor.h +++ b/src/LibsslARC4Decryptor.h @@ -48,7 +48,7 @@ namespace aria2 { class ARC4Decryptor { private: - LibsslARC4Context _ctx; + LibsslARC4Context ctx_; void handleError() const { @@ -63,14 +63,14 @@ public: void init(const unsigned char* key, size_t keyLength) { - _ctx.init(key, keyLength, 0); + ctx_.init(key, keyLength, 0); } void decrypt(unsigned char* out, size_t outLength, const unsigned char* in, size_t inLength) { int soutLength = outLength; - if(!EVP_CipherUpdate(_ctx.getCipherContext(), out, &soutLength, in, inLength)) { + if(!EVP_CipherUpdate(ctx_.getCipherContext(), out, &soutLength, in, inLength)) { handleError(); } } diff --git a/src/LibsslARC4Encryptor.h b/src/LibsslARC4Encryptor.h index b79feccc..07c15384 100644 --- a/src/LibsslARC4Encryptor.h +++ b/src/LibsslARC4Encryptor.h @@ -48,7 +48,7 @@ namespace aria2 { class ARC4Encryptor { private: - LibsslARC4Context _ctx; + LibsslARC4Context ctx_; void handleError() const { @@ -63,14 +63,14 @@ public: void init(const unsigned char* key, size_t keyLength) { - _ctx.init(key, keyLength, 1); + ctx_.init(key, keyLength, 1); } void encrypt(unsigned char* out, size_t outLength, const unsigned char* in, size_t inLength) { int soutLength = outLength; - if(!EVP_CipherUpdate(_ctx.getCipherContext(), out, &soutLength, in, inLength)) { + if(!EVP_CipherUpdate(ctx_.getCipherContext(), out, &soutLength, in, inLength)) { handleError(); } } diff --git a/src/LibsslDHKeyExchange.h b/src/LibsslDHKeyExchange.h index 62bea23c..3b006fd8 100644 --- a/src/LibsslDHKeyExchange.h +++ b/src/LibsslDHKeyExchange.h @@ -48,17 +48,17 @@ namespace aria2 { class DHKeyExchange { private: - BN_CTX* _bnCtx; + BN_CTX* bnCtx_; - size_t _keyLength; + size_t keyLength_; - BIGNUM* _prime; + BIGNUM* prime_; - BIGNUM* _generator; + BIGNUM* generator_; - BIGNUM* _privateKey; + BIGNUM* privateKey_; - BIGNUM* _publicKey; + BIGNUM* publicKey_; void handleError(const std::string& funName) const { @@ -67,70 +67,70 @@ private: funName.c_str(), ERR_error_string(ERR_get_error(), 0)).str()); } public: - DHKeyExchange():_bnCtx(0), - _keyLength(0), - _prime(0), - _generator(0), - _privateKey(0), - _publicKey(0) {} + DHKeyExchange():bnCtx_(0), + keyLength_(0), + prime_(0), + generator_(0), + privateKey_(0), + publicKey_(0) {} ~DHKeyExchange() { - BN_CTX_free(_bnCtx); - BN_free(_prime); - BN_free(_generator); - BN_free(_privateKey); - BN_free(_publicKey); + BN_CTX_free(bnCtx_); + BN_free(prime_); + BN_free(generator_); + BN_free(privateKey_); + BN_free(publicKey_); } void init(const unsigned char* prime, size_t primeBits, const unsigned char* generator, size_t privateKeyBits) { - BN_CTX_free(_bnCtx); - _bnCtx = BN_CTX_new(); - if(!_bnCtx) { + BN_CTX_free(bnCtx_); + bnCtx_ = BN_CTX_new(); + if(!bnCtx_) { handleError("BN_CTX_new in init"); } - BN_free(_prime); - _prime = 0; - BN_free(_generator); - _generator = 0; - BN_free(_privateKey); - _privateKey = 0; + BN_free(prime_); + prime_ = 0; + BN_free(generator_); + generator_ = 0; + BN_free(privateKey_); + privateKey_ = 0; - if(BN_hex2bn(&_prime, reinterpret_cast<const char*>(prime)) == 0) { + if(BN_hex2bn(&prime_, reinterpret_cast<const char*>(prime)) == 0) { handleError("BN_hex2bn in init"); } - if(BN_hex2bn(&_generator, reinterpret_cast<const char*>(generator)) == 0) { + if(BN_hex2bn(&generator_, reinterpret_cast<const char*>(generator)) == 0) { handleError("BN_hex2bn in init"); } - _privateKey = BN_new(); - if(BN_rand(_privateKey, privateKeyBits, -1, false) == 0) { + privateKey_ = BN_new(); + if(BN_rand(privateKey_, privateKeyBits, -1, false) == 0) { handleError("BN_new in init"); } - _keyLength = (primeBits+7)/8; + keyLength_ = (primeBits+7)/8; } void generatePublicKey() { - BN_free(_publicKey); - _publicKey = BN_new(); - BN_mod_exp(_publicKey, _generator, _privateKey, _prime, _bnCtx); + BN_free(publicKey_); + publicKey_ = BN_new(); + BN_mod_exp(publicKey_, generator_, privateKey_, prime_, bnCtx_); } size_t getPublicKey(unsigned char* out, size_t outLength) const { - if(outLength < _keyLength) { + if(outLength < keyLength_) { throw DL_ABORT_EX (StringFormat("Insufficient buffer for public key. expect:%u, actual:%u", - _keyLength, outLength).str()); + keyLength_, outLength).str()); } memset(out, 0, outLength); - size_t publicKeyBytes = BN_num_bytes(_publicKey); - size_t offset = _keyLength-publicKeyBytes; - size_t nwritten = BN_bn2bin(_publicKey, out+offset); + size_t publicKeyBytes = BN_num_bytes(publicKey_); + size_t offset = keyLength_-publicKeyBytes; + size_t nwritten = BN_bn2bin(publicKey_, out+offset); if(nwritten != publicKeyBytes) { throw DL_ABORT_EX (StringFormat("BN_bn2bin in DHKeyExchange::getPublicKey, %u bytes written, but %u bytes expected.", nwritten, publicKeyBytes).str()); @@ -149,10 +149,10 @@ public: const unsigned char* peerPublicKeyData, size_t peerPublicKeyLength) const { - if(outLength < _keyLength) { + if(outLength < keyLength_) { throw DL_ABORT_EX (StringFormat("Insufficient buffer for secret. expect:%u, actual:%u", - _keyLength, outLength).str()); + keyLength_, outLength).str()); } @@ -162,12 +162,12 @@ public: } BIGNUM* secret = BN_new(); - BN_mod_exp(secret, peerPublicKey, _privateKey, _prime, _bnCtx); + BN_mod_exp(secret, peerPublicKey, privateKey_, prime_, bnCtx_); BN_free(peerPublicKey); memset(out, 0, outLength); size_t secretBytes = BN_num_bytes(secret); - size_t offset = _keyLength-secretBytes; + size_t offset = keyLength_-secretBytes; size_t nwritten = BN_bn2bin(secret, out+offset); BN_free(secret); if(nwritten != secretBytes) { diff --git a/src/LibsslTLSContext.cc b/src/LibsslTLSContext.cc index 12b62cc7..0bc84e8b 100644 --- a/src/LibsslTLSContext.cc +++ b/src/LibsslTLSContext.cc @@ -43,75 +43,75 @@ namespace aria2 { -TLSContext::TLSContext():_sslCtx(0), - _peerVerificationEnabled(false), - _logger(LogFactory::getInstance()) +TLSContext::TLSContext():sslCtx_(0), + peerVerificationEnabled_(false), + logger_(LogFactory::getInstance()) { - _sslCtx = SSL_CTX_new(SSLv23_client_method()); - if(_sslCtx) { - _good = true; + sslCtx_ = SSL_CTX_new(SSLv23_client_method()); + if(sslCtx_) { + good_ = true; } else { - _good = false; - _logger->error("SSL_CTX_new() failed. Cause: %s", + good_ = false; + logger_->error("SSL_CTX_new() failed. Cause: %s", ERR_error_string(ERR_get_error(), 0)); } - SSL_CTX_set_mode(_sslCtx, SSL_MODE_AUTO_RETRY); + SSL_CTX_set_mode(sslCtx_, SSL_MODE_AUTO_RETRY); } TLSContext::~TLSContext() { - SSL_CTX_free(_sslCtx); + SSL_CTX_free(sslCtx_); } bool TLSContext::good() const { - return _good; + return good_; } bool TLSContext::bad() const { - return !_good; + return !good_; } bool TLSContext::addClientKeyFile(const std::string& certfile, const std::string& keyfile) { - if(SSL_CTX_use_PrivateKey_file(_sslCtx, keyfile.c_str(), + if(SSL_CTX_use_PrivateKey_file(sslCtx_, keyfile.c_str(), SSL_FILETYPE_PEM) != 1) { - _logger->error("Failed to load client private key from %s. Cause: %s", + logger_->error("Failed to load client private key from %s. Cause: %s", keyfile.c_str(), ERR_error_string(ERR_get_error(), 0)); return false; } - if(SSL_CTX_use_certificate_chain_file(_sslCtx, certfile.c_str()) != 1) { - _logger->error("Failed to load client certificate from %s. Cause: %s", + if(SSL_CTX_use_certificate_chain_file(sslCtx_, certfile.c_str()) != 1) { + logger_->error("Failed to load client certificate from %s. Cause: %s", certfile.c_str(), ERR_error_string(ERR_get_error(), 0)); return false; } - _logger->info("Client Key File(cert=%s, key=%s) were successfully added.", + logger_->info("Client Key File(cert=%s, key=%s) were successfully added.", certfile.c_str(), keyfile.c_str()); return true; } bool TLSContext::addTrustedCACertFile(const std::string& certfile) { - if(SSL_CTX_load_verify_locations(_sslCtx, certfile.c_str(), 0) != 1) { - _logger->error(MSG_LOADING_TRUSTED_CA_CERT_FAILED, + if(SSL_CTX_load_verify_locations(sslCtx_, certfile.c_str(), 0) != 1) { + logger_->error(MSG_LOADING_TRUSTED_CA_CERT_FAILED, certfile.c_str(), ERR_error_string(ERR_get_error(), 0)); return false; } else { - _logger->info("Trusted CA certificates were successfully added."); + logger_->info("Trusted CA certificates were successfully added."); return true; } } void TLSContext::enablePeerVerification() { - _peerVerificationEnabled = true; + peerVerificationEnabled_ = true; } void TLSContext::disablePeerVerification() { - _peerVerificationEnabled = false; + peerVerificationEnabled_ = false; } } // namespace aria2 diff --git a/src/LibsslTLSContext.h b/src/LibsslTLSContext.h index 260531f5..53592bf3 100644 --- a/src/LibsslTLSContext.h +++ b/src/LibsslTLSContext.h @@ -49,13 +49,13 @@ class Logger; class TLSContext { private: - SSL_CTX* _sslCtx; + SSL_CTX* sslCtx_; - bool _good; + bool good_; - bool _peerVerificationEnabled; + bool peerVerificationEnabled_; - Logger* _logger; + Logger* logger_; public: TLSContext(); @@ -74,7 +74,7 @@ public: SSL_CTX* getSSLCtx() const { - return _sslCtx; + return sslCtx_; } void enablePeerVerification(); @@ -83,7 +83,7 @@ public: bool peerVerificationEnabled() const { - return _peerVerificationEnabled; + return peerVerificationEnabled_; } }; diff --git a/src/LogFactory.cc b/src/LogFactory.cc index 17f9324a..a7b99889 100644 --- a/src/LogFactory.cc +++ b/src/LogFactory.cc @@ -39,53 +39,53 @@ namespace aria2 { -std::string LogFactory::_filename = DEV_NULL; -Logger* LogFactory::_logger = 0; -bool LogFactory::_consoleOutput = true; -Logger::LEVEL LogFactory::_logLevel = Logger::A2_DEBUG; +std::string LogFactory::filename_ = DEV_NULL; +Logger* LogFactory::logger_ = 0; +bool LogFactory::consoleOutput_ = true; +Logger::LEVEL LogFactory::logLevel_ = Logger::A2_DEBUG; Logger* LogFactory::getInstance() { - if(!_logger) { + if(!logger_) { SimpleLogger* slogger = new SimpleLogger(); - if(_filename != DEV_NULL) { + if(filename_ != DEV_NULL) { // don't open file DEV_NULL for performance sake. // This avoids costly unecessary message formatting and write. - slogger->openFile(_filename); + slogger->openFile(filename_); } - slogger->setLogLevel(_logLevel); - if(_consoleOutput) { + slogger->setLogLevel(logLevel_); + if(consoleOutput_) { slogger->setStdoutLogLevel(Logger::A2_NOTICE, true); slogger->setStdoutLogLevel(Logger::A2_WARN, true); slogger->setStdoutLogLevel(Logger::A2_ERROR, true); } - _logger = slogger; + logger_ = slogger; } - return _logger; + return logger_; } void LogFactory::setLogLevel(Logger::LEVEL level) { - _logLevel = level; + logLevel_ = level; } void LogFactory::setLogLevel(const std::string& level) { if(level == V_DEBUG) { - _logLevel = Logger::A2_DEBUG; + logLevel_ = Logger::A2_DEBUG; } else if(level == V_INFO) { - _logLevel = Logger::A2_INFO; + logLevel_ = Logger::A2_INFO; } else if(level == V_NOTICE) { - _logLevel = Logger::A2_NOTICE; + logLevel_ = Logger::A2_NOTICE; } else if(level == V_WARN) { - _logLevel = Logger::A2_WARN; + logLevel_ = Logger::A2_WARN; } else if(level == V_ERROR) { - _logLevel = Logger::A2_ERROR; + logLevel_ = Logger::A2_ERROR; } } void LogFactory::release() { - delete _logger; - _logger = 0; + delete logger_; + logger_ = 0; } } // namespace aria2 diff --git a/src/LogFactory.h b/src/LogFactory.h index 14b46f6d..fa3e3d28 100644 --- a/src/LogFactory.h +++ b/src/LogFactory.h @@ -45,10 +45,10 @@ namespace aria2 { class LogFactory { private: - static std::string _filename; - static Logger* _logger; - static bool _consoleOutput; - static Logger::LEVEL _logLevel; + static std::string filename_; + static Logger* logger_; + static bool consoleOutput_; + static Logger::LEVEL logLevel_; public: /** * Get logger instance. Returned logger is singleton. @@ -60,7 +60,7 @@ public: * Set a filename to write log. */ static void setLogFile(const std::string& name) { - _filename = name; + filename_ = name; } /** @@ -68,7 +68,7 @@ public: * If f is false, log is not printed in console. */ static void setConsoleOutput(bool f) { - _consoleOutput = f; + consoleOutput_ = f; } diff --git a/src/Logger.cc b/src/Logger.cc index 2cbb4c1c..09eb546f 100644 --- a/src/Logger.cc +++ b/src/Logger.cc @@ -53,7 +53,7 @@ const std::string Logger::ERROR_LABEL("ERROR"); const std::string Logger::INFO_LABEL("INFO"); -Logger::Logger():_logLevel(Logger::A2_DEBUG), _stdoutField(0) {} +Logger::Logger():logLevel_(Logger::A2_DEBUG), stdoutField_(0) {} Logger::~Logger() { @@ -62,8 +62,8 @@ Logger::~Logger() void Logger::openFile(const std::string& filename) { - _file.open(filename.c_str(), std::ios::app|std::ios::binary); - if(!_file) { + file_.open(filename.c_str(), std::ios::app|std::ios::binary); + if(!file_) { throw DL_ABORT_EX (StringFormat(EX_FILE_OPEN, filename.c_str(), strerror(errno)).str()); } @@ -71,20 +71,20 @@ void Logger::openFile(const std::string& filename) void Logger::closeFile() { - if(_file.is_open()) { - _file.close(); + if(file_.is_open()) { + file_.close(); } } #define WRITE_LOG(LEVEL, LEVEL_LABEL, MSG) \ - if(LEVEL >= _logLevel && _file.is_open()) { \ + if(LEVEL >= logLevel_ && file_.is_open()) { \ va_list ap; \ va_start(ap, MSG); \ - writeLog(_file, LEVEL, LEVEL_LABEL, MSG, ap); \ + writeLog(file_, LEVEL, LEVEL_LABEL, MSG, ap); \ va_end(ap); \ - _file << std::flush; \ + file_ << std::flush; \ } \ - if(_stdoutField&LEVEL) { \ + if(stdoutField_&LEVEL) { \ std::cout << "\n"; \ va_list ap; \ va_start(ap, MSG); \ @@ -94,15 +94,15 @@ void Logger::closeFile() } \ #define WRITE_LOG_EX(LEVEL, LEVEL_LABEL, MSG, EX) \ - if(LEVEL >= _logLevel && _file.is_open()) { \ + if(LEVEL >= logLevel_ && file_.is_open()) { \ va_list ap; \ va_start(ap, EX); \ - writeLog(_file, LEVEL, LEVEL_LABEL, MSG, ap); \ + writeLog(file_, LEVEL, LEVEL_LABEL, MSG, ap); \ va_end(ap); \ - writeStackTrace(_file, LEVEL, LEVEL_LABEL, EX); \ - _file << std::flush; \ + writeStackTrace(file_, LEVEL, LEVEL_LABEL, EX); \ + file_ << std::flush; \ } \ - if(_stdoutField&LEVEL) { \ + if(stdoutField_&LEVEL) { \ std::cout << "\n"; \ va_list ap; \ va_start(ap, EX); \ @@ -165,9 +165,9 @@ void Logger::error(const char* msg, const Exception& ex, ...) void Logger::setStdoutLogLevel(Logger::LEVEL level, bool enabled) { if(enabled) { - _stdoutField |= level; + stdoutField_ |= level; } else { - _stdoutField &= ~level; + stdoutField_ &= ~level; } } diff --git a/src/Logger.h b/src/Logger.h index e7cdcb8d..55d75185 100644 --- a/src/Logger.h +++ b/src/Logger.h @@ -66,15 +66,15 @@ public: static const std::string INFO_LABEL; private: - LEVEL _logLevel; + LEVEL logLevel_; - std::ofstream _file; + std::ofstream file_; - int _stdoutField; + int stdoutField_; bool levelEnabled(LEVEL level) { - return (level >= _logLevel && _file.is_open()) || _stdoutField&level; + return (level >= logLevel_ && file_.is_open()) || stdoutField_&level; } protected: virtual void writeLog @@ -115,7 +115,7 @@ public: void setLogLevel(LEVEL level) { - _logLevel = level; + logLevel_ = level; } void setStdoutLogLevel(Logger::LEVEL level, bool enabled); diff --git a/src/LpdDispatchMessageCommand.cc b/src/LpdDispatchMessageCommand.cc index 778baf46..0996f480 100644 --- a/src/LpdDispatchMessageCommand.cc +++ b/src/LpdDispatchMessageCommand.cc @@ -53,40 +53,40 @@ LpdDispatchMessageCommand::LpdDispatchMessageCommand const SharedHandle<LpdMessageDispatcher>& dispatcher, DownloadEngine* e): Command(cuid), - _dispatcher(dispatcher), - _e(e), - _tryCount(0) {} + dispatcher_(dispatcher), + e_(e), + tryCount_(0) {} bool LpdDispatchMessageCommand::execute() { - if(_btRuntime->isHalt()) { + if(btRuntime_->isHalt()) { return true; } - if(_dispatcher->isAnnounceReady()) { + if(dispatcher_->isAnnounceReady()) { try { getLogger()->info("Dispatching LPD message for infohash=%s", - util::toHex(_dispatcher->getInfoHash()).c_str()); - if(_dispatcher->sendMessage()) { + util::toHex(dispatcher_->getInfoHash()).c_str()); + if(dispatcher_->sendMessage()) { getLogger()->info("Sending LPD message is complete."); - _dispatcher->resetAnnounceTimer(); - _tryCount = 0; + dispatcher_->resetAnnounceTimer(); + tryCount_ = 0; } else { - ++_tryCount; - if(_tryCount >= 5) { + ++tryCount_; + if(tryCount_ >= 5) { getLogger()->info("Sending LPD message %u times but all failed."); - _dispatcher->resetAnnounceTimer(); - _tryCount = 0; + dispatcher_->resetAnnounceTimer(); + tryCount_ = 0; } else { getLogger()->info("Could not send LPD message, retry shortly."); } } } catch(RecoverableException& e) { getLogger()->info("Failed to send LPD message.", e); - _dispatcher->resetAnnounceTimer(); - _tryCount = 0; + dispatcher_->resetAnnounceTimer(); + tryCount_ = 0; } } - _e->addCommand(this); + e_->addCommand(this); return false; } diff --git a/src/LpdDispatchMessageCommand.h b/src/LpdDispatchMessageCommand.h index 15b0aab7..8991c7ec 100644 --- a/src/LpdDispatchMessageCommand.h +++ b/src/LpdDispatchMessageCommand.h @@ -46,10 +46,10 @@ class BtRuntime; class LpdDispatchMessageCommand:public Command { private: - SharedHandle<LpdMessageDispatcher> _dispatcher; - DownloadEngine* _e; - unsigned int _tryCount; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<LpdMessageDispatcher> dispatcher_; + DownloadEngine* e_; + unsigned int tryCount_; + SharedHandle<BtRuntime> btRuntime_; public: LpdDispatchMessageCommand (cuid_t cuid, @@ -60,7 +60,7 @@ public: void setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } }; diff --git a/src/LpdMessage.h b/src/LpdMessage.h index 909689ed..701a1501 100644 --- a/src/LpdMessage.h +++ b/src/LpdMessage.h @@ -43,22 +43,22 @@ namespace aria2 { class LpdMessage { private: - SharedHandle<Peer> _peer; - std::string _infoHash; + SharedHandle<Peer> peer_; + std::string infoHash_; public: LpdMessage() {} LpdMessage(const SharedHandle<Peer>& peer, const std::string& infoHash): - _peer(peer), _infoHash(infoHash) {} + peer_(peer), infoHash_(infoHash) {} const SharedHandle<Peer>& getPeer() const { - return _peer; + return peer_; } const std::string& getInfoHash() const { - return _infoHash; + return infoHash_; } }; diff --git a/src/LpdMessageDispatcher.cc b/src/LpdMessageDispatcher.cc index a0d5659e..a1f2778b 100644 --- a/src/LpdMessageDispatcher.cc +++ b/src/LpdMessageDispatcher.cc @@ -46,39 +46,39 @@ LpdMessageDispatcher::LpdMessageDispatcher (const std::string& infoHash, uint16_t port, const std::string& multicastAddress, uint16_t multicastPort, time_t interval): - _infoHash(infoHash), - _port(port), - _multicastAddress(multicastAddress), - _multicastPort(multicastPort), - _timer(0), - _interval(interval), - _request(bittorrent::createLpdRequest(_multicastAddress, _multicastPort, - _infoHash, _port)), - _logger(LogFactory::getInstance()) {} + infoHash_(infoHash), + port_(port), + multicastAddress_(multicastAddress), + multicastPort_(multicastPort), + timer_(0), + interval_(interval), + request_(bittorrent::createLpdRequest(multicastAddress_, multicastPort_, + infoHash_, port_)), + logger_(LogFactory::getInstance()) {} bool LpdMessageDispatcher::init(const std::string& localAddr, unsigned char ttl, unsigned char loop) { try { - _socket.reset(new SocketCore(SOCK_DGRAM)); - _socket->create(AF_INET); - if(_logger->debug()) { - _logger->debug("Setting multicast outgoing interface=%s", + socket_.reset(new SocketCore(SOCK_DGRAM)); + socket_->create(AF_INET); + if(logger_->debug()) { + logger_->debug("Setting multicast outgoing interface=%s", localAddr.c_str()); } - _socket->setMulticastInterface(localAddr); - if(_logger->debug()) { - _logger->debug("Setting multicast ttl=%u",static_cast<unsigned int>(ttl)); + socket_->setMulticastInterface(localAddr); + if(logger_->debug()) { + logger_->debug("Setting multicast ttl=%u",static_cast<unsigned int>(ttl)); } - _socket->setMulticastTtl(ttl); - if(_logger->debug()) { - _logger->debug("Setting multicast loop=%u", + socket_->setMulticastTtl(ttl); + if(logger_->debug()) { + logger_->debug("Setting multicast loop=%u", static_cast<unsigned int>(loop)); } - _socket->setMulticastLoop(loop); + socket_->setMulticastLoop(loop); return true; } catch(RecoverableException& e) { - _logger->error("Failed to initialize LpdMessageDispatcher.", e); + logger_->error("Failed to initialize LpdMessageDispatcher.", e); } return false; } @@ -86,19 +86,19 @@ bool LpdMessageDispatcher::init(const std::string& localAddr, bool LpdMessageDispatcher::sendMessage() { return - _socket->writeData(_request.c_str(), _request.size(), - _multicastAddress, _multicastPort) - == (ssize_t)_request.size(); + socket_->writeData(request_.c_str(), request_.size(), + multicastAddress_, multicastPort_) + == (ssize_t)request_.size(); } bool LpdMessageDispatcher::isAnnounceReady() const { - return _timer.difference(global::wallclock) >= _interval; + return timer_.difference(global::wallclock) >= interval_; } void LpdMessageDispatcher::resetAnnounceTimer() { - _timer = global::wallclock; + timer_ = global::wallclock; } namespace bittorrent { diff --git a/src/LpdMessageDispatcher.h b/src/LpdMessageDispatcher.h index 3b35f99e..e263b717 100644 --- a/src/LpdMessageDispatcher.h +++ b/src/LpdMessageDispatcher.h @@ -47,15 +47,15 @@ class Logger; class LpdMessageDispatcher { private: - SharedHandle<SocketCore> _socket; - std::string _infoHash; - uint16_t _port; - std::string _multicastAddress; - uint16_t _multicastPort; - Timer _timer; - time_t _interval; - std::string _request; - Logger* _logger; + SharedHandle<SocketCore> socket_; + std::string infoHash_; + uint16_t port_; + std::string multicastAddress_; + uint16_t multicastPort_; + Timer timer_; + time_t interval_; + std::string request_; + Logger* logger_; public: LpdMessageDispatcher (const std::string& infoHash, uint16_t port, @@ -65,7 +65,7 @@ public: // No throw bool init(const std::string& localAddr, unsigned char ttl,unsigned char loop); - // Returns true if _timer reached announce interval, which is by + // Returns true if timer_ reached announce interval, which is by // default 5mins. bool isAnnounceReady() const; @@ -73,17 +73,17 @@ public: // returns false. bool sendMessage(); - // Reset _timer to the current time. + // Reset timer_ to the current time. void resetAnnounceTimer(); const std::string& getInfoHash() const { - return _infoHash; + return infoHash_; } uint16_t getPort() const { - return _port; + return port_; } }; diff --git a/src/LpdMessageReceiver.cc b/src/LpdMessageReceiver.cc index 2645e8ef..81256bad 100644 --- a/src/LpdMessageReceiver.cc +++ b/src/LpdMessageReceiver.cc @@ -44,33 +44,33 @@ namespace aria2 { LpdMessageReceiver::LpdMessageReceiver (const std::string& multicastAddress, uint16_t multicastPort): - _multicastAddress(multicastAddress), - _multicastPort(multicastPort), - _logger(LogFactory::getInstance()) {} + multicastAddress_(multicastAddress), + multicastPort_(multicastPort), + logger_(LogFactory::getInstance()) {} bool LpdMessageReceiver::init(const std::string& localAddr) { try { - _socket.reset(new SocketCore(SOCK_DGRAM)); + socket_.reset(new SocketCore(SOCK_DGRAM)); #ifdef __MINGW32__ // Binding multicast address fails under Windows. - _socket->bindWithFamily(_multicastPort, AF_INET); + socket_->bindWithFamily(multicastPort_, AF_INET); #else // !__MINGW32__ - _socket->bind(_multicastAddress, _multicastPort); + socket_->bind(multicastAddress_, multicastPort_); #endif // !__MINGW32__ - if(_logger->debug()) { - _logger->debug("Joining multicast group. %s:%u, localAddr=%s", - _multicastAddress.c_str(), _multicastPort, + if(logger_->debug()) { + logger_->debug("Joining multicast group. %s:%u, localAddr=%s", + multicastAddress_.c_str(), multicastPort_, localAddr.c_str()); } - _socket->joinMulticastGroup(_multicastAddress, _multicastPort, localAddr); - _socket->setNonBlockingMode(); - _localAddress = localAddr; - _logger->info("Listening multicast group (%s:%u) packet", - _multicastAddress.c_str(), _multicastPort); + socket_->joinMulticastGroup(multicastAddress_, multicastPort_, localAddr); + socket_->setNonBlockingMode(); + localAddress_ = localAddr; + logger_->info("Listening multicast group (%s:%u) packet", + multicastAddress_.c_str(), multicastPort_); return true; } catch(RecoverableException& e) { - _logger->error("Failed to initialize LPD message receiver.", e); + logger_->error("Failed to initialize LPD message receiver.", e); } return false; } @@ -81,7 +81,7 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage() try { unsigned char buf[200]; std::pair<std::string, uint16_t> peerAddr; - ssize_t length = _socket->readDataFrom(buf, sizeof(buf), peerAddr); + ssize_t length = socket_->readDataFrom(buf, sizeof(buf), peerAddr); if(length == 0) { return msg; } @@ -94,13 +94,13 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage() SharedHandle<HttpHeader> header = proc.getHttpRequestHeader(); std::string infoHashString = header->getFirst("Infohash"); uint16_t port = header->getFirstAsUInt("Port"); - _logger->info("LPD message received infohash=%s, port=%u from %s", + logger_->info("LPD message received infohash=%s, port=%u from %s", infoHashString.c_str(), port, peerAddr.first.c_str()); std::string infoHash; if(infoHashString.size() != 40 || (infoHash = util::fromHex(infoHashString)).empty() || port == 0) { - _logger->info("LPD bad request. infohash=%s", infoHashString.c_str()); + logger_->info("LPD bad request. infohash=%s", infoHashString.c_str()); msg.reset(new LpdMessage()); return msg; } @@ -111,7 +111,7 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage() msg.reset(new LpdMessage(peer, infoHash)); return msg; } catch(RecoverableException& e) { - _logger->info("Failed to receive LPD message.", e); + logger_->info("Failed to receive LPD message.", e); msg.reset(new LpdMessage()); return msg; } diff --git a/src/LpdMessageReceiver.h b/src/LpdMessageReceiver.h index 879a1797..43296c6f 100644 --- a/src/LpdMessageReceiver.h +++ b/src/LpdMessageReceiver.h @@ -47,11 +47,11 @@ class LpdMessage; class LpdMessageReceiver { private: - SharedHandle<SocketCore> _socket; - std::string _multicastAddress; - uint16_t _multicastPort; - std::string _localAddress; - Logger* _logger; + SharedHandle<SocketCore> socket_; + std::string multicastAddress_; + uint16_t multicastPort_; + std::string localAddress_; + Logger* logger_; public: // Currently only IPv4 multicastAddresses are supported. LpdMessageReceiver @@ -68,12 +68,12 @@ public: const SharedHandle<SocketCore>& getSocket() const { - return _socket; + return socket_; } const std::string& getLocalAddress() const { - return _localAddress; + return localAddress_; } }; diff --git a/src/LpdReceiveMessageCommand.cc b/src/LpdReceiveMessageCommand.cc index 973c8d2d..86e84131 100644 --- a/src/LpdReceiveMessageCommand.cc +++ b/src/LpdReceiveMessageCommand.cc @@ -56,34 +56,34 @@ namespace aria2 { -unsigned int LpdReceiveMessageCommand::__numInstance = 0; +unsigned int LpdReceiveMessageCommand::numInstance_ = 0; -LpdReceiveMessageCommand* LpdReceiveMessageCommand::__instance = 0; +LpdReceiveMessageCommand* LpdReceiveMessageCommand::instance_ = 0; LpdReceiveMessageCommand::LpdReceiveMessageCommand (cuid_t cuid, const SharedHandle<LpdMessageReceiver>& receiver, - DownloadEngine* e):Command(cuid), _receiver(receiver), _e(e) + DownloadEngine* e):Command(cuid), receiver_(receiver), e_(e) { - _e->addSocketForReadCheck(_receiver->getSocket(), this); - ++__numInstance; + e_->addSocketForReadCheck(receiver_->getSocket(), this); + ++numInstance_; } LpdReceiveMessageCommand::~LpdReceiveMessageCommand() { - _e->deleteSocketForReadCheck(_receiver->getSocket(), this); - --__numInstance; - if(__numInstance == 0) { - __instance = 0; + e_->deleteSocketForReadCheck(receiver_->getSocket(), this); + --numInstance_; + if(numInstance_ == 0) { + instance_ = 0; } } bool LpdReceiveMessageCommand::execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } for(size_t i = 0; i < 20; ++i) { - SharedHandle<LpdMessage> m = _receiver->receiveMessage(); + SharedHandle<LpdMessage> m = receiver_->receiveMessage(); if(m.isNull()) { break; } @@ -91,7 +91,7 @@ bool LpdReceiveMessageCommand::execute() // bad message continue; } - SharedHandle<BtRegistry> reg = _e->getBtRegistry(); + SharedHandle<BtRegistry> reg = e_->getBtRegistry(); SharedHandle<DownloadContext> dctx = reg->getDownloadContext(m->getInfoHash()); if(dctx.isNull()) { @@ -112,7 +112,7 @@ bool LpdReceiveMessageCommand::execute() assert(group); BtObject btobj = reg->get(group->getGID()); assert(!btobj.isNull()); - SharedHandle<PeerStorage> peerStorage = btobj._peerStorage; + SharedHandle<PeerStorage> peerStorage = btobj.peerStorage_; assert(!peerStorage.isNull()); SharedHandle<Peer> peer = m->getPeer(); if(peerStorage->addPeer(peer)) { @@ -129,7 +129,7 @@ bool LpdReceiveMessageCommand::execute() } } } - _e->addCommand(this); + e_->addCommand(this); return false; } @@ -137,18 +137,18 @@ LpdReceiveMessageCommand* LpdReceiveMessageCommand::getInstance (DownloadEngine* e, const SharedHandle<LpdMessageReceiver>& receiver) { - if(__numInstance == 0) { - __instance = new LpdReceiveMessageCommand(e->newCUID(), receiver, e); + if(numInstance_ == 0) { + instance_ = new LpdReceiveMessageCommand(e->newCUID(), receiver, e); } - return __instance; + return instance_; } LpdReceiveMessageCommand* LpdReceiveMessageCommand::getInstance() { - if(__numInstance == 0) { + if(numInstance_ == 0) { return 0; } else { - return __instance; + return instance_; } } diff --git a/src/LpdReceiveMessageCommand.h b/src/LpdReceiveMessageCommand.h index 24fdd388..37048b01 100644 --- a/src/LpdReceiveMessageCommand.h +++ b/src/LpdReceiveMessageCommand.h @@ -46,17 +46,17 @@ class SocketCore; class LpdReceiveMessageCommand:public Command { private: - SharedHandle<LpdMessageReceiver> _receiver; + SharedHandle<LpdMessageReceiver> receiver_; - static unsigned int __numInstance; + static unsigned int numInstance_; - static LpdReceiveMessageCommand* __instance; + static LpdReceiveMessageCommand* instance_; LpdReceiveMessageCommand (cuid_t cuid, const SharedHandle<LpdMessageReceiver>& receiver, DownloadEngine* e); - DownloadEngine* _e; + DownloadEngine* e_; public: virtual ~LpdReceiveMessageCommand(); @@ -64,20 +64,20 @@ public: const SharedHandle<LpdMessageReceiver>& getLpdMessageReceiver() const { - return _receiver; + return receiver_; } static LpdReceiveMessageCommand* getInstance (DownloadEngine* e, const SharedHandle<LpdMessageReceiver>& receiver); - // If __numInstance is 0, then return 0. If __numInstance > 0, it - // returns __instance + // If numInstance_ is 0, then return 0. If numInstance_ > 0, it + // returns instance_ static LpdReceiveMessageCommand* getInstance(); static unsigned int getNumInstance() { - return __numInstance; + return numInstance_; } }; diff --git a/src/MSEHandshake.cc b/src/MSEHandshake.cc index 20706cd0..326c0d70 100644 --- a/src/MSEHandshake.cc +++ b/src/MSEHandshake.cc @@ -67,52 +67,52 @@ const unsigned char MSEHandshake::VC[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; MSEHandshake::MSEHandshake(cuid_t cuid, const SocketHandle& socket, const Option* op): - _cuid(cuid), - _socket(socket), - _option(op), - _logger(LogFactory::getInstance()), - _rbufLength(0), - _socketBuffer(socket), - _negotiatedCryptoType(CRYPTO_NONE), - _dh(0), - _initiator(true), - _markerIndex(0), - _padLength(0), - _iaLength(0), - _ia(0) + cuid_(cuid), + socket_(socket), + option_(op), + logger_(LogFactory::getInstance()), + rbufLength_(0), + socketBuffer_(socket), + negotiatedCryptoType_(CRYPTO_NONE), + dh_(0), + initiator_(true), + markerIndex_(0), + padLength_(0), + iaLength_(0), + ia_(0) {} MSEHandshake::~MSEHandshake() { - delete _dh; - delete [] _ia; + delete dh_; + delete [] ia_; } MSEHandshake::HANDSHAKE_TYPE MSEHandshake::identifyHandshakeType() { - if(!_socket->isReadable(0)) { + if(!socket_->isReadable(0)) { return HANDSHAKE_NOT_YET; } - size_t r = 20-_rbufLength; - _socket->readData(_rbuf+_rbufLength, r); - if(r == 0 && !_socket->wantRead() && !_socket->wantWrite()) { + size_t r = 20-rbufLength_; + socket_->readData(rbuf_+rbufLength_, r); + if(r == 0 && !socket_->wantRead() && !socket_->wantWrite()) { throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _rbufLength += r; - if(_rbufLength < 20) { + rbufLength_ += r; + if(rbufLength_ < 20) { return HANDSHAKE_NOT_YET; } - if(_rbuf[0] == BtHandshakeMessage::PSTR_LENGTH && - memcmp(BtHandshakeMessage::BT_PSTR, _rbuf+1, 19) == 0) { - if(_logger->debug()) { - _logger->debug("CUID#%s - This is legacy BitTorrent handshake.", - util::itos(_cuid).c_str()); + if(rbuf_[0] == BtHandshakeMessage::PSTR_LENGTH && + memcmp(BtHandshakeMessage::BT_PSTR, rbuf_+1, 19) == 0) { + if(logger_->debug()) { + logger_->debug("CUID#%s - This is legacy BitTorrent handshake.", + util::itos(cuid_).c_str()); } return HANDSHAKE_LEGACY; } else { - if(_logger->debug()) { - _logger->debug("CUID#%s - This may be encrypted BitTorrent handshake.", - util::itos(_cuid).c_str()); + if(logger_->debug()) { + logger_->debug("CUID#%s - This may be encrypted BitTorrent handshake.", + util::itos(cuid_).c_str()); } return HANDSHAKE_ENCRYPTED; } @@ -120,87 +120,87 @@ MSEHandshake::HANDSHAKE_TYPE MSEHandshake::identifyHandshakeType() void MSEHandshake::initEncryptionFacility(bool initiator) { - delete _dh; - _dh = new DHKeyExchange(); - _dh->init(PRIME, PRIME_BITS, GENERATOR, 160); - _dh->generatePublicKey(); - if(_logger->debug()) { - _logger->debug("CUID#%s - DH initialized.", util::itos(_cuid).c_str()); - } - _initiator = initiator; + delete dh_; + dh_ = new DHKeyExchange(); + dh_->init(PRIME, PRIME_BITS, GENERATOR, 160); + dh_->generatePublicKey(); + if(logger_->debug()) { + logger_->debug("CUID#%s - DH initialized.", util::itos(cuid_).c_str()); + } + initiator_ = initiator; } bool MSEHandshake::sendPublicKey() { - if(_socketBuffer.sendBufferIsEmpty()) { - if(_logger->debug()) { - _logger->debug("CUID#%s - Sending public key.", - util::itos(_cuid).c_str()); + if(socketBuffer_.sendBufferIsEmpty()) { + if(logger_->debug()) { + logger_->debug("CUID#%s - Sending public key.", + util::itos(cuid_).c_str()); } unsigned char buffer[KEY_LENGTH+MAX_PAD_LENGTH]; - _dh->getPublicKey(buffer, KEY_LENGTH); + dh_->getPublicKey(buffer, KEY_LENGTH); size_t padLength = SimpleRandomizer::getInstance()->getRandomNumber(MAX_PAD_LENGTH+1); - _dh->generateNonce(buffer+KEY_LENGTH, padLength); - _socketBuffer.pushStr(std::string(&buffer[0], + dh_->generateNonce(buffer+KEY_LENGTH, padLength); + socketBuffer_.pushStr(std::string(&buffer[0], &buffer[KEY_LENGTH+padLength])); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } bool MSEHandshake::receivePublicKey() { - size_t r = KEY_LENGTH-_rbufLength; + size_t r = KEY_LENGTH-rbufLength_; if(r > receiveNBytes(r)) { return false; } - if(_logger->debug()) { - _logger->debug("CUID#%s - public key received.", util::itos(_cuid).c_str()); + if(logger_->debug()) { + logger_->debug("CUID#%s - public key received.", util::itos(cuid_).c_str()); } // TODO handle exception. in catch, resbufLength = 0; - _dh->computeSecret(_secret, sizeof(_secret), _rbuf, _rbufLength); - // reset _rbufLength - _rbufLength = 0; + dh_->computeSecret(secret_, sizeof(secret_), rbuf_, rbufLength_); + // reset rbufLength_ + rbufLength_ = 0; return true; } void MSEHandshake::initCipher(const unsigned char* infoHash) { - memcpy(_infoHash, infoHash, INFO_HASH_LENGTH); + memcpy(infoHash_, infoHash, INFO_HASH_LENGTH); //Initialize cipher unsigned char s[4+KEY_LENGTH+INFO_HASH_LENGTH]; - memcpy(s, _initiator?"keyA":"keyB", 4); - memcpy(s+4, _secret, KEY_LENGTH); + memcpy(s, initiator_?"keyA":"keyB", 4); + memcpy(s+4, secret_, KEY_LENGTH); memcpy(s+4+KEY_LENGTH, infoHash, INFO_HASH_LENGTH); unsigned char localCipherKey[20]; MessageDigestHelper::digest(localCipherKey, sizeof(localCipherKey), MessageDigestContext::SHA1, s, sizeof(s)); - _encryptor.reset(new ARC4Encryptor()); - _encryptor->init(localCipherKey, sizeof(localCipherKey)); + encryptor_.reset(new ARC4Encryptor()); + encryptor_->init(localCipherKey, sizeof(localCipherKey)); unsigned char peerCipherKey[20]; - memcpy(s, _initiator?"keyB":"keyA", 4); + memcpy(s, initiator_?"keyB":"keyA", 4); MessageDigestHelper::digest(peerCipherKey, sizeof(peerCipherKey), MessageDigestContext::SHA1, s, sizeof(s)); - _decryptor.reset(new ARC4Decryptor()); - _decryptor->init(peerCipherKey, sizeof(peerCipherKey)); + decryptor_.reset(new ARC4Decryptor()); + decryptor_->init(peerCipherKey, sizeof(peerCipherKey)); // discard first 1024 bytes ARC4 output. unsigned char from[1024]; unsigned char to[1024]; - _encryptor->encrypt(to, 1024, from, 1024); - _decryptor->decrypt(to, 1024, from, 1024); + encryptor_->encrypt(to, 1024, from, 1024); + decryptor_->decrypt(to, 1024, from, 1024); - if(_initiator) { + if(initiator_) { ARC4Encryptor enc; enc.init(peerCipherKey, sizeof(peerCipherKey)); // discard first 1024 bytes ARC4 output. enc.encrypt(to, 1024, from, 1024); - enc.encrypt(_initiatorVCMarker, sizeof(_initiatorVCMarker), VC, sizeof(VC)); + enc.encrypt(initiatorVCMarker_, sizeof(initiatorVCMarker_), VC, sizeof(VC)); } } @@ -212,8 +212,8 @@ void MSEHandshake::encryptAndSendData(const unsigned char* data, size_t length) size_t r = length; while(r > 0) { s = std::min(r, sizeof(temp)); - _encryptor->encrypt(temp, s, dptr, s); - _socketBuffer.pushStr(std::string(&temp[0], &temp[s])); + encryptor_->encrypt(temp, s, dptr, s); + socketBuffer_.pushStr(std::string(&temp[0], &temp[s])); dptr += s; r -= s; } @@ -223,7 +223,7 @@ void MSEHandshake::createReq1Hash(unsigned char* md) const { unsigned char buffer[100]; memcpy(buffer, "req1", 4); - memcpy(buffer+4, _secret, KEY_LENGTH); + memcpy(buffer+4, secret_, KEY_LENGTH); MessageDigestHelper::digest(md, 20, MessageDigestContext::SHA1, buffer, 4+KEY_LENGTH); } @@ -239,7 +239,7 @@ void MSEHandshake::createReq23Hash(unsigned char* md, const unsigned char* infoH unsigned char y[4+96]; memcpy(y, "req3", 4); - memcpy(y+4, _secret, KEY_LENGTH); + memcpy(y+4, secret_, KEY_LENGTH); unsigned char yh[20]; MessageDigestHelper::digest(yh, sizeof(yh), MessageDigestContext::SHA1, y, sizeof(y)); @@ -252,7 +252,7 @@ void MSEHandshake::createReq23Hash(unsigned char* md, const unsigned char* infoH uint16_t MSEHandshake::decodeLength16(const unsigned char* buffer) { uint16_t be; - _decryptor->decrypt(reinterpret_cast<unsigned char*>(&be), + decryptor_->decrypt(reinterpret_cast<unsigned char*>(&be), sizeof(be), buffer, sizeof(be)); return ntohs(be); @@ -260,17 +260,17 @@ uint16_t MSEHandshake::decodeLength16(const unsigned char* buffer) bool MSEHandshake::sendInitiatorStep2() { - if(_socketBuffer.sendBufferIsEmpty()) { - if(_logger->debug()) { - _logger->debug("CUID#%s - Sending negotiation step2.", - util::itos(_cuid).c_str()); + if(socketBuffer_.sendBufferIsEmpty()) { + if(logger_->debug()) { + logger_->debug("CUID#%s - Sending negotiation step2.", + util::itos(cuid_).c_str()); } unsigned char md[20]; createReq1Hash(md); - _socketBuffer.pushStr(std::string(&md[0], &md[sizeof(md)])); + socketBuffer_.pushStr(std::string(&md[0], &md[sizeof(md)])); - createReq23Hash(md, _infoHash); - _socketBuffer.pushStr(std::string(&md[0], &md[sizeof(md)])); + createReq23Hash(md, infoHash_); + socketBuffer_.pushStr(std::string(&md[0], &md[sizeof(md)])); { // buffer is filled in this order: @@ -286,7 +286,7 @@ bool MSEHandshake::sendInitiatorStep2() // crypto_provide unsigned char cryptoProvide[CRYPTO_BITFIELD_LENGTH]; memset(cryptoProvide, 0, sizeof(cryptoProvide)); - if(_option->get(PREF_BT_MIN_CRYPTO_LEVEL) == V_PLAIN) { + if(option_->get(PREF_BT_MIN_CRYPTO_LEVEL) == V_PLAIN) { cryptoProvide[3] = CRYPTO_PLAIN_TEXT; } cryptoProvide[3] |= CRYPTO_ARC4; @@ -313,164 +313,164 @@ bool MSEHandshake::sendInitiatorStep2() VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2+padCLength+2); } } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } // This function reads exactly until the end of VC marker is reached. bool MSEHandshake::findInitiatorVCMarker() { // 616 is synchronization point of initiator - size_t r = 616-KEY_LENGTH-_rbufLength; - if(!_socket->isReadable(0)) { + size_t r = 616-KEY_LENGTH-rbufLength_; + if(!socket_->isReadable(0)) { return false; } - _socket->peekData(_rbuf+_rbufLength, r); + socket_->peekData(rbuf_+rbufLength_, r); if(r == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return false; } throw DL_ABORT_EX(EX_EOF_FROM_PEER); } // find vc { - std::string buf(&_rbuf[0], &_rbuf[_rbufLength+r]); - std::string vc(&_initiatorVCMarker[0], &_initiatorVCMarker[VC_LENGTH]); - if((_markerIndex = buf.find(vc)) == std::string::npos) { - if(616-KEY_LENGTH <= _rbufLength+r) { + std::string buf(&rbuf_[0], &rbuf_[rbufLength_+r]); + std::string vc(&initiatorVCMarker_[0], &initiatorVCMarker_[VC_LENGTH]); + if((markerIndex_ = buf.find(vc)) == std::string::npos) { + if(616-KEY_LENGTH <= rbufLength_+r) { throw DL_ABORT_EX("Failed to find VC marker."); } else { - _socket->readData(_rbuf+_rbufLength, r); - _rbufLength += r; + socket_->readData(rbuf_+rbufLength_, r); + rbufLength_ += r; return false; } } } - assert(_markerIndex+VC_LENGTH-_rbufLength <= r); - size_t toRead = _markerIndex+VC_LENGTH-_rbufLength; - _socket->readData(_rbuf+_rbufLength, toRead); - _rbufLength += toRead; - if(_logger->debug()) { - _logger->debug("CUID#%s - VC marker found at %u", - util::itos(_cuid).c_str(), _markerIndex); - } - verifyVC(_rbuf+_markerIndex); - // reset _rbufLength - _rbufLength = 0; + assert(markerIndex_+VC_LENGTH-rbufLength_ <= r); + size_t toRead = markerIndex_+VC_LENGTH-rbufLength_; + socket_->readData(rbuf_+rbufLength_, toRead); + rbufLength_ += toRead; + if(logger_->debug()) { + logger_->debug("CUID#%s - VC marker found at %u", + util::itos(cuid_).c_str(), markerIndex_); + } + verifyVC(rbuf_+markerIndex_); + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::receiveInitiatorCryptoSelectAndPadDLength() { - size_t r = CRYPTO_BITFIELD_LENGTH+2/* PadD length*/-_rbufLength; + size_t r = CRYPTO_BITFIELD_LENGTH+2/* PadD length*/-rbufLength_; if(r > receiveNBytes(r)) { return false; } //verifyCryptoSelect - unsigned char* rbufptr = _rbuf; + unsigned char* rbufptr = rbuf_; { unsigned char cryptoSelect[CRYPTO_BITFIELD_LENGTH]; - _decryptor->decrypt(cryptoSelect, sizeof(cryptoSelect), + decryptor_->decrypt(cryptoSelect, sizeof(cryptoSelect), rbufptr, sizeof(cryptoSelect)); if(cryptoSelect[3]&CRYPTO_PLAIN_TEXT && - _option->get(PREF_BT_MIN_CRYPTO_LEVEL) == V_PLAIN) { - if(_logger->debug()) { - _logger->debug("CUID#%s - peer prefers plaintext.", - util::itos(_cuid).c_str()); + option_->get(PREF_BT_MIN_CRYPTO_LEVEL) == V_PLAIN) { + if(logger_->debug()) { + logger_->debug("CUID#%s - peer prefers plaintext.", + util::itos(cuid_).c_str()); } - _negotiatedCryptoType = CRYPTO_PLAIN_TEXT; + negotiatedCryptoType_ = CRYPTO_PLAIN_TEXT; } if(cryptoSelect[3]&CRYPTO_ARC4) { - if(_logger->debug()) { - _logger->debug("CUID#%s - peer prefers ARC4", - util::itos(_cuid).c_str()); + if(logger_->debug()) { + logger_->debug("CUID#%s - peer prefers ARC4", + util::itos(cuid_).c_str()); } - _negotiatedCryptoType = CRYPTO_ARC4; + negotiatedCryptoType_ = CRYPTO_ARC4; } - if(_negotiatedCryptoType == CRYPTO_NONE) { + if(negotiatedCryptoType_ == CRYPTO_NONE) { throw DL_ABORT_EX (StringFormat("CUID#%s - No supported crypto type selected.", - util::itos(_cuid).c_str()).str()); + util::itos(cuid_).c_str()).str()); } } // padD length rbufptr += CRYPTO_BITFIELD_LENGTH; - _padLength = verifyPadLength(rbufptr, "PadD"); - // reset _rbufLength - _rbufLength = 0; + padLength_ = verifyPadLength(rbufptr, "PadD"); + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::receivePad() { - if(_padLength == 0) { + if(padLength_ == 0) { return true; } - size_t r = _padLength-_rbufLength; + size_t r = padLength_-rbufLength_; if(r > receiveNBytes(r)) { return false; } unsigned char temp[MAX_PAD_LENGTH]; - _decryptor->decrypt(temp, _padLength, _rbuf, _padLength); - // reset _rbufLength - _rbufLength = 0; + decryptor_->decrypt(temp, padLength_, rbuf_, padLength_); + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::findReceiverHashMarker() { // 628 is synchronization limit of receiver. - size_t r = 628-KEY_LENGTH-_rbufLength; - if(!_socket->isReadable(0)) { + size_t r = 628-KEY_LENGTH-rbufLength_; + if(!socket_->isReadable(0)) { return false; } - _socket->peekData(_rbuf+_rbufLength, r); + socket_->peekData(rbuf_+rbufLength_, r); if(r == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return false; } throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - // find hash('req1', S), S is _secret. + // find hash('req1', S), S is secret_. { - std::string buf(&_rbuf[0], &_rbuf[_rbufLength+r]); + std::string buf(&rbuf_[0], &rbuf_[rbufLength_+r]); unsigned char md[20]; createReq1Hash(md); std::string req1(&md[0], &md[sizeof(md)]); - if((_markerIndex = buf.find(req1)) == std::string::npos) { - if(628-KEY_LENGTH <= _rbufLength+r) { + if((markerIndex_ = buf.find(req1)) == std::string::npos) { + if(628-KEY_LENGTH <= rbufLength_+r) { throw DL_ABORT_EX("Failed to find hash marker."); } else { - _socket->readData(_rbuf+_rbufLength, r); - _rbufLength += r; + socket_->readData(rbuf_+rbufLength_, r); + rbufLength_ += r; return false; } } } - assert(_markerIndex+20-_rbufLength <= r); - size_t toRead = _markerIndex+20-_rbufLength; - _socket->readData(_rbuf+_rbufLength, toRead); - _rbufLength += toRead; - if(_logger->debug()) { - _logger->debug("CUID#%s - Hash marker found at %u.", - util::itos(_cuid).c_str(), _markerIndex); - } - verifyReq1Hash(_rbuf+_markerIndex); - // reset _rbufLength - _rbufLength = 0; + assert(markerIndex_+20-rbufLength_ <= r); + size_t toRead = markerIndex_+20-rbufLength_; + socket_->readData(rbuf_+rbufLength_, toRead); + rbufLength_ += toRead; + if(logger_->debug()) { + logger_->debug("CUID#%s - Hash marker found at %u.", + util::itos(cuid_).c_str(), markerIndex_); + } + verifyReq1Hash(rbuf_+markerIndex_); + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::receiveReceiverHashAndPadCLength (const std::vector<SharedHandle<DownloadContext> >& downloadContexts) { - size_t r = 20+VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2/*PadC length*/-_rbufLength; + size_t r = 20+VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2/*PadC length*/-rbufLength_; if(r > receiveNBytes(r)) { return false; } // resolve info hash // pointing to the position of HASH('req2', SKEY) xor HASH('req3', S) - unsigned char* rbufptr = _rbuf; + unsigned char* rbufptr = rbuf_; SharedHandle<DownloadContext> downloadContext; for(std::vector<SharedHandle<DownloadContext> >::const_iterator i = downloadContexts.begin(), eoi = downloadContexts.end(); @@ -479,9 +479,9 @@ bool MSEHandshake::receiveReceiverHashAndPadCLength const unsigned char* infohash = bittorrent::getInfoHash(*i); createReq23Hash(md, infohash); if(memcmp(md, rbufptr, sizeof(md)) == 0) { - if(_logger->debug()) { - _logger->debug("CUID#%s - info hash found: %s", - util::itos(_cuid).c_str(), + if(logger_->debug()) { + logger_->debug("CUID#%s - info hash found: %s", + util::itos(cuid_).c_str(), util::toHex(infohash, INFO_HASH_LENGTH).c_str()); } downloadContext = *i; @@ -499,78 +499,78 @@ bool MSEHandshake::receiveReceiverHashAndPadCLength rbufptr += VC_LENGTH; { unsigned char cryptoProvide[CRYPTO_BITFIELD_LENGTH]; - _decryptor->decrypt(cryptoProvide, sizeof(cryptoProvide), + decryptor_->decrypt(cryptoProvide, sizeof(cryptoProvide), rbufptr, sizeof(cryptoProvide)); // TODO choose the crypto type based on the preference. // For now, choose ARC4. if(cryptoProvide[3]&CRYPTO_PLAIN_TEXT && - _option->get(PREF_BT_MIN_CRYPTO_LEVEL) == V_PLAIN) { - if(_logger->debug()) { - _logger->debug("CUID#%s - peer provides plaintext.", - util::itos(_cuid).c_str()); + option_->get(PREF_BT_MIN_CRYPTO_LEVEL) == V_PLAIN) { + if(logger_->debug()) { + logger_->debug("CUID#%s - peer provides plaintext.", + util::itos(cuid_).c_str()); } - _negotiatedCryptoType = CRYPTO_PLAIN_TEXT; + negotiatedCryptoType_ = CRYPTO_PLAIN_TEXT; } else if(cryptoProvide[3]&CRYPTO_ARC4) { - if(_logger->debug()) { - _logger->debug("CUID#%s - peer provides ARC4.", - util::itos(_cuid).c_str()); + if(logger_->debug()) { + logger_->debug("CUID#%s - peer provides ARC4.", + util::itos(cuid_).c_str()); } - _negotiatedCryptoType = CRYPTO_ARC4; + negotiatedCryptoType_ = CRYPTO_ARC4; } - if(_negotiatedCryptoType == CRYPTO_NONE) { + if(negotiatedCryptoType_ == CRYPTO_NONE) { throw DL_ABORT_EX (StringFormat("CUID#%s - No supported crypto type provided.", - util::itos(_cuid).c_str()).str()); + util::itos(cuid_).c_str()).str()); } } // decrypt PadC length rbufptr += CRYPTO_BITFIELD_LENGTH; - _padLength = verifyPadLength(rbufptr, "PadC"); - // reset _rbufLength - _rbufLength = 0; + padLength_ = verifyPadLength(rbufptr, "PadC"); + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::receiveReceiverIALength() { - size_t r = 2-_rbufLength; + size_t r = 2-rbufLength_; assert(r > 0); if(r > receiveNBytes(r)) { return false; } - _iaLength = decodeLength16(_rbuf); - if(_logger->debug()) { - _logger->debug("CUID#%s - len(IA)=%u.", - util::itos(_cuid).c_str(), _iaLength); + iaLength_ = decodeLength16(rbuf_); + if(logger_->debug()) { + logger_->debug("CUID#%s - len(IA)=%u.", + util::itos(cuid_).c_str(), iaLength_); } - // reset _rbufLength - _rbufLength = 0; + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::receiveReceiverIA() { - if(_iaLength == 0) { + if(iaLength_ == 0) { return true; } - size_t r = _iaLength-_rbufLength; + size_t r = iaLength_-rbufLength_; if(r > receiveNBytes(r)) { return false; } - delete [] _ia; - _ia = new unsigned char[_iaLength]; - _decryptor->decrypt(_ia, _iaLength, _rbuf, _iaLength); - if(_logger->debug()) { - _logger->debug("CUID#%s - IA received.", util::itos(_cuid).c_str()); + delete [] ia_; + ia_ = new unsigned char[iaLength_]; + decryptor_->decrypt(ia_, iaLength_, rbuf_, iaLength_); + if(logger_->debug()) { + logger_->debug("CUID#%s - IA received.", util::itos(cuid_).c_str()); } - // reset _rbufLength - _rbufLength = 0; + // reset rbufLength_ + rbufLength_ = 0; return true; } bool MSEHandshake::sendReceiverStep2() { - if(_socketBuffer.sendBufferIsEmpty()) { + if(socketBuffer_.sendBufferIsEmpty()) { // buffer is filled in this order: // VC(VC_LENGTH bytes), // cryptoSelect(CRYPTO_BITFIELD_LENGTH bytes), @@ -582,7 +582,7 @@ bool MSEHandshake::sendReceiverStep2() // crypto_select unsigned char cryptoSelect[CRYPTO_BITFIELD_LENGTH]; memset(cryptoSelect, 0, sizeof(cryptoSelect)); - cryptoSelect[3] = _negotiatedCryptoType; + cryptoSelect[3] = negotiatedCryptoType_; memcpy(buffer+VC_LENGTH, cryptoSelect, sizeof(cryptoSelect)); // len(padD) uint16_t padDLength = SimpleRandomizer::getInstance()->getRandomNumber(MAX_PAD_LENGTH+1); @@ -595,20 +595,20 @@ bool MSEHandshake::sendReceiverStep2() memset(buffer+VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2, 0, padDLength); encryptAndSendData(buffer, VC_LENGTH+CRYPTO_BITFIELD_LENGTH+2+padDLength); } - _socketBuffer.send(); - return _socketBuffer.sendBufferIsEmpty(); + socketBuffer_.send(); + return socketBuffer_.sendBufferIsEmpty(); } uint16_t MSEHandshake::verifyPadLength(const unsigned char* padlenbuf, const char* padName) { - if(_logger->debug()) { - _logger->debug("CUID#%s - Verifying Pad length for %s", - util::itos(_cuid).c_str(), padName); + if(logger_->debug()) { + logger_->debug("CUID#%s - Verifying Pad length for %s", + util::itos(cuid_).c_str(), padName); } uint16_t padLength = decodeLength16(padlenbuf); - if(_logger->debug()) { - _logger->debug("CUID#%s - len(%s)=%u", - util::itos(_cuid).c_str(), padName, padLength); + if(logger_->debug()) { + logger_->debug("CUID#%s - len(%s)=%u", + util::itos(cuid_).c_str(), padName, padLength); } if(padLength > 512) { throw DL_ABORT_EX @@ -619,11 +619,11 @@ uint16_t MSEHandshake::verifyPadLength(const unsigned char* padlenbuf, const cha void MSEHandshake::verifyVC(const unsigned char* vcbuf) { - if(_logger->debug()) { - _logger->debug("CUID#%s - Verifying VC.", util::itos(_cuid).c_str()); + if(logger_->debug()) { + logger_->debug("CUID#%s - Verifying VC.", util::itos(cuid_).c_str()); } unsigned char vc[VC_LENGTH]; - _decryptor->decrypt(vc, sizeof(vc), vcbuf, sizeof(vc)); + decryptor_->decrypt(vc, sizeof(vc), vcbuf, sizeof(vc)); if(memcmp(VC, vc, sizeof(VC)) != 0) { throw DL_ABORT_EX (StringFormat("Invalid VC: %s", util::toHex(vc, VC_LENGTH).c_str()).str()); @@ -632,8 +632,8 @@ void MSEHandshake::verifyVC(const unsigned char* vcbuf) void MSEHandshake::verifyReq1Hash(const unsigned char* req1buf) { - if(_logger->debug()) { - _logger->debug("CUID#%s - Verifying req hash.", util::itos(_cuid).c_str()); + if(logger_->debug()) { + logger_->debug("CUID#%s - Verifying req hash.", util::itos(cuid_).c_str()); } unsigned char md[20]; createReq1Hash(md); @@ -646,14 +646,14 @@ size_t MSEHandshake::receiveNBytes(size_t bytes) { size_t r = bytes; if(r > 0) { - if(!_socket->isReadable(0)) { + if(!socket_->isReadable(0)) { return 0; } - _socket->readData(_rbuf+_rbufLength, r); - if(r == 0 && !_socket->wantRead() && !_socket->wantWrite()) { + socket_->readData(rbuf_+rbufLength_, r); + if(r == 0 && !socket_->wantRead() && !socket_->wantWrite()) { throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _rbufLength += r; + rbufLength_ += r; } return r; } diff --git a/src/MSEHandshake.h b/src/MSEHandshake.h index 17d2e4a5..ebb06baa 100644 --- a/src/MSEHandshake.h +++ b/src/MSEHandshake.h @@ -81,28 +81,28 @@ private: static const size_t MAX_BUFFER_LENGTH = 6*1024; - cuid_t _cuid; - SharedHandle<SocketCore> _socket; - const Option* _option; - Logger* _logger; - - unsigned char _rbuf[MAX_BUFFER_LENGTH]; - size_t _rbufLength; - - SocketBuffer _socketBuffer; - - CRYPTO_TYPE _negotiatedCryptoType; - DHKeyExchange* _dh; - SharedHandle<ARC4Encryptor> _encryptor; - SharedHandle<ARC4Decryptor> _decryptor; - unsigned char _infoHash[INFO_HASH_LENGTH]; - unsigned char _secret[KEY_LENGTH]; - bool _initiator; - unsigned char _initiatorVCMarker[VC_LENGTH]; - size_t _markerIndex; - uint16_t _padLength; - uint16_t _iaLength; - unsigned char* _ia; + cuid_t cuid_; + SharedHandle<SocketCore> socket_; + const Option* option_; + Logger* logger_; + + unsigned char rbuf_[MAX_BUFFER_LENGTH]; + size_t rbufLength_; + + SocketBuffer socketBuffer_; + + CRYPTO_TYPE negotiatedCryptoType_; + DHKeyExchange* dh_; + SharedHandle<ARC4Encryptor> encryptor_; + SharedHandle<ARC4Decryptor> decryptor_; + unsigned char infoHash_[INFO_HASH_LENGTH]; + unsigned char secret_[KEY_LENGTH]; + bool initiator_; + unsigned char initiatorVCMarker_[VC_LENGTH]; + size_t markerIndex_; + uint16_t padLength_; + uint16_t iaLength_; + unsigned char* ia_; static const unsigned char* PRIME; @@ -170,42 +170,42 @@ public: // returns plain text IA const unsigned char* getIA() const { - return _ia; + return ia_; } size_t getIALength() const { - return _iaLength; + return iaLength_; } const unsigned char* getInfoHash() const { - return _infoHash; + return infoHash_; } CRYPTO_TYPE getNegotiatedCryptoType() const { - return _negotiatedCryptoType; + return negotiatedCryptoType_; } const SharedHandle<ARC4Encryptor>& getEncryptor() const { - return _encryptor; + return encryptor_; } const SharedHandle<ARC4Decryptor>& getDecryptor() const { - return _decryptor; + return decryptor_; } const unsigned char* getBuffer() const { - return _rbuf; + return rbuf_; } size_t getBufferLength() const { - return _rbufLength; + return rbufLength_; } }; diff --git a/src/MessageDigestHelper.cc b/src/MessageDigestHelper.cc index b27bee29..92f97b9b 100644 --- a/src/MessageDigestHelper.cc +++ b/src/MessageDigestHelper.cc @@ -45,27 +45,27 @@ namespace aria2 { -MessageDigestContext* MessageDigestHelper::_sha1Ctx = 0; +MessageDigestContext* MessageDigestHelper::sha1Ctx_ = 0; void MessageDigestHelper::staticSHA1DigestInit() { staticSHA1DigestFree(); - _sha1Ctx = new MessageDigestContext(); - _sha1Ctx->trySetAlgo(MessageDigestContext::SHA1); - _sha1Ctx->digestInit(); + sha1Ctx_ = new MessageDigestContext(); + sha1Ctx_->trySetAlgo(MessageDigestContext::SHA1); + sha1Ctx_->digestInit(); } void MessageDigestHelper::staticSHA1DigestFree() { - delete _sha1Ctx; + delete sha1Ctx_; } std::string MessageDigestHelper::staticSHA1Digest(const BinaryStreamHandle& bs, off_t offset, uint64_t length) { - _sha1Ctx->digestReset(); - return digest(_sha1Ctx, bs, offset, length); + sha1Ctx_->digestReset(); + return digest(sha1Ctx_, bs, offset, length); } std::string MessageDigestHelper::digest(const std::string& algo, diff --git a/src/MessageDigestHelper.h b/src/MessageDigestHelper.h index 612868e0..a1657bf8 100644 --- a/src/MessageDigestHelper.h +++ b/src/MessageDigestHelper.h @@ -46,7 +46,7 @@ class BinaryStream; class MessageDigestHelper { private: - static MessageDigestContext* _sha1Ctx; + static MessageDigestContext* sha1Ctx_; public: /** * Returns message digest in hexadecimal representation. @@ -63,15 +63,15 @@ public: /** * staticSHA1DigestInit(), staticSHA1DigestFree(), staticSHA1Digest() - * use statically declared MessageDigestContext _sha1Ctx. + * use statically declared MessageDigestContext sha1Ctx_. */ /** - * Initializes _sha1Ctx + * Initializes sha1Ctx_ */ static void staticSHA1DigestInit(); /** - * Frees allocated resources for _sha1Ctx + * Frees allocated resources for sha1Ctx_ */ static void staticSHA1DigestFree(); diff --git a/src/MetadataInfo.cc b/src/MetadataInfo.cc index dc3bc3c3..1f0625a4 100644 --- a/src/MetadataInfo.cc +++ b/src/MetadataInfo.cc @@ -36,14 +36,14 @@ namespace aria2 { -int64_t MetadataInfo::_count = 0; +int64_t MetadataInfo::count_ = 0; int64_t MetadataInfo::genId() { - if(_count == INT64_MAX) { - _count = 0; + if(count_ == INT64_MAX) { + count_ = 0; } - return ++_count; + return ++count_; } } // namespace aria2 diff --git a/src/MetadataInfo.h b/src/MetadataInfo.h index 4e8293c6..25099205 100644 --- a/src/MetadataInfo.h +++ b/src/MetadataInfo.h @@ -43,29 +43,29 @@ namespace aria2 { class MetadataInfo { private: - int64_t _id; - std::string _uri; - bool _dataOnly; - static int64_t _count; + int64_t id_; + std::string uri_; + bool dataOnly_; + static int64_t count_; public: - MetadataInfo(const std::string& uri):_id(genId()), _uri(uri), _dataOnly(false) + MetadataInfo(const std::string& uri):id_(genId()), uri_(uri), dataOnly_(false) {} - MetadataInfo():_id(genId()), _dataOnly(true) {} + MetadataInfo():id_(genId()), dataOnly_(true) {} bool dataOnly() const { - return _dataOnly; + return dataOnly_; } const std::string& getUri() const { - return _uri; + return uri_; } int64_t getId() const { - return _id; + return id_; } static int64_t genId(); diff --git a/src/Metalink2RequestGroup.cc b/src/Metalink2RequestGroup.cc index 5f1b9b54..46caac4b 100644 --- a/src/Metalink2RequestGroup.cc +++ b/src/Metalink2RequestGroup.cc @@ -67,7 +67,7 @@ namespace aria2 { Metalink2RequestGroup::Metalink2RequestGroup(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} class AccumulateNonP2PUri { private: @@ -144,7 +144,7 @@ Metalink2RequestGroup::createRequestGroup const SharedHandle<Option>& option) { if(entries.empty()) { - _logger->notice(EX_NO_RESULT_WITH_YOUR_PREFS); + logger_->notice(EX_NO_RESULT_WITH_YOUR_PREFS); return; } std::vector<int32_t> selectIndexes = @@ -193,7 +193,7 @@ Metalink2RequestGroup::createRequestGroup entryGroups.begin(), eoi = entryGroups.end(); itr != eoi; ++itr) { const std::string& metaurl = (*itr).first; const std::vector<SharedHandle<MetalinkEntry> >& mes = (*itr).second; - _logger->info("Processing metaurl group metaurl=%s", metaurl.c_str()); + logger_->info("Processing metaurl group metaurl=%s", metaurl.c_str()); #ifdef ENABLE_BITTORRENT SharedHandle<RequestGroup> torrentRg; if(!metaurl.empty()) { @@ -229,7 +229,7 @@ Metalink2RequestGroup::createRequestGroup SharedHandle<DownloadContext> dctx; if(mes.size() == 1) { SharedHandle<MetalinkEntry> entry = mes[0]; - _logger->info(MSG_METALINK_QUEUEING, entry->getPath().c_str()); + logger_->info(MSG_METALINK_QUEUEING, entry->getPath().c_str()); entry->reorderResourcesByPriority(); std::vector<std::string> uris; std::for_each(entry->resources.begin(), entry->resources.end(), @@ -280,9 +280,9 @@ Metalink2RequestGroup::createRequestGroup off_t offset = 0; for(std::vector<SharedHandle<MetalinkEntry> >::const_iterator i = mes.begin(), eoi = mes.end(); i != eoi; ++i) { - _logger->info("Metalink: Queueing %s for download as a member.", + logger_->info("Metalink: Queueing %s for download as a member.", (*i)->getPath().c_str()); - _logger->debug("originalName = %s", (*i)->metaurls[0]->name.c_str()); + logger_->debug("originalName = %s", (*i)->metaurls[0]->name.c_str()); (*i)->reorderResourcesByPriority(); std::vector<std::string> uris; std::for_each((*i)->resources.begin(), (*i)->resources.end(), diff --git a/src/Metalink2RequestGroup.h b/src/Metalink2RequestGroup.h index 066f842c..858ad182 100644 --- a/src/Metalink2RequestGroup.h +++ b/src/Metalink2RequestGroup.h @@ -50,7 +50,7 @@ class MetalinkEntry; class Metalink2RequestGroup { private: - Logger* _logger; + Logger* logger_; void createRequestGroup(std::vector<SharedHandle<RequestGroup> >& groups, diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc index 3515e5e6..cecb5266 100644 --- a/src/MetalinkEntry.cc +++ b/src/MetalinkEntry.cc @@ -59,20 +59,20 @@ MetalinkEntry::~MetalinkEntry() {} class AddLocationPriority { private: - std::vector<std::string> _locations; - int _priorityToAdd; + std::vector<std::string> locations_; + int priorityToAdd_; public: AddLocationPriority (const std::vector<std::string>& locations, int priorityToAdd): - _locations(locations), _priorityToAdd(priorityToAdd) + locations_(locations), priorityToAdd_(priorityToAdd) { - std::sort(_locations.begin(), _locations.end()); + std::sort(locations_.begin(), locations_.end()); } void operator()(SharedHandle<MetalinkResource>& res) { if(std::binary_search - (_locations.begin(), _locations.end(), res->location)) { - res->priority += _priorityToAdd; + (locations_.begin(), locations_.end(), res->location)) { + res->priority += priorityToAdd_; } } }; @@ -89,7 +89,7 @@ MetalinkEntry& MetalinkEntry::operator=(const MetalinkEntry& metalinkEntry) this->checksum = metalinkEntry.checksum; this->chunkChecksum = metalinkEntry.chunkChecksum; #endif // ENABLE_MESSAGE_DIGEST - this->_signature = metalinkEntry._signature; + this->signature_ = metalinkEntry.signature_; } return *this; } @@ -113,16 +113,16 @@ void MetalinkEntry::setLocationPriority class AddProtocolPriority { private: - std::string _protocol; - int _priorityToAdd; + std::string protocol_; + int priorityToAdd_; public: AddProtocolPriority(const std::string& protocol, int prefToAdd): - _protocol(protocol), _priorityToAdd(prefToAdd) {} + protocol_(protocol), priorityToAdd_(prefToAdd) {} void operator()(const SharedHandle<MetalinkResource>& res) const { - if(_protocol == MetalinkResource::getTypeString(res->type)) { - res->priority += _priorityToAdd; + if(protocol_ == MetalinkResource::getTypeString(res->type)) { + res->priority += priorityToAdd_; } } }; @@ -193,7 +193,7 @@ void MetalinkEntry::toFileEntry void MetalinkEntry::setSignature(const SharedHandle<Signature>& signature) { - _signature = signature; + signature_ = signature; } } // namespace aria2 diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h index 5382e15d..a3acc4b1 100644 --- a/src/MetalinkEntry.h +++ b/src/MetalinkEntry.h @@ -70,7 +70,7 @@ public: SharedHandle<ChunkChecksum> chunkChecksum; #endif // ENABLE_MESSAGE_DIGEST private: - SharedHandle<Signature> _signature; + SharedHandle<Signature> signature_; public: MetalinkEntry(); @@ -117,7 +117,7 @@ public: const SharedHandle<Signature>& getSignature() const { - return _signature; + return signature_; } }; diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc index 8871b010..40c03691 100644 --- a/src/MetalinkParserController.cc +++ b/src/MetalinkParserController.cc @@ -54,82 +54,82 @@ namespace aria2 { MetalinkParserController::MetalinkParserController(): - _metalinker(new Metalinker()) + metalinker_(new Metalinker()) {} MetalinkParserController::~MetalinkParserController() {} void MetalinkParserController::newEntryTransaction() { - _tEntry.reset(new MetalinkEntry()); - _tResource.reset(); - _tMetaurl.reset(); + tEntry_.reset(new MetalinkEntry()); + tResource_.reset(); + tMetaurl_.reset(); #ifdef ENABLE_MESSAGE_DIGEST - _tChecksum.reset(); - _tChunkChecksumV4.reset(); - _tChunkChecksum.reset(); + tChecksum_.reset(); + tChunkChecksumV4_.reset(); + tChunkChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::setFileNameOfEntry(const std::string& filename) { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - if(_tEntry->file.isNull()) { - _tEntry->file.reset(new FileEntry(util::escapePath(filename), 0, 0)); + if(tEntry_->file.isNull()) { + tEntry_->file.reset(new FileEntry(util::escapePath(filename), 0, 0)); } else { - _tEntry->file->setPath(util::escapePath(filename)); + tEntry_->file->setPath(util::escapePath(filename)); } } void MetalinkParserController::setFileLengthOfEntry(uint64_t length) { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - if(_tEntry->file.isNull()) { + if(tEntry_->file.isNull()) { return; } - _tEntry->file->setLength(length); - _tEntry->sizeKnown = true; + tEntry_->file->setLength(length); + tEntry_->sizeKnown = true; } void MetalinkParserController::setVersionOfEntry(const std::string& version) { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tEntry->version = version; + tEntry_->version = version; } void MetalinkParserController::setLanguageOfEntry(const std::string& language) { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tEntry->languages.push_back(language); + tEntry_->languages.push_back(language); } void MetalinkParserController::setOSOfEntry(const std::string& os) { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tEntry->oses.push_back(os); + tEntry_->oses.push_back(os); } void MetalinkParserController::setMaxConnectionsOfEntry(int maxConnections) { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tEntry->maxConnections = maxConnections; + tEntry_->maxConnections = maxConnections; } void MetalinkParserController::commitEntryTransaction() { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } commitResourceTransaction(); @@ -138,8 +138,8 @@ void MetalinkParserController::commitEntryTransaction() commitChunkChecksumTransactionV4(); commitChunkChecksumTransaction(); commitSignatureTransaction(); - _metalinker->addEntry(_tEntry); - _tEntry.reset(); + metalinker_->addEntry(tEntry_); + tEntry_.reset(); } void MetalinkParserController::cancelEntryTransaction() @@ -150,25 +150,25 @@ void MetalinkParserController::cancelEntryTransaction() cancelChunkChecksumTransactionV4(); cancelChunkChecksumTransaction(); cancelSignatureTransaction(); - _tEntry.reset(); + tEntry_.reset(); } void MetalinkParserController::newResourceTransaction() { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tResource.reset(new MetalinkResource()); + tResource_.reset(new MetalinkResource()); } void MetalinkParserController::setURLOfResource(const std::string& url) { - if(_tResource.isNull()) { + if(tResource_.isNull()) { return; } - _tResource->url = url; + tResource_->url = url; // Metalink4Spec - if(_tResource->type == MetalinkResource::TYPE_UNKNOWN) { + if(tResource_->type == MetalinkResource::TYPE_UNKNOWN) { // guess from URI sheme std::string::size_type pos = url.find("://"); if(pos != std::string::npos) { @@ -179,93 +179,93 @@ void MetalinkParserController::setURLOfResource(const std::string& url) void MetalinkParserController::setTypeOfResource(const std::string& type) { - if(_tResource.isNull()) { + if(tResource_.isNull()) { return; } if(type == MetalinkResource::FTP) { - _tResource->type = MetalinkResource::TYPE_FTP; + tResource_->type = MetalinkResource::TYPE_FTP; } else if(type == MetalinkResource::HTTP) { - _tResource->type = MetalinkResource::TYPE_HTTP; + tResource_->type = MetalinkResource::TYPE_HTTP; } else if(type == MetalinkResource::HTTPS) { - _tResource->type = MetalinkResource::TYPE_HTTPS; + tResource_->type = MetalinkResource::TYPE_HTTPS; } else if(type == MetalinkResource::BITTORRENT) { - _tResource->type = MetalinkResource::TYPE_BITTORRENT; + tResource_->type = MetalinkResource::TYPE_BITTORRENT; } else if(type == MetalinkResource::TORRENT) { // Metalink4Spec - _tResource->type = MetalinkResource::TYPE_BITTORRENT; + tResource_->type = MetalinkResource::TYPE_BITTORRENT; } else { - _tResource->type = MetalinkResource::TYPE_NOT_SUPPORTED; + tResource_->type = MetalinkResource::TYPE_NOT_SUPPORTED; } } void MetalinkParserController::setLocationOfResource(const std::string& location) { - if(_tResource.isNull()) { + if(tResource_.isNull()) { return; } - _tResource->location = location; + tResource_->location = location; } void MetalinkParserController::setPriorityOfResource(int priority) { - if(_tResource.isNull()) { + if(tResource_.isNull()) { return; } - _tResource->priority = priority; + tResource_->priority = priority; } void MetalinkParserController::setMaxConnectionsOfResource(int maxConnections) { - if(_tResource.isNull()) { + if(tResource_.isNull()) { return; } - _tResource->maxConnections = maxConnections; + tResource_->maxConnections = maxConnections; } void MetalinkParserController::commitResourceTransaction() { - if(_tResource.isNull()) { + if(tResource_.isNull()) { return; } #ifdef ENABLE_BITTORRENT - if(_tResource->type == MetalinkResource::TYPE_BITTORRENT) { + if(tResource_->type == MetalinkResource::TYPE_BITTORRENT) { SharedHandle<MetalinkMetaurl> metaurl(new MetalinkMetaurl()); - metaurl->url = _tResource->url; - metaurl->priority = _tResource->priority; + metaurl->url = tResource_->url; + metaurl->priority = tResource_->priority; metaurl->mediatype = MetalinkMetaurl::MEDIATYPE_TORRENT; - _tEntry->metaurls.push_back(metaurl); + tEntry_->metaurls.push_back(metaurl); } else { - _tEntry->resources.push_back(_tResource); + tEntry_->resources.push_back(tResource_); } #else // !ENABLE_BITTORRENT - _tEntry->resources.push_back(_tResource); + tEntry_->resources.push_back(tResource_); #endif // !ENABLE_BITTORRENT - _tResource.reset(); + tResource_.reset(); } void MetalinkParserController::cancelResourceTransaction() { - _tResource.reset(); + tResource_.reset(); } void MetalinkParserController::newChecksumTransaction() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tChecksum.reset(new Checksum()); + tChecksum_.reset(new Checksum()); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::setTypeOfChecksum(const std::string& type) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChecksum.isNull()) { + if(tChecksum_.isNull()) { return; } std::string calgo = MessageDigestContext::getCanonicalAlgo(type); if(MessageDigestContext::supports(calgo)) { - _tChecksum->setAlgo(calgo); + tChecksum_->setAlgo(calgo); } else { cancelChecksumTransaction(); } @@ -275,11 +275,11 @@ void MetalinkParserController::setTypeOfChecksum(const std::string& type) void MetalinkParserController::setHashOfChecksum(const std::string& md) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChecksum.isNull()) { + if(tChecksum_.isNull()) { return; } - if(MessageDigestContext::isValidHash(_tChecksum->getAlgo(), md)) { - _tChecksum->setMessageDigest(md); + if(MessageDigestContext::isValidHash(tChecksum_->getAlgo(), md)) { + tChecksum_->setMessageDigest(md); } else { cancelChecksumTransaction(); } @@ -289,45 +289,45 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md) void MetalinkParserController::commitChecksumTransaction() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChecksum.isNull()) { + if(tChecksum_.isNull()) { return; } - if(_tEntry->checksum.isNull() || - MessageDigestContext::isStronger(_tChecksum->getAlgo(), - _tEntry->checksum->getAlgo())) { - _tEntry->checksum = _tChecksum; + if(tEntry_->checksum.isNull() || + MessageDigestContext::isStronger(tChecksum_->getAlgo(), + tEntry_->checksum->getAlgo())) { + tEntry_->checksum = tChecksum_; } - _tChecksum.reset(); + tChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::cancelChecksumTransaction() { #ifdef ENABLE_MESSAGE_DIGEST - _tChecksum.reset(); + tChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::newChunkChecksumTransactionV4() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tChunkChecksumV4.reset(new ChunkChecksum()); - _tempChunkChecksumsV4.clear(); + tChunkChecksumV4_.reset(new ChunkChecksum()); + tempChunkChecksumsV4_.clear(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::setTypeOfChunkChecksumV4(const std::string& type) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksumV4.isNull()) { + if(tChunkChecksumV4_.isNull()) { return; } std::string calgo = MessageDigestContext::getCanonicalAlgo(type); if(MessageDigestContext::supports(calgo)) { - _tChunkChecksumV4->setAlgo(calgo); + tChunkChecksumV4_->setAlgo(calgo); } else { cancelChunkChecksumTransactionV4(); } @@ -337,11 +337,11 @@ void MetalinkParserController::setTypeOfChunkChecksumV4(const std::string& type) void MetalinkParserController::setLengthOfChunkChecksumV4(size_t length) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksumV4.isNull()) { + if(tChunkChecksumV4_.isNull()) { return; } if(length > 0) { - _tChunkChecksumV4->setChecksumLength(length); + tChunkChecksumV4_->setChecksumLength(length); } else { cancelChunkChecksumTransactionV4(); } @@ -351,11 +351,11 @@ void MetalinkParserController::setLengthOfChunkChecksumV4(size_t length) void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksumV4.isNull()) { + if(tChunkChecksumV4_.isNull()) { return; } - if(MessageDigestContext::isValidHash(_tChunkChecksumV4->getAlgo(), md)) { - _tempChunkChecksumsV4.push_back(md); + if(MessageDigestContext::isValidHash(tChunkChecksumV4_->getAlgo(), md)) { + tempChunkChecksumsV4_.push_back(md); } else { cancelChunkChecksumTransactionV4(); } @@ -365,48 +365,48 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md) void MetalinkParserController::commitChunkChecksumTransactionV4() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksumV4.isNull()) { + if(tChunkChecksumV4_.isNull()) { return; } - if(_tEntry->chunkChecksum.isNull() || - MessageDigestContext::isStronger(_tChunkChecksumV4->getAlgo(), - _tEntry->chunkChecksum->getAlgo())) { - std::vector<std::string> checksums(_tempChunkChecksumsV4.begin(), - _tempChunkChecksumsV4.end()); - _tChunkChecksumV4->setChecksums(checksums); - _tEntry->chunkChecksum = _tChunkChecksumV4; + if(tEntry_->chunkChecksum.isNull() || + MessageDigestContext::isStronger(tChunkChecksumV4_->getAlgo(), + tEntry_->chunkChecksum->getAlgo())) { + std::vector<std::string> checksums(tempChunkChecksumsV4_.begin(), + tempChunkChecksumsV4_.end()); + tChunkChecksumV4_->setChecksums(checksums); + tEntry_->chunkChecksum = tChunkChecksumV4_; } - _tChunkChecksumV4.reset(); + tChunkChecksumV4_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::cancelChunkChecksumTransactionV4() { #ifdef ENABLE_MESSAGE_DIGEST - _tChunkChecksumV4.reset(); + tChunkChecksumV4_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::newChunkChecksumTransaction() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tChunkChecksum.reset(new ChunkChecksum()); - _tempChunkChecksums.clear(); + tChunkChecksum_.reset(new ChunkChecksum()); + tempChunkChecksums_.clear(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::setTypeOfChunkChecksum(const std::string& type) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } std::string calgo = MessageDigestContext::getCanonicalAlgo(type); if(MessageDigestContext::supports(calgo)) { - _tChunkChecksum->setAlgo(calgo); + tChunkChecksum_->setAlgo(calgo); } else { cancelChunkChecksumTransaction(); } @@ -416,11 +416,11 @@ void MetalinkParserController::setTypeOfChunkChecksum(const std::string& type) void MetalinkParserController::setLengthOfChunkChecksum(size_t length) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } if(length > 0) { - _tChunkChecksum->setChecksumLength(length); + tChunkChecksum_->setChecksumLength(length); } else { cancelChunkChecksumTransaction(); } @@ -430,11 +430,11 @@ void MetalinkParserController::setLengthOfChunkChecksum(size_t length) void MetalinkParserController::addHashOfChunkChecksum(size_t order, const std::string& md) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } - if(MessageDigestContext::isValidHash(_tChunkChecksum->getAlgo(), md)) { - _tempChunkChecksums.push_back(std::make_pair(order, md)); + if(MessageDigestContext::isValidHash(tChunkChecksum_->getAlgo(), md)) { + tempChunkChecksums_.push_back(std::make_pair(order, md)); } else { cancelChunkChecksumTransaction(); } @@ -444,21 +444,21 @@ void MetalinkParserController::addHashOfChunkChecksum(size_t order, const std::s void MetalinkParserController::createNewHashOfChunkChecksum(size_t order) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } - _tempHashPair.first = order; + tempHashPair_.first = order; #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string& md) { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } - if(MessageDigestContext::isValidHash(_tChunkChecksum->getAlgo(), md)) { - _tempHashPair.second = md; + if(MessageDigestContext::isValidHash(tChunkChecksum_->getAlgo(), md)) { + tempHashPair_.second = md; } else { cancelChunkChecksumTransaction(); } @@ -468,145 +468,145 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string void MetalinkParserController::addHashOfChunkChecksum() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } - _tempChunkChecksums.push_back(_tempHashPair); + tempChunkChecksums_.push_back(tempHashPair_); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::commitChunkChecksumTransaction() { #ifdef ENABLE_MESSAGE_DIGEST - if(_tChunkChecksum.isNull()) { + if(tChunkChecksum_.isNull()) { return; } - if(_tEntry->chunkChecksum.isNull() || - MessageDigestContext::isStronger(_tChunkChecksum->getAlgo(), - _tEntry->chunkChecksum->getAlgo())) { - std::sort(_tempChunkChecksums.begin(), _tempChunkChecksums.end(), + if(tEntry_->chunkChecksum.isNull() || + MessageDigestContext::isStronger(tChunkChecksum_->getAlgo(), + tEntry_->chunkChecksum->getAlgo())) { + std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end(), Ascend1st<std::pair<size_t, std::string> >()); std::vector<std::string> checksums; - std::transform(_tempChunkChecksums.begin(), _tempChunkChecksums.end(), + std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(), std::back_inserter(checksums), select2nd<std::pair<size_t, std::string> >()); - _tChunkChecksum->setChecksums(checksums); - _tEntry->chunkChecksum = _tChunkChecksum; + tChunkChecksum_->setChecksums(checksums); + tEntry_->chunkChecksum = tChunkChecksum_; } - _tChunkChecksum.reset(); + tChunkChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::cancelChunkChecksumTransaction() { #ifdef ENABLE_MESSAGE_DIGEST - _tChunkChecksum.reset(); + tChunkChecksum_.reset(); #endif // ENABLE_MESSAGE_DIGEST } void MetalinkParserController::newSignatureTransaction() { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tSignature.reset(new Signature()); + tSignature_.reset(new Signature()); } void MetalinkParserController::setTypeOfSignature(const std::string& type) { - if(_tSignature.isNull()) { + if(tSignature_.isNull()) { return; } - _tSignature->setType(type); + tSignature_->setType(type); } void MetalinkParserController::setFileOfSignature(const std::string& file) { - if(_tSignature.isNull()) { + if(tSignature_.isNull()) { return; } - _tSignature->setFile(file); + tSignature_->setFile(file); } void MetalinkParserController::setBodyOfSignature(const std::string& body) { - if(_tSignature.isNull()) { + if(tSignature_.isNull()) { return; } - _tSignature->setBody(body); + tSignature_->setBody(body); } void MetalinkParserController::commitSignatureTransaction() { - if(_tSignature.isNull()) { + if(tSignature_.isNull()) { return; } - _tEntry->setSignature(_tSignature); - _tSignature.reset(); + tEntry_->setSignature(tSignature_); + tSignature_.reset(); } void MetalinkParserController::cancelSignatureTransaction() { - _tSignature.reset(); + tSignature_.reset(); } void MetalinkParserController::newMetaurlTransaction() { - if(_tEntry.isNull()) { + if(tEntry_.isNull()) { return; } - _tMetaurl.reset(new MetalinkMetaurl()); + tMetaurl_.reset(new MetalinkMetaurl()); } void MetalinkParserController::setURLOfMetaurl(const std::string& url) { - if(_tMetaurl.isNull()) { + if(tMetaurl_.isNull()) { return; } - _tMetaurl->url = url; + tMetaurl_->url = url; } void MetalinkParserController::setMediatypeOfMetaurl (const std::string& mediatype) { - if(_tMetaurl.isNull()) { + if(tMetaurl_.isNull()) { return; } - _tMetaurl->mediatype = mediatype; + tMetaurl_->mediatype = mediatype; } void MetalinkParserController::setPriorityOfMetaurl(int priority) { - if(_tMetaurl.isNull()) { + if(tMetaurl_.isNull()) { return; } - _tMetaurl->priority = priority; + tMetaurl_->priority = priority; } void MetalinkParserController::setNameOfMetaurl(const std::string& name) { - if(_tMetaurl.isNull()) { + if(tMetaurl_.isNull()) { return; } - _tMetaurl->name = name; + tMetaurl_->name = name; } void MetalinkParserController::commitMetaurlTransaction() { - if(_tMetaurl.isNull()) { + if(tMetaurl_.isNull()) { return; } #ifdef ENABLE_BITTORRENT - if(_tMetaurl->mediatype == MetalinkMetaurl::MEDIATYPE_TORRENT) { - _tEntry->metaurls.push_back(_tMetaurl); + if(tMetaurl_->mediatype == MetalinkMetaurl::MEDIATYPE_TORRENT) { + tEntry_->metaurls.push_back(tMetaurl_); } #endif // ENABLE_BITTORRENT - _tMetaurl.reset(); + tMetaurl_.reset(); } void MetalinkParserController::cancelMetaurlTransaction() { - _tMetaurl.reset(); + tMetaurl_.reset(); } } // namespace aria2 diff --git a/src/MetalinkParserController.h b/src/MetalinkParserController.h index 6693974c..4e3b794b 100644 --- a/src/MetalinkParserController.h +++ b/src/MetalinkParserController.h @@ -58,29 +58,29 @@ class ChunkChecksum; class MetalinkParserController { private: - SharedHandle<Metalinker> _metalinker; + SharedHandle<Metalinker> metalinker_; - SharedHandle<MetalinkEntry> _tEntry; + SharedHandle<MetalinkEntry> tEntry_; - SharedHandle<MetalinkResource> _tResource; + SharedHandle<MetalinkResource> tResource_; - SharedHandle<MetalinkMetaurl> _tMetaurl; + SharedHandle<MetalinkMetaurl> tMetaurl_; #ifdef ENABLE_MESSAGE_DIGEST - SharedHandle<Checksum> _tChecksum; + SharedHandle<Checksum> tChecksum_; - SharedHandle<ChunkChecksum> _tChunkChecksumV4; // Metalink4Spec + SharedHandle<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec - std::vector<std::string> _tempChunkChecksumsV4; // Metalink4Spec + std::vector<std::string> tempChunkChecksumsV4_; // Metalink4Spec - SharedHandle<ChunkChecksum> _tChunkChecksum; // Metalink3Spec + SharedHandle<ChunkChecksum> tChunkChecksum_; // Metalink3Spec - std::vector<std::pair<size_t, std::string> > _tempChunkChecksums;//Metalink3Spec + std::vector<std::pair<size_t, std::string> > tempChunkChecksums_;//Metalink3Spec - std::pair<size_t, std::string> _tempHashPair; // Metalink3Spec + std::pair<size_t, std::string> tempHashPair_; // Metalink3Spec #endif // ENABLE_MESSAGE_DIGEST - SharedHandle<Signature> _tSignature; + SharedHandle<Signature> tSignature_; public: MetalinkParserController(); @@ -88,7 +88,7 @@ public: const SharedHandle<Metalinker>& getResult() const { - return _metalinker; + return metalinker_; } void newEntryTransaction(); diff --git a/src/MetalinkParserStateMachine.cc b/src/MetalinkParserStateMachine.cc index 5d28ef3c..f9fcfc3b 100644 --- a/src/MetalinkParserStateMachine.cc +++ b/src/MetalinkParserStateMachine.cc @@ -45,458 +45,458 @@ namespace aria2 { -MetalinkParserState* MetalinkParserStateMachine::_initialState = +MetalinkParserState* MetalinkParserStateMachine::initialState_ = new InitialMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_skipTagState = +MetalinkParserState* MetalinkParserStateMachine::skipTagState_ = new SkipTagMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_metalinkState = +MetalinkParserState* MetalinkParserStateMachine::metalinkState_ = new MetalinkMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_filesState = +MetalinkParserState* MetalinkParserStateMachine::filesState_ = new FilesMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_fileState = +MetalinkParserState* MetalinkParserStateMachine::fileState_ = new FileMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_sizeState = +MetalinkParserState* MetalinkParserStateMachine::sizeState_ = new SizeMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_versionState = +MetalinkParserState* MetalinkParserStateMachine::versionState_ = new VersionMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_languageState = +MetalinkParserState* MetalinkParserStateMachine::languageState_ = new LanguageMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_osState = +MetalinkParserState* MetalinkParserStateMachine::osState_ = new OSMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_verificationState = +MetalinkParserState* MetalinkParserStateMachine::verificationState_ = new VerificationMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_hashState = +MetalinkParserState* MetalinkParserStateMachine::hashState_ = new HashMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_piecesState = +MetalinkParserState* MetalinkParserStateMachine::piecesState_ = new PiecesMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_pieceHashState = +MetalinkParserState* MetalinkParserStateMachine::pieceHashState_ = new PieceHashMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_signatureState = +MetalinkParserState* MetalinkParserStateMachine::signatureState_ = new SignatureMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_resourcesState = +MetalinkParserState* MetalinkParserStateMachine::resourcesState_ = new ResourcesMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_urlState = +MetalinkParserState* MetalinkParserStateMachine::urlState_ = new URLMetalinkParserState(); -MetalinkParserState* MetalinkParserStateMachine::_metalinkStateV4 = +MetalinkParserState* MetalinkParserStateMachine::metalinkStateV4_ = new MetalinkMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_fileStateV4 = +MetalinkParserState* MetalinkParserStateMachine::fileStateV4_ = new FileMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_sizeStateV4 = +MetalinkParserState* MetalinkParserStateMachine::sizeStateV4_ = new SizeMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_versionStateV4 = +MetalinkParserState* MetalinkParserStateMachine::versionStateV4_ = new VersionMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_languageStateV4 = +MetalinkParserState* MetalinkParserStateMachine::languageStateV4_ = new LanguageMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_osStateV4 = +MetalinkParserState* MetalinkParserStateMachine::osStateV4_ = new OSMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_hashStateV4 = +MetalinkParserState* MetalinkParserStateMachine::hashStateV4_ = new HashMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_piecesStateV4 = +MetalinkParserState* MetalinkParserStateMachine::piecesStateV4_ = new PiecesMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_pieceHashStateV4 = +MetalinkParserState* MetalinkParserStateMachine::pieceHashStateV4_ = new PieceHashMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_signatureStateV4 = +MetalinkParserState* MetalinkParserStateMachine::signatureStateV4_ = new SignatureMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_urlStateV4 = +MetalinkParserState* MetalinkParserStateMachine::urlStateV4_ = new URLMetalinkParserStateV4(); -MetalinkParserState* MetalinkParserStateMachine::_metaurlStateV4 = +MetalinkParserState* MetalinkParserStateMachine::metaurlStateV4_ = new MetaurlMetalinkParserStateV4(); MetalinkParserStateMachine::MetalinkParserStateMachine(): - _ctrl(new MetalinkParserController()) + ctrl_(new MetalinkParserController()) { - _stateStack.push(_initialState); + stateStack_.push(initialState_); } void MetalinkParserStateMachine::setMetalinkState() { - _stateStack.push(_metalinkState); + stateStack_.push(metalinkState_); } void MetalinkParserStateMachine::setFilesState() { - _stateStack.push(_filesState); + stateStack_.push(filesState_); } void MetalinkParserStateMachine::setFileState() { - _stateStack.push(_fileState); + stateStack_.push(fileState_); } void MetalinkParserStateMachine::setSizeState() { - _stateStack.push(_sizeState); + stateStack_.push(sizeState_); } void MetalinkParserStateMachine::setVersionState() { - _stateStack.push(_versionState); + stateStack_.push(versionState_); } void MetalinkParserStateMachine::setLanguageState() { - _stateStack.push(_languageState); + stateStack_.push(languageState_); } void MetalinkParserStateMachine::setOSState() { - _stateStack.push(_osState); + stateStack_.push(osState_); } void MetalinkParserStateMachine::setVerificationState() { - _stateStack.push(_verificationState); + stateStack_.push(verificationState_); } void MetalinkParserStateMachine::setHashState() { - _stateStack.push(_hashState); + stateStack_.push(hashState_); } void MetalinkParserStateMachine::setPiecesState() { - _stateStack.push(_piecesState); + stateStack_.push(piecesState_); } void MetalinkParserStateMachine::setPieceHashState() { - _stateStack.push(_pieceHashState); + stateStack_.push(pieceHashState_); } void MetalinkParserStateMachine::setSignatureState() { - _stateStack.push(_signatureState); + stateStack_.push(signatureState_); } void MetalinkParserStateMachine::setResourcesState() { - _stateStack.push(_resourcesState); + stateStack_.push(resourcesState_); } void MetalinkParserStateMachine::setURLState() { - _stateStack.push(_urlState); + stateStack_.push(urlState_); } void MetalinkParserStateMachine::setMetalinkStateV4() { - _stateStack.push(_metalinkStateV4); + stateStack_.push(metalinkStateV4_); } void MetalinkParserStateMachine::setFileStateV4() { - _stateStack.push(_fileStateV4); + stateStack_.push(fileStateV4_); } void MetalinkParserStateMachine::setSizeStateV4() { - _stateStack.push(_sizeStateV4); + stateStack_.push(sizeStateV4_); } void MetalinkParserStateMachine::setVersionStateV4() { - _stateStack.push(_versionStateV4); + stateStack_.push(versionStateV4_); } void MetalinkParserStateMachine::setLanguageStateV4() { - _stateStack.push(_languageStateV4); + stateStack_.push(languageStateV4_); } void MetalinkParserStateMachine::setOSStateV4() { - _stateStack.push(_osStateV4); + stateStack_.push(osStateV4_); } void MetalinkParserStateMachine::setHashStateV4() { - _stateStack.push(_hashStateV4); + stateStack_.push(hashStateV4_); } void MetalinkParserStateMachine::setPiecesStateV4() { - _stateStack.push(_piecesStateV4); + stateStack_.push(piecesStateV4_); } void MetalinkParserStateMachine::setPieceHashStateV4() { - _stateStack.push(_pieceHashStateV4); + stateStack_.push(pieceHashStateV4_); } void MetalinkParserStateMachine::setSignatureStateV4() { - _stateStack.push(_signatureStateV4); + stateStack_.push(signatureStateV4_); } void MetalinkParserStateMachine::setURLStateV4() { - _stateStack.push(_urlStateV4); + stateStack_.push(urlStateV4_); } void MetalinkParserStateMachine::setMetaurlStateV4() { - _stateStack.push(_metaurlStateV4); + stateStack_.push(metaurlStateV4_); } void MetalinkParserStateMachine::setSkipTagState() { - _stateStack.push(_skipTagState); + stateStack_.push(skipTagState_); } bool MetalinkParserStateMachine::finished() const { - return _stateStack.top() == _initialState; + return stateStack_.top() == initialState_; } void MetalinkParserStateMachine::newEntryTransaction() { - _ctrl->newEntryTransaction(); + ctrl_->newEntryTransaction(); } void MetalinkParserStateMachine::setFileNameOfEntry(const std::string& filename) { - _ctrl->setFileNameOfEntry(filename); + ctrl_->setFileNameOfEntry(filename); } void MetalinkParserStateMachine::setFileLengthOfEntry(uint64_t length) { - _ctrl->setFileLengthOfEntry(length); + ctrl_->setFileLengthOfEntry(length); } void MetalinkParserStateMachine::setVersionOfEntry(const std::string& version) { - _ctrl->setVersionOfEntry(version); + ctrl_->setVersionOfEntry(version); } void MetalinkParserStateMachine::setLanguageOfEntry(const std::string& language) { - _ctrl->setLanguageOfEntry(language); + ctrl_->setLanguageOfEntry(language); } void MetalinkParserStateMachine::setOSOfEntry(const std::string& os) { - _ctrl->setOSOfEntry(os); + ctrl_->setOSOfEntry(os); } void MetalinkParserStateMachine::setMaxConnectionsOfEntry(int maxConnections) { - _ctrl->setMaxConnectionsOfEntry(maxConnections); + ctrl_->setMaxConnectionsOfEntry(maxConnections); } void MetalinkParserStateMachine::commitEntryTransaction() { - _ctrl->commitEntryTransaction(); + ctrl_->commitEntryTransaction(); } void MetalinkParserStateMachine::cancelEntryTransaction() { - _ctrl->cancelEntryTransaction(); + ctrl_->cancelEntryTransaction(); } void MetalinkParserStateMachine::newResourceTransaction() { - _ctrl->newResourceTransaction(); + ctrl_->newResourceTransaction(); } void MetalinkParserStateMachine::setURLOfResource(const std::string& url) { - _ctrl->setURLOfResource(url); + ctrl_->setURLOfResource(url); } void MetalinkParserStateMachine::setTypeOfResource(const std::string& type) { - _ctrl->setTypeOfResource(type); + ctrl_->setTypeOfResource(type); } void MetalinkParserStateMachine::setLocationOfResource (const std::string& location) { - _ctrl->setLocationOfResource(location); + ctrl_->setLocationOfResource(location); } void MetalinkParserStateMachine::setPriorityOfResource(int priority) { - _ctrl->setPriorityOfResource(priority); + ctrl_->setPriorityOfResource(priority); } void MetalinkParserStateMachine::setMaxConnectionsOfResource(int maxConnections) { - _ctrl->setMaxConnectionsOfResource(maxConnections); + ctrl_->setMaxConnectionsOfResource(maxConnections); } void MetalinkParserStateMachine::commitResourceTransaction() { - _ctrl->commitResourceTransaction(); + ctrl_->commitResourceTransaction(); } void MetalinkParserStateMachine::cancelResourceTransaction() { - _ctrl->cancelResourceTransaction(); + ctrl_->cancelResourceTransaction(); } void MetalinkParserStateMachine::newChecksumTransaction() { - _ctrl->newChecksumTransaction(); + ctrl_->newChecksumTransaction(); } void MetalinkParserStateMachine::setTypeOfChecksum(const std::string& type) { - _ctrl->setTypeOfChecksum(type); + ctrl_->setTypeOfChecksum(type); } void MetalinkParserStateMachine::setHashOfChecksum(const std::string& md) { - _ctrl->setHashOfChecksum(md); + ctrl_->setHashOfChecksum(md); } void MetalinkParserStateMachine::commitChecksumTransaction() { - _ctrl->commitChecksumTransaction(); + ctrl_->commitChecksumTransaction(); } void MetalinkParserStateMachine::cancelChecksumTransaction() { - _ctrl->cancelChecksumTransaction(); + ctrl_->cancelChecksumTransaction(); } void MetalinkParserStateMachine::newChunkChecksumTransactionV4() { - _ctrl->newChunkChecksumTransactionV4(); + ctrl_->newChunkChecksumTransactionV4(); } void MetalinkParserStateMachine::setLengthOfChunkChecksumV4(size_t length) { - _ctrl->setLengthOfChunkChecksumV4(length); + ctrl_->setLengthOfChunkChecksumV4(length); } void MetalinkParserStateMachine::setTypeOfChunkChecksumV4 (const std::string& type) { - _ctrl->setTypeOfChunkChecksumV4(type); + ctrl_->setTypeOfChunkChecksumV4(type); } void MetalinkParserStateMachine::addHashOfChunkChecksumV4(const std::string& md) { - _ctrl->addHashOfChunkChecksumV4(md); + ctrl_->addHashOfChunkChecksumV4(md); } void MetalinkParserStateMachine::commitChunkChecksumTransactionV4() { - _ctrl->commitChunkChecksumTransactionV4(); + ctrl_->commitChunkChecksumTransactionV4(); } void MetalinkParserStateMachine::cancelChunkChecksumTransactionV4() { - _ctrl->cancelChunkChecksumTransactionV4(); + ctrl_->cancelChunkChecksumTransactionV4(); } void MetalinkParserStateMachine::newChunkChecksumTransaction() { - _ctrl->newChunkChecksumTransaction(); + ctrl_->newChunkChecksumTransaction(); } void MetalinkParserStateMachine::setLengthOfChunkChecksum(size_t length) { - _ctrl->setLengthOfChunkChecksum(length); + ctrl_->setLengthOfChunkChecksum(length); } void MetalinkParserStateMachine::setTypeOfChunkChecksum(const std::string& type) { - _ctrl->setTypeOfChunkChecksum(type); + ctrl_->setTypeOfChunkChecksum(type); } void MetalinkParserStateMachine::createNewHashOfChunkChecksum(size_t order) { - _ctrl->createNewHashOfChunkChecksum(order); + ctrl_->createNewHashOfChunkChecksum(order); } void MetalinkParserStateMachine::setMessageDigestOfChunkChecksum (const std::string& md) { - _ctrl->setMessageDigestOfChunkChecksum(md); + ctrl_->setMessageDigestOfChunkChecksum(md); } void MetalinkParserStateMachine::addHashOfChunkChecksum() { - _ctrl->addHashOfChunkChecksum(); + ctrl_->addHashOfChunkChecksum(); } void MetalinkParserStateMachine::commitChunkChecksumTransaction() { - _ctrl->commitChunkChecksumTransaction(); + ctrl_->commitChunkChecksumTransaction(); } void MetalinkParserStateMachine::cancelChunkChecksumTransaction() { - _ctrl->cancelChunkChecksumTransaction(); + ctrl_->cancelChunkChecksumTransaction(); } void MetalinkParserStateMachine::newSignatureTransaction() { - _ctrl->newSignatureTransaction(); + ctrl_->newSignatureTransaction(); } void MetalinkParserStateMachine::setTypeOfSignature(const std::string& type) { - _ctrl->setTypeOfSignature(type); + ctrl_->setTypeOfSignature(type); } void MetalinkParserStateMachine::setFileOfSignature(const std::string& file) { - _ctrl->setFileOfSignature(file); + ctrl_->setFileOfSignature(file); } void MetalinkParserStateMachine::setBodyOfSignature(const std::string& body) { - _ctrl->setBodyOfSignature(body); + ctrl_->setBodyOfSignature(body); } void MetalinkParserStateMachine::commitSignatureTransaction() { - _ctrl->commitSignatureTransaction(); + ctrl_->commitSignatureTransaction(); } void MetalinkParserStateMachine::cancelSignatureTransaction() { - _ctrl->cancelSignatureTransaction(); + ctrl_->cancelSignatureTransaction(); } void MetalinkParserStateMachine::newMetaurlTransaction() { - _ctrl->newMetaurlTransaction(); + ctrl_->newMetaurlTransaction(); } void MetalinkParserStateMachine::setURLOfMetaurl(const std::string& url) { - _ctrl->setURLOfMetaurl(url); + ctrl_->setURLOfMetaurl(url); } void MetalinkParserStateMachine::setMediatypeOfMetaurl (const std::string& mediatype) { - _ctrl->setMediatypeOfMetaurl(mediatype); + ctrl_->setMediatypeOfMetaurl(mediatype); } void MetalinkParserStateMachine::setPriorityOfMetaurl(int priority) { - _ctrl->setPriorityOfMetaurl(priority); + ctrl_->setPriorityOfMetaurl(priority); } void MetalinkParserStateMachine::setNameOfMetaurl(const std::string& name) { - _ctrl->setNameOfMetaurl(name); + ctrl_->setNameOfMetaurl(name); } void MetalinkParserStateMachine::commitMetaurlTransaction() { - _ctrl->commitMetaurlTransaction(); + ctrl_->commitMetaurlTransaction(); } void MetalinkParserStateMachine::cancelMetaurlTransaction() { - _ctrl->cancelMetaurlTransaction(); + ctrl_->cancelMetaurlTransaction(); } void MetalinkParserStateMachine::beginElement @@ -505,7 +505,7 @@ void MetalinkParserStateMachine::beginElement const std::string& nsUri, const std::vector<XmlAttr>& attrs) { - _stateStack.top()->beginElement(this, localname, prefix, nsUri, attrs); + stateStack_.top()->beginElement(this, localname, prefix, nsUri, attrs); } void MetalinkParserStateMachine::endElement @@ -514,19 +514,19 @@ void MetalinkParserStateMachine::endElement const std::string& nsUri, const std::string& characters) { - _stateStack.top()->endElement(this, localname, prefix, nsUri, characters); - _stateStack.pop(); + stateStack_.top()->endElement(this, localname, prefix, nsUri, characters); + stateStack_.pop(); } bool MetalinkParserStateMachine::needsCharactersBuffering() const { - return _stateStack.top()->needsCharactersBuffering(); + return stateStack_.top()->needsCharactersBuffering(); } void MetalinkParserStateMachine::logError(const std::string& log) { - if(_errors.size() < 10) { - _errors.push_back(log); + if(errors_.size() < 10) { + errors_.push_back(log); } } @@ -534,7 +534,7 @@ std::string MetalinkParserStateMachine::getErrorString() const { std::stringstream error; error << "Specification violation: "; - std::copy(_errors.begin(), _errors.end(), + std::copy(errors_.begin(), errors_.end(), std::ostream_iterator<std::string>(error, ", ")); return error.str(); } diff --git a/src/MetalinkParserStateMachine.h b/src/MetalinkParserStateMachine.h index 1eea88b5..b0666b58 100644 --- a/src/MetalinkParserStateMachine.h +++ b/src/MetalinkParserStateMachine.h @@ -50,45 +50,45 @@ class Metalinker; class MetalinkParserStateMachine { private: - SharedHandle<MetalinkParserController> _ctrl; + SharedHandle<MetalinkParserController> ctrl_; - std::stack<MetalinkParserState*> _stateStack; + std::stack<MetalinkParserState*> stateStack_; // Error messages encountered while parsing document. - std::vector<std::string> _errors; + std::vector<std::string> errors_; - static MetalinkParserState* _initialState; - static MetalinkParserState* _skipTagState; + static MetalinkParserState* initialState_; + static MetalinkParserState* skipTagState_; // Metalink3 - static MetalinkParserState* _metalinkState; - static MetalinkParserState* _filesState; // Metalink3Spec - static MetalinkParserState* _fileState; - static MetalinkParserState* _sizeState; - static MetalinkParserState* _versionState; - static MetalinkParserState* _languageState; - static MetalinkParserState* _osState; - static MetalinkParserState* _verificationState; // Metalink3Spec - static MetalinkParserState* _hashState; - static MetalinkParserState* _piecesState; // Metalink3Spec - static MetalinkParserState* _pieceHashState; // Metalink3Spec - static MetalinkParserState* _signatureState; - static MetalinkParserState* _resourcesState; // Metalink3Spec - static MetalinkParserState* _urlState; + static MetalinkParserState* metalinkState_; + static MetalinkParserState* filesState_; // Metalink3Spec + static MetalinkParserState* fileState_; + static MetalinkParserState* sizeState_; + static MetalinkParserState* versionState_; + static MetalinkParserState* languageState_; + static MetalinkParserState* osState_; + static MetalinkParserState* verificationState_; // Metalink3Spec + static MetalinkParserState* hashState_; + static MetalinkParserState* piecesState_; // Metalink3Spec + static MetalinkParserState* pieceHashState_; // Metalink3Spec + static MetalinkParserState* signatureState_; + static MetalinkParserState* resourcesState_; // Metalink3Spec + static MetalinkParserState* urlState_; // Metalink4 - static MetalinkParserState* _metalinkStateV4; - static MetalinkParserState* _fileStateV4; - static MetalinkParserState* _sizeStateV4; - static MetalinkParserState* _versionStateV4; - static MetalinkParserState* _languageStateV4; - static MetalinkParserState* _osStateV4; - static MetalinkParserState* _hashStateV4; - static MetalinkParserState* _piecesStateV4; // Metalink4Spec - static MetalinkParserState* _pieceHashStateV4; // Metalink4Spec - static MetalinkParserState* _signatureStateV4; - static MetalinkParserState* _urlStateV4; - static MetalinkParserState* _metaurlStateV4; + static MetalinkParserState* metalinkStateV4_; + static MetalinkParserState* fileStateV4_; + static MetalinkParserState* sizeStateV4_; + static MetalinkParserState* versionStateV4_; + static MetalinkParserState* languageStateV4_; + static MetalinkParserState* osStateV4_; + static MetalinkParserState* hashStateV4_; + static MetalinkParserState* piecesStateV4_; // Metalink4Spec + static MetalinkParserState* pieceHashStateV4_; // Metalink4Spec + static MetalinkParserState* signatureStateV4_; + static MetalinkParserState* urlStateV4_; + static MetalinkParserState* metaurlStateV4_; public: MetalinkParserStateMachine(); @@ -255,14 +255,14 @@ public: const std::vector<std::string>& getErrors() const { - return _errors; + return errors_; } std::string getErrorString() const; const SharedHandle<Metalinker>& getResult() const { - return _ctrl->getResult(); + return ctrl_->getResult(); } }; diff --git a/src/MetalinkParserStateV3Impl.cc b/src/MetalinkParserStateV3Impl.cc index 98a931dd..b89ee4da 100644 --- a/src/MetalinkParserStateV3Impl.cc +++ b/src/MetalinkParserStateV3Impl.cc @@ -69,13 +69,13 @@ const std::string METALINK3_NAMESPACE_URI("http://www.metalinker.org/"); namespace { class FindAttr { private: - const std::string& _localname; + const std::string& localname_; public: - FindAttr(const std::string& localname):_localname(localname) {} + FindAttr(const std::string& localname):localname_(localname) {} bool operator()(const XmlAttr& attr) const { - return attr.localname == _localname && + return attr.localname == localname_ && (attr.nsUri.empty() || attr.nsUri == METALINK3_NAMESPACE_URI); } }; diff --git a/src/MetalinkParserStateV4Impl.cc b/src/MetalinkParserStateV4Impl.cc index 6b09adb2..bfa4d0d6 100644 --- a/src/MetalinkParserStateV4Impl.cc +++ b/src/MetalinkParserStateV4Impl.cc @@ -68,13 +68,13 @@ const std::string METALINK4_NAMESPACE_URI("urn:ietf:params:xml:ns:metalink"); namespace { class FindAttr { private: - const std::string& _localname; + const std::string& localname_; public: - FindAttr(const std::string& localname):_localname(localname) {} + FindAttr(const std::string& localname):localname_(localname) {} bool operator()(const XmlAttr& attr) const { - return attr.localname == _localname && + return attr.localname == localname_ && (attr.nsUri.empty() || attr.nsUri == METALINK4_NAMESPACE_URI); } }; diff --git a/src/Metalinker.cc b/src/Metalinker.cc index af11f489..4a3c8f35 100644 --- a/src/Metalinker.cc +++ b/src/Metalinker.cc @@ -82,7 +82,7 @@ void Metalinker::queryEntry const std::string& language, const std::string& os) const { - std::remove_copy_if(_entries.begin(), _entries.end(), + std::remove_copy_if(entries_.begin(), entries_.end(), std::back_inserter(queryResult), std::not1(EntryQuery(version, language, os))); } diff --git a/src/Metalinker.h b/src/Metalinker.h index b17eb80e..363d90e7 100644 --- a/src/Metalinker.h +++ b/src/Metalinker.h @@ -48,14 +48,14 @@ class MetalinkEntry; class Metalinker { private: - std::vector<SharedHandle<MetalinkEntry> > _entries; + std::vector<SharedHandle<MetalinkEntry> > entries_; public: Metalinker(); ~Metalinker(); Metalinker& operator=(const Metalinker& metalinker) { if(this != &metalinker) { - _entries = metalinker._entries; + entries_ = metalinker.entries_; } return *this; } @@ -68,12 +68,12 @@ public: const std::vector<SharedHandle<MetalinkEntry> >& getEntries() const { - return _entries; + return entries_; } void addEntry(const SharedHandle<MetalinkEntry>& entry) { - _entries.push_back(entry); + entries_.push_back(entry); } }; diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc index e13ef330..66ece501 100644 --- a/src/MultiDiskAdaptor.cc +++ b/src/MultiDiskAdaptor.cc @@ -53,58 +53,58 @@ namespace aria2 { DiskWriterEntry::DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry): - _fileEntry(fileEntry), _open(false), _directIO(false), - _needsFileAllocation(false) {} + fileEntry_(fileEntry), open_(false), directIO_(false), + needsFileAllocation_(false) {} const std::string& DiskWriterEntry::getFilePath() const { - return _fileEntry->getPath(); + return fileEntry_->getPath(); } void DiskWriterEntry::initAndOpenFile() { - if(!_diskWriter.isNull()) { - _diskWriter->initAndOpenFile(_fileEntry->getLength()); - if(_directIO) { - _diskWriter->enableDirectIO(); + if(!diskWriter_.isNull()) { + diskWriter_->initAndOpenFile(fileEntry_->getLength()); + if(directIO_) { + diskWriter_->enableDirectIO(); } - _open = true; + open_ = true; } } void DiskWriterEntry::openFile() { - if(!_diskWriter.isNull()) { - _diskWriter->openFile(_fileEntry->getLength()); - if(_directIO) { - _diskWriter->enableDirectIO(); + if(!diskWriter_.isNull()) { + diskWriter_->openFile(fileEntry_->getLength()); + if(directIO_) { + diskWriter_->enableDirectIO(); } - _open = true; + open_ = true; } } void DiskWriterEntry::openExistingFile() { - if(!_diskWriter.isNull()) { - _diskWriter->openExistingFile(_fileEntry->getLength()); - if(_directIO) { - _diskWriter->enableDirectIO(); + if(!diskWriter_.isNull()) { + diskWriter_->openExistingFile(fileEntry_->getLength()); + if(directIO_) { + diskWriter_->enableDirectIO(); } - _open = true; + open_ = true; } } void DiskWriterEntry::closeFile() { - if(_open) { - _diskWriter->closeFile(); - _open = false; + if(open_) { + diskWriter_->closeFile(); + open_ = false; } } bool DiskWriterEntry::fileExists() { - return _fileEntry->exists(); + return fileEntry_->exists(); } uint64_t DiskWriterEntry::size() const @@ -114,35 +114,35 @@ uint64_t DiskWriterEntry::size() const void DiskWriterEntry::setDiskWriter(const SharedHandle<DiskWriter>& diskWriter) { - _diskWriter = diskWriter; + diskWriter_ = diskWriter; } bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const { - return _fileEntry < entry._fileEntry; + return fileEntry_ < entry.fileEntry_; } void DiskWriterEntry::enableDirectIO() { - if(_open) { - _diskWriter->enableDirectIO(); + if(open_) { + diskWriter_->enableDirectIO(); } - _directIO = true; + directIO_ = true; } void DiskWriterEntry::disableDirectIO() { - if(_open) { - _diskWriter->disableDirectIO(); + if(open_) { + diskWriter_->disableDirectIO(); } - _directIO = false; + directIO_ = false; } MultiDiskAdaptor::MultiDiskAdaptor(): - _pieceLength(0), - _maxOpenFiles(DEFAULT_MAX_OPEN_FILES), - _directIOAllowed(false), - _readOnly(false) {} + pieceLength_(0), + maxOpenFiles_(DEFAULT_MAX_OPEN_FILES), + directIOAllowed_(false), + readOnly_(false) {} static SharedHandle<DiskWriterEntry> createDiskWriterEntry (const SharedHandle<FileEntry>& fileEntry, @@ -155,7 +155,7 @@ static SharedHandle<DiskWriterEntry> createDiskWriterEntry void MultiDiskAdaptor::resetDiskWriterEntries() { - _diskWriterEntries.clear(); + diskWriterEntries_.clear(); if(getFileEntries().empty()) { return; @@ -163,16 +163,16 @@ void MultiDiskAdaptor::resetDiskWriterEntries() for(std::vector<SharedHandle<FileEntry> >::const_iterator i = getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) { - _diskWriterEntries.push_back + diskWriterEntries_.push_back (createDiskWriterEntry(*i, (*i)->isRequested())); } std::map<std::string, bool> dwreq; - // TODO Currently, _pieceLength == 0 is used for unit testing only. - if(_pieceLength > 0) { + // TODO Currently, pieceLength_ == 0 is used for unit testing only. + if(pieceLength_ > 0) { std::vector<SharedHandle<DiskWriterEntry> >::const_iterator done = - _diskWriterEntries.begin(); + diskWriterEntries_.begin(); for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator itr = - _diskWriterEntries.begin(), eoi = _diskWriterEntries.end(); + diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); itr != eoi;) { const SharedHandle<FileEntry>& fileEntry = (*itr)->getFileEntry(); @@ -181,8 +181,8 @@ void MultiDiskAdaptor::resetDiskWriterEntries() continue; } off_t pieceStartOffset = - (fileEntry->getOffset()/_pieceLength)*_pieceLength; - if(itr != _diskWriterEntries.begin()) { + (fileEntry->getOffset()/pieceLength_)*pieceLength_; + if(itr != diskWriterEntries_.begin()) { for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i = itr-1; true; --i) { const SharedHandle<FileEntry>& fileEntry = (*i)->getFileEntry(); @@ -202,12 +202,12 @@ void MultiDiskAdaptor::resetDiskWriterEntries() if(fileEntry->getLength() > 0) { off_t lastPieceStartOffset = (fileEntry->getOffset()+fileEntry->getLength()-1)/ - _pieceLength*_pieceLength; + pieceLength_*pieceLength_; if(getLogger()->debug()) { getLogger()->debug("Checking adjacent backward file to %s" - " whose lastPieceStartOffset+_pieceLength=%lld", + " whose lastPieceStartOffset+pieceLength_=%lld", fileEntry->getPath().c_str(), - lastPieceStartOffset+_pieceLength); + lastPieceStartOffset+pieceLength_); } ++itr; // adjacent backward files are not needed to be allocated. They @@ -221,7 +221,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() (*itr)->getFileEntry()->getOffset()); } if((*itr)->getFileEntry()->getOffset() < - static_cast<off_t>(lastPieceStartOffset+_pieceLength)) { + static_cast<off_t>(lastPieceStartOffset+pieceLength_)) { if(getLogger()->debug()) { getLogger()->debug("%s needs diskwriter", (*itr)->getFileEntry()->getPath().c_str()); @@ -240,7 +240,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() } DefaultDiskWriterFactory dwFactory; for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i = - _diskWriterEntries.begin(), eoi = _diskWriterEntries.end(); + diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); i != eoi; ++i) { if((*i)->needsFileAllocation() || dwreq.find((*i)->getFileEntry()->getPath()) != dwreq.end() || @@ -250,10 +250,10 @@ void MultiDiskAdaptor::resetDiskWriterEntries() (*i)->getFilePath().c_str()); } (*i)->setDiskWriter(dwFactory.newDiskWriter((*i)->getFilePath())); - if(_directIOAllowed) { + if(directIOAllowed_) { (*i)->getDiskWriter()->allowDirectIO(); } - if(_readOnly) { + if(readOnly_) { (*i)->getDiskWriter()->enableReadOnly(); } } @@ -263,7 +263,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() void MultiDiskAdaptor::mkdir() const { for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i = - _diskWriterEntries.begin(), eoi = _diskWriterEntries.end(); + diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); i != eoi; ++i) { (*i)->getFileEntry()->setupDir(); } @@ -276,20 +276,20 @@ void MultiDiskAdaptor::openIfNot // getLogger()->debug("DiskWriterEntry: Cache MISS. offset=%s", // util::itos(entry->getFileEntry()->getOffset()).c_str()); - size_t numOpened = _openedDiskWriterEntries.size(); + size_t numOpened = openedDiskWriterEntries_.size(); (entry.get()->*open)(); - if(numOpened >= _maxOpenFiles) { + if(numOpened >= maxOpenFiles_) { // Cache is full. // Choose one DiskWriterEntry randomly and close it. size_t index = SimpleRandomizer::getInstance()->getRandomNumber(numOpened); std::vector<SharedHandle<DiskWriterEntry> >::iterator i = - _openedDiskWriterEntries.begin(); + openedDiskWriterEntries_.begin(); std::advance(i, index); (*i)->closeFile(); (*i) = entry; } else { - _openedDiskWriterEntries.push_back(entry); + openedDiskWriterEntries_.push_back(entry); } } else { // getLogger()->debug("DiskWriterEntry: Cache HIT. offset=%s", @@ -303,8 +303,8 @@ void MultiDiskAdaptor::openFile() mkdir(); // Call DiskWriterEntry::openFile to make sure that zero-length files are // created. - for(DiskWriterEntries::const_iterator itr = _diskWriterEntries.begin(), - eoi = _diskWriterEntries.end(); itr != eoi; ++itr) { + for(DiskWriterEntries::const_iterator itr = diskWriterEntries_.begin(), + eoi = diskWriterEntries_.end(); itr != eoi; ++itr) { openIfNot(*itr, &DiskWriterEntry::openFile); } } @@ -314,8 +314,8 @@ void MultiDiskAdaptor::initAndOpenFile() resetDiskWriterEntries(); mkdir(); // Call DiskWriterEntry::initAndOpenFile to make files truncated. - for(DiskWriterEntries::const_iterator itr = _diskWriterEntries.begin(), - eoi = _diskWriterEntries.end(); itr != eoi; ++itr) { + for(DiskWriterEntries::const_iterator itr = diskWriterEntries_.begin(), + eoi = diskWriterEntries_.end(); itr != eoi; ++itr) { openIfNot(*itr, &DiskWriterEntry::initAndOpenFile); } } @@ -328,7 +328,7 @@ void MultiDiskAdaptor::openExistingFile() void MultiDiskAdaptor::closeFile() { - std::for_each(_diskWriterEntries.begin(), _diskWriterEntries.end(), + std::for_each(diskWriterEntries_.begin(), diskWriterEntries_.end(), mem_fun_sh(&DiskWriterEntry::closeFile)); } @@ -391,12 +391,12 @@ void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len, off_t offset) { DiskWriterEntries::const_iterator first = - findFirstDiskWriterEntry(_diskWriterEntries, offset); + findFirstDiskWriterEntry(diskWriterEntries_, offset); size_t rem = len; off_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); for(DiskWriterEntries::const_iterator i = first, - eoi = _diskWriterEntries.end(); i != eoi; ++i) { + eoi = diskWriterEntries_.end(); i != eoi; ++i) { size_t writeLength = calculateLength(*i, fileOffset, rem); openIfNot(*i, &DiskWriterEntry::openFile); @@ -418,13 +418,13 @@ ssize_t MultiDiskAdaptor::readData (unsigned char* data, size_t len, off_t offset) { DiskWriterEntries::const_iterator first = - findFirstDiskWriterEntry(_diskWriterEntries, offset); + findFirstDiskWriterEntry(diskWriterEntries_, offset); size_t rem = len; size_t totalReadLength = 0; off_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); for(DiskWriterEntries::const_iterator i = first, - eoi = _diskWriterEntries.end(); i != eoi; ++i) { + eoi = diskWriterEntries_.end(); i != eoi; ++i) { size_t readLength = calculateLength(*i, fileOffset, rem); openIfNot(*i, &DiskWriterEntry::openFile); @@ -469,30 +469,30 @@ FileAllocationIteratorHandle MultiDiskAdaptor::fileAllocationIterator() void MultiDiskAdaptor::enableDirectIO() { - std::for_each(_diskWriterEntries.begin(), _diskWriterEntries.end(), + std::for_each(diskWriterEntries_.begin(), diskWriterEntries_.end(), mem_fun_sh(&DiskWriterEntry::enableDirectIO)); } void MultiDiskAdaptor::disableDirectIO() { - std::for_each(_diskWriterEntries.begin(), _diskWriterEntries.end(), + std::for_each(diskWriterEntries_.begin(), diskWriterEntries_.end(), mem_fun_sh(&DiskWriterEntry::disableDirectIO)); } void MultiDiskAdaptor::enableReadOnly() { - _readOnly = true; + readOnly_ = true; } void MultiDiskAdaptor::disableReadOnly() { - _readOnly = false; + readOnly_ = false; } void MultiDiskAdaptor::cutTrailingGarbage() { for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i = - _diskWriterEntries.begin(), eoi = _diskWriterEntries.end(); + diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); i != eoi; ++i) { uint64_t length = (*i)->getFileEntry()->getLength(); if(File((*i)->getFilePath()).size() > length) { @@ -505,7 +505,7 @@ void MultiDiskAdaptor::cutTrailingGarbage() void MultiDiskAdaptor::setMaxOpenFiles(size_t maxOpenFiles) { - _maxOpenFiles = maxOpenFiles; + maxOpenFiles_ = maxOpenFiles; } size_t MultiDiskAdaptor::utime(const Time& actime, const Time& modtime) diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h index 3f0f016c..c29c0351 100644 --- a/src/MultiDiskAdaptor.h +++ b/src/MultiDiskAdaptor.h @@ -45,11 +45,11 @@ class DiskWriter; class DiskWriterEntry { private: - SharedHandle<FileEntry> _fileEntry; - SharedHandle<DiskWriter> _diskWriter; - bool _open; - bool _directIO; - bool _needsFileAllocation; + SharedHandle<FileEntry> fileEntry_; + SharedHandle<DiskWriter> diskWriter_; + bool open_; + bool directIO_; + bool needsFileAllocation_; public: DiskWriterEntry(const SharedHandle<FileEntry>& fileEntry); @@ -65,7 +65,7 @@ public: bool isOpen() const { - return _open; + return open_; } bool fileExists(); @@ -74,36 +74,36 @@ public: const SharedHandle<FileEntry>& getFileEntry() const { - return _fileEntry; + return fileEntry_; } void setDiskWriter(const SharedHandle<DiskWriter>& diskWriter); const SharedHandle<DiskWriter>& getDiskWriter() const { - return _diskWriter; + return diskWriter_; } bool operator<(const DiskWriterEntry& entry) const; - // Set _directIO to true. + // Set directIO_ to true. // Additionally, if diskWriter is opened, diskWriter->enableDirectIO() is // called. void enableDirectIO(); - // Set _directIO to false. + // Set directIO_ to false. // Additionally, if diskWriter is opened, diskWriter->disableDirectIO() is // called. void disableDirectIO(); bool needsFileAllocation() const { - return _needsFileAllocation; + return needsFileAllocation_; } void needsFileAllocation(bool f) { - _needsFileAllocation = f; + needsFileAllocation_ = f; } }; @@ -115,16 +115,16 @@ typedef std::vector<DiskWriterEntryHandle> DiskWriterEntries; class MultiDiskAdaptor : public DiskAdaptor { friend class MultiFileAllocationIterator; private: - size_t _pieceLength; - DiskWriterEntries _diskWriterEntries; + size_t pieceLength_; + DiskWriterEntries diskWriterEntries_; - std::vector<SharedHandle<DiskWriterEntry> > _openedDiskWriterEntries; + std::vector<SharedHandle<DiskWriterEntry> > openedDiskWriterEntries_; - size_t _maxOpenFiles; + size_t maxOpenFiles_; - bool _directIOAllowed; + bool directIOAllowed_; - bool _readOnly; + bool readOnly_; void resetDiskWriterEntries(); @@ -165,20 +165,20 @@ public: virtual void disableReadOnly(); - virtual bool isReadOnlyEnabled() const { return _readOnly; } + virtual bool isReadOnlyEnabled() const { return readOnly_; } void setPieceLength(size_t pieceLength) { - _pieceLength = pieceLength; + pieceLength_ = pieceLength; } size_t getPieceLength() const { - return _pieceLength; + return pieceLength_; } void allowDirectIO() { - _directIOAllowed = true; + directIOAllowed_ = true; } virtual void cutTrailingGarbage(); @@ -190,7 +190,7 @@ public: const std::vector<SharedHandle<DiskWriterEntry> >& getDiskWriterEntries() const { - return _diskWriterEntries; + return diskWriterEntries_; } }; diff --git a/src/MultiFileAllocationIterator.cc b/src/MultiFileAllocationIterator.cc index 82d10e58..8fa15a97 100644 --- a/src/MultiFileAllocationIterator.cc +++ b/src/MultiFileAllocationIterator.cc @@ -44,30 +44,30 @@ namespace aria2 { MultiFileAllocationIterator::MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor): - _diskAdaptor(diskAdaptor), - _entries(_diskAdaptor->_diskWriterEntries.begin(), - _diskAdaptor->_diskWriterEntries.end()), - _offset(0) + diskAdaptor_(diskAdaptor), + entries_(diskAdaptor_->diskWriterEntries_.begin(), + diskAdaptor_->diskWriterEntries_.end()), + offset_(0) {} MultiFileAllocationIterator::~MultiFileAllocationIterator() {} void MultiFileAllocationIterator::allocateChunk() { - while(_fileAllocationIterator.isNull() || _fileAllocationIterator->finished()) { - if(_entries.empty()) { + while(fileAllocationIterator_.isNull() || fileAllocationIterator_->finished()) { + if(entries_.empty()) { break; } - SharedHandle<DiskWriterEntry> entry = _entries.front(); - _entries.pop_front(); + SharedHandle<DiskWriterEntry> entry = entries_.front(); + entries_.pop_front(); SharedHandle<FileEntry> fileEntry = entry->getFileEntry(); // Open file before calling DiskWriterEntry::size() - _diskAdaptor->openIfNot(entry, &DiskWriterEntry::openFile); + diskAdaptor_->openIfNot(entry, &DiskWriterEntry::openFile); if(entry->needsFileAllocation() && entry->size() < fileEntry->getLength()) { // Calling private function of MultiDiskAdaptor. #ifdef HAVE_POSIX_FALLOCATE - if(_diskAdaptor->doesFallocate()) { - _fileAllocationIterator.reset + if(diskAdaptor_->doesFallocate()) { + fileAllocationIterator_.reset (new FallocFileAllocationIterator(entry->getDiskWriter().get(), entry->size(), fileEntry->getLength())); @@ -79,43 +79,43 @@ void MultiFileAllocationIterator::allocateChunk() entry->size(), fileEntry->getLength())); fa->init(); - _fileAllocationIterator = fa; + fileAllocationIterator_ = fa; } } } if(finished()) { return; } - _fileAllocationIterator->allocateChunk(); + fileAllocationIterator_->allocateChunk(); } bool MultiFileAllocationIterator::finished() { - return _entries.empty() && (_fileAllocationIterator.isNull() || _fileAllocationIterator->finished()); + return entries_.empty() && (fileAllocationIterator_.isNull() || fileAllocationIterator_->finished()); } off_t MultiFileAllocationIterator::getCurrentLength() { - if(_fileAllocationIterator.isNull()) { + if(fileAllocationIterator_.isNull()) { return 0; } else { - return _fileAllocationIterator->getCurrentLength(); + return fileAllocationIterator_->getCurrentLength(); } } uint64_t MultiFileAllocationIterator::getTotalLength() { - if(_fileAllocationIterator.isNull()) { + if(fileAllocationIterator_.isNull()) { return 0; } else { - return _fileAllocationIterator->getTotalLength(); + return fileAllocationIterator_->getTotalLength(); } } const std::deque<SharedHandle<DiskWriterEntry> >& MultiFileAllocationIterator::getDiskWriterEntries() const { - return _entries; + return entries_; } } // namespace aria2 diff --git a/src/MultiFileAllocationIterator.h b/src/MultiFileAllocationIterator.h index ac9152b9..42239c4f 100644 --- a/src/MultiFileAllocationIterator.h +++ b/src/MultiFileAllocationIterator.h @@ -46,10 +46,10 @@ class DiskWriterEntry; class MultiFileAllocationIterator:public FileAllocationIterator { private: - MultiDiskAdaptor* _diskAdaptor; - std::deque<SharedHandle<DiskWriterEntry> > _entries; - SharedHandle<FileAllocationIterator> _fileAllocationIterator; - off_t _offset; + MultiDiskAdaptor* diskAdaptor_; + std::deque<SharedHandle<DiskWriterEntry> > entries_; + SharedHandle<FileAllocationIterator> fileAllocationIterator_; + off_t offset_; public: MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor); diff --git a/src/MultiUrlRequestInfo.cc b/src/MultiUrlRequestInfo.cc index aebd6451..7baf11c1 100644 --- a/src/MultiUrlRequestInfo.cc +++ b/src/MultiUrlRequestInfo.cc @@ -100,18 +100,18 @@ MultiUrlRequestInfo::MultiUrlRequestInfo const SharedHandle<StatCalc>& statCalc, std::ostream& summaryOut) : - _requestGroups(requestGroups), - _option(op), - _statCalc(statCalc), - _summaryOut(summaryOut), - _logger(LogFactory::getInstance()) + requestGroups_(requestGroups), + option_(op), + statCalc_(statCalc), + summaryOut_(summaryOut), + logger_(LogFactory::getInstance()) {} MultiUrlRequestInfo::~MultiUrlRequestInfo() {} void MultiUrlRequestInfo::printMessageForContinue() { - _summaryOut << "\n" + summaryOut_ << "\n" << _("aria2 will resume download if the transfer is restarted.") << "\n" << _("If there are any errors, then see the log file. See '-l' option in help/man page for details.") @@ -123,29 +123,29 @@ downloadresultcode::RESULT MultiUrlRequestInfo::execute() downloadresultcode::RESULT returnValue = downloadresultcode::FINISHED; try { DownloadEngineHandle e = - DownloadEngineFactory().newDownloadEngine(_option.get(), _requestGroups); + DownloadEngineFactory().newDownloadEngine(option_.get(), requestGroups_); - if(!_option->blank(PREF_LOAD_COOKIES)) { - File cookieFile(_option->get(PREF_LOAD_COOKIES)); + if(!option_->blank(PREF_LOAD_COOKIES)) { + File cookieFile(option_->get(PREF_LOAD_COOKIES)); if(cookieFile.isFile()) { e->getCookieStorage()->load(cookieFile.getPath()); - _logger->info("Loaded cookies from '%s'.", + logger_->info("Loaded cookies from '%s'.", cookieFile.getPath().c_str()); } else { - _logger->error(MSG_LOADING_COOKIE_FAILED, cookieFile.getPath().c_str()); + logger_->error(MSG_LOADING_COOKIE_FAILED, cookieFile.getPath().c_str()); } } SharedHandle<AuthConfigFactory> authConfigFactory(new AuthConfigFactory()); - File netrccf(_option->get(PREF_NETRC_PATH)); - if(!_option->getAsBool(PREF_NO_NETRC) && netrccf.isFile()) { + File netrccf(option_->get(PREF_NETRC_PATH)); + if(!option_->getAsBool(PREF_NO_NETRC) && netrccf.isFile()) { mode_t mode = netrccf.mode(); if(mode&(S_IRWXG|S_IRWXO)) { - _logger->notice(MSG_INCORRECT_NETRC_PERMISSION, - _option->get(PREF_NETRC_PATH).c_str()); + logger_->notice(MSG_INCORRECT_NETRC_PERMISSION, + option_->get(PREF_NETRC_PATH).c_str()); } else { SharedHandle<Netrc> netrc(new Netrc()); - netrc->parse(_option->get(PREF_NETRC_PATH)); + netrc->parse(option_->get(PREF_NETRC_PATH)); authConfigFactory->setNetrc(netrc); } } @@ -153,36 +153,36 @@ downloadresultcode::RESULT MultiUrlRequestInfo::execute() #ifdef ENABLE_SSL SharedHandle<TLSContext> tlsContext(new TLSContext()); - if(!_option->blank(PREF_CERTIFICATE) && - !_option->blank(PREF_PRIVATE_KEY)) { - tlsContext->addClientKeyFile(_option->get(PREF_CERTIFICATE), - _option->get(PREF_PRIVATE_KEY)); + if(!option_->blank(PREF_CERTIFICATE) && + !option_->blank(PREF_PRIVATE_KEY)) { + tlsContext->addClientKeyFile(option_->get(PREF_CERTIFICATE), + option_->get(PREF_PRIVATE_KEY)); } - if(!_option->blank(PREF_CA_CERTIFICATE)) { - if(!tlsContext->addTrustedCACertFile(_option->get(PREF_CA_CERTIFICATE))) { - _logger->warn(MSG_WARN_NO_CA_CERT); + if(!option_->blank(PREF_CA_CERTIFICATE)) { + if(!tlsContext->addTrustedCACertFile(option_->get(PREF_CA_CERTIFICATE))) { + logger_->warn(MSG_WARN_NO_CA_CERT); } - } else if(_option->getAsBool(PREF_CHECK_CERTIFICATE)) { - _logger->warn(MSG_WARN_NO_CA_CERT); + } else if(option_->getAsBool(PREF_CHECK_CERTIFICATE)) { + logger_->warn(MSG_WARN_NO_CA_CERT); } - if(_option->getAsBool(PREF_CHECK_CERTIFICATE)) { + if(option_->getAsBool(PREF_CHECK_CERTIFICATE)) { tlsContext->enablePeerVerification(); } SocketCore::setTLSContext(tlsContext); #endif if(!Timer::monotonicClock()) { - _logger->warn("Don't change system time while aria2c is running." + logger_->warn("Don't change system time while aria2c is running." " Doing this may make aria2c hang for long time."); } - std::string serverStatIf = _option->get(PREF_SERVER_STAT_IF); + std::string serverStatIf = option_->get(PREF_SERVER_STAT_IF); if(!serverStatIf.empty()) { e->getRequestGroupMan()->loadServerStat(serverStatIf); e->getRequestGroupMan()->removeStaleServerStat - (_option->getAsInt(PREF_SERVER_STAT_TIMEOUT)); + (option_->getAsInt(PREF_SERVER_STAT_TIMEOUT)); } - e->setStatCalc(_statCalc); + e->setStatCalc(statCalc_); #ifdef SIGHUP util::setGlobalSignalHandler(SIGHUP, handler, 0); #endif // SIGHUP @@ -191,16 +191,16 @@ downloadresultcode::RESULT MultiUrlRequestInfo::execute() e->run(); - if(!_option->blank(PREF_SAVE_COOKIES)) { - e->getCookieStorage()->saveNsFormat(_option->get(PREF_SAVE_COOKIES)); + if(!option_->blank(PREF_SAVE_COOKIES)) { + e->getCookieStorage()->saveNsFormat(option_->get(PREF_SAVE_COOKIES)); } - std::string serverStatOf = _option->get(PREF_SERVER_STAT_OF); + std::string serverStatOf = option_->get(PREF_SERVER_STAT_OF); if(!serverStatOf.empty()) { e->getRequestGroupMan()->saveServerStat(serverStatOf); } - e->getRequestGroupMan()->showDownloadResults(_summaryOut); - _summaryOut << std::flush; + e->getRequestGroupMan()->showDownloadResults(summaryOut_); + summaryOut_ << std::flush; RequestGroupMan::DownloadStat s = e->getRequestGroupMan()->getDownloadStat(); @@ -215,13 +215,13 @@ downloadresultcode::RESULT MultiUrlRequestInfo::execute() } SessionSerializer sessionSerializer(e->getRequestGroupMan()); // TODO Add option: --save-session-status=error,inprogress,waiting - if(!_option->blank(PREF_SAVE_SESSION)) { - const std::string& filename = _option->get(PREF_SAVE_SESSION); + if(!option_->blank(PREF_SAVE_SESSION)) { + const std::string& filename = option_->get(PREF_SAVE_SESSION); if(sessionSerializer.save(filename)) { - _logger->notice("Serialized session to '%s' successfully.", + logger_->notice("Serialized session to '%s' successfully.", filename.c_str()); } else { - _logger->notice("Failed to serialize session to '%s'.", + logger_->notice("Failed to serialize session to '%s'.", filename.c_str()); } } @@ -229,7 +229,7 @@ downloadresultcode::RESULT MultiUrlRequestInfo::execute() if(returnValue == downloadresultcode::FINISHED) { returnValue = downloadresultcode::UNKNOWN_ERROR; } - _logger->error(EX_EXCEPTION_CAUGHT, e); + logger_->error(EX_EXCEPTION_CAUGHT, e); } #ifdef SIGHUP util::setGlobalSignalHandler(SIGHUP, SIG_DFL, 0); diff --git a/src/MultiUrlRequestInfo.h b/src/MultiUrlRequestInfo.h index 2191151a..e372fe86 100644 --- a/src/MultiUrlRequestInfo.h +++ b/src/MultiUrlRequestInfo.h @@ -52,15 +52,15 @@ class StatCalc; class MultiUrlRequestInfo { private: - std::vector<SharedHandle<RequestGroup> > _requestGroups; + std::vector<SharedHandle<RequestGroup> > requestGroups_; - SharedHandle<Option> _option; + SharedHandle<Option> option_; - SharedHandle<StatCalc> _statCalc; + SharedHandle<StatCalc> statCalc_; - std::ostream& _summaryOut; + std::ostream& summaryOut_; - Logger* _logger; + Logger* logger_; void printMessageForContinue(); diff --git a/src/NameMatchOptionHandler.h b/src/NameMatchOptionHandler.h index f974c499..89a1f13a 100644 --- a/src/NameMatchOptionHandler.h +++ b/src/NameMatchOptionHandler.h @@ -58,21 +58,21 @@ class Option; class NameMatchOptionHandler : public OptionHandler { protected: - std::string _optName; + std::string optName_; - std::string _description; + std::string description_; - std::string _defaultValue; + std::string defaultValue_; - std::vector<std::string> _tags; + std::vector<std::string> tags_; - int _id; + int id_; - OptionHandler::ARG_TYPE _argType; + OptionHandler::ARG_TYPE argType_; - char _shortName; + char shortName_; - bool _hidden; + bool hidden_; virtual void parseArg(Option& option, const std::string& arg) = 0; public: @@ -81,19 +81,19 @@ public: const std::string& defaultValue = NO_DEFAULT_VALUE, ARG_TYPE argType = REQ_ARG, char shortName = 0): - _optName(optName), - _description(description), - _defaultValue(defaultValue), - _id(0), - _argType(argType), - _shortName(shortName), - _hidden(false) {} + optName_(optName), + description_(description), + defaultValue_(defaultValue), + id_(0), + argType_(argType), + shortName_(shortName), + hidden_(false) {} virtual ~NameMatchOptionHandler() {} virtual bool canHandle(const std::string& optName) { - return strcasecmp(_optName.c_str(), optName.c_str()) == 0; + return strcasecmp(optName_.c_str(), optName.c_str()) == 0; } virtual void parse(Option& option, const std::string& arg) @@ -101,68 +101,68 @@ public: try { parseArg(option, arg); } catch(Exception& e) { - throw OPTION_HANDLER_EXCEPTION2(_optName, e); + throw OPTION_HANDLER_EXCEPTION2(optName_, e); } } virtual bool hasTag(const std::string& tag) const { - return std::find(_tags.begin(), _tags.end(), tag) != _tags.end(); + return std::find(tags_.begin(), tags_.end(), tag) != tags_.end(); } virtual void addTag(const std::string& tag) { - _tags.push_back(tag); + tags_.push_back(tag); } virtual std::string toTagString() const { - return strjoin(_tags.begin(), _tags.end(), ", "); + return strjoin(tags_.begin(), tags_.end(), ", "); } virtual const std::string& getName() const { - return _optName; + return optName_; } virtual const std::string& getDescription() const { - return _description; + return description_; } virtual const std::string& getDefaultValue() const { - return _defaultValue; + return defaultValue_; } virtual bool isHidden() const { - return _hidden; + return hidden_; } virtual void hide() { - _hidden = true; + hidden_ = true; } virtual char getShortName() const { - return _shortName; + return shortName_; } virtual int getOptionID() const { - return _id; + return id_; } virtual void setOptionID(int id) { - _id = id; + id_ = id; } virtual OptionHandler::ARG_TYPE getArgType() const { - return _argType; + return argType_; } }; diff --git a/src/NameResolver.cc b/src/NameResolver.cc index 7a126d6e..2c32035a 100644 --- a/src/NameResolver.cc +++ b/src/NameResolver.cc @@ -44,14 +44,14 @@ namespace aria2 { -NameResolver::NameResolver():_socktype(0), _family(AF_UNSPEC) {} +NameResolver::NameResolver():socktype_(0), family_(AF_UNSPEC) {} void NameResolver::resolve(std::vector<std::string>& resolvedAddresses, const std::string& hostname) { struct addrinfo* res; int s; - s = callGetaddrinfo(&res, hostname.c_str(), 0, _family, _socktype, 0, 0); + s = callGetaddrinfo(&res, hostname.c_str(), 0, family_, socktype_, 0, 0); if(s) { throw DL_ABORT_EX(StringFormat(EX_RESOLVE_HOSTNAME, hostname.c_str(), gai_strerror(s)).str()); @@ -67,7 +67,7 @@ void NameResolver::resolve(std::vector<std::string>& resolvedAddresses, void NameResolver::setSocktype(int socktype) { - _socktype = socktype; + socktype_ = socktype; } } // namespace aria2 diff --git a/src/NameResolver.h b/src/NameResolver.h index 0e9781b0..ebd2ca9d 100644 --- a/src/NameResolver.h +++ b/src/NameResolver.h @@ -43,8 +43,8 @@ namespace aria2 { class NameResolver { private: - int _socktype; - int _family; + int socktype_; + int family_; public: NameResolver(); @@ -60,7 +60,7 @@ public: // specify protocol family void setFamily(int family) { - _family = family; + family_ = family; } }; diff --git a/src/Netrc.cc b/src/Netrc.cc index 505ccf50..f95b98f0 100644 --- a/src/Netrc.cc +++ b/src/Netrc.cc @@ -68,7 +68,7 @@ void Netrc::skipMacdef(std::ifstream& f) const void Netrc::parse(const std::string& path) { - _authenticators.clear(); + authenticators_.clear(); std::ifstream f(path.c_str(), std::ios::binary); if(!f) { @@ -146,7 +146,7 @@ void Netrc::parse(const std::string& path) void Netrc::storeAuthenticator(const SharedHandle<Authenticator>& authenticator) { if(!authenticator.isNull()) { - _authenticators.push_back(authenticator); + authenticators_.push_back(authenticator); } } @@ -167,9 +167,9 @@ Netrc::findAuthenticator(const std::string& hostname) const { SharedHandle<Authenticator> res; std::vector<SharedHandle<Authenticator> >::const_iterator itr = - std::find_if(_authenticators.begin(), _authenticators.end(), + std::find_if(authenticators_.begin(), authenticators_.end(), AuthHostMatch(hostname)); - if(itr != _authenticators.end()) { + if(itr != authenticators_.end()) { res = *itr; } return res; diff --git a/src/Netrc.h b/src/Netrc.h index 44ccdc0c..f0ad3d23 100644 --- a/src/Netrc.h +++ b/src/Netrc.h @@ -55,10 +55,10 @@ public: class Authenticator : public Authenticatable { private: - std::string _machine; - std::string _login; - std::string _password; - std::string _account; + std::string machine_; + std::string login_; + std::string password_; + std::string account_; public: Authenticator() {} @@ -66,45 +66,45 @@ public: const std::string& login, const std::string& password, const std::string& account) - :_machine(machine), - _login(login), - _password(password), - _account(account) {} + :machine_(machine), + login_(login), + password_(password), + account_(account) {} virtual ~Authenticator() {} virtual bool match(const std::string& hostname) const { - return hostname == _machine; + return hostname == machine_; } const std::string& getMachine() const { - return _machine; + return machine_; } - void setMachine(const std::string& machine) { _machine = machine; } + void setMachine(const std::string& machine) { machine_ = machine; } const std::string& getLogin() const { - return _login; + return login_; } - void setLogin(const std::string& login) { _login = login; } + void setLogin(const std::string& login) { login_ = login; } const std::string& getPassword() const { - return _password; + return password_; } - void setPassword(const std::string& password) { _password = password; } + void setPassword(const std::string& password) { password_ = password; } const std::string& getAccount() const { - return _account; + return account_; } - void setAccount(const std::string& account) { _account = account; } + void setAccount(const std::string& account) { account_ = account; } }; class DefaultAuthenticator : public Authenticator { @@ -126,7 +126,7 @@ public: class Netrc { private: - std::vector<SharedHandle<Authenticator> > _authenticators; + std::vector<SharedHandle<Authenticator> > authenticators_; void storeAuthenticator(const SharedHandle<Authenticator>& authenticator); @@ -143,12 +143,12 @@ public: const std::vector<SharedHandle<Authenticator> >& getAuthenticators() const { - return _authenticators; + return authenticators_; } void addAuthenticator(const SharedHandle<Authenticator>& authenticator) { - _authenticators.push_back(authenticator); + authenticators_.push_back(authenticator); } static const std::string MACHINE; diff --git a/src/NetrcAuthResolver.cc b/src/NetrcAuthResolver.cc index ef54c02d..9d188585 100644 --- a/src/NetrcAuthResolver.cc +++ b/src/NetrcAuthResolver.cc @@ -38,7 +38,7 @@ namespace aria2 { -NetrcAuthResolver::NetrcAuthResolver():_ignoreDefault(false) {} +NetrcAuthResolver::NetrcAuthResolver():ignoreDefault_(false) {} SharedHandle<AuthConfig> NetrcAuthResolver::resolveAuthConfig(const std::string& hostname) @@ -53,14 +53,14 @@ NetrcAuthResolver::resolveAuthConfig(const std::string& hostname) SharedHandle<AuthConfig> NetrcAuthResolver::findNetrcAuthenticator(const std::string& hostname) const { - if(_netrc.isNull()) { + if(netrc_.isNull()) { return getDefaultAuthConfig(); } else { - SharedHandle<Authenticator> auth = _netrc->findAuthenticator(hostname); + SharedHandle<Authenticator> auth = netrc_->findAuthenticator(hostname); if(auth.isNull()) { return getDefaultAuthConfig(); } else { - if(_ignoreDefault && auth->getMachine().empty()) { + if(ignoreDefault_ && auth->getMachine().empty()) { return getDefaultAuthConfig(); } else { return SharedHandle<AuthConfig> @@ -72,17 +72,17 @@ NetrcAuthResolver::findNetrcAuthenticator(const std::string& hostname) const void NetrcAuthResolver::setNetrc(const SharedHandle<Netrc>& netrc) { - _netrc = netrc; + netrc_ = netrc; } void NetrcAuthResolver::ignoreDefault() { - _ignoreDefault = true; + ignoreDefault_ = true; } void NetrcAuthResolver::useDefault() { - _ignoreDefault = false; + ignoreDefault_ = false; } } // namespace aria2 diff --git a/src/NetrcAuthResolver.h b/src/NetrcAuthResolver.h index 8b5786c7..48f50fee 100644 --- a/src/NetrcAuthResolver.h +++ b/src/NetrcAuthResolver.h @@ -43,9 +43,9 @@ class Netrc; class NetrcAuthResolver : public AbstractAuthResolver { private: - SharedHandle<Netrc> _netrc; + SharedHandle<Netrc> netrc_; - bool _ignoreDefault; + bool ignoreDefault_; SharedHandle<AuthConfig> findNetrcAuthenticator (const std::string& hostname) const; @@ -59,7 +59,7 @@ public: const SharedHandle<Netrc>& getNetrc() const { - return _netrc; + return netrc_; } // Ignores default token of netrc diff --git a/src/Option.cc b/src/Option.cc index d4da5d9d..491c2ef8 100644 --- a/src/Option.cc +++ b/src/Option.cc @@ -45,23 +45,23 @@ Option::Option() {} Option::~Option() {} void Option::put(const std::string& name, const std::string& value) { - _table[name] = value; + table_[name] = value; } bool Option::defined(const std::string& name) const { - return _table.count(name) == 1; + return table_.count(name) == 1; } bool Option::blank(const std::string& name) const { - std::map<std::string, std::string>::const_iterator i = _table.find(name); - return i == _table.end() || (*i).second.empty(); + std::map<std::string, std::string>::const_iterator i = table_.find(name); + return i == table_.end() || (*i).second.empty(); } const std::string& Option::get(const std::string& name) const { - std::map<std::string, std::string>::const_iterator itr = _table.find(name); - if(itr == _table.end()) { + std::map<std::string, std::string>::const_iterator itr = table_.find(name); + if(itr == table_.end()) { return A2STR::NIL; } else { return (*itr).second; @@ -101,15 +101,15 @@ double Option::getAsDouble(const std::string& name) const { void Option::remove(const std::string& name) { - std::map<std::string, std::string>::iterator i = _table.find(name); - if(i != _table.end()) { - _table.erase(i); + std::map<std::string, std::string>::iterator i = table_.find(name); + if(i != table_.end()) { + table_.erase(i); } } void Option::clear() { - _table.clear(); + table_.clear(); } } // namespace aria2 diff --git a/src/Option.h b/src/Option.h index e8a04192..fdea715a 100644 --- a/src/Option.h +++ b/src/Option.h @@ -43,7 +43,7 @@ namespace aria2 { class Option { private: - std::map<std::string, std::string> _table; + std::map<std::string, std::string> table_; public: Option(); ~Option(); @@ -67,12 +67,12 @@ public: std::map<std::string, std::string>::const_iterator begin() const { - return _table.begin(); + return table_.begin(); } std::map<std::string, std::string>::const_iterator end() const { - return _table.end(); + return table_.end(); } }; diff --git a/src/OptionHandlerException.cc b/src/OptionHandlerException.cc index 6e9c8500..a8e83b35 100644 --- a/src/OptionHandlerException.cc +++ b/src/OptionHandlerException.cc @@ -44,24 +44,24 @@ OptionHandlerException::OptionHandlerException(const char* file, int line, const std::string& optName): RecoverableException (file, line, StringFormat(MESSAGE.c_str(), optName.c_str()).str()), - _optName(optName) {} + optName_(optName) {} OptionHandlerException::OptionHandlerException(const char* file, int line, const std::string& optName, const Exception& cause): RecoverableException (file, line, StringFormat(MESSAGE.c_str(), optName.c_str()).str(), cause), - _optName(optName) {} + optName_(optName) {} OptionHandlerException::OptionHandlerException(const char* file, int line, const OptionHandlerException& e): - RecoverableException(file, line, e), _optName(e._optName) {} + RecoverableException(file, line, e), optName_(e.optName_) {} OptionHandlerException::~OptionHandlerException() throw() {} const std::string& OptionHandlerException::getOptionName() const throw() { - return _optName; + return optName_; } SharedHandle<Exception> OptionHandlerException::copy() const diff --git a/src/OptionHandlerException.h b/src/OptionHandlerException.h index 88fb0596..689c1911 100644 --- a/src/OptionHandlerException.h +++ b/src/OptionHandlerException.h @@ -40,7 +40,7 @@ namespace aria2 { class OptionHandlerException:public RecoverableException { private: - std::string _optName; + std::string optName_; static const std::string MESSAGE; protected: diff --git a/src/OptionHandlerImpl.h b/src/OptionHandlerImpl.h index 1d414b25..a1d63c90 100644 --- a/src/OptionHandlerImpl.h +++ b/src/OptionHandlerImpl.h @@ -64,7 +64,7 @@ namespace aria2 { class NullOptionHandler : public OptionHandler { private: - int _id; + int id_; public: virtual ~NullOptionHandler() {} @@ -97,12 +97,12 @@ public: virtual int getOptionID() const { - return _id; + return id_; } virtual void setOptionID(int id) { - _id = id; + id_ = id; } virtual char getShortName() const @@ -126,14 +126,14 @@ public: virtual void parseArg(Option& option, const std::string& optarg) { if(optarg == "true" || - ((_argType == OptionHandler::OPT_ARG || - _argType == OptionHandler::NO_ARG) + ((argType_ == OptionHandler::OPT_ARG || + argType_ == OptionHandler::NO_ARG) && optarg.empty())) { - option.put(_optName, V_TRUE); + option.put(optName_, V_TRUE); } else if(optarg == "false") { - option.put(_optName, V_FALSE); + option.put(optName_, V_FALSE); } else { - std::string msg = _optName; + std::string msg = optName_; strappend(msg, " ", _("must be either 'true' or 'false'.")); throw DL_ABORT_EX(msg); } @@ -147,8 +147,8 @@ public: class IntegerRangeOptionHandler : public NameMatchOptionHandler { private: - int32_t _min; - int32_t _max; + int32_t min_; + int32_t max_; public: IntegerRangeOptionHandler(const std::string& optName, const std::string& description, @@ -157,7 +157,7 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _min(min), _max(max) {} + min_(min), max_(max) {} virtual ~IntegerRangeOptionHandler() {} @@ -166,27 +166,27 @@ public: IntSequence seq = util::parseIntRange(optarg); while(seq.hasNext()) { int32_t v = seq.next(); - if(v < _min || _max < v) { - std::string msg = _optName; + if(v < min_ || max_ < v) { + std::string msg = optName_; strappend(msg, " ", _("must be between %s and %s.")); throw DL_ABORT_EX - (StringFormat(msg.c_str(), util::itos(_min).c_str(), - util::itos(_max).c_str()).str()); + (StringFormat(msg.c_str(), util::itos(min_).c_str(), + util::itos(max_).c_str()).str()); } - option.put(_optName, optarg); + option.put(optName_, optarg); } } virtual std::string createPossibleValuesString() const { - return util::itos(_min)+"-"+util::itos(_max); + return util::itos(min_)+"-"+util::itos(max_); } }; class NumberOptionHandler : public NameMatchOptionHandler { private: - int64_t _min; - int64_t _max; + int64_t min_; + int64_t max_; public: NumberOptionHandler(const std::string& optName, const std::string& description = NO_DESCRIPTION, @@ -196,7 +196,7 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _min(min), _max(max) {} + min_(min), max_(max) {} virtual ~NumberOptionHandler() {} @@ -208,20 +208,20 @@ public: void parseArg(Option& option, int64_t number) { - if((_min == -1 || _min <= number) && (_max == -1 || number <= _max)) { - option.put(_optName, util::itos(number)); + if((min_ == -1 || min_ <= number) && (max_ == -1 || number <= max_)) { + option.put(optName_, util::itos(number)); } else { - std::string msg = _optName; + std::string msg = optName_; msg += " "; - if(_min == -1 && _max != -1) { + if(min_ == -1 && max_ != -1) { msg += StringFormat(_("must be smaller than or equal to %s."), - util::itos(_max).c_str()).str(); - } else if(_min != -1 && _max != -1) { + util::itos(max_).c_str()).str(); + } else if(min_ != -1 && max_ != -1) { msg += StringFormat(_("must be between %s and %s."), - util::itos(_min).c_str(), util::itos(_max).c_str()).str(); - } else if(_min != -1 && _max == -1) { + util::itos(min_).c_str(), util::itos(max_).c_str()).str(); + } else if(min_ != -1 && max_ == -1) { msg += StringFormat(_("must be greater than or equal to %s."), - util::itos(_min).c_str()).str(); + util::itos(min_).c_str()).str(); } else { msg += _("must be a number."); } @@ -232,16 +232,16 @@ public: virtual std::string createPossibleValuesString() const { std::string values; - if(_min == -1) { + if(min_ == -1) { values += "*"; } else { - values += util::itos(_min); + values += util::itos(min_); } values += "-"; - if(_max == -1) { + if(max_ == -1) { values += "*"; } else { - values += util::itos(_max); + values += util::itos(max_); } return values; } @@ -269,8 +269,8 @@ public: class FloatNumberOptionHandler : public NameMatchOptionHandler { private: - double _min; - double _max; + double min_; + double max_; public: FloatNumberOptionHandler(const std::string& optName, const std::string& description = NO_DESCRIPTION, @@ -279,27 +279,27 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _min(min), _max(max) {} + min_(min), max_(max) {} virtual ~FloatNumberOptionHandler() {} virtual void parseArg(Option& option, const std::string& optarg) { double number = strtod(optarg.c_str(), 0); - if((_min < 0 || _min <= number) && (_max < 0 || number <= _max)) { - option.put(_optName, optarg); + if((min_ < 0 || min_ <= number) && (max_ < 0 || number <= max_)) { + option.put(optName_, optarg); } else { - std::string msg = _optName; + std::string msg = optName_; msg += " "; - if(_min < 0 && _max >= 0) { + if(min_ < 0 && max_ >= 0) { msg += StringFormat(_("must be smaller than or equal to %.1f."), - _max).str(); - } else if(_min >= 0 && _max >= 0) { + max_).str(); + } else if(min_ >= 0 && max_ >= 0) { msg += StringFormat(_("must be between %.1f and %.1f."), - _min, _max).str(); - } else if(_min >= 0 && _max < 0) { + min_, max_).str(); + } else if(min_ >= 0 && max_ < 0) { msg += StringFormat(_("must be greater than or equal to %.1f."), - _min).str(); + min_).str(); } else { msg += _("must be a number."); } @@ -310,19 +310,19 @@ public: virtual std::string createPossibleValuesString() const { std::string valuesString; - if(_min < 0) { + if(min_ < 0) { valuesString += "*"; } else { char buf[11]; - snprintf(buf, sizeof(buf), "%.1f", _min); + snprintf(buf, sizeof(buf), "%.1f", min_); valuesString += buf; } valuesString += "-"; - if(_max < 0) { + if(max_ < 0) { valuesString += "*"; } else { char buf[11]; - snprintf(buf, sizeof(buf), "%.1f", _max); + snprintf(buf, sizeof(buf), "%.1f", max_); valuesString += buf; } return valuesString; @@ -331,7 +331,7 @@ public: class DefaultOptionHandler : public NameMatchOptionHandler { private: - std::string _possibleValuesString; + std::string possibleValuesString_; public: DefaultOptionHandler(const std::string& optName, const std::string& description = NO_DESCRIPTION, @@ -341,26 +341,26 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, argType, shortName), - _possibleValuesString(possibleValuesString) {} + possibleValuesString_(possibleValuesString) {} virtual ~DefaultOptionHandler() {} virtual void parseArg(Option& option, const std::string& optarg) { - option.put(_optName, optarg); + option.put(optName_, optarg); } virtual std::string createPossibleValuesString() const { - return _possibleValuesString; + return possibleValuesString_; } }; class CumulativeOptionHandler : public NameMatchOptionHandler { private: - std::string _delim; + std::string delim_; - std::string _possibleValuesString; + std::string possibleValuesString_; public: CumulativeOptionHandler(const std::string& optName, const std::string& description, @@ -372,21 +372,21 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, argType, shortName), - _delim(delim), - _possibleValuesString(possibleValuesString) {} + delim_(delim), + possibleValuesString_(possibleValuesString) {} virtual ~CumulativeOptionHandler() {} virtual void parseArg(Option& option, const std::string& optarg) { - std::string value = option.get(_optName); - strappend(value, optarg, _delim); - option.put(_optName, value); + std::string value = option.get(optName_); + strappend(value, optarg, delim_); + option.put(optName_, value); } virtual std::string createPossibleValuesString() const { - return _possibleValuesString; + return possibleValuesString_; } }; @@ -405,9 +405,9 @@ public: { // See optarg is in the fomrat of "INDEX=PATH" util::parseIndexPath(optarg); - std::string value = option.get(_optName); + std::string value = option.get(optName_); strappend(value, optarg, "\n"); - option.put(_optName, value); + option.put(optName_, value); } virtual std::string createPossibleValuesString() const @@ -418,7 +418,7 @@ public: class ParameterOptionHandler : public NameMatchOptionHandler { private: - std::vector<std::string> _validParamValues; + std::vector<std::string> validParamValues_; public: ParameterOptionHandler(const std::string& optName, const std::string& description, @@ -427,7 +427,7 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _validParamValues(validParamValues) {} + validParamValues_(validParamValues) {} ParameterOptionHandler(const std::string& optName, const std::string& description, @@ -437,7 +437,7 @@ public: NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName) { - _validParamValues.push_back(validParamValue); + validParamValues_.push_back(validParamValue); } ParameterOptionHandler(const std::string& optName, @@ -449,8 +449,8 @@ public: NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName) { - _validParamValues.push_back(validParamValue1); - _validParamValues.push_back(validParamValue2); + validParamValues_.push_back(validParamValue1); + validParamValues_.push_back(validParamValue2); } ParameterOptionHandler(const std::string& optName, @@ -463,9 +463,9 @@ public: NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName) { - _validParamValues.push_back(validParamValue1); - _validParamValues.push_back(validParamValue2); - _validParamValues.push_back(validParamValue3); + validParamValues_.push_back(validParamValue1); + validParamValues_.push_back(validParamValue2); + validParamValues_.push_back(validParamValue3); } virtual ~ParameterOptionHandler() {} @@ -473,29 +473,29 @@ public: virtual void parseArg(Option& option, const std::string& optarg) { std::vector<std::string>::const_iterator itr = - std::find(_validParamValues.begin(), _validParamValues.end(), optarg); - if(itr == _validParamValues.end()) { - std::string msg = _optName; + std::find(validParamValues_.begin(), validParamValues_.end(), optarg); + if(itr == validParamValues_.end()) { + std::string msg = optName_; strappend(msg, " ", _("must be one of the following:")); - if(_validParamValues.size() == 0) { + if(validParamValues_.size() == 0) { msg += "''"; } else { for(std::vector<std::string>::const_iterator itr = - _validParamValues.begin(), eoi = _validParamValues.end(); + validParamValues_.begin(), eoi = validParamValues_.end(); itr != eoi; ++itr) { strappend(msg, "'", *itr, "' "); } } throw DL_ABORT_EX(msg); } else { - option.put(_optName, optarg); + option.put(optName_, optarg); } } virtual std::string createPossibleValuesString() const { std::stringstream s; - std::copy(_validParamValues.begin(), _validParamValues.end(), + std::copy(validParamValues_.begin(), validParamValues_.end(), std::ostream_iterator<std::string>(s, ",")); return util::trim(s.str(), ", "); } @@ -503,9 +503,9 @@ public: class HostPortOptionHandler : public NameMatchOptionHandler { private: - std::string _hostOptionName; + std::string hostOptionName_; - std::string _portOptionName; + std::string portOptionName_; public: HostPortOptionHandler(const std::string& optName, const std::string& description, @@ -515,8 +515,8 @@ public: char shortName = 0): NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _hostOptionName(hostOptionName), - _portOptionName(portOptionName) {} + hostOptionName_(hostOptionName), + portOptionName_(portOptionName) {} virtual ~HostPortOptionHandler() {} @@ -528,14 +528,14 @@ public: port <= 0 || 65535 < port) { throw DL_ABORT_EX(_("unrecognized proxy format")); } - option.put(_optName, optarg); + option.put(optName_, optarg); setHostAndPort(option, proxy.first, port); } void setHostAndPort(Option& option, const std::string& hostname, uint16_t port) { - option.put(_hostOptionName, hostname); - option.put(_portOptionName, util::uitos(port)); + option.put(hostOptionName_, hostname); + option.put(portOptionName_, util::uitos(port)); } virtual std::string createPossibleValuesString() const @@ -556,8 +556,8 @@ public: virtual void parseArg(Option& option, const std::string& optarg) { - if(util::endsWith(_optName, "-user")) { - const std::string proxyPref = _optName.substr(0, _optName.size()-5); + if(util::endsWith(optName_, "-user")) { + const std::string proxyPref = optName_.substr(0, optName_.size()-5); const std::string& olduri = option.get(proxyPref); if(!olduri.empty()) { Request req; @@ -578,7 +578,7 @@ public: option.put(proxyPref, uri); } } - option.put(_optName, optarg); + option.put(optName_, optarg); } virtual std::string createPossibleValuesString() const @@ -599,8 +599,8 @@ public: virtual void parseArg(Option& option, const std::string& optarg) { - if(util::endsWith(_optName, "-passwd")) { - const std::string proxyPref = _optName.substr(0, _optName.size()-7); + if(util::endsWith(optName_, "-passwd")) { + const std::string proxyPref = optName_.substr(0, optName_.size()-7); const std::string& olduri = option.get(proxyPref); if(!olduri.empty()) { Request req; @@ -621,7 +621,7 @@ public: option.put(proxyPref, uri); } } - option.put(_optName, optarg); + option.put(optName_, optarg); } virtual std::string createPossibleValuesString() const @@ -632,8 +632,8 @@ public: class HttpProxyOptionHandler : public NameMatchOptionHandler { private: - std::string _proxyUserPref; - std::string _proxyPasswdPref; + std::string proxyUserPref_; + std::string proxyPasswdPref_; public: HttpProxyOptionHandler(const std::string& optName, const std::string& description, @@ -642,8 +642,8 @@ public: : NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _proxyUserPref(_optName+"-user"), - _proxyPasswdPref(_optName+"-passwd") + proxyUserPref_(optName_+"-user"), + proxyPasswdPref_(optName_+"-passwd") {} virtual ~HttpProxyOptionHandler() {} @@ -651,7 +651,7 @@ public: virtual void parseArg(Option& option, const std::string& optarg) { if(optarg.empty()) { - option.put(_optName, optarg); + option.put(optName_, optarg); } else { Request req; std::string uri; @@ -665,16 +665,16 @@ public: } uri = "http://"; if(req.getUsername().empty()) { - if(option.defined(_proxyUserPref)) { - uri += util::percentEncode(option.get(_proxyUserPref)); + if(option.defined(proxyUserPref_)) { + uri += util::percentEncode(option.get(proxyUserPref_)); } } else { uri += util::percentEncode(req.getUsername()); } if(!req.hasPassword()) { - if(option.defined(_proxyPasswdPref)) { + if(option.defined(proxyPasswdPref_)) { uri += A2STR::COLON_C; - uri += util::percentEncode(option.get(_proxyPasswdPref)); + uri += util::percentEncode(option.get(proxyPasswdPref_)); } } else { uri += A2STR::COLON_C; @@ -684,7 +684,7 @@ public: uri += "@"; } strappend(uri, req.getHost(), A2STR::COLON_C, util::uitos(req.getPort())); - option.put(_optName, uri); + option.put(optName_, uri); } } @@ -696,7 +696,7 @@ public: class LocalFilePathOptionHandler : public NameMatchOptionHandler { private: - bool _acceptStdin; + bool acceptStdin_; public: LocalFilePathOptionHandler (const std::string& optName, @@ -707,19 +707,19 @@ public: NameMatchOptionHandler(optName, description, defaultValue, OptionHandler::REQ_ARG, shortName), - _acceptStdin(acceptStdin) {} + acceptStdin_(acceptStdin) {} virtual void parseArg(Option& option, const std::string& optarg) { - if(_acceptStdin && optarg == "-") { - option.put(_optName, DEV_STDIN); + if(acceptStdin_ && optarg == "-") { + option.put(optName_, DEV_STDIN); } else { File f(optarg); if(!f.exists() || f.isDir()) { throw DL_ABORT_EX (StringFormat(MSG_NOT_FILE, optarg.c_str()).str()); } - option.put(_optName, optarg); + option.put(optName_, optarg); } } @@ -746,7 +746,7 @@ public: std::vector<size_t> result; util::parsePrioritizePieceRange (result, optarg, std::vector<SharedHandle<FileEntry> >(), 1024); - option.put(_optName, optarg); + option.put(optName_, optarg); } virtual std::string createPossibleValuesString() const diff --git a/src/OptionParser.cc b/src/OptionParser.cc index 9553ecf9..03254ac6 100644 --- a/src/OptionParser.cc +++ b/src/OptionParser.cc @@ -52,7 +52,7 @@ namespace aria2 { OptionParser::OptionParser(): - _idCounter(0) + idCounter_(0) {} template<typename InputIterator> @@ -130,13 +130,13 @@ void OptionParser::parseArg (std::ostream& out, std::vector<std::string>& nonopts, int argc, char* const argv[]) { - size_t numPublicOption = countPublicOption(_optionHandlers.begin(), - _optionHandlers.end()); + size_t numPublicOption = countPublicOption(optionHandlers_.begin(), + optionHandlers_.end()); int lopt; array_ptr<struct option> longOpts(new struct option[numPublicOption+1]); - putOptions(longOpts, &lopt,_optionHandlers.begin(),_optionHandlers.end()); - std::string optstring = createOptstring(_optionHandlers.begin(), - _optionHandlers.end()); + putOptions(longOpts, &lopt,optionHandlers_.begin(),optionHandlers_.end()); + std::string optstring = createOptstring(optionHandlers_.begin(), + optionHandlers_.end()); while(1) { int c = getopt_long(argc, argv, optstring.c_str(), longOpts, 0); if(c == -1) { @@ -195,9 +195,9 @@ OptionHandlerHandle OptionParser::getOptionHandlerByName { SharedHandle<OptionHandler> handler(new DummyOptionHandler(optName)); std::vector<SharedHandle<OptionHandler> >::const_iterator i = - std::lower_bound(_optionHandlers.begin(), _optionHandlers.end(), + std::lower_bound(optionHandlers_.begin(), optionHandlers_.end(), handler, OptionHandlerNameLesser()); - if(i != _optionHandlers.end() && (*i)->canHandle(optName)) { + if(i != optionHandlers_.end() && (*i)->canHandle(optName)) { handler = *i; } else { handler.reset(new NullOptionHandler()); @@ -208,30 +208,30 @@ OptionHandlerHandle OptionParser::getOptionHandlerByName void OptionParser::setOptionHandlers (const std::vector<SharedHandle<OptionHandler> >& optionHandlers) { - _optionHandlers = optionHandlers; + optionHandlers_ = optionHandlers; for(std::vector<SharedHandle<OptionHandler> >::const_iterator i = - _optionHandlers.begin(), eoi = _optionHandlers.end(); + optionHandlers_.begin(), eoi = optionHandlers_.end(); i != eoi; ++i) { - (*i)->setOptionID(++_idCounter); + (*i)->setOptionID(++idCounter_); } - std::sort(_optionHandlers.begin(), _optionHandlers.end(), + std::sort(optionHandlers_.begin(), optionHandlers_.end(), OptionHandlerNameLesser()); } void OptionParser::addOptionHandler (const SharedHandle<OptionHandler>& optionHandler) { - optionHandler->setOptionID(++_idCounter); + optionHandler->setOptionID(++idCounter_); std::vector<SharedHandle<OptionHandler> >::iterator i = - std::lower_bound(_optionHandlers.begin(), _optionHandlers.end(), + std::lower_bound(optionHandlers_.begin(), optionHandlers_.end(), optionHandler, OptionHandlerNameLesser()); - _optionHandlers.insert(i, optionHandler); + optionHandlers_.insert(i, optionHandler); } void OptionParser::parseDefaultValues(Option& option) const { for(std::vector<SharedHandle<OptionHandler> >::const_iterator i = - _optionHandlers.begin(), eoi = _optionHandlers.end(); + optionHandlers_.begin(), eoi = optionHandlers_.end(); i != eoi; ++i) { if(!(*i)->getDefaultValue().empty()) { (*i)->parse(option, (*i)->getDefaultValue()); @@ -242,13 +242,13 @@ void OptionParser::parseDefaultValues(Option& option) const class FindOptionHandlerByTag : public std::unary_function<SharedHandle<OptionHandler>, bool> { private: - std::string _tag; + std::string tag_; public: - FindOptionHandlerByTag(const std::string& tag):_tag(tag) {} + FindOptionHandlerByTag(const std::string& tag):tag_(tag) {} bool operator()(const SharedHandle<OptionHandler>& optionHandler) const { - return !optionHandler->isHidden() && optionHandler->hasTag(_tag); + return !optionHandler->isHidden() && optionHandler->hasTag(tag_); } }; @@ -256,7 +256,7 @@ std::vector<SharedHandle<OptionHandler> > OptionParser::findByTag(const std::string& tag) const { std::vector<SharedHandle<OptionHandler> > result; - std::remove_copy_if(_optionHandlers.begin(), _optionHandlers.end(), + std::remove_copy_if(optionHandlers_.begin(), optionHandlers_.end(), std::back_inserter(result), std::not1(FindOptionHandlerByTag(tag))); std::sort(result.begin(), result.end(), OptionHandlerIDLesser()); @@ -266,15 +266,15 @@ OptionParser::findByTag(const std::string& tag) const class FindOptionHandlerByNameSubstring : public std::unary_function<SharedHandle<OptionHandler> , bool> { private: - std::string _substring; + std::string substring_; public: FindOptionHandlerByNameSubstring - (const std::string& substring):_substring(substring) {} + (const std::string& substring):substring_(substring) {} bool operator()(const SharedHandle<OptionHandler>& optionHandler) const { return !optionHandler->isHidden() && - optionHandler->getName().find(_substring) != std::string::npos; + optionHandler->getName().find(substring_) != std::string::npos; } }; @@ -282,7 +282,7 @@ std::vector<SharedHandle<OptionHandler> > OptionParser::findByNameSubstring(const std::string& substring) const { std::vector<SharedHandle<OptionHandler> > result; - std::remove_copy_if(_optionHandlers.begin(), _optionHandlers.end(), + std::remove_copy_if(optionHandlers_.begin(), optionHandlers_.end(), std::back_inserter(result), std::not1(FindOptionHandlerByNameSubstring(substring))); std::sort(result.begin(), result.end(), OptionHandlerIDLesser()); @@ -292,7 +292,7 @@ OptionParser::findByNameSubstring(const std::string& substring) const std::vector<SharedHandle<OptionHandler> > OptionParser::findAll() const { std::vector<SharedHandle<OptionHandler> > result; - std::remove_copy_if(_optionHandlers.begin(), _optionHandlers.end(), + std::remove_copy_if(optionHandlers_.begin(), optionHandlers_.end(), std::back_inserter(result), mem_fun_sh(&OptionHandler::isHidden)); std::sort(result.begin(), result.end(), OptionHandlerIDLesser()); @@ -316,9 +316,9 @@ OptionParser::findByName(const std::string& name) const { SharedHandle<OptionHandler> handler(new DummyOptionHandler(name)); std::vector<SharedHandle<OptionHandler> >::const_iterator i = - std::lower_bound(_optionHandlers.begin(), _optionHandlers.end(), + std::lower_bound(optionHandlers_.begin(), optionHandlers_.end(), handler, OptionHandlerNameLesser()); - if(i != _optionHandlers.end() && (*i)->getName() == name && + if(i != optionHandlers_.end() && (*i)->getName() == name && !(*i)->isHidden()) { handler = *i; } else { @@ -330,52 +330,52 @@ OptionParser::findByName(const std::string& name) const class FindOptionHandlerByID:public std::unary_function <SharedHandle<OptionHandler>, bool> { private: - int _id; + int id_; public: - FindOptionHandlerByID(int id):_id(id) {} + FindOptionHandlerByID(int id):id_(id) {} bool operator()(const SharedHandle<OptionHandler>& optionHandler) const { - return !optionHandler->isHidden() && optionHandler->getOptionID() == _id; + return !optionHandler->isHidden() && optionHandler->getOptionID() == id_; } }; SharedHandle<OptionHandler> OptionParser::findByID(int id) const { - return findOptionHandler(_optionHandlers.begin(), _optionHandlers.end(), + return findOptionHandler(optionHandlers_.begin(), optionHandlers_.end(), FindOptionHandlerByID(id)); } class FindOptionHandlerByShortName: public std::unary_function<SharedHandle<OptionHandler>, bool> { private: - char _shortName; + char shortName_; public: - FindOptionHandlerByShortName(char shortName):_shortName(shortName) {} + FindOptionHandlerByShortName(char shortName):shortName_(shortName) {} bool operator()(const SharedHandle<OptionHandler>& optionHandler) const { return !optionHandler->isHidden() && - optionHandler->getShortName() == _shortName; + optionHandler->getShortName() == shortName_; } }; SharedHandle<OptionHandler> OptionParser::findByShortName(char shortName) const { - return findOptionHandler(_optionHandlers.begin(), _optionHandlers.end(), + return findOptionHandler(optionHandlers_.begin(), optionHandlers_.end(), FindOptionHandlerByShortName(shortName)); } -SharedHandle<OptionParser> OptionParser::_optionParser; +SharedHandle<OptionParser> OptionParser::optionParser_; const SharedHandle<OptionParser>& OptionParser::getInstance() { - if(_optionParser.isNull()) { - _optionParser.reset(new OptionParser()); - _optionParser->setOptionHandlers(OptionHandlerFactory::createOptionHandlers()); + if(optionParser_.isNull()) { + optionParser_.reset(new OptionParser()); + optionParser_->setOptionHandlers(OptionHandlerFactory::createOptionHandlers()); } - return _optionParser; + return optionParser_; } } // namespace aria2 diff --git a/src/OptionParser.h b/src/OptionParser.h index 1abf7167..6ef579e1 100644 --- a/src/OptionParser.h +++ b/src/OptionParser.h @@ -50,16 +50,16 @@ class OptionHandler; class OptionParser { private: - int _idCounter; + int idCounter_; - // _optionHandlers is sorted by OptionHandler::getName() in + // optionHandlers_ is sorted by OptionHandler::getName() in // ascending order. - std::vector<SharedHandle<OptionHandler> > _optionHandlers; + std::vector<SharedHandle<OptionHandler> > optionHandlers_; SharedHandle<OptionHandler> getOptionHandlerByName(const std::string& optName); - static SharedHandle<OptionParser> _optionParser; + static SharedHandle<OptionParser> optionParser_; public: OptionParser(); diff --git a/src/PStringBuildVisitor.cc b/src/PStringBuildVisitor.cc index 599a0e86..68c57671 100644 --- a/src/PStringBuildVisitor.cc +++ b/src/PStringBuildVisitor.cc @@ -43,22 +43,22 @@ namespace aria2 { void PStringBuildVisitor::visit(PStringSegment& segment) { std::string uri; - if(_buildQueue.empty()) { + if(buildQueue_.empty()) { uri += segment.getValue(); } else { - uri = _buildQueue.front(); + uri = buildQueue_.front(); uri += segment.getValue(); } - _buildQueue.push_front(uri); + buildQueue_.push_front(uri); if(!segment.hasNext()) { - _uris.push_back(uri); + uris_.push_back(uri); } if(!segment.getNext().isNull()) { segment.getNext()->accept(*this); } - _buildQueue.pop_front(); + buildQueue_.pop_front(); } void PStringBuildVisitor::visit(PStringNumLoop& s) @@ -83,13 +83,13 @@ void PStringBuildVisitor::visit(PStringSelect& s) const std::vector<std::string>& PStringBuildVisitor::getURIs() const { - return _uris; + return uris_; } void PStringBuildVisitor::reset() { - _buildQueue.clear(); - _uris.clear(); + buildQueue_.clear(); + uris_.clear(); } } // namespace aria2 diff --git a/src/PStringBuildVisitor.h b/src/PStringBuildVisitor.h index 687237cd..37e5e82e 100644 --- a/src/PStringBuildVisitor.h +++ b/src/PStringBuildVisitor.h @@ -49,9 +49,9 @@ class PStringBuildVisitor : public PStringVisitor { private: - std::deque<std::string> _buildQueue; + std::deque<std::string> buildQueue_; - std::vector<std::string> _uris; + std::vector<std::string> uris_; public: virtual void visit(PStringSegment& s); diff --git a/src/PStringNumLoop.h b/src/PStringNumLoop.h index c7456764..d7694646 100644 --- a/src/PStringNumLoop.h +++ b/src/PStringNumLoop.h @@ -46,34 +46,34 @@ class PStringNumLoop : public PStringDatum { private: - unsigned int _startValue; + unsigned int startValue_; - unsigned int _endValue; + unsigned int endValue_; - unsigned int _step; + unsigned int step_; - SharedHandle<NumberDecorator> _numberDecorator; + SharedHandle<NumberDecorator> numberDecorator_; - SharedHandle<PStringDatum> _next; + SharedHandle<PStringDatum> next_; public: PStringNumLoop(unsigned int startValue, unsigned int endValue, unsigned int step, const SharedHandle<NumberDecorator>& nd, const SharedHandle<PStringDatum>& next): - _startValue(startValue), - _endValue(endValue), - _step(step), - _numberDecorator(nd), - _next(next) {} + startValue_(startValue), + endValue_(endValue), + step_(step), + numberDecorator_(nd), + next_(next) {} PStringNumLoop(unsigned int startValue, unsigned int endValue, unsigned int step, const SharedHandle<NumberDecorator>& nd): - _startValue(startValue), - _endValue(endValue), - _step(step), - _numberDecorator(nd) {} + startValue_(startValue), + endValue_(endValue), + step_(step), + numberDecorator_(nd) {} virtual ~PStringNumLoop() {} @@ -84,27 +84,27 @@ public: const SharedHandle<NumberDecorator>& getNumberDecorator() const { - return _numberDecorator; + return numberDecorator_; } SharedHandle<PStringDatum> getNext() const { - return _next; + return next_; } unsigned int getStartValue() const { - return _startValue; + return startValue_; } unsigned int getEndValue() const { - return _endValue; + return endValue_; } unsigned int getStep() const { - return _step; + return step_; } }; diff --git a/src/PStringSegment.cc b/src/PStringSegment.cc index 84fcab02..a08df34f 100644 --- a/src/PStringSegment.cc +++ b/src/PStringSegment.cc @@ -39,10 +39,10 @@ namespace aria2 { PStringSegment::PStringSegment(const std::string& value, const SharedHandle<PStringDatum>& next): - _value(value), _next(next) {} + value_(value), next_(next) {} PStringSegment::PStringSegment(const std::string& value): - _value(value) {} + value_(value) {} PStringSegment::~PStringSegment() {} @@ -53,17 +53,17 @@ void PStringSegment::accept(PStringVisitor& visitor) const std::string& PStringSegment::getValue() const { - return _value; + return value_; } bool PStringSegment::hasNext() const { - return !_next.isNull(); + return !next_.isNull(); } SharedHandle<PStringDatum> PStringSegment::getNext() const { - return _next; + return next_; } } // namespace aria2 diff --git a/src/PStringSegment.h b/src/PStringSegment.h index 99d58da5..3ee8df17 100644 --- a/src/PStringSegment.h +++ b/src/PStringSegment.h @@ -44,9 +44,9 @@ class PStringSegment : public PStringDatum { private: - std::string _value; + std::string value_; - SharedHandle<PStringDatum> _next; + SharedHandle<PStringDatum> next_; public: PStringSegment(const std::string& value, diff --git a/src/PStringSelect.h b/src/PStringSelect.h index 0cf40750..d27d4c41 100644 --- a/src/PStringSelect.h +++ b/src/PStringSelect.h @@ -45,18 +45,18 @@ class PStringSelect : public PStringDatum { private: - std::vector<std::string> _values; + std::vector<std::string> values_; - SharedHandle<PStringDatum> _next; + SharedHandle<PStringDatum> next_; public: PStringSelect(const std::vector<std::string>& values, const SharedHandle<PStringDatum>& next): - _values(values), - _next(next) {} + values_(values), + next_(next) {} PStringSelect(const std::vector<std::string>& values): - _values(values) {} + values_(values) {} virtual ~PStringSelect() {} @@ -67,12 +67,12 @@ public: const std::vector<std::string>& getValues() const { - return _values; + return values_; } SharedHandle<PStringDatum> getNext() const { - return _next; + return next_; } }; diff --git a/src/Peer.cc b/src/Peer.cc index ae385123..8955d4e3 100644 --- a/src/Peer.cc +++ b/src/Peer.cc @@ -48,19 +48,19 @@ namespace aria2 { #define BAD_CONDITION_INTERVAL 10 Peer::Peer(std::string ipaddr, uint16_t port, bool incoming): - _ipaddr(ipaddr), - _port(port), - _firstContactTime(global::wallclock), - _badConditionStartTime(0), - _seeder(false), - _res(0), - _incoming(incoming), - _localPeer(false) -{ - memset(_peerId, 0, PEER_ID_LENGTH); + ipaddr_(ipaddr), + port_(port), + firstContactTime_(global::wallclock), + badConditionStartTime_(0), + seeder_(false), + res_(0), + incoming_(incoming), + localPeer_(false) +{ + memset(peerId_, 0, PEER_ID_LENGTH); resetStatus(); - _id = _ipaddr; - strappend(_id, A2STR::COLON_C, util::uitos(_port)); + id_ = ipaddr_; + strappend(id_, A2STR::COLON_C, util::uitos(port_)); } Peer::~Peer() @@ -70,345 +70,345 @@ Peer::~Peer() void Peer::usedBy(cuid_t cuid) { - _cuid = cuid; + cuid_ = cuid; } void Peer::allocateSessionResource(size_t pieceLength, uint64_t totalLength) { - delete _res; - _res = new PeerSessionResource(pieceLength, totalLength); - _res->getPeerStat().downloadStart(); + delete res_; + res_ = new PeerSessionResource(pieceLength, totalLength); + res_->getPeerStat().downloadStart(); } void Peer::releaseSessionResource() { - delete _res; - _res = 0; + delete res_; + res_ = 0; } void Peer::setPeerId(const unsigned char* peerId) { - memcpy(_peerId, peerId, PEER_ID_LENGTH); + memcpy(peerId_, peerId, PEER_ID_LENGTH); } void Peer::resetStatus() { - _cuid = 0; + cuid_ = 0; } bool Peer::amChoking() const { - assert(_res); - return _res->amChoking(); + assert(res_); + return res_->amChoking(); } void Peer::amChoking(bool b) const { - assert(_res); - _res->amChoking(b); + assert(res_); + res_->amChoking(b); } // localhost is interested in this peer bool Peer::amInterested() const { - assert(_res); - return _res->amInterested(); + assert(res_); + return res_->amInterested(); } void Peer::amInterested(bool b) const { - assert(_res); - _res->amInterested(b); + assert(res_); + res_->amInterested(b); } // this peer is choking localhost bool Peer::peerChoking() const { - assert(_res); - return _res->peerChoking(); + assert(res_); + return res_->peerChoking(); } void Peer::peerChoking(bool b) const { - assert(_res); - _res->peerChoking(b); + assert(res_); + res_->peerChoking(b); } // this peer is interested in localhost bool Peer::peerInterested() const { - assert(_res); - return _res->peerInterested(); + assert(res_); + return res_->peerInterested(); } void Peer::peerInterested(bool b) { - assert(_res); - _res->peerInterested(b); + assert(res_); + res_->peerInterested(b); } // this peer should be choked bool Peer::chokingRequired() const { - assert(_res); - return _res->chokingRequired(); + assert(res_); + return res_->chokingRequired(); } void Peer::chokingRequired(bool b) { - assert(_res); - _res->chokingRequired(b); + assert(res_); + res_->chokingRequired(b); } // this peer is eligible for unchoking optionally. bool Peer::optUnchoking() const { - assert(_res); - return _res->optUnchoking(); + assert(res_); + return res_->optUnchoking(); } void Peer::optUnchoking(bool b) { - assert(_res); - _res->optUnchoking(b); + assert(res_); + res_->optUnchoking(b); } // this peer is snubbing. bool Peer::snubbing() const { - assert(_res); - return _res->snubbing(); + assert(res_); + return res_->snubbing(); } void Peer::snubbing(bool b) { - assert(_res); - _res->snubbing(b); + assert(res_); + res_->snubbing(b); } void Peer::updateUploadLength(size_t bytes) { - assert(_res); - _res->updateUploadLength(bytes); + assert(res_); + res_->updateUploadLength(bytes); } void Peer::updateDownloadLength(size_t bytes) { - assert(_res); - _res->updateDownloadLength(bytes); + assert(res_); + res_->updateDownloadLength(bytes); } void Peer::updateSeeder() { - assert(_res); - if(_res->hasAllPieces()) { - _seeder = true; + assert(res_); + if(res_->hasAllPieces()) { + seeder_ = true; } } void Peer::updateBitfield(size_t index, int operation) { - assert(_res); - _res->updateBitfield(index, operation); + assert(res_); + res_->updateBitfield(index, operation); updateSeeder(); } unsigned int Peer::calculateUploadSpeed() { - assert(_res); - return _res->getPeerStat().calculateUploadSpeed(); + assert(res_); + return res_->getPeerStat().calculateUploadSpeed(); } unsigned int Peer::calculateDownloadSpeed() { - assert(_res); - return _res->getPeerStat().calculateDownloadSpeed(); + assert(res_); + return res_->getPeerStat().calculateDownloadSpeed(); } uint64_t Peer::getSessionUploadLength() const { - assert(_res); - return _res->uploadLength(); + assert(res_); + return res_->uploadLength(); } uint64_t Peer::getSessionDownloadLength() const { - assert(_res); - return _res->downloadLength(); + assert(res_); + return res_->downloadLength(); } void Peer::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) { - assert(_res); - _res->setBitfield(bitfield, bitfieldLength); + assert(res_); + res_->setBitfield(bitfield, bitfieldLength); updateSeeder(); } const unsigned char* Peer::getBitfield() const { - assert(_res); - return _res->getBitfield(); + assert(res_); + return res_->getBitfield(); } size_t Peer::getBitfieldLength() const { - assert(_res); - return _res->getBitfieldLength(); + assert(res_); + return res_->getBitfieldLength(); } bool Peer::shouldBeChoking() const { - assert(_res); - return _res->shouldBeChoking(); + assert(res_); + return res_->shouldBeChoking(); } bool Peer::hasPiece(size_t index) const { - assert(_res); - return _res->hasPiece(index); + assert(res_); + return res_->hasPiece(index); } void Peer::setFastExtensionEnabled(bool enabled) { - assert(_res); - return _res->fastExtensionEnabled(enabled); + assert(res_); + return res_->fastExtensionEnabled(enabled); } bool Peer::isFastExtensionEnabled() const { - assert(_res); - return _res->fastExtensionEnabled(); + assert(res_); + return res_->fastExtensionEnabled(); } size_t Peer::countPeerAllowedIndexSet() const { - assert(_res); - return _res->peerAllowedIndexSet().size(); + assert(res_); + return res_->peerAllowedIndexSet().size(); } const std::vector<size_t>& Peer::getPeerAllowedIndexSet() const { - assert(_res); - return _res->peerAllowedIndexSet(); + assert(res_); + return res_->peerAllowedIndexSet(); } bool Peer::isInPeerAllowedIndexSet(size_t index) const { - assert(_res); - return _res->peerAllowedIndexSetContains(index); + assert(res_); + return res_->peerAllowedIndexSetContains(index); } void Peer::addPeerAllowedIndex(size_t index) { - assert(_res); - _res->addPeerAllowedIndex(index); + assert(res_); + res_->addPeerAllowedIndex(index); } bool Peer::isInAmAllowedIndexSet(size_t index) const { - assert(_res); - return _res->amAllowedIndexSetContains(index); + assert(res_); + return res_->amAllowedIndexSetContains(index); } void Peer::addAmAllowedIndex(size_t index) { - assert(_res); - _res->addAmAllowedIndex(index); + assert(res_); + res_->addAmAllowedIndex(index); } void Peer::setAllBitfield() { - assert(_res); - _res->markSeeder(); - _seeder = true; + assert(res_); + res_->markSeeder(); + seeder_ = true; } void Peer::startBadCondition() { - _badConditionStartTime = global::wallclock; + badConditionStartTime_ = global::wallclock; } bool Peer::isGood() const { - return _badConditionStartTime. + return badConditionStartTime_. difference(global::wallclock) >= BAD_CONDITION_INTERVAL; } uint8_t Peer::getExtensionMessageID(const std::string& name) const { - assert(_res); - return _res->getExtensionMessageID(name); + assert(res_); + return res_->getExtensionMessageID(name); } std::string Peer::getExtensionName(uint8_t id) const { - assert(_res); - return _res->getExtensionName(id); + assert(res_); + return res_->getExtensionName(id); } void Peer::setExtension(const std::string& name, uint8_t id) { - assert(_res); - _res->addExtension(name, id); + assert(res_); + res_->addExtension(name, id); } void Peer::setExtendedMessagingEnabled(bool enabled) { - assert(_res); - _res->extendedMessagingEnabled(enabled); + assert(res_); + res_->extendedMessagingEnabled(enabled); } bool Peer::isExtendedMessagingEnabled() const { - assert(_res); - return _res->extendedMessagingEnabled(); + assert(res_); + return res_->extendedMessagingEnabled(); } void Peer::setDHTEnabled(bool enabled) { - assert(_res); - _res->dhtEnabled(enabled); + assert(res_); + res_->dhtEnabled(enabled); } bool Peer::isDHTEnabled() const { - assert(_res); - return _res->dhtEnabled(); + assert(res_); + return res_->dhtEnabled(); } const Timer& Peer::getLastDownloadUpdate() const { - assert(_res); - return _res->getLastDownloadUpdate(); + assert(res_); + return res_->getLastDownloadUpdate(); } const Timer& Peer::getLastAmUnchoking() const { - assert(_res); - return _res->getLastAmUnchoking(); + assert(res_); + return res_->getLastAmUnchoking(); } uint64_t Peer::getCompletedLength() const { - assert(_res); - return _res->getCompletedLength(); + assert(res_); + return res_->getCompletedLength(); } void Peer::setIncomingPeer(bool incoming) { - _incoming = incoming; + incoming_ = incoming; } void Peer::setFirstContactTime(const Timer& time) { - _firstContactTime = time; + firstContactTime_ = time; } void Peer::setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dpt) { - assert(_res); - _res->setBtMessageDispatcher(dpt); + assert(res_); + res_->setBtMessageDispatcher(dpt); } size_t Peer::countOutstandingUpload() const { - assert(_res); - return _res->countOutstandingUpload(); + assert(res_); + return res_->countOutstandingUpload(); } } // namespace aria2 @@ -56,34 +56,34 @@ class BtMessageDispatcher; class Peer { private: - std::string _ipaddr; - // TCP port of the other end of communication. If _incoming is + std::string ipaddr_; + // TCP port of the other end of communication. If incoming_ is // true, then this port is not a port the peer is listening to and // we cannot connect to it. - uint16_t _port; + uint16_t port_; - std::string _id; + std::string id_; - cuid_t _cuid; + cuid_t cuid_; - unsigned char _peerId[PEER_ID_LENGTH]; + unsigned char peerId_[PEER_ID_LENGTH]; - Timer _firstContactTime; + Timer firstContactTime_; - Timer _badConditionStartTime; + Timer badConditionStartTime_; - bool _seeder; + bool seeder_; - PeerSessionResource* _res; + PeerSessionResource* res_; // If true, port is assumed not to be a listening port. - bool _incoming; + bool incoming_; // If true, this peer is from local network. - bool _localPeer; + bool localPeer_; // Before calling updateSeeder(), make sure that - // allocateSessionResource() is called and _res is created. + // allocateSessionResource() is called and res_ is created. // Otherwise assertion fails. void updateSeeder(); public: @@ -93,7 +93,7 @@ public: bool operator==(const Peer& p) { - return _id == p._id; + return id_ == p.id_; } bool operator!=(const Peer& p) @@ -105,52 +105,52 @@ public: const std::string& getIPAddress() const { - return _ipaddr; + return ipaddr_; } uint16_t getPort() const { - return _port; + return port_; } void setPort(uint16_t port) { - _port = port; + port_ = port; } void usedBy(cuid_t cuid); cuid_t usedBy() const { - return _cuid; + return cuid_; } bool unused() const { - return _cuid == 0; + return cuid_ == 0; } - // Returns true iff _res != 0. + // Returns true iff res_ != 0. bool isActive() const { - return _res != 0; + return res_ != 0; } void setPeerId(const unsigned char* peerId); const unsigned char* getPeerId() const { - return _peerId; + return peerId_; } bool isSeeder() const { - return _seeder; + return seeder_; } const std::string& getID() const { - return _id; + return id_; } void startBadCondition(); @@ -163,18 +163,18 @@ public: const Timer& getFirstContactTime() const { - return _firstContactTime; + return firstContactTime_; } void setFirstContactTime(const Timer& time); const Timer& getBadConditionStartTime() const { - return _badConditionStartTime; + return badConditionStartTime_; } // Before calling following member functions, make sure that - // allocateSessionResource() is called and _res is created. + // allocateSessionResource() is called and res_ is created. // Otherwise assertion fails. // localhost is choking this peer @@ -292,19 +292,19 @@ public: bool isIncomingPeer() const { - return _incoming; + return incoming_; } void setIncomingPeer(bool incoming); bool isLocalPeer() const { - return _localPeer; + return localPeer_; } void setLocalPeer(bool flag) { - _localPeer = flag; + localPeer_ = flag; } void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& dpt); diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc index 3fb27c66..4a663839 100644 --- a/src/PeerAbstractCommand.cc +++ b/src/PeerAbstractCommand.cc @@ -58,18 +58,18 @@ PeerAbstractCommand::PeerAbstractCommand(cuid_t cuid, DownloadEngine* e, const SocketHandle& s): Command(cuid), - _checkPoint(global::wallclock), + checkPoint_(global::wallclock), // TODO referring global option - _timeout(e->getOption()->getAsInt(PREF_BT_TIMEOUT)), - _e(e), - _socket(s), - _peer(peer), - _checkSocketIsReadable(false), - _checkSocketIsWritable(false), - _noCheck(false) + timeout_(e->getOption()->getAsInt(PREF_BT_TIMEOUT)), + e_(e), + socket_(s), + peer_(peer), + checkSocketIsReadable_(false), + checkSocketIsWritable_(false), + noCheck_(false) { - if(!_socket.isNull() && _socket->isOpen()) { - setReadCheckSocket(_socket); + if(!socket_.isNull() && socket_->isOpen()) { + setReadCheckSocket(socket_); } } @@ -87,24 +87,24 @@ bool PeerAbstractCommand::execute() util::itos(getCuid()).c_str(), readEventEnabled(), writeEventEnabled(), hupEventEnabled(), errorEventEnabled(), - _noCheck); + noCheck_); } if(exitBeforeExecute()) { onAbort(); return true; } try { - if(_noCheck || - (_checkSocketIsReadable && readEventEnabled()) || - (_checkSocketIsWritable && writeEventEnabled()) || + if(noCheck_ || + (checkSocketIsReadable_ && readEventEnabled()) || + (checkSocketIsWritable_ && writeEventEnabled()) || hupEventEnabled()) { - _checkPoint = global::wallclock; + checkPoint_ = global::wallclock; } else if(errorEventEnabled()) { throw DL_ABORT_EX (StringFormat(MSG_NETWORK_PROBLEM, - _socket->getSocketError().c_str()).str()); + socket_->getSocketError().c_str()).str()); } - if(_checkPoint.difference(global::wallclock) >= _timeout) { + if(checkPoint_.difference(global::wallclock) >= timeout_) { throw DL_ABORT_EX(EX_TIME_OUT); } return executeInternal(); @@ -119,8 +119,8 @@ bool PeerAbstractCommand::execute() util::itos(getCuid()).c_str()); getLogger()->debug(MSG_PEER_BANNED, util::itos(getCuid()).c_str(), - _peer->getIPAddress().c_str(), - _peer->getPort()); + peer_->getIPAddress().c_str(), + peer_->getPort()); } onAbort(); return prepareForNextPeer(0); @@ -135,10 +135,10 @@ bool PeerAbstractCommand::prepareForNextPeer(time_t wait) void PeerAbstractCommand::disableReadCheckSocket() { - if(_checkSocketIsReadable) { - _e->deleteSocketForReadCheck(_readCheckTarget, this); - _checkSocketIsReadable = false; - _readCheckTarget.reset(); + if(checkSocketIsReadable_) { + e_->deleteSocketForReadCheck(readCheckTarget_, this); + checkSocketIsReadable_ = false; + readCheckTarget_.reset(); } } @@ -147,26 +147,26 @@ void PeerAbstractCommand::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; } } } void PeerAbstractCommand::disableWriteCheckSocket() { - if(_checkSocketIsWritable) { - _e->deleteSocketForWriteCheck(_writeCheckTarget, this); - _checkSocketIsWritable = false; - _writeCheckTarget.reset(); + if(checkSocketIsWritable_) { + e_->deleteSocketForWriteCheck(writeCheckTarget_, this); + checkSocketIsWritable_ = false; + writeCheckTarget_.reset(); } } @@ -175,33 +175,33 @@ void PeerAbstractCommand::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; } } } void PeerAbstractCommand::setNoCheck(bool check) { - _noCheck = check; + noCheck_ = check; } void PeerAbstractCommand::updateKeepAlive() { - _checkPoint = global::wallclock; + checkPoint_ = global::wallclock; } void PeerAbstractCommand::createSocket() { - _socket.reset(new SocketCore()); + socket_.reset(new SocketCore()); } } // namespace aria2 diff --git a/src/PeerAbstractCommand.h b/src/PeerAbstractCommand.h index 19bf455f..a3cb6aa7 100644 --- a/src/PeerAbstractCommand.h +++ b/src/PeerAbstractCommand.h @@ -48,36 +48,36 @@ class SocketCore; class PeerAbstractCommand : public Command { private: - Timer _checkPoint; - time_t _timeout; - DownloadEngine* _e; - SharedHandle<SocketCore> _socket; - SharedHandle<Peer> _peer; + Timer checkPoint_; + time_t timeout_; + DownloadEngine* e_; + SharedHandle<SocketCore> socket_; + SharedHandle<Peer> peer_; - bool _checkSocketIsReadable; - bool _checkSocketIsWritable; - SharedHandle<SocketCore> _readCheckTarget; - SharedHandle<SocketCore> _writeCheckTarget; - bool _noCheck; + bool checkSocketIsReadable_; + bool checkSocketIsWritable_; + SharedHandle<SocketCore> readCheckTarget_; + SharedHandle<SocketCore> writeCheckTarget_; + bool noCheck_; protected: DownloadEngine* getDownloadEngine() const { - return _e; + return e_; } const SharedHandle<SocketCore>& getSocket() const { - return _socket; + return socket_; } void createSocket(); const SharedHandle<Peer>& getPeer() const { - return _peer; + return peer_; } - void setTimeout(time_t timeout) { _timeout = timeout; } + void setTimeout(time_t timeout) { timeout_ = timeout; } virtual bool prepareForNextPeer(time_t wait); virtual void onAbort() {}; // This function is called when DownloadFailureException is caught right after diff --git a/src/PeerAddrEntry.h b/src/PeerAddrEntry.h index 8bc146e3..e539e6d9 100644 --- a/src/PeerAddrEntry.h +++ b/src/PeerAddrEntry.h @@ -45,39 +45,39 @@ namespace aria2 { class PeerAddrEntry { private: - std::string _ipaddr; + std::string ipaddr_; - uint16_t _port; + uint16_t port_; - Timer _lastUpdated; + Timer lastUpdated_; public: PeerAddrEntry (const std::string& ipaddr, uint16_t port, Timer updated = Timer()): - _ipaddr(ipaddr), _port(port), _lastUpdated(updated) {} + ipaddr_(ipaddr), port_(port), lastUpdated_(updated) {} const std::string& getIPAddress() const { - return _ipaddr; + return ipaddr_; } uint16_t getPort() const { - return _port; + return port_; } const Timer& getLastUpdated() const { - return _lastUpdated; + return lastUpdated_; } void notifyUpdate() { - _lastUpdated.reset(); + lastUpdated_.reset(); } bool operator==(const PeerAddrEntry& entry) const { - return _ipaddr == entry._ipaddr && _port == entry._port; + return ipaddr_ == entry.ipaddr_ && port_ == entry.port_; } }; diff --git a/src/PeerChokeCommand.cc b/src/PeerChokeCommand.cc index fa9b0777..a266df2e 100644 --- a/src/PeerChokeCommand.cc +++ b/src/PeerChokeCommand.cc @@ -47,31 +47,31 @@ namespace aria2 { PeerChokeCommand::PeerChokeCommand(cuid_t cuid, DownloadEngine* e): Command(cuid), - _e(e) {} + e_(e) {} PeerChokeCommand::~PeerChokeCommand() {} bool PeerChokeCommand::execute() { - if(_btRuntime->isHalt()) { + if(btRuntime_->isHalt()) { return true; } - if(_peerStorage->chokeRoundIntervalElapsed()) { - _peerStorage->executeChoke(); + if(peerStorage_->chokeRoundIntervalElapsed()) { + peerStorage_->executeChoke(); } - _e->addCommand(this); + e_->addCommand(this); return false; } void PeerChokeCommand::setBtRuntime (const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void PeerChokeCommand::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } } // namespace aria2 diff --git a/src/PeerChokeCommand.h b/src/PeerChokeCommand.h index 2a99e1e5..a6e2a70c 100644 --- a/src/PeerChokeCommand.h +++ b/src/PeerChokeCommand.h @@ -46,11 +46,11 @@ class PeerStorage; class PeerChokeCommand : public Command { private: - DownloadEngine* _e; + DownloadEngine* e_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; public: PeerChokeCommand(cuid_t cuid, DownloadEngine* e); diff --git a/src/PeerConnection.cc b/src/PeerConnection.cc index 16b4f8ec..51ac9998 100644 --- a/src/PeerConnection.cc +++ b/src/PeerConnection.cc @@ -54,177 +54,177 @@ namespace aria2 { PeerConnection::PeerConnection(cuid_t cuid, const SocketHandle& socket) - :_cuid(cuid), - _socket(socket), - _logger(LogFactory::getInstance()), - _resbuf(new unsigned char[MAX_PAYLOAD_LEN]), - _resbufLength(0), - _currentPayloadLength(0), - _lenbufLength(0), - _socketBuffer(socket), - _encryptionEnabled(false), - _prevPeek(false) + :cuid_(cuid), + socket_(socket), + logger_(LogFactory::getInstance()), + resbuf_(new unsigned char[MAX_PAYLOAD_LEN]), + resbufLength_(0), + currentPayloadLength_(0), + lenbufLength_(0), + socketBuffer_(socket), + encryptionEnabled_(false), + prevPeek_(false) {} PeerConnection::~PeerConnection() { - delete [] _resbuf; + delete [] resbuf_; } void PeerConnection::pushStr(const std::string& data) { - if(_encryptionEnabled) { + if(encryptionEnabled_) { const size_t len = data.size(); unsigned char* chunk = new unsigned char[len]; try { - _encryptor->encrypt + encryptor_->encrypt (chunk, len, reinterpret_cast<const unsigned char*>(data.data()), len); } catch(RecoverableException& e) { delete [] chunk; throw; } - _socketBuffer.pushBytes(chunk, len); + socketBuffer_.pushBytes(chunk, len); } else { - _socketBuffer.pushStr(data); + socketBuffer_.pushStr(data); } } void PeerConnection::pushBytes(unsigned char* data, size_t len) { - if(_encryptionEnabled) { + if(encryptionEnabled_) { unsigned char* chunk = new unsigned char[len]; try { - _encryptor->encrypt(chunk, len, data, len); + encryptor_->encrypt(chunk, len, data, len); } catch(RecoverableException& e) { delete [] data; delete [] chunk; throw; } delete [] data; - _socketBuffer.pushBytes(chunk, len); + socketBuffer_.pushBytes(chunk, len); } else { - _socketBuffer.pushBytes(data, len); + socketBuffer_.pushBytes(data, len); } } bool PeerConnection::receiveMessage(unsigned char* data, size_t& dataLength) { - if(_resbufLength == 0 && 4 > _lenbufLength) { - if(!_socket->isReadable(0)) { + if(resbufLength_ == 0 && 4 > lenbufLength_) { + if(!socket_->isReadable(0)) { return false; } // read payload size, 32bit unsigned integer - size_t remaining = 4-_lenbufLength; + size_t remaining = 4-lenbufLength_; size_t temp = remaining; - readData(_lenbuf+_lenbufLength, remaining, _encryptionEnabled); + readData(lenbuf_+lenbufLength_, remaining, encryptionEnabled_); if(remaining == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return false; } // we got EOF - if(_logger->debug()) { - _logger->debug("CUID#%s - In PeerConnection::receiveMessage()," + if(logger_->debug()) { + logger_->debug("CUID#%s - In PeerConnection::receiveMessage()," " remain=%lu", - util::itos(_cuid).c_str(), + util::itos(cuid_).c_str(), static_cast<unsigned long>(temp)); } throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _lenbufLength += remaining; - if(4 > _lenbufLength) { - // still 4-_lenbufLength bytes to go + lenbufLength_ += remaining; + if(4 > lenbufLength_) { + // still 4-lenbufLength_ bytes to go return false; } uint32_t payloadLength; - memcpy(&payloadLength, _lenbuf, sizeof(payloadLength)); + memcpy(&payloadLength, lenbuf_, sizeof(payloadLength)); payloadLength = ntohl(payloadLength); if(payloadLength > MAX_PAYLOAD_LEN) { throw DL_ABORT_EX(StringFormat(EX_TOO_LONG_PAYLOAD, payloadLength).str()); } - _currentPayloadLength = payloadLength; + currentPayloadLength_ = payloadLength; } - if(!_socket->isReadable(0)) { + if(!socket_->isReadable(0)) { return false; } // we have currentPayloadLen-resbufLen bytes to read - size_t remaining = _currentPayloadLength-_resbufLength; + size_t remaining = currentPayloadLength_-resbufLength_; size_t temp = remaining; if(remaining > 0) { - readData(_resbuf+_resbufLength, remaining, _encryptionEnabled); + readData(resbuf_+resbufLength_, remaining, encryptionEnabled_); if(remaining == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return false; } // we got EOF - if(_logger->debug()) { - _logger->debug("CUID#%s - In PeerConnection::receiveMessage()," + if(logger_->debug()) { + logger_->debug("CUID#%s - In PeerConnection::receiveMessage()," " payloadlen=%lu, remaining=%lu", - util::itos(_cuid).c_str(), - static_cast<unsigned long>(_currentPayloadLength), + util::itos(cuid_).c_str(), + static_cast<unsigned long>(currentPayloadLength_), static_cast<unsigned long>(temp)); } throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _resbufLength += remaining; - if(_currentPayloadLength > _resbufLength) { + resbufLength_ += remaining; + if(currentPayloadLength_ > resbufLength_) { return false; } } // we got whole payload. - _resbufLength = 0; - _lenbufLength = 0; + resbufLength_ = 0; + lenbufLength_ = 0; if(data) { - memcpy(data, _resbuf, _currentPayloadLength); + memcpy(data, resbuf_, currentPayloadLength_); } - dataLength = _currentPayloadLength; + dataLength = currentPayloadLength_; return true; } bool PeerConnection::receiveHandshake(unsigned char* data, size_t& dataLength, bool peek) { - assert(BtHandshakeMessage::MESSAGE_LENGTH >= _resbufLength); + assert(BtHandshakeMessage::MESSAGE_LENGTH >= resbufLength_); bool retval = true; - if(_prevPeek && !peek && _resbufLength) { + if(prevPeek_ && !peek && resbufLength_) { // We have data in previous peek. // There is a chance that socket is readable because of EOF, for example, // official bttrack shutdowns socket after sending first 48 bytes of // handshake in its NAT checking. - // So if there are data in _resbuf, return it without checking socket + // So if there are data in resbuf_, return it without checking socket // status. - _prevPeek = false; - retval = BtHandshakeMessage::MESSAGE_LENGTH <= _resbufLength; + prevPeek_ = false; + retval = BtHandshakeMessage::MESSAGE_LENGTH <= resbufLength_; } else { - _prevPeek = peek; - size_t remaining = BtHandshakeMessage::MESSAGE_LENGTH-_resbufLength; - if(remaining > 0 && !_socket->isReadable(0)) { + prevPeek_ = peek; + size_t remaining = BtHandshakeMessage::MESSAGE_LENGTH-resbufLength_; + if(remaining > 0 && !socket_->isReadable(0)) { dataLength = 0; return false; } if(remaining > 0) { size_t temp = remaining; - readData(_resbuf+_resbufLength, remaining, _encryptionEnabled); + readData(resbuf_+resbufLength_, remaining, encryptionEnabled_); if(remaining == 0) { - if(_socket->wantRead() || _socket->wantWrite()) { + if(socket_->wantRead() || socket_->wantWrite()) { return false; } // we got EOF - if(_logger->debug()) { - _logger->debug + if(logger_->debug()) { + logger_->debug ("CUID#%s - In PeerConnection::receiveHandshake(), remain=%lu", - util::itos(_cuid).c_str(), static_cast<unsigned long>(temp)); + util::itos(cuid_).c_str(), static_cast<unsigned long>(temp)); } throw DL_ABORT_EX(EX_EOF_FROM_PEER); } - _resbufLength += remaining; - if(BtHandshakeMessage::MESSAGE_LENGTH > _resbufLength) { + resbufLength_ += remaining; + if(BtHandshakeMessage::MESSAGE_LENGTH > resbufLength_) { retval = false; } } } - size_t writeLength = std::min(_resbufLength, dataLength); - memcpy(data, _resbuf, writeLength); + size_t writeLength = std::min(resbufLength_, dataLength); + memcpy(data, resbuf_, writeLength); dataLength = writeLength; if(retval && !peek) { - _resbufLength = 0; + resbufLength_ = 0; } return retval; } @@ -235,10 +235,10 @@ void PeerConnection::readData if(encryption) { unsigned char temp[MAX_PAYLOAD_LEN]; assert(MAX_PAYLOAD_LEN >= length); - _socket->readData(temp, length); - _decryptor->decrypt(data, length, temp, length); + socket_->readData(temp, length); + decryptor_->decrypt(data, length, temp, length); } else { - _socket->readData(data, length); + socket_->readData(data, length); } } @@ -246,29 +246,29 @@ void PeerConnection::enableEncryption (const SharedHandle<ARC4Encryptor>& encryptor, const SharedHandle<ARC4Decryptor>& decryptor) { - _encryptor = encryptor; - _decryptor = decryptor; + encryptor_ = encryptor; + decryptor_ = decryptor; - _encryptionEnabled = true; + encryptionEnabled_ = true; } void PeerConnection::presetBuffer(const unsigned char* data, size_t length) { size_t nwrite = std::min((size_t)MAX_PAYLOAD_LEN, length); - memcpy(_resbuf, data, nwrite); - _resbufLength = length; + memcpy(resbuf_, data, nwrite); + resbufLength_ = length; } bool PeerConnection::sendBufferIsEmpty() const { - return _socketBuffer.sendBufferIsEmpty(); + return socketBuffer_.sendBufferIsEmpty(); } ssize_t PeerConnection::sendPendingData() { - ssize_t writtenLength = _socketBuffer.send(); - if(_logger->debug()) { - _logger->debug("sent %d byte(s).", writtenLength); + ssize_t writtenLength = socketBuffer_.send(); + if(logger_->debug()) { + logger_->debug("sent %d byte(s).", writtenLength); } return writtenLength; } diff --git a/src/PeerConnection.h b/src/PeerConnection.h index e95eb672..a8dc885a 100644 --- a/src/PeerConnection.h +++ b/src/PeerConnection.h @@ -56,23 +56,23 @@ class ARC4Decryptor; class PeerConnection { private: - cuid_t _cuid; - SharedHandle<SocketCore> _socket; - Logger* _logger; + cuid_t cuid_; + SharedHandle<SocketCore> socket_; + Logger* logger_; - unsigned char* _resbuf; - size_t _resbufLength; - size_t _currentPayloadLength; - unsigned char _lenbuf[4]; - size_t _lenbufLength; + unsigned char* resbuf_; + size_t resbufLength_; + size_t currentPayloadLength_; + unsigned char lenbuf_[4]; + size_t lenbufLength_; - SocketBuffer _socketBuffer; + SocketBuffer socketBuffer_; - bool _encryptionEnabled; - SharedHandle<ARC4Encryptor> _encryptor; - SharedHandle<ARC4Decryptor> _decryptor; + bool encryptionEnabled_; + SharedHandle<ARC4Encryptor> encryptor_; + SharedHandle<ARC4Decryptor> decryptor_; - bool _prevPeek; + bool prevPeek_; void readData(unsigned char* data, size_t& length, bool encryption); @@ -111,13 +111,13 @@ public: const unsigned char* getBuffer() const { - return _resbuf; + return resbuf_; } unsigned char* detachBuffer() { - unsigned char* detachbuf = _resbuf; - _resbuf = new unsigned char[MAX_PAYLOAD_LEN]; + unsigned char* detachbuf = resbuf_; + resbuf_ = new unsigned char[MAX_PAYLOAD_LEN]; return detachbuf; } }; diff --git a/src/PeerInitiateConnectionCommand.cc b/src/PeerInitiateConnectionCommand.cc index 4eacf021..d3d6dd29 100644 --- a/src/PeerInitiateConnectionCommand.cc +++ b/src/PeerInitiateConnectionCommand.cc @@ -65,18 +65,18 @@ PeerInitiateConnectionCommand::PeerInitiateConnectionCommand bool mseHandshakeEnabled) : PeerAbstractCommand(cuid, peer, e), - _requestGroup(requestGroup), - _btRuntime(btRuntime), - _mseHandshakeEnabled(mseHandshakeEnabled) + requestGroup_(requestGroup), + btRuntime_(btRuntime), + mseHandshakeEnabled_(mseHandshakeEnabled) { - _btRuntime->increaseConnections(); - _requestGroup->increaseNumCommand(); + btRuntime_->increaseConnections(); + requestGroup_->increaseNumCommand(); } PeerInitiateConnectionCommand::~PeerInitiateConnectionCommand() { - _requestGroup->decreaseNumCommand(); - _btRuntime->decreaseConnections(); + requestGroup_->decreaseNumCommand(); + btRuntime_->decreaseConnections(); } bool PeerInitiateConnectionCommand::executeInternal() { @@ -89,19 +89,19 @@ bool PeerInitiateConnectionCommand::executeInternal() { createSocket(); getSocket()->establishConnection(getPeer()->getIPAddress(), getPeer()->getPort()); - if(_mseHandshakeEnabled) { + if(mseHandshakeEnabled_) { InitiatorMSEHandshakeCommand* c = - new InitiatorMSEHandshakeCommand(getCuid(), _requestGroup, getPeer(), + new InitiatorMSEHandshakeCommand(getCuid(), requestGroup_, getPeer(), getDownloadEngine(), - _btRuntime, getSocket()); - c->setPeerStorage(_peerStorage); - c->setPieceStorage(_pieceStorage); + btRuntime_, getSocket()); + c->setPeerStorage(peerStorage_); + c->setPieceStorage(pieceStorage_); getDownloadEngine()->addCommand(c); } else { PeerInteractionCommand* command = new PeerInteractionCommand - (getCuid(), _requestGroup, getPeer(), getDownloadEngine(), - _btRuntime, _pieceStorage, _peerStorage, + (getCuid(), requestGroup_, getPeer(), getDownloadEngine(), + btRuntime_, pieceStorage_, peerStorage_, getSocket(), PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE); getDownloadEngine()->addCommand(command); } @@ -110,38 +110,38 @@ bool PeerInitiateConnectionCommand::executeInternal() { // TODO this method removed when PeerBalancerCommand is implemented bool PeerInitiateConnectionCommand::prepareForNextPeer(time_t wait) { - if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) { - SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); + if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) { + SharedHandle<Peer> peer = peerStorage_->getUnusedPeer(); peer->usedBy(getDownloadEngine()->newCUID()); PeerInitiateConnectionCommand* command = - new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, - getDownloadEngine(), _btRuntime); - command->setPeerStorage(_peerStorage); - command->setPieceStorage(_pieceStorage); + new PeerInitiateConnectionCommand(peer->usedBy(), requestGroup_, peer, + getDownloadEngine(), btRuntime_); + command->setPeerStorage(peerStorage_); + command->setPieceStorage(pieceStorage_); getDownloadEngine()->addCommand(command); } return true; } void PeerInitiateConnectionCommand::onAbort() { - _peerStorage->returnPeer(getPeer()); + peerStorage_->returnPeer(getPeer()); } bool PeerInitiateConnectionCommand::exitBeforeExecute() { - return _btRuntime->isHalt(); + return btRuntime_->isHalt(); } void PeerInitiateConnectionCommand::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void PeerInitiateConnectionCommand::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } } // namespace aria2 diff --git a/src/PeerInitiateConnectionCommand.h b/src/PeerInitiateConnectionCommand.h index 6b824da9..2e01423b 100644 --- a/src/PeerInitiateConnectionCommand.h +++ b/src/PeerInitiateConnectionCommand.h @@ -46,15 +46,15 @@ class PieceStorage; class PeerInitiateConnectionCommand : public PeerAbstractCommand { private: - RequestGroup* _requestGroup; + RequestGroup* requestGroup_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - bool _mseHandshakeEnabled; + bool mseHandshakeEnabled_; protected: virtual bool executeInternal(); virtual bool prepareForNextPeer(time_t wait); diff --git a/src/PeerInteractionCommand.cc b/src/PeerInteractionCommand.cc index 8fa666f6..698df99f 100644 --- a/src/PeerInteractionCommand.cc +++ b/src/PeerInteractionCommand.cc @@ -90,20 +90,20 @@ PeerInteractionCommand::PeerInteractionCommand Seq sequence, const PeerConnectionHandle& passedPeerConnection) :PeerAbstractCommand(cuid, p, e, s), - _requestGroup(requestGroup), - _btRuntime(btRuntime), - _pieceStorage(pieceStorage), - _peerStorage(peerStorage), - _sequence(sequence) + requestGroup_(requestGroup), + btRuntime_(btRuntime), + pieceStorage_(pieceStorage), + peerStorage_(peerStorage), + sequence_(sequence) { // TODO move following bunch of processing to separate method, like init() - if(_sequence == INITIATOR_SEND_HANDSHAKE) { + if(sequence_ == INITIATOR_SEND_HANDSHAKE) { disableReadCheckSocket(); setWriteCheckSocket(getSocket()); setTimeout(getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT)); } SharedHandle<TorrentAttribute> torrentAttrs = - bittorrent::getTorrentAttrs(_requestGroup->getDownloadContext()); + bittorrent::getTorrentAttrs(requestGroup_->getDownloadContext()); bool metadataGetMode = torrentAttrs->metadata.empty(); SharedHandle<ExtensionMessageRegistry> exMsgRegistry @@ -120,14 +120,14 @@ PeerInteractionCommand::PeerInteractionCommand (new DefaultExtensionMessageFactory(getPeer(), exMsgRegistry)); extensionMessageFactory->setPeerStorage(peerStorage); extensionMessageFactory->setDownloadContext - (_requestGroup->getDownloadContext()); + (requestGroup_->getDownloadContext()); extensionMessageFactory->setUTMetadataRequestTracker (utMetadataRequestTracker); // PieceStorage will be set later. SharedHandle<DefaultBtMessageFactory> factory(new DefaultBtMessageFactory()); factory->setCuid(cuid); - factory->setDownloadContext(_requestGroup->getDownloadContext()); + factory->setDownloadContext(requestGroup_->getDownloadContext()); factory->setPieceStorage(pieceStorage); factory->setPeerStorage(peerStorage); factory->setExtensionMessageFactory(extensionMessageFactory); @@ -151,7 +151,7 @@ PeerInteractionCommand::PeerInteractionCommand (new DefaultBtMessageDispatcher()); dispatcher->setCuid(cuid); dispatcher->setPeer(getPeer()); - dispatcher->setDownloadContext(_requestGroup->getDownloadContext()); + dispatcher->setDownloadContext(requestGroup_->getDownloadContext()); dispatcher->setPieceStorage(pieceStorage); dispatcher->setPeerStorage(peerStorage); dispatcher->setRequestTimeout(getOption()->getAsInt(PREF_BT_REQUEST_TIMEOUT)); @@ -159,7 +159,7 @@ PeerInteractionCommand::PeerInteractionCommand dispatcher->setRequestGroupMan(getDownloadEngine()->getRequestGroupMan()); DefaultBtMessageReceiverHandle receiver(new DefaultBtMessageReceiver()); - receiver->setDownloadContext(_requestGroup->getDownloadContext()); + receiver->setDownloadContext(requestGroup_->getDownloadContext()); receiver->setPeerConnection(peerConnection); receiver->setDispatcher(dispatcher); receiver->setBtMessageFactory(factory); @@ -172,9 +172,9 @@ PeerInteractionCommand::PeerInteractionCommand reqFactory->setBtMessageFactory(factory); DefaultBtInteractiveHandle btInteractive - (new DefaultBtInteractive(_requestGroup->getDownloadContext(), getPeer())); - btInteractive->setBtRuntime(_btRuntime); - btInteractive->setPieceStorage(_pieceStorage); + (new DefaultBtInteractive(requestGroup_->getDownloadContext(), getPeer())); + btInteractive->setBtRuntime(btRuntime_); + btInteractive->setPieceStorage(pieceStorage_); btInteractive->setPeerStorage(peerStorage); // Note: Not a member variable. btInteractive->setCuid(cuid); btInteractive->setBtMessageReceiver(receiver); @@ -204,7 +204,7 @@ PeerInteractionCommand::PeerInteractionCommand btInteractive->enableMetadataGetMode(); } - _btInteractive = btInteractive; + btInteractive_ = btInteractive; // reverse depends factory->setBtMessageDispatcher(dispatcher); @@ -216,7 +216,7 @@ PeerInteractionCommand::PeerInteractionCommand if(metadataGetMode) { utMetadataRequestFactory->setDownloadContext - (_requestGroup->getDownloadContext()); + (requestGroup_->getDownloadContext()); utMetadataRequestFactory->setBtMessageDispatcher(dispatcher); utMetadataRequestFactory->setBtMessageFactory(factory); utMetadataRequestFactory->setPeer(getPeer()); @@ -225,28 +225,28 @@ PeerInteractionCommand::PeerInteractionCommand } getPeer()->allocateSessionResource - (_requestGroup->getDownloadContext()->getPieceLength(), - _requestGroup->getDownloadContext()->getTotalLength()); + (requestGroup_->getDownloadContext()->getPieceLength(), + requestGroup_->getDownloadContext()->getTotalLength()); getPeer()->setBtMessageDispatcher(dispatcher); - _btRuntime->increaseConnections(); - _requestGroup->increaseNumCommand(); + btRuntime_->increaseConnections(); + requestGroup_->increaseNumCommand(); } PeerInteractionCommand::~PeerInteractionCommand() { if(getPeer()->getCompletedLength() > 0) { - _pieceStorage->subtractPieceStats(getPeer()->getBitfield(), + pieceStorage_->subtractPieceStats(getPeer()->getBitfield(), getPeer()->getBitfieldLength()); } getPeer()->releaseSessionResource(); - _requestGroup->decreaseNumCommand(); - _btRuntime->decreaseConnections(); + requestGroup_->decreaseNumCommand(); + btRuntime_->decreaseConnections(); } bool PeerInteractionCommand::executeInternal() { setNoCheck(false); - switch(_sequence) { + switch(sequence_) { case INITIATOR_SEND_HANDSHAKE: if(!getSocket()->isWritable(0)) { break; @@ -255,53 +255,53 @@ bool PeerInteractionCommand::executeInternal() { setReadCheckSocket(getSocket()); //socket->setBlockingMode(); setTimeout(getOption()->getAsInt(PREF_BT_TIMEOUT)); - _btInteractive->initiateHandshake(); - _sequence = INITIATOR_WAIT_HANDSHAKE; + btInteractive_->initiateHandshake(); + sequence_ = INITIATOR_WAIT_HANDSHAKE; break; case INITIATOR_WAIT_HANDSHAKE: { - if(_btInteractive->countPendingMessage() > 0) { - _btInteractive->sendPendingMessage(); - if(_btInteractive->countPendingMessage() > 0) { + if(btInteractive_->countPendingMessage() > 0) { + btInteractive_->sendPendingMessage(); + if(btInteractive_->countPendingMessage() > 0) { break; } } - BtMessageHandle handshakeMessage = _btInteractive->receiveHandshake(); + BtMessageHandle handshakeMessage = btInteractive_->receiveHandshake(); if(handshakeMessage.isNull()) { break; } - _btInteractive->doPostHandshakeProcessing(); - _sequence = WIRED; + btInteractive_->doPostHandshakeProcessing(); + sequence_ = WIRED; break; } case RECEIVER_WAIT_HANDSHAKE: { - BtMessageHandle handshakeMessage =_btInteractive->receiveAndSendHandshake(); + BtMessageHandle handshakeMessage =btInteractive_->receiveAndSendHandshake(); if(handshakeMessage.isNull()) { break; } - _btInteractive->doPostHandshakeProcessing(); - _sequence = WIRED; + btInteractive_->doPostHandshakeProcessing(); + sequence_ = WIRED; break; } case WIRED: // See the comment for writable check below. disableWriteCheckSocket(); - _btInteractive->doInteractionProcessing(); - if(_btInteractive->countReceivedMessageInIteration() > 0) { + btInteractive_->doInteractionProcessing(); + if(btInteractive_->countReceivedMessageInIteration() > 0) { updateKeepAlive(); } if((getPeer()->amInterested() && !getPeer()->peerChoking()) || - _btInteractive->countOutstandingRequest() || + btInteractive_->countOutstandingRequest() || (getPeer()->peerInterested() && !getPeer()->amChoking())) { // Writable check to avoid slow seeding - if(_btInteractive->isSendingMessageInProgress()) { + if(btInteractive_->isSendingMessageInProgress()) { setWriteCheckSocket(getSocket()); } if(getDownloadEngine()->getRequestGroupMan()-> doesOverallDownloadSpeedExceed() || - _requestGroup->doesDownloadSpeedExceed()) { + requestGroup_->doesDownloadSpeedExceed()) { disableReadCheckSocket(); setNoCheck(true); } else { @@ -312,7 +312,7 @@ bool PeerInteractionCommand::executeInternal() { } break; } - if(_btInteractive->countPendingMessage() > 0) { + if(btInteractive_->countPendingMessage() > 0) { setNoCheck(true); } getDownloadEngine()->addCommand(this); @@ -321,37 +321,37 @@ bool PeerInteractionCommand::executeInternal() { // TODO this method removed when PeerBalancerCommand is implemented bool PeerInteractionCommand::prepareForNextPeer(time_t wait) { - if(_peerStorage->isPeerAvailable() && _btRuntime->lessThanEqMinPeers()) { - SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); + if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) { + SharedHandle<Peer> peer = peerStorage_->getUnusedPeer(); peer->usedBy(getDownloadEngine()->newCUID()); PeerInitiateConnectionCommand* command = new PeerInitiateConnectionCommand - (peer->usedBy(), _requestGroup, peer, getDownloadEngine(), _btRuntime); - command->setPeerStorage(_peerStorage); - command->setPieceStorage(_pieceStorage); + (peer->usedBy(), requestGroup_, peer, getDownloadEngine(), btRuntime_); + command->setPeerStorage(peerStorage_); + command->setPieceStorage(pieceStorage_); getDownloadEngine()->addCommand(command); } return true; } void PeerInteractionCommand::onAbort() { - _btInteractive->cancelAllPiece(); - _peerStorage->returnPeer(getPeer()); + btInteractive_->cancelAllPiece(); + peerStorage_->returnPeer(getPeer()); } void PeerInteractionCommand::onFailure() { - _requestGroup->setHaltRequested(true); + requestGroup_->setHaltRequested(true); } bool PeerInteractionCommand::exitBeforeExecute() { - return _btRuntime->isHalt(); + return btRuntime_->isHalt(); } const SharedHandle<Option>& PeerInteractionCommand::getOption() const { - return _requestGroup->getOption(); + return requestGroup_->getOption(); } } // namespace aria2 diff --git a/src/PeerInteractionCommand.h b/src/PeerInteractionCommand.h index f5f59743..e8ffae43 100644 --- a/src/PeerInteractionCommand.h +++ b/src/PeerInteractionCommand.h @@ -55,16 +55,16 @@ public: RECEIVER_WAIT_HANDSHAKE, WIRED}; private: - RequestGroup* _requestGroup; + RequestGroup* requestGroup_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - Seq _sequence; - SharedHandle<BtInteractive> _btInteractive; + Seq sequence_; + SharedHandle<BtInteractive> btInteractive_; const SharedHandle<Option>& getOption() const; protected: diff --git a/src/PeerListenCommand.cc b/src/PeerListenCommand.cc index 99cd3821..8786be20 100644 --- a/src/PeerListenCommand.cc +++ b/src/PeerListenCommand.cc @@ -54,26 +54,26 @@ namespace aria2 { -unsigned int PeerListenCommand::__numInstance = 0; +unsigned int PeerListenCommand::numInstance_ = 0; -PeerListenCommand* PeerListenCommand::__instance = 0; +PeerListenCommand* PeerListenCommand::instance_ = 0; PeerListenCommand::PeerListenCommand(cuid_t cuid, DownloadEngine* e): Command(cuid), - _e(e), - _lowestSpeedLimit(20*1024) + e_(e), + lowestSpeedLimit_(20*1024) { - ++__numInstance; + ++numInstance_; } PeerListenCommand::~PeerListenCommand() { - --__numInstance; + --numInstance_; } bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq) { - _socket.reset(new SocketCore()); + socket_.reset(new SocketCore()); std::vector<int32_t> randPorts = seq.flush(); std::random_shuffle(randPorts.begin(), randPorts.end(), @@ -86,15 +86,15 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq) } port = (*portItr); try { - _socket->bind(port); - _socket->beginListen(); - _socket->setNonBlockingMode(); + socket_->bind(port); + socket_->beginListen(); + socket_->setNonBlockingMode(); getLogger()->notice("BitTorrent: listening to port %d", port); return true; } catch(RecoverableException& ex) { getLogger()->error(MSG_BIND_FAILURE, ex, util::itos(getCuid()).c_str(), port); - _socket->closeConnection(); + socket_->closeConnection(); } } return false; @@ -102,33 +102,33 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq) uint16_t PeerListenCommand::getPort() const { - if(_socket.isNull()) { + if(socket_.isNull()) { return 0; } else { std::pair<std::string, uint16_t> addr; - _socket->getAddrInfo(addr); + socket_->getAddrInfo(addr); return addr.second; } } bool PeerListenCommand::execute() { - if(_e->isHaltRequested() || _e->getRequestGroupMan()->downloadFinished()) { + if(e_->isHaltRequested() || e_->getRequestGroupMan()->downloadFinished()) { return true; } - for(int i = 0; i < 3 && _socket->isReadable(0); ++i) { + for(int i = 0; i < 3 && socket_->isReadable(0); ++i) { SocketHandle peerSocket; try { - peerSocket.reset(_socket->acceptConnection()); + peerSocket.reset(socket_->acceptConnection()); std::pair<std::string, uint16_t> peerInfo; peerSocket->getPeerInfo(peerInfo); peerSocket->setNonBlockingMode(); SharedHandle<Peer> peer(new Peer(peerInfo.first, peerInfo.second, true)); - cuid_t cuid = _e->newCUID(); + cuid_t cuid = e_->newCUID(); Command* command = - new ReceiverMSEHandshakeCommand(cuid, peer, _e, peerSocket); - _e->addCommand(command); + new ReceiverMSEHandshakeCommand(cuid, peer, e_, peerSocket); + e_->addCommand(command); if(getLogger()->debug()) { getLogger()->debug("Accepted the connection from %s:%u.", peer->getIPAddress().c_str(), @@ -140,16 +140,16 @@ bool PeerListenCommand::execute() { getLogger()->debug(MSG_ACCEPT_FAILURE, ex, util::itos(getCuid()).c_str()); } } - _e->addCommand(this); + e_->addCommand(this); return false; } PeerListenCommand* PeerListenCommand::getInstance(DownloadEngine* e) { - if(__numInstance == 0) { - __instance = new PeerListenCommand(e->newCUID(), e); + if(numInstance_ == 0) { + instance_ = new PeerListenCommand(e->newCUID(), e); } - return __instance; + return instance_; } } // namespace aria2 diff --git a/src/PeerListenCommand.h b/src/PeerListenCommand.h index d8b6a2ec..c64a8556 100644 --- a/src/PeerListenCommand.h +++ b/src/PeerListenCommand.h @@ -46,13 +46,13 @@ class SocketCore; class PeerListenCommand : public Command { private: - DownloadEngine* _e; - SharedHandle<SocketCore> _socket; - unsigned int _lowestSpeedLimit; + DownloadEngine* e_; + SharedHandle<SocketCore> socket_; + unsigned int lowestSpeedLimit_; - static unsigned int __numInstance; + static unsigned int numInstance_; - static PeerListenCommand* __instance; + static PeerListenCommand* instance_; public: PeerListenCommand(cuid_t cuid, DownloadEngine* e); @@ -72,14 +72,14 @@ public: void setLowestSpeedLimit(unsigned int speed) { - _lowestSpeedLimit = speed; + lowestSpeedLimit_ = speed; } static PeerListenCommand* getInstance(DownloadEngine* e); static unsigned int getNumInstance() { - return __numInstance; + return numInstance_; } }; diff --git a/src/PeerReceiveHandshakeCommand.cc b/src/PeerReceiveHandshakeCommand.cc index e80e8d0c..f9ec9767 100644 --- a/src/PeerReceiveHandshakeCommand.cc +++ b/src/PeerReceiveHandshakeCommand.cc @@ -70,10 +70,10 @@ PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand const SharedHandle<PeerConnection>& peerConnection) : PeerAbstractCommand(cuid, peer, e, s), - _peerConnection(peerConnection) + peerConnection_(peerConnection) { - if(_peerConnection.isNull()) { - _peerConnection.reset(new PeerConnection(cuid, getSocket())); + if(peerConnection_.isNull()) { + peerConnection_.reset(new PeerConnection(cuid, getSocket())); } } @@ -91,7 +91,7 @@ bool PeerReceiveHandshakeCommand::executeInternal() size_t dataLength = BtHandshakeMessage::MESSAGE_LENGTH; // ignore return value. The received data is kept in PeerConnection object // because of peek = true. - _peerConnection->receiveHandshake(data, dataLength, true); + peerConnection_->receiveHandshake(data, dataLength, true); // To handle tracker's NAT-checking feature if(dataLength >= 48) { // check info_hash @@ -106,9 +106,9 @@ bool PeerReceiveHandshakeCommand::executeInternal() } BtObject btObject = getDownloadEngine()->getBtRegistry()->get (downloadContext->getOwnerRequestGroup()->getGID()); - SharedHandle<BtRuntime> btRuntime = btObject._btRuntime; - SharedHandle<PieceStorage> pieceStorage = btObject._pieceStorage; - SharedHandle<PeerStorage> peerStorage = btObject._peerStorage; + SharedHandle<BtRuntime> btRuntime = btObject.btRuntime_; + SharedHandle<PieceStorage> pieceStorage = btObject.pieceStorage_; + SharedHandle<PeerStorage> peerStorage = btObject.peerStorage_; if(!btRuntime->ready()) { throw DL_ABORT_EX (StringFormat("Unknown info hash %s", @@ -142,7 +142,7 @@ bool PeerReceiveHandshakeCommand::executeInternal() peerStorage, getSocket(), PeerInteractionCommand::RECEIVER_WAIT_HANDSHAKE, - _peerConnection); + peerConnection_); getDownloadEngine()->addCommand(command); if(getLogger()->debug()) { getLogger()->debug(MSG_INCOMING_PEER_CONNECTION, diff --git a/src/PeerReceiveHandshakeCommand.h b/src/PeerReceiveHandshakeCommand.h index 70bad064..d0b8cb2e 100644 --- a/src/PeerReceiveHandshakeCommand.h +++ b/src/PeerReceiveHandshakeCommand.h @@ -46,7 +46,7 @@ class Peer; class PeerReceiveHandshakeCommand:public PeerAbstractCommand { private: - SharedHandle<PeerConnection> _peerConnection; + SharedHandle<PeerConnection> peerConnection_; protected: virtual bool executeInternal(); virtual bool exitBeforeExecute(); diff --git a/src/PeerSessionResource.cc b/src/PeerSessionResource.cc index 7c8355f0..daae8bf7 100644 --- a/src/PeerSessionResource.cc +++ b/src/PeerSessionResource.cc @@ -45,71 +45,71 @@ namespace aria2 { PeerSessionResource::PeerSessionResource(size_t pieceLength, uint64_t totalLength): - _amChoking(true), - _amInterested(false), - _peerChoking(true), - _peerInterested(false), - _chokingRequired(true), - _optUnchoking(false), - _snubbing(false), - _bitfieldMan(new BitfieldMan(pieceLength, totalLength)), - _fastExtensionEnabled(false), - _extendedMessagingEnabled(false), - _dhtEnabled(false), - _lastDownloadUpdate(0), - _lastAmUnchoking(0) + amChoking_(true), + amInterested_(false), + peerChoking_(true), + peerInterested_(false), + chokingRequired_(true), + optUnchoking_(false), + snubbing_(false), + bitfieldMan_(new BitfieldMan(pieceLength, totalLength)), + fastExtensionEnabled_(false), + extendedMessagingEnabled_(false), + dhtEnabled_(false), + lastDownloadUpdate_(0), + lastAmUnchoking_(0) {} PeerSessionResource::~PeerSessionResource() { - delete _bitfieldMan; + delete bitfieldMan_; } void PeerSessionResource::amChoking(bool b) { - _amChoking = b; + amChoking_ = b; if(!b) { - _lastAmUnchoking = global::wallclock; + lastAmUnchoking_ = global::wallclock; } } void PeerSessionResource::amInterested(bool b) { - _amInterested = b; + amInterested_ = b; } void PeerSessionResource::peerChoking(bool b) { - _peerChoking = b; + peerChoking_ = b; } void PeerSessionResource::peerInterested(bool b) { - _peerInterested = b; + peerInterested_ = b; } void PeerSessionResource::chokingRequired(bool b) { - _chokingRequired = b; + chokingRequired_ = b; } void PeerSessionResource::optUnchoking(bool b) { - _optUnchoking = b; + optUnchoking_ = b; } bool PeerSessionResource::shouldBeChoking() const { - if(_optUnchoking) { + if(optUnchoking_) { return false; } - return _chokingRequired; + return chokingRequired_; } void PeerSessionResource::snubbing(bool b) { - _snubbing = b; - if(_snubbing) { + snubbing_ = b; + if(snubbing_) { chokingRequired(true); optUnchoking(false); } @@ -117,51 +117,51 @@ void PeerSessionResource::snubbing(bool b) bool PeerSessionResource::hasAllPieces() const { - return _bitfieldMan->isAllBitSet(); + return bitfieldMan_->isAllBitSet(); } void PeerSessionResource::updateBitfield(size_t index, int operation) { if(operation == 1) { - _bitfieldMan->setBit(index); + bitfieldMan_->setBit(index); } else if(operation == 0) { - _bitfieldMan->unsetBit(index); + bitfieldMan_->unsetBit(index); } } void PeerSessionResource::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) { - _bitfieldMan->setBitfield(bitfield, bitfieldLength); + bitfieldMan_->setBitfield(bitfield, bitfieldLength); } const unsigned char* PeerSessionResource::getBitfield() const { - return _bitfieldMan->getBitfield(); + return bitfieldMan_->getBitfield(); } size_t PeerSessionResource::getBitfieldLength() const { - return _bitfieldMan->getBitfieldLength(); + return bitfieldMan_->getBitfieldLength(); } bool PeerSessionResource::hasPiece(size_t index) const { - return _bitfieldMan->isBitSet(index); + return bitfieldMan_->isBitSet(index); } void PeerSessionResource::markSeeder() { - _bitfieldMan->setAllBit(); + bitfieldMan_->setAllBit(); } void PeerSessionResource::fastExtensionEnabled(bool b) { - _fastExtensionEnabled = b; + fastExtensionEnabled_ = b; } const std::vector<size_t>& PeerSessionResource::peerAllowedIndexSet() const { - return _peerAllowedIndexSet; + return peerAllowedIndexSet_; } static void updateIndexSet(std::vector<size_t>& c, size_t index) @@ -174,38 +174,38 @@ static void updateIndexSet(std::vector<size_t>& c, size_t index) void PeerSessionResource::addPeerAllowedIndex(size_t index) { - updateIndexSet(_peerAllowedIndexSet, index); + updateIndexSet(peerAllowedIndexSet_, index); } bool PeerSessionResource::peerAllowedIndexSetContains(size_t index) const { - return std::binary_search(_peerAllowedIndexSet.begin(), - _peerAllowedIndexSet.end(), + return std::binary_search(peerAllowedIndexSet_.begin(), + peerAllowedIndexSet_.end(), index); } void PeerSessionResource::addAmAllowedIndex(size_t index) { - updateIndexSet(_amAllowedIndexSet, index); + updateIndexSet(amAllowedIndexSet_, index); } bool PeerSessionResource::amAllowedIndexSetContains(size_t index) const { - return std::binary_search(_amAllowedIndexSet.begin(), - _amAllowedIndexSet.end(), + return std::binary_search(amAllowedIndexSet_.begin(), + amAllowedIndexSet_.end(), index); } void PeerSessionResource::extendedMessagingEnabled(bool b) { - _extendedMessagingEnabled = b; + extendedMessagingEnabled_ = b; } uint8_t PeerSessionResource::getExtensionMessageID(const std::string& name) const { - Extensions::const_iterator itr = _extensions.find(name); - if(itr == _extensions.end()) { + Extensions::const_iterator itr = extensions_.find(name); + if(itr == extensions_.end()) { return 0; } else { return (*itr).second; @@ -214,8 +214,8 @@ PeerSessionResource::getExtensionMessageID(const std::string& name) const std::string PeerSessionResource::getExtensionName(uint8_t id) const { - for(Extensions::const_iterator itr = _extensions.begin(), - eoi = _extensions.end(); itr != eoi; ++itr) { + for(Extensions::const_iterator itr = extensions_.begin(), + eoi = extensions_.end(); itr != eoi; ++itr) { const Extensions::value_type& p = *itr; if(p.second == id) { return p.first; @@ -226,51 +226,51 @@ std::string PeerSessionResource::getExtensionName(uint8_t id) const void PeerSessionResource::addExtension(const std::string& name, uint8_t id) { - _extensions[name] = id; + extensions_[name] = id; } void PeerSessionResource::dhtEnabled(bool b) { - _dhtEnabled = b; + dhtEnabled_ = b; } uint64_t PeerSessionResource::uploadLength() const { - return _peerStat.getSessionUploadLength(); + return peerStat_.getSessionUploadLength(); } void PeerSessionResource::updateUploadLength(size_t bytes) { - _peerStat.updateUploadLength(bytes); + peerStat_.updateUploadLength(bytes); } uint64_t PeerSessionResource::downloadLength() const { - return _peerStat.getSessionDownloadLength(); + return peerStat_.getSessionDownloadLength(); } void PeerSessionResource::updateDownloadLength(size_t bytes) { - _peerStat.updateDownloadLength(bytes); + peerStat_.updateDownloadLength(bytes); - _lastDownloadUpdate = global::wallclock; + lastDownloadUpdate_ = global::wallclock; } uint64_t PeerSessionResource::getCompletedLength() const { - return _bitfieldMan->getCompletedLength(); + return bitfieldMan_->getCompletedLength(); } void PeerSessionResource::setBtMessageDispatcher (const WeakHandle<BtMessageDispatcher>& dpt) { - _dispatcher = dpt; + dispatcher_ = dpt; } size_t PeerSessionResource::countOutstandingUpload() const { - assert(!_dispatcher.isNull()); - return _dispatcher->countOutstandingUpload(); + assert(!dispatcher_.isNull()); + return dispatcher_->countOutstandingUpload(); } } // namespace aria2 diff --git a/src/PeerSessionResource.h b/src/PeerSessionResource.h index 1cdf358e..4fe28d16 100644 --- a/src/PeerSessionResource.h +++ b/src/PeerSessionResource.h @@ -52,36 +52,36 @@ class BtMessageDispatcher; class PeerSessionResource { private: // localhost is choking this peer - bool _amChoking; + bool amChoking_; // localhost is interested in this peer - bool _amInterested; + bool amInterested_; // this peer is choking localhost - bool _peerChoking; + bool peerChoking_; // this peer is interested in localhost - bool _peerInterested; + bool peerInterested_; // choking this peer is requested - bool _chokingRequired; + bool chokingRequired_; // this peer is eligible for *optional* unchoking. - bool _optUnchoking; + bool optUnchoking_; // this peer is snubbing. - bool _snubbing; + bool snubbing_; - BitfieldMan* _bitfieldMan; - bool _fastExtensionEnabled; + BitfieldMan* bitfieldMan_; + bool fastExtensionEnabled_; // fast index set which a peer has sent to localhost. - std::vector<size_t> _peerAllowedIndexSet; + std::vector<size_t> peerAllowedIndexSet_; // fast index set which localhost has sent to a peer. - std::vector<size_t> _amAllowedIndexSet; - bool _extendedMessagingEnabled; - Extensions _extensions; - bool _dhtEnabled; - PeerStat _peerStat; + std::vector<size_t> amAllowedIndexSet_; + bool extendedMessagingEnabled_; + Extensions extensions_; + bool dhtEnabled_; + PeerStat peerStat_; - Timer _lastDownloadUpdate; + Timer lastDownloadUpdate_; - Timer _lastAmUnchoking; + Timer lastAmUnchoking_; - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; public: PeerSessionResource(size_t pieceLength, uint64_t totalLength); @@ -90,7 +90,7 @@ public: // localhost is choking this peer bool amChoking() const { - return _amChoking; + return amChoking_; } void amChoking(bool b); @@ -98,7 +98,7 @@ public: // localhost is interested in this peer bool amInterested() const { - return _amInterested; + return amInterested_; } void amInterested(bool b); @@ -106,7 +106,7 @@ public: // this peer is choking localhost bool peerChoking() const { - return _peerChoking; + return peerChoking_; } void peerChoking(bool b); @@ -114,7 +114,7 @@ public: // this peer is interested in localhost bool peerInterested() const { - return _peerInterested; + return peerInterested_; } void peerInterested(bool b); @@ -122,7 +122,7 @@ public: // this peer should be choked bool chokingRequired() const { - return _chokingRequired; + return chokingRequired_; } void chokingRequired(bool b); @@ -130,7 +130,7 @@ public: // this peer is eligible for unchoking optionally. bool optUnchoking() const { - return _optUnchoking; + return optUnchoking_; } void optUnchoking(bool b); @@ -140,7 +140,7 @@ public: // this peer is snubbing. bool snubbing() const { - return _snubbing; + return snubbing_; } void snubbing(bool b); @@ -161,7 +161,7 @@ public: bool fastExtensionEnabled() const { - return _fastExtensionEnabled; + return fastExtensionEnabled_; } void fastExtensionEnabled(bool b); @@ -176,7 +176,7 @@ public: // fast index set which localhost has sent to a peer. const std::vector<size_t>& amAllowedIndexSet() const { - return _amAllowedIndexSet; + return amAllowedIndexSet_; } void addAmAllowedIndex(size_t index); @@ -185,7 +185,7 @@ public: bool extendedMessagingEnabled() const { - return _extendedMessagingEnabled; + return extendedMessagingEnabled_; } void extendedMessagingEnabled(bool b); @@ -198,14 +198,14 @@ public: bool dhtEnabled() const { - return _dhtEnabled; + return dhtEnabled_; } void dhtEnabled(bool b); PeerStat& getPeerStat() { - return _peerStat; + return peerStat_; } uint64_t uploadLength() const; @@ -218,12 +218,12 @@ public: const Timer& getLastDownloadUpdate() const { - return _lastDownloadUpdate; + return lastDownloadUpdate_; } const Timer& getLastAmUnchoking() const { - return _lastAmUnchoking; + return lastAmUnchoking_; } uint64_t getCompletedLength() const; diff --git a/src/PeerStat.h b/src/PeerStat.h index b8cc3abf..1ab12030 100644 --- a/src/PeerStat.h +++ b/src/PeerStat.h @@ -53,139 +53,139 @@ public: ACTIVE, }; private: - cuid_t _cuid; - std::string _hostname; - std::string _protocol; - SpeedCalc _downloadSpeed; - SpeedCalc _uploadSpeed; - Timer _downloadStartTime; - PeerStat::STATUS _status; - unsigned int _avgDownloadSpeed; - unsigned int _avgUploadSpeed; - uint64_t _sessionDownloadLength; - uint64_t _sessionUploadLength; + cuid_t cuid_; + std::string hostname_; + std::string protocol_; + SpeedCalc downloadSpeed_; + SpeedCalc uploadSpeed_; + Timer downloadStartTime_; + PeerStat::STATUS status_; + unsigned int avgDownloadSpeed_; + unsigned int avgUploadSpeed_; + uint64_t sessionDownloadLength_; + uint64_t sessionUploadLength_; public: PeerStat(cuid_t cuid, const std::string& hostname, const::std::string& protocol): - _cuid(cuid), - _hostname(hostname), - _protocol(protocol), - _downloadStartTime(global::wallclock), - _status(PeerStat::IDLE), - _avgDownloadSpeed(0), - _avgUploadSpeed(0), - _sessionDownloadLength(0), - _sessionUploadLength(0) {} + cuid_(cuid), + hostname_(hostname), + protocol_(protocol), + downloadStartTime_(global::wallclock), + status_(PeerStat::IDLE), + avgDownloadSpeed_(0), + avgUploadSpeed_(0), + sessionDownloadLength_(0), + sessionUploadLength_(0) {} PeerStat(cuid_t cuid = 0): - _cuid(cuid), - _status(PeerStat::IDLE), - _avgDownloadSpeed(0), - _avgUploadSpeed(0), - _sessionDownloadLength(0), - _sessionUploadLength(0) {} + cuid_(cuid), + status_(PeerStat::IDLE), + avgDownloadSpeed_(0), + avgUploadSpeed_(0), + sessionDownloadLength_(0), + sessionUploadLength_(0) {} /** * Returns current download speed in byte per sec. */ unsigned int calculateDownloadSpeed() { - return _downloadSpeed.calculateSpeed(); + return downloadSpeed_.calculateSpeed(); } unsigned int calculateAvgDownloadSpeed() { - _avgDownloadSpeed = _downloadSpeed.calculateAvgSpeed(); - return _avgDownloadSpeed; + avgDownloadSpeed_ = downloadSpeed_.calculateAvgSpeed(); + return avgDownloadSpeed_; } unsigned int calculateUploadSpeed() { - return _uploadSpeed.calculateSpeed(); + return uploadSpeed_.calculateSpeed(); } unsigned int calculateAvgUploadSpeed() { - _avgUploadSpeed = _uploadSpeed.calculateAvgSpeed(); - return _avgUploadSpeed; + avgUploadSpeed_ = uploadSpeed_.calculateAvgSpeed(); + return avgUploadSpeed_; } void updateDownloadLength(size_t bytes) { - _downloadSpeed.update(bytes); - _sessionDownloadLength += bytes; + downloadSpeed_.update(bytes); + sessionDownloadLength_ += bytes; } void updateUploadLength(size_t bytes) { - _uploadSpeed.update(bytes); - _sessionUploadLength += bytes; + uploadSpeed_.update(bytes); + sessionUploadLength_ += bytes; } unsigned int getMaxDownloadSpeed() const { - return _downloadSpeed.getMaxSpeed(); + return downloadSpeed_.getMaxSpeed(); } unsigned int getMaxUploadSpeed() const { - return _uploadSpeed.getMaxSpeed(); + return uploadSpeed_.getMaxSpeed(); } unsigned int getAvgDownloadSpeed() const { - return _avgDownloadSpeed; + return avgDownloadSpeed_; } unsigned int getAvgUploadSpeed() const { - return _avgUploadSpeed; + return avgUploadSpeed_; } void reset() { - _downloadSpeed.reset(); - _uploadSpeed.reset(); - _downloadStartTime = global::wallclock; - _status = PeerStat::IDLE; + downloadSpeed_.reset(); + uploadSpeed_.reset(); + downloadStartTime_ = global::wallclock; + status_ = PeerStat::IDLE; } void downloadStart() { reset(); - _status = PeerStat::ACTIVE; + status_ = PeerStat::ACTIVE; } void downloadStop() { calculateAvgDownloadSpeed(); calculateAvgUploadSpeed(); - _status = PeerStat::IDLE; + status_ = PeerStat::IDLE; } const Timer& getDownloadStartTime() const { - return _downloadStartTime; + return downloadStartTime_; } PeerStat::STATUS getStatus() const { - return _status; + return status_; } cuid_t getCuid() const { - return _cuid; + return cuid_; } const std::string& getHostname() const { - return _hostname; + return hostname_; } const std::string& getProtocol() const { - return _protocol; + return protocol_; } uint64_t getSessionDownloadLength() const { - return _sessionDownloadLength; + return sessionDownloadLength_; } uint64_t getSessionUploadLength() const { - return _sessionUploadLength; + return sessionUploadLength_; } void addSessionDownloadLength(uint64_t length) { - _sessionDownloadLength += length; + sessionDownloadLength_ += length; } }; diff --git a/src/Piece.cc b/src/Piece.cc index ddf167ce..eb5eda04 100644 --- a/src/Piece.cc +++ b/src/Piece.cc @@ -44,127 +44,127 @@ namespace aria2 { -Piece::Piece():_index(0), _length(0), _blockLength(BLOCK_LENGTH), _bitfield(0) +Piece::Piece():index_(0), length_(0), blockLength_(BLOCK_LENGTH), bitfield_(0) #ifdef ENABLE_MESSAGE_DIGEST - , _nextBegin(0) + , nextBegin_(0) #endif // ENABLE_MESSAGE_DIGEST {} Piece::Piece(size_t index, size_t length, size_t blockLength): - _index(index), _length(length), _blockLength(blockLength), - _bitfield(new BitfieldMan(_blockLength, length)) + index_(index), length_(length), blockLength_(blockLength), + bitfield_(new BitfieldMan(blockLength_, length)) #ifdef ENABLE_MESSAGE_DIGEST - , _nextBegin(0) + , nextBegin_(0) #endif // ENABLE_MESSAGE_DIGEST {} Piece::Piece(const Piece& piece) { - _index = piece._index; - _length = piece._length; - _blockLength = piece._blockLength; - if(piece._bitfield == 0) { - _bitfield = 0; + index_ = piece.index_; + length_ = piece.length_; + blockLength_ = piece.blockLength_; + if(piece.bitfield_ == 0) { + bitfield_ = 0; } else { - _bitfield = new BitfieldMan(*piece._bitfield); + bitfield_ = new BitfieldMan(*piece.bitfield_); } #ifdef ENABLE_MESSAGE_DIGEST - _nextBegin = piece._nextBegin; + nextBegin_ = piece.nextBegin_; // TODO Is this OK? - _mdctx = piece._mdctx; + mdctx_ = piece.mdctx_; #endif // ENABLE_MESSAGE_DIGEST } Piece::~Piece() { - delete _bitfield; + delete bitfield_; } Piece& Piece::operator=(const Piece& piece) { if(this != &piece) { - _index = piece._index; - _length = piece._length; - delete _bitfield; - if(piece._bitfield) { - _bitfield = new BitfieldMan(*piece._bitfield); + index_ = piece.index_; + length_ = piece.length_; + delete bitfield_; + if(piece.bitfield_) { + bitfield_ = new BitfieldMan(*piece.bitfield_); } else { - _bitfield = 0; + bitfield_ = 0; } } return *this; } void Piece::completeBlock(size_t blockIndex) { - _bitfield->setBit(blockIndex); - _bitfield->unsetUseBit(blockIndex); + bitfield_->setBit(blockIndex); + bitfield_->unsetUseBit(blockIndex); } void Piece::clearAllBlock() { - _bitfield->clearAllBit(); - _bitfield->clearAllUseBit(); + bitfield_->clearAllBit(); + bitfield_->clearAllUseBit(); } void Piece::setAllBlock() { - _bitfield->setAllBit(); + bitfield_->setAllBit(); } bool Piece::pieceComplete() const { - return _bitfield->isAllBitSet(); + return bitfield_->isAllBitSet(); } size_t Piece::countBlock() const { - return _bitfield->countBlock(); + return bitfield_->countBlock(); } size_t Piece::getBlockLength(size_t index) const { - return _bitfield->getBlockLength(index); + return bitfield_->getBlockLength(index); } size_t Piece::getBlockLength() const { - return _bitfield->getBlockLength(); + return bitfield_->getBlockLength(); } const unsigned char* Piece::getBitfield() const { - return _bitfield->getBitfield(); + return bitfield_->getBitfield(); } size_t Piece::getBitfieldLength() const { - return _bitfield->getBitfieldLength(); + return bitfield_->getBitfieldLength(); } bool Piece::isBlockUsed(size_t index) const { - return _bitfield->isUseBitSet(index); + return bitfield_->isUseBitSet(index); } void Piece::cancelBlock(size_t blockIndex) { - _bitfield->unsetUseBit(blockIndex); + bitfield_->unsetUseBit(blockIndex); } size_t Piece::countCompleteBlock() const { - return _bitfield->countBlock()-_bitfield->countMissingBlock(); + return bitfield_->countBlock()-bitfield_->countMissingBlock(); } size_t Piece::countMissingBlock() const { - return _bitfield->countMissingBlock(); + return bitfield_->countMissingBlock(); } bool Piece::hasBlock(size_t blockIndex) const { - return _bitfield->isBitSet(blockIndex); + return bitfield_->isBitSet(blockIndex); } bool Piece::getMissingUnusedBlockIndex(size_t& index) const { - if(_bitfield->getFirstMissingUnusedIndex(index)) { - _bitfield->setUseBit(index); + if(bitfield_->getFirstMissingUnusedIndex(index)) { + bitfield_->setUseBit(index); return true; } else { return false; @@ -174,11 +174,11 @@ bool Piece::getMissingUnusedBlockIndex(size_t& index) const size_t Piece::getMissingUnusedBlockIndex (std::vector<size_t>& indexes, size_t n) const { - size_t num = _bitfield->getFirstNMissingUnusedIndex(indexes, n); + size_t num = bitfield_->getFirstNMissingUnusedIndex(indexes, n); if(num) { for(std::vector<size_t>::const_iterator i = indexes.end()-num, eoi = indexes.end(); i != eoi; ++i) { - _bitfield->setUseBit(*i); + bitfield_->setUseBit(*i); } } return num; @@ -186,60 +186,60 @@ size_t Piece::getMissingUnusedBlockIndex bool Piece::getFirstMissingBlockIndexWithoutLock(size_t& index) const { - return _bitfield->getFirstMissingIndex(index); + return bitfield_->getFirstMissingIndex(index); } bool Piece::getAllMissingBlockIndexes (unsigned char* misbitfield, size_t mislen) const { - return _bitfield->getAllMissingIndexes(misbitfield, mislen); + return bitfield_->getAllMissingIndexes(misbitfield, mislen); } std::string Piece::toString() const { - return strconcat("piece: index=", util::itos(_index), - ", length=", util::itos(_length)); + return strconcat("piece: index=", util::itos(index_), + ", length=", util::itos(length_)); } void Piece::reconfigure(size_t length) { - delete _bitfield; - _length = length; - _bitfield = new BitfieldMan(_blockLength, _length); + delete bitfield_; + length_ = length; + bitfield_ = new BitfieldMan(blockLength_, length_); } void Piece::setBitfield(const unsigned char* bitfield, size_t len) { - _bitfield->setBitfield(bitfield, len); + bitfield_->setBitfield(bitfield, len); } size_t Piece::getCompletedLength() { - return _bitfield->getCompletedLength(); + return bitfield_->getCompletedLength(); } #ifdef ENABLE_MESSAGE_DIGEST void Piece::setHashAlgo(const std::string& algo) { - _hashAlgo = algo; + hashAlgo_ = algo; } bool Piece::updateHash (uint32_t begin, const unsigned char* data, size_t dataLength) { - if(_hashAlgo.empty()) { + if(hashAlgo_.empty()) { return false; } - if(begin == _nextBegin && _nextBegin+dataLength <= _length) { + if(begin == nextBegin_ && nextBegin_+dataLength <= length_) { - if(_mdctx.isNull()) { - _mdctx.reset(new MessageDigestContext()); - _mdctx->trySetAlgo(_hashAlgo); - _mdctx->digestInit(); + if(mdctx_.isNull()) { + mdctx_.reset(new MessageDigestContext()); + mdctx_->trySetAlgo(hashAlgo_); + mdctx_->digestInit(); } - _mdctx->digestUpdate(data, dataLength); - _nextBegin += dataLength; + mdctx_->digestUpdate(data, dataLength); + nextBegin_ += dataLength; return true; } else { return false; @@ -248,15 +248,15 @@ bool Piece::updateHash bool Piece::isHashCalculated() const { - return !_mdctx.isNull() && _nextBegin == _length; + return !mdctx_.isNull() && nextBegin_ == length_; } std::string Piece::getHashString() { - if(_mdctx.isNull()) { + if(mdctx_.isNull()) { return A2STR::NIL; } else { - std::string hash = util::toHex(_mdctx->digestFinal()); + std::string hash = util::toHex(mdctx_->digestFinal()); destroyHashContext(); return hash; } @@ -264,8 +264,8 @@ std::string Piece::getHashString() void Piece::destroyHashContext() { - _mdctx.reset(); - _nextBegin = 0; + mdctx_.reset(); + nextBegin_ = 0; } #endif // ENABLE_MESSAGE_DIGEST diff --git a/src/Piece.h b/src/Piece.h index abb673ca..dcfc63c0 100644 --- a/src/Piece.h +++ b/src/Piece.h @@ -55,18 +55,18 @@ class MessageDigestContext; class Piece { private: - size_t _index; - size_t _length; - size_t _blockLength; - BitfieldMan* _bitfield; + size_t index_; + size_t length_; + size_t blockLength_; + BitfieldMan* bitfield_; #ifdef ENABLE_MESSAGE_DIGEST - size_t _nextBegin; + size_t nextBegin_; - std::string _hashAlgo; + std::string hashAlgo_; - SharedHandle<MessageDigestContext> _mdctx; + SharedHandle<MessageDigestContext> mdctx_; #endif // ENABLE_MESSAGE_DIGEST @@ -86,12 +86,12 @@ public: bool operator==(const Piece& piece) const { - return _index == piece._index; + return index_ == piece.index_; } bool operator<(const Piece& piece) const { - return _index < piece._index; + return index_ < piece.index_; } // TODO This function only used by unit tests @@ -128,13 +128,13 @@ public: size_t getBlockLength() const; - size_t getIndex() const { return _index; } + size_t getIndex() const { return index_; } - void setIndex(size_t index) { _index = index; } + void setIndex(size_t index) { index_ = index; } - size_t getLength() const { return _length; } + size_t getLength() const { return length_; } - void setLength(size_t length) { _length = length; } + void setLength(size_t length) { length_ = length; } const unsigned char* getBitfield() const; @@ -157,7 +157,7 @@ public: void setHashAlgo(const std::string& algo); // Updates hash value. This function compares begin and private variable - // _nextBegin and only when they are equal, hash is updated eating data and + // nextBegin_ and only when they are equal, hash is updated eating data and // returns true. Otherwise returns false. bool updateHash(uint32_t begin, const unsigned char* data, size_t dataLength); diff --git a/src/PieceStatMan.cc b/src/PieceStatMan.cc index 5f71bc06..098fcb9b 100644 --- a/src/PieceStatMan.cc +++ b/src/PieceStatMan.cc @@ -41,40 +41,40 @@ namespace aria2 { -PieceStat::PieceStat(size_t index):_order(0), _index(index), _count(0) {} +PieceStat::PieceStat(size_t index):order_(0), index_(index), count_(0) {} void PieceStat::addCount() { - if(_count < SIZE_MAX) { - ++_count; + if(count_ < SIZE_MAX) { + ++count_; } } void PieceStat::subCount() { - if(_count > 0) { - --_count; + if(count_ > 0) { + --count_; } } class GenPieceStat { private: - size_t _index; + size_t index_; public: - GenPieceStat():_index(0) {} + GenPieceStat():index_(0) {} SharedHandle<PieceStat> operator()() { - return SharedHandle<PieceStat>(new PieceStat(_index++)); + return SharedHandle<PieceStat>(new PieceStat(index_++)); } }; PieceStatMan::PieceStatMan(size_t pieceNum, bool randomShuffle): - _pieceStats(pieceNum), - _sortedPieceStatIndexes(pieceNum) + pieceStats_(pieceNum), + sortedPieceStatIndexes_(pieceNum) { - std::generate(_pieceStats.begin(), _pieceStats.end(), GenPieceStat()); - std::vector<SharedHandle<PieceStat> > sortedPieceStats(_pieceStats); + std::generate(pieceStats_.begin(), pieceStats_.end(), GenPieceStat()); + std::vector<SharedHandle<PieceStat> > sortedPieceStats(pieceStats_); // we need some randomness in ordering. if(randomShuffle) { std::random_shuffle(sortedPieceStats.begin(), sortedPieceStats.end(), @@ -85,7 +85,7 @@ PieceStatMan::PieceStatMan(size_t pieceNum, bool randomShuffle): for(std::vector<SharedHandle<PieceStat> >::const_iterator i = sortedPieceStats.begin(), eoi = sortedPieceStats.end(); i != eoi; ++i) { - _sortedPieceStatIndexes[order] = (*i)->getIndex(); + sortedPieceStatIndexes_[order] = (*i)->getIndex(); (*i)->setOrder(order++); } } @@ -93,76 +93,76 @@ PieceStatMan::PieceStatMan(size_t pieceNum, bool randomShuffle): class PieceStatRarer { private: - const std::vector<SharedHandle<PieceStat> >& _pieceStats; + const std::vector<SharedHandle<PieceStat> >& pieceStats_; public: PieceStatRarer(const std::vector<SharedHandle<PieceStat> >& ps): - _pieceStats(ps) {} + pieceStats_(ps) {} bool operator()(size_t lhs, size_t rhs) const { - return _pieceStats[lhs] < _pieceStats[rhs]; + return pieceStats_[lhs] < pieceStats_[rhs]; } }; void PieceStatMan::addPieceStats(const unsigned char* bitfield, size_t bitfieldLength) { - const size_t nbits = _pieceStats.size(); + const size_t nbits = pieceStats_.size(); assert(nbits <= bitfieldLength*8); for(size_t i = 0; i < nbits; ++i) { if(bitfield::test(bitfield, nbits, i)) { - _pieceStats[i]->addCount(); + pieceStats_[i]->addCount(); } } - std::sort(_sortedPieceStatIndexes.begin(), _sortedPieceStatIndexes.end(), - PieceStatRarer(_pieceStats)); + std::sort(sortedPieceStatIndexes_.begin(), sortedPieceStatIndexes_.end(), + PieceStatRarer(pieceStats_)); } void PieceStatMan::subtractPieceStats(const unsigned char* bitfield, size_t bitfieldLength) { - const size_t nbits = _pieceStats.size(); + const size_t nbits = pieceStats_.size(); assert(nbits <= bitfieldLength*8); for(size_t i = 0; i < nbits; ++i) { if(bitfield::test(bitfield, nbits, i)) { - _pieceStats[i]->subCount(); + pieceStats_[i]->subCount(); } } - std::sort(_sortedPieceStatIndexes.begin(), _sortedPieceStatIndexes.end(), - PieceStatRarer(_pieceStats)); + std::sort(sortedPieceStatIndexes_.begin(), sortedPieceStatIndexes_.end(), + PieceStatRarer(pieceStats_)); } void PieceStatMan::updatePieceStats(const unsigned char* newBitfield, size_t newBitfieldLength, const unsigned char* oldBitfield) { - const size_t nbits = _pieceStats.size(); + const size_t nbits = pieceStats_.size(); assert(nbits <= newBitfieldLength*8); for(size_t i = 0; i < nbits; ++i) { if(bitfield::test(newBitfield, nbits, i) && !bitfield::test(oldBitfield, nbits, i)) { - _pieceStats[i]->addCount(); + pieceStats_[i]->addCount(); } else if(!bitfield::test(newBitfield, nbits, i) && bitfield::test(oldBitfield, nbits, i)) { - _pieceStats[i]->subCount(); + pieceStats_[i]->subCount(); } } - std::sort(_sortedPieceStatIndexes.begin(), _sortedPieceStatIndexes.end(), - PieceStatRarer(_pieceStats)); + std::sort(sortedPieceStatIndexes_.begin(), sortedPieceStatIndexes_.end(), + PieceStatRarer(pieceStats_)); } void PieceStatMan::addPieceStats(size_t index) { std::vector<size_t>::iterator cur = - std::lower_bound(_sortedPieceStatIndexes.begin(), - _sortedPieceStatIndexes.end(), - index, PieceStatRarer(_pieceStats)); + std::lower_bound(sortedPieceStatIndexes_.begin(), + sortedPieceStatIndexes_.end(), + index, PieceStatRarer(pieceStats_)); - _pieceStats[index]->addCount(); + pieceStats_[index]->addCount(); std::vector<size_t>::iterator to = - std::upper_bound(cur+1, _sortedPieceStatIndexes.end(), - index, PieceStatRarer(_pieceStats)); + std::upper_bound(cur+1, sortedPieceStatIndexes_.end(), + index, PieceStatRarer(pieceStats_)); std::rotate(cur, cur+1, to); } diff --git a/src/PieceStatMan.h b/src/PieceStatMan.h index 6d3f0351..5a6c9df3 100644 --- a/src/PieceStatMan.h +++ b/src/PieceStatMan.h @@ -45,18 +45,18 @@ namespace aria2 { class PieceStat { private: - size_t _order; - size_t _index; - size_t _count; + size_t order_; + size_t index_; + size_t count_; public: PieceStat(size_t index); bool operator<(const PieceStat& pieceStat) const { - if(_count == pieceStat._count) { - return _order < pieceStat._order; + if(count_ == pieceStat.count_) { + return order_ < pieceStat.order_; } else { - return _count < pieceStat._count; + return count_ < pieceStat.count_; } } @@ -65,31 +65,31 @@ public: size_t getOrder() const { - return _order; + return order_; } void setOrder(size_t order) { - _order = order; + order_ = order; } size_t getIndex() const { - return _index; + return index_; } size_t getCount() const { - return _count; + return count_; } }; class PieceStatMan { private: - std::vector<SharedHandle<PieceStat> > _pieceStats; + std::vector<SharedHandle<PieceStat> > pieceStats_; - std::vector<size_t> _sortedPieceStatIndexes; + std::vector<size_t> sortedPieceStatIndexes_; public: PieceStatMan(size_t pieceNum, bool randomShuffle); @@ -108,12 +108,12 @@ public: // Returns piece index in rarest first order. const std::vector<size_t>& getRarerPieceIndexes() const { - return _sortedPieceStatIndexes; + return sortedPieceStatIndexes_; } const std::vector<SharedHandle<PieceStat> >& getPieceStats() const { - return _pieceStats; + return pieceStats_; } }; diff --git a/src/PiecedSegment.cc b/src/PiecedSegment.cc index bc774122..44e8d180 100644 --- a/src/PiecedSegment.cc +++ b/src/PiecedSegment.cc @@ -40,55 +40,55 @@ namespace aria2 { PiecedSegment::PiecedSegment (size_t pieceLength, const SharedHandle<Piece>& piece): - _pieceLength(pieceLength), _overflowLength(0), _piece(piece) + pieceLength_(pieceLength), overflowLength_(0), piece_(piece) { size_t index; - bool t = _piece->getFirstMissingBlockIndexWithoutLock(index); + bool t = piece_->getFirstMissingBlockIndexWithoutLock(index); assert(t); - _writtenLength = index*_piece->getBlockLength(); + writtenLength_ = index*piece_->getBlockLength(); } PiecedSegment::~PiecedSegment() {} bool PiecedSegment::complete() const { - return _piece->pieceComplete(); + return piece_->pieceComplete(); } size_t PiecedSegment::getIndex() const { - return _piece->getIndex(); + return piece_->getIndex(); } off_t PiecedSegment::getPosition() const { - return ((off_t)_piece->getIndex())*_pieceLength; + return ((off_t)piece_->getIndex())*pieceLength_; } off_t PiecedSegment::getPositionToWrite() const { - return getPosition()+_writtenLength; + return getPosition()+writtenLength_; } size_t PiecedSegment::getLength() const { - return _piece->getLength(); + return piece_->getLength(); } void PiecedSegment::updateWrittenLength(size_t bytes) { - size_t newWrittenLength = _writtenLength+bytes; - if(newWrittenLength > _piece->getLength()) { - _overflowLength = newWrittenLength-_piece->getLength(); - newWrittenLength = _piece->getLength(); + size_t newWrittenLength = writtenLength_+bytes; + if(newWrittenLength > piece_->getLength()) { + overflowLength_ = newWrittenLength-piece_->getLength(); + newWrittenLength = piece_->getLength(); } - for(size_t i = _writtenLength/_piece->getBlockLength(); i < newWrittenLength/_piece->getBlockLength(); ++i) { - _piece->completeBlock(i); + for(size_t i = writtenLength_/piece_->getBlockLength(); i < newWrittenLength/piece_->getBlockLength(); ++i) { + piece_->completeBlock(i); } - if(newWrittenLength == _piece->getLength()) { - _piece->completeBlock(_piece->countBlock()-1); + if(newWrittenLength == piece_->getLength()) { + piece_->completeBlock(piece_->countBlock()-1); } - _writtenLength = newWrittenLength; + writtenLength_ = newWrittenLength; } #ifdef ENABLE_MESSAGE_DIGEST @@ -96,37 +96,37 @@ void PiecedSegment::updateWrittenLength(size_t bytes) bool PiecedSegment::updateHash(uint32_t begin, const unsigned char* data, size_t dataLength) { - return _piece->updateHash(begin, data, dataLength); + return piece_->updateHash(begin, data, dataLength); } bool PiecedSegment::isHashCalculated() const { - return _piece->isHashCalculated(); + return piece_->isHashCalculated(); } std::string PiecedSegment::getHashString() { - return _piece->getHashString(); + return piece_->getHashString(); } #endif // ENABLE_MESSAGE_DIGEST void PiecedSegment::clear() { - _writtenLength = 0; - _overflowLength = 0; - _piece->clearAllBlock(); + writtenLength_ = 0; + overflowLength_ = 0; + piece_->clearAllBlock(); #ifdef ENABLE_MESSAGE_DIGEST - _piece->destroyHashContext(); + piece_->destroyHashContext(); #endif // ENABLE_MESSAGE_DIGEST } SharedHandle<Piece> PiecedSegment::getPiece() const { - return _piece; + return piece_; } } // namespace aria2 diff --git a/src/PiecedSegment.h b/src/PiecedSegment.h index 544347a1..f673f116 100644 --- a/src/PiecedSegment.h +++ b/src/PiecedSegment.h @@ -45,10 +45,10 @@ private: * Piece class has length property but it is a actual length of piece. * The last piece likely have shorter length than the other length. */ - size_t _pieceLength; - size_t _overflowLength; - SharedHandle<Piece> _piece; - size_t _writtenLength; + size_t pieceLength_; + size_t overflowLength_; + SharedHandle<Piece> piece_; + size_t writtenLength_; public: PiecedSegment(size_t pieceLength, const SharedHandle<Piece>& piece); @@ -67,17 +67,17 @@ public: virtual size_t getSegmentLength() const { - return _pieceLength; + return pieceLength_; } virtual size_t getWrittenLength() const { - return _writtenLength; + return writtenLength_; } virtual size_t getOverflowLength() const { - return _overflowLength; + return overflowLength_; } virtual void updateWrittenLength(size_t bytes); diff --git a/src/Platform.cc b/src/Platform.cc index 74f42a5d..be2acd63 100644 --- a/src/Platform.cc +++ b/src/Platform.cc @@ -71,7 +71,7 @@ namespace aria2 { -bool Platform::_initialized = false; +bool Platform::initialized_ = false; Platform::Platform() { @@ -85,10 +85,10 @@ Platform::~Platform() bool Platform::setUp() { - if (_initialized) { + if (initialized_) { return false; } - _initialized = true; + initialized_ = true; #ifdef ENABLE_NLS setlocale (LC_CTYPE, ""); @@ -132,10 +132,10 @@ bool Platform::setUp() bool Platform::tearDown() { - if (!_initialized) { + if (!initialized_) { return false; } - _initialized = false; + initialized_ = false; #ifdef HAVE_LIBGNUTLS gnutls_global_deinit(); @@ -154,7 +154,7 @@ bool Platform::tearDown() bool Platform::isInitialized() { - return _initialized; + return initialized_; } } // namespace aria2 diff --git a/src/Platform.h b/src/Platform.h index d2e4fcc8..81fa2c83 100644 --- a/src/Platform.h +++ b/src/Platform.h @@ -41,7 +41,7 @@ namespace aria2 { class Platform { private: - static bool _initialized; + static bool initialized_; public: Platform(); diff --git a/src/PollEventPoll.cc b/src/PollEventPoll.cc index 0b057aca..eaa174f1 100644 --- a/src/PollEventPoll.cc +++ b/src/PollEventPoll.cc @@ -55,17 +55,17 @@ int accumulateEvent(int events, const PollEventPoll::KEvent& event) struct pollfd PollEventPoll::KSocketEntry::getEvents() { struct pollfd pollEvent; - pollEvent.fd = _socket; + pollEvent.fd = socket_; #ifdef ENABLE_ASYNC_DNS pollEvent.events = - std::accumulate(_adnsEvents.begin(), - _adnsEvents.end(), - std::accumulate(_commandEvents.begin(), - _commandEvents.end(), 0, accumulateEvent), + std::accumulate(adnsEvents_.begin(), + adnsEvents_.end(), + std::accumulate(commandEvents_.begin(), + commandEvents_.end(), 0, accumulateEvent), accumulateEvent); #else // !ENABLE_ASYNC_DNS pollEvent.events = - std::accumulate(_commandEvents.begin(), _commandEvents.end(), 0, + std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0, accumulateEvent); #endif // !ENABLE_ASYNC_DNS pollEvent.revents = 0; @@ -73,14 +73,14 @@ struct pollfd PollEventPoll::KSocketEntry::getEvents() } PollEventPoll::PollEventPoll(): - _pollfdCapacity(1024), _pollfdNum(0), _logger(LogFactory::getInstance()) + pollfdCapacity_(1024), pollfdNum_(0), logger_(LogFactory::getInstance()) { - _pollfds = new struct pollfd[_pollfdCapacity]; + pollfds_ = new struct pollfd[pollfdCapacity_]; } PollEventPoll::~PollEventPoll() { - delete [] _pollfds; + delete [] pollfds_; } void PollEventPoll::poll(const struct timeval& tv) @@ -88,21 +88,21 @@ void PollEventPoll::poll(const struct timeval& tv) // timeout is millisec int timeout = tv.tv_sec*1000+tv.tv_usec/1000; int res; - while((res = ::poll(_pollfds, _pollfdNum, timeout)) == -1 && + while((res = ::poll(pollfds_, pollfdNum_, timeout)) == -1 && errno == EINTR); if(res > 0) { SharedHandle<KSocketEntry> se(new KSocketEntry(0)); - for(struct pollfd* first = _pollfds, *last = _pollfds+_pollfdNum; + for(struct pollfd* first = pollfds_, *last = pollfds_+pollfdNum_; first != last; ++first) { if(first->revents) { se->setSocket(first->fd); std::deque<SharedHandle<KSocketEntry> >::iterator itr = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), se); - if(itr != _socketEntries.end() && (*itr) == se) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), se); + if(itr != socketEntries_.end() && (*itr) == se) { (*itr)->processEvents(first->revents); } else { - if(_logger->debug()) { - _logger->debug("Socket %d is not found in SocketEntries.", + if(logger_->debug()) { + logger_->debug("Socket %d is not found in SocketEntries.", first->fd); } } @@ -115,7 +115,7 @@ void PollEventPoll::poll(const struct timeval& tv) // their API. So we call ares_process_fd for all ares_channel and // re-register their sockets. for(std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator i = - _nameResolverEntries.begin(), eoi = _nameResolverEntries.end(); + nameResolverEntries_.begin(), eoi = nameResolverEntries_.end(); i != eoi; ++i) { (*i)->processTimeout(); (*i)->removeSocketEvents(this); @@ -150,10 +150,10 @@ bool PollEventPoll::addEvents { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); - if(i != _socketEntries.end() && (*i) == socketEntry) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); + if(i != socketEntries_.end() && (*i) == socketEntry) { event.addSelf(*i); - for(struct pollfd* first = _pollfds, *last = _pollfds+_pollfdNum; + for(struct pollfd* first = pollfds_, *last = pollfds_+pollfdNum_; first != last; ++first) { if(first->fd == socket) { *first = (*i)->getEvents(); @@ -161,17 +161,17 @@ bool PollEventPoll::addEvents } } } else { - _socketEntries.insert(i, socketEntry); + socketEntries_.insert(i, socketEntry); event.addSelf(socketEntry); - if(_pollfdCapacity == _pollfdNum) { - _pollfdCapacity *= 2; - struct pollfd* newPollfds = new struct pollfd[_pollfdCapacity]; - memcpy(newPollfds, _pollfds, _pollfdNum*sizeof(struct pollfd)); - delete [] _pollfds; - _pollfds = newPollfds; + if(pollfdCapacity_ == pollfdNum_) { + pollfdCapacity_ *= 2; + struct pollfd* newPollfds = new struct pollfd[pollfdCapacity_]; + memcpy(newPollfds, pollfds_, pollfdNum_*sizeof(struct pollfd)); + delete [] pollfds_; + pollfds_ = newPollfds; } - _pollfds[_pollfdNum] = socketEntry->getEvents(); - ++_pollfdNum; + pollfds_[pollfdNum_] = socketEntry->getEvents(); + ++pollfdNum_; } return true; } @@ -197,18 +197,18 @@ bool PollEventPoll::deleteEvents { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); - if(i != _socketEntries.end() && (*i) == socketEntry) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); + if(i != socketEntries_.end() && (*i) == socketEntry) { event.removeSelf(*i); - for(struct pollfd* first = _pollfds, *last = _pollfds+_pollfdNum; + for(struct pollfd* first = pollfds_, *last = pollfds_+pollfdNum_; first != last; ++first) { if(first->fd == socket) { if((*i)->eventEmpty()) { - if(_pollfdNum >= 2) { + if(pollfdNum_ >= 2) { *first = *(last-1); } - --_pollfdNum; - _socketEntries.erase(i); + --pollfdNum_; + socketEntries_.erase(i); } else { *first = (*i)->getEvents(); } @@ -217,8 +217,8 @@ bool PollEventPoll::deleteEvents } return true; } else { - if(_logger->debug()) { - _logger->debug("Socket %d is not found in SocketEntries.", socket); + if(logger_->debug()) { + logger_->debug("Socket %d is not found in SocketEntries.", socket); } return false; } @@ -246,9 +246,9 @@ bool PollEventPoll::addNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { - _nameResolverEntries.push_back(entry); + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { + nameResolverEntries_.push_back(entry); entry->addSocketEvents(this); return true; } else { @@ -262,12 +262,12 @@ bool PollEventPoll::deleteNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { return false; } else { (*itr)->removeSocketEvents(this); - _nameResolverEntries.erase(itr); + nameResolverEntries_.erase(itr); return true; } } diff --git a/src/PollEventPoll.h b/src/PollEventPoll.h index b9577a98..c452d19d 100644 --- a/src/PollEventPoll.h +++ b/src/PollEventPoll.h @@ -71,20 +71,20 @@ private: friend int accumulateEvent(int events, const KEvent& event); private: - std::deque<SharedHandle<KSocketEntry> > _socketEntries; + std::deque<SharedHandle<KSocketEntry> > socketEntries_; #ifdef ENABLE_ASYNC_DNS - std::deque<SharedHandle<KAsyncNameResolverEntry> > _nameResolverEntries; + std::deque<SharedHandle<KAsyncNameResolverEntry> > nameResolverEntries_; #endif // ENABLE_ASYNC_DNS - // Allocated the number of struct pollfd in _pollfds. - int _pollfdCapacity; + // Allocated the number of struct pollfd in pollfds_. + int pollfdCapacity_; - // The number of valid struct pollfd in _pollfds. - int _pollfdNum; + // The number of valid struct pollfd in pollfds_. + int pollfdNum_; - struct pollfd* _pollfds; + struct pollfd* pollfds_; - Logger* _logger; + Logger* logger_; bool addEvents(sock_t socket, const KEvent& event); diff --git a/src/PortEventPoll.cc b/src/PortEventPoll.cc index 766ee4ab..20bf1a85 100644 --- a/src/PortEventPoll.cc +++ b/src/PortEventPoll.cc @@ -58,14 +58,14 @@ PortEventPoll::A2PortEvent PortEventPoll::KSocketEntry::getEvents() portEvent.socketEntry = this; #ifdef ENABLE_ASYNC_DNS portEvent.events = - std::accumulate(_adnsEvents.begin(), - _adnsEvents.end(), - std::accumulate(_commandEvents.begin(), - _commandEvents.end(), 0, accumulateEvent), + std::accumulate(adnsEvents_.begin(), + adnsEvents_.end(), + std::accumulate(commandEvents_.begin(), + commandEvents_.end(), 0, accumulateEvent), accumulateEvent); #else // !ENABLE_ASYNC_DNS portEvent.events = - std::accumulate(_commandEvents.begin(), _commandEvents.end(), 0, + std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0, accumulateEvent); #endif // !ENABLE_ASYNC_DNS @@ -73,29 +73,29 @@ PortEventPoll::A2PortEvent PortEventPoll::KSocketEntry::getEvents() } PortEventPoll::PortEventPoll(): - _portEventsSize(PORT_EVENTS_SIZE), - _portEvents(new port_event_t[_portEventsSize]), - _logger(LogFactory::getInstance()) + portEventsSize_(PORT_EVENTS_SIZE), + portEvents_(new port_event_t[portEventsSize_]), + logger_(LogFactory::getInstance()) { - _port = port_create(); + port_ = port_create(); } PortEventPoll::~PortEventPoll() { - if(_port != -1) { + if(port_ != -1) { int r; - while((r = close(_port)) == -1 && errno == EINTR); + while((r = close(port_)) == -1 && errno == EINTR); if(r == -1) { - _logger->error("Error occurred while closing port %d: %s", - _port, strerror(errno)); + logger_->error("Error occurred while closing port %d: %s", + port_, strerror(errno)); } } - delete [] _portEvents; + delete [] portEvents_; } bool PortEventPoll::good() const { - return _port != -1; + return port_ != -1; } void PortEventPoll::poll(const struct timeval& tv) @@ -106,22 +106,22 @@ void PortEventPoll::poll(const struct timeval& tv) // If port_getn was interrupted by signal, it can consume events but // not updat nget!. For this very annoying bug, we have to check // actually event is filled or not. - _portEvents[0].portev_user = (void*)-1; - res = port_getn(_port, _portEvents, _portEventsSize, &nget, &timeout); + portEvents_[0].portev_user = (void*)-1; + res = port_getn(port_, portEvents_, portEventsSize_, &nget, &timeout); if(res == 0 || (res == -1 && (errno == ETIME || errno == EINTR) && - _portEvents[0].portev_user != (void*)-1)) { - if(_logger->debug()) { - _logger->debug("nget=%u", nget); + portEvents_[0].portev_user != (void*)-1)) { + if(logger_->debug()) { + logger_->debug("nget=%u", nget); } for(uint_t i = 0; i < nget; ++i) { - const port_event_t& pev = _portEvents[i]; + const port_event_t& pev = portEvents_[i]; KSocketEntry* p = reinterpret_cast<KSocketEntry*>(pev.portev_user); p->processEvents(pev.portev_events); - int r = port_associate(_port, PORT_SOURCE_FD, pev.portev_object, + int r = port_associate(port_, PORT_SOURCE_FD, pev.portev_object, p->getEvents().events, p); if(r == -1) { - _logger->error("port_associate failed for file descriptor %d: cause %s", + logger_->error("port_associate failed for file descriptor %d: cause %s", pev.portev_object, strerror(errno)); } } @@ -132,7 +132,7 @@ void PortEventPoll::poll(const struct timeval& tv) // their API. So we call ares_process_fd for all ares_channel and // re-register their sockets. for(std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator i = - _nameResolverEntries.begin(), eoi = _nameResolverEntries.end(); + nameResolverEntries_.begin(), eoi = nameResolverEntries_.end(); i != eoi; ++i) { (*i)->processTimeout(); (*i)->removeSocketEvents(this); @@ -167,28 +167,28 @@ bool PortEventPoll::addEvents(sock_t socket, { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); int r = 0; - if(i != _socketEntries.end() && (*i) == socketEntry) { + if(i != socketEntries_.end() && (*i) == socketEntry) { event.addSelf(*i); A2PortEvent pv = (*i)->getEvents(); - r = port_associate(_port, PORT_SOURCE_FD, (*i)->getSocket(), + r = port_associate(port_, PORT_SOURCE_FD, (*i)->getSocket(), pv.events, pv.socketEntry); } else { - _socketEntries.insert(i, socketEntry); - if(_socketEntries.size() > _portEventsSize) { - _portEventsSize *= 2; - delete [] _portEvents; - _portEvents = new port_event_t[_portEventsSize]; + socketEntries_.insert(i, socketEntry); + if(socketEntries_.size() > portEventsSize_) { + portEventsSize_ *= 2; + delete [] portEvents_; + portEvents_ = new port_event_t[portEventsSize_]; } event.addSelf(socketEntry); A2PortEvent pv = socketEntry->getEvents(); - r = port_associate(_port, PORT_SOURCE_FD, socketEntry->getSocket(), + r = port_associate(port_, PORT_SOURCE_FD, socketEntry->getSocket(), pv.events, pv.socketEntry); } if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to add socket event %d:%s", + if(logger_->debug()) { + logger_->debug("Failed to add socket event %d:%s", socket, strerror(errno)); } return false; @@ -217,29 +217,29 @@ bool PortEventPoll::deleteEvents(sock_t socket, { SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket)); std::deque<SharedHandle<KSocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); - if(i != _socketEntries.end() && (*i) == socketEntry) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); + if(i != socketEntries_.end() && (*i) == socketEntry) { event.removeSelf(*i); int r = 0; if((*i)->eventEmpty()) { - r = port_dissociate(_port, PORT_SOURCE_FD, (*i)->getSocket()); - _socketEntries.erase(i); + r = port_dissociate(port_, PORT_SOURCE_FD, (*i)->getSocket()); + socketEntries_.erase(i); } else { A2PortEvent pv = (*i)->getEvents(); - r = port_associate(_port, PORT_SOURCE_FD, (*i)->getSocket(), + r = port_associate(port_, PORT_SOURCE_FD, (*i)->getSocket(), pv.events, pv.socketEntry); } if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to delete socket event:%s", strerror(errno)); + if(logger_->debug()) { + logger_->debug("Failed to delete socket event:%s", strerror(errno)); } return false; } else { return true; } } else { - if(_logger->debug()) { - _logger->debug("Socket %d is not found in SocketEntries.", socket); + if(logger_->debug()) { + logger_->debug("Socket %d is not found in SocketEntries.", socket); } return false; } @@ -267,9 +267,9 @@ bool PortEventPoll::addNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { - _nameResolverEntries.push_back(entry); + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { + nameResolverEntries_.push_back(entry); entry->addSocketEvents(this); return true; } else { @@ -283,12 +283,12 @@ bool PortEventPoll::deleteNameResolver SharedHandle<KAsyncNameResolverEntry> entry (new KAsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { return false; } else { (*itr)->removeSocketEvents(this); - _nameResolverEntries.erase(itr); + nameResolverEntries_.erase(itr); return true; } } diff --git a/src/PortEventPoll.h b/src/PortEventPoll.h index 1759d44f..35de0d66 100644 --- a/src/PortEventPoll.h +++ b/src/PortEventPoll.h @@ -78,20 +78,20 @@ private: friend int accumulateEvent(int events, const KEvent& event); private: - std::deque<SharedHandle<KSocketEntry> > _socketEntries; + std::deque<SharedHandle<KSocketEntry> > socketEntries_; #ifdef ENABLE_ASYNC_DNS - std::deque<SharedHandle<KAsyncNameResolverEntry> > _nameResolverEntries; + std::deque<SharedHandle<KAsyncNameResolverEntry> > nameResolverEntries_; #endif // ENABLE_ASYNC_DNS - int _port; + int port_; - size_t _portEventsSize; + size_t portEventsSize_; - port_event_t* _portEvents; + port_event_t* portEvents_; static const size_t PORT_EVENTS_SIZE = 1024; - Logger* _logger; + Logger* logger_; bool addEvents(sock_t socket, const KEvent& event); diff --git a/src/PriorityPieceSelector.cc b/src/PriorityPieceSelector.cc index cb7ded3d..eb03ed56 100644 --- a/src/PriorityPieceSelector.cc +++ b/src/PriorityPieceSelector.cc @@ -39,19 +39,19 @@ namespace aria2 { PriorityPieceSelector::PriorityPieceSelector (const SharedHandle<PieceSelector>& selector): - _selector(selector) {} + selector_(selector) {} bool PriorityPieceSelector::select (size_t& index, const unsigned char* bitfield, size_t nbits) const { - for(std::vector<size_t>::const_iterator i = _prioritizedPieces.begin(), - eoi = _prioritizedPieces.end(); i != eoi; ++i) { + for(std::vector<size_t>::const_iterator i = prioritizedPieces_.begin(), + eoi = prioritizedPieces_.end(); i != eoi; ++i) { if(bitfield::test(bitfield, nbits, *i)) { index = *i; return true; } } - return _selector->select(index, bitfield, nbits); + return selector_->select(index, bitfield, nbits); } } // namespace aria2 diff --git a/src/PriorityPieceSelector.h b/src/PriorityPieceSelector.h index 972ca85e..6726d916 100644 --- a/src/PriorityPieceSelector.h +++ b/src/PriorityPieceSelector.h @@ -45,9 +45,9 @@ namespace aria2 { class PriorityPieceSelector:public PieceSelector { private: - std::vector<size_t> _prioritizedPieces; + std::vector<size_t> prioritizedPieces_; - SharedHandle<PieceSelector> _selector; + SharedHandle<PieceSelector> selector_; public: PriorityPieceSelector(const SharedHandle<PieceSelector>& selector); @@ -58,7 +58,7 @@ public: void setPriorityPiece(InputIterator first, InputIterator last) { std::vector<size_t> t(first, last); - _prioritizedPieces.swap(t); + prioritizedPieces_.swap(t); } }; diff --git a/src/Range.h b/src/Range.h index fb77a097..86ee970c 100644 --- a/src/Range.h +++ b/src/Range.h @@ -42,20 +42,20 @@ namespace aria2 { class Range { private: - off_t _startByte; - off_t _endByte; - uint64_t _entityLength; + off_t startByte_; + off_t endByte_; + uint64_t entityLength_; public: - Range():_startByte(0), _endByte(0), _entityLength(0) {} + Range():startByte_(0), endByte_(0), entityLength_(0) {} Range(off_t startByte, off_t endByte, uint64_t entityLength): - _startByte(startByte), _endByte(endByte), _entityLength(entityLength) {} + startByte_(startByte), endByte_(endByte), entityLength_(entityLength) {} bool operator==(const Range& range) const { - return _startByte == range._startByte && - _endByte == range._endByte && - _entityLength == range._entityLength; + return startByte_ == range.startByte_ && + endByte_ == range.endByte_ && + entityLength_ == range.entityLength_; } bool operator!=(const Range& range) const @@ -65,23 +65,23 @@ public: off_t getStartByte() const { - return _startByte; + return startByte_; } off_t getEndByte() const { - return _endByte; + return endByte_; } uint64_t getEntityLength() const { - return _entityLength; + return entityLength_; } uint64_t getContentLength() const { - if(_endByte >= _startByte) { - return _endByte-_startByte+1; + if(endByte_ >= startByte_) { + return endByte_-startByte_+1; } else { return 0; } diff --git a/src/RangeBtMessage.cc b/src/RangeBtMessage.cc index 3e480ae2..b5318810 100644 --- a/src/RangeBtMessage.cc +++ b/src/RangeBtMessage.cc @@ -43,9 +43,9 @@ RangeBtMessage::RangeBtMessage(uint8_t id, const std::string& name, size_t index, uint32_t begin, size_t length) :SimpleBtMessage(id, name), - _index(index), - _begin(begin), - _length(length) {} + index_(index), + begin_(begin), + length_(length) {} unsigned char* RangeBtMessage::createMessage() { @@ -59,9 +59,9 @@ unsigned char* RangeBtMessage::createMessage() */ unsigned char* msg = new unsigned char[MESSAGE_LENGTH]; bittorrent::createPeerMessageString(msg, MESSAGE_LENGTH, 13, getId()); - bittorrent::setIntParam(&msg[5], _index); - bittorrent::setIntParam(&msg[9], _begin); - bittorrent::setIntParam(&msg[13], _length); + bittorrent::setIntParam(&msg[5], index_); + bittorrent::setIntParam(&msg[9], begin_); + bittorrent::setIntParam(&msg[13], length_); return msg; } @@ -72,9 +72,9 @@ size_t RangeBtMessage::getMessageLength() std::string RangeBtMessage::toString() const { - return strconcat(getName(), " index=", util::uitos(_index), - ", begin=", util::uitos(_begin), - ", length=", util::uitos(_length)); + return strconcat(getName(), " index=", util::uitos(index_), + ", begin=", util::uitos(begin_), + ", length=", util::uitos(length_)); } } // namespace aria2 diff --git a/src/RangeBtMessage.h b/src/RangeBtMessage.h index 94ddacc8..a1f8cb84 100644 --- a/src/RangeBtMessage.h +++ b/src/RangeBtMessage.h @@ -42,9 +42,9 @@ namespace aria2 { class RangeBtMessage : public SimpleBtMessage { private: - size_t _index; - uint32_t _begin; - size_t _length; + size_t index_; + uint32_t begin_; + size_t length_; static const size_t MESSAGE_LENGTH = 17; protected: @@ -64,17 +64,17 @@ public: RangeBtMessage(uint8_t id, const std::string& name, size_t index, uint32_t begin, size_t length); - size_t getIndex() const { return _index; } + size_t getIndex() const { return index_; } - void setIndex(size_t index) { _index = index; } + void setIndex(size_t index) { index_ = index; } - uint32_t getBegin() const { return _begin; } + uint32_t getBegin() const { return begin_; } - void setBegin(uint32_t begin) { _begin = begin; } + void setBegin(uint32_t begin) { begin_ = begin; } - size_t getLength() const { return _length; } + size_t getLength() const { return length_; } - void setLength(size_t length) { _length = length; } + void setLength(size_t length) { length_ = length; } virtual unsigned char* createMessage(); diff --git a/src/RangeBtMessageValidator.h b/src/RangeBtMessageValidator.h index 87e96385..e7242412 100644 --- a/src/RangeBtMessageValidator.h +++ b/src/RangeBtMessageValidator.h @@ -43,25 +43,25 @@ namespace aria2 { class RangeBtMessageValidator : public BtMessageValidator { private: - const RangeBtMessage* _message; - size_t _numPiece; - size_t _pieceLength; + const RangeBtMessage* message_; + size_t numPiece_; + size_t pieceLength_; public: RangeBtMessageValidator(const RangeBtMessage* message, size_t numPiece, size_t pieceLength): - _message(message), - _numPiece(numPiece), - _pieceLength(pieceLength) {} + message_(message), + numPiece_(numPiece), + pieceLength_(pieceLength) {} virtual void validate() { - bittorrent::checkIndex(_message->getIndex(), _numPiece); - bittorrent::checkBegin(_message->getBegin(), _pieceLength); - bittorrent::checkLength(_message->getLength()); - bittorrent::checkRange(_message->getBegin(), - _message->getLength(), - _pieceLength); + bittorrent::checkIndex(message_->getIndex(), numPiece_); + bittorrent::checkBegin(message_->getBegin(), pieceLength_); + bittorrent::checkLength(message_->getLength()); + bittorrent::checkRange(message_->getBegin(), + message_->getLength(), + pieceLength_); } }; diff --git a/src/RarestPieceSelector.cc b/src/RarestPieceSelector.cc index 235cd634..4c4e040d 100644 --- a/src/RarestPieceSelector.cc +++ b/src/RarestPieceSelector.cc @@ -42,22 +42,22 @@ namespace aria2 { RarestPieceSelector::RarestPieceSelector -(const SharedHandle<PieceStatMan>& pieceStatMan):_pieceStatMan(pieceStatMan) {} +(const SharedHandle<PieceStatMan>& pieceStatMan):pieceStatMan_(pieceStatMan) {} class FindRarestPiece { private: - const unsigned char* _misbitfield; - size_t _numbits; + const unsigned char* misbitfield_; + size_t numbits_; public: FindRarestPiece(const unsigned char* misbitfield, size_t numbits): - _misbitfield(misbitfield), _numbits(numbits) {} + misbitfield_(misbitfield), numbits_(numbits) {} bool operator()(const size_t& index) { - assert(index < _numbits); + assert(index < numbits_); unsigned char mask = (128 >> (index%8)); - return _misbitfield[index/8]&mask; + return misbitfield_[index/8]&mask; } }; @@ -65,7 +65,7 @@ bool RarestPieceSelector::select (size_t& index, const unsigned char* bitfield, size_t nbits) const { const std::vector<size_t>& pieceIndexes = - _pieceStatMan->getRarerPieceIndexes(); + pieceStatMan_->getRarerPieceIndexes(); std::vector<size_t>::const_iterator i = std::find_if(pieceIndexes.begin(), pieceIndexes.end(), FindRarestPiece(bitfield, nbits)); diff --git a/src/RarestPieceSelector.h b/src/RarestPieceSelector.h index 2f1936c7..94f0ba1d 100644 --- a/src/RarestPieceSelector.h +++ b/src/RarestPieceSelector.h @@ -44,7 +44,7 @@ class PieceStatMan; class RarestPieceSelector:public PieceSelector { private: - SharedHandle<PieceStatMan> _pieceStatMan; + SharedHandle<PieceStatMan> pieceStatMan_; public: RarestPieceSelector(const SharedHandle<PieceStatMan>& pieceStatMan); diff --git a/src/RealtimeCommand.cc b/src/RealtimeCommand.cc index 0a32e467..3aae9099 100644 --- a/src/RealtimeCommand.cc +++ b/src/RealtimeCommand.cc @@ -47,23 +47,23 @@ namespace aria2 { RealtimeCommand::RealtimeCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e): Command(cuid), - _requestGroup(requestGroup), - _e(e) + requestGroup_(requestGroup), + e_(e) { setStatusRealtime(); - _requestGroup->increaseNumCommand(); + requestGroup_->increaseNumCommand(); } RealtimeCommand::~RealtimeCommand() { - _requestGroup->decreaseNumCommand(); + requestGroup_->decreaseNumCommand(); } bool RealtimeCommand::execute() { setStatusRealtime(); - _e->setNoWait(true); + e_->setNoWait(true); try { return executeInternal(); } catch(Exception& e) { diff --git a/src/RealtimeCommand.h b/src/RealtimeCommand.h index 779e05cb..29d82dae 100644 --- a/src/RealtimeCommand.h +++ b/src/RealtimeCommand.h @@ -45,17 +45,17 @@ class Exception; class RealtimeCommand : public Command { private: - RequestGroup* _requestGroup; - DownloadEngine* _e; + RequestGroup* requestGroup_; + DownloadEngine* e_; protected: DownloadEngine* getDownloadEngine() const { - return _e; + return e_; } RequestGroup* getRequestGroup() const { - return _requestGroup; + return requestGroup_; } public: RealtimeCommand(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e); diff --git a/src/ReceiverMSEHandshakeCommand.cc b/src/ReceiverMSEHandshakeCommand.cc index f8c3c210..d3404880 100644 --- a/src/ReceiverMSEHandshakeCommand.cc +++ b/src/ReceiverMSEHandshakeCommand.cc @@ -68,15 +68,15 @@ ReceiverMSEHandshakeCommand::ReceiverMSEHandshakeCommand const SharedHandle<SocketCore>& s): PeerAbstractCommand(cuid, peer, e, s), - _sequence(RECEIVER_IDENTIFY_HANDSHAKE), - _mseHandshake(new MSEHandshake(cuid, s, e->getOption())) + sequence_(RECEIVER_IDENTIFY_HANDSHAKE), + mseHandshake_(new MSEHandshake(cuid, s, e->getOption())) { setTimeout(e->getOption()->getAsInt(PREF_PEER_CONNECTION_TIMEOUT)); } ReceiverMSEHandshakeCommand::~ReceiverMSEHandshakeCommand() { - delete _mseHandshake; + delete mseHandshake_; } bool ReceiverMSEHandshakeCommand::exitBeforeExecute() @@ -87,15 +87,15 @@ bool ReceiverMSEHandshakeCommand::exitBeforeExecute() bool ReceiverMSEHandshakeCommand::executeInternal() { - switch(_sequence) { + switch(sequence_) { case RECEIVER_IDENTIFY_HANDSHAKE: { - MSEHandshake::HANDSHAKE_TYPE type = _mseHandshake->identifyHandshakeType(); + MSEHandshake::HANDSHAKE_TYPE type = mseHandshake_->identifyHandshakeType(); switch(type) { case MSEHandshake::HANDSHAKE_NOT_YET: break; case MSEHandshake::HANDSHAKE_ENCRYPTED: - _mseHandshake->initEncryptionFacility(false); - _sequence = RECEIVER_WAIT_KEY; + mseHandshake_->initEncryptionFacility(false); + sequence_ = RECEIVER_WAIT_KEY; break; case MSEHandshake::HANDSHAKE_LEGACY: { if(getDownloadEngine()->getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) { @@ -105,8 +105,8 @@ bool ReceiverMSEHandshakeCommand::executeInternal() } SharedHandle<PeerConnection> peerConnection (new PeerConnection(getCuid(), getSocket())); - peerConnection->presetBuffer(_mseHandshake->getBuffer(), - _mseHandshake->getBufferLength()); + peerConnection->presetBuffer(mseHandshake_->getBuffer(), + mseHandshake_->getBufferLength()); Command* c = new PeerReceiveHandshakeCommand(getCuid(), getPeer(), getDownloadEngine(), @@ -121,25 +121,25 @@ bool ReceiverMSEHandshakeCommand::executeInternal() break; } case RECEIVER_WAIT_KEY: { - if(_mseHandshake->receivePublicKey()) { - if(_mseHandshake->sendPublicKey()) { - _sequence = RECEIVER_FIND_HASH_MARKER; + if(mseHandshake_->receivePublicKey()) { + if(mseHandshake_->sendPublicKey()) { + sequence_ = RECEIVER_FIND_HASH_MARKER; } else { setWriteCheckSocket(getSocket()); - _sequence = RECEIVER_SEND_KEY_PENDING; + sequence_ = RECEIVER_SEND_KEY_PENDING; } } break; } case RECEIVER_SEND_KEY_PENDING: - if(_mseHandshake->sendPublicKey()) { + if(mseHandshake_->sendPublicKey()) { disableWriteCheckSocket(); - _sequence = RECEIVER_FIND_HASH_MARKER; + sequence_ = RECEIVER_FIND_HASH_MARKER; } break; case RECEIVER_FIND_HASH_MARKER: { - if(_mseHandshake->findReceiverHashMarker()) { - _sequence = RECEIVER_RECEIVE_PAD_C_LENGTH; + if(mseHandshake_->findReceiverHashMarker()) { + sequence_ = RECEIVER_RECEIVE_PAD_C_LENGTH; } break; } @@ -147,37 +147,37 @@ bool ReceiverMSEHandshakeCommand::executeInternal() std::vector<SharedHandle<DownloadContext> > downloadContexts; getDownloadEngine()->getBtRegistry()->getAllDownloadContext (std::back_inserter(downloadContexts)); - if(_mseHandshake->receiveReceiverHashAndPadCLength(downloadContexts)) { - _sequence = RECEIVER_RECEIVE_PAD_C; + if(mseHandshake_->receiveReceiverHashAndPadCLength(downloadContexts)) { + sequence_ = RECEIVER_RECEIVE_PAD_C; } break; } case RECEIVER_RECEIVE_PAD_C: { - if(_mseHandshake->receivePad()) { - _sequence = RECEIVER_RECEIVE_IA_LENGTH; + if(mseHandshake_->receivePad()) { + sequence_ = RECEIVER_RECEIVE_IA_LENGTH; } break; } case RECEIVER_RECEIVE_IA_LENGTH: { - if(_mseHandshake->receiveReceiverIALength()) { - _sequence = RECEIVER_RECEIVE_IA; + if(mseHandshake_->receiveReceiverIALength()) { + sequence_ = RECEIVER_RECEIVE_IA; } break; } case RECEIVER_RECEIVE_IA: { - if(_mseHandshake->receiveReceiverIA()) { - if(_mseHandshake->sendReceiverStep2()) { + if(mseHandshake_->receiveReceiverIA()) { + if(mseHandshake_->sendReceiverStep2()) { createCommand(); return true; } else { setWriteCheckSocket(getSocket()); - _sequence = RECEIVER_SEND_STEP2_PENDING; + sequence_ = RECEIVER_SEND_STEP2_PENDING; } } break; } case RECEIVER_SEND_STEP2_PENDING: - if(_mseHandshake->sendReceiverStep2()) { + if(mseHandshake_->sendReceiverStep2()) { disableWriteCheckSocket(); createCommand(); return true; @@ -192,15 +192,15 @@ void ReceiverMSEHandshakeCommand::createCommand() { SharedHandle<PeerConnection> peerConnection (new PeerConnection(getCuid(), getSocket())); - if(_mseHandshake->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4) { - peerConnection->enableEncryption(_mseHandshake->getEncryptor(), - _mseHandshake->getDecryptor()); + if(mseHandshake_->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4) { + peerConnection->enableEncryption(mseHandshake_->getEncryptor(), + mseHandshake_->getDecryptor()); } - if(_mseHandshake->getIALength() > 0) { - peerConnection->presetBuffer(_mseHandshake->getIA(), - _mseHandshake->getIALength()); + if(mseHandshake_->getIALength() > 0) { + peerConnection->presetBuffer(mseHandshake_->getIA(), + mseHandshake_->getIALength()); } - // TODO add _mseHandshake->getInfoHash() to PeerReceiveHandshakeCommand + // TODO add mseHandshake_->getInfoHash() to PeerReceiveHandshakeCommand // as a hint. If this info hash and one in BitTorrent Handshake does not // match, then drop connection. Command* c = diff --git a/src/ReceiverMSEHandshakeCommand.h b/src/ReceiverMSEHandshakeCommand.h index 925c7a7c..ea055913 100644 --- a/src/ReceiverMSEHandshakeCommand.h +++ b/src/ReceiverMSEHandshakeCommand.h @@ -58,9 +58,9 @@ public: RECEIVER_SEND_STEP2_PENDING, }; private: - Seq _sequence; + Seq sequence_; - MSEHandshake* _mseHandshake; + MSEHandshake* mseHandshake_; void createCommand(); protected: diff --git a/src/RecoverableException.cc b/src/RecoverableException.cc index 933c9284..fd6f40b4 100644 --- a/src/RecoverableException.cc +++ b/src/RecoverableException.cc @@ -45,23 +45,23 @@ SharedHandle<Exception> RecoverableException::copy() const RecoverableException::RecoverableException (const char* file, int line, const std::string& msg): Exception(file, line, msg), - _code(downloadresultcode::UNKNOWN_ERROR) {} + code_(downloadresultcode::UNKNOWN_ERROR) {} RecoverableException::RecoverableException (const char* file, int line, const std::string& msg, const Exception& cause): Exception(file, line, msg, cause), - _code(downloadresultcode::UNKNOWN_ERROR) {} + code_(downloadresultcode::UNKNOWN_ERROR) {} RecoverableException::RecoverableException (const char* file, int line, const RecoverableException& e): Exception(file, line, e), - _code(downloadresultcode::UNKNOWN_ERROR) {} + code_(downloadresultcode::UNKNOWN_ERROR) {} RecoverableException::RecoverableException (const char* file, int line, const std::string& msg, downloadresultcode::RESULT result): - Exception(file, line, msg), _code(result) {} + Exception(file, line, msg), code_(result) {} } // namespace aria2 diff --git a/src/RecoverableException.h b/src/RecoverableException.h index 25dcc735..0b77074a 100644 --- a/src/RecoverableException.h +++ b/src/RecoverableException.h @@ -41,7 +41,7 @@ namespace aria2 { class RecoverableException:public Exception { private: - downloadresultcode::RESULT _code; + downloadresultcode::RESULT code_; protected: virtual SharedHandle<Exception> copy() const; @@ -57,7 +57,7 @@ public: RecoverableException(const char* file, int line, const std::string& msg, downloadresultcode::RESULT result); - downloadresultcode::RESULT getCode() const { return _code; } + downloadresultcode::RESULT getCode() const { return code_; } }; } // namespace aria2 diff --git a/src/Request.cc b/src/Request.cc index 9fbba5ab..761ec1b9 100644 --- a/src/Request.cc +++ b/src/Request.cc @@ -55,16 +55,16 @@ const std::string Request::PROTO_HTTPS("https"); const std::string Request::PROTO_FTP("ftp"); Request::Request(): - _port(0), _tryCount(0), - _redirectCount(0), - _supportsPersistentConnection(true), - _keepAliveHint(false), - _pipeliningHint(false), - _maxPipelinedRequest(1), - _method(METHOD_GET), - _hasPassword(false), - _ipv6LiteralAddress(false), - _removalRequested(false) + port_(0), tryCount_(0), + redirectCount_(0), + supportsPersistentConnection_(true), + keepAliveHint_(false), + pipeliningHint_(false), + maxPipelinedRequest_(1), + method_(METHOD_GET), + hasPassword_(false), + ipv6LiteralAddress_(false), + removalRequested_(false) {} static std::string removeFragment(const std::string& uri) @@ -108,36 +108,36 @@ static std::string percentEncode(const std::string& src) } bool Request::setUri(const std::string& uri) { - _supportsPersistentConnection = true; - _uri = uri; - return parseUri(_uri); + supportsPersistentConnection_ = true; + uri_ = uri; + return parseUri(uri_); } bool Request::resetUri() { - _previousUri = _referer; - _supportsPersistentConnection = true; - return parseUri(_uri); + previousUri_ = referer_; + supportsPersistentConnection_ = true; + return parseUri(uri_); } void Request::setReferer(const std::string& uri) { - _referer = _previousUri = percentEncode(removeFragment(uri)); + referer_ = previousUri_ = percentEncode(removeFragment(uri)); } bool Request::redirectUri(const std::string& uri) { - _previousUri = A2STR::NIL; - _supportsPersistentConnection = true; - ++_redirectCount; + previousUri_ = A2STR::NIL; + supportsPersistentConnection_ = true; + ++redirectCount_; std::string redirectedUri; if(uri.find("://") == std::string::npos) { // rfc2616 requires absolute URI should be provided by Location header // field, but some servers don't obey this rule. if(util::startsWith(uri, "/")) { // abosulute path - redirectedUri = strconcat(_protocol, "://", _host, uri); + redirectedUri = strconcat(protocol_, "://", host_, uri); } else { // relative path - redirectedUri = strconcat(_protocol, "://", _host, _dir, "/", uri); + redirectedUri = strconcat(protocol_, "://", host_, dir_, "/", uri); } } else { redirectedUri = uri; @@ -147,16 +147,16 @@ bool Request::redirectUri(const std::string& uri) { bool Request::parseUri(const std::string& srcUri) { const std::string uri = percentEncode(removeFragment(srcUri)); - _currentUri = uri; - _host = A2STR::NIL; - _port = 0; - _dir = A2STR::NIL; - _file = A2STR::NIL; - _query = A2STR::NIL; - _username = A2STR::NIL; - _password = A2STR::NIL; - _hasPassword = false; - _ipv6LiteralAddress = false; + currentUri_ = uri; + host_ = A2STR::NIL; + port_ = 0; + dir_ = A2STR::NIL; + file_ = A2STR::NIL; + query_ = A2STR::NIL; + username_ = A2STR::NIL; + password_ = A2STR::NIL; + hasPassword_ = false; + ipv6LiteralAddress_ = false; // http://user:password@aria2.sourceforge.net:80/dir/file?query // | || || | | | @@ -177,13 +177,13 @@ bool Request::parseUri(const std::string& srcUri) { for(; queryFirst != uri.end(); ++queryFirst) { if(*queryFirst == '?') break; } - _query = std::string(queryFirst, uri.end()); + query_ = std::string(queryFirst, uri.end()); // find protocol std::string::size_type protocolOffset = uri.find("://"); if(protocolOffset == std::string::npos) return false; - _protocol = std::string(uri.begin(), uri.begin()+protocolOffset); + protocol_ = std::string(uri.begin(), uri.begin()+protocolOffset); uint16_t defPort; - if((defPort = FeatureConfig::getInstance()->getDefaultPort(_protocol)) == 0) { + if((defPort = FeatureConfig::getInstance()->getDefaultPort(protocol_)) == 0) { return false; } // find authority @@ -206,12 +206,12 @@ bool Request::parseUri(const std::string& srcUri) { std::string::const_iterator userLast = authorityFirst; for(; userLast != userInfoLast; ++userLast) { if(*userLast == ':') { - _password = util::percentDecode(std::string(userLast+1,userInfoLast)); - _hasPassword = true; + password_ = util::percentDecode(std::string(userLast+1,userInfoLast)); + hasPassword_ = true; break; } } - _username = util::percentDecode(std::string(authorityFirst, userLast)); + username_ = util::percentDecode(std::string(authorityFirst, userLast)); break; } } @@ -223,18 +223,18 @@ bool Request::parseUri(const std::string& srcUri) { if(*hostLast == ']') { ++hostLast; if(hostLast == authorityLast) { - _ipv6LiteralAddress = true; + ipv6LiteralAddress_ = true; } else { if(*hostLast == ':') { portFirst = hostLast; ++portFirst; - _ipv6LiteralAddress = true; + ipv6LiteralAddress_ = true; } } break; } } - if(!_ipv6LiteralAddress) { + if(!ipv6LiteralAddress_) { return false; } } else { @@ -253,22 +253,22 @@ bool Request::parseUri(const std::string& srcUri) { if(portFirst == authorityLast) { // If port is not specified, then we set it to default port of // its protocol.. - _port = defPort; + port_ = defPort; } else { uint32_t tempPort; if(util::parseUIntNoThrow(tempPort, std::string(portFirst, authorityLast))){ if(65535 < tempPort) { return false; } - _port = tempPort; + port_ = tempPort; } else { return false; } } - if(_ipv6LiteralAddress) { - _host = std::string(hostPortFirst+1, hostLast-1); + if(ipv6LiteralAddress_) { + host_ = std::string(hostPortFirst+1, hostLast-1); } else { - _host = std::string(hostPortFirst, hostLast); + host_ = std::string(hostPortFirst, hostLast); } // find directory and file part std::string::const_iterator dirLast = authorityLast; @@ -279,7 +279,7 @@ bool Request::parseUri(const std::string& srcUri) { } } if(dirLast != queryFirst) { - _file = std::string(dirLast+1, queryFirst); + file_ = std::string(dirLast+1, queryFirst); } // Erase duplicated slashes. std::string::const_iterator dirFirst = authorityLast; @@ -296,21 +296,21 @@ bool Request::parseUri(const std::string& srcUri) { } } if(dirFirst == dirLast) { - _dir = A2STR::SLASH_C; + dir_ = A2STR::SLASH_C; } else { - _dir = std::string(dirFirst, dirLast); + dir_ = std::string(dirFirst, dirLast); } return true; } void Request::resetRedirectCount() { - _redirectCount = 0; + redirectCount_ = 0; } void Request::setMaxPipelinedRequest(unsigned int num) { - _maxPipelinedRequest = num; + maxPipelinedRequest_ = num; } const SharedHandle<PeerStat>& Request::initPeerStat() @@ -318,9 +318,9 @@ const SharedHandle<PeerStat>& Request::initPeerStat() // Use host and protocol in original URI, because URI selector // selects URI based on original URI, not redirected one. Request origReq; - origReq.setUri(_uri); - _peerStat.reset(new PeerStat(0, origReq.getHost(), origReq.getProtocol())); - return _peerStat; + origReq.setUri(uri_); + peerStat_.reset(new PeerStat(0, origReq.getHost(), origReq.getProtocol())); + return peerStat_; } } // namespace aria2 diff --git a/src/Request.h b/src/Request.h index db9b9f5c..f05b9377 100644 --- a/src/Request.h +++ b/src/Request.h @@ -46,80 +46,80 @@ namespace aria2 { class Request { private: - std::string _uri; - std::string _currentUri; + std::string uri_; + std::string currentUri_; /** * URI previously requested to the server. This is used as Referer */ - std::string _previousUri; + std::string previousUri_; /** * URI used as Referer in the initial request */ - std::string _referer; - std::string _protocol; - std::string _host; - uint16_t _port; - std::string _dir; - std::string _file; + std::string referer_; + std::string protocol_; + std::string host_; + uint16_t port_; + std::string dir_; + std::string file_; /* after ? mark(includes '?' itself) */ - std::string _query; - unsigned int _tryCount; + std::string query_; + unsigned int tryCount_; - unsigned int _redirectCount; + unsigned int redirectCount_; // whether or not the server supports persistent connection - bool _supportsPersistentConnection; + bool supportsPersistentConnection_; // enable keep-alive if possible. - bool _keepAliveHint; + bool keepAliveHint_; // enable pipelining if possible. - bool _pipeliningHint; + bool pipeliningHint_; // maximum number of pipelined requests - unsigned int _maxPipelinedRequest; + unsigned int maxPipelinedRequest_; - std::string _method; + std::string method_; - std::string _username; + std::string username_; - std::string _password; + std::string password_; - bool _hasPassword; + bool hasPassword_; - bool _ipv6LiteralAddress; + bool ipv6LiteralAddress_; - SharedHandle<PeerStat> _peerStat; + SharedHandle<PeerStat> peerStat_; - bool _removalRequested; + bool removalRequested_; bool parseUri(const std::string& uri); public: Request(); - // Sets uri to _uri and parses URI. Returns true if parsing goes + // Sets uri to uri_ and parses URI. Returns true if parsing goes // successful, otherwise returns false. bool setUri(const std::string& uri); - // Parses URI. _uri field are not altered by this method. Returns + // Parses URI. uri_ field are not altered by this method. Returns // true if parsing goes successful, otherwise returns false. bool redirectUri(const std::string& uri); bool resetUri(); - void resetTryCount() { _tryCount = 0; } - void addTryCount() { ++_tryCount; } - unsigned int getTryCount() const { return _tryCount; } + void resetTryCount() { tryCount_ = 0; } + void addTryCount() { ++tryCount_; } + unsigned int getTryCount() const { return tryCount_; } void resetRedirectCount(); unsigned int getRedirectCount() const { - return _redirectCount; + return redirectCount_; } // Returns URI passed by setUri() - const std::string& getUri() const { return _uri; } - const std::string& getCurrentUri() const { return _currentUri; } - const std::string& getPreviousUri() const { return _previousUri; } - const std::string& getReferer() const { return _referer; } + const std::string& getUri() const { return uri_; } + const std::string& getCurrentUri() const { return currentUri_; } + const std::string& getPreviousUri() const { return previousUri_; } + const std::string& getReferer() const { return referer_; } void setReferer(const std::string& uri); - const std::string& getProtocol() const { return _protocol; } - const std::string& getHost() const { return _host; } + const std::string& getProtocol() const { return protocol_; } + const std::string& getHost() const { return host_; } // Same as getHost(), but for IPv6 literal addresses, enclose them // with square brackets and return. std::string getURIHost() const @@ -130,90 +130,90 @@ public: return getHost(); } } - uint16_t getPort() const { return _port; } - const std::string& getDir() const { return _dir; } - const std::string& getFile() const { return _file;} - const std::string& getQuery() const { return _query; } - bool isIPv6LiteralAddress() const { return _ipv6LiteralAddress; } + uint16_t getPort() const { return port_; } + const std::string& getDir() const { return dir_; } + const std::string& getFile() const { return file_;} + const std::string& getQuery() const { return query_; } + bool isIPv6LiteralAddress() const { return ipv6LiteralAddress_; } void supportsPersistentConnection(bool f) { - _supportsPersistentConnection = f; + supportsPersistentConnection_ = f; } bool supportsPersistentConnection() { - return _supportsPersistentConnection; + return supportsPersistentConnection_; } bool isKeepAliveEnabled() const { - return _supportsPersistentConnection && _keepAliveHint; + return supportsPersistentConnection_ && keepAliveHint_; } void setKeepAliveHint(bool keepAliveHint) { - _keepAliveHint = keepAliveHint; + keepAliveHint_ = keepAliveHint; } bool isPipeliningEnabled() { - return _supportsPersistentConnection && _pipeliningHint; + return supportsPersistentConnection_ && pipeliningHint_; } void setPipeliningHint(bool pipeliningHint) { - _pipeliningHint = pipeliningHint; + pipeliningHint_ = pipeliningHint; } bool isPipeliningHint() const { - return _pipeliningHint; + return pipeliningHint_; } void setMaxPipelinedRequest(unsigned int num); unsigned int getMaxPipelinedRequest() const { - return _maxPipelinedRequest; + return maxPipelinedRequest_; } void setMethod(const std::string& method) { - _method = method; + method_ = method; } const std::string& getUsername() const { - return _username; + return username_; } const std::string& getPassword() const { - return _password; + return password_; } // Returns true if current URI has embedded password. bool hasPassword() const { - return _hasPassword; + return hasPassword_; } const std::string& getMethod() const { - return _method; + return method_; } - const SharedHandle<PeerStat>& getPeerStat() const { return _peerStat; } + const SharedHandle<PeerStat>& getPeerStat() const { return peerStat_; } const SharedHandle<PeerStat>& initPeerStat(); void requestRemoval() { - _removalRequested = true; + removalRequested_ = true; } bool removalRequested() const { - return _removalRequested; + return removalRequested_; } static const std::string METHOD_GET; diff --git a/src/RequestGroup.cc b/src/RequestGroup.cc index 5774da48..948f4a08 100644 --- a/src/RequestGroup.cc +++ b/src/RequestGroup.cc @@ -111,41 +111,41 @@ namespace aria2 { -gid_t RequestGroup::_gidCounter = 0; +gid_t RequestGroup::gidCounter_ = 0; RequestGroup::RequestGroup(const SharedHandle<Option>& option): - _gid(newGID()), - _option(new Option(*option.get())), - _numConcurrentCommand(option->getAsInt(PREF_SPLIT)), - _numStreamConnection(0), - _numCommand(0), - _saveControlFile(true), - _progressInfoFile(new NullProgressInfoFile()), - _preLocalFileCheckEnabled(true), - _haltRequested(false), - _forceHaltRequested(false), - _haltReason(RequestGroup::NONE), - _pauseRequested(false), - _uriSelector(new InOrderURISelector()), - _lastModifiedTime(Time::null()), - _fileNotFoundCount(0), - _timeout(option->getAsInt(PREF_TIMEOUT)), - _inMemoryDownload(false), - _maxDownloadSpeedLimit(option->getAsInt(PREF_MAX_DOWNLOAD_LIMIT)), - _maxUploadSpeedLimit(option->getAsInt(PREF_MAX_UPLOAD_LIMIT)), - _belongsToGID(0), - _requestGroupMan(0), - _resumeFailureCount(0), - _logger(LogFactory::getInstance()) -{ - _fileAllocationEnabled = _option->get(PREF_FILE_ALLOCATION) != V_NONE; + gid_(newGID()), + option_(new Option(*option.get())), + numConcurrentCommand_(option->getAsInt(PREF_SPLIT)), + numStreamConnection_(0), + numCommand_(0), + saveControlFile_(true), + progressInfoFile_(new NullProgressInfoFile()), + preLocalFileCheckEnabled_(true), + haltRequested_(false), + forceHaltRequested_(false), + haltReason_(RequestGroup::NONE), + pauseRequested_(false), + uriSelector_(new InOrderURISelector()), + lastModifiedTime_(Time::null()), + fileNotFoundCount_(0), + timeout_(option->getAsInt(PREF_TIMEOUT)), + inMemoryDownload_(false), + maxDownloadSpeedLimit_(option->getAsInt(PREF_MAX_DOWNLOAD_LIMIT)), + maxUploadSpeedLimit_(option->getAsInt(PREF_MAX_UPLOAD_LIMIT)), + belongsToGID_(0), + requestGroupMan_(0), + resumeFailureCount_(0), + logger_(LogFactory::getInstance()) +{ + fileAllocationEnabled_ = option_->get(PREF_FILE_ALLOCATION) != V_NONE; // Add types to be sent as a Accept header value here. // It would be good to put this value in Option so that user can tweak // and add this list. // The mime types of Metalink is used for `transparent metalink'. addAcceptType(DownloadHandlerConstants::getMetalinkContentTypes().begin(), DownloadHandlerConstants::getMetalinkContentTypes().end()); - if(!_option->getAsBool(PREF_DRY_RUN)) { + if(!option_->getAsBool(PREF_DRY_RUN)) { initializePreDownloadHandler(); initializePostDownloadHandler(); } @@ -155,19 +155,19 @@ RequestGroup::~RequestGroup() {} bool RequestGroup::downloadFinished() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return false; } else { - return _pieceStorage->downloadFinished(); + return pieceStorage_->downloadFinished(); } } bool RequestGroup::allDownloadFinished() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return false; } else { - return _pieceStorage->allDownloadFinished(); + return pieceStorage_->allDownloadFinished(); } } @@ -176,23 +176,23 @@ downloadresultcode::RESULT RequestGroup::downloadResult() const if (downloadFinished()) return downloadresultcode::FINISHED; else { - if (_lastUriResult.isNull()) { - if(_haltReason == RequestGroup::USER_REQUEST || - _haltReason == RequestGroup::SHUTDOWN_SIGNAL) { + if (lastUriResult_.isNull()) { + if(haltReason_ == RequestGroup::USER_REQUEST || + haltReason_ == RequestGroup::SHUTDOWN_SIGNAL) { return downloadresultcode::IN_PROGRESS; } else { return downloadresultcode::UNKNOWN_ERROR; } } else { - return _lastUriResult->getResult(); + return lastUriResult_->getResult(); } } } void RequestGroup::closeFile() { - if(!_pieceStorage.isNull()) { - _pieceStorage->getDiskAdaptor()->closeFile(); + if(!pieceStorage_.isNull()) { + pieceStorage_->getDiskAdaptor()->closeFile(); } } @@ -201,11 +201,11 @@ void RequestGroup::createInitialCommand { #ifdef ENABLE_BITTORRENT { - if(_downloadContext->hasAttribute(bittorrent::BITTORRENT)) { + if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) { SharedHandle<TorrentAttribute> torrentAttrs = - bittorrent::getTorrentAttrs(_downloadContext); + bittorrent::getTorrentAttrs(downloadContext_); bool metadataGetMode = torrentAttrs->metadata.empty(); - if(_option->getAsBool(PREF_DRY_RUN)) { + if(option_->getAsBool(PREF_DRY_RUN)) { throw DOWNLOAD_FAILURE_EXCEPTION ("Cancel BitTorrent download in dry-run context."); } @@ -216,7 +216,7 @@ void RequestGroup::createInitialCommand throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat ("InfoHash %s is already registered.", - bittorrent::getInfoHashString(_downloadContext).c_str()).str()); + bittorrent::getInfoHashString(downloadContext_).c_str()).str()); } if(metadataGetMode) { // Use UnknownLengthPieceStorage. @@ -225,63 +225,63 @@ void RequestGroup::createInitialCommand if(e->getRequestGroupMan()->isSameFileBeingDownloaded(this)) { throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat(EX_DUPLICATE_FILE_DOWNLOAD, - _downloadContext->getBasePath().c_str()).str()); + downloadContext_->getBasePath().c_str()).str()); } initPieceStorage(); - if(_downloadContext->getFileEntries().size() > 1) { - _pieceStorage->setupFileFilter(); + if(downloadContext_->getFileEntries().size() > 1) { + pieceStorage_->setupFileFilter(); } } SharedHandle<DefaultBtProgressInfoFile> progressInfoFile; if(!metadataGetMode) { - progressInfoFile.reset(new DefaultBtProgressInfoFile(_downloadContext, - _pieceStorage, - _option.get())); + progressInfoFile.reset(new DefaultBtProgressInfoFile(downloadContext_, + pieceStorage_, + option_.get())); } BtRuntimeHandle btRuntime(new BtRuntime()); - btRuntime->setMaxPeers(_option->getAsInt(PREF_BT_MAX_PEERS)); - _btRuntime = btRuntime; + btRuntime->setMaxPeers(option_->getAsInt(PREF_BT_MAX_PEERS)); + btRuntime_ = btRuntime; if(!progressInfoFile.isNull()) { progressInfoFile->setBtRuntime(btRuntime); } SharedHandle<DefaultPeerStorage> peerStorage(new DefaultPeerStorage()); peerStorage->setBtRuntime(btRuntime); - peerStorage->setPieceStorage(_pieceStorage); - _peerStorage = peerStorage; + peerStorage->setPieceStorage(pieceStorage_); + peerStorage_ = peerStorage; if(!progressInfoFile.isNull()) { progressInfoFile->setPeerStorage(peerStorage); } SharedHandle<DefaultBtAnnounce> btAnnounce - (new DefaultBtAnnounce(_downloadContext, _option.get())); + (new DefaultBtAnnounce(downloadContext_, option_.get())); btAnnounce->setBtRuntime(btRuntime); - btAnnounce->setPieceStorage(_pieceStorage); + btAnnounce->setPieceStorage(pieceStorage_); btAnnounce->setPeerStorage(peerStorage); btAnnounce->setUserDefinedInterval - (_option->getAsInt(PREF_BT_TRACKER_INTERVAL)); + (option_->getAsInt(PREF_BT_TRACKER_INTERVAL)); btAnnounce->shuffleAnnounce(); - assert(btRegistry->get(_gid).isNull()); - btRegistry->put(_gid, - BtObject(_downloadContext, - _pieceStorage, + assert(btRegistry->get(gid_).isNull()); + btRegistry->put(gid_, + BtObject(downloadContext_, + pieceStorage_, peerStorage, btAnnounce, btRuntime, (progressInfoFile.isNull()? - _progressInfoFile: + progressInfoFile_: SharedHandle<BtProgressInfoFile> (progressInfoFile)))); if(metadataGetMode) { - if(_option->getAsBool(PREF_ENABLE_DHT)) { + if(option_->getAsBool(PREF_ENABLE_DHT)) { std::vector<Command*> dhtCommands; DHTSetup().setup(dhtCommands, e); e->addCommand(dhtCommands); } else { - _logger->notice("For BitTorrent Magnet URI, enabling DHT is strongly" + logger_->notice("For BitTorrent Magnet URI, enabling DHT is strongly" " recommended. See --enable-dht option."); } @@ -293,18 +293,18 @@ void RequestGroup::createInitialCommand } removeDefunctControlFile(progressInfoFile); { - uint64_t actualFileSize = _pieceStorage->getDiskAdaptor()->size(); - if(actualFileSize == _downloadContext->getTotalLength()) { + uint64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size(); + if(actualFileSize == downloadContext_->getTotalLength()) { // First, make DiskAdaptor read-only mode to allow the // program to seed file in read-only media. - _pieceStorage->getDiskAdaptor()->enableReadOnly(); + pieceStorage_->getDiskAdaptor()->enableReadOnly(); } else { // Open file in writable mode to allow the program - // truncate the file to _downloadContext->getTotalLength() - if(_logger->debug()) { - _logger->debug("File size not match. File is opened in writable" + // truncate the file to downloadContext_->getTotalLength() + if(logger_->debug()) { + logger_->debug("File size not match. File is opened in writable" " mode. Expected:%s Actual:%s", - util::uitos(_downloadContext->getTotalLength()).c_str(), + util::uitos(downloadContext_->getTotalLength()).c_str(), util::uitos(actualFileSize).c_str()); } } @@ -313,30 +313,30 @@ void RequestGroup::createInitialCommand if(progressInfoFile->exists()) { // load .aria2 file if it exists. progressInfoFile->load(); - _pieceStorage->getDiskAdaptor()->openFile(); + pieceStorage_->getDiskAdaptor()->openFile(); } else { - if(_pieceStorage->getDiskAdaptor()->fileExists()) { - if(!_option->getAsBool(PREF_CHECK_INTEGRITY) && - !_option->getAsBool(PREF_ALLOW_OVERWRITE) && - !_option->getAsBool(PREF_BT_SEED_UNVERIFIED)) { + if(pieceStorage_->getDiskAdaptor()->fileExists()) { + if(!option_->getAsBool(PREF_CHECK_INTEGRITY) && + !option_->getAsBool(PREF_ALLOW_OVERWRITE) && + !option_->getAsBool(PREF_BT_SEED_UNVERIFIED)) { // TODO we need this->haltRequested = true? throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat (MSG_FILE_ALREADY_EXISTS, - _downloadContext->getBasePath().c_str()).str()); + downloadContext_->getBasePath().c_str()).str()); } else { - _pieceStorage->getDiskAdaptor()->openFile(); + pieceStorage_->getDiskAdaptor()->openFile(); } - if(_option->getAsBool(PREF_BT_SEED_UNVERIFIED)) { - _pieceStorage->markAllPiecesDone(); + if(option_->getAsBool(PREF_BT_SEED_UNVERIFIED)) { + pieceStorage_->markAllPiecesDone(); } } else { - _pieceStorage->getDiskAdaptor()->openFile(); + pieceStorage_->getDiskAdaptor()->openFile(); } } - _progressInfoFile = progressInfoFile; + progressInfoFile_ = progressInfoFile; - if(!torrentAttrs->privateTorrent && _option->getAsBool(PREF_ENABLE_DHT)) { + if(!torrentAttrs->privateTorrent && option_->getAsBool(PREF_ENABLE_DHT)) { std::vector<Command*> dhtCommands; DHTSetup().setup(dhtCommands, e); e->addCommand(dhtCommands); @@ -356,8 +356,8 @@ void RequestGroup::createInitialCommand SharedHandle<CheckIntegrityEntry> entry(new BtCheckIntegrityEntry(this)); // --bt-seed-unverified=true is given and download has completed, skip // validation for piece hashes. - if(_option->getAsBool(PREF_BT_SEED_UNVERIFIED) && - _pieceStorage->downloadFinished()) { + if(option_->getAsBool(PREF_BT_SEED_UNVERIFIED) && + pieceStorage_->downloadFinished()) { entry->onDownloadFinished(commands, e); } else { processCheckIntegrityEntry(commands, entry, e); @@ -366,32 +366,32 @@ void RequestGroup::createInitialCommand } } #endif // ENABLE_BITTORRENT - if(_downloadContext->getFileEntries().size() == 1) { + if(downloadContext_->getFileEntries().size() == 1) { // TODO I assume here when totallength is set to DownloadContext and it is // not 0, then filepath is also set DownloadContext correctly.... - if(_option->getAsBool(PREF_DRY_RUN) || - _downloadContext->getTotalLength() == 0) { + if(option_->getAsBool(PREF_DRY_RUN) || + downloadContext_->getTotalLength() == 0) { createNextCommand(commands, e, 1); }else { if(e->getRequestGroupMan()->isSameFileBeingDownloaded(this)) { throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat(EX_DUPLICATE_FILE_DOWNLOAD, - _downloadContext->getBasePath().c_str()).str()); + downloadContext_->getBasePath().c_str()).str()); } adjustFilename (SharedHandle<BtProgressInfoFile>(new DefaultBtProgressInfoFile - (_downloadContext, + (downloadContext_, SharedHandle<PieceStorage>(), - _option.get()))); + option_.get()))); initPieceStorage(); BtProgressInfoFileHandle infoFile - (new DefaultBtProgressInfoFile(_downloadContext, _pieceStorage, - _option.get())); + (new DefaultBtProgressInfoFile(downloadContext_, pieceStorage_, + option_.get())); if(!infoFile->exists() && downloadFinishedByFileLength()) { - _pieceStorage->markAllPiecesDone(); - _logger->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, - util::itos(_gid).c_str(), - _downloadContext->getBasePath().c_str()); + pieceStorage_->markAllPiecesDone(); + logger_->notice(MSG_DOWNLOAD_ALREADY_COMPLETED, + util::itos(gid_).c_str(), + downloadContext_->getBasePath().c_str()); } else { loadAndOpenFile(infoFile); SharedHandle<CheckIntegrityEntry> checkIntegrityEntry @@ -405,39 +405,39 @@ void RequestGroup::createInitialCommand if(e->getRequestGroupMan()->isSameFileBeingDownloaded(this)) { throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat(EX_DUPLICATE_FILE_DOWNLOAD, - _downloadContext->getBasePath().c_str()).str()); + downloadContext_->getBasePath().c_str()).str()); } initPieceStorage(); - if(_downloadContext->getFileEntries().size() > 1) { - _pieceStorage->setupFileFilter(); + if(downloadContext_->getFileEntries().size() > 1) { + pieceStorage_->setupFileFilter(); } SharedHandle<DefaultBtProgressInfoFile> progressInfoFile - (new DefaultBtProgressInfoFile(_downloadContext, - _pieceStorage, - _option.get())); + (new DefaultBtProgressInfoFile(downloadContext_, + pieceStorage_, + option_.get())); removeDefunctControlFile(progressInfoFile); // Call Load, Save and file allocation command here if(progressInfoFile->exists()) { // load .aria2 file if it exists. progressInfoFile->load(); - _pieceStorage->getDiskAdaptor()->openFile(); + pieceStorage_->getDiskAdaptor()->openFile(); } else { - if(_pieceStorage->getDiskAdaptor()->fileExists()) { - if(!_option->getAsBool(PREF_CHECK_INTEGRITY) && - !_option->getAsBool(PREF_ALLOW_OVERWRITE)) { + if(pieceStorage_->getDiskAdaptor()->fileExists()) { + if(!option_->getAsBool(PREF_CHECK_INTEGRITY) && + !option_->getAsBool(PREF_ALLOW_OVERWRITE)) { // TODO we need this->haltRequested = true? throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat (MSG_FILE_ALREADY_EXISTS, - _downloadContext->getBasePath().c_str()).str()); + downloadContext_->getBasePath().c_str()).str()); } else { - _pieceStorage->getDiskAdaptor()->openFile(); + pieceStorage_->getDiskAdaptor()->openFile(); } } else { - _pieceStorage->getDiskAdaptor()->openFile(); + pieceStorage_->getDiskAdaptor()->openFile(); } } - _progressInfoFile = progressInfoFile; + progressInfoFile_ = progressInfoFile; SharedHandle<CheckIntegrityEntry> checkIntegrityEntry (new StreamCheckIntegrityEntry(this)); processCheckIntegrityEntry(commands, checkIntegrityEntry, e); @@ -450,7 +450,7 @@ void RequestGroup::processCheckIntegrityEntry DownloadEngine* e) { #ifdef ENABLE_MESSAGE_DIGEST - if(_option->getAsBool(PREF_CHECK_INTEGRITY) && + if(option_->getAsBool(PREF_CHECK_INTEGRITY) && entry->isValidationReady()) { entry->initValidator(); entry->cutTrailingGarbage(); @@ -472,29 +472,29 @@ void RequestGroup::processCheckIntegrityEntry void RequestGroup::initPieceStorage() { SharedHandle<PieceStorage> tempPieceStorage; - if(_downloadContext->knowsTotalLength()) { + if(downloadContext_->knowsTotalLength()) { #ifdef ENABLE_BITTORRENT SharedHandle<DefaultPieceStorage> ps - (new DefaultPieceStorage(_downloadContext, _option.get())); - if(_downloadContext->hasAttribute(bittorrent::BITTORRENT)) { + (new DefaultPieceStorage(downloadContext_, option_.get())); + if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) { if(isUriSuppliedForRequsetFileEntry - (_downloadContext->getFileEntries().begin(), - _downloadContext->getFileEntries().end())) { + (downloadContext_->getFileEntries().begin(), + downloadContext_->getFileEntries().end())) { // Use LongestSequencePieceSelector when HTTP/FTP/BitTorrent // integrated downloads. Currently multi-file integrated // download is not supported. - if(_logger->debug()) { - _logger->debug("Using LongestSequencePieceSelector"); + if(logger_->debug()) { + logger_->debug("Using LongestSequencePieceSelector"); } ps->setPieceSelector (SharedHandle<PieceSelector>(new LongestSequencePieceSelector())); } - if(_option->defined(PREF_BT_PRIORITIZE_PIECE)) { + if(option_->defined(PREF_BT_PRIORITIZE_PIECE)) { std::vector<size_t> result; util::parsePrioritizePieceRange - (result, _option->get(PREF_BT_PRIORITIZE_PIECE), - _downloadContext->getFileEntries(), - _downloadContext->getPieceLength()); + (result, option_->get(PREF_BT_PRIORITIZE_PIECE), + downloadContext_->getFileEntries(), + downloadContext_->getPieceLength()); if(!result.empty()) { std::random_shuffle(result.begin(), result.end(), *(SimpleRandomizer::getInstance().get())); @@ -507,48 +507,48 @@ void RequestGroup::initPieceStorage() } #else // !ENABLE_BITTORRENT SharedHandle<DefaultPieceStorage> ps - (new DefaultPieceStorage(_downloadContext, _option.get())); + (new DefaultPieceStorage(downloadContext_, option_.get())); #endif // !ENABLE_BITTORRENT - if(!_diskWriterFactory.isNull()) { - ps->setDiskWriterFactory(_diskWriterFactory); + if(!diskWriterFactory_.isNull()) { + ps->setDiskWriterFactory(diskWriterFactory_); } tempPieceStorage = ps; } else { UnknownLengthPieceStorageHandle ps - (new UnknownLengthPieceStorage(_downloadContext, _option.get())); - if(!_diskWriterFactory.isNull()) { - ps->setDiskWriterFactory(_diskWriterFactory); + (new UnknownLengthPieceStorage(downloadContext_, option_.get())); + if(!diskWriterFactory_.isNull()) { + ps->setDiskWriterFactory(diskWriterFactory_); } tempPieceStorage = ps; } tempPieceStorage->initStorage(); SharedHandle<SegmentMan> tempSegmentMan - (new SegmentMan(_option.get(), _downloadContext, tempPieceStorage)); + (new SegmentMan(option_.get(), downloadContext_, tempPieceStorage)); - _pieceStorage = tempPieceStorage; - _segmentMan = tempSegmentMan; + pieceStorage_ = tempPieceStorage; + segmentMan_ = tempSegmentMan; } void RequestGroup::dropPieceStorage() { - _segmentMan.reset(); - _pieceStorage.reset(); + segmentMan_.reset(); + pieceStorage_.reset(); } bool RequestGroup::downloadFinishedByFileLength() { // assuming that a control file doesn't exist. if(!isPreLocalFileCheckEnabled() || - _option->getAsBool(PREF_ALLOW_OVERWRITE) || - (_option->getAsBool(PREF_CHECK_INTEGRITY) && - !_downloadContext->getPieceHashes().empty())) { + option_->getAsBool(PREF_ALLOW_OVERWRITE) || + (option_->getAsBool(PREF_CHECK_INTEGRITY) && + !downloadContext_->getPieceHashes().empty())) { return false; } - if(!_downloadContext->knowsTotalLength()) { + if(!downloadContext_->knowsTotalLength()) { return false; } File outfile(getFirstFilePath()); - if(outfile.exists() && _downloadContext->getTotalLength() == outfile.size()) { + if(outfile.exists() && downloadContext_->getTotalLength() == outfile.size()) { return true; } else { return false; @@ -562,11 +562,11 @@ void RequestGroup::adjustFilename // OK, no need to care about filename. return; } - if(!_option->getAsBool(PREF_DRY_RUN) && - _option->getAsBool(PREF_REMOVE_CONTROL_FILE) && + if(!option_->getAsBool(PREF_DRY_RUN) && + option_->getAsBool(PREF_REMOVE_CONTROL_FILE) && infoFile->exists()) { infoFile->removeFile(); - _logger->notice("Removed control file for %s because it is requested by" + logger_->notice("Removed control file for %s because it is requested by" " user.", infoFile->getFilename().c_str()); } if(infoFile->exists()) { @@ -575,12 +575,12 @@ void RequestGroup::adjustFilename // File was downloaded already, no need to change file name. } else { File outfile(getFirstFilePath()); - if(outfile.exists() && _option->getAsBool(PREF_CONTINUE) && - outfile.size() <= _downloadContext->getTotalLength()) { + if(outfile.exists() && option_->getAsBool(PREF_CONTINUE) && + outfile.size() <= downloadContext_->getTotalLength()) { // File exists but user decided to resume it. } else { #ifdef ENABLE_MESSAGE_DIGEST - if(outfile.exists() && _option->getAsBool(PREF_CHECK_INTEGRITY)) { + if(outfile.exists() && option_->getAsBool(PREF_CHECK_INTEGRITY)) { // check-integrity existing file } else { #endif // ENABLE_MESSAGE_DIGEST @@ -597,11 +597,11 @@ void RequestGroup::removeDefunctControlFile { // Remove the control file if download file doesn't exist if(progressInfoFile->exists() && - !_pieceStorage->getDiskAdaptor()->fileExists()) { + !pieceStorage_->getDiskAdaptor()->fileExists()) { progressInfoFile->removeFile(); - _logger->notice(MSG_REMOVED_DEFUNCT_CONTROL_FILE, + logger_->notice(MSG_REMOVED_DEFUNCT_CONTROL_FILE, progressInfoFile->getFilename().c_str(), - _downloadContext->getBasePath().c_str()); + downloadContext_->getBasePath().c_str()); } } @@ -609,26 +609,26 @@ void RequestGroup::loadAndOpenFile(const BtProgressInfoFileHandle& progressInfoF { try { if(!isPreLocalFileCheckEnabled()) { - _pieceStorage->getDiskAdaptor()->initAndOpenFile(); + pieceStorage_->getDiskAdaptor()->initAndOpenFile(); return; } removeDefunctControlFile(progressInfoFile); if(progressInfoFile->exists()) { progressInfoFile->load(); - _pieceStorage->getDiskAdaptor()->openExistingFile(); + pieceStorage_->getDiskAdaptor()->openExistingFile(); } else { File outfile(getFirstFilePath()); - if(outfile.exists() && _option->getAsBool(PREF_CONTINUE) && + if(outfile.exists() && option_->getAsBool(PREF_CONTINUE) && outfile.size() <= getTotalLength()) { - _pieceStorage->getDiskAdaptor()->openExistingFile(); - _pieceStorage->markPiecesDone(outfile.size()); + pieceStorage_->getDiskAdaptor()->openExistingFile(); + pieceStorage_->markPiecesDone(outfile.size()); } else { #ifdef ENABLE_MESSAGE_DIGEST - if(outfile.exists() && _option->getAsBool(PREF_CHECK_INTEGRITY)) { - _pieceStorage->getDiskAdaptor()->openExistingFile(); + if(outfile.exists() && option_->getAsBool(PREF_CHECK_INTEGRITY)) { + pieceStorage_->getDiskAdaptor()->openExistingFile(); } else { #endif // ENABLE_MESSAGE_DIGEST - _pieceStorage->getDiskAdaptor()->initAndOpenFile(); + pieceStorage_->getDiskAdaptor()->initAndOpenFile(); #ifdef ENABLE_MESSAGE_DIGEST } #endif // ENABLE_MESSAGE_DIGEST @@ -644,14 +644,14 @@ void RequestGroup::loadAndOpenFile(const BtProgressInfoFileHandle& progressInfoF // assuming that a control file does not exist void RequestGroup::shouldCancelDownloadForSafety() { - if(_option->getAsBool(PREF_ALLOW_OVERWRITE)) { + if(option_->getAsBool(PREF_ALLOW_OVERWRITE)) { return; } File outfile(getFirstFilePath()); if(outfile.exists()) { - if(_option->getAsBool(PREF_AUTO_FILE_RENAMING)) { + if(option_->getAsBool(PREF_AUTO_FILE_RENAMING)) { if(tryAutoFileRenaming()) { - _logger->notice(MSG_FILE_RENAMED, getFirstFilePath().c_str()); + logger_->notice(MSG_FILE_RENAMED, getFirstFilePath().c_str()); } else { throw DOWNLOAD_FAILURE_EXCEPTION (StringFormat("File renaming failed: %s", @@ -675,7 +675,7 @@ bool RequestGroup::tryAutoFileRenaming() File newfile(strconcat(filepath, A2STR::DOT_C, util::uitos(i))); File ctrlfile(newfile.getPath()+DefaultBtProgressInfoFile::getSuffix()); if(!newfile.exists() || (newfile.exists() && ctrlfile.exists())) { - _downloadContext->getFirstFileEntry()->setPath(newfile.getPath()); + downloadContext_->getFirstFileEntry()->setPath(newfile.getPath()); return true; } } @@ -689,8 +689,8 @@ void RequestGroup::createNextCommandWithAdj(std::vector<Command*>& commands, if(getTotalLength() == 0) { numCommand = 1+numAdj; } else { - numCommand = std::min(_downloadContext->getNumPieces(), - _numConcurrentCommand); + numCommand = std::min(downloadContext_->getNumPieces(), + numConcurrentCommand_); numCommand += numAdj; } if(numCommand > 0) { @@ -703,17 +703,17 @@ void RequestGroup::createNextCommand(std::vector<Command*>& commands, { int numCommand; if(getTotalLength() == 0) { - if(_numStreamConnection > 0) { + if(numStreamConnection_ > 0) { numCommand = 0; } else { numCommand = 1; } } else { - if(_numStreamConnection >= _numConcurrentCommand) { + if(numStreamConnection_ >= numConcurrentCommand_) { numCommand = 0; } else { - numCommand = std::min(_downloadContext->getNumPieces(), - _numConcurrentCommand-_numStreamConnection); + numCommand = std::min(downloadContext_->getNumPieces(), + numConcurrentCommand_-numStreamConnection_); } } if(numCommand > 0) { @@ -736,37 +736,37 @@ void RequestGroup::createNextCommand(std::vector<Command*>& commands, std::string RequestGroup::getFirstFilePath() const { - assert(!_downloadContext.isNull()); + assert(!downloadContext_.isNull()); if(inMemoryDownload()) { static const std::string DIR_MEMORY("[MEMORY]"); - return DIR_MEMORY+File(_downloadContext->getFirstFileEntry()->getPath()).getBasename(); + return DIR_MEMORY+File(downloadContext_->getFirstFileEntry()->getPath()).getBasename(); } else { - return _downloadContext->getFirstFileEntry()->getPath(); + return downloadContext_->getFirstFileEntry()->getPath(); } } uint64_t RequestGroup::getTotalLength() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return 0; } else { - if(_pieceStorage->isSelectiveDownloadingMode()) { - return _pieceStorage->getFilteredTotalLength(); + if(pieceStorage_->isSelectiveDownloadingMode()) { + return pieceStorage_->getFilteredTotalLength(); } else { - return _pieceStorage->getTotalLength(); + return pieceStorage_->getTotalLength(); } } } uint64_t RequestGroup::getCompletedLength() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return 0; } else { - if(_pieceStorage->isSelectiveDownloadingMode()) { - return _pieceStorage->getFilteredCompletedLength(); + if(pieceStorage_->isSelectiveDownloadingMode()) { + return pieceStorage_->getFilteredCompletedLength(); } else { - return _pieceStorage->getCompletedLength(); + return pieceStorage_->getCompletedLength(); } } } @@ -800,7 +800,7 @@ void RequestGroup::validateTotalLength(uint64_t expectedTotalLength, void RequestGroup::validateFilename(const std::string& actualFilename) const { - validateFilename(_downloadContext->getFileEntries().front()->getBasename(), actualFilename); + validateFilename(downloadContext_->getFileEntries().front()->getBasename(), actualFilename); } void RequestGroup::validateTotalLength(uint64_t actualTotalLength) const @@ -810,20 +810,20 @@ void RequestGroup::validateTotalLength(uint64_t actualTotalLength) const void RequestGroup::increaseStreamConnection() { - ++_numStreamConnection; + ++numStreamConnection_; } void RequestGroup::decreaseStreamConnection() { - --_numStreamConnection; + --numStreamConnection_; } unsigned int RequestGroup::getNumConnection() const { - unsigned int numConnection = _numStreamConnection; + unsigned int numConnection = numStreamConnection_; #ifdef ENABLE_BITTORRENT - if(!_btRuntime.isNull()) { - numConnection += _btRuntime->getConnections(); + if(!btRuntime_.isNull()) { + numConnection += btRuntime_->getConnections(); } #endif // ENABLE_BITTORRENT return numConnection; @@ -831,17 +831,17 @@ unsigned int RequestGroup::getNumConnection() const void RequestGroup::increaseNumCommand() { - ++_numCommand; + ++numCommand_; } void RequestGroup::decreaseNumCommand() { - --_numCommand; - if(!_numCommand && _requestGroupMan) { - if(_logger->debug()) { - _logger->debug("GID#%s - Request queue check", util::itos(_gid).c_str()); + --numCommand_; + if(!numCommand_ && requestGroupMan_) { + if(logger_->debug()) { + logger_->debug("GID#%s - Request queue check", util::itos(gid_).c_str()); } - _requestGroupMan->requestQueueCheck(); + requestGroupMan_->requestQueueCheck(); } } @@ -850,30 +850,30 @@ TransferStat RequestGroup::calculateStat() const { TransferStat stat; #ifdef ENABLE_BITTORRENT - if(!_peerStorage.isNull()) { - stat = _peerStorage->calculateStat(); + if(!peerStorage_.isNull()) { + stat = peerStorage_->calculateStat(); } #endif // ENABLE_BITTORRENT - if(!_segmentMan.isNull()) { + if(!segmentMan_.isNull()) { stat.setDownloadSpeed - (stat.getDownloadSpeed()+_segmentMan->calculateDownloadSpeed()); + (stat.getDownloadSpeed()+segmentMan_->calculateDownloadSpeed()); stat.setSessionDownloadLength (stat.getSessionDownloadLength()+ - _segmentMan->calculateSessionDownloadLength()); + segmentMan_->calculateSessionDownloadLength()); } return stat; } void RequestGroup::setHaltRequested(bool f, HaltReason haltReason) { - _haltRequested = f; - if(_haltRequested) { - _pauseRequested = false; - _haltReason = haltReason; + haltRequested_ = f; + if(haltRequested_) { + pauseRequested_ = false; + haltReason_ = haltReason; } #ifdef ENABLE_BITTORRENT - if(!_btRuntime.isNull()) { - _btRuntime->setHalt(f); + if(!btRuntime_.isNull()) { + btRuntime_->setHalt(f); } #endif // ENABLE_BITTORRENT } @@ -881,37 +881,37 @@ void RequestGroup::setHaltRequested(bool f, HaltReason haltReason) void RequestGroup::setForceHaltRequested(bool f, HaltReason haltReason) { setHaltRequested(f, haltReason); - _forceHaltRequested = f; + forceHaltRequested_ = f; } void RequestGroup::setPauseRequested(bool f) { - _pauseRequested = f; + pauseRequested_ = f; } void RequestGroup::releaseRuntimeResource(DownloadEngine* e) { #ifdef ENABLE_BITTORRENT - e->getBtRegistry()->remove(_gid); + e->getBtRegistry()->remove(gid_); #endif // ENABLE_BITTORRENT - if(!_pieceStorage.isNull()) { - _pieceStorage->removeAdvertisedPiece(0); + if(!pieceStorage_.isNull()) { + pieceStorage_->removeAdvertisedPiece(0); } - // Don't reset _segmentMan and _pieceStorage here to provide + // Don't reset segmentMan_ and pieceStorage_ here to provide // progress information via XML-RPC - _progressInfoFile.reset(); - _downloadContext->releaseRuntimeResource(); + progressInfoFile_.reset(); + downloadContext_->releaseRuntimeResource(); } void RequestGroup::preDownloadProcessing() { - if(_logger->debug()) { - _logger->debug("Finding PreDownloadHandler for path %s.", + if(logger_->debug()) { + logger_->debug("Finding PreDownloadHandler for path %s.", getFirstFilePath().c_str()); } try { for(std::vector<SharedHandle<PreDownloadHandler> >::const_iterator itr = - _preDownloadHandlers.begin(), eoi = _preDownloadHandlers.end(); + preDownloadHandlers_.begin(), eoi = preDownloadHandlers_.end(); itr != eoi; ++itr) { if((*itr)->canHandle(this)) { (*itr)->execute(this); @@ -919,11 +919,11 @@ void RequestGroup::preDownloadProcessing() } } } catch(RecoverableException& ex) { - _logger->error(EX_EXCEPTION_CAUGHT, ex); + logger_->error(EX_EXCEPTION_CAUGHT, ex); return; } - if(_logger->debug()) { - _logger->debug("No PreDownloadHandler found."); + if(logger_->debug()) { + logger_->debug("No PreDownloadHandler found."); } return; } @@ -931,13 +931,13 @@ void RequestGroup::preDownloadProcessing() void RequestGroup::postDownloadProcessing (std::vector<SharedHandle<RequestGroup> >& groups) { - if(_logger->debug()) { - _logger->debug("Finding PostDownloadHandler for path %s.", + if(logger_->debug()) { + logger_->debug("Finding PostDownloadHandler for path %s.", getFirstFilePath().c_str()); } try { for(std::vector<SharedHandle<PostDownloadHandler> >::const_iterator itr = - _postDownloadHandlers.begin(), eoi = _postDownloadHandlers.end(); + postDownloadHandlers_.begin(), eoi = postDownloadHandlers_.end(); itr != eoi; ++itr) { if((*itr)->canHandle(this)) { (*itr)->getNextRequestGroups(groups, this); @@ -945,23 +945,23 @@ void RequestGroup::postDownloadProcessing } } } catch(RecoverableException& ex) { - _logger->error(EX_EXCEPTION_CAUGHT, ex); + logger_->error(EX_EXCEPTION_CAUGHT, ex); } - if(_logger->debug()) { - _logger->debug("No PostDownloadHandler found."); + if(logger_->debug()) { + logger_->debug("No PostDownloadHandler found."); } } void RequestGroup::initializePreDownloadHandler() { #ifdef ENABLE_BITTORRENT - if(_option->get(PREF_FOLLOW_TORRENT) == V_MEM) { - _preDownloadHandlers.push_back(DownloadHandlerFactory::getBtPreDownloadHandler()); + if(option_->get(PREF_FOLLOW_TORRENT) == V_MEM) { + preDownloadHandlers_.push_back(DownloadHandlerFactory::getBtPreDownloadHandler()); } #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK - if(_option->get(PREF_FOLLOW_METALINK) == V_MEM) { - _preDownloadHandlers.push_back(DownloadHandlerFactory::getMetalinkPreDownloadHandler()); + if(option_->get(PREF_FOLLOW_METALINK) == V_MEM) { + preDownloadHandlers_.push_back(DownloadHandlerFactory::getMetalinkPreDownloadHandler()); } #endif // ENABLE_METALINK } @@ -969,128 +969,128 @@ void RequestGroup::initializePreDownloadHandler() void RequestGroup::initializePostDownloadHandler() { #ifdef ENABLE_BITTORRENT - if(_option->getAsBool(PREF_FOLLOW_TORRENT) || - _option->get(PREF_FOLLOW_TORRENT) == V_MEM) { - _postDownloadHandlers.push_back(DownloadHandlerFactory::getBtPostDownloadHandler()); + if(option_->getAsBool(PREF_FOLLOW_TORRENT) || + option_->get(PREF_FOLLOW_TORRENT) == V_MEM) { + postDownloadHandlers_.push_back(DownloadHandlerFactory::getBtPostDownloadHandler()); } #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK - if(_option->getAsBool(PREF_FOLLOW_METALINK) || - _option->get(PREF_FOLLOW_METALINK) == V_MEM) { - _postDownloadHandlers.push_back(DownloadHandlerFactory::getMetalinkPostDownloadHandler()); + if(option_->getAsBool(PREF_FOLLOW_METALINK) || + option_->get(PREF_FOLLOW_METALINK) == V_MEM) { + postDownloadHandlers_.push_back(DownloadHandlerFactory::getMetalinkPostDownloadHandler()); } #endif // ENABLE_METALINK } bool RequestGroup::isDependencyResolved() { - if(_dependency.isNull()) { + if(dependency_.isNull()) { return true; } - return _dependency->resolve(); + return dependency_->resolve(); } void RequestGroup::dependsOn(const DependencyHandle& dep) { - _dependency = dep; + dependency_ = dep; } void RequestGroup::setDiskWriterFactory(const DiskWriterFactoryHandle& diskWriterFactory) { - _diskWriterFactory = diskWriterFactory; + diskWriterFactory_ = diskWriterFactory; } void RequestGroup::addPostDownloadHandler (const SharedHandle<PostDownloadHandler>& handler) { - _postDownloadHandlers.push_back(handler); + postDownloadHandlers_.push_back(handler); } void RequestGroup::addPreDownloadHandler (const SharedHandle<PreDownloadHandler>& handler) { - _preDownloadHandlers.push_back(handler); + preDownloadHandlers_.push_back(handler); } void RequestGroup::clearPostDownloadHandler() { - _postDownloadHandlers.clear(); + postDownloadHandlers_.clear(); } void RequestGroup::clearPreDownloadHandler() { - _preDownloadHandlers.clear(); + preDownloadHandlers_.clear(); } void RequestGroup::setPieceStorage(const PieceStorageHandle& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void RequestGroup::setProgressInfoFile(const BtProgressInfoFileHandle& progressInfoFile) { - _progressInfoFile = progressInfoFile; + progressInfoFile_ = progressInfoFile; } bool RequestGroup::needsFileAllocation() const { return isFileAllocationEnabled() && - (uint64_t)_option->getAsLLInt(PREF_NO_FILE_ALLOCATION_LIMIT) <= getTotalLength() && - !_pieceStorage->getDiskAdaptor()->fileAllocationIterator()->finished(); + (uint64_t)option_->getAsLLInt(PREF_NO_FILE_ALLOCATION_LIMIT) <= getTotalLength() && + !pieceStorage_->getDiskAdaptor()->fileAllocationIterator()->finished(); } DownloadResultHandle RequestGroup::createDownloadResult() const { - if(_logger->debug()) { - _logger->debug("GID#%s - Creating DownloadResult.", - util::itos(_gid).c_str()); + if(logger_->debug()) { + logger_->debug("GID#%s - Creating DownloadResult.", + util::itos(gid_).c_str()); } TransferStat st = calculateStat(); SharedHandle<DownloadResult> res(new DownloadResult()); - res->gid = _gid; - res->fileEntries = _downloadContext->getFileEntries(); - res->inMemoryDownload = _inMemoryDownload; + res->gid = gid_; + res->fileEntries = downloadContext_->getFileEntries(); + res->inMemoryDownload = inMemoryDownload_; res->sessionDownloadLength = st.getSessionDownloadLength(); - res->sessionTime = _downloadContext->calculateSessionTime(); + res->sessionTime = downloadContext_->calculateSessionTime(); res->result = downloadResult(); - res->followedBy = _followedByGIDs; - res->belongsTo = _belongsToGID; - res->option = _option; - res->metadataInfo = _metadataInfo; + res->followedBy = followedByGIDs_; + res->belongsTo = belongsToGID_; + res->option = option_; + res->metadataInfo = metadataInfo_; res->totalLength = getTotalLength(); res->completedLength = getCompletedLength(); res->uploadLength = st.getAllTimeUploadLength(); - if(!_pieceStorage.isNull()) { - if(_pieceStorage->getBitfieldLength() > 0) { - res->bitfieldStr = util::toHex(_pieceStorage->getBitfield(), - _pieceStorage->getBitfieldLength()); + if(!pieceStorage_.isNull()) { + if(pieceStorage_->getBitfieldLength() > 0) { + res->bitfieldStr = util::toHex(pieceStorage_->getBitfield(), + pieceStorage_->getBitfieldLength()); } } #ifdef ENABLE_BITTORRENT - if(_downloadContext->hasAttribute(bittorrent::BITTORRENT)) { - res->infoHashStr = bittorrent::getInfoHashString(_downloadContext); + if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) { + res->infoHashStr = bittorrent::getInfoHashString(downloadContext_); } #endif // ENABLE_BITTORRENT - res->pieceLength = _downloadContext->getPieceLength(); - res->numPieces = _downloadContext->getNumPieces(); - res->dir = _downloadContext->getDir(); + res->pieceLength = downloadContext_->getPieceLength(); + res->numPieces = downloadContext_->getNumPieces(); + res->dir = downloadContext_->getDir(); return res; } void RequestGroup::reportDownloadFinished() { - _logger->notice(MSG_FILE_DOWNLOAD_COMPLETED, - _downloadContext->getBasePath().c_str()); - _uriSelector->resetCounters(); + logger_->notice(MSG_FILE_DOWNLOAD_COMPLETED, + downloadContext_->getBasePath().c_str()); + uriSelector_->resetCounters(); #ifdef ENABLE_BITTORRENT - if(_downloadContext->hasAttribute(bittorrent::BITTORRENT)) { + if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) { TransferStat stat = calculateStat(); double shareRatio = ((stat.getAllTimeUploadLength()*10)/getCompletedLength())/10.0; SharedHandle<TorrentAttribute> attrs = - bittorrent::getTorrentAttrs(_downloadContext); + bittorrent::getTorrentAttrs(downloadContext_); if(!attrs->metadata.empty()) { - _logger->notice(MSG_SHARE_RATIO_REPORT, + logger_->notice(MSG_SHARE_RATIO_REPORT, shareRatio, util::abbrevSize(stat.getAllTimeUploadLength()).c_str(), util::abbrevSize(getCompletedLength()).c_str()); @@ -1101,49 +1101,49 @@ void RequestGroup::reportDownloadFinished() void RequestGroup::addAcceptType(const std::string& type) { - if(std::find(_acceptTypes.begin(), _acceptTypes.end(), type) == _acceptTypes.end()) { - _acceptTypes.push_back(type); + if(std::find(acceptTypes_.begin(), acceptTypes_.end(), type) == acceptTypes_.end()) { + acceptTypes_.push_back(type); } } void RequestGroup::removeAcceptType(const std::string& type) { - _acceptTypes.erase(std::remove(_acceptTypes.begin(), _acceptTypes.end(), type), - _acceptTypes.end()); + acceptTypes_.erase(std::remove(acceptTypes_.begin(), acceptTypes_.end(), type), + acceptTypes_.end()); } void RequestGroup::setURISelector(const SharedHandle<URISelector>& uriSelector) { - _uriSelector = uriSelector; + uriSelector_ = uriSelector; } void RequestGroup::applyLastModifiedTimeToLocalFiles() { - if(!_pieceStorage.isNull() && _lastModifiedTime.good()) { - time_t t = _lastModifiedTime.getTime(); - _logger->info("Applying Last-Modified time: %s in local time zone", + if(!pieceStorage_.isNull() && lastModifiedTime_.good()) { + time_t t = lastModifiedTime_.getTime(); + logger_->info("Applying Last-Modified time: %s in local time zone", ctime(&t)); size_t n = - _pieceStorage->getDiskAdaptor()->utime(Time(), _lastModifiedTime); - _logger->info("Last-Modified attrs of %lu files were updated.", + pieceStorage_->getDiskAdaptor()->utime(Time(), lastModifiedTime_); + logger_->info("Last-Modified attrs of %lu files were updated.", static_cast<unsigned long>(n)); } } void RequestGroup::updateLastModifiedTime(const Time& time) { - if(time.good() && _lastModifiedTime < time) { - _lastModifiedTime = time; + if(time.good() && lastModifiedTime_ < time) { + lastModifiedTime_ = time; } } void RequestGroup::increaseAndValidateFileNotFoundCount() { - ++_fileNotFoundCount; - const unsigned int maxCount = _option->getAsInt(PREF_MAX_FILE_NOT_FOUND); - if(maxCount > 0 && _fileNotFoundCount >= maxCount && - (_segmentMan.isNull() || - _segmentMan->calculateSessionDownloadLength() == 0)) { + ++fileNotFoundCount_; + const unsigned int maxCount = option_->getAsInt(PREF_MAX_FILE_NOT_FOUND); + if(maxCount > 0 && fileNotFoundCount_ >= maxCount && + (segmentMan_.isNull() || + segmentMan_->calculateSessionDownloadLength() == 0)) { throw DOWNLOAD_FAILURE_EXCEPTION2 (StringFormat("Reached max-file-not-found count=%u", maxCount).str(), downloadresultcode::MAX_FILE_NOT_FOUND); @@ -1152,57 +1152,57 @@ void RequestGroup::increaseAndValidateFileNotFoundCount() void RequestGroup::markInMemoryDownload() { - _inMemoryDownload = true; + inMemoryDownload_ = true; } void RequestGroup::setTimeout(time_t timeout) { - _timeout = timeout; + timeout_ = timeout; } bool RequestGroup::doesDownloadSpeedExceed() { - return _maxDownloadSpeedLimit > 0 && - _maxDownloadSpeedLimit < calculateStat().getDownloadSpeed(); + return maxDownloadSpeedLimit_ > 0 && + maxDownloadSpeedLimit_ < calculateStat().getDownloadSpeed(); } bool RequestGroup::doesUploadSpeedExceed() { - return _maxUploadSpeedLimit > 0 && - _maxUploadSpeedLimit < calculateStat().getUploadSpeed(); + return maxUploadSpeedLimit_ > 0 && + maxUploadSpeedLimit_ < calculateStat().getUploadSpeed(); } void RequestGroup::setLastUriResult (const std::string uri, downloadresultcode::RESULT result) { - _lastUriResult.reset(new URIResult(uri, result)); + lastUriResult_.reset(new URIResult(uri, result)); } void RequestGroup::saveControlFile() const { - if(_saveControlFile) { - _progressInfoFile->save(); + if(saveControlFile_) { + progressInfoFile_->save(); } } void RequestGroup::removeControlFile() const { - _progressInfoFile->removeFile(); + progressInfoFile_->removeFile(); } void RequestGroup::setDownloadContext (const SharedHandle<DownloadContext>& downloadContext) { - _downloadContext = downloadContext; - if(!_downloadContext.isNull()) { - _downloadContext->setOwnerRequestGroup(this); + downloadContext_ = downloadContext; + if(!downloadContext_.isNull()) { + downloadContext_->setOwnerRequestGroup(this); } } bool RequestGroup::p2pInvolved() const { #ifdef ENABLE_BITTORRENT - return _downloadContext->hasAttribute(bittorrent::BITTORRENT); + return downloadContext_->hasAttribute(bittorrent::BITTORRENT); #else // !ENABLE_BITTORRENT return false; #endif // !ENABLE_BITTORRENT @@ -1210,10 +1210,10 @@ bool RequestGroup::p2pInvolved() const gid_t RequestGroup::newGID() { - if(_gidCounter == INT64_MAX) { - _gidCounter = 0; + if(gidCounter_ == INT64_MAX) { + gidCounter_ = 0; } - return ++_gidCounter; + return ++gidCounter_; } } // namespace aria2 diff --git a/src/RequestGroup.h b/src/RequestGroup.h index bb8d3f32..df29fbe3 100644 --- a/src/RequestGroup.h +++ b/src/RequestGroup.h @@ -84,97 +84,97 @@ public: USER_REQUEST }; private: - static gid_t _gidCounter; + static gid_t gidCounter_; - gid_t _gid; + gid_t gid_; - SharedHandle<Option> _option; + SharedHandle<Option> option_; - size_t _numConcurrentCommand; + size_t numConcurrentCommand_; /** * This is the number of connections used in streaming protocol(http/ftp) */ - unsigned int _numStreamConnection; + unsigned int numStreamConnection_; - unsigned int _numCommand; + unsigned int numCommand_; - SharedHandle<SegmentMan> _segmentMan; + SharedHandle<SegmentMan> segmentMan_; - SharedHandle<DownloadContext> _downloadContext; + SharedHandle<DownloadContext> downloadContext_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - bool _saveControlFile; + bool saveControlFile_; - SharedHandle<BtProgressInfoFile> _progressInfoFile; + SharedHandle<BtProgressInfoFile> progressInfoFile_; - SharedHandle<DiskWriterFactory> _diskWriterFactory; + SharedHandle<DiskWriterFactory> diskWriterFactory_; - SharedHandle<Dependency> _dependency; + SharedHandle<Dependency> dependency_; - bool _fileAllocationEnabled; + bool fileAllocationEnabled_; - bool _preLocalFileCheckEnabled; + bool preLocalFileCheckEnabled_; - bool _haltRequested; + bool haltRequested_; - bool _forceHaltRequested; + bool forceHaltRequested_; - HaltReason _haltReason; + HaltReason haltReason_; - bool _pauseRequested; + bool pauseRequested_; - std::vector<SharedHandle<PreDownloadHandler> > _preDownloadHandlers; + std::vector<SharedHandle<PreDownloadHandler> > preDownloadHandlers_; - std::vector<SharedHandle<PostDownloadHandler> > _postDownloadHandlers; + std::vector<SharedHandle<PostDownloadHandler> > postDownloadHandlers_; - std::vector<std::string> _acceptTypes; + std::vector<std::string> acceptTypes_; - SharedHandle<URISelector> _uriSelector; + SharedHandle<URISelector> uriSelector_; - Time _lastModifiedTime; + Time lastModifiedTime_; - unsigned int _fileNotFoundCount; + unsigned int fileNotFoundCount_; // Timeout used for HTTP/FTP downloads. - time_t _timeout; + time_t timeout_; #ifdef ENABLE_BITTORRENT - WeakHandle<BtRuntime> _btRuntime; + WeakHandle<BtRuntime> btRuntime_; - WeakHandle<PeerStorage> _peerStorage; + WeakHandle<PeerStorage> peerStorage_; #endif // ENABLE_BITTORRENT // This flag just indicates that the downloaded file is not saved disk but // just sits in memory. - bool _inMemoryDownload; + bool inMemoryDownload_; - unsigned int _maxDownloadSpeedLimit; + unsigned int maxDownloadSpeedLimit_; - unsigned int _maxUploadSpeedLimit; + unsigned int maxUploadSpeedLimit_; - SharedHandle<URIResult> _lastUriResult; + SharedHandle<URIResult> lastUriResult_; // If this download generates another downloads when completed(for // example, downloads generated by PostDownloadHandler), this field // has the GID of generated RequestGroups. empty list means there is // no such RequestGroup. - std::vector<gid_t> _followedByGIDs; + std::vector<gid_t> followedByGIDs_; // If this download is a part of another download(for example, // downloading torrent file described in Metalink file), this field // has the GID of parent RequestGroup. 0 means this is a parent // RequestGroup. - gid_t _belongsToGID; + gid_t belongsToGID_; - SharedHandle<MetadataInfo> _metadataInfo; + SharedHandle<MetadataInfo> metadataInfo_; - RequestGroupMan* _requestGroupMan; + RequestGroupMan* requestGroupMan_; - int _resumeFailureCount; + int resumeFailureCount_; - Logger* _logger; + Logger* logger_; void validateFilename(const std::string& expectedFilename, const std::string& actualFilename) const; @@ -202,7 +202,7 @@ public: const SharedHandle<SegmentMan>& getSegmentMan() const { - return _segmentMan; + return segmentMan_; } // Returns first bootstrap commands to initiate a download. @@ -245,24 +245,24 @@ public: void setNumConcurrentCommand(unsigned int num) { - _numConcurrentCommand = num; + numConcurrentCommand_ = num; } unsigned int getNumConcurrentCommand() const { - return _numConcurrentCommand; + return numConcurrentCommand_; } gid_t getGID() const { - return _gid; + return gid_; } TransferStat calculateStat() const; const SharedHandle<DownloadContext>& getDownloadContext() const { - return _downloadContext; + return downloadContext_; } // This function also calls @@ -271,7 +271,7 @@ public: const SharedHandle<PieceStorage>& getPieceStorage() const { - return _pieceStorage; + return pieceStorage_; } void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage); @@ -283,7 +283,7 @@ public: void decreaseStreamConnection(); // Returns the number of connections used in HTTP(S)/FTP. - unsigned int getNumStreamConnection() { return _numStreamConnection; } + unsigned int getNumStreamConnection() { return numStreamConnection_; } unsigned int getNumConnection() const; @@ -293,7 +293,7 @@ public: unsigned int getNumCommand() const { - return _numCommand; + return numCommand_; } // TODO is it better to move the following 2 methods to SingleFileDownloadContext? @@ -301,34 +301,34 @@ public: const SharedHandle<DiskWriterFactory>& getDiskWriterFactory() const { - return _diskWriterFactory; + return diskWriterFactory_; } void setFileAllocationEnabled(bool f) { - _fileAllocationEnabled = f; + fileAllocationEnabled_ = f; } bool isFileAllocationEnabled() const { - return _fileAllocationEnabled; + return fileAllocationEnabled_; } bool needsFileAllocation() const; /** - * Setting _preLocalFileCheckEnabled to false, then skip the check to see + * Setting preLocalFileCheckEnabled_ to false, then skip the check to see * if a file is already exists and control file exists etc. * Always open file with DiskAdaptor::initAndOpenFile() */ void setPreLocalFileCheckEnabled(bool f) { - _preLocalFileCheckEnabled = f; + preLocalFileCheckEnabled_ = f; } bool isPreLocalFileCheckEnabled() const { - return _preLocalFileCheckEnabled; + return preLocalFileCheckEnabled_; } void setHaltRequested(bool f, HaltReason = SHUTDOWN_SIGNAL); @@ -337,19 +337,19 @@ public: bool isHaltRequested() const { - return _haltRequested; + return haltRequested_; } bool isForceHaltRequested() const { - return _forceHaltRequested; + return forceHaltRequested_; } void setPauseRequested(bool f); bool isPauseRequested() const { - return _pauseRequested; + return pauseRequested_; } void dependsOn(const SharedHandle<Dependency>& dep); @@ -374,8 +374,8 @@ public: const SharedHandle<CheckIntegrityEntry>& entry, DownloadEngine* e); - // Initializes _pieceStorage and _segmentMan. We guarantee that - // either both of _pieceStorage and _segmentMan are initialized or + // Initializes pieceStorage_ and segmentMan_. We guarantee that + // either both of pieceStorage_ and segmentMan_ are initialized or // they are not. void initPieceStorage(); @@ -393,14 +393,14 @@ public: const SharedHandle<Option>& getOption() const { - return _option; + return option_; } void reportDownloadFinished(); const std::vector<std::string>& getAcceptTypes() const { - return _acceptTypes; + return acceptTypes_; } void addAcceptType(const std::string& type); @@ -409,9 +409,9 @@ public: void addAcceptType(InputIterator first, InputIterator last) { for(; first != last; ++first) { - if(std::find(_acceptTypes.begin(), _acceptTypes.end(), *first) == - _acceptTypes.end()) { - _acceptTypes.push_back(*first); + if(std::find(acceptTypes_.begin(), acceptTypes_.end(), *first) == + acceptTypes_.end()) { + acceptTypes_.push_back(*first); } } } @@ -422,7 +422,7 @@ public: const SharedHandle<URISelector>& getURISelector() const { - return _uriSelector; + return uriSelector_; } void applyLastModifiedTimeToLocalFiles(); @@ -437,44 +437,44 @@ public: // Returns inMemoryDownload flag. bool inMemoryDownload() const { - return _inMemoryDownload; + return inMemoryDownload_; } void setTimeout(time_t timeout); time_t getTimeout() const { - return _timeout; + return timeout_; } // Returns true if current download speed exceeds - // _maxDownloadSpeedLimit. Always returns false if - // _maxDownloadSpeedLimit == 0. Otherwise returns false. + // maxDownloadSpeedLimit_. Always returns false if + // maxDownloadSpeedLimit_ == 0. Otherwise returns false. bool doesDownloadSpeedExceed(); // Returns true if current upload speed exceeds - // _maxUploadSpeedLimit. Always returns false if - // _maxUploadSpeedLimit == 0. Otherwise returns false. + // maxUploadSpeedLimit_. Always returns false if + // maxUploadSpeedLimit_ == 0. Otherwise returns false. bool doesUploadSpeedExceed(); unsigned int getMaxDownloadSpeedLimit() const { - return _maxDownloadSpeedLimit; + return maxDownloadSpeedLimit_; } void setMaxDownloadSpeedLimit(unsigned int speed) { - _maxDownloadSpeedLimit = speed; + maxDownloadSpeedLimit_ = speed; } unsigned int getMaxUploadSpeedLimit() const { - return _maxUploadSpeedLimit; + return maxUploadSpeedLimit_; } void setMaxUploadSpeedLimit(unsigned int speed) { - _maxUploadSpeedLimit = speed; + maxUploadSpeedLimit_ = speed; } void setLastUriResult(std::string uri, downloadresultcode::RESULT result); @@ -483,62 +483,62 @@ public: void removeControlFile() const; - void enableSaveControlFile() { _saveControlFile = true; } + void enableSaveControlFile() { saveControlFile_ = true; } - void disableSaveControlFile() { _saveControlFile = false; } + void disableSaveControlFile() { saveControlFile_ = false; } template<typename InputIterator> void followedBy(InputIterator groupFirst, InputIterator groupLast) { - _followedByGIDs.clear(); + followedByGIDs_.clear(); for(; groupFirst != groupLast; ++groupFirst) { - _followedByGIDs.push_back((*groupFirst)->getGID()); + followedByGIDs_.push_back((*groupFirst)->getGID()); } } const std::vector<gid_t>& followedBy() const { - return _followedByGIDs; + return followedByGIDs_; } void belongsTo(gid_t gid) { - _belongsToGID = gid; + belongsToGID_ = gid; } gid_t belongsTo() const { - return _belongsToGID; + return belongsToGID_; } void setRequestGroupMan(RequestGroupMan* requestGroupMan) { - _requestGroupMan = requestGroupMan; + requestGroupMan_ = requestGroupMan; } int getResumeFailureCount() const { - return _resumeFailureCount; + return resumeFailureCount_; } void increaseResumeFailureCount() { - ++_resumeFailureCount; + ++resumeFailureCount_; } bool p2pInvolved() const; void setMetadataInfo(const SharedHandle<MetadataInfo>& info) { - _metadataInfo = info; + metadataInfo_ = info; } const SharedHandle<MetadataInfo>& getMetadataInfo() const { - return _metadataInfo; + return metadataInfo_; } - static void resetGIDCounter() { _gidCounter = 0; } + static void resetGIDCounter() { gidCounter_ = 0; } static gid_t newGID(); }; diff --git a/src/RequestGroupEntry.cc b/src/RequestGroupEntry.cc index 30c29f69..65427017 100644 --- a/src/RequestGroupEntry.cc +++ b/src/RequestGroupEntry.cc @@ -41,22 +41,22 @@ namespace aria2 { RequestGroupEntry::RequestGroupEntry(RequestGroup* requestGroup, Command* nextCommand): - _requestGroup(requestGroup), - _nextCommand(nextCommand) + requestGroup_(requestGroup), + nextCommand_(nextCommand) { - _requestGroup->increaseNumCommand(); + requestGroup_->increaseNumCommand(); } RequestGroupEntry::~RequestGroupEntry() { - _requestGroup->decreaseNumCommand(); - delete _nextCommand; + requestGroup_->decreaseNumCommand(); + delete nextCommand_; } Command* RequestGroupEntry::popNextCommand() { - Command* temp = _nextCommand; - _nextCommand = 0; + Command* temp = nextCommand_; + nextCommand_ = 0; return temp; } diff --git a/src/RequestGroupEntry.h b/src/RequestGroupEntry.h index 0275c5a4..4b1ed49f 100644 --- a/src/RequestGroupEntry.h +++ b/src/RequestGroupEntry.h @@ -45,8 +45,8 @@ class Command; class RequestGroupEntry { private: - RequestGroup* _requestGroup; - Command* _nextCommand; + RequestGroup* requestGroup_; + Command* nextCommand_; public: RequestGroupEntry(RequestGroup* requestGroup, Command* nextCommand = 0); @@ -55,12 +55,12 @@ public: RequestGroup* getRequestGroup() const { - return _requestGroup; + return requestGroup_; } Command* getNextCommand() const { - return _nextCommand; + return nextCommand_; } Command* popNextCommand(); diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc index 6adf2dda..1be6ea21 100644 --- a/src/RequestGroupMan.cc +++ b/src/RequestGroupMan.cc @@ -78,82 +78,82 @@ RequestGroupMan::RequestGroupMan (const std::vector<SharedHandle<RequestGroup> >& requestGroups, unsigned int maxSimultaneousDownloads, const Option* option): - _reservedGroups(requestGroups.begin(), requestGroups.end()), - _logger(LogFactory::getInstance()), - _maxSimultaneousDownloads(maxSimultaneousDownloads), - _option(option), - _serverStatMan(new ServerStatMan()), - _maxOverallDownloadSpeedLimit + reservedGroups_(requestGroups.begin(), requestGroups.end()), + logger_(LogFactory::getInstance()), + maxSimultaneousDownloads_(maxSimultaneousDownloads), + option_(option), + serverStatMan_(new ServerStatMan()), + maxOverallDownloadSpeedLimit_ (option->getAsInt(PREF_MAX_OVERALL_DOWNLOAD_LIMIT)), - _maxOverallUploadSpeedLimit(option->getAsInt(PREF_MAX_OVERALL_UPLOAD_LIMIT)), - _xmlRpc(option->getAsBool(PREF_ENABLE_XML_RPC)), - _queueCheck(true) + maxOverallUploadSpeedLimit_(option->getAsInt(PREF_MAX_OVERALL_UPLOAD_LIMIT)), + xmlRpc_(option->getAsBool(PREF_ENABLE_XML_RPC)), + queueCheck_(true) {} bool RequestGroupMan::downloadFinished() { #ifdef ENABLE_XML_RPC - if(_xmlRpc) { + if(xmlRpc_) { return false; } #endif // ENABLE_XML_RPC - return _requestGroups.empty() && _reservedGroups.empty(); + return requestGroups_.empty() && reservedGroups_.empty(); } void RequestGroupMan::addRequestGroup (const SharedHandle<RequestGroup>& group) { - _requestGroups.push_back(group); + requestGroups_.push_back(group); } void RequestGroupMan::addReservedGroup (const std::vector<SharedHandle<RequestGroup> >& groups) { - if(_reservedGroups.empty()) { + if(reservedGroups_.empty()) { requestQueueCheck(); } - _reservedGroups.insert(_reservedGroups.end(), groups.begin(), groups.end()); + reservedGroups_.insert(reservedGroups_.end(), groups.begin(), groups.end()); } void RequestGroupMan::addReservedGroup (const SharedHandle<RequestGroup>& group) { - if(_reservedGroups.empty()) { + if(reservedGroups_.empty()) { requestQueueCheck(); } - _reservedGroups.push_back(group); + reservedGroups_.push_back(group); } void RequestGroupMan::insertReservedGroup (size_t pos, const std::vector<SharedHandle<RequestGroup> >& groups) { - if(_reservedGroups.empty()) { + if(reservedGroups_.empty()) { requestQueueCheck(); } - _reservedGroups.insert - (_reservedGroups.begin()+std::min(_reservedGroups.size(), pos), + reservedGroups_.insert + (reservedGroups_.begin()+std::min(reservedGroups_.size(), pos), groups.begin(), groups.end()); } void RequestGroupMan::insertReservedGroup (size_t pos, const SharedHandle<RequestGroup>& group) { - if(_reservedGroups.empty()) { + if(reservedGroups_.empty()) { requestQueueCheck(); } - _reservedGroups.insert - (_reservedGroups.begin()+std::min(_reservedGroups.size(), pos), group); + reservedGroups_.insert + (reservedGroups_.begin()+std::min(reservedGroups_.size(), pos), group); } size_t RequestGroupMan::countRequestGroup() const { - return _requestGroups.size(); + return requestGroups_.size(); } SharedHandle<RequestGroup> RequestGroupMan::getRequestGroup(size_t index) const { - if(index < _requestGroups.size()) { - return _requestGroups[index]; + if(index < requestGroups_.size()) { + return requestGroups_[index]; } else { return SharedHandle<RequestGroup>(); } @@ -174,8 +174,8 @@ SharedHandle<RequestGroup> RequestGroupMan::findRequestGroup(gid_t gid) const { std::deque<SharedHandle<RequestGroup> >::const_iterator i = - findByGID(_requestGroups.begin(), _requestGroups.end(), gid); - if(i == _requestGroups.end()) { + findByGID(requestGroups_.begin(), requestGroups_.end(), gid); + if(i == requestGroups_.end()) { return SharedHandle<RequestGroup>(); } else { return *i; @@ -186,8 +186,8 @@ SharedHandle<RequestGroup> RequestGroupMan::findReservedGroup(gid_t gid) const { std::deque<SharedHandle<RequestGroup> >::const_iterator i = - findByGID(_reservedGroups.begin(), _reservedGroups.end(), gid); - if(i == _reservedGroups.end()) { + findByGID(reservedGroups_.begin(), reservedGroups_.end(), gid); + if(i == reservedGroups_.end()) { return SharedHandle<RequestGroup>(); } else { return *i; @@ -198,14 +198,14 @@ size_t RequestGroupMan::changeReservedGroupPosition (gid_t gid, int pos, HOW how) { std::deque<SharedHandle<RequestGroup> >::iterator i = - findByGID(_reservedGroups.begin(), _reservedGroups.end(), gid); - if(i == _reservedGroups.end()) { + findByGID(reservedGroups_.begin(), reservedGroups_.end(), gid); + if(i == reservedGroups_.end()) { throw DL_ABORT_EX (StringFormat("GID#%s not found in the waiting queue.", util::itos(gid).c_str()).str()); } SharedHandle<RequestGroup> rg = *i; - const size_t maxPos = _reservedGroups.size()-1; + const size_t maxPos = reservedGroups_.size()-1; if(how == POS_SET) { if(pos < 0) { pos = 0; @@ -213,12 +213,12 @@ size_t RequestGroupMan::changeReservedGroupPosition pos = std::min(maxPos, (size_t)pos); } } else if(how == POS_CUR) { - size_t abspos = std::distance(_reservedGroups.begin(), i); + size_t abspos = std::distance(reservedGroups_.begin(), i); if(pos < 0) { - int dist = -std::distance(_reservedGroups.begin(), i); + int dist = -std::distance(reservedGroups_.begin(), i); pos = abspos+std::max(pos, dist); } else if(pos > 0) { - int dist = std::distance(i, _reservedGroups.end())-1; + int dist = std::distance(i, reservedGroups_.end())-1; pos = abspos+std::min(pos, dist); } else { pos = abspos; @@ -230,10 +230,10 @@ size_t RequestGroupMan::changeReservedGroupPosition pos = maxPos-std::min(maxPos, (size_t)-pos); } } - if(std::distance(_reservedGroups.begin(), i) < pos) { - std::rotate(i, i+1, _reservedGroups.begin()+pos+1); + if(std::distance(reservedGroups_.begin(), i) < pos) { + std::rotate(i, i+1, reservedGroups_.begin()+pos+1); } else { - std::rotate(_reservedGroups.begin()+pos, i, i+1); + std::rotate(reservedGroups_.begin()+pos, i, i+1); } return pos; } @@ -241,11 +241,11 @@ size_t RequestGroupMan::changeReservedGroupPosition bool RequestGroupMan::removeReservedGroup(gid_t gid) { std::deque<SharedHandle<RequestGroup> >::iterator i = - findByGID(_reservedGroups.begin(), _reservedGroups.end(), gid); - if(i == _reservedGroups.end()) { + findByGID(reservedGroups_.begin(), reservedGroups_.end(), gid); + if(i == reservedGroups_.end()) { return false; } else { - _reservedGroups.erase(i); + reservedGroups_.erase(i); return true; } } @@ -320,10 +320,10 @@ static void executeStopHook class ProcessStoppedRequestGroup { private: - DownloadEngine* _e; - std::deque<SharedHandle<DownloadResult> >& _downloadResults; - std::deque<SharedHandle<RequestGroup> >& _reservedGroups; - Logger* _logger; + DownloadEngine* e_; + std::deque<SharedHandle<DownloadResult> >& downloadResults_; + std::deque<SharedHandle<RequestGroup> >& reservedGroups_; + Logger* logger_; void saveSignature(const SharedHandle<RequestGroup>& group) { @@ -334,9 +334,9 @@ private: // ".sig". std::string signatureFile = group->getFirstFilePath()+".sig"; if(sig->save(signatureFile)) { - _logger->notice(MSG_SIGNATURE_SAVED, signatureFile.c_str()); + logger_->notice(MSG_SIGNATURE_SAVED, signatureFile.c_str()); } else { - _logger->notice(MSG_SIGNATURE_NOT_SAVED, signatureFile.c_str()); + logger_->notice(MSG_SIGNATURE_NOT_SAVED, signatureFile.c_str()); } } } @@ -345,10 +345,10 @@ public: (DownloadEngine* e, std::deque<SharedHandle<DownloadResult> >& downloadResults, std::deque<SharedHandle<RequestGroup> >& reservedGroups): - _e(e), - _downloadResults(downloadResults), - _reservedGroups(reservedGroups), - _logger(LogFactory::getInstance()) {} + e_(e), + downloadResults_(downloadResults), + reservedGroups_(reservedGroups), + logger_(LogFactory::getInstance()) {} void operator()(const SharedHandle<RequestGroup>& group) { @@ -378,32 +378,32 @@ public: std::vector<SharedHandle<RequestGroup> > nextGroups; group->postDownloadProcessing(nextGroups); if(!nextGroups.empty()) { - if(_logger->debug()) { - _logger->debug + if(logger_->debug()) { + logger_->debug ("Adding %lu RequestGroups as a result of PostDownloadHandler.", static_cast<unsigned long>(nextGroups.size())); } - _e->getRequestGroupMan()->insertReservedGroup(0, nextGroups); + e_->getRequestGroupMan()->insertReservedGroup(0, nextGroups); } } else { group->saveControlFile(); } } catch(RecoverableException& ex) { - _logger->error(EX_EXCEPTION_CAUGHT, ex); + logger_->error(EX_EXCEPTION_CAUGHT, ex); } if(group->isPauseRequested()) { - _reservedGroups.push_front(group); + reservedGroups_.push_front(group); } else { - _downloadResults.push_back(group->createDownloadResult()); + downloadResults_.push_back(group->createDownloadResult()); } - group->releaseRuntimeResource(_e); + group->releaseRuntimeResource(e_); if(group->isPauseRequested()) { group->setForceHaltRequested(false); - executeHookByOptName(group, _e->getOption(), PREF_ON_DOWNLOAD_PAUSE); + executeHookByOptName(group, e_->getOption(), PREF_ON_DOWNLOAD_PAUSE); // TODO Should we have to prepend spend uris to remaining uris // in case PREF_REUSE_URI is disabed? } else { - executeStopHook(_downloadResults.back(), _e->getOption()); + executeStopHook(downloadResults_.back(), e_->getOption()); } } } @@ -411,10 +411,10 @@ public: class CollectServerStat { private: - RequestGroupMan* _requestGroupMan; + RequestGroupMan* requestGroupMan_; public: CollectServerStat(RequestGroupMan* requestGroupMan): - _requestGroupMan(requestGroupMan) {} + requestGroupMan_(requestGroupMan) {} void operator()(const SharedHandle<RequestGroup>& group) { @@ -435,7 +435,7 @@ public: if (speed == 0) continue; SharedHandle<ServerStat> ss = - _requestGroupMan->getOrCreateServerStat((*i)->getHostname(), + requestGroupMan_->getOrCreateServerStat((*i)->getHostname(), (*i)->getProtocol()); ss->increaseCounter(); ss->updateDownloadSpeed(speed); @@ -460,31 +460,31 @@ public: void RequestGroupMan::updateServerStat() { - std::for_each(_requestGroups.begin(), _requestGroups.end(), + std::for_each(requestGroups_.begin(), requestGroups_.end(), CollectServerStat(this)); } void RequestGroupMan::removeStoppedGroup(DownloadEngine* e) { - size_t numPrev = _requestGroups.size(); + size_t numPrev = requestGroups_.size(); updateServerStat(); - std::for_each(_requestGroups.begin(), _requestGroups.end(), + std::for_each(requestGroups_.begin(), requestGroups_.end(), ProcessStoppedRequestGroup - (e, _downloadResults, _reservedGroups)); + (e, downloadResults_, reservedGroups_)); std::deque<SharedHandle<RequestGroup> >::iterator i = - std::remove_if(_requestGroups.begin(), - _requestGroups.end(), + std::remove_if(requestGroups_.begin(), + requestGroups_.end(), FindStoppedRequestGroup()); - if(i != _requestGroups.end()) { - _requestGroups.erase(i, _requestGroups.end()); + if(i != requestGroups_.end()) { + requestGroups_.erase(i, requestGroups_.end()); } - size_t numRemoved = numPrev-_requestGroups.size(); + size_t numRemoved = numPrev-requestGroups_.size(); if(numRemoved > 0) { - if(_logger->debug()) { - _logger->debug("%lu RequestGroup(s) deleted.", + if(logger_->debug()) { + logger_->debug("%lu RequestGroup(s) deleted.", static_cast<unsigned long>(numRemoved)); } } @@ -493,16 +493,16 @@ void RequestGroupMan::removeStoppedGroup(DownloadEngine* e) void RequestGroupMan::configureRequestGroup (const SharedHandle<RequestGroup>& requestGroup) const { - const std::string& uriSelectorValue = _option->get(PREF_URI_SELECTOR); + const std::string& uriSelectorValue = option_->get(PREF_URI_SELECTOR); if(uriSelectorValue == V_FEEDBACK) { requestGroup->setURISelector - (SharedHandle<URISelector>(new FeedbackURISelector(_serverStatMan))); + (SharedHandle<URISelector>(new FeedbackURISelector(serverStatMan_))); } else if(uriSelectorValue == V_INORDER) { requestGroup->setURISelector (SharedHandle<URISelector>(new InOrderURISelector())); } else if(uriSelectorValue == V_ADAPTIVE) { requestGroup->setURISelector - (SharedHandle<URISelector>(new AdaptiveURISelector(_serverStatMan, + (SharedHandle<URISelector>(new AdaptiveURISelector(serverStatMan_, requestGroup.get()))); } } @@ -517,15 +517,15 @@ static void createInitialCommand(const SharedHandle<RequestGroup>& requestGroup, void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e) { removeStoppedGroup(e); - if(_maxSimultaneousDownloads <= _requestGroups.size()) { + if(maxSimultaneousDownloads_ <= requestGroups_.size()) { return; } std::vector<SharedHandle<RequestGroup> > temp; unsigned int count = 0; - size_t num = _maxSimultaneousDownloads-_requestGroups.size(); - while(count < num && !_reservedGroups.empty()) { - SharedHandle<RequestGroup> groupToAdd = _reservedGroups.front(); - _reservedGroups.pop_front(); + size_t num = maxSimultaneousDownloads_-requestGroups_.size(); + while(count < num && !reservedGroups_.empty()) { + SharedHandle<RequestGroup> groupToAdd = reservedGroups_.front(); + reservedGroups_.pop_front(); std::vector<Command*> commands; try { if(groupToAdd->isPauseRequested()||!groupToAdd->isDependencyResolved()) { @@ -541,32 +541,32 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e) if(commands.empty()) { requestQueueCheck(); } - _requestGroups.push_back(groupToAdd); + requestGroups_.push_back(groupToAdd); ++count; e->addCommand(commands); commands.clear(); executeHookByOptName(groupToAdd, e->getOption(), PREF_ON_DOWNLOAD_START); } catch(RecoverableException& ex) { - _logger->error(EX_EXCEPTION_CAUGHT, ex); - if(_logger->debug()) { - _logger->debug("Deleting temporal commands."); + logger_->error(EX_EXCEPTION_CAUGHT, ex); + if(logger_->debug()) { + logger_->debug("Deleting temporal commands."); } std::for_each(commands.begin(), commands.end(), Deleter()); commands.clear(); - if(_logger->debug()) { - _logger->debug("Commands deleted"); + if(logger_->debug()) { + logger_->debug("Commands deleted"); } groupToAdd->releaseRuntimeResource(e); - _downloadResults.push_back(groupToAdd->createDownloadResult()); + downloadResults_.push_back(groupToAdd->createDownloadResult()); } } if(!temp.empty()) { - _reservedGroups.insert(_reservedGroups.begin(), temp.begin(), temp.end()); + reservedGroups_.insert(reservedGroups_.begin(), temp.begin(), temp.end()); } if(count > 0) { e->setNoWait(true); - if(_logger->debug()) { - _logger->debug("%d RequestGroup(s) added.", count); + if(logger_->debug()) { + logger_->debug("%d RequestGroup(s) added.", count); } } } @@ -574,14 +574,14 @@ void RequestGroupMan::fillRequestGroupFromReserver(DownloadEngine* e) void RequestGroupMan::save() { for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = - _requestGroups.begin(), eoi = _requestGroups.end(); itr != eoi; ++itr) { + requestGroups_.begin(), eoi = requestGroups_.end(); itr != eoi; ++itr) { if((*itr)->allDownloadFinished()) { (*itr)->removeControlFile(); } else { try { (*itr)->saveControlFile(); } catch(RecoverableException& e) { - _logger->error(EX_EXCEPTION_CAUGHT, e); + logger_->error(EX_EXCEPTION_CAUGHT, e); } } } @@ -590,7 +590,7 @@ void RequestGroupMan::save() void RequestGroupMan::closeFile() { for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = - _requestGroups.begin(), eoi = _requestGroups.end(); itr != eoi; ++itr) { + requestGroups_.begin(), eoi = requestGroups_.end(); itr != eoi; ++itr) { (*itr)->closeFile(); } } @@ -602,7 +602,7 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const size_t inprogress = 0; downloadresultcode::RESULT lastError = downloadresultcode::FINISHED; for(std::deque<SharedHandle<DownloadResult> >::const_iterator itr = - _downloadResults.begin(), eoi = _downloadResults.end(); + downloadResults_.begin(), eoi = downloadResults_.end(); itr != eoi; ++itr) { if((*itr)->result == downloadresultcode::FINISHED) { ++finished; @@ -612,7 +612,7 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const } } for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = - _requestGroups.begin(), eoi = _requestGroups.end(); itr != eoi; ++itr) { + requestGroups_.begin(), eoi = requestGroups_.end(); itr != eoi; ++itr) { DownloadResultHandle result = (*itr)->createDownloadResult(); if(result->result == downloadresultcode::FINISHED) { ++finished; @@ -620,7 +620,7 @@ RequestGroupMan::DownloadStat RequestGroupMan::getDownloadStat() const ++inprogress; } } - return DownloadStat(finished, error, inprogress, _reservedGroups.size(), + return DownloadStat(finished, error, inprogress, reservedGroups_.size(), lastError); } @@ -648,7 +648,7 @@ void RequestGroupMan::showDownloadResults(std::ostream& o) const int inpr = 0; for(std::deque<SharedHandle<DownloadResult> >::const_iterator itr = - _downloadResults.begin(), eoi = _downloadResults.end(); + downloadResults_.begin(), eoi = downloadResults_.end(); itr != eoi; ++itr) { std::string status; if((*itr)->result == downloadresultcode::FINISHED) { @@ -664,7 +664,7 @@ void RequestGroupMan::showDownloadResults(std::ostream& o) const o << formatDownloadResult(status, *itr) << "\n"; } for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = - _requestGroups.begin(), eoi = _requestGroups.end(); itr != eoi; ++itr) { + requestGroups_.begin(), eoi = requestGroups_.end(); itr != eoi; ++itr) { DownloadResultHandle result = (*itr)->createDownloadResult(); std::string status; if(result->result == downloadresultcode::FINISHED) { @@ -683,7 +683,7 @@ void RequestGroupMan::showDownloadResults(std::ostream& o) const o << formatDownloadResult(status, result) << "\n"; } for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = - _reservedGroups.begin(), eoi = _reservedGroups.end(); + reservedGroups_.begin(), eoi = reservedGroups_.end(); itr != eoi; ++itr) { if(!(*itr)->isPauseRequested()) { continue; @@ -753,7 +753,7 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons } std::vector<std::string> files; for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = - _requestGroups.begin(), eoi = _requestGroups.end(); itr != eoi; ++itr) { + requestGroups_.begin(), eoi = requestGroups_.end(); itr != eoi; ++itr) { if((*itr).get() != requestGroup) { const std::vector<SharedHandle<FileEntry> >& entries = (*itr)->getDownloadContext()->getFileEntries(); @@ -772,7 +772,7 @@ bool RequestGroupMan::isSameFileBeingDownloaded(RequestGroup* requestGroup) cons void RequestGroupMan::halt() { for(std::deque<SharedHandle<RequestGroup> >::const_iterator i = - _requestGroups.begin(), eoi = _requestGroups.end(); i != eoi; ++i) { + requestGroups_.begin(), eoi = requestGroups_.end(); i != eoi; ++i) { (*i)->setHaltRequested(true); } } @@ -780,7 +780,7 @@ void RequestGroupMan::halt() void RequestGroupMan::forceHalt() { for(std::deque<SharedHandle<RequestGroup> >::const_iterator i = - _requestGroups.begin(), eoi = _requestGroups.end(); i != eoi; ++i) { + requestGroups_.begin(), eoi = requestGroups_.end(); i != eoi; ++i) { (*i)->setForceHaltRequested(true); } } @@ -789,7 +789,7 @@ TransferStat RequestGroupMan::calculateStat() { TransferStat s; for(std::deque<SharedHandle<RequestGroup> >::const_iterator i = - _requestGroups.begin(), eoi = _requestGroups.end(); i != eoi; ++i) { + requestGroups_.begin(), eoi = requestGroups_.end(); i != eoi; ++i) { s += (*i)->calculateStat(); } return s; @@ -799,7 +799,7 @@ SharedHandle<DownloadResult> RequestGroupMan::findDownloadResult(gid_t gid) const { for(std::deque<SharedHandle<DownloadResult> >::const_iterator i = - _downloadResults.begin(), eoi = _downloadResults.end(); i != eoi; ++i) { + downloadResults_.begin(), eoi = downloadResults_.end(); i != eoi; ++i) { if((*i)->gid == gid) { return *i; } @@ -809,14 +809,14 @@ RequestGroupMan::findDownloadResult(gid_t gid) const void RequestGroupMan::purgeDownloadResult() { - _downloadResults.clear(); + downloadResults_.clear(); } SharedHandle<ServerStat> RequestGroupMan::findServerStat(const std::string& hostname, const std::string& protocol) const { - return _serverStatMan->find(hostname, protocol); + return serverStatMan_->find(hostname, protocol); } SharedHandle<ServerStat> @@ -833,21 +833,21 @@ RequestGroupMan::getOrCreateServerStat(const std::string& hostname, bool RequestGroupMan::addServerStat(const SharedHandle<ServerStat>& serverStat) { - return _serverStatMan->add(serverStat); + return serverStatMan_->add(serverStat); } bool RequestGroupMan::loadServerStat(const std::string& filename) { std::ifstream in(filename.c_str(), std::ios::binary); if(!in) { - _logger->error(MSG_OPENING_READABLE_SERVER_STAT_FILE_FAILED, filename.c_str()); + logger_->error(MSG_OPENING_READABLE_SERVER_STAT_FILE_FAILED, filename.c_str()); return false; } - if(_serverStatMan->load(in)) { - _logger->notice(MSG_SERVER_STAT_LOADED, filename.c_str()); + if(serverStatMan_->load(in)) { + logger_->notice(MSG_SERVER_STAT_LOADED, filename.c_str()); return true; } else { - _logger->error(MSG_READING_SERVER_STAT_FILE_FAILED, filename.c_str()); + logger_->error(MSG_READING_SERVER_STAT_FILE_FAILED, filename.c_str()); return false; } } @@ -859,39 +859,39 @@ bool RequestGroupMan::saveServerStat(const std::string& filename) const { std::ofstream out(tempfile.c_str(), std::ios::binary); if(!out) { - _logger->error(MSG_OPENING_WRITABLE_SERVER_STAT_FILE_FAILED, + logger_->error(MSG_OPENING_WRITABLE_SERVER_STAT_FILE_FAILED, filename.c_str()); return false; } - if(!_serverStatMan->save(out)) { - _logger->error(MSG_WRITING_SERVER_STAT_FILE_FAILED, filename.c_str()); + if(!serverStatMan_->save(out)) { + logger_->error(MSG_WRITING_SERVER_STAT_FILE_FAILED, filename.c_str()); return false; } } if(File(tempfile).renameTo(filename)) { - _logger->notice(MSG_SERVER_STAT_SAVED, filename.c_str()); + logger_->notice(MSG_SERVER_STAT_SAVED, filename.c_str()); return true; } else { - _logger->error(MSG_WRITING_SERVER_STAT_FILE_FAILED, filename.c_str()); + logger_->error(MSG_WRITING_SERVER_STAT_FILE_FAILED, filename.c_str()); return false; } } void RequestGroupMan::removeStaleServerStat(time_t timeout) { - _serverStatMan->removeStaleServerStat(timeout); + serverStatMan_->removeStaleServerStat(timeout); } bool RequestGroupMan::doesOverallDownloadSpeedExceed() { - return _maxOverallDownloadSpeedLimit > 0 && - _maxOverallDownloadSpeedLimit < calculateStat().getDownloadSpeed(); + return maxOverallDownloadSpeedLimit_ > 0 && + maxOverallDownloadSpeedLimit_ < calculateStat().getDownloadSpeed(); } bool RequestGroupMan::doesOverallUploadSpeedExceed() { - return _maxOverallUploadSpeedLimit > 0 && - _maxOverallUploadSpeedLimit < calculateStat().getUploadSpeed(); + return maxOverallUploadSpeedLimit_ > 0 && + maxOverallUploadSpeedLimit_ < calculateStat().getUploadSpeed(); } } // namespace aria2 diff --git a/src/RequestGroupMan.h b/src/RequestGroupMan.h index 5e959bfc..0487e936 100644 --- a/src/RequestGroupMan.h +++ b/src/RequestGroupMan.h @@ -59,24 +59,24 @@ class Option; class RequestGroupMan { private: - std::deque<SharedHandle<RequestGroup> > _requestGroups; - std::deque<SharedHandle<RequestGroup> > _reservedGroups; - std::deque<SharedHandle<DownloadResult> > _downloadResults; - Logger* _logger; - unsigned int _maxSimultaneousDownloads; + std::deque<SharedHandle<RequestGroup> > requestGroups_; + std::deque<SharedHandle<RequestGroup> > reservedGroups_; + std::deque<SharedHandle<DownloadResult> > downloadResults_; + Logger* logger_; + unsigned int maxSimultaneousDownloads_; - const Option* _option; + const Option* option_; - SharedHandle<ServerStatMan> _serverStatMan; + SharedHandle<ServerStatMan> serverStatMan_; - unsigned int _maxOverallDownloadSpeedLimit; + unsigned int maxOverallDownloadSpeedLimit_; - unsigned int _maxOverallUploadSpeedLimit; + unsigned int maxOverallUploadSpeedLimit_; // truf if XML-RPC is enabled. - bool _xmlRpc; + bool xmlRpc_; - bool _queueCheck; + bool queueCheck_; std::string formatDownloadResult(const std::string& status, @@ -120,14 +120,14 @@ public: const std::deque<SharedHandle<RequestGroup> >& getRequestGroups() const { - return _requestGroups; + return requestGroups_; } SharedHandle<RequestGroup> findRequestGroup(gid_t gid) const; const std::deque<SharedHandle<RequestGroup> >& getReservedGroups() const { - return _reservedGroups; + return reservedGroups_; } SharedHandle<RequestGroup> findReservedGroup(gid_t gid) const; @@ -159,11 +159,11 @@ public: class DownloadStat { private: - size_t _completed; - size_t _error; - size_t _inProgress; - size_t _waiting; - downloadresultcode::RESULT _lastErrorResult; + size_t completed_; + size_t error_; + size_t inProgress_; + size_t waiting_; + downloadresultcode::RESULT lastErrorResult_; public: DownloadStat(size_t completed, size_t error, @@ -171,25 +171,25 @@ public: size_t waiting, downloadresultcode::RESULT lastErrorResult = downloadresultcode::FINISHED): - _completed(completed), - _error(error), - _inProgress(inProgress), - _waiting(waiting), - _lastErrorResult(lastErrorResult) {} + completed_(completed), + error_(error), + inProgress_(inProgress), + waiting_(waiting), + lastErrorResult_(lastErrorResult) {} downloadresultcode::RESULT getLastErrorResult() const { - return _lastErrorResult; + return lastErrorResult_; } bool allCompleted() const { - return _error == 0 && _inProgress == 0 && _waiting == 0; + return error_ == 0 && inProgress_ == 0 && waiting_ == 0; } size_t getInProgress() const { - return _inProgress; + return inProgress_; } }; @@ -197,7 +197,7 @@ public: const std::deque<SharedHandle<DownloadResult> >& getDownloadResults() const { - return _downloadResults; + return downloadResults_; } SharedHandle<DownloadResult> findDownloadResult(gid_t gid) const; @@ -222,56 +222,56 @@ public: void removeStaleServerStat(time_t timeout); // Returns true if current download speed exceeds - // _maxOverallDownloadSpeedLimit. Always returns false if - // _maxOverallDownloadSpeedLimit == 0. Otherwise returns false. + // maxOverallDownloadSpeedLimit_. Always returns false if + // maxOverallDownloadSpeedLimit_ == 0. Otherwise returns false. bool doesOverallDownloadSpeedExceed(); void setMaxOverallDownloadSpeedLimit(unsigned int speed) { - _maxOverallDownloadSpeedLimit = speed; + maxOverallDownloadSpeedLimit_ = speed; } unsigned int getMaxOverallDownloadSpeedLimit() const { - return _maxOverallDownloadSpeedLimit; + return maxOverallDownloadSpeedLimit_; } // Returns true if current upload speed exceeds - // _maxOverallUploadSpeedLimit. Always returns false if - // _maxOverallUploadSpeedLimit == 0. Otherwise returns false. + // maxOverallUploadSpeedLimit_. Always returns false if + // maxOverallUploadSpeedLimit_ == 0. Otherwise returns false. bool doesOverallUploadSpeedExceed(); void setMaxOverallUploadSpeedLimit(unsigned int speed) { - _maxOverallUploadSpeedLimit = speed; + maxOverallUploadSpeedLimit_ = speed; } unsigned int getMaxOverallUploadSpeedLimit() const { - return _maxOverallUploadSpeedLimit; + return maxOverallUploadSpeedLimit_; } void setMaxSimultaneousDownloads(unsigned int max) { - _maxSimultaneousDownloads = max; + maxSimultaneousDownloads_ = max; } - // Call this function if _requestGroups queue should be maintained. + // Call this function if requestGroups_ queue should be maintained. // This function is added to reduce the call of maintenance, but at // the same time, it provides fast maintenance reaction. void requestQueueCheck() { - _queueCheck = true; + queueCheck_ = true; } void clearQueueCheck() { - _queueCheck = false; + queueCheck_ = false; } bool queueCheckRequested() const { - return _queueCheck; + return queueCheck_; } }; diff --git a/src/RequestSlot.cc b/src/RequestSlot.cc index 909aab66..557fc5ab 100644 --- a/src/RequestSlot.cc +++ b/src/RequestSlot.cc @@ -40,16 +40,16 @@ namespace aria2 { RequestSlot RequestSlot::nullSlot = RequestSlot(); void RequestSlot::setDispatchedTime(time_t sec) { - _dispatchedTime.reset(sec); + dispatchedTime_.reset(sec); } bool RequestSlot::isTimeout(time_t timeoutSec) const { - return _dispatchedTime.difference(global::wallclock) >= timeoutSec; + return dispatchedTime_.difference(global::wallclock) >= timeoutSec; } bool RequestSlot::isNull(const RequestSlot& requestSlot) { - return requestSlot._index == 0 && requestSlot._begin == 0&& - requestSlot._length == 0; + return requestSlot.index_ == 0 && requestSlot.begin_ == 0&& + requestSlot.length_ == 0; } } // namespace aria2 diff --git a/src/RequestSlot.h b/src/RequestSlot.h index 9a2c239e..933a9af1 100644 --- a/src/RequestSlot.h +++ b/src/RequestSlot.h @@ -44,47 +44,47 @@ namespace aria2 { class RequestSlot { private: - Timer _dispatchedTime; - size_t _index; - uint32_t _begin; - size_t _length; - size_t _blockIndex; + Timer dispatchedTime_; + size_t index_; + uint32_t begin_; + size_t length_; + size_t blockIndex_; // This is the piece whose index is index of this RequestSlot has. // To detect duplicate RequestSlot, we have to find the piece using // PieceStorage::getPiece() repeatedly. It turns out that this process // takes time(about 1.7% of processing time). To reduce it, we put piece here // at the construction of RequestSlot as a cache. - SharedHandle<Piece> _piece; + SharedHandle<Piece> piece_; // inlined for performance reason void copy(const RequestSlot& requestSlot) { - _dispatchedTime = requestSlot._dispatchedTime; - _index = requestSlot._index; - _begin = requestSlot._begin; - _length = requestSlot._length; - _blockIndex = requestSlot._blockIndex; - _piece = requestSlot._piece; + dispatchedTime_ = requestSlot.dispatchedTime_; + index_ = requestSlot.index_; + begin_ = requestSlot.begin_; + length_ = requestSlot.length_; + blockIndex_ = requestSlot.blockIndex_; + piece_ = requestSlot.piece_; } public: RequestSlot(size_t index, uint32_t begin, size_t length, size_t blockIndex, const SharedHandle<Piece>& piece = SharedHandle<Piece>()): - _dispatchedTime(global::wallclock), - _index(index), _begin(begin), _length(length), _blockIndex(blockIndex), - _piece(piece) {} + dispatchedTime_(global::wallclock), + index_(index), begin_(begin), length_(length), blockIndex_(blockIndex), + piece_(piece) {} RequestSlot(const RequestSlot& requestSlot): - _dispatchedTime(requestSlot._dispatchedTime), - _index(requestSlot._index), - _begin(requestSlot._begin), - _length(requestSlot._length), - _blockIndex(requestSlot._blockIndex), - _piece(requestSlot._piece) {} - - RequestSlot():_dispatchedTime(0), _index(0), _begin(0), _length(0), - _blockIndex(0) + dispatchedTime_(requestSlot.dispatchedTime_), + index_(requestSlot.index_), + begin_(requestSlot.begin_), + length_(requestSlot.length_), + blockIndex_(requestSlot.blockIndex_), + piece_(requestSlot.piece_) {} + + RequestSlot():dispatchedTime_(0), index_(0), begin_(0), length_(0), + blockIndex_(0) {} ~RequestSlot() {} @@ -99,8 +99,8 @@ public: bool operator==(const RequestSlot& requestSlot) const { - return _index == requestSlot._index && _begin == requestSlot._begin - && _length == requestSlot._length; + return index_ == requestSlot.index_ && begin_ == requestSlot.begin_ + && length_ == requestSlot.length_; } bool operator!=(const RequestSlot& requestSlot) const @@ -110,10 +110,10 @@ public: bool operator<(const RequestSlot& requestSlot) const { - if(_index == requestSlot._index) { - return _begin < requestSlot._begin; + if(index_ == requestSlot.index_) { + return begin_ < requestSlot.begin_; } else { - return _index < requestSlot._index; + return index_ < requestSlot.index_; } } @@ -121,21 +121,21 @@ public: bool isTimeout(time_t timeoutSec) const; - size_t getIndex() const { return _index; } - void setIndex(size_t index) { _index = index; } + size_t getIndex() const { return index_; } + void setIndex(size_t index) { index_ = index; } - uint32_t getBegin() const { return _begin; } - void setBegin(uint32_t begin) { _begin = begin; } + uint32_t getBegin() const { return begin_; } + void setBegin(uint32_t begin) { begin_ = begin; } - size_t getLength() const { return _length; } - void setLength(size_t length) { _length = length; } + size_t getLength() const { return length_; } + void setLength(size_t length) { length_ = length; } - size_t getBlockIndex() const { return _blockIndex; } - void setBlockIndex(size_t blockIndex) { _blockIndex = blockIndex; } + size_t getBlockIndex() const { return blockIndex_; } + void setBlockIndex(size_t blockIndex) { blockIndex_ = blockIndex; } const SharedHandle<Piece>& getPiece() const { - return _piece; + return piece_; } static RequestSlot nullSlot; diff --git a/src/SeedCheckCommand.cc b/src/SeedCheckCommand.cc index 56853945..43bbfe93 100644 --- a/src/SeedCheckCommand.cc +++ b/src/SeedCheckCommand.cc @@ -54,58 +54,58 @@ SeedCheckCommand::SeedCheckCommand DownloadEngine* e, const SharedHandle<SeedCriteria>& seedCriteria) :Command(cuid), - _requestGroup(requestGroup), - _e(e), - _seedCriteria(seedCriteria), - _checkStarted(false) + requestGroup_(requestGroup), + e_(e), + seedCriteria_(seedCriteria), + checkStarted_(false) { setStatusRealtime(); - _requestGroup->increaseNumCommand(); + requestGroup_->increaseNumCommand(); } SeedCheckCommand::~SeedCheckCommand() { - _requestGroup->decreaseNumCommand(); + requestGroup_->decreaseNumCommand(); } bool SeedCheckCommand::execute() { - if(_btRuntime->isHalt()) { + if(btRuntime_->isHalt()) { return true; } - if(!_seedCriteria.get()) { + if(!seedCriteria_.get()) { return false; } - if(!_checkStarted) { - if(_pieceStorage->downloadFinished()) { - _checkStarted = true; - _seedCriteria->reset(); + if(!checkStarted_) { + if(pieceStorage_->downloadFinished()) { + checkStarted_ = true; + seedCriteria_->reset(); } } - if(_checkStarted) { - if(_seedCriteria->evaluate()) { + if(checkStarted_) { + if(seedCriteria_->evaluate()) { getLogger()->notice(MSG_SEEDING_END); - _btRuntime->setHalt(true); + btRuntime_->setHalt(true); } } - _e->addCommand(this); + e_->addCommand(this); return false; } void SeedCheckCommand::setSeedCriteria (const SharedHandle<SeedCriteria>& seedCriteria) { - _seedCriteria = seedCriteria; + seedCriteria_ = seedCriteria; } void SeedCheckCommand::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void SeedCheckCommand::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } diff --git a/src/SeedCheckCommand.h b/src/SeedCheckCommand.h index 875173ec..dd42d702 100644 --- a/src/SeedCheckCommand.h +++ b/src/SeedCheckCommand.h @@ -49,12 +49,12 @@ class PieceStorage; class SeedCheckCommand : public Command { private: - RequestGroup* _requestGroup; - DownloadEngine* _e; - SharedHandle<PieceStorage> _pieceStorage; - SharedHandle<BtRuntime> _btRuntime; - SharedHandle<SeedCriteria> _seedCriteria; - bool _checkStarted; + RequestGroup* requestGroup_; + DownloadEngine* e_; + SharedHandle<PieceStorage> pieceStorage_; + SharedHandle<BtRuntime> btRuntime_; + SharedHandle<SeedCriteria> seedCriteria_; + bool checkStarted_; public: SeedCheckCommand(cuid_t cuid, RequestGroup* requestGroup, diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc index f7a62264..ae17f8de 100644 --- a/src/SegmentMan.cc +++ b/src/SegmentMan.cc @@ -58,26 +58,26 @@ namespace aria2 { SegmentMan::SegmentMan(const Option* option, const SharedHandle<DownloadContext>& downloadContext, const PieceStorageHandle& pieceStorage): - _option(option), - _logger(LogFactory::getInstance()), - _downloadContext(downloadContext), - _pieceStorage(pieceStorage), - _lastPeerStatDlspdMapUpdated(0), - _cachedDlspd(0), - _ignoreBitfield(downloadContext->getPieceLength(), + option_(option), + logger_(LogFactory::getInstance()), + downloadContext_(downloadContext), + pieceStorage_(pieceStorage), + lastPeerStatDlspdMapUpdated_(0), + cachedDlspd_(0), + ignoreBitfield_(downloadContext->getPieceLength(), downloadContext->getTotalLength()) { - _ignoreBitfield.enableFilter(); + ignoreBitfield_.enableFilter(); } SegmentMan::~SegmentMan() {} bool SegmentMan::downloadFinished() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return false; } else { - return _pieceStorage->downloadFinished(); + return pieceStorage_->downloadFinished(); } } @@ -89,22 +89,22 @@ void SegmentMan::init() uint64_t SegmentMan::getTotalLength() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return 0; } else { - return _pieceStorage->getTotalLength(); + return pieceStorage_->getTotalLength(); } } void SegmentMan::setPieceStorage(const PieceStorageHandle& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void SegmentMan::setDownloadContext (const SharedHandle<DownloadContext>& downloadContext) { - _downloadContext = downloadContext; + downloadContext_ = downloadContext; } SharedHandle<Segment> SegmentMan::checkoutSegment @@ -113,20 +113,20 @@ SharedHandle<Segment> SegmentMan::checkoutSegment if(piece.isNull()) { return SharedHandle<Segment>(); } - if(_logger->debug()) { - _logger->debug("Attach segment#%d to CUID#%s.", + if(logger_->debug()) { + logger_->debug("Attach segment#%d to CUID#%s.", piece->getIndex(), util::itos(cuid).c_str()); } SharedHandle<Segment> segment; if(piece->getLength() == 0) { segment.reset(new GrowSegment(piece)); } else { - segment.reset(new PiecedSegment(_downloadContext->getPieceLength(), piece)); + segment.reset(new PiecedSegment(downloadContext_->getPieceLength(), piece)); } SegmentEntryHandle entry(new SegmentEntry(cuid, segment)); - _usedSegmentEntries.push_back(entry); - if(_logger->debug()) { - _logger->debug("index=%d, length=%d, segmentLength=%d, writtenLength=%d", + usedSegmentEntries_.push_back(entry); + if(logger_->debug()) { + logger_->debug("index=%d, length=%d, segmentLength=%d, writtenLength=%d", segment->getIndex(), segment->getLength(), segment->getSegmentLength(), @@ -134,11 +134,11 @@ SharedHandle<Segment> SegmentMan::checkoutSegment } if(piece->getLength() > 0) { std::map<size_t, size_t>::iterator positr = - _segmentWrittenLengthMemo.find(segment->getIndex()); - if(positr != _segmentWrittenLengthMemo.end()) { + segmentWrittenLengthMemo_.find(segment->getIndex()); + if(positr != segmentWrittenLengthMemo_.end()) { const size_t writtenLength = (*positr).second; - if(_logger->debug()) { - _logger->debug("writtenLength(in memo)=%d, writtenLength=%d", + if(logger_->debug()) { + logger_->debug("writtenLength(in memo)=%d, writtenLength=%d", writtenLength, segment->getWrittenLength()); } // If the difference between cached writtenLength and segment's @@ -156,8 +156,8 @@ SharedHandle<Segment> SegmentMan::checkoutSegment void SegmentMan::getInFlightSegment (std::vector<SharedHandle<Segment> >& segments, cuid_t cuid) { - for(SegmentEntries::const_iterator itr = _usedSegmentEntries.begin(), - eoi = _usedSegmentEntries.end(); itr != eoi; ++itr) { + for(SegmentEntries::const_iterator itr = usedSegmentEntries_.begin(), + eoi = usedSegmentEntries_.end(); itr != eoi; ++itr) { const SegmentEntryHandle& segmentEntry = *itr; if(segmentEntry->cuid == cuid) { segments.push_back(segmentEntry->segment); @@ -167,8 +167,8 @@ void SegmentMan::getInFlightSegment SharedHandle<Segment> SegmentMan::getSegment(cuid_t cuid) { SharedHandle<Piece> piece = - _pieceStorage->getSparseMissingUnusedPiece - (_ignoreBitfield.getFilterBitfield(),_ignoreBitfield.getBitfieldLength()); + pieceStorage_->getSparseMissingUnusedPiece + (ignoreBitfield_.getFilterBitfield(),ignoreBitfield_.getBitfieldLength()); return checkoutSegment(cuid, piece); } @@ -178,14 +178,14 @@ void SegmentMan::getSegment const SharedHandle<FileEntry>& fileEntry, size_t maxSegments) { - BitfieldMan filter(_ignoreBitfield); + BitfieldMan filter(ignoreBitfield_); filter.enableFilter(); filter.addNotFilter(fileEntry->getOffset(), fileEntry->getLength()); std::vector<SharedHandle<Segment> > pending; while(segments.size() < maxSegments) { SharedHandle<Segment> segment = checkoutSegment(cuid, - _pieceStorage->getSparseMissingUnusedPiece + pieceStorage_->getSparseMissingUnusedPiece (filter.getFilterBitfield(), filter.getBitfieldLength())); if(segment.isNull()) { break; @@ -204,20 +204,20 @@ void SegmentMan::getSegment } SharedHandle<Segment> SegmentMan::getSegment(cuid_t cuid, size_t index) { - if(index > 0 && _downloadContext->getNumPieces() <= index) { + if(index > 0 && downloadContext_->getNumPieces() <= index) { return SharedHandle<Segment>(); } - return checkoutSegment(cuid, _pieceStorage->getMissingPiece(index)); + return checkoutSegment(cuid, pieceStorage_->getMissingPiece(index)); } SharedHandle<Segment> SegmentMan::getCleanSegmentIfOwnerIsIdle (cuid_t cuid, size_t index) { - if(index > 0 && _downloadContext->getNumPieces() <= index) { + if(index > 0 && downloadContext_->getNumPieces() <= index) { return SharedHandle<Segment>(); } - for(SegmentEntries::const_iterator itr = _usedSegmentEntries.begin(), - eoi = _usedSegmentEntries.end(); itr != eoi; ++itr) { + for(SegmentEntries::const_iterator itr = usedSegmentEntries_.begin(), + eoi = usedSegmentEntries_.end(); itr != eoi; ++itr) { const SharedHandle<SegmentEntry>& segmentEntry = *itr; if(segmentEntry->segment->getIndex() == index) { if(segmentEntry->cuid == cuid) { @@ -236,29 +236,29 @@ SharedHandle<Segment> SegmentMan::getCleanSegmentIfOwnerIsIdle } } } - return checkoutSegment(cuid, _pieceStorage->getMissingPiece(index)); + return checkoutSegment(cuid, pieceStorage_->getMissingPiece(index)); } void SegmentMan::cancelSegment(const SharedHandle<Segment>& segment) { - if(_logger->debug()) { - _logger->debug("Canceling segment#%d", segment->getIndex()); + if(logger_->debug()) { + logger_->debug("Canceling segment#%d", segment->getIndex()); } - _pieceStorage->cancelPiece(segment->getPiece()); - _segmentWrittenLengthMemo[segment->getIndex()] = segment->getWrittenLength(); - if(_logger->debug()) { - _logger->debug("Memorized segment index=%u, writtenLength=%u", + pieceStorage_->cancelPiece(segment->getPiece()); + segmentWrittenLengthMemo_[segment->getIndex()] = segment->getWrittenLength(); + if(logger_->debug()) { + logger_->debug("Memorized segment index=%u, writtenLength=%u", segment->getIndex(), segment->getWrittenLength()); } } void SegmentMan::cancelSegment(cuid_t cuid) { - for(SegmentEntries::iterator itr = _usedSegmentEntries.begin(), - eoi = _usedSegmentEntries.end(); itr != eoi;) { + for(SegmentEntries::iterator itr = usedSegmentEntries_.begin(), + eoi = usedSegmentEntries_.end(); itr != eoi;) { if((*itr)->cuid == cuid) { cancelSegment((*itr)->segment); - itr = _usedSegmentEntries.erase(itr); - eoi = _usedSegmentEntries.end(); + itr = usedSegmentEntries_.erase(itr); + eoi = usedSegmentEntries_.end(); } else { ++itr; } @@ -268,12 +268,12 @@ void SegmentMan::cancelSegment(cuid_t cuid) { void SegmentMan::cancelSegment (cuid_t cuid, const SharedHandle<Segment>& segment) { - for(SegmentEntries::iterator itr = _usedSegmentEntries.begin(), - eoi = _usedSegmentEntries.end(); itr != eoi;) { + for(SegmentEntries::iterator itr = usedSegmentEntries_.begin(), + eoi = usedSegmentEntries_.end(); itr != eoi;) { if((*itr)->cuid == cuid && (*itr)->segment == segment) { cancelSegment((*itr)->segment); - itr = _usedSegmentEntries.erase(itr); - //eoi = _usedSegmentEntries.end(); + itr = usedSegmentEntries_.erase(itr); + //eoi = usedSegmentEntries_.end(); break; } else { ++itr; @@ -284,73 +284,73 @@ void SegmentMan::cancelSegment void SegmentMan::cancelAllSegments() { for(std::deque<SharedHandle<SegmentEntry> >::iterator itr = - _usedSegmentEntries.begin(), eoi = _usedSegmentEntries.end(); + usedSegmentEntries_.begin(), eoi = usedSegmentEntries_.end(); itr != eoi; ++itr) { cancelSegment((*itr)->segment); } - _usedSegmentEntries.clear(); + usedSegmentEntries_.clear(); } void SegmentMan::eraseSegmentWrittenLengthMemo() { - _segmentWrittenLengthMemo.clear(); + segmentWrittenLengthMemo_.clear(); } class FindSegmentEntry { private: - SharedHandle<Segment> _segment; + SharedHandle<Segment> segment_; public: - FindSegmentEntry(const SharedHandle<Segment>& segment):_segment(segment) {} + FindSegmentEntry(const SharedHandle<Segment>& segment):segment_(segment) {} bool operator()(const SegmentEntryHandle& segmentEntry) const { - return segmentEntry->segment->getIndex() == _segment->getIndex(); + return segmentEntry->segment->getIndex() == segment_->getIndex(); } }; bool SegmentMan::completeSegment (cuid_t cuid, const SharedHandle<Segment>& segment) { - _pieceStorage->completePiece(segment->getPiece()); - _pieceStorage->advertisePiece(cuid, segment->getPiece()->getIndex()); - SegmentEntries::iterator itr = std::find_if(_usedSegmentEntries.begin(), - _usedSegmentEntries.end(), + pieceStorage_->completePiece(segment->getPiece()); + pieceStorage_->advertisePiece(cuid, segment->getPiece()->getIndex()); + SegmentEntries::iterator itr = std::find_if(usedSegmentEntries_.begin(), + usedSegmentEntries_.end(), FindSegmentEntry(segment)); - if(itr == _usedSegmentEntries.end()) { + if(itr == usedSegmentEntries_.end()) { return false; } else { - _usedSegmentEntries.erase(itr); + usedSegmentEntries_.erase(itr); return true; } } bool SegmentMan::hasSegment(size_t index) const { - return _pieceStorage->hasPiece(index); + return pieceStorage_->hasPiece(index); } uint64_t SegmentMan::getDownloadLength() const { - if(_pieceStorage.isNull()) { + if(pieceStorage_.isNull()) { return 0; } else { - return _pieceStorage->getCompletedLength(); + return pieceStorage_->getCompletedLength(); } } void SegmentMan::registerPeerStat(const SharedHandle<PeerStat>& peerStat) { - for(std::vector<SharedHandle<PeerStat> >::iterator i = _peerStats.begin(), - eoi = _peerStats.end(); i != eoi; ++i) { + for(std::vector<SharedHandle<PeerStat> >::iterator i = peerStats_.begin(), + eoi = peerStats_.end(); i != eoi; ++i) { if((*i)->getStatus() == PeerStat::IDLE) { *i = peerStat; return; } } - _peerStats.push_back(peerStat); + peerStats_.push_back(peerStat); } SharedHandle<PeerStat> SegmentMan::getPeerStat(cuid_t cuid) const { for(std::vector<SharedHandle<PeerStat> >::const_iterator i = - _peerStats.begin(), eoi = _peerStats.end(); i != eoi; ++i) { + peerStats_.begin(), eoi = peerStats_.end(); i != eoi; ++i) { if((*i)->getCuid() == cuid) { return *i; } @@ -361,25 +361,25 @@ SharedHandle<PeerStat> SegmentMan::getPeerStat(cuid_t cuid) const class PeerStatHostProtoEqual { private: - const SharedHandle<PeerStat>& _peerStat; + const SharedHandle<PeerStat>& peerStat_; public: PeerStatHostProtoEqual(const SharedHandle<PeerStat>& peerStat): - _peerStat(peerStat) {} + peerStat_(peerStat) {} bool operator()(const SharedHandle<PeerStat>& p) const { - return _peerStat->getHostname() == p->getHostname() && - _peerStat->getProtocol() == p->getProtocol(); + return peerStat_->getHostname() == p->getHostname() && + peerStat_->getProtocol() == p->getProtocol(); } }; void SegmentMan::updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat) { std::vector<SharedHandle<PeerStat> >::iterator i = - std::find_if(_fastestPeerStats.begin(), _fastestPeerStats.end(), + std::find_if(fastestPeerStats_.begin(), fastestPeerStats_.end(), PeerStatHostProtoEqual(peerStat)); - if(i == _fastestPeerStats.end()) { - _fastestPeerStats.push_back(peerStat); + if(i == fastestPeerStats_.end()) { + fastestPeerStats_.push_back(peerStat); } else if((*i)->getAvgDownloadSpeed() < peerStat->getAvgDownloadSpeed()) { // *i's SessionDownloadLength must be added to peerStat peerStat->addSessionDownloadLength((*i)->getSessionDownloadLength()); @@ -393,20 +393,20 @@ void SegmentMan::updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat) unsigned int SegmentMan::calculateDownloadSpeed() { unsigned int speed = 0; - if(_lastPeerStatDlspdMapUpdated.differenceInMillis(global::wallclock) >= 250){ - _lastPeerStatDlspdMapUpdated = global::wallclock; - _peerStatDlspdMap.clear(); + if(lastPeerStatDlspdMapUpdated_.differenceInMillis(global::wallclock) >= 250){ + lastPeerStatDlspdMapUpdated_ = global::wallclock; + peerStatDlspdMap_.clear(); for(std::vector<SharedHandle<PeerStat> >::const_iterator i = - _peerStats.begin(), eoi = _peerStats.end(); i != eoi; ++i) { + peerStats_.begin(), eoi = peerStats_.end(); i != eoi; ++i) { if((*i)->getStatus() == PeerStat::ACTIVE) { unsigned int s = (*i)->calculateDownloadSpeed(); - _peerStatDlspdMap[(*i)->getCuid()] = s; + peerStatDlspdMap_[(*i)->getCuid()] = s; speed += s; } } - _cachedDlspd = speed; + cachedDlspd_ = speed; } else { - speed = _cachedDlspd; + speed = cachedDlspd_; } return speed; } @@ -414,14 +414,14 @@ unsigned int SegmentMan::calculateDownloadSpeed() void SegmentMan::updateDownloadSpeedFor(const SharedHandle<PeerStat>& pstat) { unsigned int newspd = pstat->calculateDownloadSpeed(); - unsigned int oldSpd = _peerStatDlspdMap[pstat->getCuid()]; - if(_cachedDlspd > oldSpd) { - _cachedDlspd -= oldSpd; - _cachedDlspd += newspd; + unsigned int oldSpd = peerStatDlspdMap_[pstat->getCuid()]; + if(cachedDlspd_ > oldSpd) { + cachedDlspd_ -= oldSpd; + cachedDlspd_ += newspd; } else { - _cachedDlspd = newspd; + cachedDlspd_ = newspd; } - _peerStatDlspdMap[pstat->getCuid()] = newspd; + peerStatDlspdMap_[pstat->getCuid()] = newspd; } class PeerStatDownloadLengthOperator { @@ -434,40 +434,40 @@ public: uint64_t SegmentMan::calculateSessionDownloadLength() const { - return std::accumulate(_fastestPeerStats.begin(), _fastestPeerStats.end(), + return std::accumulate(fastestPeerStats_.begin(), fastestPeerStats_.end(), 0LL, PeerStatDownloadLengthOperator()); } size_t SegmentMan::countFreePieceFrom(size_t index) const { - size_t numPieces = _downloadContext->getNumPieces(); + size_t numPieces = downloadContext_->getNumPieces(); for(size_t i = index; i < numPieces; ++i) { - if(_pieceStorage->hasPiece(i) || _pieceStorage->isPieceUsed(i)) { + if(pieceStorage_->hasPiece(i) || pieceStorage_->isPieceUsed(i)) { return i-index; } } - return _downloadContext->getNumPieces()-index; + return downloadContext_->getNumPieces()-index; } void SegmentMan::ignoreSegmentFor(const SharedHandle<FileEntry>& fileEntry) { - if(_logger->debug()) { - _logger->debug("ignoring segment for path=%s, offset=%s, length=%s", + if(logger_->debug()) { + logger_->debug("ignoring segment for path=%s, offset=%s, length=%s", fileEntry->getPath().c_str(), util::itos(fileEntry->getOffset()).c_str(), util::uitos(fileEntry->getLength()).c_str()); } - _ignoreBitfield.addFilter(fileEntry->getOffset(), fileEntry->getLength()); + ignoreBitfield_.addFilter(fileEntry->getOffset(), fileEntry->getLength()); } void SegmentMan::recognizeSegmentFor(const SharedHandle<FileEntry>& fileEntry) { - _ignoreBitfield.removeFilter(fileEntry->getOffset(), fileEntry->getLength()); + ignoreBitfield_.removeFilter(fileEntry->getOffset(), fileEntry->getLength()); } bool SegmentMan::allSegmentsIgnored() const { - return _ignoreBitfield.isAllFilterBitSet(); + return ignoreBitfield_.isAllFilterBitSet(); } } // namespace aria2 diff --git a/src/SegmentMan.h b/src/SegmentMan.h index 9f3bc13e..15fe0ff1 100644 --- a/src/SegmentMan.h +++ b/src/SegmentMan.h @@ -72,34 +72,34 @@ typedef std::deque<SegmentEntryHandle> SegmentEntries; */ class SegmentMan { private: - const Option* _option; + const Option* option_; - Logger* _logger; + Logger* logger_; - SharedHandle<DownloadContext> _downloadContext; + SharedHandle<DownloadContext> downloadContext_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - SegmentEntries _usedSegmentEntries; + SegmentEntries usedSegmentEntries_; // Remember writtenLength for each segment. The key is an index of a // segment. The value is writtenLength for that segment. - std::map<size_t, size_t> _segmentWrittenLengthMemo; + std::map<size_t, size_t> segmentWrittenLengthMemo_; // Used for calculating download speed. - std::vector<SharedHandle<PeerStat> > _peerStats; + std::vector<SharedHandle<PeerStat> > peerStats_; // Keep track of fastest PeerStat for each server - std::vector<SharedHandle<PeerStat> > _fastestPeerStats; + std::vector<SharedHandle<PeerStat> > fastestPeerStats_; // key: PeerStat's cuid, value: its download speed - std::map<cuid_t, unsigned int> _peerStatDlspdMap; + std::map<cuid_t, unsigned int> peerStatDlspdMap_; - Timer _lastPeerStatDlspdMapUpdated; + Timer lastPeerStatDlspdMapUpdated_; - unsigned int _cachedDlspd; + unsigned int cachedDlspd_; - BitfieldMan _ignoreBitfield; + BitfieldMan ignoreBitfield_; SharedHandle<Segment> checkoutSegment(cuid_t cuid, const SharedHandle<Piece>& piece); @@ -204,27 +204,27 @@ public: uint64_t getDownloadLength() const; - // If there is inactive PeerStat in _peerStats, it is replaced with + // If there is inactive PeerStat in peerStats_, it is replaced with // given peerStat. If no such PeerStat exist, the given peerStat is // inserted. void registerPeerStat(const SharedHandle<PeerStat>& peerStat); const std::vector<SharedHandle<PeerStat> >& getPeerStats() const { - return _peerStats; + return peerStats_; } SharedHandle<PeerStat> getPeerStat(cuid_t cuid) const; // If there is slower PeerStat than given peerStat for the same - // hostname and protocol in _fastestPeerStats, the former is + // hostname and protocol in fastestPeerStats_, the former is // replaced with latter. If there are no PeerStat with same hostname // and protocol with given peerStat, given peerStat is inserted. void updateFastestPeerStat(const SharedHandle<PeerStat>& peerStat); const std::vector<SharedHandle<PeerStat> >& getFastestPeerStats() const { - return _fastestPeerStats; + return fastestPeerStats_; } /** diff --git a/src/SelectEventPoll.cc b/src/SelectEventPoll.cc index 9a61df5c..ced1c046 100644 --- a/src/SelectEventPoll.cc +++ b/src/SelectEventPoll.cc @@ -49,39 +49,39 @@ namespace aria2 { SelectEventPoll::CommandEvent::CommandEvent(Command* command, int events): - _command(command), _events(events) {} + command_(command), events_(events) {} void SelectEventPoll::CommandEvent::processEvents(int events) { - if((_events&events) || + if((events_&events) || ((EventPoll::EVENT_ERROR|EventPoll::EVENT_HUP)&events)) { - _command->setStatusActive(); + command_->setStatusActive(); } if(EventPoll::EVENT_READ&events) { - _command->readEventReceived(); + command_->readEventReceived(); } if(EventPoll::EVENT_WRITE&events) { - _command->writeEventReceived(); + command_->writeEventReceived(); } if(EventPoll::EVENT_ERROR&events) { - _command->errorEventReceived(); + command_->errorEventReceived(); } if(EventPoll::EVENT_HUP&events) { - _command->hupEventReceived(); + command_->hupEventReceived(); } } -SelectEventPoll::SocketEntry::SocketEntry(sock_t socket):_socket(socket) {} +SelectEventPoll::SocketEntry::SocketEntry(sock_t socket):socket_(socket) {} void SelectEventPoll::SocketEntry::addCommandEvent (Command* command, int events) { CommandEvent cev(command, events); - std::deque<CommandEvent>::iterator i = std::find(_commandEvents.begin(), - _commandEvents.end(), + std::deque<CommandEvent>::iterator i = std::find(commandEvents_.begin(), + commandEvents_.end(), cev); - if(i == _commandEvents.end()) { - _commandEvents.push_back(cev); + if(i == commandEvents_.end()) { + commandEvents_.push_back(cev); } else { (*i).addEvents(events); } @@ -90,21 +90,21 @@ void SelectEventPoll::SocketEntry::removeCommandEvent (Command* command, int events) { CommandEvent cev(command, events); - std::deque<CommandEvent>::iterator i = std::find(_commandEvents.begin(), - _commandEvents.end(), + std::deque<CommandEvent>::iterator i = std::find(commandEvents_.begin(), + commandEvents_.end(), cev); - if(i == _commandEvents.end()) { + if(i == commandEvents_.end()) { // not found } else { (*i).removeEvents(events); if((*i).eventsEmpty()) { - _commandEvents.erase(i); + commandEvents_.erase(i); } } } void SelectEventPoll::SocketEntry::processEvents(int events) { - std::for_each(_commandEvents.begin(), _commandEvents.end(), + std::for_each(commandEvents_.begin(), commandEvents_.end(), std::bind2nd(std::mem_fun_ref(&CommandEvent::processEvents), events)); } @@ -117,7 +117,7 @@ int accumulateEvent(int events, const SelectEventPoll::CommandEvent& event) int SelectEventPoll::SocketEntry::getEvents() { return - std::accumulate(_commandEvents.begin(), _commandEvents.end(), 0, + std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0, accumulateEvent); } @@ -125,22 +125,22 @@ int SelectEventPoll::SocketEntry::getEvents() SelectEventPoll::AsyncNameResolverEntry::AsyncNameResolverEntry (const SharedHandle<AsyncNameResolver>& nameResolver, Command* command): - _nameResolver(nameResolver), _command(command) {} + nameResolver_(nameResolver), command_(command) {} int SelectEventPoll::AsyncNameResolverEntry::getFds (fd_set* rfdsPtr, fd_set* wfdsPtr) { - return _nameResolver->getFds(rfdsPtr, wfdsPtr); + return nameResolver_->getFds(rfdsPtr, wfdsPtr); } void SelectEventPoll::AsyncNameResolverEntry::process (fd_set* rfdsPtr, fd_set* wfdsPtr) { - _nameResolver->process(rfdsPtr, wfdsPtr); - switch(_nameResolver->getStatus()) { + nameResolver_->process(rfdsPtr, wfdsPtr); + switch(nameResolver_->getStatus()) { case AsyncNameResolver::STATUS_SUCCESS: case AsyncNameResolver::STATUS_ERROR: - _command->setStatusActive(); + command_->setStatusActive(); break; default: break; @@ -149,11 +149,11 @@ void SelectEventPoll::AsyncNameResolverEntry::process #endif // ENABLE_ASYNC_DNS -SelectEventPoll::SelectEventPoll():_logger(LogFactory::getInstance()) +SelectEventPoll::SelectEventPoll():logger_(LogFactory::getInstance()) { #ifdef __MINGW32__ - _dummySocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - assert(_dummySocket != (sock_t)-1); + dummySocket_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + assert(dummySocket_ != (sock_t)-1); #endif // __MINGW32__ updateFdSet(); } @@ -161,7 +161,7 @@ SelectEventPoll::SelectEventPoll():_logger(LogFactory::getInstance()) SelectEventPoll::~SelectEventPoll() { #ifdef __MINGW32__ - ::closesocket(_dummySocket); + ::closesocket(dummySocket_); #endif // __MINGW32__ } @@ -170,23 +170,23 @@ void SelectEventPoll::poll(const struct timeval& tv) fd_set rfds; fd_set wfds; - memcpy(&rfds, &_rfdset, sizeof(fd_set)); - memcpy(&wfds, &_wfdset, sizeof(fd_set)); + memcpy(&rfds, &rfdset_, sizeof(fd_set)); + memcpy(&wfds, &wfdset_, sizeof(fd_set)); #ifdef __MINGW32__ fd_set efds; FD_ZERO(&efds); - FD_SET(_dummySocket, &efds); + FD_SET(dummySocket_, &efds); #endif // __MINGW32__ #ifdef ENABLE_ASYNC_DNS for(std::deque<SharedHandle<AsyncNameResolverEntry> >::const_iterator itr = - _nameResolverEntries.begin(), eoi = _nameResolverEntries.end(); + nameResolverEntries_.begin(), eoi = nameResolverEntries_.end(); itr != eoi; ++itr) { const SharedHandle<AsyncNameResolverEntry>& entry = *itr; int fd = entry->getFds(&rfds, &wfds); // TODO force error if fd == 0 - if(_fdmax < fd) { - _fdmax = fd; + if(fdmax_ < fd) { + fdmax_ = fd; } } @@ -195,14 +195,14 @@ void SelectEventPoll::poll(const struct timeval& tv) do { struct timeval ttv = tv; #ifdef __MINGW32__ - retval = select(_fdmax+1, &rfds, &wfds, &efds, &ttv); + retval = select(fdmax_+1, &rfds, &wfds, &efds, &ttv); #else // !__MINGW32__ - retval = select(_fdmax+1, &rfds, &wfds, NULL, &ttv); + retval = select(fdmax_+1, &rfds, &wfds, NULL, &ttv); #endif // !__MINGW32__ } while(retval == -1 && errno == EINTR); if(retval > 0) { for(std::deque<SharedHandle<SocketEntry> >::const_iterator i = - _socketEntries.begin(), eoi = _socketEntries.end(); i != eoi; ++i) { + socketEntries_.begin(), eoi = socketEntries_.end(); i != eoi; ++i) { int events = 0; if(FD_ISSET((*i)->getSocket(), &rfds)) { events |= EventPoll::EVENT_READ; @@ -216,7 +216,7 @@ void SelectEventPoll::poll(const struct timeval& tv) #ifdef ENABLE_ASYNC_DNS for(std::deque<SharedHandle<AsyncNameResolverEntry> >::const_iterator i = - _nameResolverEntries.begin(), eoi = _nameResolverEntries.end(); + nameResolverEntries_.begin(), eoi = nameResolverEntries_.end(); i != eoi; ++i) { (*i)->process(&rfds, &wfds); } @@ -237,18 +237,18 @@ static void checkFdCountMingw(const fd_set& fdset, Logger* logger) void SelectEventPoll::updateFdSet() { #ifdef __MINGW32__ - _fdmax = _dummySocket; + fdmax_ = dummySocket_; #else // !__MINGW32__ - _fdmax = 0; + fdmax_ = 0; #endif // !__MINGW32__ - FD_ZERO(&_rfdset); - FD_ZERO(&_wfdset); + FD_ZERO(&rfdset_); + FD_ZERO(&wfdset_); for(std::deque<SharedHandle<SocketEntry> >::const_iterator i = - _socketEntries.begin(), eoi = _socketEntries.end(); i != eoi; ++i) { + socketEntries_.begin(), eoi = socketEntries_.end(); i != eoi; ++i) { sock_t fd = (*i)->getSocket(); #ifndef __MINGW32__ if(fd < 0 || FD_SETSIZE <= fd) { - _logger->warn("Detected file descriptor >= FD_SETSIZE or < 0. " + logger_->warn("Detected file descriptor >= FD_SETSIZE or < 0. " "Download may slow down or fail."); continue; } @@ -256,18 +256,18 @@ void SelectEventPoll::updateFdSet() int events = (*i)->getEvents(); if(events&EventPoll::EVENT_READ) { #ifdef __MINGW32__ - checkFdCountMingw(_rfdset, _logger); + checkFdCountMingw(rfdset_, logger_); #endif // __MINGW32__ - FD_SET(fd, &_rfdset); + FD_SET(fd, &rfdset_); } if(events&EventPoll::EVENT_WRITE) { #ifdef __MINGW32__ - checkFdCountMingw(_wfdset, _logger); + checkFdCountMingw(wfdset_, logger_); #endif // __MINGW32__ - FD_SET(fd, &_wfdset); + FD_SET(fd, &wfdset_); } - if(_fdmax < fd) { - _fdmax = fd; + if(fdmax_ < fd) { + fdmax_ = fd; } } } @@ -277,18 +277,18 @@ bool SelectEventPoll::addEvents(sock_t socket, Command* command, { SharedHandle<SocketEntry> socketEntry(new SocketEntry(socket)); std::deque<SharedHandle<SocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); int r = 0; - if(i != _socketEntries.end() && (*i) == socketEntry) { + if(i != socketEntries_.end() && (*i) == socketEntry) { (*i)->addCommandEvent(command, events); } else { - _socketEntries.insert(i, socketEntry); + socketEntries_.insert(i, socketEntry); socketEntry->addCommandEvent(command, events); } updateFdSet(); if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to add socket event %d:%s", + if(logger_->debug()) { + logger_->debug("Failed to add socket event %d:%s", socket, strerror(errno)); } return false; @@ -302,25 +302,25 @@ bool SelectEventPoll::deleteEvents(sock_t socket, Command* command, { SharedHandle<SocketEntry> socketEntry(new SocketEntry(socket)); std::deque<SharedHandle<SocketEntry> >::iterator i = - std::lower_bound(_socketEntries.begin(), _socketEntries.end(), socketEntry); - if(i != _socketEntries.end() && (*i) == socketEntry) { + std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry); + if(i != socketEntries_.end() && (*i) == socketEntry) { (*i)->removeCommandEvent(command, events); int r = 0; if((*i)->eventEmpty()) { - _socketEntries.erase(i); + socketEntries_.erase(i); } updateFdSet(); if(r == -1) { - if(_logger->debug()) { - _logger->debug("Failed to delete socket event:%s", strerror(errno)); + if(logger_->debug()) { + logger_->debug("Failed to delete socket event:%s", strerror(errno)); } return false; } else { return true; } } else { - if(_logger->debug()) { - _logger->debug("Socket %d is not found in SocketEntries.", socket); + if(logger_->debug()) { + logger_->debug("Socket %d is not found in SocketEntries.", socket); } return false; } @@ -333,9 +333,9 @@ bool SelectEventPoll::addNameResolver SharedHandle<AsyncNameResolverEntry> entry (new AsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<AsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { - _nameResolverEntries.push_back(entry); + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { + nameResolverEntries_.push_back(entry); return true; } else { return false; @@ -348,11 +348,11 @@ bool SelectEventPoll::deleteNameResolver SharedHandle<AsyncNameResolverEntry> entry (new AsyncNameResolverEntry(resolver, command)); std::deque<SharedHandle<AsyncNameResolverEntry> >::iterator itr = - std::find(_nameResolverEntries.begin(), _nameResolverEntries.end(), entry); - if(itr == _nameResolverEntries.end()) { + std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry); + if(itr == nameResolverEntries_.end()) { return false; } else { - _nameResolverEntries.erase(itr); + nameResolverEntries_.erase(itr); return true; } } diff --git a/src/SelectEventPoll.h b/src/SelectEventPoll.h index c55e2602..37f734ab 100644 --- a/src/SelectEventPoll.h +++ b/src/SelectEventPoll.h @@ -51,39 +51,39 @@ class SelectEventPoll : public EventPoll { private: class CommandEvent { private: - Command* _command; - int _events; + Command* command_; + int events_; public: CommandEvent(Command* command, int events); Command* getCommand() const { - return _command; + return command_; } void addEvents(int events) { - _events |= events; + events_ |= events; } void removeEvents(int events) { - _events &= (~events); + events_ &= (~events); } bool eventsEmpty() const { - return _events == 0; + return events_ == 0; } bool operator==(const CommandEvent& commandEvent) const { - return _command == commandEvent._command; + return command_ == commandEvent.command_; } int getEvents() const { - return _events; + return events_; } void processEvents(int events); @@ -94,20 +94,20 @@ private: class SocketEntry { private: - sock_t _socket; + sock_t socket_; - std::deque<CommandEvent> _commandEvents; + std::deque<CommandEvent> commandEvents_; public: SocketEntry(sock_t socket); bool operator==(const SocketEntry& entry) const { - return _socket == entry._socket; + return socket_ == entry.socket_; } bool operator<(const SocketEntry& entry) const { - return _socket < entry._socket; + return socket_ < entry.socket_; } void addCommandEvent(Command* command, int events); @@ -118,12 +118,12 @@ private: sock_t getSocket() const { - return _socket; + return socket_; } bool eventEmpty() const { - return _commandEvents.empty(); + return commandEvents_.empty(); } void processEvents(int events); @@ -133,9 +133,9 @@ private: class AsyncNameResolverEntry { private: - SharedHandle<AsyncNameResolver> _nameResolver; + SharedHandle<AsyncNameResolver> nameResolver_; - Command* _command; + Command* command_; public: AsyncNameResolverEntry(const SharedHandle<AsyncNameResolver>& nameResolver, @@ -143,8 +143,8 @@ private: bool operator==(const AsyncNameResolverEntry& entry) { - return _nameResolver == entry._nameResolver && - _command == entry._command; + return nameResolver_ == entry.nameResolver_ && + command_ == entry.command_; } int getFds(fd_set* rfdsPtr, fd_set* wfdsPtr); @@ -153,22 +153,22 @@ private: }; #endif // ENABLE_ASYNC_DNS - fd_set _rfdset; - fd_set _wfdset; - sock_t _fdmax; + fd_set rfdset_; + fd_set wfdset_; + sock_t fdmax_; - std::deque<SharedHandle<SocketEntry> > _socketEntries; + std::deque<SharedHandle<SocketEntry> > socketEntries_; #ifdef ENABLE_ASYNC_DNS - std::deque<SharedHandle<AsyncNameResolverEntry> > _nameResolverEntries; + std::deque<SharedHandle<AsyncNameResolverEntry> > nameResolverEntries_; #endif // ENABLE_ASYNC_DNS #ifdef __MINGW32__ // Winsock select() doesn't work if no socket is in FD_SET. We add // this dummy socket to work around this problem - sock_t _dummySocket; + sock_t dummySocket_; #endif // __MINGW32__ - Logger* _logger; + Logger* logger_; void updateFdSet(); public: diff --git a/src/Sequence.h b/src/Sequence.h index cd685170..17e0d8b5 100644 --- a/src/Sequence.h +++ b/src/Sequence.h @@ -43,50 +43,50 @@ template<typename T> class Sequence { public: - // Generates value in [_first, _last). _last is not included. + // Generates value in [first_, last_). last_ is not included. class Value { private: - T _first; - T _last; + T first_; + T last_; public: - Value(const T& first, const T& last):_first(first), _last(last) {} + Value(const T& first, const T& last):first_(first), last_(last) {} T next() { - return _first++; + return first_++; } bool hasNext() const { - return _first != _last; + return first_ != last_; } }; typedef std::vector<Value> Values; private: - Values _values; - typename Values::iterator _cur; + Values values_; + typename Values::iterator cur_; public: Sequence(const Values& values): - _values(values), _cur(_values.begin()) {} + values_(values), cur_(values_.begin()) {} Sequence() {} T next() { - if(_cur == _values.end()) { + if(cur_ == values_.end()) { return T(); } - T t = (*_cur).next(); - if(!(*_cur).hasNext()) { - ++_cur; + T t = (*cur_).next(); + if(!(*cur_).hasNext()) { + ++cur_; } return t; } bool hasNext() { - return _cur != _values.end(); + return cur_ != values_.end(); } std::vector<T> flush() diff --git a/src/SequentialDispatcherCommand.h b/src/SequentialDispatcherCommand.h index 08c76ced..611a9069 100644 --- a/src/SequentialDispatcherCommand.h +++ b/src/SequentialDispatcherCommand.h @@ -48,35 +48,35 @@ class DownloadEngine; template<typename T> class SequentialDispatcherCommand : public Command { private: - SharedHandle<SequentialPicker<T> > _picker; + SharedHandle<SequentialPicker<T> > picker_; - DownloadEngine* _e; + DownloadEngine* e_; protected: DownloadEngine* getDownloadEngine() const { - return _e; + return e_; } public: SequentialDispatcherCommand(cuid_t cuid, const SharedHandle<SequentialPicker<T> >& picker, DownloadEngine* e): - Command(cuid), _picker(picker), _e(e) + Command(cuid), picker_(picker), e_(e) { setStatusRealtime(); } virtual bool execute() { - if(_e->getRequestGroupMan()->downloadFinished() || _e->isHaltRequested()) { + if(e_->getRequestGroupMan()->downloadFinished() || e_->isHaltRequested()) { return true; } - if(_picker->hasNext() && !_picker->isPicked()) { - _e->addCommand(createCommand(_picker->pickNext())); + if(picker_->hasNext() && !picker_->isPicked()) { + e_->addCommand(createCommand(picker_->pickNext())); - _e->setNoWait(true); + e_->setNoWait(true); } - _e->addRoutineCommand(this); + e_->addRoutineCommand(this); return false; } diff --git a/src/SequentialPicker.h b/src/SequentialPicker.h index 1e0779a2..5f02f0e0 100644 --- a/src/SequentialPicker.h +++ b/src/SequentialPicker.h @@ -46,48 +46,48 @@ namespace aria2 { template<typename T> class SequentialPicker { private: - std::deque<SharedHandle<T> > _entries; - SharedHandle<T> _pickedEntry; + std::deque<SharedHandle<T> > entries_; + SharedHandle<T> pickedEntry_; public: bool isPicked() const { - return !_pickedEntry.isNull(); + return !pickedEntry_.isNull(); } SharedHandle<T> getPickedEntry() const { - return _pickedEntry; + return pickedEntry_; } void dropPickedEntry() { - _pickedEntry.reset(); + pickedEntry_.reset(); } bool hasNext() const { - return !_entries.empty(); + return !entries_.empty(); } SharedHandle<T> pickNext() { SharedHandle<T> r; if(hasNext()) { - r = _entries.front(); - _entries.pop_front(); - _pickedEntry = r; + r = entries_.front(); + entries_.pop_front(); + pickedEntry_ = r; } return r; } void pushEntry(const SharedHandle<T>& entry) { - _entries.push_back(entry); + entries_.push_back(entry); } size_t countEntryInQueue() const { - return _entries.size(); + return entries_.size(); } }; diff --git a/src/ServerStat.cc b/src/ServerStat.cc index 2103ed7f..a73771b8 100644 --- a/src/ServerStat.cc +++ b/src/ServerStat.cc @@ -49,119 +49,119 @@ const std::string ServerStat::STATUS_STRING[] = { ServerStat::ServerStat(const std::string& hostname, const std::string& protocol) : - _hostname(hostname), - _protocol(protocol), - _downloadSpeed(0), - _singleConnectionAvgSpeed(0), - _multiConnectionAvgSpeed(0), - _counter(0), - _logger(LogFactory::getInstance()), - _status(OK) + hostname_(hostname), + protocol_(protocol), + downloadSpeed_(0), + singleConnectionAvgSpeed_(0), + multiConnectionAvgSpeed_(0), + counter_(0), + logger_(LogFactory::getInstance()), + status_(OK) {} ServerStat::~ServerStat() {} void ServerStat::setLastUpdated(const Time& time) { - _lastUpdated = time; + lastUpdated_ = time; } void ServerStat::setDownloadSpeed(unsigned int downloadSpeed) { - _downloadSpeed = downloadSpeed; + downloadSpeed_ = downloadSpeed; } void ServerStat::updateDownloadSpeed(unsigned int downloadSpeed) { - _downloadSpeed = downloadSpeed; + downloadSpeed_ = downloadSpeed; if(downloadSpeed > 0) { - _status = OK; + status_ = OK; } - _lastUpdated.reset(); + lastUpdated_.reset(); } void ServerStat::setSingleConnectionAvgSpeed (unsigned int singleConnectionAvgSpeed) { - _singleConnectionAvgSpeed = singleConnectionAvgSpeed; + singleConnectionAvgSpeed_ = singleConnectionAvgSpeed; } void ServerStat::updateSingleConnectionAvgSpeed(unsigned int downloadSpeed) { float avgDownloadSpeed; - if(_counter == 0) + if(counter_ == 0) return; - if(_counter < 5) { + if(counter_ < 5) { avgDownloadSpeed = - ((((float)_counter-1)/(float)_counter)*(float)_singleConnectionAvgSpeed)+ - ((1.0/(float)_counter)*(float)downloadSpeed); + ((((float)counter_-1)/(float)counter_)*(float)singleConnectionAvgSpeed_)+ + ((1.0/(float)counter_)*(float)downloadSpeed); } else { - avgDownloadSpeed = ((4.0/5.0)*(float)_singleConnectionAvgSpeed) + + avgDownloadSpeed = ((4.0/5.0)*(float)singleConnectionAvgSpeed_) + ((1.0/5.0)*(float)downloadSpeed); } - if(avgDownloadSpeed < (int)(0.80*_singleConnectionAvgSpeed)) { - if(_logger->debug()) { - _logger->debug("ServerStat:%s: resetting counter since single connection" + if(avgDownloadSpeed < (int)(0.80*singleConnectionAvgSpeed_)) { + if(logger_->debug()) { + logger_->debug("ServerStat:%s: resetting counter since single connection" " speed dropped", getHostname().c_str()); } - _counter = 0; + counter_ = 0; } - if(_logger->debug()) { - _logger->debug("ServerStat:%s: _singleConnectionAvgSpeed old:%.2fKB/s" + if(logger_->debug()) { + logger_->debug("ServerStat:%s: singleConnectionAvgSpeed_ old:%.2fKB/s" " new:%.2fKB/s last:%.2fKB/s", getHostname().c_str(), - (float) _singleConnectionAvgSpeed/1024, + (float) singleConnectionAvgSpeed_/1024, (float) avgDownloadSpeed/1024, (float) downloadSpeed / 1024); } - _singleConnectionAvgSpeed = (int)avgDownloadSpeed; + singleConnectionAvgSpeed_ = (int)avgDownloadSpeed; } void ServerStat::setMultiConnectionAvgSpeed (unsigned int multiConnectionAvgSpeed) { - _multiConnectionAvgSpeed = multiConnectionAvgSpeed; + multiConnectionAvgSpeed_ = multiConnectionAvgSpeed; } void ServerStat::updateMultiConnectionAvgSpeed(unsigned int downloadSpeed) { float avgDownloadSpeed; - if(_counter == 0) + if(counter_ == 0) return; - if(_counter < 5) { + if(counter_ < 5) { avgDownloadSpeed = - ((((float)_counter-1)/(float)_counter)*(float)_multiConnectionAvgSpeed) + - ((1.0/(float)_counter)*(float)downloadSpeed); + ((((float)counter_-1)/(float)counter_)*(float)multiConnectionAvgSpeed_) + + ((1.0/(float)counter_)*(float)downloadSpeed); } else { - avgDownloadSpeed = ((4.0/5.0)*(float)_multiConnectionAvgSpeed) + + avgDownloadSpeed = ((4.0/5.0)*(float)multiConnectionAvgSpeed_) + ((1.0/5.0)*(float)downloadSpeed); } - if(_logger->debug()) { - _logger->debug("ServerStat:%s: _multiConnectionAvgSpeed old:%.2fKB/s" + if(logger_->debug()) { + logger_->debug("ServerStat:%s: multiConnectionAvgSpeed_ old:%.2fKB/s" " new:%.2fKB/s last:%.2fKB/s", getHostname().c_str(), - (float) _multiConnectionAvgSpeed/1024, + (float) multiConnectionAvgSpeed_/1024, (float) avgDownloadSpeed/1024, (float) downloadSpeed / 1024); } - _multiConnectionAvgSpeed = (int)avgDownloadSpeed; + multiConnectionAvgSpeed_ = (int)avgDownloadSpeed; } void ServerStat::increaseCounter() { - ++_counter; + ++counter_; } void ServerStat::setCounter(unsigned int value) { - _counter = value; + counter_ = value; } void ServerStat::setStatus(STATUS status) { - _status = status; + status_ = status; } void ServerStat::setStatus(const std::string& status) @@ -169,20 +169,20 @@ void ServerStat::setStatus(const std::string& status) const std::string* p = std::find(vbegin(STATUS_STRING), vend(STATUS_STRING), status); if(p != vend(STATUS_STRING)) { - _status = static_cast<STATUS>(ServerStat::OK+ + status_ = static_cast<STATUS>(ServerStat::OK+ std::distance(vbegin(STATUS_STRING), p)); } } void ServerStat::setStatusInternal(STATUS status) { - if(_logger->debug()) { - _logger->debug("ServerStat: set status %s for %s (%s)", + if(logger_->debug()) { + logger_->debug("ServerStat: set status %s for %s (%s)", STATUS_STRING[status].c_str(), - _hostname.c_str(), _protocol.c_str()); + hostname_.c_str(), protocol_.c_str()); } - _status = status; - _lastUpdated.reset(); + status_ = status; + lastUpdated_.reset(); } void ServerStat::setOK() @@ -197,9 +197,9 @@ void ServerStat::setError() bool ServerStat::operator<(const ServerStat& serverStat) const { - int c = _hostname.compare(serverStat._hostname); + int c = hostname_.compare(serverStat.hostname_); if(c == 0) { - return _protocol < serverStat._protocol; + return protocol_ < serverStat.protocol_; } else { return c < 0; } @@ -207,7 +207,7 @@ bool ServerStat::operator<(const ServerStat& serverStat) const bool ServerStat::operator==(const ServerStat& serverStat) const { - return _hostname == serverStat._hostname && _protocol == serverStat._protocol; + return hostname_ == serverStat.hostname_ && protocol_ == serverStat.protocol_; } std::ostream& operator<<(std::ostream& o, const ServerStat& serverStat) diff --git a/src/ServerStat.h b/src/ServerStat.h index 696d04e0..ea469845 100644 --- a/src/ServerStat.h +++ b/src/ServerStat.h @@ -64,17 +64,17 @@ public: const std::string& getHostname() const { - return _hostname; + return hostname_; } const std::string& getProtocol() const { - return _protocol; + return protocol_; } const Time& getLastUpdated() const { - return _lastUpdated; + return lastUpdated_; } // This method doesn't update _lastUpdate. @@ -82,10 +82,10 @@ public: unsigned int getDownloadSpeed() const { - return _downloadSpeed; + return downloadSpeed_; } - // update download speed and update _lastUpdated + // update download speed and update lastUpdated_ void updateDownloadSpeed(unsigned int downloadSpeed); // set download speed. This method doesn't update _lastUpdate. @@ -93,7 +93,7 @@ public: unsigned int getSingleConnectionAvgSpeed() const { - return _singleConnectionAvgSpeed; + return singleConnectionAvgSpeed_; } void updateSingleConnectionAvgSpeed(unsigned int downloadSpeed); @@ -101,7 +101,7 @@ public: unsigned int getMultiConnectionAvgSpeed() const { - return _multiConnectionAvgSpeed; + return multiConnectionAvgSpeed_; } void updateMultiConnectionAvgSpeed(unsigned int downloadSpeed); @@ -109,7 +109,7 @@ public: unsigned int getCounter() const { - return _counter; + return counter_; } void increaseCounter(); @@ -125,46 +125,46 @@ public: STATUS getStatus() const { - return _status; + return status_; } bool isOK() const { - return _status == OK; + return status_ == OK; } - // set status OK and update _lastUpdated + // set status OK and update lastUpdated_ void setOK(); bool isError() const { - return _status == ERROR; + return status_ == ERROR; } - // set status ERROR and update _lastUpdated + // set status ERROR and update lastUpdated_ void setError(); bool operator<(const ServerStat& serverStat) const; bool operator==(const ServerStat& serverStat) const; private: - std::string _hostname; + std::string hostname_; - std::string _protocol; + std::string protocol_; - unsigned int _downloadSpeed; + unsigned int downloadSpeed_; - unsigned int _singleConnectionAvgSpeed; + unsigned int singleConnectionAvgSpeed_; - unsigned int _multiConnectionAvgSpeed; + unsigned int multiConnectionAvgSpeed_; - unsigned int _counter; + unsigned int counter_; - Logger* _logger; + Logger* logger_; - STATUS _status; + STATUS status_; - Time _lastUpdated; + Time lastUpdated_; void setStatusInternal(STATUS status); }; diff --git a/src/ServerStatMan.cc b/src/ServerStatMan.cc index ca27eb58..51e1e3b5 100644 --- a/src/ServerStatMan.cc +++ b/src/ServerStatMan.cc @@ -55,8 +55,8 @@ SharedHandle<ServerStat> ServerStatMan::find(const std::string& hostname, { SharedHandle<ServerStat> ss(new ServerStat(hostname, protocol)); std::deque<SharedHandle<ServerStat> >::const_iterator i = - std::lower_bound(_serverStats.begin(), _serverStats.end(), ss); - if(i != _serverStats.end() && + std::lower_bound(serverStats_.begin(), serverStats_.end(), ss); + if(i != serverStats_.end() && (*i)->getHostname() == hostname && (*i)->getProtocol() == protocol) { return *i; } else { @@ -67,19 +67,19 @@ SharedHandle<ServerStat> ServerStatMan::find(const std::string& hostname, bool ServerStatMan::add(const SharedHandle<ServerStat>& serverStat) { std::deque<SharedHandle<ServerStat> >::iterator i = - std::lower_bound(_serverStats.begin(), _serverStats.end(), serverStat); + std::lower_bound(serverStats_.begin(), serverStats_.end(), serverStat); - if(i != _serverStats.end() && (*i) == serverStat) { + if(i != serverStats_.end() && (*i) == serverStat) { return false; } else { - _serverStats.insert(i, serverStat); + serverStats_.insert(i, serverStat); return true; } } bool ServerStatMan::save(std::ostream& out) const { - std::copy(_serverStats.begin(), _serverStats.end(), + std::copy(serverStats_.begin(), serverStats_.end(), std::ostream_iterator<SharedHandle<ServerStat> >(out, "\n")); out.flush(); return !out.bad(); @@ -142,22 +142,22 @@ bool ServerStatMan::load(std::istream& in) class FindStaleServerStat { private: - time_t _timeout; - Time _time; + time_t timeout_; + Time time_; public: - FindStaleServerStat(time_t timeout):_timeout(timeout) {} + FindStaleServerStat(time_t timeout):timeout_(timeout) {} bool operator()(const SharedHandle<ServerStat>& ss) const { - return ss->getLastUpdated().difference(_time) >= _timeout; + return ss->getLastUpdated().difference(time_) >= timeout_; } }; void ServerStatMan::removeStaleServerStat(time_t timeout) { - _serverStats.erase(std::remove_if(_serverStats.begin(), _serverStats.end(), + serverStats_.erase(std::remove_if(serverStats_.begin(), serverStats_.end(), FindStaleServerStat(timeout)), - _serverStats.end()); + serverStats_.end()); } } // namespace aria2 diff --git a/src/ServerStatMan.h b/src/ServerStatMan.h index 4eb1fe06..d1c33c95 100644 --- a/src/ServerStatMan.h +++ b/src/ServerStatMan.h @@ -64,7 +64,7 @@ public: void removeStaleServerStat(time_t timeout); private: - std::deque<SharedHandle<ServerStat> > _serverStats; + std::deque<SharedHandle<ServerStat> > serverStats_; }; } // namespace aria2 diff --git a/src/SessionSerializer.cc b/src/SessionSerializer.cc index 5e1a1c9d..4310aa67 100644 --- a/src/SessionSerializer.cc +++ b/src/SessionSerializer.cc @@ -54,10 +54,10 @@ namespace aria2 { SessionSerializer::SessionSerializer (const SharedHandle<RequestGroupMan>& requestGroupMan): - _rgman(requestGroupMan), - _saveError(true), - _saveInProgress(true), - _saveWaiting(true) {} + rgman_(requestGroupMan), + saveError_(true), + saveInProgress_(true), + saveWaiting_(true) {} bool SessionSerializer::save(const std::string& filename) const { @@ -161,25 +161,25 @@ void SessionSerializer::save(std::ostream& out) const { std::set<int64_t> metainfoCache; const std::deque<SharedHandle<DownloadResult> >& results = - _rgman->getDownloadResults(); + rgman_->getDownloadResults(); for(std::deque<SharedHandle<DownloadResult> >::const_iterator itr = results.begin(), eoi = results.end(); itr != eoi; ++itr) { if((*itr)->result == downloadresultcode::FINISHED) { continue; } else if((*itr)->result == downloadresultcode::IN_PROGRESS) { - if(_saveInProgress) { + if(saveInProgress_) { writeDownloadResult(out, metainfoCache, *itr); } } else { // error download - if(_saveError) { + if(saveError_) { writeDownloadResult(out, metainfoCache, *itr); } } } - if(_saveInProgress) { + if(saveInProgress_) { const std::deque<SharedHandle<RequestGroup> >& groups = - _rgman->getRequestGroups(); + rgman_->getRequestGroups(); for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = groups.begin(), eoi = groups.end(); itr != eoi; ++itr) { SharedHandle<DownloadResult> result = (*itr)->createDownloadResult(); @@ -189,9 +189,9 @@ void SessionSerializer::save(std::ostream& out) const writeDownloadResult(out, metainfoCache, result); } } - if(_saveWaiting) { + if(saveWaiting_) { const std::deque<SharedHandle<RequestGroup> >& groups = - _rgman->getReservedGroups(); + rgman_->getReservedGroups(); for(std::deque<SharedHandle<RequestGroup> >::const_iterator itr = groups.begin(), eoi = groups.end(); itr != eoi; ++itr) { SharedHandle<DownloadResult> result = (*itr)->createDownloadResult(); diff --git a/src/SessionSerializer.h b/src/SessionSerializer.h index 53ca392b..49498997 100644 --- a/src/SessionSerializer.h +++ b/src/SessionSerializer.h @@ -48,10 +48,10 @@ class RequestGroupMan; class SessionSerializer { private: - SharedHandle<RequestGroupMan> _rgman; - bool _saveError; - bool _saveInProgress; - bool _saveWaiting; + SharedHandle<RequestGroupMan> rgman_; + bool saveError_; + bool saveInProgress_; + bool saveWaiting_; public: SessionSerializer(const SharedHandle<RequestGroupMan>& requestGroupMan); diff --git a/src/ShareRatioSeedCriteria.h b/src/ShareRatioSeedCriteria.h index 461c75c8..0d95d465 100644 --- a/src/ShareRatioSeedCriteria.h +++ b/src/ShareRatioSeedCriteria.h @@ -45,27 +45,27 @@ namespace aria2 { class ShareRatioSeedCriteria : public SeedCriteria { private: double ratio; - SharedHandle<DownloadContext> _downloadContext; - SharedHandle<PeerStorage> _peerStorage; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<DownloadContext> downloadContext_; + SharedHandle<PeerStorage> peerStorage_; + SharedHandle<PieceStorage> pieceStorage_; public: ShareRatioSeedCriteria (double ratio, const SharedHandle<DownloadContext>& downloadContext) :ratio(ratio), - _downloadContext(downloadContext) {} + downloadContext_(downloadContext) {} virtual ~ShareRatioSeedCriteria() {} virtual void reset() {} virtual bool evaluate() { - if(_downloadContext->getTotalLength() == 0) { + if(downloadContext_->getTotalLength() == 0) { return false; } - TransferStat stat = _peerStorage->calculateStat(); + TransferStat stat = peerStorage_->calculateStat(); return ratio <= (double)stat.getAllTimeUploadLength()/ - _pieceStorage->getCompletedLength(); + pieceStorage_->getCompletedLength(); } void setRatio(double ratio) { @@ -78,12 +78,12 @@ public: void setPeerStorage(const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } }; diff --git a/src/SharedHandle.h b/src/SharedHandle.h index c2ebb450..1e5c29cb 100644 --- a/src/SharedHandle.h +++ b/src/SharedHandle.h @@ -44,34 +44,34 @@ typedef struct WeakRef {} WeakRef; class RefCount { private: - size_t _strongRefCount; - size_t _weakRefCount; + size_t strongRefCount_; + size_t weakRefCount_; public: - RefCount():_strongRefCount(1), _weakRefCount(1) {} + RefCount():strongRefCount_(1), weakRefCount_(1) {} - RefCount(const WeakRef&):_strongRefCount(0), _weakRefCount(1) {} + RefCount(const WeakRef&):strongRefCount_(0), weakRefCount_(1) {} inline void addRefCount() { - ++_strongRefCount; - ++_weakRefCount; + ++strongRefCount_; + ++weakRefCount_; } inline void addWeakRefCount() { - ++_weakRefCount; + ++weakRefCount_; } inline void releaseRefCount() { - --_strongRefCount; - --_weakRefCount; + --strongRefCount_; + --weakRefCount_; } inline void releaseWeakRefCount() { - --_weakRefCount; + --weakRefCount_; } - inline size_t getStrongRefCount() { return _strongRefCount; } + inline size_t getStrongRefCount() { return strongRefCount_; } - inline size_t getWeakRefCount() { return _weakRefCount; } + inline size_t getWeakRefCount() { return weakRefCount_; } }; class WeakCount; @@ -80,89 +80,89 @@ class SharedCount { private: friend class WeakCount; - RefCount* _refCount; + RefCount* refCount_; public: - SharedCount():_refCount(new RefCount()) {} + SharedCount():refCount_(new RefCount()) {} - SharedCount(const SharedCount& s):_refCount(s._refCount) + SharedCount(const SharedCount& s):refCount_(s.refCount_) { - _refCount->addRefCount(); + refCount_->addRefCount(); } ~SharedCount() { - _refCount->releaseRefCount(); - if(_refCount->getWeakRefCount() == 0) { - delete _refCount; + refCount_->releaseRefCount(); + if(refCount_->getWeakRefCount() == 0) { + delete refCount_; } } bool reassign(const SharedCount& s) { - s._refCount->addRefCount(); - _refCount->releaseRefCount(); - if(_refCount->getWeakRefCount() == 0) { - delete _refCount; - _refCount = s._refCount; + s.refCount_->addRefCount(); + refCount_->releaseRefCount(); + if(refCount_->getWeakRefCount() == 0) { + delete refCount_; + refCount_ = s.refCount_; return true; } - size_t thisCount = _refCount->getStrongRefCount(); - _refCount = s._refCount; + size_t thisCount = refCount_->getStrongRefCount(); + refCount_ = s.refCount_; return thisCount == 0; } - inline size_t getRefCount() const { return _refCount->getStrongRefCount(); } + inline size_t getRefCount() const { return refCount_->getStrongRefCount(); } }; class WeakCount { private: - RefCount* _refCount; + RefCount* refCount_; public: - WeakCount(const WeakRef& t):_refCount(new RefCount(t)) {} + WeakCount(const WeakRef& t):refCount_(new RefCount(t)) {} - WeakCount(const StrongRef& t):_refCount(new RefCount()) {} + WeakCount(const StrongRef& t):refCount_(new RefCount()) {} - WeakCount(const WeakCount& w):_refCount(w._refCount) + WeakCount(const WeakCount& w):refCount_(w.refCount_) { - _refCount->addWeakRefCount(); + refCount_->addWeakRefCount(); } - WeakCount(const SharedCount& s):_refCount(s._refCount) + WeakCount(const SharedCount& s):refCount_(s.refCount_) { - _refCount->addWeakRefCount(); + refCount_->addWeakRefCount(); } ~WeakCount() { - _refCount->releaseWeakRefCount(); - if(_refCount->getWeakRefCount() == 0) { - delete _refCount; + refCount_->releaseWeakRefCount(); + if(refCount_->getWeakRefCount() == 0) { + delete refCount_; } } bool reassign(const SharedCount& s) { - s._refCount->addWeakRefCount(); - _refCount->releaseWeakRefCount(); - if(_refCount->getWeakRefCount() == 0) { - delete _refCount; - _refCount = s._refCount; + s.refCount_->addWeakRefCount(); + refCount_->releaseWeakRefCount(); + if(refCount_->getWeakRefCount() == 0) { + delete refCount_; + refCount_ = s.refCount_; return true; } - _refCount = s._refCount; + refCount_ = s.refCount_; return false; } bool reassign(const WeakCount& s) { - s._refCount->addWeakRefCount(); - _refCount->releaseWeakRefCount(); - if(_refCount->getWeakRefCount() == 0) { - delete _refCount; - _refCount = s._refCount; + s.refCount_->addWeakRefCount(); + refCount_->releaseWeakRefCount(); + if(refCount_->getWeakRefCount() == 0) { + delete refCount_; + refCount_ = s.refCount_; return true; } - _refCount = s._refCount; + refCount_ = s.refCount_; return false; } - inline size_t getRefCount() const { return _refCount->getStrongRefCount(); } + inline size_t getRefCount() const { return refCount_->getStrongRefCount(); } }; @@ -193,55 +193,55 @@ private: template<typename S> friend class WeakHandle; - T* _obj; + T* obj_; - SharedCount _ucount; + SharedCount ucount_; public: - SharedHandle():_obj(0), _ucount() {} + SharedHandle():obj_(0), ucount_() {} - explicit SharedHandle(T* obj):_obj(obj), _ucount() {} + explicit SharedHandle(T* obj):obj_(obj), ucount_() {} - SharedHandle(const SharedHandle& t):_obj(t._obj), _ucount(t._ucount) {} + SharedHandle(const SharedHandle& t):obj_(t.obj_), ucount_(t.ucount_) {} template<typename S> - SharedHandle(const SharedHandle<S>& t):_obj(t._obj), _ucount(t._ucount) {} + SharedHandle(const SharedHandle<S>& t):obj_(t.obj_), ucount_(t.ucount_) {} template<typename S> SharedHandle(const SharedHandle<S>& t, T* p): - _obj(p), _ucount(t._ucount) {} + obj_(p), ucount_(t.ucount_) {} ~SharedHandle() { - if(_ucount.getRefCount() == 1) { - delete _obj; + if(ucount_.getRefCount() == 1) { + delete obj_; } } SharedHandle& operator=(const SharedHandle& t) { - if(_ucount.reassign(t._ucount)) { - delete _obj; + if(ucount_.reassign(t.ucount_)) { + delete obj_; } - _obj = t._obj; + obj_ = t.obj_; return *this; } template<typename S> SharedHandle& operator=(const SharedHandle<S>& t) { - if(_ucount.reassign(t._ucount)) { - delete _obj; + if(ucount_.reassign(t.ucount_)) { + delete obj_; } - _obj = t._obj; + obj_ = t.obj_; return *this; } - T* operator->() const { return _obj; } + T* operator->() const { return obj_; } T* get() const { - return _obj; + return obj_; } size_t getRefCount() const { - return _ucount.getRefCount(); + return ucount_.getRefCount(); } void reset() { @@ -253,7 +253,7 @@ public: } bool isNull() const { - return _obj == 0; + return obj_ == 0; } }; @@ -275,23 +275,23 @@ static_pointer_cast(const SharedHandle<S>& t) { template<typename T> std::ostream& operator<<(std::ostream& o, const SharedHandle<T>& sp) { - o << *sp._obj; + o << *sp.obj_; return o; } template<typename T1, typename T2> bool operator==(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) { - return *t1._obj == *t2._obj; + return *t1.obj_ == *t2.obj_; } template<typename T1, typename T2> bool operator!=(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) { - return *t1._obj != *t2._obj; + return *t1.obj_ != *t2.obj_; } template<typename T1, typename T2> bool operator<(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) { - return *t1._obj < *t2._obj; + return *t1.obj_ < *t2.obj_; } template<typename T> @@ -313,60 +313,60 @@ private: template<typename S> friend class WeakHandle; - T* _obj; + T* obj_; - WeakCount _ucount; + WeakCount ucount_; public: - WeakHandle():_obj(0), _ucount(WeakRef()) {} + WeakHandle():obj_(0), ucount_(WeakRef()) {} - explicit WeakHandle(T* obj):_obj(obj), _ucount(StrongRef()) {} + explicit WeakHandle(T* obj):obj_(obj), ucount_(StrongRef()) {} - WeakHandle(const WeakHandle& t):_obj(t._obj), _ucount(t._ucount) {} + WeakHandle(const WeakHandle& t):obj_(t.obj_), ucount_(t.ucount_) {} template<typename S> - WeakHandle(const SharedHandle<S>& t):_obj(t._obj), _ucount(t._ucount) {} + WeakHandle(const SharedHandle<S>& t):obj_(t.obj_), ucount_(t.ucount_) {} template<typename S> WeakHandle(const WeakHandle<S>& t, T* p): - _obj(p), _ucount(t._ucount) {} + obj_(p), ucount_(t.ucount_) {} ~WeakHandle() {} WeakHandle& operator=(const WeakHandle& t) { - _ucount.reassign(t._ucount); - _obj = t._obj; + ucount_.reassign(t.ucount_); + obj_ = t.obj_; return *this; } template<typename S> WeakHandle& operator=(const SharedHandle<S>& t) { - _ucount.reassign(t._ucount); - _obj = t._obj; + ucount_.reassign(t.ucount_); + obj_ = t.obj_; return *this; } template<typename S> WeakHandle& operator=(const WeakHandle<S>& t) { - _ucount.reassign(t._ucount); - _obj = t._obj; + ucount_.reassign(t.ucount_); + obj_ = t.obj_; return *this; } - T* operator->() { return _obj; } + T* operator->() { return obj_; } - T* operator->() const { return _obj; } + T* operator->() const { return obj_; } T* get() const { if(isNull()) { return 0; } else { - return _obj; + return obj_; } } size_t getRefCount() const { - return _ucount.getRefCount(); + return ucount_.getRefCount(); } void reset() { @@ -374,29 +374,29 @@ public: } bool isNull() const { - return _ucount.getRefCount() == 0 || _obj == 0; + return ucount_.getRefCount() == 0 || obj_ == 0; } }; template<typename T> std::ostream& operator<<(std::ostream& o, const WeakHandle<T>& sp) { - o << *sp._obj; + o << *sp.obj_; return o; } template<typename T1, typename T2> bool operator==(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) { - return *t1._obj == *t2._obj; + return *t1.obj_ == *t2.obj_; } template<typename T1, typename T2> bool operator!=(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) { - return *t1._obj != *t2._obj; + return *t1.obj_ != *t2.obj_; } template<typename T1, typename T2> bool operator<(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) { - return *t1._obj < *t2._obj; + return *t1.obj_ < *t2.obj_; } template<typename T, typename S> diff --git a/src/Signature.cc b/src/Signature.cc index 82f718ed..f8cd695f 100644 --- a/src/Signature.cc +++ b/src/Signature.cc @@ -47,22 +47,22 @@ Signature::~Signature() {} void Signature::setType(const std::string& type) { - _type = type; + type_ = type; } void Signature::setFile(const std::string& file) { - _file = file; + file_ = file; } void Signature::setBody(const std::string& body) { - _body = body; + body_ = body; } bool Signature::save(const std::string& filepath) const { - return util::saveAs(filepath, _body); + return util::saveAs(filepath, body_); } } // namespace aria2 diff --git a/src/Signature.h b/src/Signature.h index 184d743f..4b85b4a0 100644 --- a/src/Signature.h +++ b/src/Signature.h @@ -45,11 +45,11 @@ namespace aria2 { class Signature { private: - std::string _type; + std::string type_; - std::string _file; + std::string file_; - std::string _body; + std::string body_; public: Signature(); @@ -59,21 +59,21 @@ public: const std::string& getType() const { - return _type; + return type_; } void setFile(const std::string& file); const std::string& getFile() const { - return _file; + return file_; } void setBody(const std::string& body); const std::string& getBody() const { - return _body; + return body_; } bool save(const std::string& filepath) const; diff --git a/src/SimpleRandomizer.cc b/src/SimpleRandomizer.cc index 2f7d8504..86fbbb81 100644 --- a/src/SimpleRandomizer.cc +++ b/src/SimpleRandomizer.cc @@ -40,14 +40,14 @@ namespace aria2 { -SharedHandle<SimpleRandomizer> SimpleRandomizer::_randomizer; +SharedHandle<SimpleRandomizer> SimpleRandomizer::randomizer_; const SharedHandle<SimpleRandomizer>& SimpleRandomizer::getInstance() { - if(_randomizer.isNull()) { - _randomizer.reset(new SimpleRandomizer()); + if(randomizer_.isNull()) { + randomizer_.reset(new SimpleRandomizer()); } - return _randomizer; + return randomizer_; } void SimpleRandomizer::init() diff --git a/src/SimpleRandomizer.h b/src/SimpleRandomizer.h index cbecaf6a..c2a10c10 100644 --- a/src/SimpleRandomizer.h +++ b/src/SimpleRandomizer.h @@ -41,7 +41,7 @@ namespace aria2 { class SimpleRandomizer : public Randomizer { private: - static SharedHandle<SimpleRandomizer> _randomizer; + static SharedHandle<SimpleRandomizer> randomizer_; SimpleRandomizer(); public: diff --git a/src/SingleFileAllocationIterator.cc b/src/SingleFileAllocationIterator.cc index 5dc463db..b67ce9cd 100644 --- a/src/SingleFileAllocationIterator.cc +++ b/src/SingleFileAllocationIterator.cc @@ -44,47 +44,47 @@ namespace aria2 { #define BUFSIZE (256*1024) #define ALIGNMENT 512 -SingleFileAllocationIterator::SingleFileAllocationIterator(BinaryStream* stream, off_t offset, uint64_t totalLength):_stream(stream), _offset(offset), _totalLength(totalLength), _buffer(0) +SingleFileAllocationIterator::SingleFileAllocationIterator(BinaryStream* stream, off_t offset, uint64_t totalLength):stream_(stream), offset_(offset), totalLength_(totalLength), buffer_(0) { - if(_offset%ALIGNMENT != 0) { - _stream->disableDirectIO(); + if(offset_%ALIGNMENT != 0) { + stream_->disableDirectIO(); } } SingleFileAllocationIterator::~SingleFileAllocationIterator() { #ifdef HAVE_POSIX_MEMALIGN - free(_buffer); + free(buffer_); #else - delete [] _buffer; + delete [] buffer_; #endif // HAVE_POSIX_MEMALIGN } void SingleFileAllocationIterator::init() { #ifdef HAVE_POSIX_MEMALIGN - _buffer = reinterpret_cast<unsigned char*> + buffer_ = reinterpret_cast<unsigned char*> (util::allocateAlignedMemory(ALIGNMENT, BUFSIZE)); #else - _buffer = new unsigned char[BUFSIZE]; + buffer_ = new unsigned char[BUFSIZE]; #endif // HAVE_POSIX_MEMALIGN - memset(_buffer, 0, BUFSIZE); + memset(buffer_, 0, BUFSIZE); } void SingleFileAllocationIterator::allocateChunk() { - _stream->writeData(_buffer, BUFSIZE, _offset); - _offset += BUFSIZE; + stream_->writeData(buffer_, BUFSIZE, offset_); + offset_ += BUFSIZE; - if(_totalLength < (uint64_t)_offset) { - _stream->truncate(_totalLength); - _offset = _totalLength; + if(totalLength_ < (uint64_t)offset_) { + stream_->truncate(totalLength_); + offset_ = totalLength_; } } bool SingleFileAllocationIterator::finished() { - return (uint64_t)_offset >= _totalLength; + return (uint64_t)offset_ >= totalLength_; } } // namespace aria2 diff --git a/src/SingleFileAllocationIterator.h b/src/SingleFileAllocationIterator.h index 5347c3e4..308180d3 100644 --- a/src/SingleFileAllocationIterator.h +++ b/src/SingleFileAllocationIterator.h @@ -44,13 +44,13 @@ class BinaryStream; class SingleFileAllocationIterator:public FileAllocationIterator { private: - BinaryStream* _stream; + BinaryStream* stream_; - off_t _offset; + off_t offset_; - uint64_t _totalLength; + uint64_t totalLength_; - unsigned char* _buffer; + unsigned char* buffer_; public: SingleFileAllocationIterator(BinaryStream* stream, off_t offset, uint64_t totalLength); @@ -62,12 +62,12 @@ public: virtual off_t getCurrentLength() { - return _offset; + return offset_; } virtual uint64_t getTotalLength() { - return _totalLength; + return totalLength_; } /** diff --git a/src/SingletonHolder.h b/src/SingletonHolder.h index 18edb279..7963125f 100644 --- a/src/SingletonHolder.h +++ b/src/SingletonHolder.h @@ -40,7 +40,7 @@ namespace aria2 { template<typename T> class SingletonHolder { private: - static T _instance; + static T instance_; SingletonHolder() {} public: @@ -48,17 +48,17 @@ public: static T& instance() { - return _instance; + return instance_; } static void instance(T& instance) { - _instance = instance; + instance_ = instance; } }; template<typename T> -T SingletonHolder<T>::_instance; +T SingletonHolder<T>::instance_; } // namespace aria2 diff --git a/src/SleepCommand.cc b/src/SleepCommand.cc index c8fd2868..d705a7c2 100644 --- a/src/SleepCommand.cc +++ b/src/SleepCommand.cc @@ -47,22 +47,22 @@ namespace aria2 { SleepCommand::SleepCommand(cuid_t cuid, DownloadEngine* e, RequestGroup* requestGroup, Command* nextCommand, time_t wait): - Command(cuid), _engine(e), _requestGroup(requestGroup), - _nextCommand(nextCommand), _wait(wait), _checkPoint(global::wallclock) {} + Command(cuid), engine_(e), requestGroup_(requestGroup), + nextCommand_(nextCommand), wait_(wait), checkPoint_(global::wallclock) {} SleepCommand::~SleepCommand() { - delete _nextCommand; + delete nextCommand_; } bool SleepCommand::execute() { - if(_requestGroup->downloadFinished() || _requestGroup->isHaltRequested()) { + if(requestGroup_->downloadFinished() || requestGroup_->isHaltRequested()) { return true; - } else if(_checkPoint.difference(global::wallclock) >= _wait) { - _engine->addCommand(_nextCommand); - _nextCommand = 0; + } else if(checkPoint_.difference(global::wallclock) >= wait_) { + engine_->addCommand(nextCommand_); + nextCommand_ = 0; return true; } else { - _engine->addCommand(this); + engine_->addCommand(this); return false; } } diff --git a/src/SleepCommand.h b/src/SleepCommand.h index cf03dc42..b437971e 100644 --- a/src/SleepCommand.h +++ b/src/SleepCommand.h @@ -45,11 +45,11 @@ class RequestGroup; class SleepCommand:public Command { private: - DownloadEngine* _engine; - RequestGroup* _requestGroup; - Command* _nextCommand; - time_t _wait; - Timer _checkPoint; + DownloadEngine* engine_; + RequestGroup* requestGroup_; + Command* nextCommand_; + time_t wait_; + Timer checkPoint_; public: SleepCommand(cuid_t cuid, DownloadEngine* e, RequestGroup* requestGroup, Command* nextCommand, time_t wait); diff --git a/src/SocketBuffer.cc b/src/SocketBuffer.cc index dd061f7e..28024a96 100644 --- a/src/SocketBuffer.cc +++ b/src/SocketBuffer.cc @@ -45,52 +45,52 @@ namespace aria2 { SocketBuffer::SocketBuffer(const SharedHandle<SocketCore>& socket): - _socket(socket), _offset(0) {} + socket_(socket), offset_(0) {} SocketBuffer::~SocketBuffer() { - std::for_each(_bufq.begin(), _bufq.end(), + std::for_each(bufq_.begin(), bufq_.end(), std::mem_fun_ref(&BufEntry::deleteBuf)); } void SocketBuffer::pushBytes(unsigned char* bytes, size_t len) { - _bufq.push_back(BufEntry(bytes, len)); + bufq_.push_back(BufEntry(bytes, len)); } void SocketBuffer::pushStr(const std::string& data) { - _bufq.push_back(BufEntry(data)); + bufq_.push_back(BufEntry(data)); } ssize_t SocketBuffer::send() { size_t totalslen = 0; - while(!_bufq.empty()) { - BufEntry& buf = _bufq[0]; + while(!bufq_.empty()) { + BufEntry& buf = bufq_[0]; const char* data; ssize_t r; if(buf.type == TYPE_BYTES) { data = reinterpret_cast<const char*>(buf.bytes); - r = buf.bytesLen-_offset; + r = buf.bytesLen-offset_; } else { const std::string& str = *buf.str; data = str.data(); - r = str.size()-_offset; + r = str.size()-offset_; } - ssize_t slen = _socket->writeData(data+_offset, r); - if(slen == 0 && !_socket->wantRead() && !_socket->wantWrite()) { + ssize_t slen = socket_->writeData(data+offset_, r); + if(slen == 0 && !socket_->wantRead() && !socket_->wantWrite()) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_SEND, "Connection closed.").str()); } totalslen += slen; if(slen < r) { - _offset += slen; + offset_ += slen; break; } else { - _offset = 0; + offset_ = 0; buf.deleteBuf(); - _bufq.pop_front(); + bufq_.pop_front(); } } return totalslen; @@ -98,7 +98,7 @@ ssize_t SocketBuffer::send() bool SocketBuffer::sendBufferIsEmpty() const { - return _bufq.empty(); + return bufq_.empty(); } } // namespace aria2 diff --git a/src/SocketBuffer.h b/src/SocketBuffer.h index 51462c8e..68f5ab77 100644 --- a/src/SocketBuffer.h +++ b/src/SocketBuffer.h @@ -74,14 +74,14 @@ private: type(TYPE_STR), str(new std::string(str)) {} }; - SharedHandle<SocketCore> _socket; + SharedHandle<SocketCore> socket_; - std::deque<BufEntry> _bufq; + std::deque<BufEntry> bufq_; - // Offset of data in _bufq[0]. SocketBuffer tries to send _bufq[0], + // Offset of data in bufq_[0]. SocketBuffer tries to send bufq_[0], // but it cannot always send whole data. In this case, offset points // to the data to be sent in the next send() call. - size_t _offset; + size_t offset_; public: SocketBuffer(const SharedHandle<SocketCore>& socket); diff --git a/src/SocketCore.cc b/src/SocketCore.cc index 29a0301c..cb6602f8 100644 --- a/src/SocketCore.cc +++ b/src/SocketCore.cc @@ -118,52 +118,52 @@ static const char *errorMsg() return errorMsg(SOCKET_ERRNO); } -int SocketCore::_protocolFamily = AF_UNSPEC; +int SocketCore::protocolFamily_ = AF_UNSPEC; std::vector<std::pair<struct sockaddr_storage, socklen_t> > -SocketCore::_bindAddrs; +SocketCore::bindAddrs_; #ifdef ENABLE_SSL -SharedHandle<TLSContext> SocketCore::_tlsContext; +SharedHandle<TLSContext> SocketCore::tlsContext_; void SocketCore::setTLSContext(const SharedHandle<TLSContext>& tlsContext) { - _tlsContext = tlsContext; + tlsContext_ = tlsContext; } #endif // ENABLE_SSL -SocketCore::SocketCore(int sockType):_sockType(sockType), _sockfd(-1) { +SocketCore::SocketCore(int sockType):sockType_(sockType), sockfd_(-1) { init(); } -SocketCore::SocketCore(sock_t sockfd, int sockType):_sockType(sockType), _sockfd(sockfd) { +SocketCore::SocketCore(sock_t sockfd, int sockType):sockType_(sockType), sockfd_(sockfd) { init(); } void SocketCore::init() { - _blocking = true; - _secure = 0; + blocking_ = true; + secure_ = 0; - _wantRead = false; - _wantWrite = false; + wantRead_ = false; + wantWrite_ = false; #ifdef HAVE_LIBSSL // for SSL ssl = NULL; #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS - _sslSession = 0; - _peekBufMax = 4096; - _peekBuf = 0; - _peekBufLength = 0; + sslSession_ = 0; + peekBufMax_ = 4096; + peekBuf_ = 0; + peekBufLength_ = 0; #endif //HAVE_LIBGNUTLS } SocketCore::~SocketCore() { closeConnection(); #ifdef HAVE_LIBGNUTLS - delete [] _peekBuf; + delete [] peekBuf_; #endif // HAVE_LIBGNUTLS } @@ -186,7 +186,7 @@ std::string uitos(T value) void SocketCore::create(int family, int protocol) { closeConnection(); - sock_t fd = socket(family, _sockType, protocol); + sock_t fd = socket(family, sockType_, protocol); if(fd == (sock_t) -1) { throw DL_ABORT_EX (StringFormat("Failed to create socket. Cause:%s", errorMsg()).str()); @@ -198,7 +198,7 @@ void SocketCore::create(int family, int protocol) throw DL_ABORT_EX (StringFormat("Failed to create socket. Cause:%s", errorMsg()).str()); } - _sockfd = fd; + sockfd_ = fd; } static sock_t bindInternal(int family, int socktype, int protocol, @@ -250,11 +250,11 @@ void SocketCore::bindWithFamily(uint16_t port, int family, int flags) { closeConnection(); std::string error; - sock_t fd = bindTo(0, port, family, _sockType, flags, error); + sock_t fd = bindTo(0, port, family, sockType_, flags, error); if(fd == (sock_t) -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str()); } else { - _sockfd = fd; + sockfd_ = fd; } } @@ -263,11 +263,11 @@ void SocketCore::bind(const std::string& addr, uint16_t port, int flags) closeConnection(); std::string error; sock_t fd = - bindTo(addr.c_str(), port, _protocolFamily, _sockType, flags, error); + bindTo(addr.c_str(), port, protocolFamily_, sockType_, flags, error); if(fd == (sock_t)-1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str()); } else { - _sockfd = fd; + sockfd_ = fd; } } @@ -275,14 +275,14 @@ void SocketCore::bind(uint16_t port, int flags) { closeConnection(); std::string error; - if(!(flags&AI_PASSIVE) || _bindAddrs.empty()) { - sock_t fd = bindTo(0, port, _protocolFamily, _sockType, flags, error); + if(!(flags&AI_PASSIVE) || bindAddrs_.empty()) { + sock_t fd = bindTo(0, port, protocolFamily_, sockType_, flags, error); if(fd != (sock_t) -1) { - _sockfd = fd; + sockfd_ = fd; } } else { for(std::vector<std::pair<struct sockaddr_storage, socklen_t> >:: - const_iterator i = _bindAddrs.begin(), eoi = _bindAddrs.end(); + const_iterator i = bindAddrs_.begin(), eoi = bindAddrs_.end(); i != eoi; ++i) { char host[NI_MAXHOST]; int s; @@ -294,14 +294,14 @@ void SocketCore::bind(uint16_t port, int flags) error = gai_strerror(s); continue; } - sock_t fd = bindTo(host, port, _protocolFamily, _sockType, flags, error); + sock_t fd = bindTo(host, port, protocolFamily_, sockType_, flags, error); if(fd != (sock_t)-1) { - _sockfd = fd; + sockfd_ = fd; break; } } } - if(_sockfd == (sock_t) -1) { + if(sockfd_ == (sock_t) -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str()); } } @@ -310,9 +310,9 @@ void SocketCore::bind(const struct sockaddr* addr, socklen_t addrlen) { closeConnection(); std::string error; - sock_t fd = bindInternal(addr->sa_family, _sockType, 0, addr, addrlen, error); + sock_t fd = bindInternal(addr->sa_family, sockType_, 0, addr, addrlen, error); if(fd != (sock_t)-1) { - _sockfd = fd; + sockfd_ = fd; } else { throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str()); } @@ -320,7 +320,7 @@ void SocketCore::bind(const struct sockaddr* addr, socklen_t addrlen) void SocketCore::beginListen() { - if(listen(_sockfd, 1) == -1) { + if(listen(sockfd_, 1) == -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_LISTEN, errorMsg()).str()); } } @@ -330,11 +330,11 @@ SocketCore* SocketCore::acceptConnection() const struct sockaddr_storage sockaddr; socklen_t len = sizeof(sockaddr); sock_t fd; - while((fd = accept(_sockfd, reinterpret_cast<struct sockaddr*>(&sockaddr), &len)) == (sock_t) -1 && SOCKET_ERRNO == A2_EINTR); + while((fd = accept(sockfd_, reinterpret_cast<struct sockaddr*>(&sockaddr), &len)) == (sock_t) -1 && SOCKET_ERRNO == A2_EINTR); if(fd == (sock_t) -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_ACCEPT, errorMsg()).str()); } - return new SocketCore(fd, _sockType); + return new SocketCore(fd, sockType_); } void SocketCore::getAddrInfo(std::pair<std::string, uint16_t>& addrinfo) const @@ -342,7 +342,7 @@ void SocketCore::getAddrInfo(std::pair<std::string, uint16_t>& addrinfo) const struct sockaddr_storage sockaddr; socklen_t len = sizeof(sockaddr); struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr); - if(getsockname(_sockfd, addrp, &len) == -1) { + if(getsockname(sockfd_, addrp, &len) == -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str()); } addrinfo = util::getNumericNameInfo(addrp, len); @@ -353,7 +353,7 @@ void SocketCore::getPeerInfo(std::pair<std::string, uint16_t>& peerinfo) const struct sockaddr_storage sockaddr; socklen_t len = sizeof(sockaddr); struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr); - if(getpeername(_sockfd, addrp, &len) == -1) { + if(getpeername(sockfd_, addrp, &len) == -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str()); } peerinfo = util::getNumericNameInfo(addrp, len); @@ -365,8 +365,8 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port) std::string error; struct addrinfo* res; int s; - s = callGetaddrinfo(&res, host.c_str(), uitos(port).c_str(), _protocolFamily, - _sockType, 0, 0); + s = callGetaddrinfo(&res, host.c_str(), uitos(port).c_str(), protocolFamily_, + sockType_, 0, 0); if(s) { throw DL_ABORT_EX(StringFormat(EX_RESOLVE_HOSTNAME, host.c_str(), gai_strerror(s)).str()); @@ -385,10 +385,10 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port) CLOSE(fd); continue; } - if(!_bindAddrs.empty()) { + if(!bindAddrs_.empty()) { bool bindSuccess = false; for(std::vector<std::pair<struct sockaddr_storage, socklen_t> >:: - const_iterator i = _bindAddrs.begin(), eoi = _bindAddrs.end(); + const_iterator i = bindAddrs_.begin(), eoi = bindAddrs_.end(); i != eoi; ++i) { if(::bind(fd,reinterpret_cast<const struct sockaddr*>(&(*i).first), (*i).second) == -1) { @@ -407,21 +407,21 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port) } } - _sockfd = fd; + sockfd_ = fd; // make socket non-blocking mode setNonBlockingMode(); if(connect(fd, rp->ai_addr, rp->ai_addrlen) == -1 && SOCKET_ERRNO != A2_EINPROGRESS) { error = errorMsg(); - CLOSE(_sockfd); - _sockfd = (sock_t) -1; + CLOSE(sockfd_); + sockfd_ = (sock_t) -1; continue; } // TODO at this point, connection may not be established and it may fail // later. In such case, next ai_addr should be tried. break; } - if(_sockfd == (sock_t) -1) { + if(sockfd_ == (sock_t) -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_CONNECT, host.c_str(), error.c_str()).str()); } @@ -430,7 +430,7 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port) void SocketCore::setSockOpt (int level, int optname, void* optval, socklen_t optlen) { - if(setsockopt(_sockfd, level, optname, (a2_sockopt_t)optval, optlen) < 0) { + if(setsockopt(sockfd_, level, optname, (a2_sockopt_t)optval, optlen) < 0) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_SET_OPT, errorMsg()).str()); } } @@ -488,60 +488,60 @@ void SocketCore::setNonBlockingMode() { #ifdef __MINGW32__ static u_long flag = 1; - if (::ioctlsocket(_sockfd, FIONBIO, &flag) == -1) { + if (::ioctlsocket(sockfd_, FIONBIO, &flag) == -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_NONBLOCKING, errorMsg()).str()); } #else int flags; - while((flags = fcntl(_sockfd, F_GETFL, 0)) == -1 && errno == EINTR); + while((flags = fcntl(sockfd_, F_GETFL, 0)) == -1 && errno == EINTR); // TODO add error handling - while(fcntl(_sockfd, F_SETFL, flags|O_NONBLOCK) == -1 && errno == EINTR); + while(fcntl(sockfd_, F_SETFL, flags|O_NONBLOCK) == -1 && errno == EINTR); #endif // __MINGW32__ - _blocking = false; + blocking_ = false; } void SocketCore::setBlockingMode() { #ifdef __MINGW32__ static u_long flag = 0; - if (::ioctlsocket(_sockfd, FIONBIO, &flag) == -1) { + if (::ioctlsocket(sockfd_, FIONBIO, &flag) == -1) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_BLOCKING, errorMsg()).str()); } #else int flags; - while((flags = fcntl(_sockfd, F_GETFL, 0)) == -1 && errno == EINTR); + while((flags = fcntl(sockfd_, F_GETFL, 0)) == -1 && errno == EINTR); // TODO add error handling - while(fcntl(_sockfd, F_SETFL, flags&(~O_NONBLOCK)) == -1 && errno == EINTR); + while(fcntl(sockfd_, F_SETFL, flags&(~O_NONBLOCK)) == -1 && errno == EINTR); #endif // __MINGW32__ - _blocking = true; + blocking_ = true; } void SocketCore::closeConnection() { #ifdef HAVE_LIBSSL // for SSL - if(_secure) { + if(secure_) { SSL_shutdown(ssl); } #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS - if(_secure) { - gnutls_bye(_sslSession, GNUTLS_SHUT_RDWR); + if(secure_) { + gnutls_bye(sslSession_, GNUTLS_SHUT_RDWR); } #endif // HAVE_LIBGNUTLS - if(_sockfd != (sock_t) -1) { - CLOSE(_sockfd); - _sockfd = -1; + if(sockfd_ != (sock_t) -1) { + CLOSE(sockfd_); + sockfd_ = -1; } #ifdef HAVE_LIBSSL // for SSL - if(_secure) { + if(secure_) { SSL_free(ssl); } #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS - if(_secure) { - gnutls_deinit(_sslSession); + if(secure_) { + gnutls_deinit(sslSession_); } #endif // HAVE_LIBGNUTLS } @@ -549,7 +549,7 @@ void SocketCore::closeConnection() #ifndef __MINGW32__ # define CHECK_FD(fd) \ if(fd < 0 || FD_SETSIZE <= fd) { \ - _logger->warn("Detected file descriptor >= FD_SETSIZE or < 0. " \ + logger_->warn("Detected file descriptor >= FD_SETSIZE or < 0. " \ "Download may slow down or fail."); \ return false; \ } @@ -559,7 +559,7 @@ bool SocketCore::isWritable(time_t timeout) { #ifdef HAVE_POLL struct pollfd p; - p.fd = _sockfd; + p.fd = sockfd_; p.events = POLLOUT; int r; while((r = poll(&p, 1, timeout*1000)) == -1 && errno == EINTR); @@ -573,17 +573,17 @@ bool SocketCore::isWritable(time_t timeout) } #else // !HAVE_POLL # ifndef __MINGW32__ - CHECK_FD(_sockfd); + CHECK_FD(sockfd_); # endif // !__MINGW32__ fd_set fds; FD_ZERO(&fds); - FD_SET(_sockfd, &fds); + FD_SET(sockfd_, &fds); struct timeval tv; tv.tv_sec = timeout; tv.tv_usec = 0; - int r = select(_sockfd+1, NULL, &fds, NULL, &tv); + int r = select(sockfd_+1, NULL, &fds, NULL, &tv); if(r == 1) { return true; } else if(r == 0) { @@ -603,13 +603,13 @@ bool SocketCore::isWritable(time_t timeout) bool SocketCore::isReadable(time_t timeout) { #ifdef HAVE_LIBGNUTLS - if(_secure && _peekBufLength > 0) { + if(secure_ && peekBufLength_ > 0) { return true; } #endif // HAVE_LIBGNUTLS #ifdef HAVE_POLL struct pollfd p; - p.fd = _sockfd; + p.fd = sockfd_; p.events = POLLIN; int r; while((r = poll(&p, 1, timeout*1000)) == -1 && errno == EINTR); @@ -623,17 +623,17 @@ bool SocketCore::isReadable(time_t timeout) } #else // !HAVE_POLL # ifndef __MINGW32__ - CHECK_FD(_sockfd); + CHECK_FD(sockfd_); # endif // !__MINGW32__ fd_set fds; FD_ZERO(&fds); - FD_SET(_sockfd, &fds); + FD_SET(sockfd_, &fds); struct timeval tv; tv.tv_sec = timeout; tv.tv_usec = 0; - int r = select(_sockfd+1, &fds, NULL, NULL, &tv); + int r = select(sockfd_+1, &fds, NULL, NULL, &tv); if(r == 1) { return true; } else if(r == 0) { @@ -657,9 +657,9 @@ int SocketCore::sslHandleEAGAIN(int ret) if(error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE) { ret = 0; if(error == SSL_ERROR_WANT_READ) { - _wantRead = true; + wantRead_ = true; } else { - _wantWrite = true; + wantWrite_ = true; } } return ret; @@ -669,11 +669,11 @@ int SocketCore::sslHandleEAGAIN(int ret) #ifdef HAVE_LIBGNUTLS void SocketCore::gnutlsRecordCheckDirection() { - int direction = gnutls_record_get_direction(_sslSession); + int direction = gnutls_record_get_direction(sslSession_); if(direction == 0) { - _wantRead = true; + wantRead_ = true; } else { // if(direction == 1) { - _wantWrite = true; + wantWrite_ = true; } } #endif // HAVE_LIBGNUTLS @@ -681,14 +681,14 @@ void SocketCore::gnutlsRecordCheckDirection() ssize_t SocketCore::writeData(const char* data, size_t len) { ssize_t ret = 0; - _wantRead = false; - _wantWrite = false; + wantRead_ = false; + wantWrite_ = false; - if(!_secure) { - while((ret = send(_sockfd, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR); + if(!secure_) { + while((ret = send(sockfd_, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR); if(ret == -1) { if(A2_WOULDBLOCK(SOCKET_ERRNO)) { - _wantWrite = true; + wantWrite_ = true; ret = 0; } else { throw DL_RETRY_EX(StringFormat(EX_SOCKET_SEND, errorMsg()).str()); @@ -707,7 +707,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len) } #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS - while((ret = gnutls_record_send(_sslSession, data, len)) == + while((ret = gnutls_record_send(sslSession_, data, len)) == GNUTLS_E_INTERRUPTED); if(ret == GNUTLS_E_AGAIN) { gnutlsRecordCheckDirection(); @@ -724,15 +724,15 @@ ssize_t SocketCore::writeData(const char* data, size_t len) void SocketCore::readData(char* data, size_t& len) { ssize_t ret = 0; - _wantRead = false; - _wantWrite = false; + wantRead_ = false; + wantWrite_ = false; - if(!_secure) { - while((ret = recv(_sockfd, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR); + if(!secure_) { + while((ret = recv(sockfd_, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR); if(ret == -1) { if(A2_WOULDBLOCK(SOCKET_ERRNO)) { - _wantRead = true; + wantRead_ = true; ret = 0; } else { throw DL_RETRY_EX(StringFormat(EX_SOCKET_RECV, errorMsg()).str()); @@ -770,15 +770,15 @@ void SocketCore::readData(char* data, size_t& len) void SocketCore::peekData(char* data, size_t& len) { ssize_t ret = 0; - _wantRead = false; - _wantWrite = false; + wantRead_ = false; + wantWrite_ = false; - if(!_secure) { - while((ret = recv(_sockfd, data, len, MSG_PEEK)) == -1 && + if(!secure_) { + while((ret = recv(sockfd_, data, len, MSG_PEEK)) == -1 && SOCKET_ERRNO == A2_EINTR); if(ret == -1) { if(A2_WOULDBLOCK(SOCKET_ERRNO)) { - _wantRead = true; + wantRead_ = true; ret = 0; } else { throw DL_RETRY_EX(StringFormat(EX_SOCKET_PEEK, errorMsg()).str()); @@ -816,15 +816,15 @@ void SocketCore::peekData(char* data, size_t& len) #ifdef HAVE_LIBGNUTLS size_t SocketCore::shiftPeekData(char* data, size_t len) { - if(_peekBufLength <= len) { - memcpy(data, _peekBuf, _peekBufLength); - size_t ret = _peekBufLength; - _peekBufLength = 0; + if(peekBufLength_ <= len) { + memcpy(data, peekBuf_, peekBufLength_); + size_t ret = peekBufLength_; + peekBufLength_ = 0; return ret; } else { - memcpy(data, _peekBuf, len); - _peekBufLength -= len; - memmove(_peekBuf, _peekBuf+len, _peekBufLength); + memcpy(data, peekBuf_, len); + peekBufLength_ -= len; + memmove(peekBuf_, peekBuf_+len, peekBufLength_); return len; } @@ -832,15 +832,15 @@ size_t SocketCore::shiftPeekData(char* data, size_t len) void SocketCore::addPeekData(char* data, size_t len) { - if(_peekBufLength+len > _peekBufMax) { - char* temp = new char[_peekBufMax+len]; - memcpy(temp, _peekBuf, _peekBufLength); - delete [] _peekBuf; - _peekBuf = temp; - _peekBufMax = _peekBufLength+len; + if(peekBufLength_+len > peekBufMax_) { + char* temp = new char[peekBufMax_+len]; + memcpy(temp, peekBuf_, peekBufLength_); + delete [] peekBuf_; + peekBuf_ = temp; + peekBufMax_ = peekBufLength_+len; } - memcpy(_peekBuf+_peekBufLength, data, len); - _peekBufLength += len; + memcpy(peekBuf_+peekBufLength_, data, len); + peekBufLength_ += len; } static ssize_t GNUTLS_RECORD_RECV_NO_INTERRUPT @@ -861,7 +861,7 @@ ssize_t SocketCore::gnutlsRecv(char* data, size_t len) size_t plen = shiftPeekData(data, len); if(plen < len) { ssize_t ret = GNUTLS_RECORD_RECV_NO_INTERRUPT - (_sslSession, data+plen, len-plen); + (sslSession_, data+plen, len-plen); if(ret == GNUTLS_E_AGAIN) { return GNUTLS_E_AGAIN; } @@ -873,34 +873,34 @@ ssize_t SocketCore::gnutlsRecv(char* data, size_t len) ssize_t SocketCore::gnutlsPeek(char* data, size_t len) { - if(_peekBufLength >= len) { - memcpy(data, _peekBuf, len); + if(peekBufLength_ >= len) { + memcpy(data, peekBuf_, len); return len; } else { - memcpy(data, _peekBuf, _peekBufLength); + memcpy(data, peekBuf_, peekBufLength_); ssize_t ret = GNUTLS_RECORD_RECV_NO_INTERRUPT - (_sslSession, data+_peekBufLength, len-_peekBufLength); + (sslSession_, data+peekBufLength_, len-peekBufLength_); if(ret == GNUTLS_E_AGAIN) { return GNUTLS_E_AGAIN; } - addPeekData(data+_peekBufLength, ret); - return _peekBufLength; + addPeekData(data+peekBufLength_, ret); + return peekBufLength_; } } #endif // HAVE_LIBGNUTLS void SocketCore::prepareSecureConnection() { - if(!_secure) { + if(!secure_) { #ifdef HAVE_LIBSSL // for SSL - ssl = SSL_new(_tlsContext->getSSLCtx()); + ssl = SSL_new(tlsContext_->getSSLCtx()); if(!ssl) { throw DL_ABORT_EX (StringFormat(EX_SSL_INIT_FAILURE, ERR_error_string(ERR_get_error(), 0)).str()); } - if(SSL_set_fd(ssl, _sockfd) == 0) { + if(SSL_set_fd(ssl, sockfd_) == 0) { throw DL_ABORT_EX (StringFormat(EX_SSL_INIT_FAILURE, ERR_error_string(ERR_get_error(), 0)).str()); @@ -908,31 +908,31 @@ void SocketCore::prepareSecureConnection() #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS int r; - gnutls_init(&_sslSession, GNUTLS_CLIENT); + gnutls_init(&sslSession_, GNUTLS_CLIENT); // It seems err is not error message, but the argument string // which causes syntax error. const char* err; // Disables TLS1.1 here because there are servers that don't // understand TLS1.1. - r = gnutls_priority_set_direct(_sslSession, "NORMAL:!VERS-TLS1.1", &err); + r = gnutls_priority_set_direct(sslSession_, "NORMAL:!VERS-TLS1.1", &err); if(r != GNUTLS_E_SUCCESS) { throw DL_ABORT_EX (StringFormat(EX_SSL_INIT_FAILURE, gnutls_strerror(r)).str()); } // put the x509 credentials to the current session - gnutls_credentials_set(_sslSession, GNUTLS_CRD_CERTIFICATE, - _tlsContext->getCertCred()); - gnutls_transport_set_ptr(_sslSession, (gnutls_transport_ptr_t)_sockfd); + gnutls_credentials_set(sslSession_, GNUTLS_CRD_CERTIFICATE, + tlsContext_->getCertCred()); + gnutls_transport_set_ptr(sslSession_, (gnutls_transport_ptr_t)sockfd_); #endif // HAVE_LIBGNUTLS - _secure = 1; + secure_ = 1; } } bool SocketCore::initiateSecureConnection(const std::string& hostname) { - if(_secure == 1) { - _wantRead = false; - _wantWrite = false; + if(secure_ == 1) { + wantRead_ = false; + wantWrite_ = false; #ifdef HAVE_LIBSSL int e = SSL_connect(ssl); @@ -943,14 +943,14 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) break; case SSL_ERROR_WANT_READ: - _wantRead = true; + wantRead_ = true; return false; case SSL_ERROR_WANT_WRITE: - _wantWrite = true; + wantWrite_ = true; return false; case SSL_ERROR_WANT_X509_LOOKUP: case SSL_ERROR_ZERO_RETURN: - if (_blocking) { + if (blocking_) { throw DL_ABORT_EX (StringFormat(EX_SSL_CONNECT_ERROR, ssl_error).str()); } @@ -967,7 +967,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) (StringFormat(EX_SSL_UNKNOWN_ERROR, ssl_error).str()); } } - if(_tlsContext->peerVerificationEnabled()) { + if(tlsContext_->peerVerificationEnabled()) { // verify peer X509* peerCert = SSL_get_peer_certificate(ssl); if(!peerCert) { @@ -1012,7 +1012,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) } #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS - int ret = gnutls_handshake(_sslSession); + int ret = gnutls_handshake(sslSession_); if(ret == GNUTLS_E_AGAIN) { gnutlsRecordCheckDirection(); return false; @@ -1021,10 +1021,10 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) (StringFormat(EX_SSL_INIT_FAILURE, gnutls_strerror(ret)).str()); } - if(_tlsContext->peerVerificationEnabled()) { + if(tlsContext_->peerVerificationEnabled()) { // verify peer unsigned int status; - ret = gnutls_certificate_verify_peers2(_sslSession, &status); + ret = gnutls_certificate_verify_peers2(sslSession_, &status); if(ret < 0) { throw DL_ABORT_EX (StringFormat("gnutls_certificate_verify_peer2() failed. Cause: %s", @@ -1047,13 +1047,13 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) } } // certificate type: only X509 is allowed. - if(gnutls_certificate_type_get(_sslSession) != GNUTLS_CRT_X509) { + if(gnutls_certificate_type_get(sslSession_) != GNUTLS_CRT_X509) { throw DL_ABORT_EX("Certificate type is not X509."); } unsigned int peerCertsLength; const gnutls_datum_t* peerCerts = gnutls_certificate_get_peers - (_sslSession, &peerCertsLength); + (sslSession_, &peerCertsLength); if(!peerCerts) { throw DL_ABORT_EX(MSG_NO_CERT_FOUND); } @@ -1095,9 +1095,9 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) } } } - _peekBuf = new char[_peekBufMax]; + peekBuf_ = new char[peekBufMax_]; #endif // HAVE_LIBGNUTLS - _secure = 2; + secure_ = 2; return true; } else { return true; @@ -1107,13 +1107,13 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname) ssize_t SocketCore::writeData(const char* data, size_t len, const std::string& host, uint16_t port) { - _wantRead = false; - _wantWrite = false; + wantRead_ = false; + wantWrite_ = false; struct addrinfo* res; int s; - s = callGetaddrinfo(&res, host.c_str(), uitos(port).c_str(), _protocolFamily, - _sockType, 0, 0); + s = callGetaddrinfo(&res, host.c_str(), uitos(port).c_str(), protocolFamily_, + sockType_, 0, 0); if(s) { throw DL_ABORT_EX(StringFormat(EX_SOCKET_SEND, gai_strerror(s)).str()); } @@ -1121,13 +1121,13 @@ ssize_t SocketCore::writeData(const char* data, size_t len, struct addrinfo* rp; ssize_t r = -1; for(rp = res; rp; rp = rp->ai_next) { - while((r = sendto(_sockfd, data, len, 0, rp->ai_addr, rp->ai_addrlen)) == -1 + while((r = sendto(sockfd_, data, len, 0, rp->ai_addr, rp->ai_addrlen)) == -1 && A2_EINTR == SOCKET_ERRNO); if(r == static_cast<ssize_t>(len)) { break; } if(r == -1 && A2_WOULDBLOCK(SOCKET_ERRNO)) { - _wantWrite = true; + wantWrite_ = true; r = 0; break; } @@ -1142,17 +1142,17 @@ ssize_t SocketCore::readDataFrom(char* data, size_t len, std::pair<std::string /* numerichost */, uint16_t /* port */>& sender) { - _wantRead = false; - _wantWrite = false; + wantRead_ = false; + wantWrite_ = false; struct sockaddr_storage sockaddr; socklen_t sockaddrlen = sizeof(struct sockaddr_storage); struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr); ssize_t r; - while((r = recvfrom(_sockfd, data, len, 0, addrp, &sockaddrlen)) == -1 && + while((r = recvfrom(sockfd_, data, len, 0, addrp, &sockaddrlen)) == -1 && A2_EINTR == SOCKET_ERRNO); if(r == -1) { if(A2_WOULDBLOCK(SOCKET_ERRNO)) { - _wantRead = true; + wantRead_ = true; r = 0; } else { throw DL_RETRY_EX(StringFormat(EX_SOCKET_RECV, errorMsg()).str()); @@ -1169,7 +1169,7 @@ std::string SocketCore::getSocketError() const int error; socklen_t optlen = sizeof(error); - if(getsockopt(_sockfd, SOL_SOCKET, SO_ERROR, (a2_sockopt_t) &error, &optlen) == -1) { + if(getsockopt(sockfd_, SOL_SOCKET, SO_ERROR, (a2_sockopt_t) &error, &optlen) == -1) { throw DL_ABORT_EX(StringFormat("Failed to get socket error: %s", errorMsg()).str()); } @@ -1182,26 +1182,26 @@ std::string SocketCore::getSocketError() const bool SocketCore::wantRead() const { - return _wantRead; + return wantRead_; } bool SocketCore::wantWrite() const { - return _wantWrite; + return wantWrite_; } void SocketCore::bindAddress(const std::string& iface) { std::vector<std::pair<struct sockaddr_storage, socklen_t> > bindAddrs; - getInterfaceAddress(bindAddrs, iface, _protocolFamily); + getInterfaceAddress(bindAddrs, iface, protocolFamily_); if(bindAddrs.empty()) { throw DL_ABORT_EX (StringFormat(MSG_INTERFACE_NOT_FOUND, iface.c_str(), "not available").str()); } else { - _bindAddrs = bindAddrs; + bindAddrs_ = bindAddrs; for(std::vector<std::pair<struct sockaddr_storage, socklen_t> >:: - const_iterator i = _bindAddrs.begin(), eoi = _bindAddrs.end(); + const_iterator i = bindAddrs_.begin(), eoi = bindAddrs_.end(); i != eoi; ++i) { char host[NI_MAXHOST]; int s; diff --git a/src/SocketCore.h b/src/SocketCore.h index f0df6ec2..67585bc3 100644 --- a/src/SocketCore.h +++ b/src/SocketCore.h @@ -70,22 +70,22 @@ class SocketCore { friend bool operator<(const SocketCore& s1, const SocketCore& s2); private: // socket type defined in <sys/socket.h> - int _sockType; + int sockType_; // socket endpoint descriptor - sock_t _sockfd; + sock_t sockfd_; - static int _protocolFamily; + static int protocolFamily_; - static std::vector<std::pair<struct sockaddr_storage, socklen_t> > _bindAddrs; + static std::vector<std::pair<struct sockaddr_storage, socklen_t> > bindAddrs_; - bool _blocking; - int _secure; + bool blocking_; + int secure_; - bool _wantRead; - bool _wantWrite; + bool wantRead_; + bool wantWrite_; #if ENABLE_SSL - static SharedHandle<TLSContext> _tlsContext; + static SharedHandle<TLSContext> tlsContext_; #endif // ENABLE_SSL #ifdef HAVE_LIBSSL @@ -95,10 +95,10 @@ private: int sslHandleEAGAIN(int ret); #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS - gnutls_session_t _sslSession; - char* _peekBuf; - size_t _peekBufLength; - size_t _peekBufMax; + gnutls_session_t sslSession_; + char* peekBuf_; + size_t peekBufLength_; + size_t peekBufMax_; size_t shiftPeekData(char* data, size_t len); void addPeekData(char* data, size_t len); @@ -119,9 +119,9 @@ public: SocketCore(int sockType = SOCK_STREAM); ~SocketCore(); - sock_t getSockfd() const { return _sockfd; } + sock_t getSockfd() const { return sockfd_; } - bool isOpen() const { return _sockfd != (sock_t) -1; } + bool isOpen() const { return sockfd_ != (sock_t) -1; } void setMulticastInterface(const std::string& localAddr); @@ -219,8 +219,8 @@ public: * all data is sent. * If the underlying socket is in non-blocking mode, this method may return * even if all data is sent. The size of written data is returned. If - * underlying socket gets EAGAIN, _wantRead or _wantWrite is set accordingly. - * This method sets _wantRead and _wantWrite to false before do anything else. + * underlying socket gets EAGAIN, wantRead_ or wantWrite_ is set accordingly. + * This method sets wantRead_ and wantWrite_ to false before do anything else. * @param data data to write * @param len length of data */ @@ -254,8 +254,8 @@ public: * at least 1byte is received. * If the underlying socket is in non-blocking mode, this method may return * even if no single byte is received. If the underlying socket gets EAGAIN, - * _wantRead or _wantWrite is set accordingly. - * This method sets _wantRead and _wantWrite to false before do anything else. + * wantRead_ or wantWrite_ is set accordingly. + * This method sets wantRead_ and wantWrite_ to false before do anything else. * @param data holder to store data. * @param len the maximum size data can store. This method assigns * the number of bytes read to len. @@ -306,7 +306,7 @@ public: void prepareSecureConnection(); bool operator==(const SocketCore& s) { - return _sockfd == s._sockfd; + return sockfd_ == s.sockfd_; } bool operator!=(const SocketCore& s) { @@ -314,7 +314,7 @@ public: } bool operator<(const SocketCore& s) { - return _sockfd < s._sockfd; + return sockfd_ < s.sockfd_; } std::string getSocketError() const; @@ -338,13 +338,13 @@ public: static void setProtocolFamily(int protocolFamily) { - _protocolFamily = protocolFamily; + protocolFamily_ = protocolFamily; } // Bind socket to interface. interface may be specified as a // hostname, IP address or interface name like eth0. If the given // interface is not found or binding socket is failed, exception - // will be thrown. Set _protocolFamily before calling this function + // will be thrown. Set protocolFamily_ before calling this function // if you limit protocol family. // // We cannot use interface as an argument because it is a reserved diff --git a/src/SpeedCalc.cc b/src/SpeedCalc.cc index 17ced794..0e5bd296 100644 --- a/src/SpeedCalc.cc +++ b/src/SpeedCalc.cc @@ -43,42 +43,42 @@ namespace aria2 { #define CHANGE_INTERVAL_SEC 15 -SpeedCalc::SpeedCalc():_sw(0), _maxSpeed(0), _prevSpeed(0), - _accumulatedLength(0), - _nextInterval(CHANGE_INTERVAL_SEC) +SpeedCalc::SpeedCalc():sw_(0), maxSpeed_(0), prevSpeed_(0), + accumulatedLength_(0), + nextInterval_(CHANGE_INTERVAL_SEC) { - std::fill(&_lengthArray[0], &_lengthArray[2], 0); + std::fill(&lengthArray_[0], &lengthArray_[2], 0); } void SpeedCalc::reset() { - std::fill(&_lengthArray[0], &_lengthArray[2], 0); - std::fill(&_cpArray[0], &_cpArray[2], global::wallclock); - _sw = 0; - _maxSpeed = 0; - _prevSpeed = 0; - _start = global::wallclock; - _accumulatedLength = 0; - _nextInterval = CHANGE_INTERVAL_SEC; + std::fill(&lengthArray_[0], &lengthArray_[2], 0); + std::fill(&cpArray_[0], &cpArray_[2], global::wallclock); + sw_ = 0; + maxSpeed_ = 0; + prevSpeed_ = 0; + start_ = global::wallclock; + accumulatedLength_ = 0; + nextInterval_ = CHANGE_INTERVAL_SEC; } unsigned int SpeedCalc::calculateSpeed() { - int64_t milliElapsed = _cpArray[_sw].differenceInMillis(global::wallclock); + int64_t milliElapsed = cpArray_[sw_].differenceInMillis(global::wallclock); if(milliElapsed) { - unsigned int speed = _lengthArray[_sw]*1000/milliElapsed; - _prevSpeed = speed; - _maxSpeed = std::max(speed, _maxSpeed); + unsigned int speed = lengthArray_[sw_]*1000/milliElapsed; + prevSpeed_ = speed; + maxSpeed_ = std::max(speed, maxSpeed_); if(isIntervalOver(milliElapsed)) { changeSw(); } return speed; } else { - return _prevSpeed; + return prevSpeed_; } } void SpeedCalc::update(size_t bytes) { - _accumulatedLength += bytes; - std::transform(&_lengthArray[0], &_lengthArray[2], &_lengthArray[0], + accumulatedLength_ += bytes; + std::transform(&lengthArray_[0], &lengthArray_[2], &lengthArray_[0], std::bind1st(std::plus<uint64_t>(), (uint64_t)bytes)); if(isIntervalOver()) { changeSw(); @@ -86,28 +86,28 @@ void SpeedCalc::update(size_t bytes) { } bool SpeedCalc::isIntervalOver() const { - return _nextInterval <= _cpArray[_sw].difference(global::wallclock); + return nextInterval_ <= cpArray_[sw_].difference(global::wallclock); } bool SpeedCalc::isIntervalOver(int64_t milliElapsed) const { - return _nextInterval <= milliElapsed/1000; + return nextInterval_ <= milliElapsed/1000; } void SpeedCalc::changeSw() { - _lengthArray[_sw] = 0; - _cpArray[_sw] = global::wallclock; - _sw ^= 0x01; - _nextInterval = - _cpArray[_sw].difference(global::wallclock)+CHANGE_INTERVAL_SEC; + lengthArray_[sw_] = 0; + cpArray_[sw_] = global::wallclock; + sw_ ^= 0x01; + nextInterval_ = + cpArray_[sw_].difference(global::wallclock)+CHANGE_INTERVAL_SEC; } unsigned int SpeedCalc::calculateAvgSpeed() const { - uint64_t milliElapsed = _start.differenceInMillis(global::wallclock); + uint64_t milliElapsed = start_.differenceInMillis(global::wallclock); // if milliElapsed is too small, the average speed is rubish, better return 0 if(milliElapsed > 4) { - unsigned int speed = _accumulatedLength*1000/milliElapsed; + unsigned int speed = accumulatedLength_*1000/milliElapsed; return speed; } else { return 0; diff --git a/src/SpeedCalc.h b/src/SpeedCalc.h index 112e02cf..b19442ab 100644 --- a/src/SpeedCalc.h +++ b/src/SpeedCalc.h @@ -42,14 +42,14 @@ namespace aria2 { class SpeedCalc { private: - uint64_t _lengthArray[2]; - int _sw; - Timer _cpArray[2]; - unsigned int _maxSpeed; - unsigned int _prevSpeed; - Timer _start; - uint64_t _accumulatedLength; - time_t _nextInterval; + uint64_t lengthArray_[2]; + int sw_; + Timer cpArray_[2]; + unsigned int maxSpeed_; + unsigned int prevSpeed_; + Timer start_; + uint64_t accumulatedLength_; + time_t nextInterval_; bool isIntervalOver() const; @@ -65,7 +65,7 @@ public: unsigned int calculateSpeed(); unsigned int getMaxSpeed() const { - return _maxSpeed; + return maxSpeed_; } unsigned int calculateAvgSpeed() const; diff --git a/src/StringFormat.cc b/src/StringFormat.cc index 339e5d04..826342d0 100644 --- a/src/StringFormat.cc +++ b/src/StringFormat.cc @@ -48,14 +48,14 @@ StringFormat::StringFormat(const char* fmt, ...) char buf[1024]; int r; if((r = vsnprintf(buf, sizeof(buf), fmt, ap)) > 0) { - _msg.assign(&buf[0], &buf[r]); + msg_.assign(&buf[0], &buf[r]); } va_end(ap); } const std::string& StringFormat::str() const { - return _msg; + return msg_; } std::ostream& operator<<(std::ostream& o, const StringFormat& fmt) diff --git a/src/StringFormat.h b/src/StringFormat.h index 9f5ed2bc..49657922 100644 --- a/src/StringFormat.h +++ b/src/StringFormat.h @@ -45,7 +45,7 @@ namespace aria2 { class StringFormat { private: - std::string _msg; + std::string msg_; public: StringFormat(const char* fmt, ...); diff --git a/src/TimeA2.cc b/src/TimeA2.cc index f521aca6..33a6f551 100644 --- a/src/TimeA2.cc +++ b/src/TimeA2.cc @@ -42,25 +42,25 @@ namespace aria2 { -Time::Time():_good(true) +Time::Time():good_(true) { reset(); } Time::Time(const Time& time) { - _tv = time._tv; - _good = time._good; + tv_ = time.tv_; + good_ = time.good_; } -Time::Time(time_t sec):_good(true) +Time::Time(time_t sec):good_(true) { setTimeInSec(sec); } -Time::Time(const struct timeval& tv):_good(true) +Time::Time(const struct timeval& tv):good_(true) { - _tv = tv; + tv_ = tv; } Time::~Time() {} @@ -68,19 +68,19 @@ Time::~Time() {} Time& Time::operator=(const Time& time) { if(this != &time) { - _tv = time._tv; - _good = time._good; + tv_ = time.tv_; + good_ = time.good_; } return *this; } bool Time::operator<(const Time& time) const { - return util::difftv(time._tv, _tv) > 0; + return util::difftv(time.tv_, tv_) > 0; } void Time::reset() { - gettimeofday(&_tv, 0); + gettimeofday(&tv_, 0); } struct timeval Time::getCurrentTime() const { @@ -95,81 +95,81 @@ bool Time::elapsed(time_t sec) const { // simple test using time. // Then only when the further test is required, call gettimeofday. time_t now = time(0); - if(_tv.tv_sec+sec < now) { + if(tv_.tv_sec+sec < now) { return true; - } else if(_tv.tv_sec+sec == now) { + } else if(tv_.tv_sec+sec == now) { return - util::difftv(getCurrentTime(), _tv) >= static_cast<int64_t>(sec)*1000000; + util::difftv(getCurrentTime(), tv_) >= static_cast<int64_t>(sec)*1000000; } else { return false; } } bool Time::elapsedInMillis(int64_t millis) const { - return util::difftv(getCurrentTime(), _tv)/1000 >= millis; + return util::difftv(getCurrentTime(), tv_)/1000 >= millis; } bool Time::isNewer(const Time& time) const { - return util::difftv(_tv, time._tv) > 0; + return util::difftv(tv_, time.tv_) > 0; } time_t Time::difference() const { - return util::difftv(getCurrentTime(), _tv)/1000000; + return util::difftv(getCurrentTime(), tv_)/1000000; } time_t Time::difference(const struct timeval& now) const { - return util::difftv(now, _tv)/1000000; + return util::difftv(now, tv_)/1000000; } int64_t Time::differenceInMillis() const { - return util::difftv(getCurrentTime(), _tv)/1000; + return util::difftv(getCurrentTime(), tv_)/1000; } int64_t Time::differenceInMillis(const struct timeval& now) const { - return util::difftv(now, _tv)/1000; + return util::difftv(now, tv_)/1000; } bool Time::isZero() const { - return _tv.tv_sec == 0 && _tv.tv_usec == 0; + return tv_.tv_sec == 0 && tv_.tv_usec == 0; } int64_t Time::getTimeInMicros() const { - return (int64_t)_tv.tv_sec*1000*1000+_tv.tv_usec; + return (int64_t)tv_.tv_sec*1000*1000+tv_.tv_usec; } int64_t Time::getTimeInMillis() const { - return (int64_t)_tv.tv_sec*1000+_tv.tv_usec/1000; + return (int64_t)tv_.tv_sec*1000+tv_.tv_usec/1000; } time_t Time::getTime() const { - return _tv.tv_sec; + return tv_.tv_sec; } void Time::setTimeInSec(time_t sec) { - _tv.tv_sec = sec; - _tv.tv_usec = 0; + tv_.tv_sec = sec; + tv_.tv_usec = 0; } void Time::advance(time_t sec) { - _tv.tv_sec += sec; + tv_.tv_sec += sec; } bool Time::good() const { - return _good; + return good_; } bool Time::bad() const { - return !_good; + return !good_; } Time Time::parse(const std::string& datetime, const std::string& format) @@ -224,7 +224,7 @@ Time Time::parseHTTPDate(const std::string& datetime) Time Time::null() { Time t(0); - t._good = false; + t.good_ = false; return t; } diff --git a/src/TimeA2.h b/src/TimeA2.h index d7276987..5fd45471 100644 --- a/src/TimeA2.h +++ b/src/TimeA2.h @@ -47,9 +47,9 @@ namespace aria2 { class Time { private: - struct timeval _tv; + struct timeval tv_; - bool _good; + bool good_; struct timeval getCurrentTime() const; public: @@ -79,7 +79,7 @@ public: time_t difference(const Time& now) const { - return difference(now._tv); + return difference(now.tv_); } int64_t differenceInMillis() const; @@ -88,7 +88,7 @@ public: int64_t differenceInMillis(const Time& now) const { - return differenceInMillis(now._tv); + return differenceInMillis(now.tv_); } // Returns true if this object's time value is zero. diff --git a/src/TimeBasedCommand.cc b/src/TimeBasedCommand.cc index 929f4257..b94fe60c 100644 --- a/src/TimeBasedCommand.cc +++ b/src/TimeBasedCommand.cc @@ -46,32 +46,32 @@ namespace aria2 { TimeBasedCommand::TimeBasedCommand(cuid_t cuid, DownloadEngine* e, time_t interval, bool routineCommand): - Command(cuid), _e(e),_exit(false), _interval(interval), - _routineCommand(routineCommand), _checkPoint(global::wallclock) {} + Command(cuid), e_(e),exit_(false), interval_(interval), + routineCommand_(routineCommand), checkPoint_(global::wallclock) {} TimeBasedCommand::~TimeBasedCommand() {} bool TimeBasedCommand::execute() { preProcess(); - if(_exit) { + if(exit_) { return true; } - if(_checkPoint.difference(global::wallclock) >= _interval) { - _checkPoint = global::wallclock; + if(checkPoint_.difference(global::wallclock) >= interval_) { + checkPoint_ = global::wallclock; process(); - if(_exit) { + if(exit_) { return true; } } postProcess(); - if(_exit) { + if(exit_) { return true; } - if(_routineCommand) { - _e->addRoutineCommand(this); + if(routineCommand_) { + e_->addRoutineCommand(this); } else { - _e->addCommand(this); + e_->addCommand(this); } return false; } diff --git a/src/TimeBasedCommand.h b/src/TimeBasedCommand.h index 488df5b7..9f3d2556 100644 --- a/src/TimeBasedCommand.h +++ b/src/TimeBasedCommand.h @@ -45,36 +45,36 @@ class DownloadEngine; class TimeBasedCommand : public Command { private: - DownloadEngine* _e; + DownloadEngine* e_; /** - * setting _exit to true if this command's job has finished and you want to + * setting exit_ to true if this command's job has finished and you want to * delete this command. - * The _exit variable is evaluated after preProcess(), process(), + * The exit_ variable is evaluated after preProcess(), process(), * postProcess(), and terminate processing immediately and excute() returns * true. */ - bool _exit; + bool exit_; - time_t _interval; // unit: sec + time_t interval_; // unit: sec - bool _routineCommand; + bool routineCommand_; - Timer _checkPoint; + Timer checkPoint_; protected: DownloadEngine* getDownloadEngine() const { - return _e; + return e_; } void enableExit() { - _exit = true; + exit_ = true; } time_t getInterval() const { - return _interval; + return interval_; } public: /** diff --git a/src/TimeSeedCriteria.h b/src/TimeSeedCriteria.h index 9d7e5144..595fb368 100644 --- a/src/TimeSeedCriteria.h +++ b/src/TimeSeedCriteria.h @@ -44,26 +44,26 @@ namespace aria2 { class TimeSeedCriteria : public SeedCriteria { private: // How much time the client does seeding in seconds. - time_t _duration; - Timer _watch; + time_t duration_; + Timer watch_; public: - TimeSeedCriteria(time_t duration):_duration(duration) {} + TimeSeedCriteria(time_t duration):duration_(duration) {} virtual ~TimeSeedCriteria() {} virtual void reset() { - _watch = global::wallclock; + watch_ = global::wallclock; } virtual bool evaluate() { - return _watch.difference(global::wallclock) >= _duration; + return watch_.difference(global::wallclock) >= duration_; } void setDuration(time_t duration) { - _duration = duration; + duration_ = duration; } time_t getDuration() const { - return _duration; + return duration_; } }; diff --git a/src/TimedHaltCommand.cc b/src/TimedHaltCommand.cc index ee3250f2..30d72ec7 100644 --- a/src/TimedHaltCommand.cc +++ b/src/TimedHaltCommand.cc @@ -48,7 +48,7 @@ TimedHaltCommand::TimedHaltCommand(cuid_t cuid, DownloadEngine* e, time_t secondsToHalt, bool forceHalt): TimeBasedCommand(cuid, e, secondsToHalt, true), - _forceHalt(forceHalt) {} + forceHalt_(forceHalt) {} TimedHaltCommand::~TimedHaltCommand() {} @@ -64,7 +64,7 @@ void TimedHaltCommand::process() { if(!getDownloadEngine()->isHaltRequested()) { getLogger()->notice(MSG_TIME_HAS_PASSED, getInterval()); - if(_forceHalt) { + if(forceHalt_) { getLogger()->notice("This is emergency shutdown."); getDownloadEngine()->requestForceHalt(); } else { diff --git a/src/TimedHaltCommand.h b/src/TimedHaltCommand.h index 0a8a8014..bbac55d4 100644 --- a/src/TimedHaltCommand.h +++ b/src/TimedHaltCommand.h @@ -41,7 +41,7 @@ namespace aria2 { class TimedHaltCommand:public TimeBasedCommand { private: - bool _forceHalt; + bool forceHalt_; public: TimedHaltCommand (cuid_t cuid, DownloadEngine* e, time_t secondsToHalt, bool forceHalt=false); diff --git a/src/TimerA2.cc b/src/TimerA2.cc index 0b437791..973c830e 100644 --- a/src/TimerA2.cc +++ b/src/TimerA2.cc @@ -46,14 +46,14 @@ Timer::Timer() reset(); } -Timer::Timer(const Timer& timer):_tv(timer._tv) {} +Timer::Timer(const Timer& timer):tv_(timer.tv_) {} Timer::Timer(time_t sec) { reset(sec); } -Timer::Timer(const struct timeval& tv):_tv(tv) {} +Timer::Timer(const struct timeval& tv):tv_(tv) {} static bool useClockGettime() { @@ -65,19 +65,19 @@ static bool useClockGettime() Timer& Timer::operator=(const Timer& timer) { if(this != &timer) { - _tv = timer._tv; + tv_ = timer.tv_; } return *this; } bool Timer::operator<(const Timer& timer) const { - return util::difftv(timer._tv, _tv) > 0; + return util::difftv(timer.tv_, tv_) > 0; } bool Timer::operator>(const Timer& timer) const { - return util::difftv(_tv, timer._tv) > 0; + return util::difftv(tv_, timer.tv_) > 0; } static timeval getCurrentTime() @@ -97,69 +97,69 @@ static timeval getCurrentTime() void Timer::reset() { - _tv = getCurrentTime(); + tv_ = getCurrentTime(); } void Timer::reset(time_t sec) { - _tv.tv_sec = sec; - _tv.tv_usec = 0; + tv_.tv_sec = sec; + tv_.tv_usec = 0; } bool Timer::elapsed(time_t sec) const { return - util::difftv(getCurrentTime(), _tv) >= static_cast<int64_t>(sec)*1000000; + util::difftv(getCurrentTime(), tv_) >= static_cast<int64_t>(sec)*1000000; } bool Timer::elapsedInMillis(int64_t millis) const { - return util::difftv(getCurrentTime(), _tv)/1000 >= millis; + return util::difftv(getCurrentTime(), tv_)/1000 >= millis; } time_t Timer::difference() const { - return util::difftv(getCurrentTime(), _tv)/1000000; + return util::difftv(getCurrentTime(), tv_)/1000000; } time_t Timer::difference(const timeval& tv) const { - return util::difftv(tv, _tv)/1000000; + return util::difftv(tv, tv_)/1000000; } int64_t Timer::differenceInMillis() const { - return util::difftv(getCurrentTime(), _tv)/1000; + return util::difftv(getCurrentTime(), tv_)/1000; } int64_t Timer::differenceInMillis(const timeval& tv) const { - return util::difftv(tv, _tv)/1000; + return util::difftv(tv, tv_)/1000; } bool Timer::isZero() const { - return _tv.tv_sec == 0 && _tv.tv_usec == 0; + return tv_.tv_sec == 0 && tv_.tv_usec == 0; } int64_t Timer::getTimeInMicros() const { - return (int64_t)_tv.tv_sec*1000*1000+_tv.tv_usec; + return (int64_t)tv_.tv_sec*1000*1000+tv_.tv_usec; } int64_t Timer::getTimeInMillis() const { - return (int64_t)_tv.tv_sec*1000+_tv.tv_usec/1000; + return (int64_t)tv_.tv_sec*1000+tv_.tv_usec/1000; } time_t Timer::getTime() const { - return _tv.tv_sec; + return tv_.tv_sec; } void Timer::advance(time_t sec) { - _tv.tv_sec += sec; + tv_.tv_sec += sec; } bool Timer::monotonicClock() diff --git a/src/TimerA2.h b/src/TimerA2.h index 9166d5b1..830bd4b5 100644 --- a/src/TimerA2.h +++ b/src/TimerA2.h @@ -42,7 +42,7 @@ namespace aria2 { class Timer { private: - timeval _tv; + timeval tv_; time_t difference(const struct timeval& tv) const; @@ -73,14 +73,14 @@ public: time_t difference(const Timer& timer) const { - return difference(timer._tv); + return difference(timer.tv_); } int64_t differenceInMillis() const; int64_t differenceInMillis(const Timer& timer) const { - return differenceInMillis(timer._tv); + return differenceInMillis(timer.tv_); } // Returns true if this object's time value is zero. diff --git a/src/TrackerWatcherCommand.cc b/src/TrackerWatcherCommand.cc index 517f13ad..c9496ed8 100644 --- a/src/TrackerWatcherCommand.cc +++ b/src/TrackerWatcherCommand.cc @@ -71,44 +71,44 @@ namespace aria2 { TrackerWatcherCommand::TrackerWatcherCommand (cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e): Command(cuid), - _requestGroup(requestGroup), - _e(e) + requestGroup_(requestGroup), + e_(e) { - _requestGroup->increaseNumCommand(); + requestGroup_->increaseNumCommand(); } TrackerWatcherCommand::~TrackerWatcherCommand() { - _requestGroup->decreaseNumCommand(); + requestGroup_->decreaseNumCommand(); } bool TrackerWatcherCommand::execute() { - if(_requestGroup->isForceHaltRequested()) { - if(_trackerRequestGroup.isNull()) { + if(requestGroup_->isForceHaltRequested()) { + if(trackerRequestGroup_.isNull()) { return true; - } else if(_trackerRequestGroup->getNumCommand() == 0 || - _trackerRequestGroup->downloadFinished()) { + } else if(trackerRequestGroup_->getNumCommand() == 0 || + trackerRequestGroup_->downloadFinished()) { return true; } else { - _trackerRequestGroup->setForceHaltRequested(true); - _e->addCommand(this); + trackerRequestGroup_->setForceHaltRequested(true); + e_->addCommand(this); return false; } } - if(_btAnnounce->noMoreAnnounce()) { + if(btAnnounce_->noMoreAnnounce()) { if(getLogger()->debug()) { getLogger()->debug("no more announce"); } return true; } - if(_trackerRequestGroup.isNull()) { - _trackerRequestGroup = createAnnounce(); - if(!_trackerRequestGroup.isNull()) { + if(trackerRequestGroup_.isNull()) { + trackerRequestGroup_ = createAnnounce(); + if(!trackerRequestGroup_.isNull()) { try { std::vector<Command*>* commands = new std::vector<Command*>(); auto_delete_container<std::vector<Command*> > commandsDel(commands); - _trackerRequestGroup->createInitialCommand(*commands, _e); - _e->addCommand(*commands); + trackerRequestGroup_->createInitialCommand(*commands, e_); + e_->addCommand(*commands); commands->clear(); if(getLogger()->debug()) { getLogger()->debug("added tracker request command"); @@ -117,30 +117,30 @@ bool TrackerWatcherCommand::execute() { getLogger()->error(EX_EXCEPTION_CAUGHT, ex); } } - } else if(_trackerRequestGroup->downloadFinished()){ + } else if(trackerRequestGroup_->downloadFinished()){ try { - std::string trackerResponse = getTrackerResponse(_trackerRequestGroup); + std::string trackerResponse = getTrackerResponse(trackerRequestGroup_); processTrackerResponse(trackerResponse); - _btAnnounce->announceSuccess(); - _btAnnounce->resetAnnounce(); + btAnnounce_->announceSuccess(); + btAnnounce_->resetAnnounce(); } catch(RecoverableException& ex) { getLogger()->error(EX_EXCEPTION_CAUGHT, ex); - _btAnnounce->announceFailure(); - if(_btAnnounce->isAllAnnounceFailed()) { - _btAnnounce->resetAnnounce(); + btAnnounce_->announceFailure(); + if(btAnnounce_->isAllAnnounceFailed()) { + btAnnounce_->resetAnnounce(); } } - _trackerRequestGroup.reset(); - } else if(_trackerRequestGroup->getNumCommand() == 0){ + trackerRequestGroup_.reset(); + } else if(trackerRequestGroup_->getNumCommand() == 0){ // handle errors here - _btAnnounce->announceFailure(); // inside it, trackers = 0. - _trackerRequestGroup.reset(); - if(_btAnnounce->isAllAnnounceFailed()) { - _btAnnounce->resetAnnounce(); + btAnnounce_->announceFailure(); // inside it, trackers = 0. + trackerRequestGroup_.reset(); + if(btAnnounce_->isAllAnnounceFailed()) { + btAnnounce_->resetAnnounce(); } } - _e->addCommand(this); + e_->addCommand(this); return false; } @@ -165,21 +165,21 @@ std::string TrackerWatcherCommand::getTrackerResponse void TrackerWatcherCommand::processTrackerResponse (const std::string& trackerResponse) { - _btAnnounce->processAnnounceResponse + btAnnounce_->processAnnounceResponse (reinterpret_cast<const unsigned char*>(trackerResponse.c_str()), trackerResponse.size()); - while(!_btRuntime->isHalt() && _btRuntime->lessThanMinPeers()) { - SharedHandle<Peer> peer = _peerStorage->getUnusedPeer(); + while(!btRuntime_->isHalt() && btRuntime_->lessThanMinPeers()) { + SharedHandle<Peer> peer = peerStorage_->getUnusedPeer(); if(peer.isNull()) { break; } - peer->usedBy(_e->newCUID()); + peer->usedBy(e_->newCUID()); PeerInitiateConnectionCommand* command = new PeerInitiateConnectionCommand - (peer->usedBy(), _requestGroup, peer, _e, _btRuntime); - command->setPeerStorage(_peerStorage); - command->setPieceStorage(_pieceStorage); - _e->addCommand(command); + (peer->usedBy(), requestGroup_, peer, e_, btRuntime_); + command->setPeerStorage(peerStorage_); + command->setPieceStorage(pieceStorage_); + e_->addCommand(command); if(getLogger()->debug()) { getLogger()->debug("CUID#%s - Adding new command CUID#%s", util::itos(getCuid()).c_str(), @@ -190,9 +190,9 @@ void TrackerWatcherCommand::processTrackerResponse SharedHandle<RequestGroup> TrackerWatcherCommand::createAnnounce() { SharedHandle<RequestGroup> rg; - if(_btAnnounce->isAnnounceReady()) { - rg = createRequestGroup(_btAnnounce->getAnnounceUrl()); - _btAnnounce->announceStart(); // inside it, trackers++. + if(btAnnounce_->isAnnounceReady()) { + rg = createRequestGroup(btAnnounce_->getAnnounceUrl()); + btAnnounce_->announceStart(); // inside it, trackers++. } return rg; } @@ -221,7 +221,7 @@ TrackerWatcherCommand::createRequestGroup(const std::string& uri) std::vector<std::string> uris; uris.push_back(uri); SharedHandle<RequestGroup> rg(new RequestGroup(getOption())); - if(backupTrackerIsAvailable(_requestGroup->getDownloadContext())) { + if(backupTrackerIsAvailable(requestGroup_->getDownloadContext())) { if(getLogger()->debug()) { getLogger()->debug("This is multi-tracker announce."); } @@ -263,30 +263,30 @@ TrackerWatcherCommand::createRequestGroup(const std::string& uri) void TrackerWatcherCommand::setBtRuntime (const SharedHandle<BtRuntime>& btRuntime) { - _btRuntime = btRuntime; + btRuntime_ = btRuntime; } void TrackerWatcherCommand::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } void TrackerWatcherCommand::setPieceStorage (const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void TrackerWatcherCommand::setBtAnnounce (const SharedHandle<BtAnnounce>& btAnnounce) { - _btAnnounce = btAnnounce; + btAnnounce_ = btAnnounce; } const SharedHandle<Option>& TrackerWatcherCommand::getOption() const { - return _requestGroup->getOption(); + return requestGroup_->getOption(); } } // namespace aria2 diff --git a/src/TrackerWatcherCommand.h b/src/TrackerWatcherCommand.h index 9a2db32b..bc4a7251 100644 --- a/src/TrackerWatcherCommand.h +++ b/src/TrackerWatcherCommand.h @@ -51,19 +51,19 @@ class Option; class TrackerWatcherCommand : public Command { private: - RequestGroup* _requestGroup; + RequestGroup* requestGroup_; - DownloadEngine* _e; + DownloadEngine* e_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; - SharedHandle<BtAnnounce> _btAnnounce; + SharedHandle<BtAnnounce> btAnnounce_; - SharedHandle<RequestGroup> _trackerRequestGroup; + SharedHandle<RequestGroup> trackerRequestGroup_; /** * Returns a command for announce request. Returns 0 if no announce request * is needed. diff --git a/src/URIResult.cc b/src/URIResult.cc index 583f26d2..0e39e65e 100644 --- a/src/URIResult.cc +++ b/src/URIResult.cc @@ -37,6 +37,6 @@ namespace aria2 { URIResult::URIResult(const std::string& uri, downloadresultcode::RESULT result): - _uri(uri), _result(result) {} + uri_(uri), result_(result) {} } // namespace aria2 diff --git a/src/URIResult.h b/src/URIResult.h index 7aa49b80..4000300f 100644 --- a/src/URIResult.h +++ b/src/URIResult.h @@ -46,20 +46,20 @@ namespace aria2 { // This class stores URI and its result code as a consequence of the download. class URIResult { private: - std::string _uri; + std::string uri_; - downloadresultcode::RESULT _result; + downloadresultcode::RESULT result_; public: URIResult(const std::string& uri, downloadresultcode::RESULT result); const std::string& getURI() const { - return _uri; + return uri_; } downloadresultcode::RESULT getResult() const { - return _result; + return result_; } }; diff --git a/src/UTMetadataDataExtensionMessage.cc b/src/UTMetadataDataExtensionMessage.cc index a63855db..63ed3c54 100644 --- a/src/UTMetadataDataExtensionMessage.cc +++ b/src/UTMetadataDataExtensionMessage.cc @@ -50,15 +50,15 @@ namespace aria2 { UTMetadataDataExtensionMessage::UTMetadataDataExtensionMessage (uint8_t extensionMessageID):UTMetadataExtensionMessage(extensionMessageID), - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} std::string UTMetadataDataExtensionMessage::getPayload() { Dict dict; dict.put("msg_type", Integer::g(1)); dict.put("piece", Integer::g(getIndex())); - dict.put("total_size", Integer::g(_totalSize)); - return bencode2::encode(&dict)+_data; + dict.put("total_size", Integer::g(totalSize_)); + return bencode2::encode(&dict)+data_; } std::string UTMetadataDataExtensionMessage::toString() const @@ -68,35 +68,35 @@ std::string UTMetadataDataExtensionMessage::toString() const void UTMetadataDataExtensionMessage::doReceivedAction() { - if(_tracker->tracks(getIndex())) { - if(_logger->debug()) { - _logger->debug("ut_metadata index=%lu found in tracking list", + if(tracker_->tracks(getIndex())) { + if(logger_->debug()) { + logger_->debug("ut_metadata index=%lu found in tracking list", static_cast<unsigned long>(getIndex())); } - _tracker->remove(getIndex()); - _pieceStorage->getDiskAdaptor()->writeData - (reinterpret_cast<const unsigned char*>(_data.c_str()), _data.size(), + tracker_->remove(getIndex()); + pieceStorage_->getDiskAdaptor()->writeData + (reinterpret_cast<const unsigned char*>(data_.c_str()), data_.size(), getIndex()*METADATA_PIECE_SIZE); - _pieceStorage->completePiece(_pieceStorage->getPiece(getIndex())); - if(_pieceStorage->downloadFinished()) { - std::string metadata = util::toString(_pieceStorage->getDiskAdaptor()); + pieceStorage_->completePiece(pieceStorage_->getPiece(getIndex())); + if(pieceStorage_->downloadFinished()) { + std::string metadata = util::toString(pieceStorage_->getDiskAdaptor()); unsigned char infoHash[INFO_HASH_LENGTH]; MessageDigestHelper::digest(infoHash, INFO_HASH_LENGTH, MessageDigestContext::SHA1, metadata.data(), metadata.size()); - if(memcmp(infoHash, bittorrent::getInfoHash(_dctx), + if(memcmp(infoHash, bittorrent::getInfoHash(dctx_), INFO_HASH_LENGTH) == 0) { - _logger->info("Got ut_metadata"); + logger_->info("Got ut_metadata"); } else { - _logger->info("Got wrong ut_metadata"); - for(size_t i = 0; i < _dctx->getNumPieces(); ++i) { - _pieceStorage->markPieceMissing(i); + logger_->info("Got wrong ut_metadata"); + for(size_t i = 0; i < dctx_->getNumPieces(); ++i) { + pieceStorage_->markPieceMissing(i); } } } } else { - if(_logger->debug()) { - _logger->debug("ut_metadata index=%lu is not tracked", + if(logger_->debug()) { + logger_->debug("ut_metadata index=%lu is not tracked", static_cast<unsigned long>(getIndex())); } } diff --git a/src/UTMetadataDataExtensionMessage.h b/src/UTMetadataDataExtensionMessage.h index dc025fdf..1c032786 100644 --- a/src/UTMetadataDataExtensionMessage.h +++ b/src/UTMetadataDataExtensionMessage.h @@ -46,17 +46,17 @@ class Logger; class UTMetadataDataExtensionMessage:public UTMetadataExtensionMessage { private: - size_t _totalSize; + size_t totalSize_; - std::string _data; + std::string data_; - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - SharedHandle<PieceStorage> _pieceStorage; + SharedHandle<PieceStorage> pieceStorage_; - WeakHandle<UTMetadataRequestTracker> _tracker; + WeakHandle<UTMetadataRequestTracker> tracker_; - Logger* _logger; + Logger* logger_; public: UTMetadataDataExtensionMessage(uint8_t extensionMessageID); @@ -68,38 +68,38 @@ public: void setTotalSize(size_t totalSize) { - _totalSize = totalSize; + totalSize_ = totalSize; } size_t getTotalSize() const { - return _totalSize; + return totalSize_; } void setData(const std::string& data) { - _data = data; + data_ = data; } const std::string& getData() const { - return _data; + return data_; } void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage) { - _pieceStorage = pieceStorage; + pieceStorage_ = pieceStorage; } void setUTMetadataRequestTracker (const WeakHandle<UTMetadataRequestTracker>& tracker) { - _tracker = tracker; + tracker_ = tracker; } void setDownloadContext(const SharedHandle<DownloadContext>& dctx) { - _dctx = dctx; + dctx_ = dctx; } }; diff --git a/src/UTMetadataExtensionMessage.cc b/src/UTMetadataExtensionMessage.cc index d15ac9ef..737e47ae 100644 --- a/src/UTMetadataExtensionMessage.cc +++ b/src/UTMetadataExtensionMessage.cc @@ -40,7 +40,7 @@ const std::string UTMetadataExtensionMessage::EXTENSION_NAME = "ut_metadata"; UTMetadataExtensionMessage::UTMetadataExtensionMessage (uint8_t extensionMessageID): - _extensionMessageID(extensionMessageID), - _index(0) {} + extensionMessageID_(extensionMessageID), + index_(0) {} } // namespace aria2 diff --git a/src/UTMetadataExtensionMessage.h b/src/UTMetadataExtensionMessage.h index d758a0a2..54752d4f 100644 --- a/src/UTMetadataExtensionMessage.h +++ b/src/UTMetadataExtensionMessage.h @@ -41,15 +41,15 @@ namespace aria2 { class UTMetadataExtensionMessage:public ExtensionMessage { private: - uint8_t _extensionMessageID; + uint8_t extensionMessageID_; - size_t _index; + size_t index_; public: UTMetadataExtensionMessage(uint8_t extensionMessageID); virtual uint8_t getExtensionMessageID() { - return _extensionMessageID; + return extensionMessageID_; } virtual const std::string& getExtensionName() const @@ -61,12 +61,12 @@ public: void setIndex(size_t index) { - _index = index; + index_ = index; } size_t getIndex() const { - return _index; + return index_; } }; diff --git a/src/UTMetadataPostDownloadHandler.cc b/src/UTMetadataPostDownloadHandler.cc index 44e7073f..c82e11c9 100644 --- a/src/UTMetadataPostDownloadHandler.cc +++ b/src/UTMetadataPostDownloadHandler.cc @@ -67,7 +67,7 @@ bool UTMetadataPostDownloadHandler::Criteria::match } UTMetadataPostDownloadHandler::UTMetadataPostDownloadHandler(): - _logger(LogFactory::getInstance()) + logger_(LogFactory::getInstance()) { setCriteria(SharedHandle<Criteria>(new Criteria())); } @@ -86,9 +86,9 @@ void UTMetadataPostDownloadHandler::getNextRequestGroups util::applyDir(requestGroup->getOption()->get(PREF_DIR), util::toHex(attrs->infoHash)+".torrent"); if(util::saveAs(filename, torrent)) { - _logger->notice(MSG_METADATA_SAVED, filename.c_str()); + logger_->notice(MSG_METADATA_SAVED, filename.c_str()); } else { - _logger->notice(MSG_METADATA_NOT_SAVED, filename.c_str()); + logger_->notice(MSG_METADATA_NOT_SAVED, filename.c_str()); } } if(!requestGroup->getOption()->getAsBool(PREF_BT_METADATA_ONLY)) { diff --git a/src/UTMetadataPostDownloadHandler.h b/src/UTMetadataPostDownloadHandler.h index bc8c0b32..318ab351 100644 --- a/src/UTMetadataPostDownloadHandler.h +++ b/src/UTMetadataPostDownloadHandler.h @@ -45,7 +45,7 @@ class Logger; class UTMetadataPostDownloadHandler:public PostDownloadHandler { private: - Logger* _logger; + Logger* logger_; class Criteria:public RequestGroupCriteria { diff --git a/src/UTMetadataRequestExtensionMessage.cc b/src/UTMetadataRequestExtensionMessage.cc index 8372fb10..6374515c 100644 --- a/src/UTMetadataRequestExtensionMessage.cc +++ b/src/UTMetadataRequestExtensionMessage.cc @@ -69,14 +69,14 @@ std::string UTMetadataRequestExtensionMessage::toString() const void UTMetadataRequestExtensionMessage::doReceivedAction() { - SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(_dctx); - uint8_t id = _peer->getExtensionMessageID("ut_metadata"); + SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_); + uint8_t id = peer_->getExtensionMessageID("ut_metadata"); if(attrs->metadata.empty()) { SharedHandle<UTMetadataRejectExtensionMessage> m (new UTMetadataRejectExtensionMessage(id)); m->setIndex(getIndex()); - SharedHandle<BtMessage> msg = _messageFactory->createBtExtendedMessage(m); - _dispatcher->addMessageToQueue(msg); + SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m); + dispatcher_->addMessageToQueue(msg); }else if(getIndex()*METADATA_PIECE_SIZE < attrs->metadataSize) { SharedHandle<UTMetadataDataExtensionMessage> m (new UTMetadataDataExtensionMessage(id)); @@ -89,8 +89,8 @@ void UTMetadataRequestExtensionMessage::doReceivedAction() attrs->metadata.begin()+(getIndex()+1)*METADATA_PIECE_SIZE: attrs->metadata.end(); m->setData(std::string(begin, end)); - SharedHandle<BtMessage> msg = _messageFactory->createBtExtendedMessage(m); - _dispatcher->addMessageToQueue(msg); + SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m); + dispatcher_->addMessageToQueue(msg); } else { throw DL_ABORT_EX (StringFormat diff --git a/src/UTMetadataRequestExtensionMessage.h b/src/UTMetadataRequestExtensionMessage.h index aefda4e0..ead2c047 100644 --- a/src/UTMetadataRequestExtensionMessage.h +++ b/src/UTMetadataRequestExtensionMessage.h @@ -46,13 +46,13 @@ class Peer; class UTMetadataRequestExtensionMessage:public UTMetadataExtensionMessage { private: - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; - WeakHandle<BtMessageFactory> _messageFactory; + WeakHandle<BtMessageFactory> messageFactory_; public: UTMetadataRequestExtensionMessage(uint8_t extensionMessageID); @@ -64,22 +64,22 @@ public: void setDownloadContext(const SharedHandle<DownloadContext>& dctx) { - _dctx = dctx; + dctx_ = dctx; } void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& disp) { - _dispatcher = disp; + dispatcher_ = disp; } void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } void setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } }; diff --git a/src/UTMetadataRequestFactory.cc b/src/UTMetadataRequestFactory.cc index 8fac6dd0..11240f0a 100644 --- a/src/UTMetadataRequestFactory.cc +++ b/src/UTMetadataRequestFactory.cc @@ -46,38 +46,38 @@ namespace aria2 { UTMetadataRequestFactory::UTMetadataRequestFactory(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} void UTMetadataRequestFactory::create (std::vector<SharedHandle<BtMessage> >& msgs, size_t num, const SharedHandle<PieceStorage>& pieceStorage) { - for(size_t index = 0, numPieces = _dctx->getNumPieces(); + for(size_t index = 0, numPieces = dctx_->getNumPieces(); index < numPieces && num; ++index) { SharedHandle<Piece> p = pieceStorage->getMissingPiece(index); if(p.isNull()) { - if(_logger->debug()) { - _logger->debug("ut_metadata piece %lu is used or already acquired."); + if(logger_->debug()) { + logger_->debug("ut_metadata piece %lu is used or already acquired."); } continue; } --num; - if(_logger->debug()) { - _logger->debug("Creating ut_metadata request index=%lu", + if(logger_->debug()) { + logger_->debug("Creating ut_metadata request index=%lu", static_cast<unsigned long>(index)); } SharedHandle<UTMetadataRequestExtensionMessage> m (new UTMetadataRequestExtensionMessage - (_peer->getExtensionMessageID("ut_metadata"))); + (peer_->getExtensionMessageID("ut_metadata"))); m->setIndex(index); - m->setDownloadContext(_dctx); - m->setBtMessageDispatcher(_dispatcher); - m->setBtMessageFactory(_messageFactory); - m->setPeer(_peer); + m->setDownloadContext(dctx_); + m->setBtMessageDispatcher(dispatcher_); + m->setBtMessageFactory(messageFactory_); + m->setPeer(peer_); - SharedHandle<BtMessage> msg = _messageFactory->createBtExtendedMessage(m); + SharedHandle<BtMessage> msg = messageFactory_->createBtExtendedMessage(m); msgs.push_back(msg); - _tracker->add(index); + tracker_->add(index); } } diff --git a/src/UTMetadataRequestFactory.h b/src/UTMetadataRequestFactory.h index 0c62fc68..fa47f1b6 100644 --- a/src/UTMetadataRequestFactory.h +++ b/src/UTMetadataRequestFactory.h @@ -54,17 +54,17 @@ class Logger; class UTMetadataRequestFactory { private: - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - SharedHandle<Peer> _peer; + SharedHandle<Peer> peer_; - WeakHandle<BtMessageDispatcher> _dispatcher; + WeakHandle<BtMessageDispatcher> dispatcher_; - WeakHandle<BtMessageFactory> _messageFactory; + WeakHandle<BtMessageFactory> messageFactory_; - WeakHandle<UTMetadataRequestTracker> _tracker; + WeakHandle<UTMetadataRequestTracker> tracker_; - Logger* _logger; + Logger* logger_; public: UTMetadataRequestFactory(); @@ -75,28 +75,28 @@ public: void setDownloadContext(const SharedHandle<DownloadContext>& dctx) { - _dctx = dctx; + dctx_ = dctx; } void setBtMessageDispatcher(const WeakHandle<BtMessageDispatcher>& disp) { - _dispatcher = disp; + dispatcher_ = disp; } void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory) { - _messageFactory = factory; + messageFactory_ = factory; } void setPeer(const SharedHandle<Peer>& peer) { - _peer = peer; + peer_ = peer; } void setUTMetadataRequestTracker (const WeakHandle<UTMetadataRequestTracker>& tracker) { - _tracker = tracker; + tracker_ = tracker; } }; diff --git a/src/UTMetadataRequestTracker.cc b/src/UTMetadataRequestTracker.cc index 33380a8c..4c35e81b 100644 --- a/src/UTMetadataRequestTracker.cc +++ b/src/UTMetadataRequestTracker.cc @@ -41,26 +41,26 @@ namespace aria2 { UTMetadataRequestTracker::UTMetadataRequestTracker(): - _logger(LogFactory::getInstance()) {} + logger_(LogFactory::getInstance()) {} void UTMetadataRequestTracker::add(size_t index) { - _trackedRequests.push_back(RequestEntry(index)); + trackedRequests_.push_back(RequestEntry(index)); } bool UTMetadataRequestTracker::tracks(size_t index) { - return std::find(_trackedRequests.begin(), _trackedRequests.end(), - RequestEntry(index)) != _trackedRequests.end(); + return std::find(trackedRequests_.begin(), trackedRequests_.end(), + RequestEntry(index)) != trackedRequests_.end(); } void UTMetadataRequestTracker::remove(size_t index) { std::vector<RequestEntry>::iterator i = - std::find(_trackedRequests.begin(), _trackedRequests.end(), + std::find(trackedRequests_.begin(), trackedRequests_.end(), RequestEntry(index)); - if(i != _trackedRequests.end()) { - _trackedRequests.erase(i); + if(i != trackedRequests_.end()) { + trackedRequests_.erase(i); } } @@ -68,16 +68,16 @@ std::vector<size_t> UTMetadataRequestTracker::removeTimeoutEntry() { std::vector<size_t> indexes; const time_t TIMEOUT = 20; - for(std::vector<RequestEntry>::iterator i = _trackedRequests.begin(), - eoi = _trackedRequests.end(); i != eoi;) { + for(std::vector<RequestEntry>::iterator i = trackedRequests_.begin(), + eoi = trackedRequests_.end(); i != eoi;) { if((*i).elapsed(TIMEOUT)) { - if(_logger->debug()) { - _logger->debug("ut_metadata request timeout. index=%lu", - static_cast<unsigned long>((*i)._index)); + if(logger_->debug()) { + logger_->debug("ut_metadata request timeout. index=%lu", + static_cast<unsigned long>((*i).index_)); } - indexes.push_back((*i)._index); - i = _trackedRequests.erase(i); - eoi = _trackedRequests.end(); + indexes.push_back((*i).index_); + i = trackedRequests_.erase(i); + eoi = trackedRequests_.end(); } else { ++i; } @@ -98,9 +98,9 @@ size_t UTMetadataRequestTracker::avail() const std::vector<size_t> UTMetadataRequestTracker::getAllTrackedIndex() const { std::vector<size_t> indexes; - for(std::vector<RequestEntry>::const_iterator i = _trackedRequests.begin(), - eoi = _trackedRequests.end(); i != eoi; ++i) { - indexes.push_back((*i)._index); + for(std::vector<RequestEntry>::const_iterator i = trackedRequests_.begin(), + eoi = trackedRequests_.end(); i != eoi; ++i) { + indexes.push_back((*i).index_); } return indexes; } diff --git a/src/UTMetadataRequestTracker.h b/src/UTMetadataRequestTracker.h index b7bd91a5..5086dd16 100644 --- a/src/UTMetadataRequestTracker.h +++ b/src/UTMetadataRequestTracker.h @@ -49,25 +49,25 @@ class Logger; class UTMetadataRequestTracker { private: struct RequestEntry { - size_t _index; - Timer _dispatchedTime; + size_t index_; + Timer dispatchedTime_; - RequestEntry(size_t index):_index(index) {} + RequestEntry(size_t index):index_(index) {} bool elapsed(time_t t) const { - return _dispatchedTime.difference(global::wallclock) >= t; + return dispatchedTime_.difference(global::wallclock) >= t; } bool operator==(const RequestEntry& e) const { - return _index == e._index; + return index_ == e.index_; } }; - std::vector<RequestEntry> _trackedRequests; + std::vector<RequestEntry> trackedRequests_; - Logger* _logger; + Logger* logger_; public: UTMetadataRequestTracker(); @@ -89,7 +89,7 @@ public: // Returns the number of tracking list. size_t count() const { - return _trackedRequests.size(); + return trackedRequests_.size(); } // Returns the number of additional index this tracker can track. diff --git a/src/UTPexExtensionMessage.cc b/src/UTPexExtensionMessage.cc index 1975e5f6..726510c8 100644 --- a/src/UTPexExtensionMessage.cc +++ b/src/UTPexExtensionMessage.cc @@ -49,19 +49,19 @@ namespace aria2 { const std::string UTPexExtensionMessage::EXTENSION_NAME = "ut_pex"; UTPexExtensionMessage::UTPexExtensionMessage(uint8_t extensionMessageID): - _extensionMessageID(extensionMessageID), - _interval(DEFAULT_INTERVAL), - _maxFreshPeer(DEFAULT_MAX_FRESH_PEER), - _maxDroppedPeer(DEFAULT_MAX_DROPPED_PEER) {} + extensionMessageID_(extensionMessageID), + interval_(DEFAULT_INTERVAL), + maxFreshPeer_(DEFAULT_MAX_FRESH_PEER), + maxDroppedPeer_(DEFAULT_MAX_DROPPED_PEER) {} UTPexExtensionMessage::~UTPexExtensionMessage() {} std::string UTPexExtensionMessage::getPayload() { std::pair<std::string, std::string> freshPeerPair = - createCompactPeerListAndFlag(_freshPeers); + createCompactPeerListAndFlag(freshPeers_); std::pair<std::string, std::string> droppedPeerPair = - createCompactPeerListAndFlag(_droppedPeers); + createCompactPeerListAndFlag(droppedPeers_); Dict dict; dict.put("added", freshPeerPair.first); @@ -90,20 +90,20 @@ UTPexExtensionMessage::createCompactPeerListAndFlag std::string UTPexExtensionMessage::toString() const { - return strconcat("ut_pex added=", util::uitos(_freshPeers.size()), - ", dropped=", util::uitos(_droppedPeers.size())); + return strconcat("ut_pex added=", util::uitos(freshPeers_.size()), + ", dropped=", util::uitos(droppedPeers_.size())); } void UTPexExtensionMessage::doReceivedAction() { - _peerStorage->addPeer(_freshPeers); + peerStorage_->addPeer(freshPeers_); } bool UTPexExtensionMessage::addFreshPeer(const SharedHandle<Peer>& peer) { if(!peer->isIncomingPeer() && - peer->getFirstContactTime().difference(global::wallclock) < _interval) { - _freshPeers.push_back(peer); + peer->getFirstContactTime().difference(global::wallclock) < interval_) { + freshPeers_.push_back(peer); return true; } else { return false; @@ -112,15 +112,15 @@ bool UTPexExtensionMessage::addFreshPeer(const SharedHandle<Peer>& peer) bool UTPexExtensionMessage::freshPeersAreFull() const { - return _freshPeers.size() >= _maxFreshPeer; + return freshPeers_.size() >= maxFreshPeer_; } bool UTPexExtensionMessage::addDroppedPeer(const SharedHandle<Peer>& peer) { if(!peer->isIncomingPeer() && peer->getBadConditionStartTime(). - difference(global::wallclock) < _interval) { - _droppedPeers.push_back(peer); + difference(global::wallclock) < interval_) { + droppedPeers_.push_back(peer); return true; } else { return false; @@ -129,23 +129,23 @@ bool UTPexExtensionMessage::addDroppedPeer(const SharedHandle<Peer>& peer) bool UTPexExtensionMessage::droppedPeersAreFull() const { - return _droppedPeers.size() >= _maxDroppedPeer; + return droppedPeers_.size() >= maxDroppedPeer_; } void UTPexExtensionMessage::setMaxFreshPeer(size_t maxFreshPeer) { - _maxFreshPeer = maxFreshPeer; + maxFreshPeer_ = maxFreshPeer; } void UTPexExtensionMessage::setMaxDroppedPeer(size_t maxDroppedPeer) { - _maxDroppedPeer = maxDroppedPeer; + maxDroppedPeer_ = maxDroppedPeer; } void UTPexExtensionMessage::setPeerStorage (const SharedHandle<PeerStorage>& peerStorage) { - _peerStorage = peerStorage; + peerStorage_ = peerStorage; } UTPexExtensionMessageHandle @@ -162,11 +162,11 @@ UTPexExtensionMessage::create(const unsigned char* data, size_t len) if(dict) { const String* added = asString(dict->get("added")); if(added) { - bittorrent::extractPeer(added, std::back_inserter(msg->_freshPeers)); + bittorrent::extractPeer(added, std::back_inserter(msg->freshPeers_)); } const String* dropped = asString(dict->get("dropped")); if(dropped) { - bittorrent::extractPeer(dropped, std::back_inserter(msg->_droppedPeers)); + bittorrent::extractPeer(dropped, std::back_inserter(msg->droppedPeers_)); } } return msg; diff --git a/src/UTPexExtensionMessage.h b/src/UTPexExtensionMessage.h index e79620d4..206a01cf 100644 --- a/src/UTPexExtensionMessage.h +++ b/src/UTPexExtensionMessage.h @@ -51,19 +51,19 @@ typedef SharedHandle<UTPexExtensionMessage> UTPexExtensionMessageHandle; class UTPexExtensionMessage:public ExtensionMessage { private: - uint8_t _extensionMessageID; + uint8_t extensionMessageID_; - std::vector<SharedHandle<Peer> > _freshPeers; + std::vector<SharedHandle<Peer> > freshPeers_; - std::vector<SharedHandle<Peer> > _droppedPeers; + std::vector<SharedHandle<Peer> > droppedPeers_; - SharedHandle<PeerStorage> _peerStorage; + SharedHandle<PeerStorage> peerStorage_; - time_t _interval; + time_t interval_; - size_t _maxFreshPeer; + size_t maxFreshPeer_; - size_t _maxDroppedPeer; + size_t maxDroppedPeer_; std::pair<std::string, std::string> createCompactPeerListAndFlag(const std::vector<SharedHandle<Peer> >& peers); @@ -77,7 +77,7 @@ public: virtual uint8_t getExtensionMessageID() { - return _extensionMessageID; + return extensionMessageID_; } virtual const std::string& getExtensionName() const @@ -95,7 +95,7 @@ public: const std::vector<SharedHandle<Peer> >& getFreshPeers() const { - return _freshPeers; + return freshPeers_; } bool freshPeersAreFull() const; @@ -104,7 +104,7 @@ public: const std::vector<SharedHandle<Peer> >& getDroppedPeers() const { - return _droppedPeers; + return droppedPeers_; } bool droppedPeersAreFull() const; @@ -118,14 +118,14 @@ public: size_t getMaxFreshPeer() const { - return _maxFreshPeer; + return maxFreshPeer_; } void setMaxDroppedPeer(size_t maxDroppedPeer); size_t getMaxDroppedPeer() const { - return _maxDroppedPeer; + return maxDroppedPeer_; } static const time_t DEFAULT_INTERVAL = 60; diff --git a/src/UnionSeedCriteria.h b/src/UnionSeedCriteria.h index 1aa0e598..32beab97 100644 --- a/src/UnionSeedCriteria.h +++ b/src/UnionSeedCriteria.h @@ -43,7 +43,7 @@ namespace aria2 { class UnionSeedCriteria : public SeedCriteria { private: - std::vector<SharedHandle<SeedCriteria> > _criterion; + std::vector<SharedHandle<SeedCriteria> > criterion_; class Reset { public: @@ -67,24 +67,24 @@ public: virtual void reset() { - std::for_each(_criterion.begin(), _criterion.end(), Reset()); + std::for_each(criterion_.begin(), criterion_.end(), Reset()); } virtual bool evaluate() { std::vector<SharedHandle<SeedCriteria> >::iterator itr = - std::find_if(_criterion.begin(), _criterion.end(), Eval()); - return itr != _criterion.end(); + std::find_if(criterion_.begin(), criterion_.end(), Eval()); + return itr != criterion_.end(); } void addSeedCriteria(const SharedHandle<SeedCriteria>& cri) { - _criterion.push_back(cri); + criterion_.push_back(cri); } const std::vector<SharedHandle<SeedCriteria> >& getSeedCriterion() const { - return _criterion; + return criterion_; } }; diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc index 12b9363d..678c6942 100644 --- a/src/UnknownLengthPieceStorage.cc +++ b/src/UnknownLengthPieceStorage.cc @@ -49,26 +49,26 @@ namespace aria2 { UnknownLengthPieceStorage::UnknownLengthPieceStorage (const SharedHandle<DownloadContext>& downloadContext, const Option* option): - _downloadContext(downloadContext), - _option(option), - _diskWriterFactory(new DefaultDiskWriterFactory()), - _totalLength(0), - _downloadFinished(false) {} + downloadContext_(downloadContext), + option_(option), + diskWriterFactory_(new DefaultDiskWriterFactory()), + totalLength_(0), + downloadFinished_(false) {} UnknownLengthPieceStorage::~UnknownLengthPieceStorage() {} void UnknownLengthPieceStorage::initStorage() { DirectDiskAdaptorHandle directDiskAdaptor(new DirectDiskAdaptor()); - directDiskAdaptor->setTotalLength(_downloadContext->getTotalLength()); - directDiskAdaptor->setFileEntries(_downloadContext->getFileEntries().begin(), - _downloadContext->getFileEntries().end()); + directDiskAdaptor->setTotalLength(downloadContext_->getTotalLength()); + directDiskAdaptor->setFileEntries(downloadContext_->getFileEntries().begin(), + downloadContext_->getFileEntries().end()); DiskWriterHandle writer = - _diskWriterFactory->newDiskWriter(directDiskAdaptor->getFilePath()); + diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath()); directDiskAdaptor->setDiskWriter(writer); - _diskAdaptor = directDiskAdaptor; + diskAdaptor_ = directDiskAdaptor; } #ifdef ENABLE_BITTORRENT @@ -110,12 +110,12 @@ bool UnknownLengthPieceStorage::hasMissingUnusedPiece() SharedHandle<Piece> UnknownLengthPieceStorage::getSparseMissingUnusedPiece (const unsigned char* ignoreBitfield, size_t length) { - if(_downloadFinished) { + if(downloadFinished_) { return SharedHandle<Piece>(); } - if(_piece.isNull()) { - _piece.reset(new Piece()); - return _piece; + if(piece_.isNull()) { + piece_.reset(new Piece()); + return piece_; } else { return SharedHandle<Piece>(); } @@ -133,10 +133,10 @@ SharedHandle<Piece> UnknownLengthPieceStorage::getMissingPiece(size_t index) SharedHandle<Piece> UnknownLengthPieceStorage::getPiece(size_t index) { if(index == 0) { - if(_piece.isNull()) { + if(piece_.isNull()) { return SharedHandle<Piece>(new Piece()); } else { - return _piece; + return piece_; } } else { return SharedHandle<Piece>(); @@ -145,24 +145,24 @@ SharedHandle<Piece> UnknownLengthPieceStorage::getPiece(size_t index) void UnknownLengthPieceStorage::completePiece(const SharedHandle<Piece>& piece) { - if(_piece == piece) { - _downloadFinished = true; - _totalLength = _piece->getLength(); - _diskAdaptor->setTotalLength(_totalLength); - _piece.reset(); + if(piece_ == piece) { + downloadFinished_ = true; + totalLength_ = piece_->getLength(); + diskAdaptor_->setTotalLength(totalLength_); + piece_.reset(); } } void UnknownLengthPieceStorage::cancelPiece(const SharedHandle<Piece>& piece) { - if(_piece == piece) { - _piece.reset(); + if(piece_ == piece) { + piece_.reset(); } } bool UnknownLengthPieceStorage::hasPiece(size_t index) { - if(index == 0 && _downloadFinished) { + if(index == 0 && downloadFinished_) { return true; } else { return false; @@ -171,7 +171,7 @@ bool UnknownLengthPieceStorage::hasPiece(size_t index) bool UnknownLengthPieceStorage::isPieceUsed(size_t index) { - if(index == 0 && !_piece.isNull()) { + if(index == 0 && !piece_.isNull()) { return true; } else { return false; @@ -180,13 +180,13 @@ bool UnknownLengthPieceStorage::isPieceUsed(size_t index) DiskAdaptorHandle UnknownLengthPieceStorage::getDiskAdaptor() { - return _diskAdaptor; + return diskAdaptor_; } size_t UnknownLengthPieceStorage::getPieceLength(size_t index) { if(index == 0) { - return _totalLength; + return totalLength_; } else { return 0; } @@ -194,11 +194,11 @@ size_t UnknownLengthPieceStorage::getPieceLength(size_t index) void UnknownLengthPieceStorage::markAllPiecesDone() { - if(!_piece.isNull()) { - _totalLength = _piece->getLength(); - _piece.reset(); + if(!piece_.isNull()) { + totalLength_ = piece_->getLength(); + piece_.reset(); } - _downloadFinished = true; + downloadFinished_ = true; } void UnknownLengthPieceStorage::markPiecesDone(uint64_t length) @@ -220,7 +220,7 @@ void UnknownLengthPieceStorage::getInFlightPieces void UnknownLengthPieceStorage::setDiskWriterFactory (const DiskWriterFactoryHandle& diskWriterFactory) { - _diskWriterFactory = diskWriterFactory; + diskWriterFactory_ = diskWriterFactory; } } // namespace aria2 diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h index 8a82e4c3..1ecfa09f 100644 --- a/src/UnknownLengthPieceStorage.h +++ b/src/UnknownLengthPieceStorage.h @@ -46,19 +46,19 @@ class DirectDiskAdaptor; class UnknownLengthPieceStorage:public PieceStorage { private: - SharedHandle<DownloadContext> _downloadContext; + SharedHandle<DownloadContext> downloadContext_; - const Option* _option; + const Option* option_; - SharedHandle<DirectDiskAdaptor> _diskAdaptor; + SharedHandle<DirectDiskAdaptor> diskAdaptor_; - SharedHandle<DiskWriterFactory> _diskWriterFactory; + SharedHandle<DiskWriterFactory> diskWriterFactory_; - uint64_t _totalLength; + uint64_t totalLength_; - bool _downloadFinished; + bool downloadFinished_; - SharedHandle<Piece> _piece; + SharedHandle<Piece> piece_; public: UnknownLengthPieceStorage(const SharedHandle<DownloadContext>& downloadContext, const Option* option); @@ -140,18 +140,18 @@ public: virtual uint64_t getTotalLength() { - return _totalLength; + return totalLength_; } virtual uint64_t getFilteredTotalLength() { - return _totalLength; + return totalLength_; } virtual uint64_t getCompletedLength() { // TODO we have to return actual completed length here? - return _totalLength; + return totalLength_; } virtual uint64_t getFilteredCompletedLength() @@ -170,7 +170,7 @@ public: */ virtual bool downloadFinished() { - return _downloadFinished; + return downloadFinished_; } /** diff --git a/src/UriListParser.cc b/src/UriListParser.cc index 2ac5b96e..e783c1ca 100644 --- a/src/UriListParser.cc +++ b/src/UriListParser.cc @@ -45,9 +45,9 @@ namespace aria2 { -UriListParser::UriListParser(std::istream& in):_in(in) +UriListParser::UriListParser(std::istream& in):in_(in) { - _optparser.setOptionHandlers(OptionHandlerFactory::createOptionHandlers()); + optparser_.setOptionHandlers(OptionHandlerFactory::createOptionHandlers()); } UriListParser::~UriListParser() {} @@ -55,38 +55,38 @@ UriListParser::~UriListParser() {} void UriListParser::getOptions(Option& op) { std::stringstream ss; - while(getline(_in, _line)) { - if(util::startsWith(_line, " ")) { - ss << _line << "\n"; - } else if(util::startsWith(_line, A2STR::SHARP_C)) { + while(getline(in_, line_)) { + if(util::startsWith(line_, " ")) { + ss << line_ << "\n"; + } else if(util::startsWith(line_, A2STR::SHARP_C)) { continue; } else { break; } } - _optparser.parse(op, ss); + optparser_.parse(op, ss); } void UriListParser::parseNext(std::vector<std::string>& uris, Option& op) { - if(_line.empty()) { - getline(_in, _line); + if(line_.empty()) { + getline(in_, line_); } - if(!_in) { + if(!in_) { return; } do { - if(!util::startsWith(_line, A2STR::SHARP_C) && !util::trim(_line).empty()) { - util::split(_line, std::back_inserter(uris), "\t", true); + if(!util::startsWith(line_, A2STR::SHARP_C) && !util::trim(line_).empty()) { + util::split(line_, std::back_inserter(uris), "\t", true); getOptions(op); return; } - } while(getline(_in, _line)); + } while(getline(in_, line_)); } bool UriListParser::hasNext() const { - return _in; + return in_; } } // namespace aria2 diff --git a/src/UriListParser.h b/src/UriListParser.h index f5199db9..a1acacba 100644 --- a/src/UriListParser.h +++ b/src/UriListParser.h @@ -48,11 +48,11 @@ namespace aria2 { class UriListParser { private: - std::istream& _in; + std::istream& in_; - OptionParser _optparser; + OptionParser optparser_; - std::string _line; + std::string line_; void getOptions(Option& op); public: diff --git a/src/XML2SAXMetalinkProcessor.cc b/src/XML2SAXMetalinkProcessor.cc index ce5c3359..e76f4660 100644 --- a/src/XML2SAXMetalinkProcessor.cc +++ b/src/XML2SAXMetalinkProcessor.cc @@ -49,11 +49,11 @@ namespace aria2 { class SessionData { public: - SharedHandle<MetalinkParserStateMachine> _stm; + SharedHandle<MetalinkParserStateMachine> stm_; - std::deque<std::string> _charactersStack; + std::deque<std::string> charactersStack_; - SessionData(const SharedHandle<MetalinkParserStateMachine>& stm):_stm(stm) {} + SessionData(const SharedHandle<MetalinkParserStateMachine>& stm):stm_(stm) {} }; static void mlStartElement @@ -95,9 +95,9 @@ static void mlStartElement if(srcNsUri) { nsUri = reinterpret_cast<const char*>(srcNsUri); } - sd->_stm->beginElement(localname, prefix, nsUri, xmlAttrs); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.push_front(A2STR::NIL); + sd->stm_->beginElement(localname, prefix, nsUri, xmlAttrs); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.push_front(A2STR::NIL); } } @@ -109,9 +109,9 @@ static void mlEndElement { SessionData* sd = reinterpret_cast<SessionData*>(userData); std::string characters; - if(sd->_stm->needsCharactersBuffering()) { - characters = sd->_charactersStack.front(); - sd->_charactersStack.pop_front(); + if(sd->stm_->needsCharactersBuffering()) { + characters = sd->charactersStack_.front(); + sd->charactersStack_.pop_front(); } std::string localname = reinterpret_cast<const char*>(srcLocalname); std::string prefix; @@ -122,14 +122,14 @@ static void mlEndElement if(srcNsUri) { nsUri = reinterpret_cast<const char*>(srcNsUri); } - sd->_stm->endElement(localname, prefix, nsUri, characters); + sd->stm_->endElement(localname, prefix, nsUri, characters); } static void mlCharacters(void* userData, const xmlChar* ch, int len) { SessionData* sd = reinterpret_cast<SessionData*>(userData); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.front() += std::string(&ch[0], &ch[len]); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.front() += std::string(&ch[0], &ch[len]); } } @@ -172,8 +172,8 @@ static xmlSAXHandler mySAXHandler = SharedHandle<Metalinker> MetalinkProcessor::parseFile(const std::string& filename) { - _stm.reset(new MetalinkParserStateMachine()); - SharedHandle<SessionData> sessionData(new SessionData(_stm)); + stm_.reset(new MetalinkParserStateMachine()); + SharedHandle<SessionData> sessionData(new SessionData(stm_)); // Old libxml2(at least 2.7.6, Ubuntu 10.04LTS) does not read stdin // when "/dev/stdin" is passed as filename while 2.7.7 does. So we // convert DEV_STDIN to "-" for compatibility. @@ -188,19 +188,19 @@ MetalinkProcessor::parseFile(const std::string& filename) if(retval != 0) { throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK); } - if(!_stm->finished()) { + if(!stm_->finished()) { throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK); } - if(!_stm->getErrors().empty()) { - throw DL_ABORT_EX(_stm->getErrorString()); + if(!stm_->getErrors().empty()) { + throw DL_ABORT_EX(stm_->getErrorString()); } - return _stm->getResult(); + return stm_->getResult(); } SharedHandle<Metalinker> MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binaryStream) { - _stm.reset(new MetalinkParserStateMachine()); + stm_.reset(new MetalinkParserStateMachine()); size_t bufSize = 4096; unsigned char buf[bufSize]; @@ -209,7 +209,7 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar throw DL_ABORT_EX("Too small data for parsing XML."); } - SharedHandle<SessionData> sessionData(new SessionData(_stm)); + SharedHandle<SessionData> sessionData(new SessionData(stm_)); xmlParserCtxtPtr ctx = xmlCreatePushParserCtxt (&mySAXHandler, sessionData.get(), reinterpret_cast<const char*>(buf), res, 0); @@ -228,13 +228,13 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar } xmlParseChunk(ctx, reinterpret_cast<const char*>(buf), 0, 1); - if(!_stm->finished()) { + if(!stm_->finished()) { throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK); } - if(!_stm->getErrors().empty()) { - throw DL_ABORT_EX(_stm->getErrorString()); + if(!stm_->getErrors().empty()) { + throw DL_ABORT_EX(stm_->getErrorString()); } - return _stm->getResult(); + return stm_->getResult(); } } // namespace aria2 diff --git a/src/XML2SAXMetalinkProcessor.h b/src/XML2SAXMetalinkProcessor.h index fe83a0a0..bef4255b 100644 --- a/src/XML2SAXMetalinkProcessor.h +++ b/src/XML2SAXMetalinkProcessor.h @@ -52,7 +52,7 @@ class MetalinkParserStateMachine; class MetalinkProcessor { private: - SharedHandle<MetalinkParserStateMachine> _stm; + SharedHandle<MetalinkParserStateMachine> stm_; public: SharedHandle<Metalinker> parseFile(const std::string& filename); diff --git a/src/XORCloser.h b/src/XORCloser.h index e5843509..720e8af6 100644 --- a/src/XORCloser.h +++ b/src/XORCloser.h @@ -43,17 +43,17 @@ namespace aria2 { class XORCloser { private: - const unsigned char* _key; - size_t _length; + const unsigned char* key_; + size_t length_; public: - XORCloser(const unsigned char* key, size_t length):_key(key), _length(length) {} + XORCloser(const unsigned char* key, size_t length):key_(key), length_(length) {} bool operator()(const unsigned char* key1, const unsigned char* key2) const { - for(size_t i = 0; i < _length; ++i) { - unsigned char c1 = _key[i]^key1[i]; - unsigned char c2 = _key[i]^key2[i]; + for(size_t i = 0; i < length_; ++i) { + unsigned char c1 = key_[i]^key1[i]; + unsigned char c2 = key_[i]^key2[i]; if(c1 < c2) { return true; diff --git a/src/Xml2XmlRpcRequestProcessor.cc b/src/Xml2XmlRpcRequestProcessor.cc index 0de3a1af..bf4e52d8 100644 --- a/src/Xml2XmlRpcRequestProcessor.cc +++ b/src/Xml2XmlRpcRequestProcessor.cc @@ -48,11 +48,11 @@ namespace aria2 { namespace xmlrpc { struct SessionData { - XmlRpcRequestParserStateMachine* _stm; + XmlRpcRequestParserStateMachine* stm_; - std::stack<std::string> _charactersStack; + std::stack<std::string> charactersStack_; - SessionData(XmlRpcRequestParserStateMachine* stm):_stm(stm) {} + SessionData(XmlRpcRequestParserStateMachine* stm):stm_(stm) {} }; static void mlStartElement(void* userData, const xmlChar* name, @@ -73,9 +73,9 @@ static void mlStartElement(void* userData, const xmlChar* name, attrmap[name] = value; } } - sd->_stm->beginElement(reinterpret_cast<const char*>(name), attrmap); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.push(std::string()); + sd->stm_->beginElement(reinterpret_cast<const char*>(name), attrmap); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.push(std::string()); } } @@ -83,18 +83,18 @@ static void mlEndElement(void* userData, const xmlChar* name) { SessionData* sd = reinterpret_cast<SessionData*>(userData); std::string characters; - if(sd->_stm->needsCharactersBuffering()) { - characters = util::trim(sd->_charactersStack.top()); - sd->_charactersStack.pop(); + if(sd->stm_->needsCharactersBuffering()) { + characters = util::trim(sd->charactersStack_.top()); + sd->charactersStack_.pop(); } - sd->_stm->endElement(reinterpret_cast<const char*>(name), characters); + sd->stm_->endElement(reinterpret_cast<const char*>(name), characters); } static void mlCharacters(void* userData, const xmlChar* ch, int len) { SessionData* sd = reinterpret_cast<SessionData*>(userData); - if(sd->_stm->needsCharactersBuffering()) { - sd->_charactersStack.top() += std::string(&ch[0], &ch[len]); + if(sd->stm_->needsCharactersBuffering()) { + sd->charactersStack_.top() += std::string(&ch[0], &ch[len]); } } @@ -137,19 +137,19 @@ static xmlSAXHandler mySAXHandler = XmlRpcRequest XmlRpcRequestProcessor::parseMemory(const std::string& xml) { - _stm.reset(new XmlRpcRequestParserStateMachine()); - SharedHandle<SessionData> sessionData(new SessionData(_stm.get())); + stm_.reset(new XmlRpcRequestParserStateMachine()); + SharedHandle<SessionData> sessionData(new SessionData(stm_.get())); int r = xmlSAXUserParseMemory(&mySAXHandler, sessionData.get(), xml.data(), xml.size()); if(r != 0) { throw DL_ABORT_EX(MSG_CANNOT_PARSE_XML_RPC_REQUEST); } - if(!asList(_stm->getCurrentFrameValue())) { + if(!asList(stm_->getCurrentFrameValue())) { throw DL_ABORT_EX("Bad XML-RPC parameter list"); } - return XmlRpcRequest(_stm->getMethodName(), - static_pointer_cast<List>(_stm->getCurrentFrameValue())); + return XmlRpcRequest(stm_->getMethodName(), + static_pointer_cast<List>(stm_->getCurrentFrameValue())); } } // namespace xmlrpc diff --git a/src/Xml2XmlRpcRequestProcessor.h b/src/Xml2XmlRpcRequestProcessor.h index f6eb59a1..cb4e413d 100644 --- a/src/Xml2XmlRpcRequestProcessor.h +++ b/src/Xml2XmlRpcRequestProcessor.h @@ -50,7 +50,7 @@ class XmlRpcRequestParserStateMachine; class XmlRpcRequestProcessor { private: - SharedHandle<XmlRpcRequestParserStateMachine> _stm; + SharedHandle<XmlRpcRequestParserStateMachine> stm_; public: XmlRpcRequest parseMemory(const std::string& xml); }; diff --git a/src/XmlRpcMethod.cc b/src/XmlRpcMethod.cc index 351dc836..fc305fdf 100644 --- a/src/XmlRpcMethod.cc +++ b/src/XmlRpcMethod.cc @@ -58,8 +58,8 @@ namespace aria2 { namespace xmlrpc { XmlRpcMethod::XmlRpcMethod(): - _optionParser(OptionParser::getInstance()), - _logger(LogFactory::getInstance()) {} + optionParser_(OptionParser::getInstance()), + logger_(LogFactory::getInstance()) {} SharedHandle<ValueBase> XmlRpcMethod::createErrorResponse (const Exception& e) @@ -76,8 +76,8 @@ XmlRpcResponse XmlRpcMethod::execute try { return XmlRpcResponse(0, process(req, e)); } catch(RecoverableException& e) { - if(_logger->debug()) { - _logger->debug(EX_EXCEPTION_CAUGHT, e); + if(logger_->debug()) { + logger_->debug(EX_EXCEPTION_CAUGHT, e); } return XmlRpcResponse(1, createErrorResponse(e)); } @@ -133,7 +133,7 @@ void XmlRpcMethod::gatherRequestOption if(optionsDict) { gatherOption(optionsDict->begin(), optionsDict->end(), listRequestOptions(), - option, _optionParser); + option, optionParser_); } } @@ -170,7 +170,7 @@ void XmlRpcMethod::gatherChangeableOption if(optionsDict) { gatherOption(optionsDict->begin(), optionsDict->end(), listChangeableOptions(), - option, _optionParser); + option, optionParser_); } } @@ -197,7 +197,7 @@ void XmlRpcMethod::gatherChangeableGlobalOption if(optionsDict) { gatherOption(optionsDict->begin(), optionsDict->end(), listChangeableGlobalOptions(), - option, _optionParser); + option, optionParser_); } } diff --git a/src/XmlRpcMethod.h b/src/XmlRpcMethod.h index e4c96297..75a1ee26 100644 --- a/src/XmlRpcMethod.h +++ b/src/XmlRpcMethod.h @@ -64,9 +64,9 @@ struct XmlRpcResponse; // it to XmlRpcMethodFactory. class XmlRpcMethod { private: - SharedHandle<OptionParser> _optionParser; + SharedHandle<OptionParser> optionParser_; - Logger* _logger; + Logger* logger_; protected: // Subclass must implement this function to fulfil XmlRpcRequest // req. The return value of this method is used as a return value @@ -95,7 +95,7 @@ protected: const SharedHandle<OptionParser>& getOptionParser() const { - return _optionParser; + return optionParser_; } public: XmlRpcMethod(); diff --git a/src/XmlRpcMethodImpl.cc b/src/XmlRpcMethodImpl.cc index e169e639..d310b372 100644 --- a/src/XmlRpcMethodImpl.cc +++ b/src/XmlRpcMethodImpl.cc @@ -644,7 +644,7 @@ static void gatherProgressBitTorrent if(btObject.isNull()) { entryDict->put(KEY_NUM_SEEDERS, VLB_ZERO); } else { - SharedHandle<PeerStorage> peerStorage = btObject._peerStorage; + SharedHandle<PeerStorage> peerStorage = btObject.peerStorage_; assert(!peerStorage.isNull()); std::vector<SharedHandle<Peer> > peers; peerStorage->getActivePeers(peers); @@ -805,8 +805,8 @@ SharedHandle<ValueBase> GetPeersXmlRpcMethod::process SharedHandle<List> peers = List::g(); BtObject btObject = e->getBtRegistry()->get(group->getGID()); if(!btObject.isNull()) { - assert(!btObject._peerStorage.isNull()); - gatherPeer(peers, btObject._peerStorage); + assert(!btObject.peerStorage_.isNull()); + gatherPeer(peers, btObject.peerStorage_); } return peers; } @@ -931,7 +931,7 @@ SharedHandle<ValueBase> ChangeOptionXmlRpcMethod::process BtObject btObject = e->getBtRegistry()->get(group->getGID()); if(!btObject.isNull()) { if(option->defined(PREF_BT_MAX_PEERS)) { - btObject._btRuntime->setMaxPeers(option->getAsInt(PREF_BT_MAX_PEERS)); + btObject.btRuntime_->setMaxPeers(option->getAsInt(PREF_BT_MAX_PEERS)); } } #endif // ENABLE_BITTORRENT diff --git a/src/XmlRpcRequestParserController.cc b/src/XmlRpcRequestParserController.cc index 30a31155..c24e4210 100644 --- a/src/XmlRpcRequestParserController.cc +++ b/src/XmlRpcRequestParserController.cc @@ -42,54 +42,54 @@ namespace xmlrpc { void XmlRpcRequestParserController::pushFrame() { - _frameStack.push(_currentFrame); - _currentFrame = StateFrame(); + frameStack_.push(currentFrame_); + currentFrame_ = StateFrame(); } void XmlRpcRequestParserController::popStructFrame() { - assert(!_frameStack.empty()); + assert(!frameStack_.empty()); - StateFrame parentFrame = _frameStack.top(); - Dict* dict = asDict(parentFrame._value); + StateFrame parentFrame = frameStack_.top(); + Dict* dict = asDict(parentFrame.value_); assert(dict); - _frameStack.pop(); - if(_currentFrame.validMember()) { - dict->put(_currentFrame._name, _currentFrame._value); + frameStack_.pop(); + if(currentFrame_.validMember()) { + dict->put(currentFrame_.name_, currentFrame_.value_); } - _currentFrame = parentFrame; + currentFrame_ = parentFrame; } void XmlRpcRequestParserController::popArrayFrame() { - assert(!_frameStack.empty()); + assert(!frameStack_.empty()); - StateFrame parentFrame = _frameStack.top(); - List* list = asList(parentFrame._value); + StateFrame parentFrame = frameStack_.top(); + List* list = asList(parentFrame.value_); assert(list); - _frameStack.pop(); - if(!_currentFrame._value.isNull()) { - list->append(_currentFrame._value); + frameStack_.pop(); + if(!currentFrame_.value_.isNull()) { + list->append(currentFrame_.value_); } - _currentFrame = parentFrame; + currentFrame_ = parentFrame; } void XmlRpcRequestParserController::setCurrentFrameValue (const SharedHandle<ValueBase>& value) { - _currentFrame._value = value; + currentFrame_.value_ = value; } void XmlRpcRequestParserController::setCurrentFrameName (const std::string& name) { - _currentFrame._name = name; + currentFrame_.name_ = name; } const SharedHandle<ValueBase>& XmlRpcRequestParserController::getCurrentFrameValue() const { - return _currentFrame._value; + return currentFrame_.value_; } } // namespace xmlrpc diff --git a/src/XmlRpcRequestParserController.h b/src/XmlRpcRequestParserController.h index b5c4832e..1dae11b3 100644 --- a/src/XmlRpcRequestParserController.h +++ b/src/XmlRpcRequestParserController.h @@ -50,29 +50,29 @@ class XmlRpcRequestParserController { private: struct StateFrame { - SharedHandle<ValueBase> _value; - std::string _name; + SharedHandle<ValueBase> value_; + std::string name_; bool validMember() const { - return !_value.isNull() && !_name.empty(); + return !value_.isNull() && !name_.empty(); } }; - std::stack<StateFrame> _frameStack; + std::stack<StateFrame> frameStack_; - StateFrame _currentFrame; + StateFrame currentFrame_; - std::string _methodName; + std::string methodName_; public: void pushFrame(); - // Pops StateFrame p from _frameStack and set p[_currentFrame._name] - // = _currentFrame._value and _currentFrame = p; + // Pops StateFrame p from frameStack_ and set p[currentFrame_.name_] + // = currentFrame_.value_ and currentFrame_ = p; void popStructFrame(); - // Pops StateFrame p from _frameStack and add _currentFrame._value - // to p and _currentFrame = p; + // Pops StateFrame p from frameStack_ and add currentFrame_.value_ + // to p and currentFrame_ = p; void popArrayFrame(); void setCurrentFrameValue(const SharedHandle<ValueBase>& value); @@ -83,10 +83,10 @@ public: void setMethodName(const std::string& methodName) { - _methodName = methodName; + methodName_ = methodName; } - const std::string& getMethodName() const { return _methodName; } + const std::string& getMethodName() const { return methodName_; } }; } // namespace xmlrpc diff --git a/src/XmlRpcRequestParserStateMachine.cc b/src/XmlRpcRequestParserStateMachine.cc index 32ccb1f6..33cea480 100644 --- a/src/XmlRpcRequestParserStateMachine.cc +++ b/src/XmlRpcRequestParserStateMachine.cc @@ -39,78 +39,78 @@ namespace aria2 { namespace xmlrpc { InitialXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_initialState = +XmlRpcRequestParserStateMachine::initialState_ = new InitialXmlRpcRequestParserState(); UnknownElementXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_unknownElementState = +XmlRpcRequestParserStateMachine::unknownElementState_ = new UnknownElementXmlRpcRequestParserState(); MethodCallXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_methodCallState = +XmlRpcRequestParserStateMachine::methodCallState_ = new MethodCallXmlRpcRequestParserState(); MethodNameXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_methodNameState = +XmlRpcRequestParserStateMachine::methodNameState_ = new MethodNameXmlRpcRequestParserState(); ParamsXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_paramsState = +XmlRpcRequestParserStateMachine::paramsState_ = new ParamsXmlRpcRequestParserState(); ParamXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_paramState = +XmlRpcRequestParserStateMachine::paramState_ = new ParamXmlRpcRequestParserState(); ValueXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_valueState = +XmlRpcRequestParserStateMachine::valueState_ = new ValueXmlRpcRequestParserState(); IntXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_intState = +XmlRpcRequestParserStateMachine::intState_ = new IntXmlRpcRequestParserState(); StringXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_stringState = +XmlRpcRequestParserStateMachine::stringState_ = new StringXmlRpcRequestParserState(); Base64XmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_base64State = +XmlRpcRequestParserStateMachine::base64State_ = new Base64XmlRpcRequestParserState(); StructXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_structState = +XmlRpcRequestParserStateMachine::structState_ = new StructXmlRpcRequestParserState(); MemberXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_memberState = +XmlRpcRequestParserStateMachine::memberState_ = new MemberXmlRpcRequestParserState(); NameXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_nameState = +XmlRpcRequestParserStateMachine::nameState_ = new NameXmlRpcRequestParserState(); ArrayXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_arrayState = +XmlRpcRequestParserStateMachine::arrayState_ = new ArrayXmlRpcRequestParserState(); DataXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_dataState = +XmlRpcRequestParserStateMachine::dataState_ = new DataXmlRpcRequestParserState(); ArrayValueXmlRpcRequestParserState* -XmlRpcRequestParserStateMachine::_arrayValueState = +XmlRpcRequestParserStateMachine::arrayValueState_ = new ArrayValueXmlRpcRequestParserState(); XmlRpcRequestParserStateMachine::XmlRpcRequestParserStateMachine(): - _controller(new XmlRpcRequestParserController()) + controller_(new XmlRpcRequestParserController()) { - _stateStack.push(_initialState); + stateStack_.push(initialState_); } XmlRpcRequestParserStateMachine::~XmlRpcRequestParserStateMachine() { - delete _controller; + delete controller_; } } // namespace xmlrpc diff --git a/src/XmlRpcRequestParserStateMachine.h b/src/XmlRpcRequestParserStateMachine.h index ff308cfe..4923c041 100644 --- a/src/XmlRpcRequestParserStateMachine.h +++ b/src/XmlRpcRequestParserStateMachine.h @@ -51,27 +51,27 @@ namespace xmlrpc { class XmlRpcRequestParserStateMachine { private: - XmlRpcRequestParserController* _controller; - - std::stack<XmlRpcRequestParserState*> _stateStack; - - static InitialXmlRpcRequestParserState* _initialState; - static MethodCallXmlRpcRequestParserState* _methodCallState; - static MethodNameXmlRpcRequestParserState* _methodNameState; - static ParamsXmlRpcRequestParserState* _paramsState; - static ParamXmlRpcRequestParserState* _paramState; - static ValueXmlRpcRequestParserState* _valueState; - static IntXmlRpcRequestParserState* _intState; - static StringXmlRpcRequestParserState* _stringState; - static Base64XmlRpcRequestParserState* _base64State; - static StructXmlRpcRequestParserState* _structState; - static MemberXmlRpcRequestParserState* _memberState; - static NameXmlRpcRequestParserState* _nameState; - static ArrayXmlRpcRequestParserState* _arrayState; - static DataXmlRpcRequestParserState* _dataState; - static ArrayValueXmlRpcRequestParserState* _arrayValueState; + XmlRpcRequestParserController* controller_; + + std::stack<XmlRpcRequestParserState*> stateStack_; + + static InitialXmlRpcRequestParserState* initialState_; + static MethodCallXmlRpcRequestParserState* methodCallState_; + static MethodNameXmlRpcRequestParserState* methodNameState_; + static ParamsXmlRpcRequestParserState* paramsState_; + static ParamXmlRpcRequestParserState* paramState_; + static ValueXmlRpcRequestParserState* valueState_; + static IntXmlRpcRequestParserState* intState_; + static StringXmlRpcRequestParserState* stringState_; + static Base64XmlRpcRequestParserState* base64State_; + static StructXmlRpcRequestParserState* structState_; + static MemberXmlRpcRequestParserState* memberState_; + static NameXmlRpcRequestParserState* nameState_; + static ArrayXmlRpcRequestParserState* arrayState_; + static DataXmlRpcRequestParserState* dataState_; + static ArrayValueXmlRpcRequestParserState* arrayValueState_; - static UnknownElementXmlRpcRequestParserState* _unknownElementState; + static UnknownElementXmlRpcRequestParserState* unknownElementState_; public: XmlRpcRequestParserStateMachine(); @@ -80,89 +80,89 @@ public: void beginElement(const std::string& name, const std::map<std::string, std::string>& attrs) { - _stateStack.top()->beginElement(this, name, attrs); + stateStack_.top()->beginElement(this, name, attrs); } void endElement(const std::string& name, const std::string& characters) { - _stateStack.top()->endElement(this, name, characters); - _stateStack.pop(); + stateStack_.top()->endElement(this, name, characters); + stateStack_.pop(); } void setMethodName(const std::string& methodName) { - _controller->setMethodName(methodName); + controller_->setMethodName(methodName); } const std::string& getMethodName() const { - return _controller->getMethodName(); + return controller_->getMethodName(); } void popArrayFrame() { - _controller->popArrayFrame(); + controller_->popArrayFrame(); } void popStructFrame() { - _controller->popStructFrame(); + controller_->popStructFrame(); } void pushFrame() { - _controller->pushFrame(); + controller_->pushFrame(); } void setCurrentFrameValue(const SharedHandle<ValueBase>& value) { - _controller->setCurrentFrameValue(value); + controller_->setCurrentFrameValue(value); } const SharedHandle<ValueBase>& getCurrentFrameValue() const { - return _controller->getCurrentFrameValue(); + return controller_->getCurrentFrameValue(); } void setCurrentFrameName(const std::string& name) { - _controller->setCurrentFrameName(name); + controller_->setCurrentFrameName(name); } bool needsCharactersBuffering() const { - return _stateStack.top()->needsCharactersBuffering(); + return stateStack_.top()->needsCharactersBuffering(); } - void pushUnknownElementState() { _stateStack.push(_unknownElementState); } + void pushUnknownElementState() { stateStack_.push(unknownElementState_); } - void pushMethodCallState() { _stateStack.push(_methodCallState); } + void pushMethodCallState() { stateStack_.push(methodCallState_); } - void pushMethodNameState() { _stateStack.push(_methodNameState); } + void pushMethodNameState() { stateStack_.push(methodNameState_); } - void pushParamsState() { _stateStack.push(_paramsState); } + void pushParamsState() { stateStack_.push(paramsState_); } - void pushParamState() { _stateStack.push(_paramState); } + void pushParamState() { stateStack_.push(paramState_); } - void pushValueState() { _stateStack.push(_valueState); } + void pushValueState() { stateStack_.push(valueState_); } - void pushIntState() { _stateStack.push(_intState); } + void pushIntState() { stateStack_.push(intState_); } - void pushStringState() { _stateStack.push(_stringState); } + void pushStringState() { stateStack_.push(stringState_); } - void pushBase64State() { _stateStack.push(_base64State); } + void pushBase64State() { stateStack_.push(base64State_); } - void pushStructState() { _stateStack.push(_structState); } + void pushStructState() { stateStack_.push(structState_); } - void pushMemberState() { _stateStack.push(_memberState); } + void pushMemberState() { stateStack_.push(memberState_); } - void pushNameState() { _stateStack.push(_nameState); } + void pushNameState() { stateStack_.push(nameState_); } - void pushArrayState() { _stateStack.push(_arrayState); } + void pushArrayState() { stateStack_.push(arrayState_); } - void pushDataState() { _stateStack.push(_dataState); } + void pushDataState() { stateStack_.push(dataState_); } - void pushArrayValueState() { _stateStack.push(_arrayValueState); } + void pushArrayValueState() { stateStack_.push(arrayValueState_); } }; } // namespace xmlrpc diff --git a/src/a2functional.h b/src/a2functional.h index 2e83667e..d75e01e9 100644 --- a/src/a2functional.h +++ b/src/a2functional.h @@ -120,17 +120,17 @@ class adopt2nd_t:public std::binary_function<typename BinaryOp::first_argument_t typename UnaryOp::argument_type, typename BinaryOp::result_type> { private: - BinaryOp _binaryOp; - UnaryOp _unaryOp; + BinaryOp binaryOp_; + UnaryOp unaryOp_; public: adopt2nd_t(const BinaryOp& b, const UnaryOp& u): - _binaryOp(b), _unaryOp(u) {} + binaryOp_(b), unaryOp_(u) {} typename BinaryOp::result_type operator()(const typename BinaryOp::first_argument_type& x, const typename UnaryOp::argument_type& y) { - return _binaryOp(x, _unaryOp(y)); + return binaryOp_(x, unaryOp_(y)); } }; @@ -178,15 +178,15 @@ public: template<typename T> class Append { private: - T& _to; - T _delim; + T& to_; + T delim_; public: template<typename S> - Append(T& to, const S& delim):_to(to), _delim(delim) {} + Append(T& to, const S& delim):to_(to), delim_(delim) {} template<typename S> void operator()(const S& s) { - _to += s+_delim; + to_ += s+delim_; } }; @@ -195,28 +195,28 @@ typedef Append<std::string> StringAppend; template<typename T> class auto_delete { private: - T _obj; - void (*_deleter)(T); + T obj_; + void (*deleter_)(T); public: - auto_delete(T obj, void (*deleter)(T)):_obj(obj), _deleter(deleter) {} + auto_delete(T obj, void (*deleter)(T)):obj_(obj), deleter_(deleter) {} ~auto_delete() { - _deleter(_obj); + deleter_(obj_); } }; template<class Container> class auto_delete_container { private: - Container* _c; + Container* c_; public: - auto_delete_container(Container* c):_c(c) {} + auto_delete_container(Container* c):c_(c) {} ~auto_delete_container() { - std::for_each(_c->begin(), _c->end(), Deleter()); - delete _c; + std::for_each(c_->begin(), c_->end(), Deleter()); + delete c_; } }; diff --git a/src/a2netcompat.h b/src/a2netcompat.h index b89ea8b5..2d81a296 100644 --- a/src/a2netcompat.h +++ b/src/a2netcompat.h @@ -110,15 +110,15 @@ template<typename T> class wsaapi_auto_delete { private: - T _obj; - void (WSAAPI*_deleter)(T); + T obj_; + void (WSAAPI*deleter_)(T); public: wsaapi_auto_delete(T obj, void (WSAAPI*deleter)(T)): - _obj(obj), _deleter(deleter) {} + obj_(obj), deleter_(deleter) {} ~wsaapi_auto_delete() { - _deleter(_obj); + deleter_(obj_); } }; # define WSAAPI_AUTO_DELETE wsaapi_auto_delete diff --git a/src/array_fun.h b/src/array_fun.h index 87d14430..4e4951b4 100644 --- a/src/array_fun.h +++ b/src/array_fun.h @@ -66,7 +66,7 @@ T* vend(T (&a)[N]) template<typename T> class array_ptr { private: - T* _array; + T* array_; // Copies are not allowed. Let's make them private. array_ptr(const array_ptr& s); @@ -77,41 +77,41 @@ private: array_ptr& operator=(const array_ptr<S>& s); public: - array_ptr():_array(0) {} + array_ptr():array_(0) {} - explicit array_ptr(T* array):_array(array) {} + explicit array_ptr(T* array):array_(array) {} ~array_ptr() { - delete [] _array; + delete [] array_; } operator T*() { - return _array; + return array_; } operator const T*() const { - return _array; + return array_; } }; template<typename T, size_t N> class array_wrapper { private: - T _array[N]; + T array_[N]; public: array_wrapper() {} operator T*() { - return _array; + return array_; } operator const T*() const { - return _array; + return array_; } size_t size() const @@ -126,31 +126,31 @@ namespace expr { template<typename L, typename OpTag, typename R> struct BinExpr { - BinExpr(const L& l, const R& r):_l(l), _r(r) {} + BinExpr(const L& l, const R& r):l_(l), r_(r) {} typedef typename OpTag::returnType returnType; returnType operator[](size_t index) const { - return OpTag::apply(_l[index], _r[index]); + return OpTag::apply(l_[index], r_[index]); } - const L& _l; - const R& _r; + const L& l_; + const R& r_; }; template<typename OpTag, typename A> struct UnExpr { - UnExpr(const A& a):_a(a) {} + UnExpr(const A& a):a_(a) {} typedef typename OpTag::returnType returnType; returnType operator[](size_t index) const { - return OpTag::apply(_a[index]); + return OpTag::apply(a_[index]); } - const A& _a; + const A& a_; }; template<typename T> @@ -179,11 +179,11 @@ struct Array { typedef T returnType; - Array(const T* t):_t(t) {} + Array(const T* t):t_(t) {} - const T* _t; + const T* t_; - returnType operator[](size_t index) const { return _t[index]; } + returnType operator[](size_t index) const { return t_[index]; } }; template<typename T> diff --git a/src/download_helper.cc b/src/download_helper.cc index 16a2de78..accbf00c 100644 --- a/src/download_helper.cc +++ b/src/download_helper.cc @@ -335,46 +335,46 @@ void createRequestGroupForMetalink class AccRequestGroup { private: - std::vector<SharedHandle<RequestGroup> >& _requestGroups; - ProtocolDetector _detector; - SharedHandle<Option> _option; - bool _ignoreLocalPath; + std::vector<SharedHandle<RequestGroup> >& requestGroups_; + ProtocolDetector detector_; + SharedHandle<Option> option_; + bool ignoreLocalPath_; public: AccRequestGroup(std::vector<SharedHandle<RequestGroup> >& requestGroups, const SharedHandle<Option>& option, bool ignoreLocalPath = false): - _requestGroups(requestGroups), _option(option), - _ignoreLocalPath(ignoreLocalPath) {} + requestGroups_(requestGroups), option_(option), + ignoreLocalPath_(ignoreLocalPath) {} void operator()(const std::string& uri) { - if(_detector.isStreamProtocol(uri)) { + if(detector_.isStreamProtocol(uri)) { std::vector<std::string> streamURIs; - size_t numSplit = _option->getAsInt(PREF_SPLIT); + size_t numSplit = option_->getAsInt(PREF_SPLIT); for(size_t i = 0; i < numSplit; ++i) { streamURIs.push_back(uri); } SharedHandle<RequestGroup> rg = - createRequestGroup(_option, streamURIs); + createRequestGroup(option_, streamURIs); rg->setNumConcurrentCommand(numSplit); - _requestGroups.push_back(rg); + requestGroups_.push_back(rg); } #ifdef ENABLE_BITTORRENT - else if(_detector.guessTorrentMagnet(uri)) { + else if(detector_.guessTorrentMagnet(uri)) { try { SharedHandle<RequestGroup> group = - createBtMagnetRequestGroup(uri, _option, std::vector<std::string>()); - _requestGroups.push_back(group); + createBtMagnetRequestGroup(uri, option_, std::vector<std::string>()); + requestGroups_.push_back(group); } catch(RecoverableException& e) { // error occurred while parsing torrent file. // We simply ignore it. LogFactory::getInstance()->error(EX_EXCEPTION_CAUGHT, e); } - } else if(!_ignoreLocalPath && _detector.guessTorrentFile(uri)) { + } else if(!ignoreLocalPath_ && detector_.guessTorrentFile(uri)) { try { - _requestGroups.push_back - (createBtRequestGroup(uri, _option, std::vector<std::string>())); + requestGroups_.push_back + (createBtRequestGroup(uri, option_, std::vector<std::string>())); } catch(RecoverableException& e) { // error occurred while parsing torrent file. // We simply ignore it. @@ -383,9 +383,9 @@ public: } #endif // ENABLE_BITTORRENT #ifdef ENABLE_METALINK - else if(!_ignoreLocalPath && _detector.guessMetalinkFile(uri)) { + else if(!ignoreLocalPath_ && detector_.guessMetalinkFile(uri)) { try { - Metalink2RequestGroup().generate(_requestGroups, uri, _option); + Metalink2RequestGroup().generate(requestGroups_, uri, option_); } catch(RecoverableException& e) { // error occurred while parsing metalink file. // We simply ignore it. @@ -401,10 +401,10 @@ public: class StreamProtocolFilter { private: - ProtocolDetector _detector; + ProtocolDetector detector_; public: bool operator()(const std::string& uri) { - return _detector.isStreamProtocol(uri); + return detector_.isStreamProtocol(uri); } }; diff --git a/src/messageDigest.cc b/src/messageDigest.cc index 0e4e8d89..ff52d108 100644 --- a/src/messageDigest.cc +++ b/src/messageDigest.cc @@ -103,7 +103,7 @@ std::string MessageDigestContext::getCanonicalAlgo std::string MessageDigestContext::digestFinal() { - size_t length = digestLength(_algo); + size_t length = digestLength(algo_); unsigned char* rawMD = new unsigned char[length]; digestFinal(rawMD); std::string rawMDString(&rawMD[0], &rawMD[length]); diff --git a/src/messageDigest.h b/src/messageDigest.h index 0a24798f..590183b6 100644 --- a/src/messageDigest.h +++ b/src/messageDigest.h @@ -70,14 +70,14 @@ public: static const std::string MD5; private: #ifdef HAVE_LIBSSL - EVP_MD_CTX _ctx; + EVP_MD_CTX ctx_; #endif // HAVE_LIBSSL #ifdef HAVE_LIBGCRYPT - gcry_md_hd_t _ctx; + gcry_md_hd_t ctx_; #endif // HAVE_LIBGCRYPT - DigestAlgo _algo; + DigestAlgo algo_; public: - MessageDigestContext():_algo(getDigestAlgo(MessageDigestContext::SHA1)) + MessageDigestContext():algo_(getDigestAlgo(MessageDigestContext::SHA1)) {} ~MessageDigestContext() @@ -87,7 +87,7 @@ public: void trySetAlgo(const std::string& algostring) { - _algo = getDigestAlgo(algostring); + algo_ = getDigestAlgo(algostring); } static bool supports(const std::string& algostring); @@ -119,26 +119,26 @@ public: #if defined(HAVE_OLD_LIBSSL) void digestInit() { - EVP_DigestInit(&_ctx, _algo); + EVP_DigestInit(&ctx_, algo_); } void digestReset() { - EVP_DigestInit(&_ctx, _algo); + EVP_DigestInit(&ctx_, algo_); } void digestUpdate(const void* data, size_t length) { - EVP_DigestUpdate(&_ctx, data, length); + EVP_DigestUpdate(&ctx_, data, length); } void digestFinal(unsigned char* md) { unsigned int len; - EVP_DigestFinal(&_ctx, md, &len); + EVP_DigestFinal(&ctx_, md, &len); } void digestFree() {/*empty*/} size_t digestLength() const { - return digestLength(_algo); + return digestLength(algo_); } static size_t digestLength(DigestAlgo algo) { return EVP_MD_size(algo); @@ -146,24 +146,24 @@ public: #elif defined(HAVE_LIBSSL) void digestInit() { - EVP_MD_CTX_init(&_ctx); + EVP_MD_CTX_init(&ctx_); digestReset(); } void digestReset() { - EVP_DigestInit_ex(&_ctx, _algo, 0); + EVP_DigestInit_ex(&ctx_, algo_, 0); } void digestUpdate(const void* data, size_t length) { - EVP_DigestUpdate(&_ctx, data, length); + EVP_DigestUpdate(&ctx_, data, length); } void digestFinal(unsigned char* md) { unsigned int len; - EVP_DigestFinal_ex(&_ctx, md, &len); + EVP_DigestFinal_ex(&ctx_, md, &len); } void digestFree() { - EVP_MD_CTX_cleanup(&_ctx); + EVP_MD_CTX_cleanup(&ctx_); } size_t digestLength() const { - return digestLength(_algo); + return digestLength(algo_); } static size_t digestLength(DigestAlgo algo) { return EVP_MD_size(algo); @@ -171,23 +171,23 @@ public: #elif defined(HAVE_LIBGCRYPT) void digestInit() { - gcry_md_open(&_ctx, _algo, 0); + gcry_md_open(&ctx_, algo_, 0); } void digestReset() { - gcry_md_reset(_ctx); + gcry_md_reset(ctx_); } void digestUpdate(const void* data, size_t length) { - gcry_md_write(_ctx, data, length); + gcry_md_write(ctx_, data, length); } void digestFinal(unsigned char* md) { - gcry_md_final(_ctx); - memcpy(md, gcry_md_read(_ctx, 0), gcry_md_get_algo_dlen(_algo)); + gcry_md_final(ctx_); + memcpy(md, gcry_md_read(ctx_, 0), gcry_md_get_algo_dlen(algo_)); } void digestFree() { - gcry_md_close(_ctx); + gcry_md_close(ctx_); } size_t digestLength() const { - return digestLength(_algo); + return digestLength(algo_); } static size_t digestLength(DigestAlgo algo) { return gcry_md_get_algo_dlen(algo); diff --git a/src/util.cc b/src/util.cc index 11f89f57..45b955c5 100644 --- a/src/util.cc +++ b/src/util.cc @@ -1272,13 +1272,13 @@ bool detectDirTraversal(const std::string& s) namespace { class EscapePath { private: - char _repChar; + char repChar_; public: - EscapePath(const char& repChar):_repChar(repChar) {} + EscapePath(const char& repChar):repChar_(repChar) {} char operator()(const char& c) { if(0x00 <= c && c <=0x1f) { - return _repChar; + return repChar_; } #ifdef __MINGW32__ // We don't escape '/' because we use it as a path separator. @@ -1286,7 +1286,7 @@ public: { '"', '*', ':', '<', '>', '?', '\\', '|' }; if(std::find(vbegin(WIN_INVALID_PATH_CHARS), vend(WIN_INVALID_PATH_CHARS), c) != vend(WIN_INVALID_PATH_CHARS)) { - return _repChar; + return repChar_; } #endif // __MINGW32__ return c; diff --git a/test/BittorrentHelperTest.cc b/test/BittorrentHelperTest.cc index b3a60cfb..b8724970 100644 --- a/test/BittorrentHelperTest.cc +++ b/test/BittorrentHelperTest.cc @@ -641,7 +641,7 @@ void BittorrentHelperTest::testEtc() getTorrentAttrs(dctx)->comment); CPPUNIT_ASSERT_EQUAL(std::string("aria2"), getTorrentAttrs(dctx)->createdBy); - CPPUNIT_ASSERT_EQUAL((int64_t)1123456789, + CPPUNIT_ASSERT_EQUAL((time_t)1123456789, getTorrentAttrs(dctx)->creationDate); } diff --git a/test/BtDependencyTest.cc b/test/BtDependencyTest.cc index 35abb018..9af0a43b 100644 --- a/test/BtDependencyTest.cc +++ b/test/BtDependencyTest.cc @@ -63,11 +63,11 @@ class BtDependencyTest:public CppUnit::TestFixture { return dependee; } - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); } void testResolve(); @@ -86,9 +86,9 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtDependencyTest ); void BtDependencyTest::testResolve() { std::string filename = "single.torrent"; - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); SharedHandle<RequestGroup> dependee = - createDependee(_option, filename, File(filename).size()); + createDependee(option_, filename, File(filename).size()); dependee->getPieceStorage()->markAllPiecesDone(); BtDependency dep(dependant, dependee); @@ -108,11 +108,11 @@ void BtDependencyTest::testResolve() void BtDependencyTest::testResolve_originalNameNoMatch() { std::string filename = "single.torrent"; - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); dependant->getDownloadContext()->getFirstFileEntry()->setOriginalName ("aria2-1.1.0.tar.bz2"); SharedHandle<RequestGroup> dependee = - createDependee(_option, filename, File(filename).size()); + createDependee(option_, filename, File(filename).size()); dependee->getPieceStorage()->markAllPiecesDone(); BtDependency dep(dependant, dependee); @@ -125,10 +125,10 @@ void BtDependencyTest::testResolve_originalNameNoMatch() void BtDependencyTest::testResolve_singleFileWithoutOriginalName() { std::string filename = "single.torrent"; - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); dependant->getDownloadContext()->getFirstFileEntry()->setOriginalName(""); SharedHandle<RequestGroup> dependee = - createDependee(_option, filename, File(filename).size()); + createDependee(option_, filename, File(filename).size()); dependee->getPieceStorage()->markAllPiecesDone(); BtDependency dep(dependant, dependee); CPPUNIT_ASSERT(dep.resolve()); @@ -139,11 +139,11 @@ void BtDependencyTest::testResolve_singleFileWithoutOriginalName() void BtDependencyTest::testResolve_multiFile() { std::string filename = "test.torrent"; - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); dependant->getDownloadContext()->getFirstFileEntry()->setOriginalName ("aria2-test/aria2/src/aria2c"); SharedHandle<RequestGroup> dependee = - createDependee(_option, filename, File(filename).size()); + createDependee(option_, filename, File(filename).size()); dependee->getPieceStorage()->markAllPiecesDone(); BtDependency dep(dependant, dependee); @@ -164,9 +164,9 @@ void BtDependencyTest::testResolve_multiFile() void BtDependencyTest::testResolve_metadata() { - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); SharedHandle<RequestGroup> dependee = - createDependee(_option, "metadata", 0); + createDependee(option_, "metadata", 0); SharedHandle<DirectDiskAdaptor> diskAdaptor(new DirectDiskAdaptor()); SharedHandle<ByteArrayDiskWriter> diskWriter(new ByteArrayDiskWriter()); @@ -194,9 +194,9 @@ void BtDependencyTest::testResolve_metadata() void BtDependencyTest::testResolve_loadError() { - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); SharedHandle<RequestGroup> dependee = - createDependee(_option, "notExist", 40); + createDependee(option_, "notExist", 40); dependee->getPieceStorage()->markAllPiecesDone(); BtDependency dep(dependant, dependee); @@ -210,8 +210,8 @@ void BtDependencyTest::testResolve_loadError() void BtDependencyTest::testResolve_dependeeFailure() { - SharedHandle<RequestGroup> dependant = createDependant(_option); - SharedHandle<RequestGroup> dependee = createDependee(_option, "notExist", 40); + SharedHandle<RequestGroup> dependant = createDependant(option_); + SharedHandle<RequestGroup> dependee = createDependee(option_, "notExist", 40); BtDependency dep(dependant, dependee); CPPUNIT_ASSERT(dep.resolve()); @@ -225,9 +225,9 @@ void BtDependencyTest::testResolve_dependeeFailure() void BtDependencyTest::testResolve_dependeeInProgress() { std::string filename = "single.torrent"; - SharedHandle<RequestGroup> dependant = createDependant(_option); + SharedHandle<RequestGroup> dependant = createDependant(option_); SharedHandle<RequestGroup> dependee = - createDependee(_option, filename, File(filename).size()); + createDependee(option_, filename, File(filename).size()); dependee->increaseNumCommand(); BtDependency dep(dependant, dependee); diff --git a/test/BtExtendedMessageTest.cc b/test/BtExtendedMessageTest.cc index 723e8193..a8bceff2 100644 --- a/test/BtExtendedMessageTest.cc +++ b/test/BtExtendedMessageTest.cc @@ -92,7 +92,7 @@ void BtExtendedMessageTest::testDoReceivedAction() { (new MockExtensionMessage("charlie", 1, "")); BtExtendedMessage msg(exmsg); msg.doReceivedAction(); - CPPUNIT_ASSERT(exmsg->_doReceivedActionCalled); + CPPUNIT_ASSERT(exmsg->doReceivedActionCalled_); } void BtExtendedMessageTest::testToString() { diff --git a/test/BtPieceMessageTest.cc b/test/BtPieceMessageTest.cc index 93c58cd4..881057fd 100644 --- a/test/BtPieceMessageTest.cc +++ b/test/BtPieceMessageTest.cc @@ -72,30 +72,30 @@ public: } }; - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; SharedHandle<MockBtMessageDispatcher> btMessageDispatcher; - SharedHandle<MockBtMessageFactory> _btMessageFactory; + SharedHandle<MockBtMessageFactory> btMessageFactory_; SharedHandle<Peer> peer; SharedHandle<BtPieceMessage> msg; void setUp() { - _dctx.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file")); + dctx_.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file")); peer.reset(new Peer("host", 6969)); - peer->allocateSessionResource(_dctx->getPieceLength(), - _dctx->getTotalLength()); + peer->allocateSessionResource(dctx_->getPieceLength(), + dctx_->getTotalLength()); btMessageDispatcher.reset(new MockBtMessageDispatcher()); - _btMessageFactory.reset(new MockBtMessageFactory2()); + btMessageFactory_.reset(new MockBtMessageFactory2()); msg.reset(new BtPieceMessage()); msg->setIndex(1); msg->setBegin(1024); msg->setBlockLength(16*1024); - msg->setDownloadContext(_dctx); + msg->setDownloadContext(dctx_); msg->setPeer(peer); msg->setBtMessageDispatcher(btMessageDispatcher); - msg->setBtMessageFactory(_btMessageFactory); + msg->setBtMessageFactory(btMessageFactory_); } }; diff --git a/test/BtPortMessageTest.cc b/test/BtPortMessageTest.cc index 1cff5a32..f87dccd2 100644 --- a/test/BtPortMessageTest.cc +++ b/test/BtPortMessageTest.cc @@ -130,11 +130,11 @@ void BtPortMessageTest::testDoReceivedAction() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, taskQueue._immediateTaskQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, taskQueue.immediateTaskQueue_.size()); SharedHandle<MockDHTTask> task - (dynamic_pointer_cast<MockDHTTask>(taskQueue._immediateTaskQueue[0])); - SharedHandle<DHTNode> node = task->_remoteNode; + (dynamic_pointer_cast<MockDHTTask>(taskQueue.immediateTaskQueue_[0])); + SharedHandle<DHTNode> node = task->remoteNode_; CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), node->getIPAddress()); CPPUNIT_ASSERT_EQUAL((uint16_t)6881, node->getPort()); } @@ -159,16 +159,16 @@ void BtPortMessageTest::testDoReceivedAction_bootstrap() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)2, taskQueue._immediateTaskQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)2, taskQueue.immediateTaskQueue_.size()); SharedHandle<MockDHTTask> task - (dynamic_pointer_cast<MockDHTTask>(taskQueue._immediateTaskQueue[0])); - SharedHandle<DHTNode> node(task->_remoteNode); + (dynamic_pointer_cast<MockDHTTask>(taskQueue.immediateTaskQueue_[0])); + SharedHandle<DHTNode> node(task->remoteNode_); CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), node->getIPAddress()); CPPUNIT_ASSERT_EQUAL((uint16_t)6881, node->getPort()); SharedHandle<MockDHTTask> task2 - (dynamic_pointer_cast<MockDHTTask>(taskQueue._immediateTaskQueue[1])); - CPPUNIT_ASSERT(memcmp(nodeID, task2->_targetID, DHT_ID_LENGTH) == 0); + (dynamic_pointer_cast<MockDHTTask>(taskQueue.immediateTaskQueue_[1])); + CPPUNIT_ASSERT(memcmp(nodeID, task2->targetID_, DHT_ID_LENGTH) == 0); } } // namespace aria2 diff --git a/test/BtPostDownloadHandlerTest.cc b/test/BtPostDownloadHandlerTest.cc index 3f48f31d..c7808d08 100644 --- a/test/BtPostDownloadHandlerTest.cc +++ b/test/BtPostDownloadHandlerTest.cc @@ -18,11 +18,11 @@ class BtPostDownloadHandlerTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGetNextRequestGroups); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); } void testCanHandle_extension(); @@ -36,7 +36,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( BtPostDownloadHandlerTest ); void BtPostDownloadHandlerTest::testCanHandle_extension() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test.torrent")); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); BtPostDownloadHandler handler; @@ -51,7 +51,7 @@ void BtPostDownloadHandlerTest::testCanHandle_contentType() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test")); dctx->getFirstFileEntry()->setContentType("application/x-bittorrent"); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); BtPostDownloadHandler handler; @@ -66,7 +66,7 @@ void BtPostDownloadHandlerTest::testGetNextRequestGroups() { SharedHandle<DownloadContext> dctx (new DownloadContext(1024, 0, "test.torrent")); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); rg.initPieceStorage(); diff --git a/test/BtRegistryTest.cc b/test/BtRegistryTest.cc index a2b7b392..891d9bf1 100644 --- a/test/BtRegistryTest.cc +++ b/test/BtRegistryTest.cc @@ -42,7 +42,7 @@ void BtRegistryTest::testGetDownloadContext() CPPUNIT_ASSERT(btRegistry.getDownloadContext(1).isNull()); SharedHandle<DownloadContext> dctx(new DownloadContext()); BtObject btObject; - btObject._downloadContext = dctx; + btObject.downloadContext_ = dctx; btRegistry.put(1, btObject); CPPUNIT_ASSERT_EQUAL(dctx.get(), btRegistry.getDownloadContext(1).get()); } @@ -52,9 +52,9 @@ static void addTwoDownloadContext(BtRegistry& btRegistry) SharedHandle<DownloadContext> dctx1(new DownloadContext()); SharedHandle<DownloadContext> dctx2(new DownloadContext()); BtObject btObject1; - btObject1._downloadContext = dctx1; + btObject1.downloadContext_ = dctx1; BtObject btObject2; - btObject2._downloadContext = dctx2; + btObject2.downloadContext_ = dctx2; btRegistry.put(1, btObject1); btRegistry.put(2, btObject2); } diff --git a/test/BtRequestMessageTest.cc b/test/BtRequestMessageTest.cc index 13a69784..8fd8b096 100644 --- a/test/BtRequestMessageTest.cc +++ b/test/BtRequestMessageTest.cc @@ -95,31 +95,31 @@ public: typedef SharedHandle<MockBtMessageFactory2> MockBtMessageFactory2Handle; - SharedHandle<MockPieceStorage> _pieceStorage; - SharedHandle<Peer> _peer; - SharedHandle<MockBtMessageDispatcher> _dispatcher; - SharedHandle<MockBtMessageFactory> _messageFactory; + SharedHandle<MockPieceStorage> pieceStorage_; + SharedHandle<Peer> peer_; + SharedHandle<MockBtMessageDispatcher> dispatcher_; + SharedHandle<MockBtMessageFactory> messageFactory_; SharedHandle<BtRequestMessage> msg; void setUp() { - _pieceStorage.reset(new MockPieceStorage2()); + pieceStorage_.reset(new MockPieceStorage2()); - _peer.reset(new Peer("host", 6969)); - _peer->allocateSessionResource(16*1024, 256*1024); + peer_.reset(new Peer("host", 6969)); + peer_->allocateSessionResource(16*1024, 256*1024); - _dispatcher.reset(new MockBtMessageDispatcher()); + dispatcher_.reset(new MockBtMessageDispatcher()); - _messageFactory.reset(new MockBtMessageFactory2()); + messageFactory_.reset(new MockBtMessageFactory2()); msg.reset(new BtRequestMessage()); - msg->setPeer(_peer); + msg->setPeer(peer_); msg->setIndex(1); msg->setBegin(16); msg->setLength(32); msg->setBlockIndex(2); - msg->setBtMessageDispatcher(_dispatcher); - msg->setBtMessageFactory(_messageFactory); - msg->setPieceStorage(_pieceStorage); + msg->setBtMessageDispatcher(dispatcher_); + msg->setBtMessageFactory(messageFactory_); + msg->setPieceStorage(pieceStorage_); } }; @@ -172,12 +172,12 @@ void BtRequestMessageTest::testCreateMessage() { } void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmNotChoking() { - _peer->amChoking(false); + peer_->amChoking(false); msg->doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, _dispatcher->messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size()); SharedHandle<MockBtMessage2> pieceMsg = - dynamic_pointer_cast<MockBtMessage2>(_dispatcher->messageQueue.front()); + dynamic_pointer_cast<MockBtMessage2>(dispatcher_->messageQueue.front()); CPPUNIT_ASSERT_EQUAL(std::string("piece"), pieceMsg->type); CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index); CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin); @@ -185,13 +185,13 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmNotChoking() { } void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExtensionEnabled() { - _peer->amChoking(true); - _peer->setFastExtensionEnabled(true); + peer_->amChoking(true); + peer_->setFastExtensionEnabled(true); msg->doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, _dispatcher->messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size()); SharedHandle<MockBtMessage2> pieceMsg = - dynamic_pointer_cast<MockBtMessage2>(_dispatcher->messageQueue.front()); + dynamic_pointer_cast<MockBtMessage2>(dispatcher_->messageQueue.front()); CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type); CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index); CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin); @@ -199,21 +199,21 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExten } void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExtensionDisabled() { - _peer->amChoking(true); + peer_->amChoking(true); msg->doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)0, _dispatcher->messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)0, dispatcher_->messageQueue.size()); } void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionEnabled() { msg->setIndex(2); - _peer->amChoking(false); - _peer->setFastExtensionEnabled(true); + peer_->amChoking(false); + peer_->setFastExtensionEnabled(true); msg->doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, _dispatcher->messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size()); SharedHandle<MockBtMessage2> pieceMsg = - dynamic_pointer_cast<MockBtMessage2>(_dispatcher->messageQueue.front()); + dynamic_pointer_cast<MockBtMessage2>(dispatcher_->messageQueue.front()); CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type); CPPUNIT_ASSERT_EQUAL((size_t)2, pieceMsg->index); CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin); @@ -222,10 +222,10 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionE void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionDisabled() { msg->setIndex(2); - _peer->amChoking(false); + peer_->amChoking(false); msg->doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)0, _dispatcher->messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)0, dispatcher_->messageQueue.size()); } void BtRequestMessageTest::testHandleAbortRequestEvent() { diff --git a/test/DHTAnnouncePeerMessageTest.cc b/test/DHTAnnouncePeerMessageTest.cc index 8a25b11f..1a8c8149 100644 --- a/test/DHTAnnouncePeerMessageTest.cc +++ b/test/DHTAnnouncePeerMessageTest.cc @@ -34,7 +34,7 @@ public: { return SharedHandle<DHTResponseMessage> (new MockDHTResponseMessage - (_localNode, remoteNode, "announce_peer", transactionID)); + (localNode_, remoteNode, "announce_peer", transactionID)); } }; }; @@ -107,10 +107,10 @@ void DHTAnnouncePeerMessageTest::testDoReceivedAction() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size()); SharedHandle<MockDHTResponseMessage> m (dynamic_pointer_cast<MockDHTResponseMessage> - (dispatcher._messageQueue[0]._message)); + (dispatcher.messageQueue_[0].message_)); CPPUNIT_ASSERT(localNode == m->getLocalNode()); CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); CPPUNIT_ASSERT_EQUAL(std::string("announce_peer"), m->getMessageType()); diff --git a/test/DHTFindNodeMessageTest.cc b/test/DHTFindNodeMessageTest.cc index 9a049c2d..c9f0ce54 100644 --- a/test/DHTFindNodeMessageTest.cc +++ b/test/DHTFindNodeMessageTest.cc @@ -37,8 +37,8 @@ public: { SharedHandle<MockDHTResponseMessage> m (new MockDHTResponseMessage - (_localNode, remoteNode, "find_node", transactionID)); - m->_nodes = closestKNodes; + (localNode_, remoteNode, "find_node", transactionID)); + m->nodes_ = closestKNodes; return m; } }; @@ -99,15 +99,15 @@ void DHTFindNodeMessageTest::testDoReceivedAction() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size()); SharedHandle<MockDHTResponseMessage> m (dynamic_pointer_cast<MockDHTResponseMessage> - (dispatcher._messageQueue[0]._message)); + (dispatcher.messageQueue_[0].message_)); CPPUNIT_ASSERT(localNode == m->getLocalNode()); CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); CPPUNIT_ASSERT_EQUAL(std::string("find_node"), m->getMessageType()); CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID()); - CPPUNIT_ASSERT_EQUAL((size_t)1, m->_nodes.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, m->nodes_.size()); } } // namespace aria2 diff --git a/test/DHTGetPeersMessageTest.cc b/test/DHTGetPeersMessageTest.cc index d5badc3f..9a817cbf 100644 --- a/test/DHTGetPeersMessageTest.cc +++ b/test/DHTGetPeersMessageTest.cc @@ -39,9 +39,9 @@ public: { SharedHandle<MockDHTResponseMessage> m (new MockDHTResponseMessage - (_localNode, remoteNode, "get_peers", transactionID)); - m->_peers = peers; - m->_token = token; + (localNode_, remoteNode, "get_peers", transactionID)); + m->peers_ = peers; + m->token_ = token; return m; } @@ -54,9 +54,9 @@ public: { SharedHandle<MockDHTResponseMessage> m (new MockDHTResponseMessage - (_localNode, remoteNode, "get_peers", transactionID)); - m->_nodes = closestKNodes; - m->_token = token; + (localNode_, remoteNode, "get_peers", transactionID)); + m->nodes_ = closestKNodes; + m->token_ = token; return m; } @@ -134,29 +134,29 @@ void DHTGetPeersMessageTest::testDoReceivedAction() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size()); SharedHandle<MockDHTResponseMessage> m (dynamic_pointer_cast<MockDHTResponseMessage> - (dispatcher._messageQueue[0]._message)); + (dispatcher.messageQueue_[0].message_)); CPPUNIT_ASSERT(localNode == m->getLocalNode()); CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); CPPUNIT_ASSERT_EQUAL(std::string("get_peers"), m->getMessageType()); CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID()); - CPPUNIT_ASSERT_EQUAL(tokenTracker.generateToken(infoHash, remoteNode->getIPAddress(), remoteNode->getPort()), m->_token); - CPPUNIT_ASSERT_EQUAL((size_t)0, m->_nodes.size()); - CPPUNIT_ASSERT_EQUAL((size_t)2, m->_peers.size()); + CPPUNIT_ASSERT_EQUAL(tokenTracker.generateToken(infoHash, remoteNode->getIPAddress(), remoteNode->getPort()), m->token_); + CPPUNIT_ASSERT_EQUAL((size_t)0, m->nodes_.size()); + CPPUNIT_ASSERT_EQUAL((size_t)2, m->peers_.size()); { - SharedHandle<Peer> peer = m->_peers[0]; + SharedHandle<Peer> peer = m->peers_[0]; CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.100"), peer->getIPAddress()); CPPUNIT_ASSERT_EQUAL((uint16_t)6888, peer->getPort()); } { - SharedHandle<Peer> peer = m->_peers[1]; + SharedHandle<Peer> peer = m->peers_[1]; CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.101"), peer->getIPAddress()); CPPUNIT_ASSERT_EQUAL((uint16_t)6889, peer->getPort()); } } - dispatcher._messageQueue.clear(); + dispatcher.messageQueue_.clear(); { // localhost doesn't have peer contact information for that infohash. DHTPeerAnnounceStorage peerAnnounceStorage; @@ -171,18 +171,18 @@ void DHTGetPeersMessageTest::testDoReceivedAction() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size()); SharedHandle<MockDHTResponseMessage> m (dynamic_pointer_cast<MockDHTResponseMessage> - (dispatcher._messageQueue[0]._message)); + (dispatcher.messageQueue_[0].message_)); CPPUNIT_ASSERT(localNode == m->getLocalNode()); CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); CPPUNIT_ASSERT_EQUAL(std::string("get_peers"), m->getMessageType()); CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID()); - CPPUNIT_ASSERT_EQUAL(tokenTracker.generateToken(infoHash, remoteNode->getIPAddress(), remoteNode->getPort()), m->_token); - CPPUNIT_ASSERT_EQUAL((size_t)1, m->_nodes.size()); - CPPUNIT_ASSERT(returnNode1 == m->_nodes[0]); - CPPUNIT_ASSERT_EQUAL((size_t)0, m->_peers.size()); + CPPUNIT_ASSERT_EQUAL(tokenTracker.generateToken(infoHash, remoteNode->getIPAddress(), remoteNode->getPort()), m->token_); + CPPUNIT_ASSERT_EQUAL((size_t)1, m->nodes_.size()); + CPPUNIT_ASSERT(returnNode1 == m->nodes_[0]); + CPPUNIT_ASSERT_EQUAL((size_t)0, m->peers_.size()); } } diff --git a/test/DHTPingMessageTest.cc b/test/DHTPingMessageTest.cc index b1070000..dd12c20d 100644 --- a/test/DHTPingMessageTest.cc +++ b/test/DHTPingMessageTest.cc @@ -34,7 +34,7 @@ public: const std::string& transactionID) { return SharedHandle<MockDHTResponseMessage> - (new MockDHTResponseMessage(_localNode, remoteNode, "ping_reply", + (new MockDHTResponseMessage(localNode_, remoteNode, "ping_reply", transactionID)); } }; @@ -88,10 +88,10 @@ void DHTPingMessageTest::testDoReceivedAction() msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size()); + CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher.messageQueue_.size()); SharedHandle<MockDHTResponseMessage> m (dynamic_pointer_cast<MockDHTResponseMessage> - (dispatcher._messageQueue[0]._message)); + (dispatcher.messageQueue_[0].message_)); CPPUNIT_ASSERT(localNode == m->getLocalNode()); CPPUNIT_ASSERT(remoteNode == m->getRemoteNode()); CPPUNIT_ASSERT_EQUAL(std::string("ping_reply"), m->getMessageType()); diff --git a/test/DNSCacheTest.cc b/test/DNSCacheTest.cc index 61346e18..d85bf7c8 100644 --- a/test/DNSCacheTest.cc +++ b/test/DNSCacheTest.cc @@ -13,15 +13,15 @@ class DNSCacheTest:public CppUnit::TestFixture { CPPUNIT_TEST(testRemove); CPPUNIT_TEST_SUITE_END(); - DNSCache _cache; + DNSCache cache_; public: void setUp() { - _cache = DNSCache(); - _cache.put("www", "192.168.0.1", 80); - _cache.put("www", "::1", 80); - _cache.put("ftp", "192.168.0.1", 21); - _cache.put("proxy", "192.168.1.2", 8080); + cache_ = DNSCache(); + cache_.put("www", "192.168.0.1", 80); + cache_.put("www", "::1", 80); + cache_.put("ftp", "192.168.0.1", 21); + cache_.put("proxy", "192.168.1.2", 8080); } void testFind(); @@ -35,30 +35,30 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DNSCacheTest); void DNSCacheTest::testFind() { - CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), _cache.find("www", 80)); - CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), _cache.find("ftp", 21)); - CPPUNIT_ASSERT_EQUAL(std::string("192.168.1.2"), _cache.find("proxy", 8080)); - CPPUNIT_ASSERT_EQUAL(std::string(""), _cache.find("www", 8080)); - CPPUNIT_ASSERT_EQUAL(std::string(""), _cache.find("another", 80)); + CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), cache_.find("www", 80)); + CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), cache_.find("ftp", 21)); + CPPUNIT_ASSERT_EQUAL(std::string("192.168.1.2"), cache_.find("proxy", 8080)); + CPPUNIT_ASSERT_EQUAL(std::string(""), cache_.find("www", 8080)); + CPPUNIT_ASSERT_EQUAL(std::string(""), cache_.find("another", 80)); } void DNSCacheTest::testMarkBad() { - _cache.markBad("www", "192.168.0.1", 80); - CPPUNIT_ASSERT_EQUAL(std::string("::1"), _cache.find("www", 80)); + cache_.markBad("www", "192.168.0.1", 80); + CPPUNIT_ASSERT_EQUAL(std::string("::1"), cache_.find("www", 80)); } void DNSCacheTest::testPutBadAddr() { - _cache.markBad("www", "192.168.0.1", 80); - _cache.put("www", "192.168.0.1", 80); - CPPUNIT_ASSERT_EQUAL(std::string("::1"), _cache.find("www", 80)); + cache_.markBad("www", "192.168.0.1", 80); + cache_.put("www", "192.168.0.1", 80); + CPPUNIT_ASSERT_EQUAL(std::string("::1"), cache_.find("www", 80)); } void DNSCacheTest::testRemove() { - _cache.remove("www", 80); - CPPUNIT_ASSERT_EQUAL(std::string(""), _cache.find("www", 80)); + cache_.remove("www", 80); + CPPUNIT_ASSERT_EQUAL(std::string(""), cache_.find("www", 80)); } } // namespace aria2 diff --git a/test/DefaultAuthResolverTest.cc b/test/DefaultAuthResolverTest.cc index 017e5651..bfac93aa 100644 --- a/test/DefaultAuthResolverTest.cc +++ b/test/DefaultAuthResolverTest.cc @@ -14,15 +14,15 @@ class DefaultAuthResolverTest : public CppUnit::TestFixture { private: //NetrcHandle _netrc; //SharedHandle<Option> _option; - SharedHandle<DefaultAuthResolver> _resolver; + SharedHandle<DefaultAuthResolver> resolver_; public: void setUp() { //_netrc = new Netrc(); //_option = new Option(); - _resolver.reset(new DefaultAuthResolver()); + resolver_.reset(new DefaultAuthResolver()); //_factory->setOption(_option.get()); - _resolver->setDefaultAuthConfig + resolver_->setDefaultAuthConfig (SharedHandle<AuthConfig>(new AuthConfig("foo", "bar"))); } @@ -35,15 +35,15 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DefaultAuthResolverTest ); void DefaultAuthResolverTest::testResolveAuthConfig_without_userDefined() { - SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost"); + SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost"); CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText()); } void DefaultAuthResolverTest::testResolveAuthConfig_with_userDefined() { - _resolver->setUserDefinedAuthConfig + resolver_->setUserDefinedAuthConfig (SharedHandle<AuthConfig>(new AuthConfig("myname", "mypasswd"))); - SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost"); + SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost"); CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText()); } diff --git a/test/DefaultBtAnnounceTest.cc b/test/DefaultBtAnnounceTest.cc index c39aa451..1ad8a175 100644 --- a/test/DefaultBtAnnounceTest.cc +++ b/test/DefaultBtAnnounceTest.cc @@ -35,14 +35,14 @@ class DefaultBtAnnounceTest:public CppUnit::TestFixture { CPPUNIT_TEST(testProcessAnnounceResponse); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<DownloadContext> _dctx; - SharedHandle<MockPieceStorage> _pieceStorage; - SharedHandle<MockPeerStorage> _peerStorage; - SharedHandle<BtRuntime> _btRuntime; - Option* _option; + SharedHandle<DownloadContext> dctx_; + SharedHandle<MockPieceStorage> pieceStorage_; + SharedHandle<MockPeerStorage> peerStorage_; + SharedHandle<BtRuntime> btRuntime_; + Option* option_; public: void setUp() { - _option = new Option(); + option_ = new Option(); int64_t totalLength = 4*1024*1024; int32_t pieceLength = 256*1024; @@ -55,29 +55,29 @@ public: std::string peerId = "-aria2-ultrafastdltl"; - _dctx.reset(new DownloadContext(pieceLength, totalLength)); + dctx_.reset(new DownloadContext(pieceLength, totalLength)); SharedHandle<TorrentAttribute> torrentAttrs(new TorrentAttribute()); torrentAttrs->infoHash = std::string(vbegin(infoHash), vend(infoHash)); - _dctx->setAttribute(bittorrent::BITTORRENT, torrentAttrs); + dctx_->setAttribute(bittorrent::BITTORRENT, torrentAttrs); bittorrent::setStaticPeerId(peerId); - _pieceStorage.reset(new MockPieceStorage()); - _pieceStorage->setTotalLength(totalLength); - _pieceStorage->setCompletedLength(pieceLength*10); + pieceStorage_.reset(new MockPieceStorage()); + pieceStorage_->setTotalLength(totalLength); + pieceStorage_->setCompletedLength(pieceLength*10); - _peerStorage.reset(new MockPeerStorage()); + peerStorage_.reset(new MockPeerStorage()); TransferStat stat; stat.setSessionDownloadLength(pieceLength*5); stat.setSessionUploadLength(pieceLength*6); - _peerStorage->setStat(stat); + peerStorage_->setStat(stat); - _btRuntime.reset(new BtRuntime()); - _btRuntime->setListenPort(6989); + btRuntime_.reset(new BtRuntime()); + btRuntime_->setListenPort(6989); } void tearDown() { - delete _option; + delete option_; } void testGetAnnounceUrl(); @@ -137,12 +137,12 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce() announceList->append(createAnnounceTier("http://localhost/announce")); announceList->append(createAnnounceTier("http://backup/announce")); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -157,7 +157,7 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce() btAnnounce.announceSuccess(); - _pieceStorage->setAllDownloadFinished(true); + pieceStorage_->setAllDownloadFinished(true); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=completed&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -167,7 +167,7 @@ void DefaultBtAnnounceTest::testNoMoreAnnounce() btAnnounce.announceSuccess(); - _btRuntime->setHalt(true); + btRuntime_->setHalt(true); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=0&no_peer_id=1&port=6989&event=stopped&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -185,12 +185,12 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl() SharedHandle<List> announceList = List::g(); announceList->append(createAnnounceTier("http://localhost/announce")); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -201,13 +201,13 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl() btAnnounce.announceSuccess(); - _pieceStorage->setAllDownloadFinished(true); + pieceStorage_->setAllDownloadFinished(true); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=completed&supportcrypto=1"), btAnnounce.getAnnounceUrl()); btAnnounce.announceSuccess(); - _btRuntime->setHalt(true); + btRuntime_->setHalt(true); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=0&no_peer_id=1&port=6989&event=stopped&supportcrypto=1"), btAnnounce.getAnnounceUrl()); } @@ -216,12 +216,12 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_withQuery() { SharedHandle<List> announceList = List::g(); announceList->append(createAnnounceTier("http://localhost/announce?k=v")); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL @@ -238,13 +238,13 @@ void DefaultBtAnnounceTest::testGetAnnounceUrl_externalIP() { SharedHandle<List> announceList = List::g(); announceList->append(createAnnounceTier("http://localhost/announce")); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - _option->put(PREF_BT_EXTERNAL_IP, "192.168.1.1"); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + option_->put(PREF_BT_EXTERNAL_IP, "192.168.1.1"); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL @@ -262,12 +262,12 @@ void DefaultBtAnnounceTest::testIsAllAnnounceFailed() SharedHandle<List> announceList = List::g(); announceList->append(createAnnounceTier("http://localhost/announce")); announceList->append(createAnnounceTier("http://backup/announce")); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -294,19 +294,19 @@ void DefaultBtAnnounceTest::testURLOrderInStoppedEvent() SharedHandle<List> announceList = List::g(); announceList->append(createAnnounceTier(vbegin(urls), vend(urls))); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl()); btAnnounce.announceSuccess(); - _btRuntime->setHalt(true); + btRuntime_->setHalt(true); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=0&no_peer_id=1&port=6989&event=stopped&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -324,19 +324,19 @@ void DefaultBtAnnounceTest::testURLOrderInCompletedEvent() SharedHandle<List> announceList = List::g(); announceList->append(createAnnounceTier(vbegin(urls), vend(urls))); - setAnnounceList(_dctx, announceList); + setAnnounceList(dctx_, announceList); - DefaultBtAnnounce btAnnounce(_dctx, _option); - btAnnounce.setPieceStorage(_pieceStorage); - btAnnounce.setPeerStorage(_peerStorage); - btAnnounce.setBtRuntime(_btRuntime); + DefaultBtAnnounce btAnnounce(dctx_, option_); + btAnnounce.setPieceStorage(pieceStorage_); + btAnnounce.setPeerStorage(peerStorage_); + btAnnounce.setBtRuntime(btRuntime_); btAnnounce.setRandomizer(SharedHandle<Randomizer>(new FixedNumberRandomizer())); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=started&supportcrypto=1"), btAnnounce.getAnnounceUrl()); btAnnounce.announceSuccess(); - _pieceStorage->setAllDownloadFinished(true); + pieceStorage_->setAllDownloadFinished(true); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost1/announce?info_hash=%01%23Eg%89%AB%CD%EF%01%23Eg%89%AB%CD%EF%01%23Eg&peer_id=%2Daria2%2Dultrafastdltl&uploaded=1572864&downloaded=1310720&left=1572864&compact=1&key=fastdltl&numwant=50&no_peer_id=1&port=6989&event=completed&supportcrypto=1"), btAnnounce.getAnnounceUrl()); @@ -351,7 +351,7 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse_malformed() { try { std::string res = "i123e"; - DefaultBtAnnounce(_dctx, _option).processAnnounceResponse(reinterpret_cast<const unsigned char*>(res.c_str()), res.size()); + DefaultBtAnnounce(dctx_, option_).processAnnounceResponse(reinterpret_cast<const unsigned char*>(res.c_str()), res.size()); CPPUNIT_FAIL("exception must be thrown."); } catch(Exception& e) { std::cerr << e.stackTrace() << std::endl; @@ -362,7 +362,7 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse_failureReason() { try { std::string res = "d14:failure reason11:hello worlde"; - DefaultBtAnnounce(_dctx, _option).processAnnounceResponse(reinterpret_cast<const unsigned char*>(res.c_str()), res.size()); + DefaultBtAnnounce(dctx_, option_).processAnnounceResponse(reinterpret_cast<const unsigned char*>(res.c_str()), res.size()); CPPUNIT_FAIL("exception must be thrown."); } catch(Exception& e) { std::cerr << e.stackTrace() << std::endl; @@ -380,7 +380,7 @@ void DefaultBtAnnounceTest::testProcessAnnounceResponse() "10:incompletei200e" "e"; - DefaultBtAnnounce an(_dctx, _option); + DefaultBtAnnounce an(dctx_, option_); an.processAnnounceResponse(reinterpret_cast<const unsigned char*>(res.c_str()), res.size()); CPPUNIT_ASSERT_EQUAL(std::string("foo"), an.getTrackerID()); CPPUNIT_ASSERT_EQUAL((time_t)3000, an.getInterval()); diff --git a/test/DefaultBtMessageDispatcherTest.cc b/test/DefaultBtMessageDispatcherTest.cc index bfba0bb8..1c5d149b 100644 --- a/test/DefaultBtMessageDispatcherTest.cc +++ b/test/DefaultBtMessageDispatcherTest.cc @@ -42,15 +42,15 @@ class DefaultBtMessageDispatcherTest:public CppUnit::TestFixture { CPPUNIT_TEST(testRemoveOutstandingRequest); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; SharedHandle<Peer> peer; SharedHandle<DefaultBtMessageDispatcher> btMessageDispatcher; SharedHandle<MockPeerStorage> peerStorage; SharedHandle<MockPieceStorage> pieceStorage; - SharedHandle<MockBtMessageFactory> _messageFactory; - SharedHandle<RequestGroupMan> _rgman; - SharedHandle<Option> _option; - SharedHandle<RequestGroup> _rg; + SharedHandle<MockBtMessageFactory> messageFactory_; + SharedHandle<RequestGroupMan> rgman_; + SharedHandle<Option> option_; + SharedHandle<RequestGroup> rg_; public: void tearDown() {} @@ -135,34 +135,34 @@ public: }; void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); - _rg.reset(new RequestGroup(_option)); + rg_.reset(new RequestGroup(option_)); - _dctx.reset(new DownloadContext()); - bittorrent::load("test.torrent", _dctx); + dctx_.reset(new DownloadContext()); + bittorrent::load("test.torrent", dctx_); - _rg->setDownloadContext(_dctx); + rg_->setDownloadContext(dctx_); peer.reset(new Peer("192.168.0.1", 6969)); peer->allocateSessionResource - (_dctx->getPieceLength(), _dctx->getTotalLength()); + (dctx_->getPieceLength(), dctx_->getTotalLength()); peerStorage.reset(new MockPeerStorage()); pieceStorage.reset(new MockPieceStorage()); - _messageFactory.reset(new MockBtMessageFactory2()); + messageFactory_.reset(new MockBtMessageFactory2()); - _rgman.reset(new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(), - 0, _option.get())); + rgman_.reset(new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(), + 0, option_.get())); btMessageDispatcher.reset(new DefaultBtMessageDispatcher()); btMessageDispatcher->setPeer(peer); - btMessageDispatcher->setDownloadContext(_dctx); + btMessageDispatcher->setDownloadContext(dctx_); btMessageDispatcher->setPieceStorage(pieceStorage); btMessageDispatcher->setPeerStorage(peerStorage); - btMessageDispatcher->setBtMessageFactory(_messageFactory); + btMessageDispatcher->setBtMessageFactory(messageFactory_); btMessageDispatcher->setCuid(1); - btMessageDispatcher->setRequestGroupMan(_rgman); + btMessageDispatcher->setRequestGroupMan(rgman_); } }; diff --git a/test/DefaultBtMessageFactoryTest.cc b/test/DefaultBtMessageFactoryTest.cc index 2a948f80..09a47485 100644 --- a/test/DefaultBtMessageFactoryTest.cc +++ b/test/DefaultBtMessageFactoryTest.cc @@ -24,25 +24,25 @@ class DefaultBtMessageFactoryTest:public CppUnit::TestFixture { CPPUNIT_TEST(testCreatePortMessage); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<DownloadContext> _dctx; - SharedHandle<Peer> _peer; - SharedHandle<MockExtensionMessageFactory> _exmsgFactory; - SharedHandle<DefaultBtMessageFactory> _factory; + SharedHandle<DownloadContext> dctx_; + SharedHandle<Peer> peer_; + SharedHandle<MockExtensionMessageFactory> exmsgFactory_; + SharedHandle<DefaultBtMessageFactory> factory_; public: void setUp() { - _dctx.reset(new DownloadContext()); + dctx_.reset(new DownloadContext()); - _peer.reset(new Peer("192.168.0.1", 6969)); - _peer->allocateSessionResource(1024, 1024*1024); - _peer->setExtendedMessagingEnabled(true); + peer_.reset(new Peer("192.168.0.1", 6969)); + peer_->allocateSessionResource(1024, 1024*1024); + peer_->setExtendedMessagingEnabled(true); - _exmsgFactory.reset(new MockExtensionMessageFactory()); + exmsgFactory_.reset(new MockExtensionMessageFactory()); - _factory.reset(new DefaultBtMessageFactory()); - _factory->setDownloadContext(_dctx); - _factory->setPeer(_peer); - _factory->setExtensionMessageFactory(_exmsgFactory); + factory_.reset(new DefaultBtMessageFactory()); + factory_->setDownloadContext(dctx_); + factory_->setPeer(peer_); + factory_->setExtensionMessageFactory(exmsgFactory_); } void testCreateBtMessage_BtExtendedMessage(); @@ -64,12 +64,12 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage() SharedHandle<BtExtendedMessage> m (dynamic_pointer_cast<BtExtendedMessage> - (_factory->createBtMessage((const unsigned char*)msg+4, sizeof(msg)))); + (factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg)))); try { // disable extended messaging - _peer->setExtendedMessagingEnabled(false); - _factory->createBtMessage((const unsigned char*)msg+4, sizeof(msg)); + peer_->setExtendedMessagingEnabled(false); + factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg)); CPPUNIT_FAIL("exception must be thrown."); } catch(Exception& e) { std::cerr << e.stackTrace() << std::endl; @@ -85,7 +85,7 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage() try { SharedHandle<BtPortMessage> m (dynamic_pointer_cast<BtPortMessage> - (_factory->createBtMessage(&data[4], sizeof(data)-4))); + (factory_->createBtMessage(&data[4], sizeof(data)-4))); CPPUNIT_ASSERT(!m.isNull()); CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort()); } catch(Exception& e) { @@ -94,7 +94,7 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage() } { SharedHandle<BtPortMessage> m - (dynamic_pointer_cast<BtPortMessage>(_factory->createPortMessage(6881))); + (dynamic_pointer_cast<BtPortMessage>(factory_->createPortMessage(6881))); CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort()); } } diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc index 85aafe12..d157258e 100644 --- a/test/DefaultBtProgressInfoFileTest.cc +++ b/test/DefaultBtProgressInfoFileTest.cc @@ -42,26 +42,26 @@ class DefaultBtProgressInfoFileTest:public CppUnit::TestFixture { private: #ifdef ENABLE_BITTORRENT - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; - SharedHandle<MockPeerStorage> _peerStorage; + SharedHandle<MockPeerStorage> peerStorage_; - SharedHandle<BtRuntime> _btRuntime; + SharedHandle<BtRuntime> btRuntime_; #endif // ENABLE_BITTORRENT - SharedHandle<MockPieceStorage> _pieceStorage; - SharedHandle<Option> _option; - SharedHandle<BitfieldMan> _bitfield; + SharedHandle<MockPieceStorage> pieceStorage_; + SharedHandle<Option> option_; + SharedHandle<BitfieldMan> bitfield_; public: void initializeMembers(int32_t pieceLength, int64_t totalLength) { - _option.reset(new Option()); - _option->put(PREF_DIR, "."); + option_.reset(new Option()); + option_->put(PREF_DIR, "."); - _bitfield.reset(new BitfieldMan(pieceLength, totalLength)); + bitfield_.reset(new BitfieldMan(pieceLength, totalLength)); - _pieceStorage.reset(new MockPieceStorage()); - _pieceStorage->setBitfield(_bitfield.get()); + pieceStorage_.reset(new MockPieceStorage()); + pieceStorage_->setBitfield(bitfield_.get()); #ifdef ENABLE_BITTORRENT static unsigned char infoHash[] = { @@ -69,18 +69,18 @@ public: 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, }; - _dctx.reset(new DownloadContext()); + dctx_.reset(new DownloadContext()); SharedHandle<TorrentAttribute> torrentAttrs(new TorrentAttribute()); torrentAttrs->infoHash = std::string(vbegin(infoHash), vend(infoHash)); - _dctx->setAttribute(bittorrent::BITTORRENT, torrentAttrs); - _dctx->setDir(_option->get(PREF_DIR)); + dctx_->setAttribute(bittorrent::BITTORRENT, torrentAttrs); + dctx_->setDir(option_->get(PREF_DIR)); const SharedHandle<FileEntry> fileEntries[] = { SharedHandle<FileEntry>(new FileEntry("/path/to/file",totalLength,0)) }; - _dctx->setFileEntries(vbegin(fileEntries), vend(fileEntries)); - _dctx->setPieceLength(pieceLength); - _peerStorage.reset(new MockPeerStorage()); - _btRuntime.reset(new BtRuntime()); + dctx_->setFileEntries(vbegin(fileEntries), vend(fileEntries)); + dctx_->setPieceLength(pieceLength); + peerStorage_.reset(new MockPeerStorage()); + btRuntime_.reset(new BtRuntime()); #endif // ENABLE_BITTORRENT } @@ -113,11 +113,11 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtProgressInfoFileTest); void DefaultBtProgressInfoFileTest::testLoad_compat() { initializeMembers(1024, 81920); - _dctx->setBasePath("load"); + dctx_->setBasePath("load"); - DefaultBtProgressInfoFile infoFile(_dctx, _pieceStorage, _option.get()); - infoFile.setBtRuntime(_btRuntime); - infoFile.setPeerStorage(_peerStorage); + DefaultBtProgressInfoFile infoFile(dctx_, pieceStorage_, option_.get()); + infoFile.setBtRuntime(btRuntime_); + infoFile.setPeerStorage(peerStorage_); CPPUNIT_ASSERT_EQUAL(std::string("load.aria2"), infoFile.getFilename()); @@ -126,23 +126,23 @@ void DefaultBtProgressInfoFileTest::testLoad_compat() // check the contents of objects // total length - CPPUNIT_ASSERT_EQUAL((uint64_t)81920, _dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx_->getTotalLength()); // upload length - CPPUNIT_ASSERT_EQUAL((uint64_t)1024, _btRuntime->getUploadLengthAtStartup()); + CPPUNIT_ASSERT_EQUAL((uint64_t)1024, btRuntime_->getUploadLengthAtStartup()); // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), - util::toHex(_bitfield->getBitfield(), - _bitfield->getBitfieldLength())); + util::toHex(bitfield_->getBitfield(), + bitfield_->getBitfieldLength())); // the number of in-flight pieces CPPUNIT_ASSERT_EQUAL((size_t)2, - _pieceStorage->countInFlightPiece()); + pieceStorage_->countInFlightPiece()); // piece index 1 std::vector<SharedHandle<Piece> > inFlightPieces; - _pieceStorage->getInFlightPieces(inFlightPieces); + pieceStorage_->getInFlightPieces(inFlightPieces); SharedHandle<Piece> piece1 = inFlightPieces[0]; CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex()); @@ -162,36 +162,36 @@ void DefaultBtProgressInfoFileTest::testLoad() { initializeMembers(1024, 81920); - _dctx->setBasePath("load-v0001"); + dctx_->setBasePath("load-v0001"); - DefaultBtProgressInfoFile infoFile(_dctx, _pieceStorage, _option.get()); + DefaultBtProgressInfoFile infoFile(dctx_, pieceStorage_, option_.get()); CPPUNIT_ASSERT_EQUAL(std::string("load-v0001.aria2"), infoFile.getFilename()); - infoFile.setBtRuntime(_btRuntime); - infoFile.setPeerStorage(_peerStorage); + infoFile.setBtRuntime(btRuntime_); + infoFile.setPeerStorage(peerStorage_); infoFile.load(); // check the contents of objects // total length - CPPUNIT_ASSERT_EQUAL((uint64_t)81920, _dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx_->getTotalLength()); // upload length - CPPUNIT_ASSERT_EQUAL((uint64_t)1024, _btRuntime->getUploadLengthAtStartup()); + CPPUNIT_ASSERT_EQUAL((uint64_t)1024, btRuntime_->getUploadLengthAtStartup()); // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), - util::toHex(_bitfield->getBitfield(), - _bitfield->getBitfieldLength())); + util::toHex(bitfield_->getBitfield(), + bitfield_->getBitfieldLength())); // the number of in-flight pieces CPPUNIT_ASSERT_EQUAL((size_t)2, - _pieceStorage->countInFlightPiece()); + pieceStorage_->countInFlightPiece()); // piece index 1 std::vector<SharedHandle<Piece> > inFlightPieces; - _pieceStorage->getInFlightPieces(inFlightPieces); + pieceStorage_->getInFlightPieces(inFlightPieces); SharedHandle<Piece> piece1 = inFlightPieces[0]; CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex()); @@ -210,24 +210,24 @@ void DefaultBtProgressInfoFileTest::testSave() { initializeMembers(1024, 81920); - _dctx->setBasePath("save-temp"); - _bitfield->setAllBit(); - _bitfield->unsetBit(79); - _pieceStorage->setCompletedLength(80896); + dctx_->setBasePath("save-temp"); + bitfield_->setAllBit(); + bitfield_->unsetBit(79); + pieceStorage_->setCompletedLength(80896); TransferStat stat; stat.setAllTimeUploadLength(1024); - _peerStorage->setStat(stat); + peerStorage_->setStat(stat); SharedHandle<Piece> p1(new Piece(1, 1024)); SharedHandle<Piece> p2(new Piece(2, 512)); std::vector<SharedHandle<Piece> > inFlightPieces; inFlightPieces.push_back(p1); inFlightPieces.push_back(p2); - _pieceStorage->addInFlightPiece(inFlightPieces); + pieceStorage_->addInFlightPiece(inFlightPieces); - DefaultBtProgressInfoFile infoFile(_dctx, _pieceStorage, _option.get()); - infoFile.setBtRuntime(_btRuntime); - infoFile.setPeerStorage(_peerStorage); + DefaultBtProgressInfoFile infoFile(dctx_, pieceStorage_, option_.get()); + infoFile.setBtRuntime(btRuntime_); + infoFile.setPeerStorage(peerStorage_); CPPUNIT_ASSERT_EQUAL(std::string("save-temp.aria2"), infoFile.getFilename()); @@ -334,7 +334,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat() SharedHandle<DownloadContext> dctx (new DownloadContext(1024, 81920, "load-nonBt")); - DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get()); + DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get()); CPPUNIT_ASSERT_EQUAL(std::string("load-nonBt.aria2"), infoFile.getFilename()); @@ -347,16 +347,16 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat() // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), - util::toHex(_bitfield->getBitfield(), - _bitfield->getBitfieldLength())); + util::toHex(bitfield_->getBitfield(), + bitfield_->getBitfieldLength())); // the number of in-flight pieces CPPUNIT_ASSERT_EQUAL((size_t)2, - _pieceStorage->countInFlightPiece()); + pieceStorage_->countInFlightPiece()); // piece index 1 std::vector<SharedHandle<Piece> > inFlightPieces; - _pieceStorage->getInFlightPieces(inFlightPieces); + pieceStorage_->getInFlightPieces(inFlightPieces); SharedHandle<Piece> piece1 = inFlightPieces[0]; CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex()); @@ -379,7 +379,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt() SharedHandle<DownloadContext> dctx (new DownloadContext(1024, 81920, "load-nonBt-v0001")); - DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get()); + DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get()); CPPUNIT_ASSERT_EQUAL(std::string("load-nonBt-v0001.aria2"), infoFile.getFilename()); @@ -392,16 +392,16 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt() // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), - util::toHex(_bitfield->getBitfield(), - _bitfield->getBitfieldLength())); + util::toHex(bitfield_->getBitfield(), + bitfield_->getBitfieldLength())); // the number of in-flight pieces CPPUNIT_ASSERT_EQUAL((size_t)2, - _pieceStorage->countInFlightPiece()); + pieceStorage_->countInFlightPiece()); // piece index 1 std::vector<SharedHandle<Piece> > inFlightPieces; - _pieceStorage->getInFlightPieces(inFlightPieces); + pieceStorage_->getInFlightPieces(inFlightPieces); SharedHandle<Piece> piece1 = inFlightPieces[0]; CPPUNIT_ASSERT_EQUAL((size_t)1, piece1->getIndex()); @@ -419,12 +419,12 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt() void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter() { initializeMembers(512, 81920); - _option->put(PREF_ALLOW_PIECE_LENGTH_CHANGE, V_TRUE); + option_->put(PREF_ALLOW_PIECE_LENGTH_CHANGE, V_TRUE); SharedHandle<DownloadContext> dctx (new DownloadContext(512, 81920, "load-nonBt-v0001")); - DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get()); + DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get()); CPPUNIT_ASSERT_EQUAL(std::string("load-nonBt-v0001.aria2"), infoFile.getFilename()); @@ -434,12 +434,12 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_pieceLengthShorter() // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffffffffffffffffffffffc"), - util::toHex(_bitfield->getBitfield(), - _bitfield->getBitfieldLength())); + util::toHex(bitfield_->getBitfield(), + bitfield_->getBitfieldLength())); // the number of in-flight pieces CPPUNIT_ASSERT_EQUAL((size_t)0, - _pieceStorage->countInFlightPiece()); + pieceStorage_->countInFlightPiece()); } void DefaultBtProgressInfoFileTest::testSave_nonBt() @@ -449,18 +449,18 @@ void DefaultBtProgressInfoFileTest::testSave_nonBt() SharedHandle<DownloadContext> dctx (new DownloadContext(1024, 81920, "save-temp")); - _bitfield->setAllBit(); - _bitfield->unsetBit(79); - _pieceStorage->setCompletedLength(80896); + bitfield_->setAllBit(); + bitfield_->unsetBit(79); + pieceStorage_->setCompletedLength(80896); SharedHandle<Piece> p1(new Piece(1, 1024)); SharedHandle<Piece> p2(new Piece(2, 512)); std::vector<SharedHandle<Piece> > inFlightPieces; inFlightPieces.push_back(p1); inFlightPieces.push_back(p2); - _pieceStorage->addInFlightPiece(inFlightPieces); + pieceStorage_->addInFlightPiece(inFlightPieces); - DefaultBtProgressInfoFile infoFile(dctx, _pieceStorage, _option.get()); + DefaultBtProgressInfoFile infoFile(dctx, pieceStorage_, option_.get()); CPPUNIT_ASSERT_EQUAL(std::string("save-temp.aria2"), infoFile.getFilename()); @@ -558,8 +558,8 @@ void DefaultBtProgressInfoFileTest::testUpdateFilename() DefaultBtProgressInfoFile infoFile(dctx, SharedHandle<MockPieceStorage>(), 0); #ifdef ENABLE_BITTORRENT - infoFile.setBtRuntime(_btRuntime); - infoFile.setPeerStorage(_peerStorage); + infoFile.setBtRuntime(btRuntime_); + infoFile.setPeerStorage(peerStorage_); #endif // ENABLE_BITTORRENT CPPUNIT_ASSERT_EQUAL(std::string("./file1.aria2"), infoFile.getFilename()); diff --git a/test/DefaultBtRequestFactoryTest.cc b/test/DefaultBtRequestFactoryTest.cc index c68a0e9a..941fa0e4 100644 --- a/test/DefaultBtRequestFactoryTest.cc +++ b/test/DefaultBtRequestFactoryTest.cc @@ -27,12 +27,12 @@ class DefaultBtRequestFactoryTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGetTargetPieceIndexes); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Peer> _peer; - SharedHandle<DefaultBtRequestFactory> _requestFactory; - SharedHandle<DownloadContext> _dctx; - SharedHandle<MockPieceStorage> _pieceStorage; - SharedHandle<MockBtMessageFactory> _messageFactory; - SharedHandle<MockBtMessageDispatcher> _dispatcher; + SharedHandle<Peer> peer_; + SharedHandle<DefaultBtRequestFactory> requestFactory_; + SharedHandle<DownloadContext> dctx_; + SharedHandle<MockPieceStorage> pieceStorage_; + SharedHandle<MockBtMessageFactory> messageFactory_; + SharedHandle<MockBtMessageDispatcher> dispatcher_; public: void testAddTargetPiece(); void testRemoveCompletedPiece(); @@ -88,19 +88,19 @@ public: void setUp() { - _pieceStorage.reset(new MockPieceStorage()); + pieceStorage_.reset(new MockPieceStorage()); - _peer.reset(new Peer("host", 6969)); + peer_.reset(new Peer("host", 6969)); - _messageFactory.reset(new MockBtMessageFactory2()); + messageFactory_.reset(new MockBtMessageFactory2()); - _dispatcher.reset(new MockBtMessageDispatcher()); + dispatcher_.reset(new MockBtMessageDispatcher()); - _requestFactory.reset(new DefaultBtRequestFactory()); - _requestFactory->setPieceStorage(_pieceStorage); - _requestFactory->setPeer(_peer); - _requestFactory->setBtMessageDispatcher(_dispatcher); - _requestFactory->setBtMessageFactory(_messageFactory); + requestFactory_.reset(new DefaultBtRequestFactory()); + requestFactory_->setPieceStorage(pieceStorage_); + requestFactory_->setPeer(peer_); + requestFactory_->setBtMessageDispatcher(dispatcher_); + requestFactory_->setBtMessageFactory(messageFactory_); } }; @@ -110,40 +110,40 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtRequestFactoryTest); void DefaultBtRequestFactoryTest::testAddTargetPiece() { { SharedHandle<Piece> piece(new Piece(0, 16*1024*10)); - _requestFactory->addTargetPiece(piece); - CPPUNIT_ASSERT_EQUAL((size_t)1, _requestFactory->countTargetPiece()); + requestFactory_->addTargetPiece(piece); + CPPUNIT_ASSERT_EQUAL((size_t)1, requestFactory_->countTargetPiece()); } { SharedHandle<Piece> piece(new Piece(1, 16*1024*9)); piece->completeBlock(0); - _requestFactory->addTargetPiece(piece); - CPPUNIT_ASSERT_EQUAL((size_t)2, _requestFactory->countTargetPiece()); + requestFactory_->addTargetPiece(piece); + CPPUNIT_ASSERT_EQUAL((size_t)2, requestFactory_->countTargetPiece()); } - CPPUNIT_ASSERT_EQUAL((size_t)18, _requestFactory->countMissingBlock()); + CPPUNIT_ASSERT_EQUAL((size_t)18, requestFactory_->countMissingBlock()); } void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() { SharedHandle<Piece> piece1(new Piece(0, 16*1024)); SharedHandle<Piece> piece2(new Piece(1, 16*1024)); piece2->setAllBlock(); - _requestFactory->addTargetPiece(piece1); - _requestFactory->addTargetPiece(piece2); - CPPUNIT_ASSERT_EQUAL((size_t)2, _requestFactory->countTargetPiece()); - _requestFactory->removeCompletedPiece(); - CPPUNIT_ASSERT_EQUAL((size_t)1, _requestFactory->countTargetPiece()); + requestFactory_->addTargetPiece(piece1); + requestFactory_->addTargetPiece(piece2); + CPPUNIT_ASSERT_EQUAL((size_t)2, requestFactory_->countTargetPiece()); + requestFactory_->removeCompletedPiece(); + CPPUNIT_ASSERT_EQUAL((size_t)1, requestFactory_->countTargetPiece()); CPPUNIT_ASSERT_EQUAL((size_t)0, - _requestFactory->getTargetPieces().front()->getIndex()); + requestFactory_->getTargetPieces().front()->getIndex()); } void DefaultBtRequestFactoryTest::testCreateRequestMessages() { int PIECE_LENGTH = 16*1024*2; SharedHandle<Piece> piece1(new Piece(0, PIECE_LENGTH)); SharedHandle<Piece> piece2(new Piece(1, PIECE_LENGTH)); - _requestFactory->addTargetPiece(piece1); - _requestFactory->addTargetPiece(piece2); + requestFactory_->addTargetPiece(piece1); + requestFactory_->addTargetPiece(piece2); std::vector<SharedHandle<BtMessage> > msgs; - _requestFactory->createRequestMessages(msgs, 3); + requestFactory_->createRequestMessages(msgs, 3); CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size()); std::vector<SharedHandle<BtMessage> >::iterator itr = msgs.begin(); @@ -162,7 +162,7 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages() { { std::vector<SharedHandle<BtMessage> > msgs; - _requestFactory->createRequestMessages(msgs, 3); + requestFactory_->createRequestMessages(msgs, 3); CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size()); } } @@ -171,16 +171,16 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() { SharedHandle<MockBtMessageDispatcher2> dispatcher (new MockBtMessageDispatcher2()); - _requestFactory->setBtMessageDispatcher(dispatcher); + requestFactory_->setBtMessageDispatcher(dispatcher); int PIECE_LENGTH = 16*1024*2; SharedHandle<Piece> piece1(new Piece(0, PIECE_LENGTH)); SharedHandle<Piece> piece2(new Piece(1, PIECE_LENGTH)); - _requestFactory->addTargetPiece(piece1); - _requestFactory->addTargetPiece(piece2); + requestFactory_->addTargetPiece(piece1); + requestFactory_->addTargetPiece(piece2); std::vector<SharedHandle<BtMessage> > msgs; - _requestFactory->createRequestMessagesOnEndGame(msgs, 3); + requestFactory_->createRequestMessagesOnEndGame(msgs, 3); std::vector<SharedHandle<MockBtRequestMessage> > mmsgs; for(std::vector<SharedHandle<BtMessage> >::iterator i = msgs.begin(); @@ -208,19 +208,19 @@ void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() { void DefaultBtRequestFactoryTest::testRemoveTargetPiece() { SharedHandle<Piece> piece1(new Piece(0, 16*1024)); - _requestFactory->addTargetPiece(piece1); + requestFactory_->addTargetPiece(piece1); - CPPUNIT_ASSERT(std::find(_requestFactory->getTargetPieces().begin(), - _requestFactory->getTargetPieces().end(), + CPPUNIT_ASSERT(std::find(requestFactory_->getTargetPieces().begin(), + requestFactory_->getTargetPieces().end(), piece1) != - _requestFactory->getTargetPieces().end()); + requestFactory_->getTargetPieces().end()); - _requestFactory->removeTargetPiece(piece1); + requestFactory_->removeTargetPiece(piece1); - CPPUNIT_ASSERT(std::find(_requestFactory->getTargetPieces().begin(), - _requestFactory->getTargetPieces().end(), + CPPUNIT_ASSERT(std::find(requestFactory_->getTargetPieces().begin(), + requestFactory_->getTargetPieces().end(), piece1) == - _requestFactory->getTargetPieces().end()); + requestFactory_->getTargetPieces().end()); } void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes() @@ -229,12 +229,12 @@ void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes() SharedHandle<Piece> piece3(new Piece(3, 16*1024)); SharedHandle<Piece> piece5(new Piece(5, 16*1024)); - _requestFactory->addTargetPiece(piece3); - _requestFactory->addTargetPiece(piece1); - _requestFactory->addTargetPiece(piece5); + requestFactory_->addTargetPiece(piece3); + requestFactory_->addTargetPiece(piece1); + requestFactory_->addTargetPiece(piece5); std::vector<size_t> indexes; - _requestFactory->getTargetPieceIndexes(indexes); + requestFactory_->getTargetPieceIndexes(indexes); CPPUNIT_ASSERT_EQUAL((size_t)3, indexes.size()); CPPUNIT_ASSERT_EQUAL((size_t)3, indexes[0]); CPPUNIT_ASSERT_EQUAL((size_t)1, indexes[1]); diff --git a/test/DefaultExtensionMessageFactoryTest.cc b/test/DefaultExtensionMessageFactoryTest.cc index 2a7ab725..0eb16520 100644 --- a/test/DefaultExtensionMessageFactoryTest.cc +++ b/test/DefaultExtensionMessageFactoryTest.cc @@ -39,47 +39,47 @@ class DefaultExtensionMessageFactoryTest:public CppUnit::TestFixture { CPPUNIT_TEST(testCreateMessage_UTMetadataReject); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<MockPeerStorage> _peerStorage; - SharedHandle<Peer> _peer; - SharedHandle<DefaultExtensionMessageFactory> _factory; - SharedHandle<ExtensionMessageRegistry> _registry; - SharedHandle<MockBtMessageDispatcher> _dispatcher; - SharedHandle<MockBtMessageFactory> _messageFactory; - SharedHandle<DownloadContext> _dctx; - SharedHandle<RequestGroup> _requestGroup; + SharedHandle<MockPeerStorage> peerStorage_; + SharedHandle<Peer> peer_; + SharedHandle<DefaultExtensionMessageFactory> factory_; + SharedHandle<ExtensionMessageRegistry> registry_; + SharedHandle<MockBtMessageDispatcher> dispatcher_; + SharedHandle<MockBtMessageFactory> messageFactory_; + SharedHandle<DownloadContext> dctx_; + SharedHandle<RequestGroup> requestGroup_; public: void setUp() { - _peerStorage.reset(new MockPeerStorage()); + peerStorage_.reset(new MockPeerStorage()); - _peer.reset(new Peer("192.168.0.1", 6969)); - _peer->allocateSessionResource(1024, 1024*1024); - _peer->setExtension("ut_pex", 1); + peer_.reset(new Peer("192.168.0.1", 6969)); + peer_->allocateSessionResource(1024, 1024*1024); + peer_->setExtension("ut_pex", 1); - _registry.reset(new ExtensionMessageRegistry()); + registry_.reset(new ExtensionMessageRegistry()); - _dispatcher.reset(new MockBtMessageDispatcher()); + dispatcher_.reset(new MockBtMessageDispatcher()); - _messageFactory.reset(new MockBtMessageFactory()); + messageFactory_.reset(new MockBtMessageFactory()); - _dctx.reset(new DownloadContext()); + dctx_.reset(new DownloadContext()); SharedHandle<Option> option(new Option()); - _requestGroup.reset(new RequestGroup(option)); - _requestGroup->setDownloadContext(_dctx); - - _factory.reset(new DefaultExtensionMessageFactory()); - _factory->setPeerStorage(_peerStorage); - _factory->setPeer(_peer); - _factory->setExtensionMessageRegistry(_registry); - _factory->setBtMessageDispatcher(_dispatcher); - _factory->setBtMessageFactory(_messageFactory); - _factory->setDownloadContext(_dctx); + requestGroup_.reset(new RequestGroup(option)); + requestGroup_->setDownloadContext(dctx_); + + factory_.reset(new DefaultExtensionMessageFactory()); + factory_->setPeerStorage(peerStorage_); + factory_->setPeer(peer_); + factory_->setExtensionMessageRegistry(registry_); + factory_->setBtMessageDispatcher(dispatcher_); + factory_->setBtMessageFactory(messageFactory_); + factory_->setDownloadContext(dctx_); } std::string getExtensionMessageID(const std::string& name) { - char id[1] = { _registry->getExtensionMessageID(name) }; + char id[1] = { registry_->getExtensionMessageID(name) }; return std::string(&id[0], &id[1]); } @@ -87,7 +87,7 @@ public: SharedHandle<T> createMessage(const std::string& data) { return dynamic_pointer_cast<T> - (_factory->createMessage + (factory_->createMessage (reinterpret_cast<const unsigned char*>(data.c_str()), data.size())); } @@ -104,14 +104,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultExtensionMessageFactoryTest); void DefaultExtensionMessageFactoryTest::testCreateMessage_unknown() { - _peer->setExtension("foo", 255); + peer_->setExtension("foo", 255); char id[1] = { 255 }; std::string data = std::string(&id[0], &id[1]); try { // this test fails because localhost doesn't have extension id = 255. - _factory->createMessage + factory_->createMessage (reinterpret_cast<const unsigned char*>(data.c_str()), data.size()); CPPUNIT_FAIL("exception must be thrown."); } catch(Exception& e) { @@ -148,7 +148,7 @@ void DefaultExtensionMessageFactoryTest::testCreateMessage_UTPex() SharedHandle<UTPexExtensionMessage> m = createMessage<UTPexExtensionMessage>(data); - CPPUNIT_ASSERT_EQUAL(_registry->getExtensionMessageID("ut_pex"), + CPPUNIT_ASSERT_EQUAL(registry_->getExtensionMessageID("ut_pex"), m->getExtensionMessageID()); } diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc index a75b4d54..2ae6a83f 100644 --- a/test/DefaultPieceStorageTest.cc +++ b/test/DefaultPieceStorageTest.cc @@ -33,19 +33,19 @@ class DefaultPieceStorageTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGetCompletedLength); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; SharedHandle<Peer> peer; Option* option; - SharedHandle<PieceSelector> _pieceSelector; + SharedHandle<PieceSelector> pieceSelector_; public: void setUp() { - _dctx.reset(new DownloadContext()); - bittorrent::load("test.torrent", _dctx); + dctx_.reset(new DownloadContext()); + bittorrent::load("test.torrent", dctx_); peer.reset(new Peer("192.168.0.1", 6889)); - peer->allocateSessionResource(_dctx->getPieceLength(), - _dctx->getTotalLength()); + peer->allocateSessionResource(dctx_->getPieceLength(), + dctx_->getTotalLength()); option = new Option(); - _pieceSelector.reset(new InOrderPieceSelector()); + pieceSelector_.reset(new InOrderPieceSelector()); } void tearDown() @@ -73,14 +73,14 @@ public: CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest); void DefaultPieceStorageTest::testGetTotalLength() { - DefaultPieceStorage pss(_dctx, option); + DefaultPieceStorage pss(dctx_, option); CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, pss.getTotalLength()); } void DefaultPieceStorageTest::testGetMissingPiece() { - DefaultPieceStorage pss(_dctx, option); - pss.setPieceSelector(_pieceSelector); + DefaultPieceStorage pss(dctx_, option); + pss.setPieceSelector(pieceSelector_); pss.setEndGamePieceNum(0); peer->setAllBitfield(); @@ -100,8 +100,8 @@ void DefaultPieceStorageTest::testGetMissingPiece() { void DefaultPieceStorageTest::testGetMissingPiece_excludedIndexes() { - DefaultPieceStorage pss(_dctx, option); - pss.setPieceSelector(_pieceSelector); + DefaultPieceStorage pss(dctx_, option); + pss.setPieceSelector(pieceSelector_); pss.setEndGamePieceNum(0); peer->setAllBitfield(); @@ -122,8 +122,8 @@ void DefaultPieceStorageTest::testGetMissingPiece_excludedIndexes() } void DefaultPieceStorageTest::testGetMissingFastPiece() { - DefaultPieceStorage pss(_dctx, option); - pss.setPieceSelector(_pieceSelector); + DefaultPieceStorage pss(dctx_, option); + pss.setPieceSelector(pieceSelector_); pss.setEndGamePieceNum(0); peer->setAllBitfield(); @@ -139,8 +139,8 @@ void DefaultPieceStorageTest::testGetMissingFastPiece() { void DefaultPieceStorageTest::testGetMissingFastPiece_excludedIndexes() { - DefaultPieceStorage pss(_dctx, option); - pss.setPieceSelector(_pieceSelector); + DefaultPieceStorage pss(dctx_, option); + pss.setPieceSelector(pieceSelector_); pss.setEndGamePieceNum(0); peer->setAllBitfield(); @@ -159,7 +159,7 @@ void DefaultPieceStorageTest::testGetMissingFastPiece_excludedIndexes() } void DefaultPieceStorageTest::testHasMissingPiece() { - DefaultPieceStorage pss(_dctx, option); + DefaultPieceStorage pss(dctx_, option); CPPUNIT_ASSERT(!pss.hasMissingPiece(peer)); @@ -169,8 +169,8 @@ void DefaultPieceStorageTest::testHasMissingPiece() { } void DefaultPieceStorageTest::testCompletePiece() { - DefaultPieceStorage pss(_dctx, option); - pss.setPieceSelector(_pieceSelector); + DefaultPieceStorage pss(dctx_, option); + pss.setPieceSelector(pieceSelector_); pss.setEndGamePieceNum(0); peer->setAllBitfield(); @@ -191,7 +191,7 @@ void DefaultPieceStorageTest::testCompletePiece() { } void DefaultPieceStorageTest::testGetPiece() { - DefaultPieceStorage pss(_dctx, option); + DefaultPieceStorage pss(dctx_, option); SharedHandle<Piece> pieceGot = pss.getPiece(0); CPPUNIT_ASSERT_EQUAL((size_t)0, pieceGot->getIndex()); @@ -200,7 +200,7 @@ void DefaultPieceStorageTest::testGetPiece() { } void DefaultPieceStorageTest::testGetPieceInUsedPieces() { - DefaultPieceStorage pss(_dctx, option); + DefaultPieceStorage pss(dctx_, option); SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128)); piece->completeBlock(0); pss.addUsedPiece(piece); @@ -211,7 +211,7 @@ void DefaultPieceStorageTest::testGetPieceInUsedPieces() { } void DefaultPieceStorageTest::testGetPieceCompletedPiece() { - DefaultPieceStorage pss(_dctx, option); + DefaultPieceStorage pss(dctx_, option); SharedHandle<Piece> piece = SharedHandle<Piece>(new Piece(0, 128)); pss.completePiece(piece); SharedHandle<Piece> pieceGot = pss.getPiece(0); diff --git a/test/DownloadHandlerFactoryTest.cc b/test/DownloadHandlerFactoryTest.cc index 0e384661..bf59c430 100644 --- a/test/DownloadHandlerFactoryTest.cc +++ b/test/DownloadHandlerFactoryTest.cc @@ -25,11 +25,11 @@ class DownloadHandlerFactoryTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); } #ifdef ENABLE_METALINK void testGetMetalinkPreDownloadHandler_extension(); @@ -51,7 +51,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( DownloadHandlerFactoryTest ); void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_extension() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test.metalink")); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler(); @@ -66,7 +66,7 @@ void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_contentType() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test")); dctx->getFirstFileEntry()->setContentType("application/metalink+xml"); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getMetalinkPreDownloadHandler(); @@ -84,7 +84,7 @@ void DownloadHandlerFactoryTest::testGetMetalinkPreDownloadHandler_contentType() void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_extension() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test.torrent")); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler(); @@ -99,7 +99,7 @@ void DownloadHandlerFactoryTest::testGetBtPreDownloadHandler_contentType() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test")); dctx->getFirstFileEntry()->setContentType("application/x-bittorrent"); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); SharedHandle<PreDownloadHandler> handler = DownloadHandlerFactory::getBtPreDownloadHandler(); diff --git a/test/DownloadHelperTest.cc b/test/DownloadHelperTest.cc index 79524371..c310df7e 100644 --- a/test/DownloadHelperTest.cc +++ b/test/DownloadHelperTest.cc @@ -35,11 +35,11 @@ class DownloadHelperTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); } void tearDown() {} @@ -70,13 +70,13 @@ void DownloadHelperTest::testCreateRequestGroupForUri() "http://charlie/file" }; std::vector<std::string> uris(vbegin(array), vend(array)); - _option->put(PREF_SPLIT, "3"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); + option_->put(PREF_SPLIT, "3"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); SharedHandle<RequestGroup> group = result[0]; @@ -91,11 +91,11 @@ void DownloadHelperTest::testCreateRequestGroupForUri() CPPUNIT_ASSERT_EQUAL(std::string("/tmp"), ctx->getDir()); CPPUNIT_ASSERT_EQUAL(std::string("/tmp/file.out"), ctx->getBasePath()); } - _option->put(PREF_SPLIT, "5"); + option_->put(PREF_SPLIT, "5"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); SharedHandle<RequestGroup> group = result[0]; @@ -110,11 +110,11 @@ void DownloadHelperTest::testCreateRequestGroupForUri() } CPPUNIT_ASSERT_EQUAL((unsigned int)5, group->getNumConcurrentCommand()); } - _option->put(PREF_SPLIT, "2"); + option_->put(PREF_SPLIT, "2"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); SharedHandle<RequestGroup> group = result[0]; @@ -126,11 +126,11 @@ void DownloadHelperTest::testCreateRequestGroupForUri() } CPPUNIT_ASSERT_EQUAL((unsigned int)2, group->getNumConcurrentCommand()); } - _option->put(PREF_FORCE_SEQUENTIAL, V_TRUE); + option_->put(PREF_FORCE_SEQUENTIAL, V_TRUE); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)3, result.size()); @@ -158,14 +158,14 @@ void DownloadHelperTest::testCreateRequestGroupForUri_parameterized() "http://charlie/file" }; std::vector<std::string> uris(vbegin(array), vend(array)); - _option->put(PREF_SPLIT, "3"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); - _option->put(PREF_PARAMETERIZED_URI, V_TRUE); + option_->put(PREF_SPLIT, "3"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); + option_->put(PREF_PARAMETERIZED_URI, V_TRUE); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); SharedHandle<RequestGroup> group = result[0]; @@ -194,13 +194,13 @@ void DownloadHelperTest::testCreateRequestGroupForUri_BitTorrent() "http://charlie/file" }; std::vector<std::string> uris(vbegin(array), vend(array)); - _option->put(PREF_SPLIT, "3"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); + option_->put(PREF_SPLIT, "3"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)2, result.size()); SharedHandle<RequestGroup> group = result[0]; @@ -242,14 +242,14 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink() "test.xml" }; std::vector<std::string> uris(vbegin(array), vend(array)); - _option->put(PREF_SPLIT, "3"); - _option->put(PREF_METALINK_SERVERS, "2"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); + option_->put(PREF_SPLIT, "3"); + option_->put(PREF_METALINK_SERVERS, "2"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUri(result, _option, uris); + createRequestGroupForUri(result, option_, uris); // group1: http://alpha/file, ... // group2-7: 6 file entry in Metalink and 1 torrent file download @@ -290,14 +290,14 @@ void DownloadHelperTest::testCreateRequestGroupForUri_Metalink() void DownloadHelperTest::testCreateRequestGroupForUriList() { - _option->put(PREF_SPLIT, "3"); - _option->put(PREF_INPUT_FILE, "input_uris.txt"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); + option_->put(PREF_SPLIT, "3"); + option_->put(PREF_INPUT_FILE, "input_uris.txt"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForUriList(result, _option); + createRequestGroupForUriList(result, option_); CPPUNIT_ASSERT_EQUAL((size_t)2, result.size()); @@ -330,14 +330,14 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent() }; std::vector<std::string> auxURIs(vbegin(array), vend(array)); - _option->put(PREF_SPLIT, "5"); - _option->put(PREF_TORRENT_FILE, "test.torrent"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); + option_->put(PREF_SPLIT, "5"); + option_->put(PREF_TORRENT_FILE, "test.torrent"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForBitTorrent(result, _option, auxURIs); + createRequestGroupForBitTorrent(result, option_, auxURIs); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); @@ -355,7 +355,7 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent() // no URIs are given std::vector<SharedHandle<RequestGroup> > result; std::vector<std::string> emptyURIs; - createRequestGroupForBitTorrent(result, _option, emptyURIs); + createRequestGroupForBitTorrent(result, option_, emptyURIs); CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); SharedHandle<RequestGroup> group = result[0]; @@ -363,11 +363,11 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent() group->getDownloadContext()->getFirstFileEntry()->getUris(uris); CPPUNIT_ASSERT_EQUAL((size_t)0, uris.size()); } - _option->put(PREF_FORCE_SEQUENTIAL, V_TRUE); + option_->put(PREF_FORCE_SEQUENTIAL, V_TRUE); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForBitTorrent(result, _option, auxURIs); + createRequestGroupForBitTorrent(result, option_, auxURIs); // See --force-requencial is ignored CPPUNIT_ASSERT_EQUAL((size_t)1, result.size()); @@ -378,15 +378,15 @@ void DownloadHelperTest::testCreateRequestGroupForBitTorrent() #ifdef ENABLE_METALINK void DownloadHelperTest::testCreateRequestGroupForMetalink() { - _option->put(PREF_SPLIT, "3"); - _option->put(PREF_METALINK_FILE, "test.xml"); - _option->put(PREF_METALINK_SERVERS, "5"); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_OUT, "file.out"); + option_->put(PREF_SPLIT, "3"); + option_->put(PREF_METALINK_FILE, "test.xml"); + option_->put(PREF_METALINK_SERVERS, "5"); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_OUT, "file.out"); { std::vector<SharedHandle<RequestGroup> > result; - createRequestGroupForMetalink(result, _option); + createRequestGroupForMetalink(result, option_); #ifdef ENABLE_BITTORRENT CPPUNIT_ASSERT_EQUAL((size_t)6, result.size()); diff --git a/test/FeedbackURISelectorTest.cc b/test/FeedbackURISelectorTest.cc index 2785b398..dd6813bc 100644 --- a/test/FeedbackURISelectorTest.cc +++ b/test/FeedbackURISelectorTest.cc @@ -19,7 +19,7 @@ class FeedbackURISelectorTest:public CppUnit::TestFixture { CPPUNIT_TEST(testSelect_skipErrorHost); CPPUNIT_TEST_SUITE_END(); private: - FileEntry _fileEntry; + FileEntry fileEntry_; SharedHandle<ServerStatMan> ssm; @@ -36,7 +36,7 @@ public: std::vector<std::string> uris; uris.assign(vbegin(urisSrc), vend(urisSrc)); - _fileEntry.setUris(uris); + fileEntry_.setUris(uris); ssm.reset(new ServerStatMan()); sel.reset(new FeedbackURISelector(ssm)); @@ -57,9 +57,9 @@ CPPUNIT_TEST_SUITE_REGISTRATION(FeedbackURISelectorTest); void FeedbackURISelectorTest::testSelect_withoutServerStat() { // Without ServerStat, selector returns first URI - std::string uri = sel->select(&_fileEntry); + std::string uri = sel->select(&fileEntry_); CPPUNIT_ASSERT_EQUAL(std::string("http://alpha/file"), uri); - CPPUNIT_ASSERT_EQUAL((size_t)2, _fileEntry.getRemainingUris().size()); + CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntry_.getRemainingUris().size()); } void FeedbackURISelectorTest::testSelect() @@ -77,12 +77,12 @@ void FeedbackURISelectorTest::testSelect() ssm->add(alphaHTTP); CPPUNIT_ASSERT_EQUAL(std::string("http://bravo/file"), - sel->select(&_fileEntry)); - CPPUNIT_ASSERT_EQUAL((size_t)2, _fileEntry.getRemainingUris().size()); + sel->select(&fileEntry_)); + CPPUNIT_ASSERT_EQUAL((size_t)2, fileEntry_.getRemainingUris().size()); CPPUNIT_ASSERT_EQUAL(std::string("ftp://alpha/file"), - sel->select(&_fileEntry)); - CPPUNIT_ASSERT_EQUAL((size_t)1, _fileEntry.getRemainingUris().size()); + sel->select(&fileEntry_)); + CPPUNIT_ASSERT_EQUAL((size_t)1, fileEntry_.getRemainingUris().size()); } void FeedbackURISelectorTest::testSelect_skipErrorHost() @@ -97,8 +97,8 @@ void FeedbackURISelectorTest::testSelect_skipErrorHost() // See error URIs are removed from URI List. CPPUNIT_ASSERT_EQUAL(std::string("http://bravo/file"), - sel->select(&_fileEntry)); - CPPUNIT_ASSERT_EQUAL((size_t)0, _fileEntry.getRemainingUris().size()); + sel->select(&fileEntry_)); + CPPUNIT_ASSERT_EQUAL((size_t)0, fileEntry_.getRemainingUris().size()); } } // namespace aria2 diff --git a/test/FtpConnectionTest.cc b/test/FtpConnectionTest.cc index 0eade96a..6e5bae21 100644 --- a/test/FtpConnectionTest.cc +++ b/test/FtpConnectionTest.cc @@ -35,17 +35,17 @@ class FtpConnectionTest:public CppUnit::TestFixture { CPPUNIT_TEST(testSendRetr); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<SocketCore> _serverSocket; - uint16_t _listenPort; - SharedHandle<SocketCore> _clientSocket; - SharedHandle<FtpConnection> _ftp; - SharedHandle<Option> _option; - SharedHandle<AuthConfigFactory> _authConfigFactory; + SharedHandle<SocketCore> serverSocket_; + uint16_t listenPort_; + SharedHandle<SocketCore> clientSocket_; + SharedHandle<FtpConnection> ftp_; + SharedHandle<Option> option_; + SharedHandle<AuthConfigFactory> authConfigFactory_; public: void setUp() { - _option.reset(new Option()); - _authConfigFactory.reset(new AuthConfigFactory()); + option_.reset(new Option()); + authConfigFactory_.reset(new AuthConfigFactory()); //_ftpServerSocket.reset(new SocketCore()); SharedHandle<SocketCore> listenSocket(new SocketCore()); @@ -53,22 +53,22 @@ public: listenSocket->beginListen(); std::pair<std::string, uint16_t> addrinfo; listenSocket->getAddrInfo(addrinfo); - _listenPort = addrinfo.second; + listenPort_ = addrinfo.second; SharedHandle<Request> req(new Request()); req->setUri("ftp://localhost/dir%20sp/hello%20world.img"); - _clientSocket.reset(new SocketCore()); - _clientSocket->establishConnection("localhost", _listenPort); + clientSocket_.reset(new SocketCore()); + clientSocket_->establishConnection("localhost", listenPort_); - while(!_clientSocket->isWritable(0)); - _clientSocket->setBlockingMode(); + while(!clientSocket_->isWritable(0)); + clientSocket_->setBlockingMode(); - _serverSocket.reset(listenSocket->acceptConnection()); - _ftp.reset(new FtpConnection(1, _clientSocket, req, - _authConfigFactory->createAuthConfig - (req, _option.get()), - _option.get())); + serverSocket_.reset(listenSocket->acceptConnection()); + ftp_.reset(new FtpConnection(1, clientSocket_, req, + authConfigFactory_->createAuthConfig + (req, option_.get()), + option_.get())); } void tearDown() {} @@ -98,53 +98,53 @@ static void waitRead(const SharedHandle<SocketCore>& socket) void FtpConnectionTest::testReceiveResponse() { - _serverSocket->writeData("100"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); - _serverSocket->writeData(" single line response"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); - _serverSocket->writeData("\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)100, _ftp->receiveResponse()); + serverSocket_->writeData("100"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); + serverSocket_->writeData(" single line response"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); + serverSocket_->writeData("\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)100, ftp_->receiveResponse()); // 2 responses in the buffer - _serverSocket->writeData("101 single1\r\n" + serverSocket_->writeData("101 single1\r\n" "102 single2\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)101, _ftp->receiveResponse()); - CPPUNIT_ASSERT_EQUAL((unsigned int)102, _ftp->receiveResponse()); - - _serverSocket->writeData("103-multi line response\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); - _serverSocket->writeData("103-line2\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); - _serverSocket->writeData("103"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); - _serverSocket->writeData(" "); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); - _serverSocket->writeData("last\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)103, _ftp->receiveResponse()); - - _serverSocket->writeData("104-multi\r\n" + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)101, ftp_->receiveResponse()); + CPPUNIT_ASSERT_EQUAL((unsigned int)102, ftp_->receiveResponse()); + + serverSocket_->writeData("103-multi line response\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); + serverSocket_->writeData("103-line2\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); + serverSocket_->writeData("103"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); + serverSocket_->writeData(" "); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); + serverSocket_->writeData("last\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)103, ftp_->receiveResponse()); + + serverSocket_->writeData("104-multi\r\n" "104 \r\n" "105-multi\r\n" "105 \r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)104, _ftp->receiveResponse()); - CPPUNIT_ASSERT_EQUAL((unsigned int)105, _ftp->receiveResponse()); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)104, ftp_->receiveResponse()); + CPPUNIT_ASSERT_EQUAL((unsigned int)105, ftp_->receiveResponse()); } void FtpConnectionTest::testSendMdtm() { - _ftp->sendMdtm(); + ftp_->sendMdtm(); char data[32]; size_t len = sizeof(data); - _serverSocket->readData(data, len); + serverSocket_->readData(data, len); data[len] = '\0'; CPPUNIT_ASSERT_EQUAL(std::string("MDTM hello world.img\r\n"), std::string(data)); @@ -154,44 +154,44 @@ void FtpConnectionTest::testReceiveMdtmResponse() { { Time t; - _serverSocket->writeData("213 20080908124312"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveMdtmResponse(t)); - _serverSocket->writeData("\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)213, _ftp->receiveMdtmResponse(t)); + serverSocket_->writeData("213 20080908124312"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveMdtmResponse(t)); + serverSocket_->writeData("\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveMdtmResponse(t)); CPPUNIT_ASSERT_EQUAL((time_t)1220877792, t.getTime()); } { // see milli second part is ignored Time t; - _serverSocket->writeData("213 20080908124312.014\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)213, _ftp->receiveMdtmResponse(t)); + serverSocket_->writeData("213 20080908124312.014\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveMdtmResponse(t)); CPPUNIT_ASSERT_EQUAL((time_t)1220877792, t.getTime()); } { // hhmmss part is missing Time t; - _serverSocket->writeData("213 20080908\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)213, _ftp->receiveMdtmResponse(t)); + serverSocket_->writeData("213 20080908\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveMdtmResponse(t)); CPPUNIT_ASSERT(t.bad()); } { // invalid month: 19, we don't care about invalid month.. Time t; - _serverSocket->writeData("213 20081908124312\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)213, _ftp->receiveMdtmResponse(t)); + serverSocket_->writeData("213 20081908124312\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveMdtmResponse(t)); // Wed Jul 8 12:43:12 2009 CPPUNIT_ASSERT_EQUAL((time_t)1247056992, t.getTime()); } { Time t; - _serverSocket->writeData("550 File Not Found\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)550, _ftp->receiveMdtmResponse(t)); + serverSocket_->writeData("550 File Not Found\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)550, ftp_->receiveMdtmResponse(t)); } } @@ -201,14 +201,14 @@ void FtpConnectionTest::testReceiveResponse_overflow() memset(data, 0, sizeof(data)); memcpy(data, "213 ", 4); for(int i = 0; i < 64; ++i) { - _serverSocket->writeData(data, sizeof(data)); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receiveResponse()); + serverSocket_->writeData(data, sizeof(data)); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receiveResponse()); } - _serverSocket->writeData(data, sizeof(data)); - waitRead(_clientSocket); + serverSocket_->writeData(data, sizeof(data)); + waitRead(clientSocket_); try { - _ftp->receiveResponse(); + ftp_->receiveResponse(); CPPUNIT_FAIL("exception must be thrown."); } catch(DlRetryEx& e) { // success @@ -217,10 +217,10 @@ void FtpConnectionTest::testReceiveResponse_overflow() void FtpConnectionTest::testSendPwd() { - _ftp->sendPwd(); + ftp_->sendPwd(); char data[32]; size_t len = sizeof(data); - _serverSocket->readData(data, len); + serverSocket_->readData(data, len); CPPUNIT_ASSERT_EQUAL((size_t)5, len); data[len] = '\0'; CPPUNIT_ASSERT_EQUAL(std::string("PWD\r\n"), std::string(data)); @@ -229,23 +229,23 @@ void FtpConnectionTest::testSendPwd() void FtpConnectionTest::testReceivePwdResponse() { std::string pwd; - _serverSocket->writeData("257 "); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)0, _ftp->receivePwdResponse(pwd)); + serverSocket_->writeData("257 "); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)0, ftp_->receivePwdResponse(pwd)); CPPUNIT_ASSERT(pwd.empty()); - _serverSocket->writeData("\"/dir/to\" is your directory.\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)257, _ftp->receivePwdResponse(pwd)); + serverSocket_->writeData("\"/dir/to\" is your directory.\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)257, ftp_->receivePwdResponse(pwd)); CPPUNIT_ASSERT_EQUAL(std::string("/dir/to"), pwd); } void FtpConnectionTest::testReceivePwdResponse_unquotedResponse() { std::string pwd; - _serverSocket->writeData("257 /dir/to\r\n"); - waitRead(_clientSocket); + serverSocket_->writeData("257 /dir/to\r\n"); + waitRead(clientSocket_); try { - _ftp->receivePwdResponse(pwd); + ftp_->receivePwdResponse(pwd); CPPUNIT_FAIL("exception must be thrown."); } catch(DlAbortEx& e) { // success @@ -255,58 +255,58 @@ void FtpConnectionTest::testReceivePwdResponse_unquotedResponse() void FtpConnectionTest::testReceivePwdResponse_badStatus() { std::string pwd; - _serverSocket->writeData("500 failed\r\n"); - waitRead(_clientSocket); - CPPUNIT_ASSERT_EQUAL((unsigned int)500, _ftp->receivePwdResponse(pwd)); + serverSocket_->writeData("500 failed\r\n"); + waitRead(clientSocket_); + CPPUNIT_ASSERT_EQUAL((unsigned int)500, ftp_->receivePwdResponse(pwd)); CPPUNIT_ASSERT(pwd.empty()); } void FtpConnectionTest::testSendCwd() { - _ftp->sendCwd(); + ftp_->sendCwd(); char data[32]; size_t len = sizeof(data); - _serverSocket->readData(data, len); + serverSocket_->readData(data, len); data[len] = '\0'; CPPUNIT_ASSERT_EQUAL(std::string("CWD /dir sp\r\n"), std::string(data)); } void FtpConnectionTest::testSendCwd_baseWorkingDir() { - _ftp->setBaseWorkingDir("/base"); - _ftp->sendCwd(); + ftp_->setBaseWorkingDir("/base"); + ftp_->sendCwd(); char data[32]; size_t len = sizeof(data); - _serverSocket->readData(data, len); + serverSocket_->readData(data, len); data[len] = '\0'; CPPUNIT_ASSERT_EQUAL(std::string("CWD /base/dir sp\r\n"), std::string(data)); } void FtpConnectionTest::testSendSize() { - _ftp->sendSize(); + ftp_->sendSize(); char data[32]; size_t len = sizeof(data); - _serverSocket->readData(data, len); + serverSocket_->readData(data, len); CPPUNIT_ASSERT_EQUAL(std::string("SIZE hello world.img\r\n"), std::string(&data[0], &data[len])); } void FtpConnectionTest::testReceiveSizeResponse() { - _serverSocket->writeData("213 4294967296\r\n"); - waitRead(_clientSocket); + serverSocket_->writeData("213 4294967296\r\n"); + waitRead(clientSocket_); uint64_t size; - CPPUNIT_ASSERT_EQUAL((unsigned int)213, _ftp->receiveSizeResponse(size)); + CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveSizeResponse(size)); CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296LL, size); } void FtpConnectionTest::testSendRetr() { - _ftp->sendRetr(); + ftp_->sendRetr(); char data[32]; size_t len = sizeof(data); - _serverSocket->readData(data, len); + serverSocket_->readData(data, len); CPPUNIT_ASSERT_EQUAL(std::string("RETR hello world.img\r\n"), std::string(&data[0], &data[len])); } diff --git a/test/HttpRequestTest.cc b/test/HttpRequestTest.cc index f1dd9a5f..16096391 100644 --- a/test/HttpRequestTest.cc +++ b/test/HttpRequestTest.cc @@ -37,14 +37,14 @@ class HttpRequestTest : public CppUnit::TestFixture { CPPUNIT_TEST(testEnableAcceptEncoding); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; - SharedHandle<AuthConfigFactory> _authConfigFactory; + SharedHandle<Option> option_; + SharedHandle<AuthConfigFactory> authConfigFactory_; public: void setUp() { - _option.reset(new Option()); - _option->put(PREF_HTTP_AUTH_CHALLENGE, V_TRUE); - _authConfigFactory.reset(new AuthConfigFactory()); + option_.reset(new Option()); + option_->put(PREF_HTTP_AUTH_CHALLENGE, V_TRUE); + authConfigFactory_.reset(new AuthConfigFactory()); } void testGetStartByte(); @@ -137,7 +137,7 @@ void HttpRequestTest::testCreateRequest() httpRequest.setRequest(request); httpRequest.setSegment(segment); httpRequest.setFileEntry(fileEntry); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); // remove "Connection: close" and add end byte range request->setPipeliningHint(true); @@ -235,11 +235,11 @@ void HttpRequestTest::testCreateRequest() httpRequest.setSegment(segment); // enable http auth - _option->put(PREF_HTTP_USER, "aria2user"); - _option->put(PREF_HTTP_PASSWD, "aria2passwd"); + option_->put(PREF_HTTP_USER, "aria2user"); + option_->put(PREF_HTTP_PASSWD, "aria2passwd"); - CPPUNIT_ASSERT(_authConfigFactory->activateBasicCred - ("localhost", "/", _option.get())); + CPPUNIT_ASSERT(authConfigFactory_->activateBasicCred + ("localhost", "/", option_.get())); expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n" "User-Agent: aria2\r\n" @@ -310,8 +310,8 @@ void HttpRequestTest::testCreateRequest() void HttpRequestTest::testCreateRequest_ftp() { - _option->put(PREF_FTP_USER, "aria2user"); - _option->put(PREF_FTP_PASSWD, "aria2passwd"); + option_->put(PREF_FTP_USER, "aria2user"); + option_->put(PREF_FTP_PASSWD, "aria2passwd"); SharedHandle<Request> request(new Request()); request->setUri("ftp://localhost:8080/archives/aria2-1.0.0.tar.bz2"); @@ -330,7 +330,7 @@ void HttpRequestTest::testCreateRequest_ftp() httpRequest.setRequest(request); httpRequest.setSegment(segment); httpRequest.setFileEntry(fileEntry); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); httpRequest.setProxyRequest(proxyRequest); std::string expectedText = @@ -396,7 +396,7 @@ void HttpRequestTest::testCreateRequest_with_cookie() httpRequest.setSegment(segment); httpRequest.setFileEntry(fileEntry); httpRequest.setCookieStorage(st); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); std::string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n" "User-Agent: aria2\r\n" @@ -462,7 +462,7 @@ void HttpRequestTest::testCreateRequest_query() HttpRequest httpRequest; httpRequest.disableContentEncoding(); httpRequest.setRequest(request); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); std::string expectedText = "GET /wiki?id=9ad5109a-b8a5-4edf-9373-56a1c34ae138 HTTP/1.1\r\n" @@ -485,7 +485,7 @@ void HttpRequestTest::testCreateRequest_head() HttpRequest httpRequest; httpRequest.setRequest(request); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); std::stringstream result(httpRequest.createRequest()); std::string line; @@ -626,7 +626,7 @@ void HttpRequestTest::testUserAgent() httpRequest.setRequest(request); //httpRequest.setSegment(segment); httpRequest.setUserAgent("aria2 (Linux)"); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); std::string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n" "User-Agent: aria2 (Linux)\r\n" @@ -661,7 +661,7 @@ void HttpRequestTest::testAddHeader() HttpRequest httpRequest; httpRequest.disableContentEncoding(); httpRequest.setRequest(request); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); httpRequest.addHeader("X-ARIA2: v0.13\nX-ARIA2-DISTRIBUTE: enabled\n"); httpRequest.addHeader("Accept: text/html"); std::string expectedText = "GET /archives/aria2-1.0.0.tar.bz2 HTTP/1.1\r\n" @@ -689,7 +689,7 @@ void HttpRequestTest::testAddAcceptType() HttpRequest httpRequest; httpRequest.disableContentEncoding(); httpRequest.setRequest(request); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); httpRequest.addAcceptType(vbegin(acceptTypes), vend(acceptTypes)); std::string expectedText = @@ -712,7 +712,7 @@ void HttpRequestTest::testEnableAcceptEncoding() HttpRequest httpRequest; httpRequest.setRequest(request); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); std::string acceptEncodings; #ifdef HAVE_LIBZ @@ -753,7 +753,7 @@ void HttpRequestTest::testCreateRequest_ipv6LiteralAddr() HttpRequest httpRequest; httpRequest.disableContentEncoding(); httpRequest.setRequest(request); - httpRequest.setAuthConfigFactory(_authConfigFactory, _option.get()); + httpRequest.setAuthConfigFactory(authConfigFactory_, option_.get()); CPPUNIT_ASSERT(httpRequest.createRequest().find("Host: [::1]") != std::string::npos); diff --git a/test/InOrderURISelectorTest.cc b/test/InOrderURISelectorTest.cc index cd6d6300..c187d979 100644 --- a/test/InOrderURISelectorTest.cc +++ b/test/InOrderURISelectorTest.cc @@ -15,7 +15,7 @@ class InOrderURISelectorTest:public CppUnit::TestFixture { CPPUNIT_TEST(testSelect); CPPUNIT_TEST_SUITE_END(); private: - FileEntry _fileEntry; + FileEntry fileEntry_; SharedHandle<InOrderURISelector> sel; @@ -30,7 +30,7 @@ public: std::vector<std::string> uris; uris.assign(vbegin(urisSrc), vend(urisSrc)); - _fileEntry.setUris(uris); + fileEntry_.setUris(uris); sel.reset(new InOrderURISelector()); } @@ -46,12 +46,12 @@ CPPUNIT_TEST_SUITE_REGISTRATION(InOrderURISelectorTest); void InOrderURISelectorTest::testSelect() { CPPUNIT_ASSERT_EQUAL(std::string("http://alpha/file"), - sel->select(&_fileEntry)); + sel->select(&fileEntry_)); CPPUNIT_ASSERT_EQUAL(std::string("ftp://alpha/file"), - sel->select(&_fileEntry)); + sel->select(&fileEntry_)); CPPUNIT_ASSERT_EQUAL(std::string("http://bravo/file"), - sel->select(&_fileEntry)); - CPPUNIT_ASSERT_EQUAL(std::string(""), sel->select(&_fileEntry)); + sel->select(&fileEntry_)); + CPPUNIT_ASSERT_EQUAL(std::string(""), sel->select(&fileEntry_)); } } // namespace aria2 diff --git a/test/MSEHandshakeTest.cc b/test/MSEHandshakeTest.cc index 82ec7cd1..2eec9789 100644 --- a/test/MSEHandshakeTest.cc +++ b/test/MSEHandshakeTest.cc @@ -22,7 +22,7 @@ class MSEHandshakeTest:public CppUnit::TestFixture { CPPUNIT_TEST(testHandshake); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<DownloadContext> _dctx; + SharedHandle<DownloadContext> dctx_; void doHandshake(const SharedHandle<MSEHandshake>& initiator, const SharedHandle<MSEHandshake>& receiver); @@ -30,12 +30,12 @@ private: public: void setUp() { - _dctx.reset(new DownloadContext()); + dctx_.reset(new DownloadContext()); unsigned char infoHash[20]; memset(infoHash, 0, sizeof(infoHash)); SharedHandle<TorrentAttribute> torrentAttrs(new TorrentAttribute()); torrentAttrs->infoHash = std::string(vbegin(infoHash), vend(infoHash)); - _dctx->setAttribute(bittorrent::BITTORRENT, torrentAttrs); + dctx_->setAttribute(bittorrent::BITTORRENT, torrentAttrs); } void testHandshake(); @@ -73,12 +73,12 @@ void MSEHandshakeTest::doHandshake(const SharedHandle<MSEHandshake>& initiator, receiver->sendPublicKey(); while(!initiator->receivePublicKey()); - initiator->initCipher(bittorrent::getInfoHash(_dctx)); + initiator->initCipher(bittorrent::getInfoHash(dctx_)); initiator->sendInitiatorStep2(); while(!receiver->findReceiverHashMarker()); std::vector<SharedHandle<DownloadContext> > contexts; - contexts.push_back(_dctx); + contexts.push_back(dctx_); while(!receiver->receiveReceiverHashAndPadCLength(contexts)); while(!receiver->receivePad()); while(!receiver->receiveReceiverIALength()); diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc index b2450b46..ce07dbc8 100644 --- a/test/Metalink2RequestGroupTest.cc +++ b/test/Metalink2RequestGroupTest.cc @@ -21,13 +21,13 @@ class Metalink2RequestGroupTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGenerate_dosDirTraversal); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); - _option->put(PREF_SPLIT, "1"); + option_.reset(new Option()); + option_->put(PREF_SPLIT, "1"); } void testGenerate(); @@ -41,8 +41,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( Metalink2RequestGroupTest ); void Metalink2RequestGroupTest::testGenerate() { std::vector<SharedHandle<RequestGroup> > groups; - _option->put(PREF_DIR, "/tmp"); - Metalink2RequestGroup().generate(groups, "test.xml", _option); + option_->put(PREF_DIR, "/tmp"); + Metalink2RequestGroup().generate(groups, "test.xml", option_); // first file { SharedHandle<RequestGroup> rg = groups[0]; @@ -134,7 +134,7 @@ void Metalink2RequestGroupTest::testGenerate_groupByMetaurl() { std::vector<SharedHandle<RequestGroup> > groups; Metalink2RequestGroup().generate(groups, "metalink4-groupbymetaurl.xml", - _option); + option_); CPPUNIT_ASSERT_EQUAL((size_t)3, groups.size()); #ifdef ENABLE_BITTORRENT @@ -207,9 +207,9 @@ void Metalink2RequestGroupTest::testGenerate_dosDirTraversal() #ifdef __MINGW32__ #ifdef ENABLE_BITTORRENT std::vector<SharedHandle<RequestGroup> > groups; - _option->put(PREF_DIR, "/tmp"); + option_->put(PREF_DIR, "/tmp"); Metalink2RequestGroup().generate - (groups, "metalink4-dosdirtraversal.xml", _option); + (groups, "metalink4-dosdirtraversal.xml", option_); CPPUNIT_ASSERT_EQUAL((size_t)3, groups.size()); SharedHandle<RequestGroup> rg = groups[0]; SharedHandle<FileEntry> file = rg->getDownloadContext()->getFirstFileEntry(); diff --git a/test/MetalinkPostDownloadHandlerTest.cc b/test/MetalinkPostDownloadHandlerTest.cc index e4844f15..6e476cb1 100644 --- a/test/MetalinkPostDownloadHandlerTest.cc +++ b/test/MetalinkPostDownloadHandlerTest.cc @@ -17,11 +17,11 @@ class MetalinkPostDownloadHandlerTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGetNextRequestGroups); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); } void testCanHandle_extension(); @@ -36,7 +36,7 @@ void MetalinkPostDownloadHandlerTest::testCanHandle_extension() { SharedHandle<DownloadContext> dctx (new DownloadContext(0, 0, "test.metalink")); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); MetalinkPostDownloadHandler handler; @@ -51,7 +51,7 @@ void MetalinkPostDownloadHandlerTest::testCanHandle_contentType() { SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0, "test")); dctx->getFirstFileEntry()->setContentType("application/metalink+xml"); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); MetalinkPostDownloadHandler handler; @@ -66,7 +66,7 @@ void MetalinkPostDownloadHandlerTest::testGetNextRequestGroups() { SharedHandle<DownloadContext> dctx (new DownloadContext(1024, 0, "test.xml")); - RequestGroup rg(_option); + RequestGroup rg(option_); rg.setDownloadContext(dctx); rg.initPieceStorage(); diff --git a/test/MockBtMessage.h b/test/MockBtMessage.h index 13324a24..fe3204af 100644 --- a/test/MockBtMessage.h +++ b/test/MockBtMessage.h @@ -99,9 +99,9 @@ public: template<typename T> class WrapBtMessage:public MockBtMessage { public: - SharedHandle<T> _m; + SharedHandle<T> m_; - WrapBtMessage(const SharedHandle<T>& m):_m(m) {} + WrapBtMessage(const SharedHandle<T>& m):m_(m) {} }; diff --git a/test/MockDHTMessage.h b/test/MockDHTMessage.h index d608bf2d..665d61a4 100644 --- a/test/MockDHTMessage.h +++ b/test/MockDHTMessage.h @@ -16,21 +16,21 @@ class DHTMessageCallback; class MockDHTMessage:public DHTMessage { public: - bool _isReply; + bool isReply_; - std::string _messageType; + std::string messageType_; - std::vector<SharedHandle<DHTNode> > _nodes; + std::vector<SharedHandle<DHTNode> > nodes_; - std::vector<SharedHandle<Peer> > _peers; + std::vector<SharedHandle<Peer> > peers_; - std::string _token; + std::string token_; public: MockDHTMessage(const SharedHandle<DHTNode>& localNode, const SharedHandle<DHTNode>& remoteNode, const std::string& messageType = "mock", const std::string& transactionID = ""): - DHTMessage(localNode, remoteNode, transactionID), _isReply(false), _messageType(messageType) {} + DHTMessage(localNode, remoteNode, transactionID), isReply_(false), messageType_(messageType) {} virtual ~MockDHTMessage() {} @@ -38,31 +38,31 @@ public: virtual bool send() { return true; } - virtual bool isReply() const { return _isReply; } + virtual bool isReply() const { return isReply_; } - void setReply(bool f) { _isReply = f; } + void setReply(bool f) { isReply_ = f; } - virtual const std::string& getMessageType() const { return _messageType; } + virtual const std::string& getMessageType() const { return messageType_; } virtual std::string toString() const { return "MockDHTMessage"; } }; class MockDHTQueryMessage:public DHTQueryMessage { public: - std::string _messageType; + std::string messageType_; - std::vector<SharedHandle<DHTNode> > _nodes; + std::vector<SharedHandle<DHTNode> > nodes_; - std::vector<SharedHandle<Peer> > _peers; + std::vector<SharedHandle<Peer> > peers_; - std::string _token; + std::string token_; public: MockDHTQueryMessage(const SharedHandle<DHTNode>& localNode, const SharedHandle<DHTNode>& remoteNode, const std::string& messageType = "mock", const std::string& transactionID = ""): DHTQueryMessage(localNode, remoteNode, transactionID), - _messageType(messageType) {} + messageType_(messageType) {} virtual ~MockDHTQueryMessage() {} @@ -72,7 +72,7 @@ public: virtual bool isReply() const { return false; } - virtual const std::string& getMessageType() const { return _messageType; } + virtual const std::string& getMessageType() const { return messageType_; } virtual std::string toString() const { return "MockDHTMessage"; } @@ -81,20 +81,20 @@ public: class MockDHTResponseMessage:public DHTResponseMessage { public: - std::string _messageType; + std::string messageType_; - std::vector<SharedHandle<DHTNode> > _nodes; + std::vector<SharedHandle<DHTNode> > nodes_; - std::vector<SharedHandle<Peer> > _peers; + std::vector<SharedHandle<Peer> > peers_; - std::string _token; + std::string token_; public: MockDHTResponseMessage(const SharedHandle<DHTNode>& localNode, const SharedHandle<DHTNode>& remoteNode, const std::string& messageType = "mock", const std::string& transactionID = ""): DHTResponseMessage(localNode, remoteNode, transactionID), - _messageType(messageType) {} + messageType_(messageType) {} virtual ~MockDHTResponseMessage() {} @@ -104,7 +104,7 @@ public: virtual bool isReply() const { return true; } - virtual const std::string& getMessageType() const { return _messageType; } + virtual const std::string& getMessageType() const { return messageType_; } virtual std::string toString() const { return "MockDHTMessage"; } diff --git a/test/MockDHTMessageDispatcher.h b/test/MockDHTMessageDispatcher.h index 58c24090..a6e59899 100644 --- a/test/MockDHTMessageDispatcher.h +++ b/test/MockDHTMessageDispatcher.h @@ -12,18 +12,18 @@ class MockDHTMessageDispatcher:public DHTMessageDispatcher { public: class Entry { public: - SharedHandle<DHTMessage> _message; - time_t _timeout; - SharedHandle<DHTMessageCallback> _callback; + SharedHandle<DHTMessage> message_; + time_t timeout_; + SharedHandle<DHTMessageCallback> callback_; Entry(const SharedHandle<DHTMessage>& message, time_t timeout, const SharedHandle<DHTMessageCallback>& callback): - _message(message), - _timeout(timeout), - _callback(callback) {} + message_(message), + timeout_(timeout), + callback_(callback) {} }; - std::deque<Entry> _messageQueue; + std::deque<Entry> messageQueue_; public: MockDHTMessageDispatcher() {} @@ -36,7 +36,7 @@ public: const SharedHandle<DHTMessageCallback>& callback = SharedHandle<DHTMessageCallback>()) { - _messageQueue.push_back(Entry(message, timeout, callback)); + messageQueue_.push_back(Entry(message, timeout, callback)); } virtual void @@ -44,14 +44,14 @@ public: const SharedHandle<DHTMessageCallback>& callback = SharedHandle<DHTMessageCallback>()) { - _messageQueue.push_back(Entry(message, DHT_MESSAGE_TIMEOUT, callback)); + messageQueue_.push_back(Entry(message, DHT_MESSAGE_TIMEOUT, callback)); } virtual void sendMessages() {} virtual size_t countMessageInQueue() const { - return _messageQueue.size(); + return messageQueue_.size(); } }; diff --git a/test/MockDHTMessageFactory.h b/test/MockDHTMessageFactory.h index 80c5edf0..efb83b52 100644 --- a/test/MockDHTMessageFactory.h +++ b/test/MockDHTMessageFactory.h @@ -9,7 +9,7 @@ namespace aria2 { class MockDHTMessageFactory:public DHTMessageFactory { protected: - SharedHandle<DHTNode> _localNode; + SharedHandle<DHTNode> localNode_; public: MockDHTMessageFactory() {} @@ -32,7 +32,7 @@ public: remoteNode->setIPAddress(ipaddr); remoteNode->setPort(port); SharedHandle<MockDHTResponseMessage> m - (new MockDHTResponseMessage(_localNode, remoteNode, + (new MockDHTResponseMessage(localNode_, remoteNode, asString(dict->get("t"))->s())); return m; } @@ -123,7 +123,7 @@ public: void setLocalNode(const SharedHandle<DHTNode>& node) { - _localNode = node; + localNode_ = node; } }; diff --git a/test/MockDHTTask.h b/test/MockDHTTask.h index ede1cd82..cba8047b 100644 --- a/test/MockDHTTask.h +++ b/test/MockDHTTask.h @@ -10,11 +10,11 @@ namespace aria2 { class MockDHTTask:public DHTTask { public: - SharedHandle<DHTNode> _remoteNode; + SharedHandle<DHTNode> remoteNode_; - unsigned char _targetID[DHT_ID_LENGTH]; + unsigned char targetID_[DHT_ID_LENGTH]; - MockDHTTask(const SharedHandle<DHTNode>& remoteNode):_remoteNode(remoteNode) {} + MockDHTTask(const SharedHandle<DHTNode>& remoteNode):remoteNode_(remoteNode) {} virtual ~MockDHTTask() {} @@ -27,7 +27,7 @@ public: void setTargetID(const unsigned char* targetID) { - memcpy(_targetID, targetID, DHT_ID_LENGTH); + memcpy(targetID_, targetID, DHT_ID_LENGTH); } }; diff --git a/test/MockDHTTaskQueue.h b/test/MockDHTTaskQueue.h index 2a785afb..616afb41 100644 --- a/test/MockDHTTaskQueue.h +++ b/test/MockDHTTaskQueue.h @@ -7,11 +7,11 @@ namespace aria2 { class MockDHTTaskQueue:public DHTTaskQueue { public: - std::deque<SharedHandle<DHTTask> > _periodicTaskQueue1; + std::deque<SharedHandle<DHTTask> > periodicTaskQueue1_; - std::deque<SharedHandle<DHTTask> > _periodicTaskQueue2; + std::deque<SharedHandle<DHTTask> > periodicTaskQueue2_; - std::deque<SharedHandle<DHTTask> > _immediateTaskQueue; + std::deque<SharedHandle<DHTTask> > immediateTaskQueue_; MockDHTTaskQueue() {} @@ -21,17 +21,17 @@ public: virtual void addPeriodicTask1(const SharedHandle<DHTTask>& task) { - _periodicTaskQueue1.push_back(task); + periodicTaskQueue1_.push_back(task); } virtual void addPeriodicTask2(const SharedHandle<DHTTask>& task) { - _periodicTaskQueue2.push_back(task); + periodicTaskQueue2_.push_back(task); } virtual void addImmediateTask(const SharedHandle<DHTTask>& task) { - _immediateTaskQueue.push_back(task); + immediateTaskQueue_.push_back(task); } }; diff --git a/test/MockExtensionMessage.h b/test/MockExtensionMessage.h index 6267519f..fdf5e13c 100644 --- a/test/MockExtensionMessage.h +++ b/test/MockExtensionMessage.h @@ -7,52 +7,52 @@ namespace aria2 { class MockExtensionMessage:public ExtensionMessage { public: - std::string _extensionName; - uint8_t _extensionMessageID; - std::string _data; - bool _doReceivedActionCalled; + std::string extensionName_; + uint8_t extensionMessageID_; + std::string data_; + bool doReceivedActionCalled_; public: MockExtensionMessage(const std::string& extensionName, uint8_t extensionMessageID, const unsigned char* data, - size_t length):_extensionName(extensionName), - _extensionMessageID(extensionMessageID), - _data(&data[0], &data[length]), - _doReceivedActionCalled(false) {} + size_t length):extensionName_(extensionName), + extensionMessageID_(extensionMessageID), + data_(&data[0], &data[length]), + doReceivedActionCalled_(false) {} MockExtensionMessage(const std::string& extensionName, uint8_t extensionMessageID, const std::string& data): - _extensionName(extensionName), - _extensionMessageID(extensionMessageID), - _data(data), - _doReceivedActionCalled(false) {} + extensionName_(extensionName), + extensionMessageID_(extensionMessageID), + data_(data), + doReceivedActionCalled_(false) {} virtual ~MockExtensionMessage() {} virtual std::string getPayload() { - return _data; + return data_; } virtual uint8_t getExtensionMessageID() { - return _extensionMessageID; + return extensionMessageID_; } virtual const std::string& getExtensionName() const { - return _extensionName; + return extensionName_; } virtual std::string toString() const { - return _extensionName; + return extensionName_; } virtual void doReceivedAction() { - _doReceivedActionCalled = true; + doReceivedActionCalled_ = true; } }; diff --git a/test/MockPeerStorage.h b/test/MockPeerStorage.h index 6544e495..8876456a 100644 --- a/test/MockPeerStorage.h +++ b/test/MockPeerStorage.h @@ -14,9 +14,9 @@ private: TransferStat stat; std::deque<SharedHandle<Peer> > peers; std::vector<SharedHandle<Peer> > activePeers; - int _numChokeExecuted; + int numChokeExecuted_; public: - MockPeerStorage():_numChokeExecuted(0) {} + MockPeerStorage():numChokeExecuted_(0) {} virtual ~MockPeerStorage() {} virtual bool addPeer(const SharedHandle<Peer>& peer) { @@ -68,7 +68,7 @@ public: virtual void executeChoke() { - ++_numChokeExecuted; + ++numChokeExecuted_; } virtual void updateTransferStatFor(const SharedHandle<Peer>& peer) {} @@ -80,7 +80,7 @@ public: int getNumChokeExecuted() const { - return _numChokeExecuted; + return numChokeExecuted_; } }; diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h index 00598455..de87c924 100644 --- a/test/MockPieceStorage.h +++ b/test/MockPieceStorage.h @@ -23,8 +23,8 @@ private: SharedHandle<DiskAdaptor> diskAdaptor; std::deque<size_t> pieceLengthList; std::deque<SharedHandle<Piece> > inFlightPieces; - bool _downloadFinished; - bool _allDownloadFinished; + bool downloadFinished_; + bool allDownloadFinished_; public: MockPieceStorage():totalLength(0), filteredTotalLength(0), @@ -33,8 +33,8 @@ public: bitfieldMan(0), selectiveDownloadingMode(false), endGame(false), - _downloadFinished(false), - _allDownloadFinished(false) {} + downloadFinished_(false), + allDownloadFinished_(false) {} virtual ~MockPieceStorage() {} @@ -140,21 +140,21 @@ public: virtual void clearFileFilter() {} virtual bool downloadFinished() { - return _downloadFinished; + return downloadFinished_; } void setDownloadFinished(bool f) { - _downloadFinished = f; + downloadFinished_ = f; } virtual bool allDownloadFinished() { - return _allDownloadFinished; + return allDownloadFinished_; } void setAllDownloadFinished(bool f) { - _allDownloadFinished = f; + allDownloadFinished_ = f; } virtual void initStorage() {} diff --git a/test/MultiFileAllocationIteratorTest.cc b/test/MultiFileAllocationIteratorTest.cc index 83dcb189..fa3623e8 100644 --- a/test/MultiFileAllocationIteratorTest.cc +++ b/test/MultiFileAllocationIteratorTest.cc @@ -36,7 +36,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MultiFileAllocationIteratorTest ); void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries() { std::string storeDir = "/tmp/aria2_MultiFileAllocationIteratorTest" - "_testMakeDiskWriterEntries"; + "testMakeDiskWriterEntries_"; SharedHandle<FileEntry> fs[] = { SharedHandle<FileEntry>(new FileEntry(storeDir+"/file1", 1536, 0)), diff --git a/test/NetrcAuthResolverTest.cc b/test/NetrcAuthResolverTest.cc index 399fffdf..4fa738ca 100644 --- a/test/NetrcAuthResolverTest.cc +++ b/test/NetrcAuthResolverTest.cc @@ -14,22 +14,22 @@ class NetrcAuthResolverTest : public CppUnit::TestFixture { CPPUNIT_TEST(testResolveAuthConfig_ignoreDefault); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Netrc> _netrc; + SharedHandle<Netrc> netrc_; //SharedHandle<Option> _option; - SharedHandle<NetrcAuthResolver> _resolver; + SharedHandle<NetrcAuthResolver> resolver_; public: void setUp() { - _netrc.reset(new Netrc()); - _netrc->addAuthenticator + netrc_.reset(new Netrc()); + netrc_->addAuthenticator (SharedHandle<Authenticator>(new Authenticator("localhost", "name", "passwd", "account"))); - _netrc->addAuthenticator + netrc_->addAuthenticator (SharedHandle<Authenticator>(new DefaultAuthenticator("default", "defaultpasswd", "defaultaccount"))); //_option = new Option(); - _resolver.reset(new NetrcAuthResolver()); - _resolver->setNetrc(_netrc); - _resolver->setDefaultAuthConfig + resolver_.reset(new NetrcAuthResolver()); + resolver_->setNetrc(netrc_); + resolver_->setDefaultAuthConfig (SharedHandle<AuthConfig>(new AuthConfig("foo", "bar"))); } @@ -43,42 +43,42 @@ CPPUNIT_TEST_SUITE_REGISTRATION( NetrcAuthResolverTest ); void NetrcAuthResolverTest::testResolveAuthConfig_without_userDefined() { - SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost"); + SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost"); CPPUNIT_ASSERT_EQUAL(std::string("name:passwd"), authConfig->getAuthText()); - authConfig = _resolver->resolveAuthConfig("mymachine"); + authConfig = resolver_->resolveAuthConfig("mymachine"); CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpasswd"), authConfig->getAuthText()); - _resolver->setNetrc(SharedHandle<Netrc>()); - authConfig = _resolver->resolveAuthConfig("localhost"); + resolver_->setNetrc(SharedHandle<Netrc>()); + authConfig = resolver_->resolveAuthConfig("localhost"); CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText()); } void NetrcAuthResolverTest::testResolveAuthConfig_with_userDefined() { - _resolver->setUserDefinedAuthConfig + resolver_->setUserDefinedAuthConfig (SharedHandle<AuthConfig>(new AuthConfig("myname", "mypasswd"))); - SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("localhost"); + SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("localhost"); CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText()); - authConfig = _resolver->resolveAuthConfig("mymachine"); + authConfig = resolver_->resolveAuthConfig("mymachine"); CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText()); - _resolver->setNetrc(SharedHandle<Netrc>()); - authConfig = _resolver->resolveAuthConfig("mymachine"); + resolver_->setNetrc(SharedHandle<Netrc>()); + authConfig = resolver_->resolveAuthConfig("mymachine"); CPPUNIT_ASSERT_EQUAL(std::string("myname:mypasswd"), authConfig->getAuthText()); } void NetrcAuthResolverTest::testResolveAuthConfig_ignoreDefault() { - _resolver->ignoreDefault(); - SharedHandle<AuthConfig> authConfig = _resolver->resolveAuthConfig("mirror"); + resolver_->ignoreDefault(); + SharedHandle<AuthConfig> authConfig = resolver_->resolveAuthConfig("mirror"); CPPUNIT_ASSERT_EQUAL(std::string("foo:bar"), authConfig->getAuthText()); - _resolver->useDefault(); + resolver_->useDefault(); SharedHandle<AuthConfig> defAuthConfig = - _resolver->resolveAuthConfig("mirror"); + resolver_->resolveAuthConfig("mirror"); CPPUNIT_ASSERT_EQUAL(std::string("default:defaultpasswd"), defAuthConfig->getAuthText()); } diff --git a/test/OptionParserTest.cc b/test/OptionParserTest.cc index ff8958bf..e32196db 100644 --- a/test/OptionParserTest.cc +++ b/test/OptionParserTest.cc @@ -27,35 +27,35 @@ class OptionParserTest:public CppUnit::TestFixture { CPPUNIT_TEST(testParse); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<OptionParser> _oparser; + SharedHandle<OptionParser> oparser_; public: void setUp() { - _oparser.reset(new OptionParser()); + oparser_.reset(new OptionParser()); SharedHandle<OptionHandler> alpha (new DefaultOptionHandler("alpha", NO_DESCRIPTION, "ALPHA", "", OptionHandler::REQ_ARG, 'A')); alpha->addTag("apple"); - _oparser->addOptionHandler(alpha); + oparser_->addOptionHandler(alpha); SharedHandle<OptionHandler> bravo(new DefaultOptionHandler("bravo")); bravo->addTag("apple"); bravo->addTag("orange"); bravo->addTag("pineapple"); - _oparser->addOptionHandler(bravo); + oparser_->addOptionHandler(bravo); SharedHandle<DefaultOptionHandler> charlie (new DefaultOptionHandler("charlie", NO_DESCRIPTION, "CHARLIE", "", OptionHandler::REQ_ARG, 'C')); charlie->hide(); charlie->addTag("pineapple"); - _oparser->addOptionHandler(charlie); + oparser_->addOptionHandler(charlie); SharedHandle<OptionHandler> delta (new UnitNumberOptionHandler("delta", NO_DESCRIPTION, "1M", -1, -1, 'D')); delta->addTag("pineapple"); - _oparser->addOptionHandler(delta); + oparser_->addOptionHandler(delta); } void tearDown() {} @@ -76,7 +76,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(OptionParserTest); void OptionParserTest::testFindAll() { - std::vector<SharedHandle<OptionHandler> > res = _oparser->findAll(); + std::vector<SharedHandle<OptionHandler> > res = oparser_->findAll(); CPPUNIT_ASSERT_EQUAL((size_t)3, res.size()); CPPUNIT_ASSERT_EQUAL(std::string("alpha"), res[0]->getName()); CPPUNIT_ASSERT_EQUAL(std::string("bravo"), res[1]->getName()); @@ -86,7 +86,7 @@ void OptionParserTest::testFindAll() void OptionParserTest::testFindByNameSubstring() { std::vector<SharedHandle<OptionHandler> > res = - _oparser->findByNameSubstring("l"); + oparser_->findByNameSubstring("l"); CPPUNIT_ASSERT_EQUAL((size_t)2, res.size()); CPPUNIT_ASSERT_EQUAL(std::string("alpha"), res[0]->getName()); CPPUNIT_ASSERT_EQUAL(std::string("delta"), res[1]->getName()); @@ -95,7 +95,7 @@ void OptionParserTest::testFindByNameSubstring() void OptionParserTest::testFindByTag() { std::vector<SharedHandle<OptionHandler> > res = - _oparser->findByTag("pineapple"); + oparser_->findByTag("pineapple"); CPPUNIT_ASSERT_EQUAL((size_t)2, res.size()); CPPUNIT_ASSERT_EQUAL(std::string("bravo"), res[0]->getName()); CPPUNIT_ASSERT_EQUAL(std::string("delta"), res[1]->getName()); @@ -103,39 +103,39 @@ void OptionParserTest::testFindByTag() void OptionParserTest::testFindByName() { - SharedHandle<OptionHandler> bravo = _oparser->findByName("bravo"); + SharedHandle<OptionHandler> bravo = oparser_->findByName("bravo"); CPPUNIT_ASSERT(!bravo.isNull()); CPPUNIT_ASSERT_EQUAL(std::string("bravo"), bravo->getName()); - SharedHandle<OptionHandler> charlie = _oparser->findByName("charlie"); + SharedHandle<OptionHandler> charlie = oparser_->findByName("charlie"); CPPUNIT_ASSERT(charlie.isNull()); - SharedHandle<OptionHandler> alpha2 = _oparser->findByName("alpha2"); + SharedHandle<OptionHandler> alpha2 = oparser_->findByName("alpha2"); CPPUNIT_ASSERT(alpha2.isNull()); } void OptionParserTest::testFindByShortName() { - SharedHandle<OptionHandler> alpha = _oparser->findByShortName('A'); + SharedHandle<OptionHandler> alpha = oparser_->findByShortName('A'); CPPUNIT_ASSERT(!alpha.isNull()); CPPUNIT_ASSERT_EQUAL(std::string("alpha"), alpha->getName()); - CPPUNIT_ASSERT(_oparser->findByShortName('C').isNull()); + CPPUNIT_ASSERT(oparser_->findByShortName('C').isNull()); } void OptionParserTest::testFindByID() { - SharedHandle<OptionHandler> alpha = _oparser->findByID(1); + SharedHandle<OptionHandler> alpha = oparser_->findByID(1); CPPUNIT_ASSERT(!alpha.isNull()); CPPUNIT_ASSERT_EQUAL(std::string("alpha"), alpha->getName()); - CPPUNIT_ASSERT(_oparser->findByID(3).isNull()); + CPPUNIT_ASSERT(oparser_->findByID(3).isNull()); } void OptionParserTest::testParseDefaultValues() { Option option; - _oparser->parseDefaultValues(option); + oparser_->parseDefaultValues(option); CPPUNIT_ASSERT_EQUAL(std::string("ALPHA"), option.get("alpha")); CPPUNIT_ASSERT_EQUAL(std::string("1048576"), option.get("delta")); CPPUNIT_ASSERT_EQUAL(std::string("CHARLIE"), option.get("charlie")); @@ -169,7 +169,7 @@ void OptionParserTest::testParseArg() std::stringstream s; std::vector<std::string> nonopts; - _oparser->parseArg(s, nonopts, argc, argv); + oparser_->parseArg(s, nonopts, argc, argv); CPPUNIT_ASSERT_EQUAL(std::string("alpha=ALPHA\n" "bravo=BRAVO\n"), s.str()); @@ -186,7 +186,7 @@ void OptionParserTest::testParse() "UNKNOWN=x\n" "\n" "bravo=World"); - _oparser->parse(option, in); + oparser_->parse(option, in); CPPUNIT_ASSERT_EQUAL ((ptrdiff_t)2, std::distance(option.begin(), option.end())); CPPUNIT_ASSERT_EQUAL(std::string("Hello"), option.get("alpha")); diff --git a/test/RequestGroupManTest.cc b/test/RequestGroupManTest.cc index f56db40f..b53da636 100644 --- a/test/RequestGroupManTest.cc +++ b/test/RequestGroupManTest.cc @@ -28,12 +28,12 @@ class RequestGroupManTest : public CppUnit::TestFixture { CPPUNIT_TEST(testChangeReservedGroupPosition); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { RequestGroup::resetGIDCounter(); - _option.reset(new Option()); + option_.reset(new Option()); } void testIsSameFileBeingDownloaded(); @@ -48,8 +48,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION( RequestGroupManTest ); void RequestGroupManTest::testIsSameFileBeingDownloaded() { - SharedHandle<RequestGroup> rg1(new RequestGroup(_option)); - SharedHandle<RequestGroup> rg2(new RequestGroup(_option)); + SharedHandle<RequestGroup> rg1(new RequestGroup(option_)); + SharedHandle<RequestGroup> rg2(new RequestGroup(option_)); SharedHandle<DownloadContext> dctx1 (new DownloadContext(0, 0, "aria2.tar.bz2")); @@ -60,7 +60,7 @@ void RequestGroupManTest::testIsSameFileBeingDownloaded() rg2->setDownloadContext(dctx2); RequestGroupMan gm(std::vector<SharedHandle<RequestGroup> >(), 1, - _option.get()); + option_.get()); gm.addRequestGroup(rg1); gm.addRequestGroup(rg2); @@ -81,7 +81,7 @@ void RequestGroupManTest::testGetInitialCommands() void RequestGroupManTest::testSaveServerStat() { RequestGroupMan rm - (std::vector<SharedHandle<RequestGroup> >(),0,_option.get()); + (std::vector<SharedHandle<RequestGroup> >(),0,option_.get()); SharedHandle<ServerStat> ss_localhost(new ServerStat("localhost", "http")); rm.addServerStat(ss_localhost); File f("/tmp/aria2_RequestGroupManTest_testSaveServerStat"); @@ -105,7 +105,7 @@ void RequestGroupManTest::testLoadServerStat() o.close(); RequestGroupMan rm - (std::vector<SharedHandle<RequestGroup> >(),0,_option.get()); + (std::vector<SharedHandle<RequestGroup> >(),0,option_.get()); std::cerr << "testLoadServerStat" << std::endl; CPPUNIT_ASSERT(rm.loadServerStat(f.getPath())); SharedHandle<ServerStat> ss_localhost = rm.findServerStat("localhost", @@ -117,13 +117,13 @@ void RequestGroupManTest::testLoadServerStat() void RequestGroupManTest::testChangeReservedGroupPosition() { SharedHandle<RequestGroup> gs[] = { - SharedHandle<RequestGroup>(new RequestGroup(_option)), - SharedHandle<RequestGroup>(new RequestGroup(_option)), - SharedHandle<RequestGroup>(new RequestGroup(_option)), - SharedHandle<RequestGroup>(new RequestGroup(_option)) + SharedHandle<RequestGroup>(new RequestGroup(option_)), + SharedHandle<RequestGroup>(new RequestGroup(option_)), + SharedHandle<RequestGroup>(new RequestGroup(option_)), + SharedHandle<RequestGroup>(new RequestGroup(option_)) }; std::vector<SharedHandle<RequestGroup> > groups(vbegin(gs), vend(gs)); - RequestGroupMan rm(groups, 0, _option.get()); + RequestGroupMan rm(groups, 0, option_.get()); CPPUNIT_ASSERT_EQUAL ((size_t)0, rm.changeReservedGroupPosition(1, 0, RequestGroupMan::POS_SET)); diff --git a/test/RequestGroupTest.cc b/test/RequestGroupTest.cc index f23a5d08..6cd4ac8a 100644 --- a/test/RequestGroupTest.cc +++ b/test/RequestGroupTest.cc @@ -17,11 +17,11 @@ class RequestGroupTest : public CppUnit::TestFixture { CPPUNIT_TEST(testCreateDownloadResult); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; + SharedHandle<Option> option_; public: void setUp() { - _option.reset(new Option()); + option_.reset(new Option()); } void testGetFirstFilePath(); @@ -36,7 +36,7 @@ void RequestGroupTest::testGetFirstFilePath() SharedHandle<DownloadContext> ctx (new DownloadContext(1024, 1024, "/tmp/myfile")); - RequestGroup group(_option); + RequestGroup group(option_); group.setDownloadContext(ctx); CPPUNIT_ASSERT_EQUAL(std::string("/tmp/myfile"), group.getFirstFilePath()); @@ -50,7 +50,7 @@ void RequestGroupTest::testCreateDownloadResult() { SharedHandle<DownloadContext> ctx (new DownloadContext(1024, 1024*1024, "/tmp/myfile")); - RequestGroup group(_option); + RequestGroup group(option_); group.setDownloadContext(ctx); group.initPieceStorage(); { diff --git a/test/SegmentManTest.cc b/test/SegmentManTest.cc index 0b73a0a2..691a599b 100644 --- a/test/SegmentManTest.cc +++ b/test/SegmentManTest.cc @@ -23,20 +23,20 @@ class SegmentManTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGetCleanSegmentIfOwnerIsIdle); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; - SharedHandle<DownloadContext> _dctx; - SharedHandle<DefaultPieceStorage> _pieceStorage; - SharedHandle<SegmentMan> _segmentMan; + SharedHandle<Option> option_; + SharedHandle<DownloadContext> dctx_; + SharedHandle<DefaultPieceStorage> pieceStorage_; + SharedHandle<SegmentMan> segmentMan_; public: void setUp() { size_t pieceLength = 1024*1024; uint64_t totalLength = 64*1024*1024; - _option.reset(new Option()); - _dctx.reset + option_.reset(new Option()); + dctx_.reset (new DownloadContext(pieceLength, totalLength, "aria2.tar.bz2")); - _pieceStorage.reset(new DefaultPieceStorage(_dctx, _option.get())); - _segmentMan.reset(new SegmentMan(_option.get(), _dctx, _pieceStorage)); + pieceStorage_.reset(new DefaultPieceStorage(dctx_, option_.get())); + segmentMan_.reset(new SegmentMan(option_.get(), dctx_, pieceStorage_)); } void testNullBitfield(); @@ -162,46 +162,46 @@ void SegmentManTest::testRegisterPeerStat() void SegmentManTest::testCancelAllSegments() { - _segmentMan->getSegment(1, 0); - _segmentMan->getSegment(2, 1); - CPPUNIT_ASSERT(_segmentMan->getSegment(3, 0).isNull()); - CPPUNIT_ASSERT(_segmentMan->getSegment(4, 1).isNull()); - _segmentMan->cancelAllSegments(); - CPPUNIT_ASSERT(!_segmentMan->getSegment(3, 0).isNull()); - CPPUNIT_ASSERT(!_segmentMan->getSegment(4, 1).isNull()); + segmentMan_->getSegment(1, 0); + segmentMan_->getSegment(2, 1); + CPPUNIT_ASSERT(segmentMan_->getSegment(3, 0).isNull()); + CPPUNIT_ASSERT(segmentMan_->getSegment(4, 1).isNull()); + segmentMan_->cancelAllSegments(); + CPPUNIT_ASSERT(!segmentMan_->getSegment(3, 0).isNull()); + CPPUNIT_ASSERT(!segmentMan_->getSegment(4, 1).isNull()); } void SegmentManTest::testGetPeerStat() { SharedHandle<PeerStat> peerStat1(new PeerStat(1)); - _segmentMan->registerPeerStat(peerStat1); - CPPUNIT_ASSERT_EQUAL((cuid_t)1, _segmentMan->getPeerStat(1)->getCuid()); + segmentMan_->registerPeerStat(peerStat1); + CPPUNIT_ASSERT_EQUAL((cuid_t)1, segmentMan_->getPeerStat(1)->getCuid()); } void SegmentManTest::testGetCleanSegmentIfOwnerIsIdle() { - SharedHandle<Segment> seg1 = _segmentMan->getSegment(1, 0); - SharedHandle<Segment> seg2 = _segmentMan->getSegment(2, 1); + SharedHandle<Segment> seg1 = segmentMan_->getSegment(1, 0); + SharedHandle<Segment> seg2 = segmentMan_->getSegment(2, 1); seg2->updateWrittenLength(100); - CPPUNIT_ASSERT(!_segmentMan->getCleanSegmentIfOwnerIsIdle(3, 0).isNull()); + CPPUNIT_ASSERT(!segmentMan_->getCleanSegmentIfOwnerIsIdle(3, 0).isNull()); SharedHandle<PeerStat> peerStat3(new PeerStat(3)); - _segmentMan->registerPeerStat(peerStat3); - CPPUNIT_ASSERT(!_segmentMan->getCleanSegmentIfOwnerIsIdle(4, 0).isNull()); + segmentMan_->registerPeerStat(peerStat3); + CPPUNIT_ASSERT(!segmentMan_->getCleanSegmentIfOwnerIsIdle(4, 0).isNull()); SharedHandle<PeerStat> peerStat4(new PeerStat(4)); peerStat4->downloadStart(); - _segmentMan->registerPeerStat(peerStat4); + segmentMan_->registerPeerStat(peerStat4); // Owner PeerStat is not IDLE - CPPUNIT_ASSERT(_segmentMan->getCleanSegmentIfOwnerIsIdle(5, 0).isNull()); + CPPUNIT_ASSERT(segmentMan_->getCleanSegmentIfOwnerIsIdle(5, 0).isNull()); // Segment::updateWrittenLength != 0 - CPPUNIT_ASSERT(_segmentMan->getCleanSegmentIfOwnerIsIdle(5, 1).isNull()); + CPPUNIT_ASSERT(segmentMan_->getCleanSegmentIfOwnerIsIdle(5, 1).isNull()); // Test with UnknownLengthPieceStorage SharedHandle<DownloadContext> dctx(new DownloadContext(1024, 0, "aria2")); SharedHandle<UnknownLengthPieceStorage> ps - (new UnknownLengthPieceStorage(dctx, _option.get())); - _segmentMan.reset(new SegmentMan(_option.get(), dctx, ps)); + (new UnknownLengthPieceStorage(dctx, option_.get())); + segmentMan_.reset(new SegmentMan(option_.get(), dctx, ps)); - CPPUNIT_ASSERT(!_segmentMan->getCleanSegmentIfOwnerIsIdle(1, 0).isNull()); + CPPUNIT_ASSERT(!segmentMan_->getCleanSegmentIfOwnerIsIdle(1, 0).isNull()); } diff --git a/test/SingletonHolderTest.cc b/test/SingletonHolderTest.cc index 40ddfed6..6b939824 100644 --- a/test/SingletonHolderTest.cc +++ b/test/SingletonHolderTest.cc @@ -24,14 +24,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION( SingletonHolderTest ); class M { private: - std::string _greeting; + std::string greeting_; public: - M(const std::string& greeting):_greeting(greeting) {} + M(const std::string& greeting):greeting_(greeting) {} - const std::string& greeting() const { return _greeting; } + const std::string& greeting() const { return greeting_; } void greeting(const std::string& greeting) { - _greeting = greeting; + greeting_ = greeting; } }; diff --git a/test/UTMetadataPostDownloadHandlerTest.cc b/test/UTMetadataPostDownloadHandlerTest.cc index 4775d02f..b134e164 100644 --- a/test/UTMetadataPostDownloadHandlerTest.cc +++ b/test/UTMetadataPostDownloadHandlerTest.cc @@ -24,18 +24,18 @@ class UTMetadataPostDownloadHandlerTest:public CppUnit::TestFixture { CPPUNIT_TEST(testGetNextRequestGroups); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<Option> _option; - SharedHandle<DownloadContext> _dctx; - SharedHandle<RequestGroup> _requestGroup; + SharedHandle<Option> option_; + SharedHandle<DownloadContext> dctx_; + SharedHandle<RequestGroup> requestGroup_; public: void setUp() { - _option.reset(new Option()); - _option->put("HELLO", "WORLD"); - _option->put(PREF_DIR, "."); - _dctx.reset(new DownloadContext(0, 0, "something")); - _requestGroup.reset(new RequestGroup(_option)); - _requestGroup->setDownloadContext(_dctx); + option_.reset(new Option()); + option_->put("HELLO", "WORLD"); + option_->put(PREF_DIR, "."); + dctx_.reset(new DownloadContext(0, 0, "something")); + requestGroup_.reset(new RequestGroup(option_)); + requestGroup_->setDownloadContext(dctx_); } void testCanHandle(); @@ -49,17 +49,17 @@ void UTMetadataPostDownloadHandlerTest::testCanHandle() { UTMetadataPostDownloadHandler handler; - CPPUNIT_ASSERT(!handler.canHandle(_requestGroup.get())); + CPPUNIT_ASSERT(!handler.canHandle(requestGroup_.get())); SharedHandle<TorrentAttribute> attrs(new TorrentAttribute()); - _dctx->setAttribute(bittorrent::BITTORRENT, attrs); + dctx_->setAttribute(bittorrent::BITTORRENT, attrs); - CPPUNIT_ASSERT(handler.canHandle(_requestGroup.get())); + CPPUNIT_ASSERT(handler.canHandle(requestGroup_.get())); // Only checks whether metadata is empty or not attrs->metadata = "metadata"; - CPPUNIT_ASSERT(!handler.canHandle(_requestGroup.get())); + CPPUNIT_ASSERT(!handler.canHandle(requestGroup_.get())); } void UTMetadataPostDownloadHandlerTest::testGetNextRequestGroups() @@ -75,7 +75,7 @@ void UTMetadataPostDownloadHandlerTest::testGetNextRequestGroups() MessageDigestHelper::digest (infoHash, sizeof(infoHash), MessageDigestContext::SHA1, reinterpret_cast<const unsigned char*>(metadata.data()), metadata.size()); - _dctx->getFirstFileEntry()->setLength(metadata.size()); + dctx_->getFirstFileEntry()->setLength(metadata.size()); SharedHandle<TorrentAttribute> attrs(new TorrentAttribute()); attrs->infoHash = std::string(&infoHash[0], &infoHash[20]); std::vector<std::vector<std::string> > announceList; @@ -83,53 +83,53 @@ void UTMetadataPostDownloadHandlerTest::testGetNextRequestGroups() announceTier.push_back("http://tracker"); announceList.push_back(announceTier); attrs->announceList = announceList; - _dctx->setAttribute(bittorrent::BITTORRENT, attrs); - _requestGroup->setDiskWriterFactory + dctx_->setAttribute(bittorrent::BITTORRENT, attrs); + requestGroup_->setDiskWriterFactory (SharedHandle<DiskWriterFactory>(new ByteArrayDiskWriterFactory())); - _requestGroup->initPieceStorage(); - _requestGroup->getPieceStorage()->getDiskAdaptor()->writeData + requestGroup_->initPieceStorage(); + requestGroup_->getPieceStorage()->getDiskAdaptor()->writeData (reinterpret_cast<const unsigned char*>(metadata.data()), metadata.size(), 0); UTMetadataPostDownloadHandler handler; std::vector<SharedHandle<RequestGroup> > results; - handler.getNextRequestGroups(results, _requestGroup.get()); + handler.getNextRequestGroups(results, requestGroup_.get()); CPPUNIT_ASSERT_EQUAL((size_t)1, results.size()); SharedHandle<RequestGroup> newRg = results.front(); SharedHandle<DownloadContext> newDctx = newRg->getDownloadContext(); SharedHandle<TorrentAttribute> newAttrs = bittorrent::getTorrentAttrs(newDctx); - CPPUNIT_ASSERT_EQUAL(bittorrent::getInfoHashString(_dctx), + CPPUNIT_ASSERT_EQUAL(bittorrent::getInfoHashString(dctx_), bittorrent::getInfoHashString(newDctx)); const std::vector<std::vector<std::string> >& newAnnounceList = newAttrs->announceList; CPPUNIT_ASSERT_EQUAL((size_t)1, newAnnounceList.size()); CPPUNIT_ASSERT_EQUAL(std::string("http://tracker"), newAnnounceList[0][0]); - CPPUNIT_ASSERT_EQUAL(_option->get("Hello"), + CPPUNIT_ASSERT_EQUAL(option_->get("Hello"), newRg->getOption()->get("Hello")); CPPUNIT_ASSERT - (std::find(_requestGroup->followedBy().begin(), - _requestGroup->followedBy().end(), - newRg->getGID()) != _requestGroup->followedBy().end()); + (std::find(requestGroup_->followedBy().begin(), + requestGroup_->followedBy().end(), + newRg->getGID()) != requestGroup_->followedBy().end()); CPPUNIT_ASSERT(!trfile.exists()); results.clear(); - _requestGroup->getOption()->put(PREF_BT_SAVE_METADATA, V_TRUE); - handler.getNextRequestGroups(results, _requestGroup.get()); + requestGroup_->getOption()->put(PREF_BT_SAVE_METADATA, V_TRUE); + handler.getNextRequestGroups(results, requestGroup_.get()); CPPUNIT_ASSERT(trfile.exists()); results.clear(); // See failure with bad metadata metadata = "d6:lengthi384e4:name19:aria2-0.8.2.tar.bz212:piece lengthi128e"; - _requestGroup->initPieceStorage(); - _requestGroup->getPieceStorage()->getDiskAdaptor()->writeData + requestGroup_->initPieceStorage(); + requestGroup_->getPieceStorage()->getDiskAdaptor()->writeData (reinterpret_cast<const unsigned char*>(metadata.data()), metadata.size(), 0); try { - handler.getNextRequestGroups(results, _requestGroup.get()); + handler.getNextRequestGroups(results, requestGroup_.get()); CPPUNIT_FAIL("exception must be thrown."); } catch(RecoverableException& e) { // success diff --git a/test/UTMetadataRequestExtensionMessageTest.cc b/test/UTMetadataRequestExtensionMessageTest.cc index 31c2ec69..ed854a9c 100644 --- a/test/UTMetadataRequestExtensionMessageTest.cc +++ b/test/UTMetadataRequestExtensionMessageTest.cc @@ -30,21 +30,21 @@ class UTMetadataRequestExtensionMessageTest:public CppUnit::TestFixture { CPPUNIT_TEST(testDoReceivedAction_data); CPPUNIT_TEST_SUITE_END(); public: - SharedHandle<DownloadContext> _dctx; - SharedHandle<WrapExtBtMessageFactory> _messageFactory; - SharedHandle<MockBtMessageDispatcher> _dispatcher; - SharedHandle<Peer> _peer; + SharedHandle<DownloadContext> dctx_; + SharedHandle<WrapExtBtMessageFactory> messageFactory_; + SharedHandle<MockBtMessageDispatcher> dispatcher_; + SharedHandle<Peer> peer_; void setUp() { - _messageFactory.reset(new WrapExtBtMessageFactory()); - _dispatcher.reset(new MockBtMessageDispatcher()); - _dctx.reset(new DownloadContext()); + messageFactory_.reset(new WrapExtBtMessageFactory()); + dispatcher_.reset(new MockBtMessageDispatcher()); + dctx_.reset(new DownloadContext()); SharedHandle<TorrentAttribute> attrs(new TorrentAttribute()); - _dctx->setAttribute(bittorrent::BITTORRENT, attrs); - _peer.reset(new Peer("host", 6880)); - _peer->allocateSessionResource(0, 0); - _peer->setExtension("ut_metadata", 1); + dctx_->setAttribute(bittorrent::BITTORRENT, attrs); + peer_.reset(new Peer("host", 6880)); + peer_->allocateSessionResource(0, 0); + peer_->setExtension("ut_metadata", 1); } template<typename T> @@ -52,9 +52,9 @@ public: { SharedHandle<WrapExtBtMessage> wrapmsg = dynamic_pointer_cast<WrapExtBtMessage> - (_dispatcher->messageQueue.front()); + (dispatcher_->messageQueue.front()); - SharedHandle<T> msg = dynamic_pointer_cast<T>(wrapmsg->_m); + SharedHandle<T> msg = dynamic_pointer_cast<T>(wrapmsg->m_); return msg; } @@ -101,10 +101,10 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_reject() { UTMetadataRequestExtensionMessage msg(1); msg.setIndex(10); - msg.setDownloadContext(_dctx); - msg.setPeer(_peer); - msg.setBtMessageFactory(_messageFactory); - msg.setBtMessageDispatcher(_dispatcher); + msg.setDownloadContext(dctx_); + msg.setPeer(peer_); + msg.setBtMessageFactory(messageFactory_); + msg.setBtMessageDispatcher(dispatcher_); msg.doReceivedAction(); SharedHandle<UTMetadataRejectExtensionMessage> m = @@ -119,13 +119,13 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_data() { UTMetadataRequestExtensionMessage msg(1); msg.setIndex(1); - msg.setDownloadContext(_dctx); - msg.setPeer(_peer); - msg.setBtMessageFactory(_messageFactory); - msg.setBtMessageDispatcher(_dispatcher); + msg.setDownloadContext(dctx_); + msg.setPeer(peer_); + msg.setBtMessageFactory(messageFactory_); + msg.setBtMessageDispatcher(dispatcher_); size_t metadataSize = METADATA_PIECE_SIZE*2; - SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(_dctx); + SharedHandle<TorrentAttribute> attrs = bittorrent::getTorrentAttrs(dctx_); std::string first(METADATA_PIECE_SIZE, '0'); std::string second(METADATA_PIECE_SIZE, '1'); attrs->metadata = first+second; @@ -142,7 +142,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_data() CPPUNIT_ASSERT_EQUAL(metadataSize, m->getTotalSize()); CPPUNIT_ASSERT_EQUAL((uint8_t)1, m->getExtensionMessageID()); - _dispatcher->messageQueue.clear(); + dispatcher_->messageQueue.clear(); msg.setIndex(2); diff --git a/test/UTPexExtensionMessageTest.cc b/test/UTPexExtensionMessageTest.cc index ec032e8e..c2afa55a 100644 --- a/test/UTPexExtensionMessageTest.cc +++ b/test/UTPexExtensionMessageTest.cc @@ -30,11 +30,11 @@ class UTPexExtensionMessageTest:public CppUnit::TestFixture { CPPUNIT_TEST(testDroppedPeersAreFull); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<MockPeerStorage> _peerStorage; + SharedHandle<MockPeerStorage> peerStorage_; public: void setUp() { - _peerStorage.reset(new MockPeerStorage()); + peerStorage_.reset(new MockPeerStorage()); global::wallclock.reset(); } @@ -133,18 +133,18 @@ void UTPexExtensionMessageTest::testDoReceivedAction() SharedHandle<Peer> p4(new Peer("10.1.1.3", 10000)); p4->startBadCondition(); msg.addDroppedPeer(p4); - msg.setPeerStorage(_peerStorage); + msg.setPeerStorage(peerStorage_); msg.doReceivedAction(); - CPPUNIT_ASSERT_EQUAL((size_t)2, _peerStorage->getPeers().size()); + CPPUNIT_ASSERT_EQUAL((size_t)2, peerStorage_->getPeers().size()); { - SharedHandle<Peer> p = _peerStorage->getPeers()[0]; + SharedHandle<Peer> p = peerStorage_->getPeers()[0]; CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), p->getIPAddress()); CPPUNIT_ASSERT_EQUAL((uint16_t)6881, p->getPort()); } { - SharedHandle<Peer> p = _peerStorage->getPeers()[1]; + SharedHandle<Peer> p = peerStorage_->getPeers()[1]; CPPUNIT_ASSERT_EQUAL(std::string("10.1.1.2"), p->getIPAddress()); CPPUNIT_ASSERT_EQUAL((uint16_t)9999, p->getPort()); } diff --git a/test/XmlRpcMethodTest.cc b/test/XmlRpcMethodTest.cc index 62bcd5c4..8cde572a 100644 --- a/test/XmlRpcMethodTest.cc +++ b/test/XmlRpcMethodTest.cc @@ -84,22 +84,22 @@ class XmlRpcMethodTest:public CppUnit::TestFixture { CPPUNIT_TEST(testSystemMulticall_fail); CPPUNIT_TEST_SUITE_END(); private: - SharedHandle<DownloadEngine> _e; - SharedHandle<Option> _option; + SharedHandle<DownloadEngine> e_; + SharedHandle<Option> option_; public: void setUp() { RequestGroup::resetGIDCounter(); - _option.reset(new Option()); - _option->put(PREF_DIR, "/tmp"); - _option->put(PREF_SEGMENT_SIZE, "1048576"); - _e.reset + option_.reset(new Option()); + option_->put(PREF_DIR, "/tmp"); + option_->put(PREF_SEGMENT_SIZE, "1048576"); + e_.reset (new DownloadEngine(SharedHandle<EventPoll>(new SelectEventPoll()))); - _e->setOption(_option.get()); - _e->setRequestGroupMan + e_->setOption(option_.get()); + e_->setRequestGroupMan (SharedHandle<RequestGroupMan> (new RequestGroupMan(std::vector<SharedHandle<RequestGroup> >(), - 1, _option.get()))); + 1, option_.get()))); } void testAddUri(); @@ -163,10 +163,10 @@ void XmlRpcMethodTest::testAddUri() urisParam->append("http://localhost/"); req.params->append(urisParam); { - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); const std::deque<SharedHandle<RequestGroup> > rgs = - _e->getRequestGroupMan()->getReservedGroups(); + e_->getRequestGroupMan()->getReservedGroups(); CPPUNIT_ASSERT_EQUAL((size_t)1, rgs.size()); CPPUNIT_ASSERT_EQUAL(std::string("http://localhost/"), rgs.front()->getDownloadContext()-> @@ -177,10 +177,10 @@ void XmlRpcMethodTest::testAddUri() opt->put(PREF_DIR, "/sink"); req.params->append(opt); { - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL(std::string("/sink"), - _e->getRequestGroupMan()->findReservedGroup(2)-> + e_->getRequestGroupMan()->findReservedGroup(2)-> getDownloadContext()->getDir()); } } @@ -189,7 +189,7 @@ void XmlRpcMethodTest::testAddUri_withoutUri() { AddUriXmlRpcMethod m; XmlRpcRequest req(AddUriXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -200,7 +200,7 @@ void XmlRpcMethodTest::testAddUri_notUri() SharedHandle<List> urisParam = List::g(); urisParam->append("not uri"); req.params->append(urisParam); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -214,7 +214,7 @@ void XmlRpcMethodTest::testAddUri_withBadOption() SharedHandle<Dict> opt = Dict::g(); opt->put(PREF_FILE_ALLOCATION, "badvalue"); req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -225,7 +225,7 @@ void XmlRpcMethodTest::testAddUri_withPosition() SharedHandle<List> urisParam1 = List::g(); urisParam1->append("http://uri1"); req1.params->append(urisParam1); - XmlRpcResponse res1 = m.execute(req1, _e.get()); + XmlRpcResponse res1 = m.execute(req1, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res1.code); XmlRpcRequest req2(AddUriXmlRpcMethod::getMethodName(), List::g()); @@ -234,10 +234,10 @@ void XmlRpcMethodTest::testAddUri_withPosition() req2.params->append(urisParam2); req2.params->append(Dict::g()); req2.params->append(Integer::g(0)); - m.execute(req2, _e.get()); + m.execute(req2, e_.get()); std::string uri = - _e->getRequestGroupMan()->getReservedGroups()[0]-> + e_->getRequestGroupMan()->getReservedGroups()[0]-> getDownloadContext()->getFirstFileEntry()->getRemainingUris()[0]; CPPUNIT_ASSERT_EQUAL(std::string("http://uri2"), uri); @@ -252,7 +252,7 @@ void XmlRpcMethodTest::testAddUri_withBadPosition() req.params->append(urisParam); req.params->append(Dict::g()); req.params->append(Integer::g(-1)); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -266,12 +266,12 @@ void XmlRpcMethodTest::testAddTorrent() uris->append("http://localhost/aria2-0.8.2.tar.bz2"); req.params->append(uris); { - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL(std::string("1"), asString(res.param)->s()); SharedHandle<RequestGroup> group = - _e->getRequestGroupMan()->findReservedGroup(1); + e_->getRequestGroupMan()->findReservedGroup(1); CPPUNIT_ASSERT(!group.isNull()); CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-0.8.2.tar.bz2"), group->getFirstFilePath()); @@ -287,10 +287,10 @@ void XmlRpcMethodTest::testAddTorrent() opt->put(PREF_DIR, "/sink"); req.params->append(opt); { - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL(std::string("/sink/aria2-0.8.2.tar.bz2"), - _e->getRequestGroupMan()->findReservedGroup(2)-> + e_->getRequestGroupMan()->findReservedGroup(2)-> getFirstFilePath()); } } @@ -299,7 +299,7 @@ void XmlRpcMethodTest::testAddTorrent_withoutTorrent() { AddTorrentXmlRpcMethod m; XmlRpcRequest req(AddTorrentXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -308,7 +308,7 @@ void XmlRpcMethodTest::testAddTorrent_notBase64Torrent() AddTorrentXmlRpcMethod m; XmlRpcRequest req(AddTorrentXmlRpcMethod::getMethodName(), List::g()); req.params->append("not torrent"); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -319,7 +319,7 @@ void XmlRpcMethodTest::testAddTorrent_withPosition() req1.params->append(readFile("test.torrent")); req1.params->append(List::g()); req1.params->append(Dict::g()); - XmlRpcResponse res1 = m.execute(req1, _e.get()); + XmlRpcResponse res1 = m.execute(req1, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res1.code); XmlRpcRequest req2(AddTorrentXmlRpcMethod::getMethodName(), List::g()); @@ -327,10 +327,10 @@ void XmlRpcMethodTest::testAddTorrent_withPosition() req2.params->append(List::g()); req2.params->append(Dict::g()); req2.params->append(Integer::g(0)); - m.execute(req2, _e.get()); + m.execute(req2, e_.get()); CPPUNIT_ASSERT_EQUAL((size_t)1, - _e->getRequestGroupMan()->getReservedGroups()[0]-> + e_->getRequestGroupMan()->getReservedGroups()[0]-> getDownloadContext()->getFileEntries().size()); } @@ -343,7 +343,7 @@ void XmlRpcMethodTest::testAddMetalink() XmlRpcRequest req(AddMetalinkXmlRpcMethod::getMethodName(), List::g()); req.params->append(readFile("2files.metalink")); { - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); const List* resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)2, resParams->size()); @@ -351,12 +351,12 @@ void XmlRpcMethodTest::testAddMetalink() CPPUNIT_ASSERT_EQUAL(std::string("2"), asString(resParams->get(1))->s()); SharedHandle<RequestGroup> tar = - _e->getRequestGroupMan()->findReservedGroup(1); + e_->getRequestGroupMan()->findReservedGroup(1); CPPUNIT_ASSERT(!tar.isNull()); CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-5.0.0.tar.bz2"), tar->getFirstFilePath()); SharedHandle<RequestGroup> deb = - _e->getRequestGroupMan()->findReservedGroup(2); + e_->getRequestGroupMan()->findReservedGroup(2); CPPUNIT_ASSERT(!deb.isNull()); CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-5.0.0.deb"), deb->getFirstFilePath()); @@ -366,10 +366,10 @@ void XmlRpcMethodTest::testAddMetalink() opt->put(PREF_DIR, "/sink"); req.params->append(opt); { - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL(std::string("/sink/aria2-5.0.0.tar.bz2"), - _e->getRequestGroupMan()->findReservedGroup(3)-> + e_->getRequestGroupMan()->findReservedGroup(3)-> getFirstFilePath()); } } @@ -378,7 +378,7 @@ void XmlRpcMethodTest::testAddMetalink_withoutMetalink() { AddMetalinkXmlRpcMethod m; XmlRpcRequest req(AddMetalinkXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -387,7 +387,7 @@ void XmlRpcMethodTest::testAddMetalink_notBase64Metalink() AddMetalinkXmlRpcMethod m; XmlRpcRequest req(AddMetalinkXmlRpcMethod::getMethodName(), List::g()); req.params->append("not metalink"); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -398,7 +398,7 @@ void XmlRpcMethodTest::testAddMetalink_withPosition() SharedHandle<List> urisParam1 = List::g(); urisParam1->append("http://uri"); req1.params->append(urisParam1); - XmlRpcResponse res1 = m1.execute(req1, _e.get()); + XmlRpcResponse res1 = m1.execute(req1, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res1.code); AddMetalinkXmlRpcMethod m2; @@ -406,11 +406,11 @@ void XmlRpcMethodTest::testAddMetalink_withPosition() req2.params->append(readFile("2files.metalink")); req2.params->append(Dict::g()); req2.params->append(Integer::g(0)); - XmlRpcResponse res2 = m2.execute(req2, _e.get()); + XmlRpcResponse res2 = m2.execute(req2, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res2.code); CPPUNIT_ASSERT_EQUAL(std::string("/tmp/aria2-5.0.0.tar.bz2"), - _e->getRequestGroupMan()->getReservedGroups()[0]-> + e_->getRequestGroupMan()->getReservedGroups()[0]-> getFirstFilePath()); } @@ -418,8 +418,8 @@ void XmlRpcMethodTest::testAddMetalink_withPosition() void XmlRpcMethodTest::testChangeOption() { - SharedHandle<RequestGroup> group(new RequestGroup(_option)); - _e->getRequestGroupMan()->addReservedGroup(group); + SharedHandle<RequestGroup> group(new RequestGroup(option_)); + e_->getRequestGroupMan()->addReservedGroup(group); ChangeOptionXmlRpcMethod m; XmlRpcRequest req(ChangeOptionXmlRpcMethod::getMethodName(), List::g()); @@ -432,11 +432,11 @@ void XmlRpcMethodTest::testChangeOption() opt->put(PREF_MAX_UPLOAD_LIMIT, "50K"); BtObject btObject; - btObject._btRuntime = SharedHandle<BtRuntime>(new BtRuntime()); - _e->getBtRegistry()->put(group->getGID(), btObject); + btObject.btRuntime_ = SharedHandle<BtRuntime>(new BtRuntime()); + e_->getBtRegistry()->put(group->getGID(), btObject); #endif // ENABLE_BITTORRENT req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); SharedHandle<Option> option = group->getOption(); @@ -450,7 +450,7 @@ void XmlRpcMethodTest::testChangeOption() option->get(PREF_BT_REQUEST_PEER_SPEED_LIMIT)); CPPUNIT_ASSERT_EQUAL(std::string("100"), option->get(PREF_BT_MAX_PEERS)); - CPPUNIT_ASSERT_EQUAL((unsigned int)100, btObject._btRuntime->getMaxPeers()); + CPPUNIT_ASSERT_EQUAL((unsigned int)100, btObject.btRuntime_->getMaxPeers()); CPPUNIT_ASSERT_EQUAL((unsigned int)50*1024, group->getMaxUploadSpeedLimit()); @@ -461,8 +461,8 @@ void XmlRpcMethodTest::testChangeOption() void XmlRpcMethodTest::testChangeOption_withBadOption() { - SharedHandle<RequestGroup> group(new RequestGroup(_option)); - _e->getRequestGroupMan()->addReservedGroup(group); + SharedHandle<RequestGroup> group(new RequestGroup(option_)); + e_->getRequestGroupMan()->addReservedGroup(group); ChangeOptionXmlRpcMethod m; XmlRpcRequest req(ChangeOptionXmlRpcMethod::getMethodName(), List::g()); @@ -470,14 +470,14 @@ void XmlRpcMethodTest::testChangeOption_withBadOption() SharedHandle<Dict> opt = Dict::g(); opt->put(PREF_MAX_DOWNLOAD_LIMIT, "badvalue"); req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } void XmlRpcMethodTest::testChangeOption_withNotAllowedOption() { - SharedHandle<RequestGroup> group(new RequestGroup(_option)); - _e->getRequestGroupMan()->addReservedGroup(group); + SharedHandle<RequestGroup> group(new RequestGroup(option_)); + e_->getRequestGroupMan()->addReservedGroup(group); ChangeOptionXmlRpcMethod m; XmlRpcRequest req(ChangeOptionXmlRpcMethod::getMethodName(), List::g()); @@ -485,7 +485,7 @@ void XmlRpcMethodTest::testChangeOption_withNotAllowedOption() SharedHandle<Dict> opt = Dict::g(); opt->put(PREF_MAX_OVERALL_DOWNLOAD_LIMIT, "100K"); req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -493,7 +493,7 @@ void XmlRpcMethodTest::testChangeOption_withoutGid() { ChangeOptionXmlRpcMethod m; XmlRpcRequest req(ChangeOptionXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -508,20 +508,20 @@ void XmlRpcMethodTest::testChangeGlobalOption() opt->put(PREF_MAX_OVERALL_UPLOAD_LIMIT, "50K"); #endif // ENABLE_BITTORRENT req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL ((unsigned int)100*1024, - _e->getRequestGroupMan()->getMaxOverallDownloadSpeedLimit()); + e_->getRequestGroupMan()->getMaxOverallDownloadSpeedLimit()); CPPUNIT_ASSERT_EQUAL(std::string("102400"), - _e->getOption()->get(PREF_MAX_OVERALL_DOWNLOAD_LIMIT)); + e_->getOption()->get(PREF_MAX_OVERALL_DOWNLOAD_LIMIT)); #ifdef ENABLE_BITTORRENT CPPUNIT_ASSERT_EQUAL ((unsigned int)50*1024, - _e->getRequestGroupMan()->getMaxOverallUploadSpeedLimit()); + e_->getRequestGroupMan()->getMaxOverallUploadSpeedLimit()); CPPUNIT_ASSERT_EQUAL(std::string("51200"), - _e->getOption()->get(PREF_MAX_OVERALL_UPLOAD_LIMIT)); + e_->getOption()->get(PREF_MAX_OVERALL_UPLOAD_LIMIT)); #endif // ENABLE_BITTORRENT } @@ -533,7 +533,7 @@ void XmlRpcMethodTest::testChangeGlobalOption_withBadOption() SharedHandle<Dict> opt = Dict::g(); opt->put(PREF_MAX_OVERALL_DOWNLOAD_LIMIT, "badvalue"); req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -545,7 +545,7 @@ void XmlRpcMethodTest::testChangeGlobalOption_withNotAllowedOption() SharedHandle<Dict> opt = Dict::g(); opt->put(PREF_MAX_DOWNLOAD_LIMIT, "100K"); req.params->append(opt); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -583,7 +583,7 @@ void XmlRpcMethodTest::testTellStatus_withoutGid() { TellStatusXmlRpcMethod m; XmlRpcRequest req(TellStatusXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -613,20 +613,20 @@ static void addTorrent void XmlRpcMethodTest::testTellWaiting() { - addUri("http://1/", _e); - addUri("http://2/", _e); - addUri("http://3/", _e); + addUri("http://1/", e_); + addUri("http://2/", e_); + addUri("http://3/", e_); #ifdef ENABLE_BITTORRENT - addTorrent("single.torrent", _e); + addTorrent("single.torrent", e_); #else // !ENABLE_BITTORRENT - addUri("http://4/", _e); + addUri("http://4/", e_); #endif // !ENABLE_BITTORRENT TellWaitingXmlRpcMethod m; XmlRpcRequest req(TellWaitingXmlRpcMethod::getMethodName(), List::g()); req.params->append(Integer::g(1)); req.params->append(Integer::g(2)); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); const List* resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)2, resParams->size()); @@ -638,7 +638,7 @@ void XmlRpcMethodTest::testTellWaiting() req = XmlRpcRequest(TellWaitingXmlRpcMethod::getMethodName(), List::g()); req.params->append(Integer::g(1)); req.params->append(Integer::g(3)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)3, resParams->size()); @@ -646,7 +646,7 @@ void XmlRpcMethodTest::testTellWaiting() req = XmlRpcRequest(TellWaitingXmlRpcMethod::getMethodName(), List::g()); req.params->append(Integer::g(1)); req.params->append(Integer::g(4)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)3, resParams->size()); @@ -654,7 +654,7 @@ void XmlRpcMethodTest::testTellWaiting() req = XmlRpcRequest(TellWaitingXmlRpcMethod::getMethodName(), List::g()); req.params->append(Integer::g(-1)); req.params->append(Integer::g(2)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)2, resParams->size()); @@ -664,19 +664,19 @@ void XmlRpcMethodTest::testTellWaiting() getString(asDict(resParams->get(1)), "gid")); // negative offset and size < num req.params->set(1, Integer::g(100)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)4, resParams->size()); // nagative offset and normalized offset < 0 req.params->set(0, Integer::g(-5)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)0, resParams->size()); // nagative offset and normalized offset == 0 req.params->set(0, Integer::g(-4)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)1, resParams->size()); @@ -686,7 +686,7 @@ void XmlRpcMethodTest::testTellWaiting_fail() { TellWaitingXmlRpcMethod m; XmlRpcRequest req(TellWaitingXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -694,7 +694,7 @@ void XmlRpcMethodTest::testGetVersion() { GetVersionXmlRpcMethod m; XmlRpcRequest req(GetVersionXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); const Dict* resParams = asDict(res.param); CPPUNIT_ASSERT_EQUAL(std::string(PACKAGE_VERSION), @@ -742,12 +742,12 @@ void XmlRpcMethodTest::testGatherProgressCommon() SharedHandle<DownloadContext> dctx(new DownloadContext(0, 0,"aria2.tar.bz2")); std::string uris[] = { "http://localhost/aria2.tar.bz2" }; dctx->getFirstFileEntry()->addUris(vbegin(uris), vend(uris)); - dctx->setDir(_option->get(PREF_DIR)); - SharedHandle<RequestGroup> group(new RequestGroup(_option)); + dctx->setDir(option_->get(PREF_DIR)); + SharedHandle<RequestGroup> group(new RequestGroup(option_)); group->setDownloadContext(dctx); std::vector<SharedHandle<RequestGroup> > followedBy; for(int i = 0; i < 2; ++i) { - followedBy.push_back(SharedHandle<RequestGroup>(new RequestGroup(_option))); + followedBy.push_back(SharedHandle<RequestGroup>(new RequestGroup(option_))); } group->followedBy(followedBy.begin(), followedBy.end()); @@ -822,28 +822,28 @@ void XmlRpcMethodTest::testGatherBitTorrentMetadata() void XmlRpcMethodTest::testChangePosition() { - _e->getRequestGroupMan()->addReservedGroup - (SharedHandle<RequestGroup>(new RequestGroup(_option))); - _e->getRequestGroupMan()->addReservedGroup - (SharedHandle<RequestGroup>(new RequestGroup(_option))); + e_->getRequestGroupMan()->addReservedGroup + (SharedHandle<RequestGroup>(new RequestGroup(option_))); + e_->getRequestGroupMan()->addReservedGroup + (SharedHandle<RequestGroup>(new RequestGroup(option_))); ChangePositionXmlRpcMethod m; XmlRpcRequest req(ChangePositionXmlRpcMethod::getMethodName(), List::g()); req.params->append("1"); req.params->append(Integer::g(1)); req.params->append("POS_SET"); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL((int64_t)1, asInteger(res.param)->i()); CPPUNIT_ASSERT_EQUAL - ((gid_t)1, _e->getRequestGroupMan()->getReservedGroups()[1]->getGID()); + ((gid_t)1, e_->getRequestGroupMan()->getReservedGroups()[1]->getGID()); } void XmlRpcMethodTest::testChangePosition_fail() { ChangePositionXmlRpcMethod m; XmlRpcRequest req(ChangePositionXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); req.params->append("1"); @@ -863,9 +863,9 @@ void XmlRpcMethodTest::testChangeUri() files[1]->addUri("http://example.org/mustremove2"); SharedHandle<DownloadContext> dctx(new DownloadContext()); dctx->setFileEntries(&files[0], &files[3]); - SharedHandle<RequestGroup> group(new RequestGroup(_option)); + SharedHandle<RequestGroup> group(new RequestGroup(option_)); group->setDownloadContext(dctx); - _e->getRequestGroupMan()->addReservedGroup(group); + e_->getRequestGroupMan()->addReservedGroup(group); ChangeUriXmlRpcMethod m; XmlRpcRequest req(ChangeUriXmlRpcMethod::getMethodName(), List::g()); @@ -882,7 +882,7 @@ void XmlRpcMethodTest::testChangeUri() adduris->append("baduri"); adduris->append("http://example.org/added3"); req.params->append(adduris); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL((int64_t)2, asInteger(asList(res.param)->get(0))->i()); CPPUNIT_ASSERT_EQUAL((int64_t)3, asInteger(asList(res.param)->get(1))->i()); @@ -902,7 +902,7 @@ void XmlRpcMethodTest::testChangeUri() req.params->set(3, adduris); // Set position parameter req.params->append(Integer::g(2)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL((int64_t)0, asInteger(asList(res.param)->get(0))->i()); CPPUNIT_ASSERT_EQUAL((int64_t)2, asInteger(asList(res.param)->get(1))->i()); @@ -915,7 +915,7 @@ void XmlRpcMethodTest::testChangeUri() req.params->set(1, Integer::g(1)); // Set position far beyond the size of uris in FileEntry. req.params->set(4, Integer::g(1000)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); CPPUNIT_ASSERT_EQUAL((int64_t)0, asInteger(asList(res.param)->get(0))->i()); CPPUNIT_ASSERT_EQUAL((int64_t)2, asInteger(asList(res.param)->get(1))->i()); @@ -933,9 +933,9 @@ void XmlRpcMethodTest::testChangeUri_fail() } SharedHandle<DownloadContext> dctx(new DownloadContext()); dctx->setFileEntries(&files[0], &files[3]); - SharedHandle<RequestGroup> group(new RequestGroup(_option)); + SharedHandle<RequestGroup> group(new RequestGroup(option_)); group->setDownloadContext(dctx); - _e->getRequestGroupMan()->addReservedGroup(group); + e_->getRequestGroupMan()->addReservedGroup(group); ChangeUriXmlRpcMethod m; XmlRpcRequest req(ChangeUriXmlRpcMethod::getMethodName(), List::g()); @@ -945,34 +945,34 @@ void XmlRpcMethodTest::testChangeUri_fail() req.params->append(removeuris); SharedHandle<List> adduris = List::g(); req.params->append(adduris); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); req.params->set(0, String::g("2")); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); // RPC request fails because GID#2 does not exist. CPPUNIT_ASSERT_EQUAL(1, res.code); req.params->set(0, String::g("1")); req.params->set(1, Integer::g(4)); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); // RPC request fails because FileEntry#3 does not exist. CPPUNIT_ASSERT_EQUAL(1, res.code); req.params->set(1, String::g("0")); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); // RPC request fails because index of FileEntry is string. CPPUNIT_ASSERT_EQUAL(1, res.code); req.params->set(1, Integer::g(1)); req.params->set(2, String::g("http://url")); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); // RPC request fails because 3rd param is not list. CPPUNIT_ASSERT_EQUAL(1, res.code); req.params->set(2, List::g()); req.params->set(3, String::g("http://url")); - res = m.execute(req, _e.get()); + res = m.execute(req, e_.get()); // RPC request fails because 4th param is not list. CPPUNIT_ASSERT_EQUAL(1, res.code); } @@ -981,9 +981,9 @@ void XmlRpcMethodTest::testGetSessionInfo() { GetSessionInfoXmlRpcMethod m; XmlRpcRequest req(GetSessionInfoXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); - CPPUNIT_ASSERT_EQUAL(util::toHex(_e->getSessionId()), + CPPUNIT_ASSERT_EQUAL(util::toHex(e_->getSessionId()), getString(asDict(res.param), "sessionId")); } @@ -995,16 +995,16 @@ void XmlRpcMethodTest::testPause() "http://url3", }; std::vector<std::string> uris(vbegin(URIS), vend(URIS)); - _option->put(PREF_FORCE_SEQUENTIAL, V_TRUE); + option_->put(PREF_FORCE_SEQUENTIAL, V_TRUE); std::vector<SharedHandle<RequestGroup> > groups; - createRequestGroupForUri(groups, _option, uris); + createRequestGroupForUri(groups, option_, uris); CPPUNIT_ASSERT_EQUAL((size_t)3, groups.size()); - _e->getRequestGroupMan()->addReservedGroup(groups); + e_->getRequestGroupMan()->addReservedGroup(groups); { PauseXmlRpcMethod m; XmlRpcRequest req(PauseXmlRpcMethod::getMethodName(), List::g()); req.params->append("1"); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); } CPPUNIT_ASSERT(groups[0]->isPauseRequested()); @@ -1012,14 +1012,14 @@ void XmlRpcMethodTest::testPause() UnpauseXmlRpcMethod m; XmlRpcRequest req(UnpauseXmlRpcMethod::getMethodName(), List::g()); req.params->append("1"); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); } CPPUNIT_ASSERT(!groups[0]->isPauseRequested()); { PauseAllXmlRpcMethod m; XmlRpcRequest req(PauseAllXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); } for(size_t i = 0; i < groups.size(); ++i) { @@ -1028,7 +1028,7 @@ void XmlRpcMethodTest::testPause() { UnpauseAllXmlRpcMethod m; XmlRpcRequest req(UnpauseAllXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); } for(size_t i = 0; i < groups.size(); ++i) { @@ -1037,7 +1037,7 @@ void XmlRpcMethodTest::testPause() { ForcePauseAllXmlRpcMethod m; XmlRpcRequest req(ForcePauseAllXmlRpcMethod::getMethodName(), List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); } for(size_t i = 0; i < groups.size(); ++i) { @@ -1088,7 +1088,7 @@ void XmlRpcMethodTest::testSystemMulticall() dict->put("params", List::g()); reqparams->append(dict); } - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(0, res.code); const List* resParams = asList(res.param); CPPUNIT_ASSERT_EQUAL((size_t)7, resParams->size()); @@ -1119,7 +1119,7 @@ void XmlRpcMethodTest::testSystemMulticall_fail() { SystemMulticallXmlRpcMethod m; XmlRpcRequest req("system.multicall", List::g()); - XmlRpcResponse res = m.execute(req, _e.get()); + XmlRpcResponse res = m.execute(req, e_.get()); CPPUNIT_ASSERT_EQUAL(1, res.code); } diff --git a/test/a2functionalTest.cc b/test/a2functionalTest.cc index 776930c7..518b9e22 100644 --- a/test/a2functionalTest.cc +++ b/test/a2functionalTest.cc @@ -52,12 +52,12 @@ public: }; struct LastAccess { - time_t _lastAccess; - LastAccess(time_t lastAccess):_lastAccess(lastAccess) {} + time_t lastAccess_; + LastAccess(time_t lastAccess):lastAccess_(lastAccess) {} time_t getLastAccess() const { - return _lastAccess; + return lastAccess_; } }; }; @@ -120,7 +120,7 @@ void a2functionalTest::testLeastRecentAccess() } std::sort(v.begin(), v.end(), LeastRecentAccess<LastAccess>()); for(int i = 0; i < 100; ++i) { - CPPUNIT_ASSERT_EQUAL((time_t)i, v[i]._lastAccess); + CPPUNIT_ASSERT_EQUAL((time_t)i, v[i].lastAccess_); } } |