Merge branch 'master' into random-webseeding

1 files changed, 75 insertions, 69 deletions

diff --git a/src/InitiatorMSEHandshakeCommand.cc b/src/InitiatorMSEHandshakeCommand.cc
index 7a04b984..ebcaa11b 100644
--- a/src/InitiatorMSEHandshakeCommand.cc
+++ b/src/InitiatorMSEHandshakeCommand.cc
@@ -59,18 +59,15 @@
 
 namespace aria2 {
 
-InitiatorMSEHandshakeCommand::InitiatorMSEHandshakeCommand
-(cuid_t cuid,
- RequestGroup* requestGroup,
- const std::shared_ptr<Peer>& p,
- DownloadEngine* e,
- const std::shared_ptr<BtRuntime>& btRuntime,
- const std::shared_ptr<SocketCore>& s)
-  : PeerAbstractCommand(cuid, p, e, s),
-    requestGroup_(requestGroup),
-    btRuntime_(btRuntime),
-    sequence_(INITIATOR_SEND_KEY),
-    mseHandshake_(make_unique<MSEHandshake>(cuid, s, getOption().get()))
+InitiatorMSEHandshakeCommand::InitiatorMSEHandshakeCommand(
+    cuid_t cuid, RequestGroup* requestGroup, const std::shared_ptr<Peer>& p,
+    DownloadEngine* e, const std::shared_ptr<BtRuntime>& btRuntime,
+    const std::shared_ptr<SocketCore>& s)
+    : PeerAbstractCommand(cuid, p, e, s),
+      requestGroup_(requestGroup),
+      btRuntime_(btRuntime),
+      sequence_(INITIATOR_SEND_KEY),
+      mseHandshake_(make_unique<MSEHandshake>(cuid, s, getOption().get()))
 {
   disableReadCheckSocket();
   setWriteCheckSocket(getSocket());
@@ -87,15 +84,16 @@ InitiatorMSEHandshakeCommand::~InitiatorMSEHandshakeCommand()
   btRuntime_->decreaseConnections();
 }
 
-bool InitiatorMSEHandshakeCommand::executeInternal() {
-  if(mseHandshake_->getWantRead()) {
+bool InitiatorMSEHandshakeCommand::executeInternal()
+{
+  if (mseHandshake_->getWantRead()) {
     mseHandshake_->read();
   }
   bool done = false;
-  while(!done) {
-    switch(sequence_) {
+  while (!done) {
+    switch (sequence_) {
     case INITIATOR_SEND_KEY: {
-      if(!getSocket()->isWritable(0)) {
+      if (!getSocket()->isWritable(0)) {
         addCommandSelf();
         return false;
       }
@@ -106,88 +104,93 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
       break;
     }
     case INITIATOR_SEND_KEY_PENDING:
-      if(mseHandshake_->send()) {
+      if (mseHandshake_->send()) {
         sequence_ = INITIATOR_WAIT_KEY;
-      } else {
+      }
+      else {
         done = true;
       }
       break;
     case INITIATOR_WAIT_KEY: {
-      if(mseHandshake_->receivePublicKey()) {
-        mseHandshake_->initCipher
-          (bittorrent::getInfoHash(requestGroup_->getDownloadContext()));;
+      if (mseHandshake_->receivePublicKey()) {
+        mseHandshake_->initCipher(
+            bittorrent::getInfoHash(requestGroup_->getDownloadContext()));
+        ;
         mseHandshake_->sendInitiatorStep2();
         sequence_ = INITIATOR_SEND_STEP2_PENDING;
-      } else {
+      }
+      else {
         done = true;
       }
       break;
     }
     case INITIATOR_SEND_STEP2_PENDING:
-      if(mseHandshake_->send()) {
+      if (mseHandshake_->send()) {
         sequence_ = INITIATOR_FIND_VC_MARKER;
-      } else {
+      }
+      else {
         done = true;
       }
       break;
     case INITIATOR_FIND_VC_MARKER: {
-      if(mseHandshake_->findInitiatorVCMarker()) {
+      if (mseHandshake_->findInitiatorVCMarker()) {
         sequence_ = INITIATOR_RECEIVE_PAD_D_LENGTH;
-      } else {
+      }
+      else {
         done = true;
       }
       break;
     }
     case INITIATOR_RECEIVE_PAD_D_LENGTH: {
-      if(mseHandshake_->receiveInitiatorCryptoSelectAndPadDLength()) {
+      if (mseHandshake_->receiveInitiatorCryptoSelectAndPadDLength()) {
         sequence_ = INITIATOR_RECEIVE_PAD_D;
-      } else {
+      }
+      else {
         done = true;
       }
       break;
     }
     case INITIATOR_RECEIVE_PAD_D: {
-      if(mseHandshake_->receivePad()) {
-        auto peerConnection = make_unique<PeerConnection>
-          (getCuid(), getPeer(), getSocket());
-        if(mseHandshake_->getNegotiatedCryptoType() ==
-           MSEHandshake::CRYPTO_ARC4){
+      if (mseHandshake_->receivePad()) {
+        auto peerConnection =
+            make_unique<PeerConnection>(getCuid(), getPeer(), getSocket());
+        if (mseHandshake_->getNegotiatedCryptoType() ==
+            MSEHandshake::CRYPTO_ARC4) {
           size_t buflen = mseHandshake_->getBufferLength();
-          mseHandshake_->getDecryptor()->encrypt(buflen,
-                                                 mseHandshake_->getBuffer(),
-                                                 mseHandshake_->getBuffer());
+          mseHandshake_->getDecryptor()->encrypt(
+              buflen, mseHandshake_->getBuffer(), mseHandshake_->getBuffer());
           peerConnection->presetBuffer(mseHandshake_->getBuffer(), buflen);
           peerConnection->enableEncryption(mseHandshake_->popEncryptor(),
                                            mseHandshake_->popDecryptor());
-        } else {
+        }
+        else {
           peerConnection->presetBuffer(mseHandshake_->getBuffer(),
                                        mseHandshake_->getBufferLength());
         }
-        getDownloadEngine()->addCommand
-          (make_unique<PeerInteractionCommand>
-           (getCuid(), requestGroup_, getPeer(),
-            getDownloadEngine(), btRuntime_,
-            pieceStorage_,
-            peerStorage_,
-            getSocket(),
+        getDownloadEngine()->addCommand(make_unique<PeerInteractionCommand>(
+            getCuid(), requestGroup_, getPeer(), getDownloadEngine(),
+            btRuntime_, pieceStorage_, peerStorage_, getSocket(),
             PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE,
             std::move(peerConnection)));
         return true;
-      } else {
+      }
+      else {
         done = true;
       }
       break;
     }
     }
   }
-  if(mseHandshake_->getWantRead()) {
+  if (mseHandshake_->getWantRead()) {
     setReadCheckSocket(getSocket());
-  } else {
+  }
+  else {
     disableReadCheckSocket();
   }
-  if(mseHandshake_->getWantWrite()) {
+  if (mseHandshake_->getWantWrite()) {
     setWriteCheckSocket(getSocket());
-  } else {
+  }
+  else {
     disableWriteCheckSocket();
   }
   addCommandSelf();
@@ -196,13 +199,13 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
 
 void InitiatorMSEHandshakeCommand::tryNewPeer()
 {
-  if(peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) {
+  if (peerStorage_->isPeerAvailable() && btRuntime_->lessThanEqMinPeers()) {
     cuid_t ncuid = getDownloadEngine()->newCUID();
     std::shared_ptr<Peer> peer = peerStorage_->checkoutPeer(ncuid);
     // sanity check
-    if(peer) {
-      auto command = make_unique<PeerInitiateConnectionCommand>
-        (ncuid, requestGroup_, peer, getDownloadEngine(), btRuntime_);
+    if (peer) {
+      auto command = make_unique<PeerInitiateConnectionCommand>(
+          ncuid, requestGroup_, peer, getDownloadEngine(), btRuntime_);
       command->setPeerStorage(peerStorage_);
       command->setPieceStorage(pieceStorage_);
       getDownloadEngine()->addCommand(std::move(command));
@@ -212,25 +215,28 @@ void InitiatorMSEHandshakeCommand::tryNewPeer()
 
 bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait)
 {
-  if(sequence_ == INITIATOR_SEND_KEY) {
+  if (sequence_ == INITIATOR_SEND_KEY) {
     // We don't try legacy handshake when connection did not
     // established.
     tryNewPeer();
     return true;
-  } else if(getOption()->getAsBool(PREF_BT_FORCE_ENCRYPTION) ||
-            getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
+  }
+  else if (getOption()->getAsBool(PREF_BT_FORCE_ENCRYPTION) ||
+           getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
     A2_LOG_INFO(fmt("CUID#%" PRId64 " - Establishing connection using legacy"
                     " BitTorrent handshake is disabled by preference.",
                     getCuid()));
     tryNewPeer();
     return true;
-  } else {
+  }
+  else {
     // try legacy BitTorrent handshake
-    A2_LOG_INFO(fmt("CUID#%" PRId64 " - Retry using legacy BitTorrent handshake.",
+    A2_LOG_INFO(fmt("CUID#%" PRId64
+                    " - Retry using legacy BitTorrent handshake.",
                     getCuid()));
-    auto command = make_unique<PeerInitiateConnectionCommand>
-      (getCuid(), requestGroup_, getPeer(),
-       getDownloadEngine(), btRuntime_, false);
+    auto command = make_unique<PeerInitiateConnectionCommand>(
+        getCuid(), requestGroup_, getPeer(), getDownloadEngine(), btRuntime_,
+        false);
     command->setPeerStorage(peerStorage_);
     command->setPieceStorage(pieceStorage_);
     getDownloadEngine()->addCommand(std::move(command));
@@ -240,9 +246,9 @@ bool InitiatorMSEHandshakeCommand::prepareForNextPeer(time_t wait)
 
 void InitiatorMSEHandshakeCommand::onAbort()
 {
-  if(sequence_ == INITIATOR_SEND_KEY ||
-     getOption()->getAsBool(PREF_BT_FORCE_ENCRYPTION) ||
-     getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
+  if (sequence_ == INITIATOR_SEND_KEY ||
+      getOption()->getAsBool(PREF_BT_FORCE_ENCRYPTION) ||
+      getOption()->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
     peerStorage_->returnPeer(getPeer());
   }
 }
@@ -252,14 +258,14 @@ bool InitiatorMSEHandshakeCommand::exitBeforeExecute()
   return btRuntime_->isHalt();
 }
 
-void InitiatorMSEHandshakeCommand::setPeerStorage
-(const std::shared_ptr<PeerStorage>& peerStorage)
+void InitiatorMSEHandshakeCommand::setPeerStorage(
+    const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
-void InitiatorMSEHandshakeCommand::setPieceStorage
-(const std::shared_ptr<PieceStorage>& pieceStorage)
+void InitiatorMSEHandshakeCommand::setPieceStorage(
+    const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }