diff --git a/ChangeLog b/ChangeLog
index 0cda9819..4aceba05 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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;
+    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 [] bitfield_;
+    bitfield_ = new unsigned char[bitfieldLength_];
+    memcpy(bitfield_, bitfieldMan.bitfield_, bitfieldLength_);
 
-    delete [] _useBitfield;
-    _useBitfield = new unsigned char[_bitfieldLength];
-    memcpy(_useBitfield, bitfieldMan._useBitfield, _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);
+    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()
diff --git a/src/File.h b/src/File.h
index 7890519a..6454a91d 100644
--- a/src/File.h
+++ b/src/File.h
@@ -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());
+  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;
+  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);
+  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;
+  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);
+  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;
+  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;
+  cuid_t cuid_;
+  SharedHandle<SocketCore> socket_;
+  const Option* option_;
+  Logger* logger_;
 
-  unsigned char _rbuf[MAX_BUFFER_LENGTH];
-  size_t _rbufLength;
+  unsigned char rbuf_[MAX_BUFFER_LENGTH];
+  size_t rbufLength_;
 
-  SocketBuffer _socketBuffer;
+  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;
+  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)
+  ipaddr_(ipaddr),
+  port_(port),
+  firstContactTime_(global::wallclock),
+  badConditionStartTime_(0),
+  seeder_(false),
+  res_(0),
+  incoming_(incoming),
+  localPeer_(false)
 {
-  memset(_peerId, 0, PEER_ID_LENGTH);
+  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
diff --git a/src/Peer.h b/src/Peer.h
index 61baccf2..f8dd168e 100644
--- a/src/Peer.h
+++ b/src/Peer.h
@@ -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())
+  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;
+  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) {}
+    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():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;
+  XmlRpcRequestParserController* controller_;
 
-  std::stack<XmlRpcRequestParserState*> _stateStack;
+  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 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);
+    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);
+    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());
+  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("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"
+  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_);
   }
 }