Update aria2 to 1.37.0.

Documents/BuildOriginalAria2.md

@@ -91,9 +91,9 @@ make install -j8
 make clean
 
 
-https://github.com/aria2/aria2/releases/download/release-1.36.0/aria2-1.36.0.tar.xz
+https://github.com/aria2/aria2/releases/download/release-1.37.0/aria2-1.37.0.tar.xz
 
-cd /c/msys2/aria2-1.36.0
+cd /c/msys2/aria2-1.37.0
 
 autoreconf -ifv
 

Mile.Aria2.Library/AbstractDiskWriter.cc

@@ -258,7 +258,7 @@ ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data,
                                               size_t len, int64_t offset)
 {
   if (mapaddr_) {
-    memcpy(mapaddr_ + offset, data, len);
+    std::copy_n(data, len, mapaddr_ + offset);
     return len;
   }
   else {
@@ -298,7 +298,7 @@ ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len,
       return 0;
     }
     auto readlen = std::min(maplen_ - offset, static_cast<int64_t>(len));
-    memcpy(data, mapaddr_ + offset, readlen);
+    std::copy_n(mapaddr_ + offset, readlen, data);
     return readlen;
   }
   else {
@@ -597,7 +597,7 @@ void AbstractDiskWriter::flushOSBuffers()
   }
 #ifdef __MINGW32__
   FlushFileBuffers(fd_);
-#else // !__MINGW32__
+#else  // !__MINGW32__
   fsync(fd_);
 #endif // __MINGW32__
 }

Mile.Aria2.Library/BitfieldMan.cc

@@ -64,8 +64,8 @@ BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength)
     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_);
+    std::fill_n(bitfield_, bitfieldLength_, 0);
+    std::fill_n(useBitfield_, bitfieldLength_, 0);
     updateCache();
   }
 }
@@ -85,11 +85,11 @@ BitfieldMan::BitfieldMan(const BitfieldMan& bitfieldMan)
       blockLength_(bitfieldMan.blockLength_),
       filterEnabled_(bitfieldMan.filterEnabled_)
 {
-  memcpy(bitfield_, bitfieldMan.bitfield_, bitfieldLength_);
-  memcpy(useBitfield_, bitfieldMan.useBitfield_, bitfieldLength_);
+  std::copy_n(bitfieldMan.bitfield_, bitfieldLength_, bitfield_);
+  std::copy_n(bitfieldMan.useBitfield_, bitfieldLength_, useBitfield_);
   if (filterEnabled_) {
     filterBitfield_ = new unsigned char[bitfieldLength_];
-    memcpy(filterBitfield_, bitfieldMan.filterBitfield_, bitfieldLength_);
+    std::copy_n(bitfieldMan.filterBitfield_, bitfieldLength_, filterBitfield_);
   }
   updateCache();
 }
@@ -105,16 +105,17 @@ BitfieldMan& BitfieldMan::operator=(const BitfieldMan& bitfieldMan)
 
     delete[] bitfield_;
     bitfield_ = new unsigned char[bitfieldLength_];
-    memcpy(bitfield_, bitfieldMan.bitfield_, bitfieldLength_);
+    std::copy_n(bitfieldMan.bitfield_, bitfieldLength_, bitfield_);
 
     delete[] useBitfield_;
     useBitfield_ = new unsigned char[bitfieldLength_];
-    memcpy(useBitfield_, bitfieldMan.useBitfield_, bitfieldLength_);
+    std::copy_n(bitfieldMan.useBitfield_, bitfieldLength_, useBitfield_);
 
     delete[] filterBitfield_;
     if (filterEnabled_) {
       filterBitfield_ = new unsigned char[bitfieldLength_];
-      memcpy(filterBitfield_, bitfieldMan.filterBitfield_, bitfieldLength_);
+      std::copy_n(bitfieldMan.filterBitfield_, bitfieldLength_,
+                  filterBitfield_);
     }
     else {
       filterBitfield_ = nullptr;
@@ -662,17 +663,17 @@ bool BitfieldMan::isUseBitSet(size_t index) const
 void BitfieldMan::setBitfield(const unsigned char* bitfield,
                               size_t bitfieldLength)
 {
-  if (bitfieldLength_ != bitfieldLength) {
+  if (bitfieldLength_ == 0 || bitfieldLength_ != bitfieldLength) {
     return;
   }
-  memcpy(bitfield_, bitfield, bitfieldLength_);
-  memset(useBitfield_, 0, bitfieldLength_);
+  std::copy_n(bitfield, bitfieldLength_, bitfield_);
+  std::fill_n(useBitfield_, bitfieldLength_, 0);
   updateCache();
 }
 
 void BitfieldMan::clearAllBit()
 {
-  memset(bitfield_, 0, bitfieldLength_);
+  std::fill_n(bitfield_, bitfieldLength_, 0);
   updateCache();
 }
 
@@ -686,7 +687,7 @@ void BitfieldMan::setAllBit()
 
 void BitfieldMan::clearAllUseBit()
 {
-  memset(useBitfield_, 0, bitfieldLength_);
+  std::fill_n(useBitfield_, bitfieldLength_, 0);
   updateCache();
 }
 
@@ -706,7 +707,7 @@ void BitfieldMan::ensureFilterBitfield()
 {
   if (!filterBitfield_) {
     filterBitfield_ = new unsigned char[bitfieldLength_];
-    memset(filterBitfield_, 0, bitfieldLength_);
+    std::fill_n(filterBitfield_, bitfieldLength_, 0);
   }
 }
 

Mile.Aria2.Library/BtChokingEvent.h

@@ -39,8 +39,7 @@
 
 namespace aria2 {
 
-class BtChokingEvent {
-};
+class BtChokingEvent {};
 
 } // namespace aria2
 

Mile.Aria2.Library/BtLeecherStateChoke.cc

@@ -72,8 +72,8 @@ void BtLeecherStateChoke::PeerEntry::swap(PeerEntry& c)
   swap(regularUnchoker_, c.regularUnchoker_);
 }
 
-BtLeecherStateChoke::PeerEntry& BtLeecherStateChoke::PeerEntry::
-operator=(const PeerEntry& c)
+BtLeecherStateChoke::PeerEntry&
+BtLeecherStateChoke::PeerEntry::operator=(const PeerEntry& c)
 {
   if (this != &c) {
     peer_ = c.peer_;
@@ -130,8 +130,8 @@ void swap(BtLeecherStateChoke::PeerEntry& a, BtLeecherStateChoke::PeerEntry& b)
   a.swap(b);
 }
 
-bool BtLeecherStateChoke::PeerFilter::
-operator()(const PeerEntry& peerEntry) const
+bool BtLeecherStateChoke::PeerFilter::operator()(
+    const PeerEntry& peerEntry) const
 {
   return peerEntry.getPeer()->amChoking() == amChoking_ &&
          peerEntry.getPeer()->peerInterested() == peerInterested_;

Mile.Aria2.Library/BtSeederStateChoke.cc

@@ -79,8 +79,8 @@ void BtSeederStateChoke::PeerEntry::swap(PeerEntry& c)
   swap(uploadSpeed_, c.uploadSpeed_);
 }
 
-BtSeederStateChoke::PeerEntry& BtSeederStateChoke::PeerEntry::
-operator=(const PeerEntry& c)
+BtSeederStateChoke::PeerEntry&
+BtSeederStateChoke::PeerEntry::operator=(const PeerEntry& c)
 {
   if (this != &c) {
     peer_ = c.peer_;

Mile.Aria2.Library/BufferedFile.cc

@@ -86,7 +86,9 @@ int BufferedFile::onClose()
 #else  // __MINGW32__
     _commit(fileno(fp_));
 #endif // __MINGW32__
-    rv = fclose(fp_);
+    if (fp_ != stdin && fp_ != stderr) {
+      rv = fclose(fp_);
+    }
     fp_ = nullptr;
   }
   return rv;

Mile.Aria2.Library/ByteArrayDiskWriter.h

@@ -49,7 +49,7 @@ class ByteArrayDiskWriter : public DiskWriter {
   void clear();
 
 public:
-  ByteArrayDiskWriter(size_t maxLength = 5_m);
+  ByteArrayDiskWriter(size_t maxLength = 15_m);
   virtual ~ByteArrayDiskWriter();
 
   virtual void initAndOpenFile(int64_t totalLength = 0) CXX11_OVERRIDE;

Mile.Aria2.Library/ConsoleStatCalc.h

@@ -46,11 +46,6 @@
 namespace aria2 {
 
 class SizeFormatter {
-public:
-
-  typedef int64_t argument_type;
-  typedef std::string result_type;
-
 protected:
   virtual std::string format(int64_t size) const = 0;
 

Mile.Aria2.Library/Context.cc

@@ -270,23 +270,23 @@ Context::Context(bool standalone, int argc, char** argv, const KeyVals& options)
   }
   else
 #endif // ENABLE_METALINK
-      if (!op->blank(PREF_INPUT_FILE)) {
-    if (op->getAsBool(PREF_DEFERRED_INPUT)) {
-      uriListParser = openUriListParser(op->get(PREF_INPUT_FILE));
+    if (!op->blank(PREF_INPUT_FILE)) {
+      if (op->getAsBool(PREF_DEFERRED_INPUT)) {
+        uriListParser = openUriListParser(op->get(PREF_INPUT_FILE));
+      }
+      else {
+        createRequestGroupForUriList(requestGroups, op);
+      }
+#if defined(ENABLE_BITTORRENT) || defined(ENABLE_METALINK)
+    }
+    else if (op->get(PREF_SHOW_FILES) == A2_V_TRUE) {
+      showFiles(args, op);
+      return;
+#endif // ENABLE_METALINK || ENABLE_METALINK
     }
     else {
-      createRequestGroupForUriList(requestGroups, op);
+      createRequestGroupForUri(requestGroups, op, args, false, false, true);
     }
-#if defined(ENABLE_BITTORRENT) || defined(ENABLE_METALINK)
-  }
-  else if (op->get(PREF_SHOW_FILES) == A2_V_TRUE) {
-    showFiles(args, op);
-    return;
-#endif // ENABLE_METALINK || ENABLE_METALINK
-  }
-  else {
-    createRequestGroupForUri(requestGroups, op, args, false, false, true);
-  }
 
   // Remove option values which is only valid for URIs specified in
   // command-line. If they are left, because op is used as a template

Mile.Aria2.Library/CookieStorage.cc

@@ -354,11 +354,6 @@ class CookiePathDividerConverter {
 namespace {
 class OrderByPathDepthDesc {
 public:
-
-  typedef Cookie first_argument_type;
-  typedef Cookie second_argument_type;
-  typedef bool result_type;
-
   bool operator()(const CookiePathDivider& lhs,
                   const CookiePathDivider& rhs) const
   {

Mile.Aria2.Library/DHTPeerAnnounceStorage.cc

@@ -57,9 +57,9 @@ DHTPeerAnnounceStorage::DHTPeerAnnounceStorage()
 {
 }
 
-bool DHTPeerAnnounceStorage::InfoHashLess::
-operator()(const std::shared_ptr<DHTPeerAnnounceEntry>& lhs,
-           const std::shared_ptr<DHTPeerAnnounceEntry>& rhs) const
+bool DHTPeerAnnounceStorage::InfoHashLess::operator()(
+    const std::shared_ptr<DHTPeerAnnounceEntry>& lhs,
+    const std::shared_ptr<DHTPeerAnnounceEntry>& rhs) const
 {
   return memcmp(lhs->getInfoHash(), rhs->getInfoHash(), DHT_ID_LENGTH) < 0;
 }

Mile.Aria2.Library/DHTRoutingTableDeserializer.cc

@@ -196,8 +196,8 @@ void DHTRoutingTableDeserializer::deserialize(const std::string& filename)
 
     nodes.push_back(node);
   }
-  localNode_ = localNode;
-  nodes_ = nodes;
+  localNode_ = std::move(localNode);
+  nodes_ = std::move(nodes);
   A2_LOG_INFO("DHT routing table was loaded successfully");
 }
 

Mile.Aria2.Library/DHTSetup.h

@@ -52,7 +52,7 @@ class DHTSetup {
   ~DHTSetup();
 
   // Returns two vector of Commands.  First one contains regular
-  // commands.  Secod one contains so called routine commands, which
+  // commands.  Second one contains so called routine commands, which
   // executed once per event poll returns.
   std::pair<std::vector<std::unique_ptr<Command>>,
             std::vector<std::unique_ptr<Command>>>

Mile.Aria2.Library/DefaultBtProgressInfoFile.cc

@@ -36,6 +36,7 @@
 
 #include <cstring>
 #include <cstdio>
+#include <array>
 
 #include "PieceStorage.h"
 #include "Piece.h"
@@ -56,6 +57,7 @@
 #include "DownloadContext.h"
 #include "BufferedFile.h"
 #include "SHA1IOFile.h"
+#include "BtConstants.h"
 #ifdef ENABLE_BITTORRENT
 #  include "PeerStorage.h"
 #  include "BtRuntime.h"
@@ -263,21 +265,21 @@ void DefaultBtProgressInfoFile::load()
   if (version >= 1) {
     infoHashLength = ntohl(infoHashLength);
   }
-  if (infoHashLength == 0 && infoHashCheckEnabled) {
+  if (infoHashLength > INFO_HASH_LENGTH ||
+      (infoHashLength != INFO_HASH_LENGTH && infoHashCheckEnabled)) {
     throw DL_ABORT_EX(fmt("Invalid info hash length: %d", infoHashLength));
   }
   if (infoHashLength > 0) {
-    auto savedInfoHash = make_unique<unsigned char[]>((size_t)infoHashLength);
-    READ_CHECK(fp, savedInfoHash.get(), infoHashLength);
+    std::array<unsigned char, INFO_HASH_LENGTH> savedInfoHash;
+    READ_CHECK(fp, savedInfoHash.data(), infoHashLength);
 #ifdef ENABLE_BITTORRENT
     if (infoHashCheckEnabled) {
       const unsigned char* infoHash = bittorrent::getInfoHash(dctx_);
-      if (infoHashLength != INFO_HASH_LENGTH ||
-          memcmp(savedInfoHash.get(), infoHash, INFO_HASH_LENGTH) != 0) {
+      if (memcmp(savedInfoHash.data(), infoHash, INFO_HASH_LENGTH) != 0) {
         throw DL_ABORT_EX(
             fmt("info hash mismatch. expected: %s, actual: %s",
                 util::toHex(infoHash, INFO_HASH_LENGTH).c_str(),
-                util::toHex(savedInfoHash.get(), infoHashLength).c_str()));
+                util::toHex(savedInfoHash.data(), infoHashLength).c_str()));
       }
     }
 #endif // ENABLE_BITTORRENT
@@ -289,6 +291,10 @@ void DefaultBtProgressInfoFile::load()
     pieceLength = ntohl(pieceLength);
   }
 
+  if (pieceLength == 0) {
+    throw DL_ABORT_EX("piece length must not be 0");
+  }
+
   uint64_t totalLength;
   READ_CHECK(fp, &totalLength, sizeof(totalLength));
   if (version >= 1) {

Mile.Aria2.Library/DiskAdaptor.h

@@ -115,7 +115,7 @@ class DiskAdaptor : public BinaryStream {
   virtual void writeCache(const WrDiskCacheEntry* entry) = 0;
 
   // Force physical write of data from OS buffer cache.
-  virtual void flushOSBuffers() {};
+  virtual void flushOSBuffers(){};
 
   void setFileAllocationMethod(FileAllocationMethod method)
   {

Mile.Aria2.Library/DiskWriter.h

@@ -62,7 +62,7 @@ class DiskWriter : public BinaryStream {
   virtual void closeFile() = 0;
 
   /**
-   * Opens a file.  If the file doesnot exists, an exception may be
+   * Opens a file.  If the file does not exist, an exception may be
    * thrown.
    */
   virtual void openExistingFile(int64_t totalLength = 0) = 0;

Mile.Aria2.Library/DownloadEngineFactory.cc

@@ -137,9 +137,9 @@ std::unique_ptr<EventPoll> createEventPoll(Option* op)
   }
   else
 #endif // HAVE_POLL
-      if (pollMethod == V_SELECT) {
-    return make_unique<SelectEventPoll>();
-  }
+    if (pollMethod == V_SELECT) {
+      return make_unique<SelectEventPoll>();
+    }
   assert(0);
   return nullptr;
 }

Mile.Aria2.Library/Event.h

@@ -179,8 +179,7 @@ class ADNSEvent : public Event<SocketEntry> {
 };
 #else  // !ENABLE_ASYNC_DNS
 template <typename SocketEntry, typename EventPoll>
-class ADNSEvent : public Event<SocketEntry> {
-};
+class ADNSEvent : public Event<SocketEntry> {};
 #endif // !ENABLE_ASYNC_DNS
 
 template <typename CommandEvent, typename ADNSEvent> class SocketEntry {
@@ -362,8 +361,7 @@ template <typename EventPoll> class AsyncNameResolverEntry {
   }
 };
 #else  // !ENABLE_ASYNC_DNS
-template <typename EventPoll> class AsyncNameResolverEntry {
-};
+template <typename EventPoll> class AsyncNameResolverEntry {};
 #endif // !ENABLE_ASYNC_DNS
 
 } // namespace aria2