diff options
127 files changed, 455 insertions, 488 deletions
diff --git a/src/AbstractDiskWriter.cc b/src/AbstractDiskWriter.cc index b50a9b8e..e209018a 100644 --- a/src/AbstractDiskWriter.cc +++ b/src/AbstractDiskWriter.cc @@ -62,7 +62,7 @@ AbstractDiskWriter::~AbstractDiskWriter() closeFile(); } -void AbstractDiskWriter::openFile(uint64_t totalLength) +void AbstractDiskWriter::openFile(off_t totalLength) { try { openExistingFile(totalLength); @@ -83,7 +83,7 @@ void AbstractDiskWriter::closeFile() } } -void AbstractDiskWriter::openExistingFile(uint64_t totalLength) +void AbstractDiskWriter::openExistingFile(off_t totalLength) { int flags = O_BINARY; if(readOnly_) { @@ -197,7 +197,7 @@ ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offs return ret; } -void AbstractDiskWriter::truncate(uint64_t length) +void AbstractDiskWriter::truncate(off_t length) { if(fd_ == -1) { throw DL_ABORT_EX("File not opened."); @@ -223,7 +223,7 @@ void AbstractDiskWriter::truncate(uint64_t length) #endif } -void AbstractDiskWriter::allocate(off_t offset, uint64_t length) +void AbstractDiskWriter::allocate(off_t offset, off_t length) { #ifdef HAVE_SOME_FALLOCATE if(fd_ == -1) { @@ -272,7 +272,7 @@ void AbstractDiskWriter::allocate(off_t offset, uint64_t length) #endif // HAVE_SOME_FALLOCATE } -uint64_t AbstractDiskWriter::size() +off_t AbstractDiskWriter::size() { return File(filename_).size(); } diff --git a/src/AbstractDiskWriter.h b/src/AbstractDiskWriter.h index 297c3b26..9176dfef 100644 --- a/src/AbstractDiskWriter.h +++ b/src/AbstractDiskWriter.h @@ -57,22 +57,22 @@ public: AbstractDiskWriter(const std::string& filename); virtual ~AbstractDiskWriter(); - virtual void openFile(uint64_t totalLength = 0); + virtual void openFile(off_t totalLength = 0); virtual void closeFile(); - virtual void openExistingFile(uint64_t totalLength = 0); + virtual void openExistingFile(off_t totalLength = 0); virtual void writeData(const unsigned char* data, size_t len, off_t offset); virtual ssize_t readData(unsigned char* data, size_t len, off_t offset); - virtual void truncate(uint64_t length); + virtual void truncate(off_t length); // File must be opened before calling this function. - virtual void allocate(off_t offset, uint64_t length); + virtual void allocate(off_t offset, off_t length); - virtual uint64_t size(); + virtual off_t size(); virtual void enableReadOnly(); diff --git a/src/AbstractSingleDiskAdaptor.cc b/src/AbstractSingleDiskAdaptor.cc index ddf59059..95ef1606 100644 --- a/src/AbstractSingleDiskAdaptor.cc +++ b/src/AbstractSingleDiskAdaptor.cc @@ -85,12 +85,12 @@ bool AbstractSingleDiskAdaptor::fileExists() return File(getFilePath()).exists(); } -uint64_t AbstractSingleDiskAdaptor::size() +off_t AbstractSingleDiskAdaptor::size() { return File(getFilePath()).size(); } -void AbstractSingleDiskAdaptor::truncate(uint64_t length) +void AbstractSingleDiskAdaptor::truncate(off_t length) { diskWriter_->truncate(length); } @@ -139,7 +139,7 @@ void AbstractSingleDiskAdaptor::setDiskWriter diskWriter_ = diskWriter; } -void AbstractSingleDiskAdaptor::setTotalLength(const uint64_t& totalLength) +void AbstractSingleDiskAdaptor::setTotalLength(const off_t& totalLength) { totalLength_ = totalLength; } diff --git a/src/AbstractSingleDiskAdaptor.h b/src/AbstractSingleDiskAdaptor.h index 47563d95..a5f78aa1 100644 --- a/src/AbstractSingleDiskAdaptor.h +++ b/src/AbstractSingleDiskAdaptor.h @@ -45,7 +45,7 @@ class FileAllocationIterator; class AbstractSingleDiskAdaptor : public DiskAdaptor { private: SharedHandle<DiskWriter> diskWriter_; - uint64_t totalLength_; + off_t totalLength_; bool readOnly_; public: AbstractSingleDiskAdaptor(); @@ -67,9 +67,9 @@ public: virtual bool fileExists(); - virtual uint64_t size(); + virtual off_t size(); - virtual void truncate(uint64_t length); + virtual void truncate(off_t length); virtual SharedHandle<FileAllocationIterator> fileAllocationIterator(); @@ -92,9 +92,9 @@ public: return diskWriter_; } - void setTotalLength(const uint64_t& totalLength); + void setTotalLength(const off_t& totalLength); - uint64_t getTotalLength() const + off_t getTotalLength() const { return totalLength_; } diff --git a/src/AdaptiveFileAllocationIterator.cc b/src/AdaptiveFileAllocationIterator.cc index 8eeb5f99..a96c9f4a 100644 --- a/src/AdaptiveFileAllocationIterator.cc +++ b/src/AdaptiveFileAllocationIterator.cc @@ -45,7 +45,7 @@ namespace aria2 { AdaptiveFileAllocationIterator::AdaptiveFileAllocationIterator -(BinaryStream* stream, off_t offset, uint64_t totalLength) +(BinaryStream* stream, off_t offset, off_t totalLength) : stream_(stream), offset_(offset), totalLength_(totalLength) @@ -59,8 +59,8 @@ void AdaptiveFileAllocationIterator::allocateChunk() #ifdef HAVE_FALLOCATE try { A2_LOG_DEBUG("Testing file system supports fallocate."); - if(static_cast<uint64_t>(offset_) < totalLength_) { - off_t len = std::min(totalLength_-offset_, static_cast<uint64_t>(4096)); + if(offset_ < totalLength_) { + off_t len = std::min(totalLength_-offset_, static_cast<off_t>(4096)); stream_->allocate(offset_, len); offset_ += len; } @@ -89,7 +89,7 @@ void AdaptiveFileAllocationIterator::allocateChunk() bool AdaptiveFileAllocationIterator::finished() { if(!allocator_) { - return (uint64_t)offset_ == totalLength_; + return offset_ == totalLength_; } else { return allocator_->finished(); } @@ -104,7 +104,7 @@ off_t AdaptiveFileAllocationIterator::getCurrentLength() } } -uint64_t AdaptiveFileAllocationIterator::getTotalLength() +off_t AdaptiveFileAllocationIterator::getTotalLength() { return totalLength_; } diff --git a/src/AdaptiveFileAllocationIterator.h b/src/AdaptiveFileAllocationIterator.h index 8a3f2e3b..36217e6f 100644 --- a/src/AdaptiveFileAllocationIterator.h +++ b/src/AdaptiveFileAllocationIterator.h @@ -50,10 +50,10 @@ private: off_t offset_; - uint64_t totalLength_; + off_t totalLength_; public: AdaptiveFileAllocationIterator - (BinaryStream* stream, off_t offset, uint64_t totalLength); + (BinaryStream* stream, off_t offset, off_t totalLength); virtual ~AdaptiveFileAllocationIterator(); @@ -63,7 +63,7 @@ public: virtual off_t getCurrentLength(); - virtual uint64_t getTotalLength(); + virtual off_t getTotalLength(); }; } // namespace aria2 diff --git a/src/BinaryStream.h b/src/BinaryStream.h index 4dee179b..bb7853a5 100644 --- a/src/BinaryStream.h +++ b/src/BinaryStream.h @@ -53,11 +53,11 @@ public: // Truncates a file to given length. The default implementation does // nothing. - virtual void truncate(uint64_t length) {} + virtual void truncate(off_t length) {} // Allocates given length bytes of disk space from given offset. The // default implementation does nothing. - virtual void allocate(off_t offset, uint64_t length) {} + virtual void allocate(off_t offset, off_t length) {} }; typedef SharedHandle<BinaryStream> BinaryStreamHandle; diff --git a/src/BitfieldMan.cc b/src/BitfieldMan.cc index 2d50dab6..19a6d0c9 100644 --- a/src/BitfieldMan.cc +++ b/src/BitfieldMan.cc @@ -44,7 +44,7 @@ using namespace aria2::expr; namespace aria2 { -BitfieldMan::BitfieldMan(size_t blockLength, uint64_t totalLength) +BitfieldMan::BitfieldMan(size_t blockLength, off_t totalLength) :blockLength_(blockLength), totalLength_(totalLength), bitfieldLength_(0), @@ -275,8 +275,8 @@ bool getSparseMissingUnusedIndex } else { if((!bitfield::test(useBitfield, blocks, maxRange.startIndex-1) && bitfield::test(bitfield, blocks, maxRange.startIndex-1)) || - ((uint64_t)(maxRange.endIndex-maxRange.startIndex)*blockLength_ - >= minSplitSize)) { + (static_cast<uint64_t>(maxRange.endIndex-maxRange.startIndex)* + blockLength_ >= minSplitSize)) { index = maxRange.startIndex; return true; } else { @@ -663,7 +663,7 @@ void BitfieldMan::ensureFilterBitfield() } } -void BitfieldMan::addFilter(uint64_t offset, uint64_t length) { +void BitfieldMan::addFilter(off_t offset, off_t length) { ensureFilterBitfield(); if(length > 0) { size_t startBlock = offset/blockLength_; @@ -675,7 +675,7 @@ void BitfieldMan::addFilter(uint64_t offset, uint64_t length) { updateCache(); } -void BitfieldMan::removeFilter(uint64_t offset, uint64_t length) { +void BitfieldMan::removeFilter(off_t offset, off_t length) { ensureFilterBitfield(); if(length > 0) { size_t startBlock = offset/blockLength_; @@ -687,7 +687,7 @@ void BitfieldMan::removeFilter(uint64_t offset, uint64_t length) { updateCache(); } -void BitfieldMan::addNotFilter(uint64_t offset, uint64_t length) +void BitfieldMan::addNotFilter(off_t offset, off_t length) { ensureFilterBitfield(); if(length > 0 && blocks_ > 0) { @@ -726,7 +726,7 @@ void BitfieldMan::clearFilter() { updateCache(); } -uint64_t BitfieldMan::getFilteredTotalLengthNow() const { +off_t BitfieldMan::getFilteredTotalLengthNow() const { if(!filterBitfield_) { return 0; } @@ -735,13 +735,13 @@ uint64_t BitfieldMan::getFilteredTotalLengthNow() const { return 0; } if(bitfield::test(filterBitfield_, blocks_, blocks_-1)) { - return ((uint64_t)filteredBlocks-1)*blockLength_+getLastBlockLength(); + return ((off_t)filteredBlocks-1)*blockLength_+getLastBlockLength(); } else { - return ((uint64_t)filteredBlocks)*blockLength_; + return ((off_t)filteredBlocks)*blockLength_; } } -uint64_t BitfieldMan::getCompletedLength(bool useFilter) const { +off_t BitfieldMan::getCompletedLength(bool useFilter) const { unsigned char* temp; if(useFilter) { temp = new unsigned char[bitfieldLength_]; @@ -755,14 +755,15 @@ uint64_t BitfieldMan::getCompletedLength(bool useFilter) const { temp = bitfield_; } size_t completedBlocks = bitfield::countSetBit(temp, blocks_); - uint64_t completedLength = 0; + off_t completedLength = 0; if(completedBlocks == 0) { completedLength = 0; } else { if(bitfield::test(temp, blocks_, blocks_-1)) { - completedLength = ((uint64_t)completedBlocks-1)*blockLength_+getLastBlockLength(); + completedLength = + ((off_t)completedBlocks-1)*blockLength_+getLastBlockLength(); } else { - completedLength = ((uint64_t)completedBlocks)*blockLength_; + completedLength = ((off_t)completedBlocks)*blockLength_; } } if(useFilter) { @@ -771,11 +772,11 @@ uint64_t BitfieldMan::getCompletedLength(bool useFilter) const { return completedLength; } -uint64_t BitfieldMan::getCompletedLengthNow() const { +off_t BitfieldMan::getCompletedLengthNow() const { return getCompletedLength(false); } -uint64_t BitfieldMan::getFilteredCompletedLengthNow() const { +off_t BitfieldMan::getFilteredCompletedLengthNow() const { return getCompletedLength(true); } @@ -814,7 +815,7 @@ void BitfieldMan::setBitRange(size_t startIndex, size_t endIndex) updateCache(); } -bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const +bool BitfieldMan::isBitSetOffsetRange(off_t offset, off_t length) const { if(length <= 0) { return false; @@ -835,11 +836,11 @@ bool BitfieldMan::isBitSetOffsetRange(uint64_t offset, uint64_t length) const return true; } -uint64_t BitfieldMan::getOffsetCompletedLength -(uint64_t offset, - uint64_t length) const +off_t BitfieldMan::getOffsetCompletedLength +(off_t offset, + off_t length) const { - uint64_t res = 0; + off_t res = 0; if(length == 0 || totalLength_ <= offset) { return 0; } @@ -868,12 +869,12 @@ uint64_t BitfieldMan::getOffsetCompletedLength return res; } -uint64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const +off_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const { if(startingIndex < 0 || blocks_ <= startingIndex) { return 0; } - uint64_t length = 0; + off_t length = 0; 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 d99235bf..b2ea7da4 100644 --- a/src/BitfieldMan.h +++ b/src/BitfieldMan.h @@ -46,7 +46,7 @@ namespace aria2 { class BitfieldMan { private: size_t blockLength_; - uint64_t totalLength_; + off_t totalLength_; size_t bitfieldLength_; size_t blocks_; bool filterEnabled_; @@ -57,9 +57,9 @@ private: // for caching size_t cachedNumMissingBlock_; size_t cachedNumFilteredBlock_; - uint64_t cachedCompletedLength_; - uint64_t cachedFilteredCompletedLength_; - uint64_t cachedFilteredTotalLength_; + off_t cachedCompletedLength_; + off_t cachedFilteredCompletedLength_; + off_t cachedFilteredTotalLength_; bool setBitInternal(unsigned char* bitfield, size_t index, bool on); bool setFilterBit(size_t index); @@ -67,7 +67,7 @@ private: size_t getStartIndex(size_t index) const; size_t getEndIndex(size_t index) const; - uint64_t getCompletedLength(bool useFilter) const; + off_t getCompletedLength(bool useFilter) const; // If filterBitfield_ is 0, allocate bitfieldLength_ bytes to it and // set 0 to all bytes. @@ -84,7 +84,7 @@ public: bool operator==(const Range& range) const; }; public: - BitfieldMan(size_t blockLength, uint64_t totalLength); + BitfieldMan(size_t blockLength, off_t totalLength); BitfieldMan(const BitfieldMan& bitfieldMan); ~BitfieldMan(); @@ -99,7 +99,7 @@ public: size_t getBlockLength(size_t index) const; - uint64_t getTotalLength() const { return totalLength_; } + off_t getTotalLength() const { return totalLength_; } // Returns true iff there is a bit index which is set in bitfield_, // but not set in this object. @@ -238,10 +238,10 @@ public: void clearAllUseBit(); void setAllUseBit(); - void addFilter(uint64_t offset, uint64_t length); - void removeFilter(uint64_t offset, uint64_t length); + void addFilter(off_t offset, off_t length); + void removeFilter(off_t offset, off_t length); // Add filter not in the range of [offset, offset+length) bytes - void addNotFilter(uint64_t offset, uint64_t length); + void addNotFilter(off_t offset, off_t length); // Clears filter and disables filter void clearFilter(); @@ -254,29 +254,29 @@ public: } // affected by filter - uint64_t getFilteredTotalLength() const + off_t getFilteredTotalLength() const { return cachedFilteredTotalLength_; } // affected by filter - uint64_t getFilteredTotalLengthNow() const; + off_t getFilteredTotalLengthNow() const; - uint64_t getCompletedLength() const + off_t getCompletedLength() const { return cachedCompletedLength_; } - uint64_t getCompletedLengthNow() const; + off_t getCompletedLengthNow() const; // affected by filter - uint64_t getFilteredCompletedLength() const + off_t getFilteredCompletedLength() const { return cachedFilteredCompletedLength_; } // affected by filter - uint64_t getFilteredCompletedLengthNow() const; + off_t getFilteredCompletedLengthNow() const; void updateCache(); @@ -286,13 +286,13 @@ public: void setBitRange(size_t startIndex, size_t endIndex); - bool isBitSetOffsetRange(uint64_t offset, uint64_t length) const; + bool isBitSetOffsetRange(off_t offset, off_t length) const; // Returns completed length in bytes in range [offset, // offset+length). This function will not affected by filter. - uint64_t getOffsetCompletedLength(uint64_t offset, uint64_t length) const; + off_t getOffsetCompletedLength(off_t offset, off_t length) const; - uint64_t getMissingUnusedLength(size_t startingIndex) const; + off_t getMissingUnusedLength(size_t startingIndex) const; const unsigned char* getFilterBitfield() const { diff --git a/src/BtRuntime.h b/src/BtRuntime.h index 7ceeac65..90859f41 100644 --- a/src/BtRuntime.h +++ b/src/BtRuntime.h @@ -42,7 +42,7 @@ namespace aria2 { class BtRuntime { private: - uint64_t uploadLengthAtStartup_; + off_t uploadLengthAtStartup_; bool halt_; unsigned int connections_; bool ready_; @@ -60,11 +60,11 @@ public: ~BtRuntime(); - uint64_t getUploadLengthAtStartup() const { + off_t getUploadLengthAtStartup() const { return uploadLengthAtStartup_; } - void setUploadLengthAtStartup(uint64_t length) { + void setUploadLengthAtStartup(off_t length) { uploadLengthAtStartup_ = length; } diff --git a/src/ByteArrayDiskWriter.cc b/src/ByteArrayDiskWriter.cc index bb81dcd1..e83a573a 100644 --- a/src/ByteArrayDiskWriter.cc +++ b/src/ByteArrayDiskWriter.cc @@ -50,16 +50,16 @@ void ByteArrayDiskWriter::clear() buf_.str(A2STR::NIL); } -void ByteArrayDiskWriter::initAndOpenFile(uint64_t totalLength) +void ByteArrayDiskWriter::initAndOpenFile(off_t totalLength) { clear(); } -void ByteArrayDiskWriter::openFile(uint64_t totalLength) {} +void ByteArrayDiskWriter::openFile(off_t totalLength) {} void ByteArrayDiskWriter::closeFile() {} -void ByteArrayDiskWriter::openExistingFile(uint64_t totalLength) +void ByteArrayDiskWriter::openExistingFile(off_t totalLength) { openFile(); } @@ -70,10 +70,10 @@ void ByteArrayDiskWriter::writeData(const unsigned char* data, size_t dataLength throw DL_ABORT_EX(fmt("Maximum length(%lu) exceeded.", static_cast<unsigned long>(maxLength_))); } - uint64_t length = size(); - if(length < (uint64_t)position) { + off_t length = size(); + if(length < position) { buf_.seekp(length, std::ios::beg); - for(uint64_t i = length; i < (uint64_t)position; ++i) { + for(off_t i = length; i < position; ++i) { buf_.put('\0'); } } else { @@ -90,7 +90,7 @@ ssize_t ByteArrayDiskWriter::readData(unsigned char* data, size_t len, off_t pos return buf_.gcount(); } -uint64_t ByteArrayDiskWriter::size() +off_t ByteArrayDiskWriter::size() { buf_.seekg(0, std::ios::end); buf_.clear(); diff --git a/src/ByteArrayDiskWriter.h b/src/ByteArrayDiskWriter.h index c51d8200..6899d63f 100644 --- a/src/ByteArrayDiskWriter.h +++ b/src/ByteArrayDiskWriter.h @@ -49,18 +49,18 @@ public: ByteArrayDiskWriter(size_t maxLength = 5*1024*1024); virtual ~ByteArrayDiskWriter(); - virtual void initAndOpenFile(uint64_t totalLength = 0); + virtual void initAndOpenFile(off_t totalLength = 0); - virtual void openFile(uint64_t totalLength = 0); + virtual void openFile(off_t totalLength = 0); virtual void closeFile(); - virtual void openExistingFile(uint64_t totalLength = 0); + virtual void openExistingFile(off_t totalLength = 0); virtual void writeData(const unsigned char* data, size_t len, off_t position); virtual ssize_t readData(unsigned char* data, size_t len, off_t position); - virtual uint64_t size(); + virtual off_t size(); void setString(const std::string& s); diff --git a/src/CheckIntegrityEntry.cc b/src/CheckIntegrityEntry.cc index eda0b2ab..c635a540 100644 --- a/src/CheckIntegrityEntry.cc +++ b/src/CheckIntegrityEntry.cc @@ -56,7 +56,7 @@ void CheckIntegrityEntry::validateChunk() validator_->validateChunk(); } -uint64_t CheckIntegrityEntry::getTotalLength() +off_t CheckIntegrityEntry::getTotalLength() { if(!validator_) { return 0; diff --git a/src/CheckIntegrityEntry.h b/src/CheckIntegrityEntry.h index a2fb7da7..5f5dcd58 100644 --- a/src/CheckIntegrityEntry.h +++ b/src/CheckIntegrityEntry.h @@ -61,7 +61,7 @@ public: virtual ~CheckIntegrityEntry(); - virtual uint64_t getTotalLength(); + virtual off_t getTotalLength(); virtual off_t getCurrentLength(); diff --git a/src/ChunkChecksum.cc b/src/ChunkChecksum.cc index 4d120afa..2a561819 100644 --- a/src/ChunkChecksum.cc +++ b/src/ChunkChecksum.cc @@ -56,9 +56,9 @@ bool ChunkChecksum::validateChunk return !digest.empty() && actualDigest == digest; } -uint64_t ChunkChecksum::getEstimatedDataLength() const +off_t ChunkChecksum::getEstimatedDataLength() const { - return static_cast<uint64_t>(pieceLength_)*pieceHashes_.size(); + return static_cast<off_t>(pieceLength_)*pieceHashes_.size(); } size_t ChunkChecksum::countPieceHash() const diff --git a/src/ChunkChecksum.h b/src/ChunkChecksum.h index c28364d0..126bd82f 100644 --- a/src/ChunkChecksum.h +++ b/src/ChunkChecksum.h @@ -60,7 +60,7 @@ public: bool validateChunk(const std::string& actualDigest, size_t index) const; - uint64_t getEstimatedDataLength() const; + off_t getEstimatedDataLength() const; size_t countPieceHash() const; diff --git a/src/ChunkedDecodingStreamFilter.cc b/src/ChunkedDecodingStreamFilter.cc index b1f98bdf..87140e9e 100644 --- a/src/ChunkedDecodingStreamFilter.cc +++ b/src/ChunkedDecodingStreamFilter.cc @@ -96,8 +96,11 @@ bool ChunkedDecodingStreamFilter::readChunkSize if(extPos == std::string::npos || crlfPos < extPos) { extPos = crlfPos; } - chunkSize_ = util::parseULLInt + chunkSize_ = util::parseLLInt (std::string(buf_.begin(), buf_.begin()+extPos), 16); + if(chunkSize_ < 0) { + throw DL_ABORT_EX("Chunk size must be positive"); + } assert(crlfPos+2 > pbufSize); inbufOffset += crlfPos+2-pbufSize; buf_.clear(); @@ -155,8 +158,8 @@ bool ChunkedDecodingStreamFilter::readData const SharedHandle<BinaryStream>& out, const SharedHandle<Segment>& segment) { - uint64_t readlen = - std::min(chunkSize_, static_cast<uint64_t>(inlen-inbufOffset)); + off_t readlen = + std::min(chunkSize_, static_cast<off_t>(inlen-inbufOffset)); outlen += getDelegate()->transform(out, segment, inbuf+inbufOffset, readlen); chunkSize_ -= readlen; inbufOffset += readlen; diff --git a/src/ChunkedDecodingStreamFilter.h b/src/ChunkedDecodingStreamFilter.h index 6909e33e..902d3fb5 100644 --- a/src/ChunkedDecodingStreamFilter.h +++ b/src/ChunkedDecodingStreamFilter.h @@ -59,7 +59,7 @@ private: std::string buf_; - uint64_t chunkSize_; + off_t chunkSize_; size_t bytesProcessed_; diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc index 23be204c..049f3bcd 100644 --- a/src/DefaultBtAnnounce.cc +++ b/src/DefaultBtAnnounce.cc @@ -142,7 +142,7 @@ std::string DefaultBtAnnounce::getAnnounceUrl() { numWant = 0; } TransferStat stat = peerStorage_->calculateStat(); - uint64_t left = + off_t left = pieceStorage_->getTotalLength()-pieceStorage_->getCompletedLength(); // Use last 8 bytes of peer ID as a key const size_t keyLen = 8; diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc index 84627d60..9fa32b1c 100644 --- a/src/DefaultBtProgressInfoFile.cc +++ b/src/DefaultBtProgressInfoFile.cc @@ -275,7 +275,7 @@ void DefaultBtProgressInfoFile::load() if(version >= 1) { totalLength = ntoh64(totalLength); } - if(totalLength != dctx_->getTotalLength()) { + if(totalLength != static_cast<uint64_t>(dctx_->getTotalLength())) { throw DL_ABORT_EX (fmt("total length mismatch. expected: %lld, actual: %lld", static_cast<long long int>(dctx_->getTotalLength()), diff --git a/src/DefaultDiskWriter.cc b/src/DefaultDiskWriter.cc index 7b475d8f..afa02072 100644 --- a/src/DefaultDiskWriter.cc +++ b/src/DefaultDiskWriter.cc @@ -41,7 +41,7 @@ DefaultDiskWriter::DefaultDiskWriter(const std::string& filename): DefaultDiskWriter::~DefaultDiskWriter() {} -void DefaultDiskWriter::initAndOpenFile(uint64_t totalLength) +void DefaultDiskWriter::initAndOpenFile(off_t totalLength) { createFile(); } diff --git a/src/DefaultDiskWriter.h b/src/DefaultDiskWriter.h index 339e0edd..2bc5a488 100644 --- a/src/DefaultDiskWriter.h +++ b/src/DefaultDiskWriter.h @@ -45,7 +45,7 @@ public: virtual ~DefaultDiskWriter(); - virtual void initAndOpenFile(uint64_t totalLength = 0); + virtual void initAndOpenFile(off_t totalLength = 0); }; typedef SharedHandle<DefaultDiskWriter> DefaultDiskWriterHandle; diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc index af68de2a..dec61d6f 100644 --- a/src/DefaultPeerStorage.cc +++ b/src/DefaultPeerStorage.cc @@ -60,8 +60,8 @@ const size_t MAX_PEER_LIST_UPDATE = 100; DefaultPeerStorage::DefaultPeerStorage() : maxPeerListSize_(MAX_PEER_LIST_SIZE), - removedPeerSessionDownloadLength_(0), - removedPeerSessionUploadLength_(0), + removedPeerSessionDownloadLength_(0LL), + removedPeerSessionUploadLength_(0LL), seederStateChoke_(new BtSeederStateChoke()), leecherStateChoke_(new BtLeecherStateChoke()), lastTransferStatMapUpdated_(0) diff --git a/src/DefaultPeerStorage.h b/src/DefaultPeerStorage.h index 5411eac7..8722e63b 100644 --- a/src/DefaultPeerStorage.h +++ b/src/DefaultPeerStorage.h @@ -56,8 +56,8 @@ private: size_t maxPeerListSize_; std::deque<SharedHandle<Peer> > peers_; std::deque<SharedHandle<Peer> > droppedPeers_; - uint64_t removedPeerSessionDownloadLength_; - uint64_t removedPeerSessionUploadLength_; + int64_t removedPeerSessionDownloadLength_; + int64_t removedPeerSessionUploadLength_; BtSeederStateChoke* seederStateChoke_; BtLeecherStateChoke* leecherStateChoke_; diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc index 7268bcf8..0b32761b 100644 --- a/src/DefaultPieceStorage.cc +++ b/src/DefaultPieceStorage.cc @@ -518,28 +518,28 @@ bool DefaultPieceStorage::isPieceUsed(size_t index) return bitfieldMan_->isUseBitSet(index); } -uint64_t DefaultPieceStorage::getTotalLength() +off_t DefaultPieceStorage::getTotalLength() { return bitfieldMan_->getTotalLength(); } -uint64_t DefaultPieceStorage::getFilteredTotalLength() +off_t DefaultPieceStorage::getFilteredTotalLength() { return bitfieldMan_->getFilteredTotalLength(); } -uint64_t DefaultPieceStorage::getCompletedLength() +off_t DefaultPieceStorage::getCompletedLength() { - uint64_t completedLength = + off_t completedLength = bitfieldMan_->getCompletedLength()+getInFlightPieceCompletedLength(); - uint64_t totalLength = getTotalLength(); + off_t totalLength = getTotalLength(); if(completedLength > totalLength) { completedLength = totalLength; } return completedLength; } -uint64_t DefaultPieceStorage::getFilteredCompletedLength() +off_t DefaultPieceStorage::getFilteredCompletedLength() { return bitfieldMan_->getFilteredCompletedLength()+ getInFlightPieceCompletedLength(); @@ -712,7 +712,7 @@ void DefaultPieceStorage::markAllPiecesDone() bitfieldMan_->setAllBit(); } -void DefaultPieceStorage::markPiecesDone(uint64_t length) +void DefaultPieceStorage::markPiecesDone(off_t length) { if(length == bitfieldMan_->getTotalLength()) { bitfieldMan_->setAllBit(); diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h index 30f0ecf9..21b57fcb 100644 --- a/src/DefaultPieceStorage.h +++ b/src/DefaultPieceStorage.h @@ -187,13 +187,13 @@ public: virtual bool isPieceUsed(size_t index); - virtual uint64_t getTotalLength(); + virtual off_t getTotalLength(); - virtual uint64_t getFilteredTotalLength(); + virtual off_t getFilteredTotalLength(); - virtual uint64_t getCompletedLength(); + virtual off_t getCompletedLength(); - virtual uint64_t getFilteredCompletedLength(); + virtual off_t getFilteredCompletedLength(); virtual void initStorage(); @@ -246,7 +246,7 @@ public: virtual void markAllPiecesDone(); - virtual void markPiecesDone(uint64_t length); + virtual void markPiecesDone(off_t length); virtual void markPieceMissing(size_t index); diff --git a/src/DiskAdaptor.h b/src/DiskAdaptor.h index d7c06b90..6a94def0 100644 --- a/src/DiskAdaptor.h +++ b/src/DiskAdaptor.h @@ -66,7 +66,7 @@ public: virtual bool fileExists() = 0; - virtual uint64_t size() = 0; + virtual off_t size() = 0; template<typename InputIterator> void setFileEntries(InputIterator first, InputIterator last) diff --git a/src/DiskWriter.h b/src/DiskWriter.h index 427380d4..d7c2c8b4 100644 --- a/src/DiskWriter.h +++ b/src/DiskWriter.h @@ -51,9 +51,9 @@ public: /** * Opens file. If the file exists, then it is truncated to 0 length. */ - virtual void initAndOpenFile(uint64_t totalLength = 0) = 0; + virtual void initAndOpenFile(off_t totalLength = 0) = 0; - virtual void openFile(uint64_t totalLength = 0) = 0; + virtual void openFile(off_t totalLength = 0) = 0; /** * Closes this output stream. @@ -65,10 +65,10 @@ public: * Opens a file. If the file doesnot exists, an exception may be * thrown. */ - virtual void openExistingFile(uint64_t totalLength = 0) = 0; + virtual void openExistingFile(off_t totalLength = 0) = 0; // Returns file length - virtual uint64_t size() = 0; + virtual off_t size() = 0; // Enables read-only mode. After this call, openExistingFile() opens // file in read-only mode. This is an optional functionality. The diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc index 37da0cbb..2862d3d3 100644 --- a/src/DownloadCommand.cc +++ b/src/DownloadCommand.cc @@ -146,8 +146,8 @@ bool DownloadCommand::executeInternal() { size_t bufSize; if(sinkFilterOnly_) { if(segment->getLength() > 0) { - if(static_cast<uint64_t>(segment->getPosition()+segment->getLength()) <= - static_cast<uint64_t>(getFileEntry()->getLastOffset())) { + if(static_cast<off_t>(segment->getPosition()+segment->getLength()) <= + getFileEntry()->getLastOffset()) { bufSize = std::min(segment->getLength()-segment->getWrittenLength(), getSocketRecvBuffer()->getBufferLength()); } else { diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc index 7f90627c..4a9e8e7a 100644 --- a/src/DownloadContext.cc +++ b/src/DownloadContext.cc @@ -57,7 +57,7 @@ DownloadContext::DownloadContext(): metalinkServerContacted_(false) {} DownloadContext::DownloadContext(size_t pieceLength, - uint64_t totalLength, + off_t totalLength, const std::string& path): pieceLength_(pieceLength), checksumVerified_(false), @@ -98,9 +98,7 @@ SharedHandle<FileEntry> DownloadContext::findFileEntryByOffset(off_t offset) const { if(fileEntries_.empty() || - (offset > 0 && - fileEntries_.back()->getOffset()+fileEntries_.back()->getLength() <= - static_cast<uint64_t>(offset))){ + (offset > 0 && fileEntries_.back()->getLastOffset() <= offset)) { return SharedHandle<FileEntry>(); } @@ -200,7 +198,7 @@ size_t DownloadContext::getNumPieces() const } } -uint64_t DownloadContext::getTotalLength() const +off_t DownloadContext::getTotalLength() const { if(fileEntries_.empty()) { return 0; diff --git a/src/DownloadContext.h b/src/DownloadContext.h index 46c69e69..7eee1f84 100644 --- a/src/DownloadContext.h +++ b/src/DownloadContext.h @@ -93,7 +93,7 @@ public: // Convenient constructor that creates single file download. path // should be escaped with util::escapePath(...). DownloadContext(size_t pieceLength, - uint64_t totalLength, + off_t totalLength, const std::string& path = A2STR::NIL); ~DownloadContext(); @@ -114,7 +114,7 @@ public: pieceHashes_.assign(first, last); } - uint64_t getTotalLength() const; + off_t getTotalLength() const; bool knowsTotalLength() const { return knowsTotalLength_; } diff --git a/src/DownloadResult.h b/src/DownloadResult.h index 6c80ad29..5c920510 100644 --- a/src/DownloadResult.h +++ b/src/DownloadResult.h @@ -79,11 +79,11 @@ struct DownloadResult SharedHandle<MetadataInfo> metadataInfo; - uint64_t totalLength; + off_t totalLength; - uint64_t completedLength; + off_t completedLength; - uint64_t uploadLength; + off_t uploadLength; std::string bitfield; diff --git a/src/FallocFileAllocationIterator.cc b/src/FallocFileAllocationIterator.cc index 3e4e24d1..f337bf7a 100644 --- a/src/FallocFileAllocationIterator.cc +++ b/src/FallocFileAllocationIterator.cc @@ -38,12 +38,12 @@ namespace aria2 { FallocFileAllocationIterator::FallocFileAllocationIterator -(BinaryStream* stream, off_t offset, uint64_t totalLength): +(BinaryStream* stream, off_t offset, off_t totalLength): stream_(stream), offset_(offset), totalLength_(totalLength) {} void FallocFileAllocationIterator::allocateChunk() { - if(static_cast<uint64_t>(offset_) < totalLength_) { + if(offset_ < totalLength_) { stream_->allocate(offset_, totalLength_-offset_); offset_ = totalLength_; } else { @@ -54,7 +54,7 @@ void FallocFileAllocationIterator::allocateChunk() bool FallocFileAllocationIterator::finished() { - return static_cast<uint64_t>(offset_) == totalLength_; + return offset_ == totalLength_; } off_t FallocFileAllocationIterator::getCurrentLength() @@ -62,7 +62,7 @@ off_t FallocFileAllocationIterator::getCurrentLength() return offset_; } -uint64_t FallocFileAllocationIterator::getTotalLength() +off_t FallocFileAllocationIterator::getTotalLength() { return totalLength_; } diff --git a/src/FallocFileAllocationIterator.h b/src/FallocFileAllocationIterator.h index e7e6fbc1..d43db3a6 100644 --- a/src/FallocFileAllocationIterator.h +++ b/src/FallocFileAllocationIterator.h @@ -45,10 +45,10 @@ class FallocFileAllocationIterator:public FileAllocationIterator { private: BinaryStream* stream_; off_t offset_; - uint64_t totalLength_; + off_t totalLength_; public: FallocFileAllocationIterator(BinaryStream* stream, off_t offset, - uint64_t totalLength); + off_t totalLength); virtual void allocateChunk(); @@ -56,7 +56,7 @@ public: virtual off_t getCurrentLength(); - virtual uint64_t getTotalLength(); + virtual off_t getTotalLength(); }; } // namespace aria2 diff --git a/src/File.cc b/src/File.cc index f47b78c7..87b95486 100644 --- a/src/File.cc +++ b/src/File.cc @@ -103,7 +103,7 @@ bool File::remove() { } } -uint64_t File::size() { +off_t File::size() { a2_struct_stat fstat; if(fillStat(fstat) < 0) { return 0; @@ -94,7 +94,7 @@ public: */ bool mkdirs(); - uint64_t size(); + off_t size(); mode_t mode(); diff --git a/src/FileAllocationEntry.cc b/src/FileAllocationEntry.cc index 2d96f756..ff4e0f29 100644 --- a/src/FileAllocationEntry.cc +++ b/src/FileAllocationEntry.cc @@ -54,7 +54,7 @@ off_t FileAllocationEntry::getCurrentLength() return fileAllocationIterator_->getCurrentLength(); } -uint64_t FileAllocationEntry::getTotalLength() +off_t FileAllocationEntry::getTotalLength() { return fileAllocationIterator_->getTotalLength(); } diff --git a/src/FileAllocationEntry.h b/src/FileAllocationEntry.h index 509a8a04..4d47123f 100644 --- a/src/FileAllocationEntry.h +++ b/src/FileAllocationEntry.h @@ -56,7 +56,7 @@ public: virtual off_t getCurrentLength(); - virtual uint64_t getTotalLength(); + virtual off_t getTotalLength(); virtual bool finished(); diff --git a/src/FileAllocationIterator.h b/src/FileAllocationIterator.h index a57d4277..57f4e294 100644 --- a/src/FileAllocationIterator.h +++ b/src/FileAllocationIterator.h @@ -52,7 +52,7 @@ public: virtual off_t getCurrentLength() = 0; - virtual uint64_t getTotalLength() = 0; + virtual off_t getTotalLength() = 0; }; } // namespace aria2 diff --git a/src/FileEntry.cc b/src/FileEntry.cc index 23721e7a..1af951da 100644 --- a/src/FileEntry.cc +++ b/src/FileEntry.cc @@ -53,7 +53,7 @@ namespace aria2 { FileEntry::FileEntry (const std::string& path, - uint64_t length, + off_t length, off_t offset, const std::vector<std::string>& uris) : path_(path), diff --git a/src/FileEntry.h b/src/FileEntry.h index c77ca47a..1f3385ba 100644 --- a/src/FileEntry.h +++ b/src/FileEntry.h @@ -61,7 +61,7 @@ private: std::string path_; std::deque<std::string> uris_; std::deque<std::string> spentUris_; - uint64_t length_; + off_t length_; off_t offset_; bool requested_; std::deque<SharedHandle<Request> > requestPool_; @@ -79,7 +79,7 @@ private: public: FileEntry(); - FileEntry(const std::string& path, uint64_t length, off_t offset, + FileEntry(const std::string& path, off_t length, off_t offset, const std::vector<std::string>& uris = std::vector<std::string>()); ~FileEntry(); @@ -94,9 +94,9 @@ public: void setPath(const std::string& path); - uint64_t getLength() const { return length_; } + off_t getLength() const { return length_; } - void setLength(uint64_t length) { length_ = length; } + void setLength(off_t length) { length_ = length; } off_t getOffset() const { return offset_; } diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc index 90e430c4..4436d7c0 100644 --- a/src/FtpConnection.cc +++ b/src/FtpConnection.cc @@ -400,14 +400,17 @@ unsigned int FtpConnection::receiveResponse() # define ULONGLONG_SCANF "%Lu" #endif // __MINGW32__ -unsigned int FtpConnection::receiveSizeResponse(uint64_t& size) +unsigned int FtpConnection::receiveSizeResponse(off_t& size) { std::pair<unsigned int, std::string> response; if(bulkReceiveResponse(response)) { if(response.first == 213) { std::pair<Sip, Sip> rp; util::divide(rp, response.second.begin(), response.second.end(), ' '); - size = util::parseULLInt(std::string(rp.second.first, rp.second.second)); + size = util::parseLLInt(std::string(rp.second.first, rp.second.second)); + if(size < 0) { + throw DL_ABORT_EX("Size must be positive"); + } } return response.first; } else { diff --git a/src/FtpConnection.h b/src/FtpConnection.h index 6a33a33b..1abb9683 100644 --- a/src/FtpConnection.h +++ b/src/FtpConnection.h @@ -102,7 +102,7 @@ public: bool sendRetr(); unsigned int receiveResponse(); - unsigned int receiveSizeResponse(uint64_t& size); + unsigned int receiveSizeResponse(off_t& size); // Returns status code of MDTM reply. If the status code is 213, parses // time-val and store it in time. // If a code other than 213 is returned, time is not touched. diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc index 7033715d..6412c7ac 100644 --- a/src/FtpNegotiationCommand.cc +++ b/src/FtpNegotiationCommand.cc @@ -364,7 +364,7 @@ bool FtpNegotiationCommand::sendSize() { return false; } -bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) +bool FtpNegotiationCommand::onFileSizeDetermined(off_t totalLength) { getFileEntry()->setLength(totalLength); if(getFileEntry()->getPath().empty()) { @@ -464,7 +464,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength) } bool FtpNegotiationCommand::recvSize() { - uint64_t size = 0; + off_t size = 0; unsigned int status = ftp_->receiveSizeResponse(size); if(status == 0) { return false; diff --git a/src/FtpNegotiationCommand.h b/src/FtpNegotiationCommand.h index b155595b..a22e6853 100644 --- a/src/FtpNegotiationCommand.h +++ b/src/FtpNegotiationCommand.h @@ -137,7 +137,7 @@ private: void poolConnection() const; - bool onFileSizeDetermined(uint64_t totalLength); + bool onFileSizeDetermined(off_t totalLength); void onDryRunFileFound(); diff --git a/src/HttpHeader.cc b/src/HttpHeader.cc index ad926cc0..ff6aa8d9 100644 --- a/src/HttpHeader.cc +++ b/src/HttpHeader.cc @@ -108,16 +108,23 @@ HttpHeader::equalRange(const std::string& name) const return table_.equal_range(name); } -unsigned int HttpHeader::findAsUInt(const std::string& name) const { - return findAsULLInt(name); +int32_t HttpHeader::findAsInt(const std::string& name) const +{ + const std::string& value = find(name); + if(value.empty()) { + return 0; + } else { + return util::parseInt(value); + } } -uint64_t HttpHeader::findAsULLInt(const std::string& name) const { +int64_t HttpHeader::findAsLLInt(const std::string& name) const +{ const std::string& value = find(name); if(value.empty()) { return 0; } else { - return util::parseULLInt(value); + return util::parseLLInt(value); } } @@ -129,7 +136,10 @@ RangeHandle HttpHeader::getRange() const if(clenStr.empty()) { return SharedHandle<Range>(new Range()); } else { - uint64_t contentLength = util::parseULLInt(clenStr); + off_t contentLength = util::parseLLInt(clenStr); + if(contentLength < 0) { + throw DL_ABORT_EX("Content-Length must be positive"); + } if(contentLength == 0) { return SharedHandle<Range>(new Range()); } else { @@ -168,8 +178,11 @@ RangeHandle HttpHeader::getRange() const } off_t startByte = util::parseLLInt(std::string(byteRangeSpec, minus)); off_t endByte = util::parseLLInt(std::string(minus+1, slash)); - uint64_t entityLength = - util::parseULLInt(std::string(slash+1, rangeStr.end())); + off_t entityLength = + util::parseLLInt(std::string(slash+1, rangeStr.end())); + if(startByte < 0 || endByte < 0 || entityLength < 0) { + throw DL_ABORT_EX("byte-range-spec must be positive"); + } return SharedHandle<Range>(new Range(startByte, endByte, entityLength)); } diff --git a/src/HttpHeader.h b/src/HttpHeader.h index 547a7615..b337e089 100644 --- a/src/HttpHeader.h +++ b/src/HttpHeader.h @@ -73,8 +73,8 @@ public: std::pair<std::multimap<std::string, std::string>::const_iterator, std::multimap<std::string, std::string>::const_iterator> equalRange(const std::string& name) const; - unsigned int findAsUInt(const std::string& name) const; - uint64_t findAsULLInt(const std::string& name) const; + int32_t findAsInt(const std::string& name) const; + int64_t findAsLLInt(const std::string& name) const; SharedHandle<Range> getRange() const; diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc index fa99b583..50404956 100644 --- a/src/HttpRequest.cc +++ b/src/HttpRequest.cc @@ -368,7 +368,7 @@ const SharedHandle<AuthConfig>& HttpRequest::getAuthConfig() const return authConfig_; } -uint64_t HttpRequest::getEntityLength() const +off_t HttpRequest::getEntityLength() const { assert(fileEntry_); return fileEntry_->getLength(); diff --git a/src/HttpRequest.h b/src/HttpRequest.h index 11d6642b..1e72f754 100644 --- a/src/HttpRequest.h +++ b/src/HttpRequest.h @@ -105,7 +105,7 @@ public: void setRequest(const SharedHandle<Request>& request); - uint64_t getEntityLength() const; + off_t getEntityLength() const; const std::string& getHost() const; diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc index 74ba8e10..a52ce99e 100644 --- a/src/HttpRequestCommand.cc +++ b/src/HttpRequestCommand.cc @@ -86,7 +86,7 @@ SharedHandle<HttpRequest> createHttpRequest(const SharedHandle<Request>& req, const SharedHandle<FileEntry>& fileEntry, const SharedHandle<Segment>& segment, - uint64_t totalLength, + off_t totalLength, const SharedHandle<Option>& option, const RequestGroup* rg, const SharedHandle<CookieStorage>& cookieStorage, diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc index bb2d1d09..b07d873a 100644 --- a/src/HttpResponse.cc +++ b/src/HttpResponse.cc @@ -227,7 +227,7 @@ SharedHandle<StreamFilter> HttpResponse::getContentEncodingStreamFilter() const return filter; } -uint64_t HttpResponse::getContentLength() const +off_t HttpResponse::getContentLength() const { if(!httpHeader_) { return 0; @@ -236,7 +236,7 @@ uint64_t HttpResponse::getContentLength() const } } -uint64_t HttpResponse::getEntityLength() const +off_t HttpResponse::getEntityLength() const { if(!httpHeader_) { return 0; @@ -279,7 +279,7 @@ bool HttpResponse::hasRetryAfter() const time_t HttpResponse::getRetryAfter() const { - return httpHeader_->findAsUInt(HttpHeader::RETRY_AFTER); + return httpHeader_->findAsInt(HttpHeader::RETRY_AFTER); } Time HttpResponse::getLastModifiedTime() const diff --git a/src/HttpResponse.h b/src/HttpResponse.h index 0b379f75..7e43cb8c 100644 --- a/src/HttpResponse.h +++ b/src/HttpResponse.h @@ -96,9 +96,9 @@ public: SharedHandle<StreamFilter> getContentEncodingStreamFilter() const; - uint64_t getContentLength() const; + off_t getContentLength() const; - uint64_t getEntityLength() const; + off_t getEntityLength() const; // Returns type "/" subtype. The parameter is removed. std::string getContentType() const; diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc index f9242591..70af2e89 100644 --- a/src/HttpResponseCommand.cc +++ b/src/HttpResponseCommand.cc @@ -180,7 +180,7 @@ bool HttpResponseCommand::executeInternal() int statusCode = httpResponse->getStatusCode(); if(statusCode == 304) { - uint64_t totalLength = httpResponse->getEntityLength(); + off_t totalLength = httpResponse->getEntityLength(); getFileEntry()->setLength(totalLength); getRequestGroup()->initPieceStorage(); getPieceStorage()->markAllPiecesDone(); @@ -245,7 +245,7 @@ bool HttpResponseCommand::executeInternal() } if(!getPieceStorage()) { util::removeMetalinkContentTypes(getRequestGroup()); - uint64_t totalLength = httpResponse->getEntityLength(); + off_t totalLength = httpResponse->getEntityLength(); getFileEntry()->setLength(totalLength); if(getFileEntry()->getPath().empty()) { getFileEntry()->setPath diff --git a/src/HttpServer.cc b/src/HttpServer.cc index a30cc9ae..58add493 100644 --- a/src/HttpServer.cc +++ b/src/HttpServer.cc @@ -90,7 +90,10 @@ SharedHandle<HttpHeader> HttpServer::receiveRequest() lastBody_.clear(); lastBody_.str(""); lastContentLength_ = - lastRequestHeader_->findAsUInt(HttpHeader::CONTENT_LENGTH); + lastRequestHeader_->findAsLLInt(HttpHeader::CONTENT_LENGTH); + if(lastContentLength_ < 0) { + throw DL_ABORT_EX("Content-Length must be positive."); + } headerProcessor_->clear(); const std::string& connection = @@ -144,7 +147,7 @@ bool HttpServer::receiveBody() lastBody_.write(reinterpret_cast<const char*>(socketRecvBuffer_->getBuffer()), length); socketRecvBuffer_->shiftBuffer(length); - return lastContentLength_ == static_cast<uint64_t>(lastBody_.tellp()); + return lastContentLength_ == lastBody_.tellp(); } std::string HttpServer::getBody() const diff --git a/src/HttpServer.h b/src/HttpServer.h index 665c6d88..f5ebb4ee 100644 --- a/src/HttpServer.h +++ b/src/HttpServer.h @@ -60,7 +60,7 @@ private: DownloadEngine* e_; SharedHandle<HttpHeaderProcessor> headerProcessor_; SharedHandle<HttpHeader> lastRequestHeader_; - uint64_t lastContentLength_; + off_t lastContentLength_; std::stringstream lastBody_; bool keepAlive_; bool gzip_; @@ -118,7 +118,7 @@ public: void disableGZip() { gzip_ = false; } - uint64_t getContentLength() const { return lastContentLength_; } + off_t getContentLength() const { return lastContentLength_; } const SharedHandle<SocketRecvBuffer>& getSocketRecvBuffer() const { diff --git a/src/HttpServerCommand.cc b/src/HttpServerCommand.cc index a2089645..d5653c92 100644 --- a/src/HttpServerCommand.cc +++ b/src/HttpServerCommand.cc @@ -133,8 +133,7 @@ bool HttpServerCommand::execute() e_->setNoWait(true); return true; } - if(static_cast<uint64_t> - (e_->getOption()->getAsInt(PREF_RPC_MAX_REQUEST_SIZE)) < + if(e_->getOption()->getAsInt(PREF_RPC_MAX_REQUEST_SIZE) < httpServer_->getContentLength()) { A2_LOG_INFO (fmt("Request too long. ContentLength=%lld." diff --git a/src/HttpSkipResponseCommand.cc b/src/HttpSkipResponseCommand.cc index c9744929..56d96ecc 100644 --- a/src/HttpSkipResponseCommand.cc +++ b/src/HttpSkipResponseCommand.cc @@ -127,7 +127,7 @@ bool HttpSkipResponseCommand::executeInternal() if(totalLength_ > 0) { bufSize = std::min (totalLength_-receivedBytes_, - static_cast<uint64_t>(getSocketRecvBuffer()->getBufferLength())); + static_cast<off_t>(getSocketRecvBuffer()->getBufferLength())); } else { bufSize = getSocketRecvBuffer()->getBufferLength(); } diff --git a/src/HttpSkipResponseCommand.h b/src/HttpSkipResponseCommand.h index 4a04b43c..c4a99041 100644 --- a/src/HttpSkipResponseCommand.h +++ b/src/HttpSkipResponseCommand.h @@ -53,9 +53,9 @@ private: bool sinkFilterOnly_; - uint64_t totalLength_; + off_t totalLength_; - uint64_t receivedBytes_; + off_t receivedBytes_; bool processResponse(); diff --git a/src/IteratableChecksumValidator.cc b/src/IteratableChecksumValidator.cc index 29451d4f..c086522b 100644 --- a/src/IteratableChecksumValidator.cc +++ b/src/IteratableChecksumValidator.cc @@ -84,14 +84,14 @@ void IteratableChecksumValidator::validateChunk() bool IteratableChecksumValidator::finished() const { - if((uint64_t)currentOffset_ >= dctx_->getTotalLength()) { + if(currentOffset_ >= dctx_->getTotalLength()) { return true; } else { return false; } } -uint64_t IteratableChecksumValidator::getTotalLength() const +off_t IteratableChecksumValidator::getTotalLength() const { return dctx_->getTotalLength(); } diff --git a/src/IteratableChecksumValidator.h b/src/IteratableChecksumValidator.h index d38fb42c..2c4e60d5 100644 --- a/src/IteratableChecksumValidator.h +++ b/src/IteratableChecksumValidator.h @@ -70,7 +70,7 @@ public: return currentOffset_; } - virtual uint64_t getTotalLength() const; + virtual off_t getTotalLength() const; }; typedef SharedHandle<IteratableChecksumValidator> IteratableChecksumValidatorHandle; diff --git a/src/IteratableChunkChecksumValidator.cc b/src/IteratableChunkChecksumValidator.cc index db479dc8..f3f7f2b2 100644 --- a/src/IteratableChunkChecksumValidator.cc +++ b/src/IteratableChunkChecksumValidator.cc @@ -149,10 +149,10 @@ bool IteratableChunkChecksumValidator::finished() const off_t IteratableChunkChecksumValidator::getCurrentOffset() const { - return (off_t)currentIndex_*dctx_->getPieceLength(); + return static_cast<off_t>(currentIndex_)*dctx_->getPieceLength(); } -uint64_t IteratableChunkChecksumValidator::getTotalLength() const +off_t IteratableChunkChecksumValidator::getTotalLength() const { return dctx_->getTotalLength(); } diff --git a/src/IteratableChunkChecksumValidator.h b/src/IteratableChunkChecksumValidator.h index 5e9bfef1..314e5765 100644 --- a/src/IteratableChunkChecksumValidator.h +++ b/src/IteratableChunkChecksumValidator.h @@ -73,7 +73,7 @@ public: virtual off_t getCurrentOffset() const; - virtual uint64_t getTotalLength() const; + virtual off_t getTotalLength() const; }; typedef SharedHandle<IteratableChunkChecksumValidator> IteratableChunkChecksumValidatorHandle; diff --git a/src/IteratableValidator.h b/src/IteratableValidator.h index f208f0ed..ca339ccc 100644 --- a/src/IteratableValidator.h +++ b/src/IteratableValidator.h @@ -62,7 +62,7 @@ public: virtual off_t getCurrentOffset() const = 0; - virtual uint64_t getTotalLength() const = 0; + virtual off_t getTotalLength() const = 0; }; typedef SharedHandle<IteratableValidator> IteratableValidatorHandle; diff --git a/src/LpdMessageReceiver.cc b/src/LpdMessageReceiver.cc index 0d817776..ff2faab1 100644 --- a/src/LpdMessageReceiver.cc +++ b/src/LpdMessageReceiver.cc @@ -97,7 +97,7 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage() static const std::string A2_INFOHASH = "infohash"; static const std::string A2_PORT = "port"; const std::string& infoHashString = header->find(A2_INFOHASH); - uint16_t port = header->findAsUInt(A2_PORT); + uint16_t port = header->findAsInt(A2_PORT); A2_LOG_INFO(fmt("LPD message received infohash=%s, port=%u from %s", infoHashString.c_str(), port, diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc index 9c720a2d..d1ae70be 100644 --- a/src/MetalinkEntry.cc +++ b/src/MetalinkEntry.cc @@ -101,7 +101,7 @@ const std::string& MetalinkEntry::getPath() const return file->getPath(); } -uint64_t MetalinkEntry::getLength() const +off_t MetalinkEntry::getLength() const { return file->getLength(); } diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h index 43b1ebdb..94395e7c 100644 --- a/src/MetalinkEntry.h +++ b/src/MetalinkEntry.h @@ -79,7 +79,7 @@ public: const std::string& getPath() const; - uint64_t getLength() const; + off_t getLength() const; const SharedHandle<FileEntry>& getFile() const { diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc index 51146930..1820c949 100644 --- a/src/MetalinkParserController.cc +++ b/src/MetalinkParserController.cc @@ -87,7 +87,7 @@ void MetalinkParserController::setFileNameOfEntry(const std::string& filename) } } -void MetalinkParserController::setFileLengthOfEntry(uint64_t length) +void MetalinkParserController::setFileLengthOfEntry(off_t length) { if(!tEntry_) { return; diff --git a/src/MetalinkParserController.h b/src/MetalinkParserController.h index c886becc..65f6124b 100644 --- a/src/MetalinkParserController.h +++ b/src/MetalinkParserController.h @@ -96,7 +96,7 @@ public: void setFileNameOfEntry(const std::string& filename); - void setFileLengthOfEntry(uint64_t length); + void setFileLengthOfEntry(off_t length); void setVersionOfEntry(const std::string& version); diff --git a/src/MetalinkParserStateMachine.cc b/src/MetalinkParserStateMachine.cc index d97c6bbe..17eb0304 100644 --- a/src/MetalinkParserStateMachine.cc +++ b/src/MetalinkParserStateMachine.cc @@ -262,7 +262,7 @@ void MetalinkParserStateMachine::setFileNameOfEntry(const std::string& filename) ctrl_->setFileNameOfEntry(filename); } -void MetalinkParserStateMachine::setFileLengthOfEntry(uint64_t length) +void MetalinkParserStateMachine::setFileLengthOfEntry(off_t length) { ctrl_->setFileLengthOfEntry(length); } diff --git a/src/MetalinkParserStateMachine.h b/src/MetalinkParserStateMachine.h index e0d9038c..b4e1da5c 100644 --- a/src/MetalinkParserStateMachine.h +++ b/src/MetalinkParserStateMachine.h @@ -159,7 +159,7 @@ public: void setFileNameOfEntry(const std::string& filename); - void setFileLengthOfEntry(uint64_t length); + void setFileLengthOfEntry(off_t length); void setVersionOfEntry(const std::string& version); diff --git a/src/MetalinkParserStateV3Impl.cc b/src/MetalinkParserStateV3Impl.cc index 783f0e69..fd85270f 100644 --- a/src/MetalinkParserStateV3Impl.cc +++ b/src/MetalinkParserStateV3Impl.cc @@ -148,8 +148,8 @@ void SizeMetalinkParserState::endElement const std::string& characters) { // current metalink specification doesn't require size element. - uint64_t size; - if(util::parseULLIntNoThrow(size, characters)) { + off_t size; + if(util::parseLLIntNoThrow(size, characters) && size >= 0) { psm->setFileLengthOfEntry(size); } } diff --git a/src/MetalinkParserStateV4Impl.cc b/src/MetalinkParserStateV4Impl.cc index 2ba07297..31573139 100644 --- a/src/MetalinkParserStateV4Impl.cc +++ b/src/MetalinkParserStateV4Impl.cc @@ -253,8 +253,8 @@ void SizeMetalinkParserStateV4::endElement const char* nsUri, const std::string& characters) { - uint64_t size; - if(util::parseULLIntNoThrow(size, characters)) { + off_t size; + if(util::parseLLIntNoThrow(size, characters) && size >= 0) { psm->setFileLengthOfEntry(size); } else { psm->cancelEntryTransaction(); diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc index 65bec7e3..2f815f06 100644 --- a/src/MultiDiskAdaptor.cc +++ b/src/MultiDiskAdaptor.cc @@ -101,7 +101,7 @@ bool DiskWriterEntry::fileExists() return fileEntry_->exists(); } -uint64_t DiskWriterEntry::size() const +off_t DiskWriterEntry::size() const { return File(getFilePath()).size(); } @@ -169,8 +169,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() itr-1; true; --i) { const SharedHandle<FileEntry>& fileEntry = (*i)->getFileEntry(); if(pieceStartOffset <= fileEntry->getOffset() || - (uint64_t)pieceStartOffset < - fileEntry->getOffset()+fileEntry->getLength()) { + pieceStartOffset < fileEntry->getLastOffset()) { (*i)->needsFileAllocation(true); } else { break; @@ -306,22 +305,19 @@ namespace { bool isInRange(const DiskWriterEntryHandle entry, off_t offset) { return entry->getFileEntry()->getOffset() <= offset && - (uint64_t)offset < - entry->getFileEntry()->getOffset()+entry->getFileEntry()->getLength(); + offset < entry->getFileEntry()->getLastOffset(); } } // namespace namespace { -size_t calculateLength(const DiskWriterEntryHandle entry, - off_t fileOffset, size_t rem) +ssize_t calculateLength(const DiskWriterEntryHandle entry, + off_t fileOffset, ssize_t rem) { - size_t length; - if(entry->getFileEntry()->getLength() < (uint64_t)fileOffset+rem) { - length = entry->getFileEntry()->getLength()-fileOffset; + if(entry->getFileEntry()->getLength() < fileOffset+rem) { + return entry->getFileEntry()->getLength()-fileOffset; } else { - length = rem; + return rem; } - return length; } } // namespace @@ -371,11 +367,11 @@ void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len, DiskWriterEntries::const_iterator first = findFirstDiskWriterEntry(diskWriterEntries_, offset); - size_t rem = len; + ssize_t rem = len; off_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); for(DiskWriterEntries::const_iterator i = first, eoi = diskWriterEntries_.end(); i != eoi; ++i) { - size_t writeLength = calculateLength(*i, fileOffset, rem); + ssize_t writeLength = calculateLength(*i, fileOffset, rem); openIfNot(*i, &DiskWriterEntry::openFile); @@ -398,12 +394,12 @@ ssize_t MultiDiskAdaptor::readData DiskWriterEntries::const_iterator first = findFirstDiskWriterEntry(diskWriterEntries_, offset); - size_t rem = len; - size_t totalReadLength = 0; + ssize_t rem = len; + ssize_t totalReadLength = 0; off_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); for(DiskWriterEntries::const_iterator i = first, eoi = diskWriterEntries_.end(); i != eoi; ++i) { - size_t readLength = calculateLength(*i, fileOffset, rem); + ssize_t readLength = calculateLength(*i, fileOffset, rem); openIfNot(*i, &DiskWriterEntry::openFile); @@ -429,9 +425,9 @@ bool MultiDiskAdaptor::fileExists() getFileEntries().end(); } -uint64_t MultiDiskAdaptor::size() +off_t MultiDiskAdaptor::size() { - uint64_t size = 0; + off_t size = 0; for(std::vector<SharedHandle<FileEntry> >::const_iterator i = getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) { size += File((*i)->getPath()).size(); @@ -460,9 +456,9 @@ void MultiDiskAdaptor::cutTrailingGarbage() for(std::vector<SharedHandle<DiskWriterEntry> >::const_iterator i = diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); i != eoi; ++i) { - uint64_t length = (*i)->getFileEntry()->getLength(); + off_t length = (*i)->getFileEntry()->getLength(); if(File((*i)->getFilePath()).size() > length) { - // We need open file before calling DiskWriter::truncate(uint64_t) + // We need open file before calling DiskWriter::truncate(off_t) openIfNot(*i, &DiskWriterEntry::openFile); (*i)->getDiskWriter()->truncate(length); } diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h index 4eecaae0..dea911f5 100644 --- a/src/MultiDiskAdaptor.h +++ b/src/MultiDiskAdaptor.h @@ -69,7 +69,7 @@ public: bool fileExists(); - uint64_t size() const; + off_t size() const; const SharedHandle<FileEntry>& getFileEntry() const { @@ -139,7 +139,7 @@ public: virtual bool fileExists(); - virtual uint64_t size(); + virtual off_t size(); virtual SharedHandle<FileAllocationIterator> fileAllocationIterator(); diff --git a/src/MultiFileAllocationIterator.cc b/src/MultiFileAllocationIterator.cc index 85b3f527..6b6a89fa 100644 --- a/src/MultiFileAllocationIterator.cc +++ b/src/MultiFileAllocationIterator.cc @@ -104,7 +104,7 @@ off_t MultiFileAllocationIterator::getCurrentLength() } } -uint64_t MultiFileAllocationIterator::getTotalLength() +off_t MultiFileAllocationIterator::getTotalLength() { if(!fileAllocationIterator_) { return 0; diff --git a/src/MultiFileAllocationIterator.h b/src/MultiFileAllocationIterator.h index c649cedf..55d607b6 100644 --- a/src/MultiFileAllocationIterator.h +++ b/src/MultiFileAllocationIterator.h @@ -61,7 +61,7 @@ public: virtual off_t getCurrentLength(); - virtual uint64_t getTotalLength(); + virtual off_t getTotalLength(); const std::deque<SharedHandle<DiskWriterEntry> >& getDiskWriterEntries() const; diff --git a/src/Peer.cc b/src/Peer.cc index fc690cc9..07d2f22a 100644 --- a/src/Peer.cc +++ b/src/Peer.cc @@ -73,7 +73,7 @@ void Peer::usedBy(cuid_t cuid) cuid_ = cuid; } -void Peer::allocateSessionResource(size_t pieceLength, uint64_t totalLength) +void Peer::allocateSessionResource(size_t pieceLength, off_t totalLength) { delete res_; res_ = new PeerSessionResource(pieceLength, totalLength); @@ -81,7 +81,7 @@ void Peer::allocateSessionResource(size_t pieceLength, uint64_t totalLength) updateSeeder(); } -void Peer::reconfigureSessionResource(size_t pieceLength, uint64_t totalLength) +void Peer::reconfigureSessionResource(size_t pieceLength, off_t totalLength) { assert(res_); res_->reconfigure(pieceLength, totalLength); @@ -228,13 +228,13 @@ unsigned int Peer::calculateDownloadSpeed() return res_->getPeerStat().calculateDownloadSpeed(); } -uint64_t Peer::getSessionUploadLength() const +off_t Peer::getSessionUploadLength() const { assert(res_); return res_->uploadLength(); } -uint64_t Peer::getSessionDownloadLength() const +off_t Peer::getSessionDownloadLength() const { assert(res_); return res_->downloadLength(); @@ -388,7 +388,7 @@ const Timer& Peer::getLastAmUnchoking() const return res_->getLastAmUnchoking(); } -uint64_t Peer::getCompletedLength() const +off_t Peer::getCompletedLength() const { assert(res_); return res_->getCompletedLength(); @@ -160,9 +160,9 @@ public: bool isGood() const; - void allocateSessionResource(size_t pieceLength, uint64_t totalLength); + void allocateSessionResource(size_t pieceLength, off_t totalLength); - void reconfigureSessionResource(size_t pieceLength, uint64_t totalLength); + void reconfigureSessionResource(size_t pieceLength, off_t totalLength); void releaseSessionResource(); @@ -234,12 +234,12 @@ public: /** * Returns the number of bytes uploaded to the remote host. */ - uint64_t getSessionUploadLength() const; + off_t getSessionUploadLength() const; /** * Returns the number of bytes downloaded from the remote host. */ - uint64_t getSessionDownloadLength() const; + off_t getSessionDownloadLength() const; void setBitfield(const unsigned char* bitfield, size_t bitfieldLength); @@ -293,7 +293,7 @@ public: const Timer& getLastAmUnchoking() const; - uint64_t getCompletedLength() const; + off_t getCompletedLength() const; bool isIncomingPeer() const { diff --git a/src/PeerSessionResource.cc b/src/PeerSessionResource.cc index 790f1148..912f665d 100644 --- a/src/PeerSessionResource.cc +++ b/src/PeerSessionResource.cc @@ -44,7 +44,7 @@ namespace aria2 { -PeerSessionResource::PeerSessionResource(size_t pieceLength, uint64_t totalLength): +PeerSessionResource::PeerSessionResource(size_t pieceLength, off_t totalLength): amChoking_(true), amInterested_(false), peerChoking_(true), @@ -237,7 +237,7 @@ void PeerSessionResource::dhtEnabled(bool b) dhtEnabled_ = b; } -uint64_t PeerSessionResource::uploadLength() const +off_t PeerSessionResource::uploadLength() const { return peerStat_.getSessionUploadLength(); } @@ -247,7 +247,7 @@ void PeerSessionResource::updateUploadLength(size_t bytes) peerStat_.updateUploadLength(bytes); } -uint64_t PeerSessionResource::downloadLength() const +off_t PeerSessionResource::downloadLength() const { return peerStat_.getSessionDownloadLength(); } @@ -259,7 +259,7 @@ void PeerSessionResource::updateDownloadLength(size_t bytes) lastDownloadUpdate_ = global::wallclock(); } -uint64_t PeerSessionResource::getCompletedLength() const +off_t PeerSessionResource::getCompletedLength() const { return bitfieldMan_->getCompletedLength(); } @@ -275,7 +275,7 @@ size_t PeerSessionResource::countOutstandingUpload() const return dispatcher_->countOutstandingUpload(); } -void PeerSessionResource::reconfigure(size_t pieceLength, uint64_t totalLenth) +void PeerSessionResource::reconfigure(size_t pieceLength, off_t totalLenth) { delete bitfieldMan_; bitfieldMan_ = new BitfieldMan(pieceLength, totalLenth); diff --git a/src/PeerSessionResource.h b/src/PeerSessionResource.h index fecd23fd..3d4a6869 100644 --- a/src/PeerSessionResource.h +++ b/src/PeerSessionResource.h @@ -83,7 +83,7 @@ private: BtMessageDispatcher* dispatcher_; public: - PeerSessionResource(size_t pieceLength, uint64_t totalLength); + PeerSessionResource(size_t pieceLength, off_t totalLength); ~PeerSessionResource(); @@ -155,7 +155,7 @@ public: size_t getBitfieldLength() const; - void reconfigure(size_t index, uint64_t totalLength); + void reconfigure(size_t index, off_t totalLength); bool hasPiece(size_t index) const; @@ -210,11 +210,11 @@ public: return peerStat_; } - uint64_t uploadLength() const; + off_t uploadLength() const; void updateUploadLength(size_t bytes); - uint64_t downloadLength() const; + off_t downloadLength() const; void updateDownloadLength(size_t bytes); @@ -228,7 +228,7 @@ public: return lastAmUnchoking_; } - uint64_t getCompletedLength() const; + off_t getCompletedLength() const; void setBtMessageDispatcher(BtMessageDispatcher* dpt); diff --git a/src/PeerStat.h b/src/PeerStat.h index fc491c1a..c328173d 100644 --- a/src/PeerStat.h +++ b/src/PeerStat.h @@ -61,8 +61,8 @@ private: PeerStat::STATUS status_; unsigned int avgDownloadSpeed_; unsigned int avgUploadSpeed_; - uint64_t sessionDownloadLength_; - uint64_t sessionUploadLength_; + int64_t sessionDownloadLength_; + int64_t sessionUploadLength_; public: PeerStat (cuid_t cuid, const std::string& hostname, const::std::string& protocol); diff --git a/src/PieceStorage.h b/src/PieceStorage.h index b3d3e46c..5f53122e 100644 --- a/src/PieceStorage.h +++ b/src/PieceStorage.h @@ -179,13 +179,13 @@ public: virtual bool isPieceUsed(size_t index) = 0; - virtual uint64_t getTotalLength() = 0; + virtual off_t getTotalLength() = 0; - virtual uint64_t getFilteredTotalLength() = 0; + virtual off_t getFilteredTotalLength() = 0; - virtual uint64_t getCompletedLength() = 0; + virtual off_t getCompletedLength() = 0; - virtual uint64_t getFilteredCompletedLength() = 0; + virtual off_t getFilteredCompletedLength() = 0; virtual void setupFileFilter() = 0; @@ -258,7 +258,7 @@ public: /** * Sets all bits in bitfield(0 to length) to 1. */ - virtual void markPiecesDone(uint64_t length) = 0; + virtual void markPiecesDone(off_t length) = 0; virtual void addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces) = 0; diff --git a/src/ProgressAwareEntry.h b/src/ProgressAwareEntry.h index 48f0ad0f..82d78217 100644 --- a/src/ProgressAwareEntry.h +++ b/src/ProgressAwareEntry.h @@ -50,7 +50,7 @@ public: virtual off_t getCurrentLength() = 0; - virtual uint64_t getTotalLength() = 0; + virtual off_t getTotalLength() = 0; virtual bool finished() = 0; }; diff --git a/src/Range.cc b/src/Range.cc index ba2439c7..e61e66f8 100644 --- a/src/Range.cc +++ b/src/Range.cc @@ -38,7 +38,7 @@ namespace aria2 { Range::Range():startByte_(0), endByte_(0), entityLength_(0) {} -Range::Range(off_t startByte, off_t endByte, uint64_t entityLength) +Range::Range(off_t startByte, off_t endByte, off_t entityLength) : startByte_(startByte), endByte_(endByte), entityLength_(entityLength) {} @@ -72,7 +72,7 @@ bool Range::operator!=(const Range& range) const return !(*this == range); } -uint64_t Range::getContentLength() const +off_t Range::getContentLength() const { if(endByte_ >= startByte_) { return endByte_-startByte_+1; diff --git a/src/Range.h b/src/Range.h index c43b99b2..6852a272 100644 --- a/src/Range.h +++ b/src/Range.h @@ -47,11 +47,11 @@ class Range { private: off_t startByte_; off_t endByte_; - uint64_t entityLength_; + off_t entityLength_; public: Range(); - Range(off_t startByte, off_t endByte, uint64_t entityLength); + Range(off_t startByte, off_t endByte, off_t entityLength); Range(const Range& c); @@ -73,12 +73,12 @@ public: return endByte_; } - uint64_t getEntityLength() const + off_t getEntityLength() const { return entityLength_; } - uint64_t getContentLength() const; + off_t getContentLength() const; }; typedef SharedHandle<Range> RangeHandle; diff --git a/src/RequestGroup.cc b/src/RequestGroup.cc index 9f71548f..b09fb818 100644 --- a/src/RequestGroup.cc +++ b/src/RequestGroup.cc @@ -390,7 +390,7 @@ void RequestGroup::createInitialCommand } removeDefunctControlFile(progressInfoFile); { - uint64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size(); + off_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. @@ -555,7 +555,7 @@ void RequestGroup::processCheckIntegrityEntry const SharedHandle<CheckIntegrityEntry>& entry, DownloadEngine* e) { - uint64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size(); + off_t actualFileSize = pieceStorage_->getDiskAdaptor()->size(); if(actualFileSize > downloadContext_->getTotalLength()) { entry->cutTrailingGarbage(); } @@ -863,7 +863,7 @@ std::string RequestGroup::getFirstFilePath() const } } -uint64_t RequestGroup::getTotalLength() const +off_t RequestGroup::getTotalLength() const { if(!pieceStorage_) { return 0; @@ -876,7 +876,7 @@ uint64_t RequestGroup::getTotalLength() const } } -uint64_t RequestGroup::getCompletedLength() const +off_t RequestGroup::getCompletedLength() const { if(!pieceStorage_) { return 0; @@ -902,8 +902,8 @@ void RequestGroup::validateFilename(const std::string& expectedFilename, } } -void RequestGroup::validateTotalLength(uint64_t expectedTotalLength, - uint64_t actualTotalLength) const +void RequestGroup::validateTotalLength(off_t expectedTotalLength, + off_t actualTotalLength) const { if(expectedTotalLength <= 0) { return; @@ -921,7 +921,7 @@ void RequestGroup::validateFilename(const std::string& actualFilename) const validateFilename(downloadContext_->getFileEntries().front()->getBasename(), actualFilename); } -void RequestGroup::validateTotalLength(uint64_t actualTotalLength) const +void RequestGroup::validateTotalLength(off_t actualTotalLength) const { validateTotalLength(getTotalLength(), actualTotalLength); } @@ -1155,7 +1155,7 @@ void RequestGroup::setProgressInfoFile(const BtProgressInfoFileHandle& progressI bool RequestGroup::needsFileAllocation() const { return isFileAllocationEnabled() && - (uint64_t)option_->getAsLLInt(PREF_NO_FILE_ALLOCATION_LIMIT) <= getTotalLength() && + option_->getAsLLInt(PREF_NO_FILE_ALLOCATION_LIMIT) <= getTotalLength() && !pieceStorage_->getDiskAdaptor()->fileAllocationIterator()->finished(); } @@ -1204,7 +1204,7 @@ void RequestGroup::reportDownloadFinished() #ifdef ENABLE_BITTORRENT if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) { TransferStat stat = calculateStat(); - uint64_t completedLength = getCompletedLength(); + off_t completedLength = getCompletedLength(); double shareRatio = completedLength == 0 ? 0.0 : 1.0*stat.getAllTimeUploadLength()/completedLength; SharedHandle<TorrentAttribute> attrs = diff --git a/src/RequestGroup.h b/src/RequestGroup.h index bd694ad7..b2bfb9cd 100644 --- a/src/RequestGroup.h +++ b/src/RequestGroup.h @@ -230,9 +230,9 @@ public: std::string getFirstFilePath() const; - uint64_t getTotalLength() const; + off_t getTotalLength() const; - uint64_t getCompletedLength() const; + off_t getCompletedLength() const; /** * Compares expected filename with specified actualFilename. @@ -241,10 +241,10 @@ public: */ void validateFilename(const std::string& actualFilename) const; - void validateTotalLength(uint64_t expectedTotalLength, - uint64_t actualTotalLength) const; + void validateTotalLength(off_t expectedTotalLength, + off_t actualTotalLength) const; - void validateTotalLength(uint64_t actualTotalLength) const; + void validateTotalLength(off_t actualTotalLength) const; void setNumConcurrentCommand(unsigned int num) { diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc index bb0f1232..857ec571 100644 --- a/src/RequestGroupMan.cc +++ b/src/RequestGroupMan.cc @@ -711,7 +711,7 @@ void RequestGroupMan::formatDownloadResultFull if((*i)->getLength() == 0 || downloadResult->bitfield.empty()) { o << " -|"; } else { - uint64_t completedLength = + off_t completedLength = bt.getOffsetCompletedLength((*i)->getOffset(), (*i)->getLength()); o << std::setw(3) << 100*completedLength/(*i)->getLength() << "|"; } diff --git a/src/RpcMethodImpl.cc b/src/RpcMethodImpl.cc index 99f113ee..4e0904fa 100644 --- a/src/RpcMethodImpl.cc +++ b/src/RpcMethodImpl.cc @@ -585,9 +585,9 @@ void createFileEntry entry->put(KEY_PATH, (*first)->getPath()); entry->put(KEY_SELECTED, (*first)->isRequested()?VLB_TRUE:VLB_FALSE); entry->put(KEY_LENGTH, util::uitos((*first)->getLength())); - uint64_t completedLength = bf->getOffsetCompletedLength + off_t completedLength = bf->getOffsetCompletedLength ((*first)->getOffset(), (*first)->getLength()); - entry->put(KEY_COMPLETED_LENGTH, util::uitos(completedLength)); + entry->put(KEY_COMPLETED_LENGTH, util::itos(completedLength)); SharedHandle<List> uriList = List::g(); createUriEntry(uriList, *first); @@ -602,7 +602,7 @@ template<typename InputIterator> void createFileEntry (const SharedHandle<List>& files, InputIterator first, InputIterator last, - uint64_t totalLength, + off_t totalLength, size_t pieceLength, const std::string& bitfield) { @@ -618,7 +618,7 @@ template<typename InputIterator> void createFileEntry (const SharedHandle<List>& files, InputIterator first, InputIterator last, - uint64_t totalLength, + off_t totalLength, size_t pieceLength, const SharedHandle<PieceStorage>& ps) { diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc index 3664f862..3914a660 100644 --- a/src/SegmentMan.cc +++ b/src/SegmentMan.cc @@ -94,7 +94,7 @@ void SegmentMan::init() // PieceStorage here? } -uint64_t SegmentMan::getTotalLength() const +off_t SegmentMan::getTotalLength() const { if(!pieceStorage_) { return 0; @@ -342,7 +342,7 @@ bool SegmentMan::hasSegment(size_t index) const { return pieceStorage_->hasPiece(index); } -uint64_t SegmentMan::getDownloadLength() const { +off_t SegmentMan::getDownloadLength() const { if(!pieceStorage_) { return 0; } else { @@ -444,14 +444,14 @@ void SegmentMan::updateDownloadSpeedFor(const SharedHandle<PeerStat>& pstat) namespace { class PeerStatDownloadLengthOperator { public: - uint64_t operator()(uint64_t total, const SharedHandle<PeerStat>& ps) + off_t operator()(off_t total, const SharedHandle<PeerStat>& ps) { return ps->getSessionDownloadLength()+total; } }; } // namespace -uint64_t SegmentMan::calculateSessionDownloadLength() const +off_t SegmentMan::calculateSessionDownloadLength() const { return std::accumulate(fastestPeerStats_.begin(), fastestPeerStats_.end(), 0LL, PeerStatDownloadLengthOperator()); diff --git a/src/SegmentMan.h b/src/SegmentMan.h index 3eae1501..a19fce3e 100644 --- a/src/SegmentMan.h +++ b/src/SegmentMan.h @@ -124,7 +124,7 @@ public: * If Transfer-Encoding is Chunked or Content-Length header is not provided, * then this value is set to be 0. */ - uint64_t getTotalLength() const; + off_t getTotalLength() const; /** * Returs true when the download has finished. @@ -202,7 +202,7 @@ public: /** * Returns the length of bytes downloaded. */ - uint64_t getDownloadLength() const; + off_t getDownloadLength() const; // If there is inactive PeerStat in peerStats_, it is replaced with @@ -238,7 +238,7 @@ public: /** * Returns the downloaded bytes in this session. */ - uint64_t calculateSessionDownloadLength() const; + off_t calculateSessionDownloadLength() const; size_t countFreePieceFrom(size_t index) const; diff --git a/src/ShareRatioSeedCriteria.cc b/src/ShareRatioSeedCriteria.cc index 9b60e0fc..fa1aac2c 100644 --- a/src/ShareRatioSeedCriteria.cc +++ b/src/ShareRatioSeedCriteria.cc @@ -51,7 +51,7 @@ void ShareRatioSeedCriteria::reset() {} bool ShareRatioSeedCriteria::evaluate() { - uint64_t completedLength = pieceStorage_->getCompletedLength(); + off_t completedLength = pieceStorage_->getCompletedLength(); if(completedLength == 0) { return true; } diff --git a/src/SingleFileAllocationIterator.cc b/src/SingleFileAllocationIterator.cc index fb72da8a..5a1d5598 100644 --- a/src/SingleFileAllocationIterator.cc +++ b/src/SingleFileAllocationIterator.cc @@ -51,7 +51,7 @@ namespace aria2 { SingleFileAllocationIterator::SingleFileAllocationIterator (BinaryStream* stream, off_t offset, - uint64_t totalLength) + off_t totalLength) : stream_(stream), offset_(offset), totalLength_(totalLength), @@ -90,7 +90,7 @@ void SingleFileAllocationIterator::allocateChunk() stream_->writeData(buffer_, BUFSIZE, offset_); offset_ += BUFSIZE; - if(totalLength_ < (uint64_t)offset_) { + if(totalLength_ < offset_) { stream_->truncate(totalLength_); offset_ = totalLength_; } @@ -98,7 +98,7 @@ void SingleFileAllocationIterator::allocateChunk() bool SingleFileAllocationIterator::finished() { - return (uint64_t)offset_ == totalLength_; + return offset_ == totalLength_; } } // namespace aria2 diff --git a/src/SingleFileAllocationIterator.h b/src/SingleFileAllocationIterator.h index a3d12602..b905aaea 100644 --- a/src/SingleFileAllocationIterator.h +++ b/src/SingleFileAllocationIterator.h @@ -48,11 +48,14 @@ private: off_t offset_; - uint64_t totalLength_; + off_t totalLength_; unsigned char* buffer_; public: - SingleFileAllocationIterator(BinaryStream* stream, off_t offset, uint64_t totalLength); + SingleFileAllocationIterator + (BinaryStream* stream, + off_t offset, + off_t totalLength); virtual ~SingleFileAllocationIterator(); @@ -65,7 +68,7 @@ public: return offset_; } - virtual uint64_t getTotalLength() + virtual off_t getTotalLength() { return totalLength_; } diff --git a/src/SpeedCalc.cc b/src/SpeedCalc.cc index c792df9e..719a1cc3 100644 --- a/src/SpeedCalc.cc +++ b/src/SpeedCalc.cc @@ -79,7 +79,7 @@ unsigned int SpeedCalc::calculateSpeed() { void SpeedCalc::update(size_t bytes) { accumulatedLength_ += bytes; std::transform(&lengthArray_[0], &lengthArray_[2], &lengthArray_[0], - std::bind1st(std::plus<uint64_t>(), (uint64_t)bytes)); + std::bind1st(std::plus<int64_t>(), (int64_t)bytes)); if(isIntervalOver()) { changeSw(); } @@ -103,7 +103,7 @@ void SpeedCalc::changeSw() { } unsigned int SpeedCalc::calculateAvgSpeed() const { - uint64_t milliElapsed = start_.differenceInMillis(global::wallclock()); + int64_t milliElapsed = start_.differenceInMillis(global::wallclock()); // if milliElapsed is too small, the average speed is rubish, better return 0 if(milliElapsed > 4) { diff --git a/src/SpeedCalc.h b/src/SpeedCalc.h index 716831b3..e2d5266c 100644 --- a/src/SpeedCalc.h +++ b/src/SpeedCalc.h @@ -42,13 +42,13 @@ namespace aria2 { class SpeedCalc { private: - uint64_t lengthArray_[2]; + int64_t lengthArray_[2]; int sw_; Timer cpArray_[2]; unsigned int maxSpeed_; unsigned int prevSpeed_; Timer start_; - uint64_t accumulatedLength_; + int64_t accumulatedLength_; time_t nextInterval_; bool isIntervalOver() const; diff --git a/src/TransferStat.h b/src/TransferStat.h index b8ffef46..c0c0febf 100644 --- a/src/TransferStat.h +++ b/src/TransferStat.h @@ -44,9 +44,9 @@ class TransferStat { public: unsigned int downloadSpeed; unsigned int uploadSpeed; - uint64_t sessionDownloadLength; - uint64_t sessionUploadLength; - uint64_t allTimeUploadLength; + int64_t sessionDownloadLength; + int64_t sessionUploadLength; + int64_t allTimeUploadLength; void copy(const TransferStat& stat) { @@ -98,28 +98,28 @@ public: * Returns the number of bytes downloaded since the program started. * This is not the total number of bytes downloaded. */ - uint64_t getSessionDownloadLength() const { + int64_t getSessionDownloadLength() const { return sessionDownloadLength; } - void setSessionDownloadLength(uint64_t s) { sessionDownloadLength = s; } + void setSessionDownloadLength(int64_t s) { sessionDownloadLength = s; } /** * Returns the number of bytes uploaded since the program started. * This is not the total number of bytes uploaded. */ - uint64_t getSessionUploadLength() const { + int64_t getSessionUploadLength() const { return sessionUploadLength; } - void setSessionUploadLength(uint64_t s) { sessionUploadLength = s; } + void setSessionUploadLength(int64_t s) { sessionUploadLength = s; } - void setAllTimeUploadLength(uint64_t s) + void setAllTimeUploadLength(int64_t s) { allTimeUploadLength = s; } - uint64_t getAllTimeUploadLength() const + int64_t getAllTimeUploadLength() const { return allTimeUploadLength; } diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc index c0809dff..d87ddad3 100644 --- a/src/UnknownLengthPieceStorage.cc +++ b/src/UnknownLengthPieceStorage.cc @@ -238,7 +238,7 @@ void UnknownLengthPieceStorage::markAllPiecesDone() downloadFinished_ = true; } -void UnknownLengthPieceStorage::markPiecesDone(uint64_t length) +void UnknownLengthPieceStorage::markPiecesDone(off_t length) { // TODO not implemented yet abort(); diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h index b6b340f6..39154f17 100644 --- a/src/UnknownLengthPieceStorage.h +++ b/src/UnknownLengthPieceStorage.h @@ -54,7 +54,7 @@ private: SharedHandle<DiskWriterFactory> diskWriterFactory_; - uint64_t totalLength_; + off_t totalLength_; bool downloadFinished_; @@ -152,23 +152,23 @@ public: virtual bool isPieceUsed(size_t index); - virtual uint64_t getTotalLength() + virtual off_t getTotalLength() { return totalLength_; } - virtual uint64_t getFilteredTotalLength() + virtual off_t getFilteredTotalLength() { return totalLength_; } - virtual uint64_t getCompletedLength() + virtual off_t getCompletedLength() { // TODO we have to return actual completed length here? return totalLength_; } - virtual uint64_t getFilteredCompletedLength() + virtual off_t getFilteredCompletedLength() { return getCompletedLength(); } @@ -259,7 +259,7 @@ public: */ virtual void markAllPiecesDone(); - virtual void markPiecesDone(uint64_t length); + virtual void markPiecesDone(off_t length); virtual void markPieceMissing(size_t index); diff --git a/src/bittorrent_helper.cc b/src/bittorrent_helper.cc index fffbde80..1aa51d46 100644 --- a/src/bittorrent_helper.cc +++ b/src/bittorrent_helper.cc @@ -232,7 +232,7 @@ void extractFileEntries const List* filesList = downcast<List>(infoDict->get(C_FILES)); if(filesList) { fileEntries.reserve(filesList->size()); - uint64_t length = 0; + off_t length = 0; off_t offset = 0; // multi-file mode torrent->mode = MULTI; @@ -304,7 +304,7 @@ void extractFileEntries throw DL_ABORT_EX2(fmt(MSG_MISSING_BT_INFO, C_LENGTH.c_str()), error_code::BITTORRENT_PARSE_ERROR); } - uint64_t totalLength = lengthData->i(); + off_t totalLength = lengthData->i(); // For each uri in urlList, if it ends with '/', then // concatenate name to it. Specification just says so. diff --git a/src/message_digest_helper.cc b/src/message_digest_helper.cc index b0fa8d3d..26e26a23 100644 --- a/src/message_digest_helper.cc +++ b/src/message_digest_helper.cc @@ -66,7 +66,7 @@ void staticSHA1DigestFree() } std::string staticSHA1Digest -(const BinaryStreamHandle& bs, off_t offset, uint64_t length) +(const BinaryStreamHandle& bs, off_t offset, off_t length) { sha1Ctx_->reset(); return digest(sha1Ctx_, bs, offset, length); @@ -75,14 +75,14 @@ std::string staticSHA1Digest std::string digest (const SharedHandle<MessageDigest>& ctx, const SharedHandle<BinaryStream>& bs, - off_t offset, uint64_t length) + off_t offset, off_t length) { size_t BUFSIZE = 4096; unsigned char BUF[BUFSIZE]; lldiv_t res = lldiv(length, BUFSIZE); - uint64_t iteration = res.quot; + int64_t iteration = res.quot; size_t tail = res.rem; - for(uint64_t i = 0; i < iteration; ++i) { + for(int64_t i = 0; i < iteration; ++i) { ssize_t readLength = bs->readData(BUF, BUFSIZE, offset); if((size_t)readLength != BUFSIZE) { throw DL_ABORT_EX(fmt(EX_FILE_READ, "n/a", "data is too short")); diff --git a/src/message_digest_helper.h b/src/message_digest_helper.h index 4bf5d582..b6179d92 100644 --- a/src/message_digest_helper.h +++ b/src/message_digest_helper.h @@ -63,7 +63,7 @@ void staticSHA1DigestInit(); void staticSHA1DigestFree(); std::string staticSHA1Digest -(const SharedHandle<BinaryStream>& bs, off_t offset, uint64_t length); +(const SharedHandle<BinaryStream>& bs, off_t offset, off_t length); /** * ctx must be initialized or reseted before calling this function. @@ -72,7 +72,7 @@ std::string staticSHA1Digest std::string digest (const SharedHandle<MessageDigest>& ctx, const SharedHandle<BinaryStream>& bs, - off_t offset, uint64_t length); + off_t offset, off_t length); /** * Stores *raw* message digest into md. diff --git a/src/paramed_string.cc b/src/paramed_string.cc index b2dc1406..bed6760c 100644 --- a/src/paramed_string.cc +++ b/src/paramed_string.cc @@ -38,7 +38,7 @@ namespace aria2 { namespace paramed_string { -std::string toBase26(uint32_t n, char zero, size_t width) +std::string toBase26(int32_t n, char zero, size_t width) { std::string res; if(n == 0 && width == 0) { diff --git a/src/paramed_string.h b/src/paramed_string.h index a2b617fe..b4b330f5 100644 --- a/src/paramed_string.h +++ b/src/paramed_string.h @@ -75,20 +75,20 @@ InputIterator expandChoice } template<typename InputIterator> -uint32_t fromBase26(InputIterator first, InputIterator last, char zero) +int32_t fromBase26(InputIterator first, InputIterator last, char zero) { - uint64_t res = 0; + int32_t res = 0; for(; first != last; ++first) { res *= 26; res += *first-zero; - if(res > UINT16_MAX) { + if(res > static_cast<int32_t>(UINT16_MAX)) { throw DL_ABORT_EX("Loop range overflow."); } } return res; } -std::string toBase26(uint32_t n, char zero, size_t width); +std::string toBase26(int32_t n, char zero, size_t width); template<typename InputIterator> InputIterator expandLoop @@ -147,7 +147,7 @@ InputIterator expandLoop (util::isUppercase(first, minus) && util::isUppercase(minus+1, colon))) { char zero = ('a' <= *first && *first <= 'z' ? 'a' : 'A'); - uint32_t start, end; + int32_t start, end; start = fromBase26(first, minus, zero); end = fromBase26(minus+1, colon, zero); if(start <= end) { @@ -161,7 +161,7 @@ InputIterator expandLoop res2.reserve(res.size()*((end+1-start)/step)); for(std::vector<std::string>::const_iterator i = res.begin(), eoi = res.end(); i != eoi; ++i) { - for(uint32_t j = start; j <= end; j += step) { + for(int32_t j = start; j <= end; j += step) { res2.push_back(*i); res2.back() += toBase26(j, zero, width); } diff --git a/src/util.cc b/src/util.cc index fabd9494..817cdc3d 100644 --- a/src/util.cc +++ b/src/util.cc @@ -645,32 +645,6 @@ int64_t parseLLInt(const std::string& s, int base) } } -bool parseULLIntNoThrow(uint64_t& res, const std::string& s, int base) -{ - long long int t; - if(parseLong(t, strtoll, s, base) && - t >= 0 && - t <= std::numeric_limits<int64_t>::max()) { - res = t; - return true; - } else { - return false; - } -} - -uint64_t parseULLInt(const std::string& s, int base) -{ - uint64_t res; - if(parseULLIntNoThrow(res, s, base)) { - return res; - } else { - throw DL_ABORT_EX - (fmt("Failed to convert string into 64bit unsigned integer. '%s'", - s.c_str())); - } -} - - void parseIntSegments(SegList<int>& sgl, const std::string& src) { for(std::string::const_iterator i = src.begin(), eoi = src.end(); i != eoi;) { @@ -702,7 +676,7 @@ void computeHeadPieces (std::vector<size_t>& indexes, const std::vector<SharedHandle<FileEntry> >& fileEntries, size_t pieceLength, - uint64_t head) + int64_t head) { if(head == 0) { return; @@ -727,7 +701,7 @@ void computeTailPieces (std::vector<size_t>& indexes, const std::vector<SharedHandle<FileEntry> >& fileEntries, size_t pieceLength, - uint64_t tail) + int64_t tail) { if(tail == 0) { return; @@ -737,7 +711,7 @@ void computeTailPieces if((*fi)->getLength() == 0) { continue; } - uint64_t endOffset = (*fi)->getLastOffset(); + int64_t endOffset = (*fi)->getLastOffset(); size_t fromIndex = (endOffset-1-(std::min(tail, (*fi)->getLength())-1))/pieceLength; for(size_t index = fromIndex; index <= (endOffset-1)/pieceLength; @@ -752,7 +726,7 @@ void parsePrioritizePieceRange (std::vector<size_t>& result, const std::string& src, const std::vector<SharedHandle<FileEntry> >& fileEntries, size_t pieceLength, - uint64_t defaultSize) + int64_t defaultSize) { std::vector<size_t> indexes; std::vector<Scip> parts; @@ -1181,7 +1155,7 @@ void convertBitfield(BitfieldMan* dest, const BitfieldMan* src) { size_t numBlock = dest->countBlock(); for(size_t index = 0; index < numBlock; ++index) { - if(src->isBitSetOffsetRange((uint64_t)index*dest->getBlockLength(), + if(src->isBitSetOffsetRange((off_t)index*dest->getBlockLength(), dest->getBlockLength())) { dest->setBit(index); } @@ -274,10 +274,6 @@ uint32_t parseUInt(const std::string& s, int base = 10); bool parseLLIntNoThrow(int64_t& res, const std::string& s, int base = 10); int64_t parseLLInt(const std::string& s, int base = 10); -// Valid range: [0, INT64_MAX] -bool parseULLIntNoThrow(uint64_t& res, const std::string& s, int base = 10); -uint64_t parseULLInt(const std::string& s, int base = 10); - void parseIntSegments(SegList<int>& sgl, const std::string& src); // Parses string which specifies the range of piece index for higher @@ -296,7 +292,7 @@ void parsePrioritizePieceRange (std::vector<size_t>& result, const std::string& src, const std::vector<SharedHandle<FileEntry> >& fileEntries, size_t pieceLength, - uint64_t defaultSize = 1048576 /* 1MiB */); + int64_t defaultSize = 1048576LL /* 1MiB */); // Converts ISO/IEC 8859-1 string src to utf-8. std::string iso8859ToUtf8(const std::string& src); diff --git a/test/BitfieldManTest.cc b/test/BitfieldManTest.cc index 1bd88eef..72e91d05 100644 --- a/test/BitfieldManTest.cc +++ b/test/BitfieldManTest.cc @@ -221,7 +221,7 @@ void BitfieldManTest::testFilter() for(size_t i = 0; i < A2_ARRAY_LEN(ans); ++i) { CPPUNIT_ASSERT_EQUAL(ans[i], out[i]); } - CPPUNIT_ASSERT_EQUAL((uint64_t)12ULL, btman.getFilteredTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)12ULL, btman.getFilteredTotalLength()); // test offset=5, length=2 out.clear(); @@ -235,13 +235,13 @@ void BitfieldManTest::testFilter() CPPUNIT_ASSERT_EQUAL((size_t)3, out[1]); btman.setBit(2); btman.setBit(3); - CPPUNIT_ASSERT_EQUAL((uint64_t)4ULL, btman.getFilteredTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)4ULL, btman.getFilteredTotalLength()); CPPUNIT_ASSERT(btman.isFilteredAllBitSet()); BitfieldMan btman2(2, 31); btman2.addFilter(0, 31); btman2.enableFilter(); - CPPUNIT_ASSERT_EQUAL((uint64_t)31ULL, btman2.getFilteredTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)31ULL, btman2.getFilteredTotalLength()); } void BitfieldManTest::testAddFilter_zeroLength() @@ -453,27 +453,27 @@ void BitfieldManTest::testGetOffsetCompletedLength() { BitfieldMan bt(1024, 1024*20); // 00000|00000|00000|00000 - CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(0, 1024)); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(0, 0)); + CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 1024)); + CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 0)); for(size_t i = 2; i <= 4; ++i) { bt.setBit(i); } // 00111|00000|00000|00000 - CPPUNIT_ASSERT_EQUAL((uint64_t)3072, bt.getOffsetCompletedLength(2048, 3072)); - CPPUNIT_ASSERT_EQUAL((uint64_t)3071, bt.getOffsetCompletedLength(2047, 3072)); - CPPUNIT_ASSERT_EQUAL((uint64_t)3071, bt.getOffsetCompletedLength(2049, 3072)); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(2048, 0)); - CPPUNIT_ASSERT_EQUAL((uint64_t)1, bt.getOffsetCompletedLength(2048, 1)); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(2047, 1)); - CPPUNIT_ASSERT_EQUAL((uint64_t)3072, bt.getOffsetCompletedLength(0, 1024*20)); - CPPUNIT_ASSERT_EQUAL((uint64_t)3072, + CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(2048, 3072)); + CPPUNIT_ASSERT_EQUAL((off_t)3071, bt.getOffsetCompletedLength(2047, 3072)); + CPPUNIT_ASSERT_EQUAL((off_t)3071, bt.getOffsetCompletedLength(2049, 3072)); + CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(2048, 0)); + CPPUNIT_ASSERT_EQUAL((off_t)1, bt.getOffsetCompletedLength(2048, 1)); + CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(2047, 1)); + CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(0, 1024*20)); + CPPUNIT_ASSERT_EQUAL((off_t)3072, bt.getOffsetCompletedLength(0, 1024*20+10)); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, bt.getOffsetCompletedLength(1024*20, 1)); + CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(1024*20, 1)); } void BitfieldManTest::testGetMissingUnusedLength() { - uint64_t totalLength = 1024*10+10; + off_t totalLength = 1024*10+10; size_t blockLength = 1024; BitfieldMan bf(blockLength, totalLength); @@ -482,30 +482,30 @@ void BitfieldManTest::testGetMissingUnusedLength() CPPUNIT_ASSERT_EQUAL(totalLength, bf.getMissingUnusedLength(0)); // from index 10 and all blocks are unused and not acquired. - CPPUNIT_ASSERT_EQUAL((uint64_t)10ULL, bf.getMissingUnusedLength(10)); + CPPUNIT_ASSERT_EQUAL((off_t)10ULL, bf.getMissingUnusedLength(10)); // from index 11 - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, bf.getMissingUnusedLength(11)); + CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(11)); // from index 12 - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, bf.getMissingUnusedLength(12)); + CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(12)); // from index 0 and 5th block is used. bf.setUseBit(5); - CPPUNIT_ASSERT_EQUAL((uint64_t)5ULL*blockLength, bf.getMissingUnusedLength(0)); + CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getMissingUnusedLength(0)); // from index 0 and 4th block is acquired. bf.setBit(4); - CPPUNIT_ASSERT_EQUAL((uint64_t)4ULL*blockLength, bf.getMissingUnusedLength(0)); + CPPUNIT_ASSERT_EQUAL((off_t)(4LL*blockLength), bf.getMissingUnusedLength(0)); // from index 1 - CPPUNIT_ASSERT_EQUAL((uint64_t)3ULL*blockLength, bf.getMissingUnusedLength(1)); + CPPUNIT_ASSERT_EQUAL((off_t)(3LL*blockLength), bf.getMissingUnusedLength(1)); } void BitfieldManTest::testSetBitRange() { size_t blockLength = 1024*1024; - uint64_t totalLength = 10*blockLength; + off_t totalLength = 10*blockLength; BitfieldMan bf(blockLength, totalLength); @@ -517,13 +517,13 @@ void BitfieldManTest::testSetBitRange() for(size_t i = 5; i < 10; ++i) { CPPUNIT_ASSERT(!bf.isBitSet(i)); } - CPPUNIT_ASSERT_EQUAL((uint64_t)5ULL*blockLength, bf.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getCompletedLength()); } void BitfieldManTest::testGetAllMissingIndexes_noarg() { size_t blockLength = 16*1024; - uint64_t totalLength = 1024*1024; + off_t totalLength = 1024*1024; size_t nbits = (totalLength+blockLength-1)/blockLength; BitfieldMan bf(blockLength, totalLength); unsigned char misbitfield[8]; @@ -542,7 +542,7 @@ void BitfieldManTest::testGetAllMissingIndexes_noarg() void BitfieldManTest::testGetAllMissingIndexes_checkLastByte() { size_t blockLength = 16*1024; - uint64_t totalLength = blockLength*2; + off_t totalLength = blockLength*2; size_t nbits = (totalLength+blockLength-1)/blockLength; BitfieldMan bf(blockLength, totalLength); unsigned char misbitfield[1]; @@ -555,7 +555,7 @@ void BitfieldManTest::testGetAllMissingIndexes_checkLastByte() void BitfieldManTest::testGetAllMissingIndexes() { size_t blockLength = 16*1024; - uint64_t totalLength = 1024*1024; + off_t totalLength = 1024*1024; size_t nbits = (totalLength+blockLength-1)/blockLength; BitfieldMan bf(blockLength, totalLength); BitfieldMan peerBf(blockLength, totalLength); @@ -581,7 +581,7 @@ void BitfieldManTest::testGetAllMissingIndexes() void BitfieldManTest::testGetAllMissingUnusedIndexes() { size_t blockLength = 16*1024; - uint64_t totalLength = 1024*1024; + off_t totalLength = 1024*1024; size_t nbits = (totalLength+blockLength-1)/blockLength; BitfieldMan bf(blockLength, totalLength); BitfieldMan peerBf(blockLength, totalLength); diff --git a/test/BittorrentHelperTest.cc b/test/BittorrentHelperTest.cc index 64428600..247d2113 100644 --- a/test/BittorrentHelperTest.cc +++ b/test/BittorrentHelperTest.cc @@ -205,14 +205,14 @@ void BittorrentHelperTest::testGetTotalLength() { SharedHandle<DownloadContext> dctx(new DownloadContext()); load(A2_TEST_DIR"/test.torrent", dctx, option_); - CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength()); } void BittorrentHelperTest::testGetTotalLengthSingle() { SharedHandle<DownloadContext> dctx(new DownloadContext()); load(A2_TEST_DIR"/single.torrent", dctx, option_); - CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength()); } void BittorrentHelperTest::testGetFileModeMulti() { diff --git a/test/ByteArrayDiskWriterTest.cc b/test/ByteArrayDiskWriterTest.cc index 002367c4..6630f970 100644 --- a/test/ByteArrayDiskWriterTest.cc +++ b/test/ByteArrayDiskWriterTest.cc @@ -43,7 +43,7 @@ void ByteArrayDiskWriterTest::testWriteAndRead() { buf[c] = '\0'; CPPUNIT_ASSERT_EQUAL(std::string("ello World !!"), std::string(buf)); - CPPUNIT_ASSERT_EQUAL((uint64_t)14, bw.size()); + CPPUNIT_ASSERT_EQUAL((off_t)14, bw.size()); } void ByteArrayDiskWriterTest::testWriteAndRead2() { @@ -59,7 +59,7 @@ void ByteArrayDiskWriterTest::testWriteAndRead2() { buf[c] = '\0'; CPPUNIT_ASSERT_EQUAL(std::string("Hello From Mars"), std::string(buf)); - CPPUNIT_ASSERT_EQUAL((uint64_t)15, bw.size()); + CPPUNIT_ASSERT_EQUAL((off_t)15, bw.size()); } } // namespace aria2 diff --git a/test/DefaultBtProgressInfoFileTest.cc b/test/DefaultBtProgressInfoFileTest.cc index 50dad43a..23f75ed8 100644 --- a/test/DefaultBtProgressInfoFileTest.cc +++ b/test/DefaultBtProgressInfoFileTest.cc @@ -53,7 +53,7 @@ private: SharedHandle<Option> option_; SharedHandle<BitfieldMan> bitfield_; public: - void initializeMembers(int32_t pieceLength, int64_t totalLength) + void initializeMembers(int32_t pieceLength, off_t totalLength) { option_.reset(new Option()); option_->put(PREF_DIR, A2_TEST_OUT_DIR); @@ -126,10 +126,10 @@ void DefaultBtProgressInfoFileTest::testLoad_compat() // check the contents of objects // total length - CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx_->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx_->getTotalLength()); // upload length - CPPUNIT_ASSERT_EQUAL((uint64_t)1024, btRuntime_->getUploadLengthAtStartup()); + CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup()); // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), @@ -175,10 +175,10 @@ void DefaultBtProgressInfoFileTest::testLoad() // check the contents of objects // total length - CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx_->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx_->getTotalLength()); // upload length - CPPUNIT_ASSERT_EQUAL((uint64_t)1024, btRuntime_->getUploadLengthAtStartup()); + CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup()); // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), @@ -343,7 +343,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt_compat() // check the contents of objects // total length - CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx->getTotalLength()); // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), @@ -388,7 +388,7 @@ void DefaultBtProgressInfoFileTest::testLoad_nonBt() // check the contents of objects // total length - CPPUNIT_ASSERT_EQUAL((uint64_t)81920, dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)81920, dctx->getTotalLength()); // bitfield CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"), diff --git a/test/DefaultDiskWriterTest.cc b/test/DefaultDiskWriterTest.cc index 2e1733c5..19b05936 100644 --- a/test/DefaultDiskWriterTest.cc +++ b/test/DefaultDiskWriterTest.cc @@ -25,7 +25,7 @@ void DefaultDiskWriterTest::testSize() DefaultDiskWriter dw(A2_TEST_DIR"/4096chunk.txt"); dw.enableReadOnly(); dw.openExistingFile(); - CPPUNIT_ASSERT_EQUAL((uint64_t)4096ULL, dw.size()); + CPPUNIT_ASSERT_EQUAL((off_t)4096LL, dw.size()); } } // namespace aria2 diff --git a/test/DefaultPieceStorageTest.cc b/test/DefaultPieceStorageTest.cc index 054d2598..f383c457 100644 --- a/test/DefaultPieceStorageTest.cc +++ b/test/DefaultPieceStorageTest.cc @@ -80,7 +80,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest); void DefaultPieceStorageTest::testGetTotalLength() { DefaultPieceStorage pss(dctx_, option_.get()); - CPPUNIT_ASSERT_EQUAL((uint64_t)384ULL, pss.getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)384LL, pss.getTotalLength()); } void DefaultPieceStorageTest::testGetMissingPiece() { @@ -220,15 +220,15 @@ void DefaultPieceStorageTest::testCompletePiece() { CPPUNIT_ASSERT_EQUAL(std::string("piece: index=0, length=128"), piece->toString()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, pss.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, pss.getCompletedLength()); pss.completePiece(piece); - CPPUNIT_ASSERT_EQUAL((uint64_t)128ULL, pss.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)128LL, pss.getCompletedLength()); SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer, 1); incompletePiece->completeBlock(0); - CPPUNIT_ASSERT_EQUAL((uint64_t)256ULL, pss.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)256LL, pss.getCompletedLength()); } void DefaultPieceStorageTest::testGetPiece() { @@ -264,7 +264,7 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() { void DefaultPieceStorageTest::testCancelPiece() { size_t pieceLength = 256*1024; - uint64_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM + off_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM std::deque<std::string> uris1; uris1.push_back("http://localhost/src/file1.txt"); SharedHandle<FileEntry> file1(new FileEntry("src/file1.txt", totalLength, 0 /*, uris1*/)); @@ -289,7 +289,7 @@ void DefaultPieceStorageTest::testCancelPiece() void DefaultPieceStorageTest::testMarkPiecesDone() { size_t pieceLength = 256*1024; - uint64_t totalLength = 4*1024*1024; + off_t totalLength = 4*1024*1024; SharedHandle<DownloadContext> dctx (new DownloadContext(pieceLength, totalLength)); @@ -303,7 +303,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone() for(size_t i = 10; i < (totalLength+pieceLength-1)/pieceLength; ++i) { CPPUNIT_ASSERT(!ps.hasPiece(i)); } - CPPUNIT_ASSERT_EQUAL((uint64_t)pieceLength*10+16*1024*2, ps.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)pieceLength*10+16*1024*2, ps.getCompletedLength()); ps.markPiecesDone(totalLength); @@ -312,7 +312,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone() } ps.markPiecesDone(0); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, ps.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength()); } void DefaultPieceStorageTest::testGetCompletedLength() @@ -322,10 +322,10 @@ void DefaultPieceStorageTest::testGetCompletedLength() DefaultPieceStorage ps(dctx, option_.get()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, ps.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength()); ps.markPiecesDone(250*1024*1024); - CPPUNIT_ASSERT_EQUAL((uint64_t)250*1024*1024, ps.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)250*1024*1024, ps.getCompletedLength()); std::vector<SharedHandle<Piece> > inFlightPieces; for(int i = 0; i < 2; ++i) { @@ -338,11 +338,11 @@ void DefaultPieceStorageTest::testGetCompletedLength() } ps.addInFlightPiece(inFlightPieces); - CPPUNIT_ASSERT_EQUAL((uint64_t)251*1024*1024, ps.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)251*1024*1024, ps.getCompletedLength()); ps.markPiecesDone(256*1024*1024); - CPPUNIT_ASSERT_EQUAL((uint64_t)256*1024*1024, ps.getCompletedLength()); + CPPUNIT_ASSERT_EQUAL((off_t)256*1024*1024, ps.getCompletedLength()); } void DefaultPieceStorageTest::testGetNextUsedIndex() diff --git a/test/DirectDiskAdaptorTest.cc b/test/DirectDiskAdaptorTest.cc index 164c66d4..5745c8d4 100644 --- a/test/DirectDiskAdaptorTest.cc +++ b/test/DirectDiskAdaptorTest.cc @@ -46,7 +46,7 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage() adaptor.cutTrailingGarbage(); - CPPUNIT_ASSERT_EQUAL((uint64_t)entry->getLength(), + CPPUNIT_ASSERT_EQUAL((off_t)entry->getLength(), File(entry->getPath()).size()); } diff --git a/test/FtpConnectionTest.cc b/test/FtpConnectionTest.cc index 7675ac30..501427bc 100644 --- a/test/FtpConnectionTest.cc +++ b/test/FtpConnectionTest.cc @@ -287,9 +287,9 @@ void FtpConnectionTest::testReceiveSizeResponse() { serverSocket_->writeData("213 4294967296\r\n"); waitRead(clientSocket_); - uint64_t size; + off_t size; CPPUNIT_ASSERT_EQUAL((unsigned int)213, ftp_->receiveSizeResponse(size)); - CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296LL, size); + CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, size); } void FtpConnectionTest::testSendRetr() diff --git a/test/HandshakeExtensionMessageTest.cc b/test/HandshakeExtensionMessageTest.cc index 52eb888d..4d7941bf 100644 --- a/test/HandshakeExtensionMessageTest.cc +++ b/test/HandshakeExtensionMessageTest.cc @@ -119,7 +119,7 @@ void HandshakeExtensionMessageTest::testDoReceivedAction() CPPUNIT_ASSERT_EQUAL((uint8_t)2, peer->getExtensionMessageID("a2_dht")); CPPUNIT_ASSERT(peer->isSeeder()); CPPUNIT_ASSERT_EQUAL((size_t)1024, attrs->metadataSize); - CPPUNIT_ASSERT_EQUAL((uint64_t)1024, dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)1024, dctx->getTotalLength()); CPPUNIT_ASSERT(dctx->knowsTotalLength()); // See Peer is not marked as seeder if !attrs->metadata.empty() diff --git a/test/HttpHeaderProcessorTest.cc b/test/HttpHeaderProcessorTest.cc index 162f59aa..ad41b955 100644 --- a/test/HttpHeaderProcessorTest.cc +++ b/test/HttpHeaderProcessorTest.cc @@ -117,8 +117,8 @@ void HttpHeaderProcessorTest::testGetHttpResponseHeader() header->find("date")); CPPUNIT_ASSERT_EQUAL(std::string("Apache/2.2.3 (Debian)"), header->find("server")); - CPPUNIT_ASSERT_EQUAL((uint64_t)9187ULL, - header->findAsULLInt("content-length")); + CPPUNIT_ASSERT_EQUAL((int64_t)9187LL, + header->findAsLLInt("content-length")); CPPUNIT_ASSERT_EQUAL(std::string("text/html; charset=UTF-8"), header->find("content-type")); CPPUNIT_ASSERT(!header->defined("entity")); diff --git a/test/HttpHeaderTest.cc b/test/HttpHeaderTest.cc index fc31cf04..690f3818 100644 --- a/test/HttpHeaderTest.cc +++ b/test/HttpHeaderTest.cc @@ -37,7 +37,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength()); } { HttpHeader httpHeader; @@ -48,7 +48,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength()); } { HttpHeader httpHeader; @@ -58,7 +58,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength()); } { HttpHeader httpHeader; @@ -68,7 +68,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength()); } { HttpHeader httpHeader; @@ -78,7 +78,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength()); } { HttpHeader httpHeader; @@ -88,7 +88,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength()); } { HttpHeader httpHeader; @@ -98,7 +98,7 @@ void HttpHeaderTest::testGetRange() CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte()); CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0, range->getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength()); } { HttpHeader httpHeader; diff --git a/test/HttpResponseTest.cc b/test/HttpResponseTest.cc index 482ba66c..a5c8d7ed 100644 --- a/test/HttpResponseTest.cc +++ b/test/HttpResponseTest.cc @@ -101,7 +101,7 @@ void HttpResponseTest::testGetContentLength_null() { HttpResponse httpResponse; - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, httpResponse.getContentLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpResponse.getContentLength()); } void HttpResponseTest::testGetContentLength_contentLength() @@ -113,7 +113,7 @@ void HttpResponseTest::testGetContentLength_contentLength() httpResponse.setHttpHeader(httpHeader); - CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296ULL, httpResponse.getContentLength()); + CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getContentLength()); } void HttpResponseTest::testGetEntityLength() @@ -125,11 +125,11 @@ void HttpResponseTest::testGetEntityLength() httpResponse.setHttpHeader(httpHeader); - CPPUNIT_ASSERT_EQUAL((uint64_t)4294967296ULL, httpResponse.getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getEntityLength()); httpHeader->put("content-range", "bytes 1-4294967296/4294967297"); - CPPUNIT_ASSERT_EQUAL((uint64_t)4294967297ULL, httpResponse.getEntityLength()); + CPPUNIT_ASSERT_EQUAL((off_t)4294967297LL, httpResponse.getEntityLength()); } diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc index a69df183..f38339a6 100644 --- a/test/Metalink2RequestGroupTest.cc +++ b/test/Metalink2RequestGroupTest.cc @@ -58,7 +58,7 @@ void Metalink2RequestGroupTest::testGenerate() const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext(); CPPUNIT_ASSERT(dctx); - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, dctx->getTotalLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, dctx->getTotalLength()); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType()); CPPUNIT_ASSERT_EQUAL diff --git a/test/MetalinkParserControllerTest.cc b/test/MetalinkParserControllerTest.cc index 1b1747b0..dea69f7d 100644 --- a/test/MetalinkParserControllerTest.cc +++ b/test/MetalinkParserControllerTest.cc @@ -68,7 +68,7 @@ void MetalinkParserControllerTest::testEntryTransaction() CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); SharedHandle<MetalinkEntry> e = m->getEntries().front(); CPPUNIT_ASSERT_EQUAL(std::string("aria2.tar.bz2"), e->file->getPath()); - CPPUNIT_ASSERT_EQUAL((uint64_t)(1024*1024ULL), e->file->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)(1024*1024LL), e->file->getLength()); CPPUNIT_ASSERT_EQUAL((off_t)0, e->file->getOffset()); CPPUNIT_ASSERT_EQUAL(std::string("1.0"), e->version); CPPUNIT_ASSERT_EQUAL(std::string("ja_JP"), e->languages[0]); diff --git a/test/MetalinkProcessorTest.cc b/test/MetalinkProcessorTest.cc index 26c9492f..7110a3b9 100644 --- a/test/MetalinkProcessorTest.cc +++ b/test/MetalinkProcessorTest.cc @@ -89,7 +89,7 @@ void MetalinkProcessorTest::testParseFileV4() CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); e = m->getEntries()[0]; CPPUNIT_ASSERT_EQUAL(std::string("example.ext"), e->getPath()); - CPPUNIT_ASSERT_EQUAL((uint64_t)786430LL, e->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)786430LL, e->getLength()); CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), @@ -500,7 +500,7 @@ void MetalinkProcessorTest::testParseFile() SharedHandle<MetalinkEntry> entry1 = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), entry1->getPath()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, entry1->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, entry1->getLength()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), entry1->version); CPPUNIT_ASSERT_EQUAL(std::string("en-US"), entry1->languages[0]); CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), entry1->oses[0]); @@ -550,7 +550,7 @@ void MetalinkProcessorTest::testParseFile() SharedHandle<MetalinkEntry> entry2 = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.1.tar.bz2"), entry2->getPath()); - CPPUNIT_ASSERT_EQUAL((uint64_t)345689ULL, entry2->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)345689LL, entry2->getLength()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.1"), entry2->version); CPPUNIT_ASSERT_EQUAL(std::string("ja-JP"), entry2->languages[0]); CPPUNIT_ASSERT_EQUAL(std::string("Linux-m68k"), entry2->oses[0]); @@ -697,7 +697,7 @@ void MetalinkProcessorTest::testBadSize() m->getEntries().begin(); SharedHandle<MetalinkEntry> e = *entryItr; CPPUNIT_ASSERT_EQUAL(std::string("aria2-0.5.2.tar.bz2"), e->getPath()); - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, e->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, e->getLength()); CPPUNIT_ASSERT_EQUAL(std::string("0.5.2"), e->version); CPPUNIT_ASSERT_EQUAL(std::string("en-US"), e->languages[0]); CPPUNIT_ASSERT_EQUAL(std::string("Linux-x86"), e->oses[0]); @@ -728,7 +728,7 @@ void MetalinkProcessorTest::testBadMaxConn() std::vector<SharedHandle<MetalinkEntry> >::const_iterator entryItr = m->getEntries().begin(); SharedHandle<MetalinkEntry> e = *entryItr; - CPPUNIT_ASSERT_EQUAL((uint64_t)43743838ULL, e->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)43743838LL, e->getLength()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); } @@ -1008,7 +1008,7 @@ void MetalinkProcessorTest::testLargeFileSize() try { SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw); SharedHandle<MetalinkEntry> e = m->getEntries()[0]; - CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, e->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, e->getLength()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); } @@ -1032,7 +1032,7 @@ void MetalinkProcessorTest::testXmlPrefixV3() SharedHandle<Metalinker> m = metalink::parseBinaryStream(&dw); CPPUNIT_ASSERT_EQUAL((size_t)1, m->getEntries().size()); SharedHandle<MetalinkEntry> e = m->getEntries()[0]; - CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807ULL, e->getLength()); + CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, e->getLength()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); } diff --git a/test/MockPieceStorage.h b/test/MockPieceStorage.h index 8b1cb631..36e64b00 100644 --- a/test/MockPieceStorage.h +++ b/test/MockPieceStorage.h @@ -13,10 +13,10 @@ namespace aria2 { class MockPieceStorage : public PieceStorage { private: - uint64_t totalLength; - uint64_t filteredTotalLength; - uint64_t completedLength; - uint64_t filteredCompletedLength; + off_t totalLength; + off_t filteredTotalLength; + off_t completedLength; + off_t filteredCompletedLength; BitfieldMan* bitfieldMan; bool selectiveDownloadingMode; bool endGame; @@ -117,7 +117,7 @@ public: virtual void markPieceMissing(size_t index) {} - virtual void markPiecesDone(uint64_t) {} + virtual void markPiecesDone(off_t) {} virtual SharedHandle<Piece> getPiece(size_t index) { return SharedHandle<Piece>(new Piece()); @@ -131,35 +131,35 @@ public: return false; } - virtual uint64_t getTotalLength() { + virtual off_t getTotalLength() { return totalLength; } - void setTotalLength(uint64_t totalLength) { + void setTotalLength(off_t totalLength) { this->totalLength = totalLength; } - virtual uint64_t getFilteredTotalLength() { + virtual off_t getFilteredTotalLength() { return filteredTotalLength; } - void setFilteredTotalLength(uint64_t totalLength) { + void setFilteredTotalLength(off_t totalLength) { this->filteredTotalLength = totalLength; } - virtual uint64_t getCompletedLength() { + virtual off_t getCompletedLength() { return completedLength; } - void setCompletedLength(uint64_t completedLength) { + void setCompletedLength(off_t completedLength) { this->completedLength = completedLength; } - virtual uint64_t getFilteredCompletedLength() { + virtual off_t getFilteredCompletedLength() { return filteredCompletedLength; } - void setFilteredCompletedLength(uint64_t completedLength) { + void setFilteredCompletedLength(off_t completedLength) { this->filteredCompletedLength = completedLength; } diff --git a/test/MultiDiskAdaptorTest.cc b/test/MultiDiskAdaptorTest.cc index 7a7ae1e5..bf4473b9 100644 --- a/test/MultiDiskAdaptorTest.cc +++ b/test/MultiDiskAdaptorTest.cc @@ -386,9 +386,9 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage() adaptor.cutTrailingGarbage(); - CPPUNIT_ASSERT_EQUAL((uint64_t)256, + CPPUNIT_ASSERT_EQUAL((off_t)256, File(entries[0]->getPath()).size()); - CPPUNIT_ASSERT_EQUAL((uint64_t)512, + CPPUNIT_ASSERT_EQUAL((off_t)512, File(entries[1]->getPath()).size()); } @@ -413,7 +413,7 @@ void MultiDiskAdaptorTest::testSize() adaptor.openFile(); - CPPUNIT_ASSERT_EQUAL((uint64_t)2, adaptor.size()); + CPPUNIT_ASSERT_EQUAL((off_t)2, adaptor.size()); } void MultiDiskAdaptorTest::testUtime() diff --git a/test/MultiFileAllocationIteratorTest.cc b/test/MultiFileAllocationIteratorTest.cc index 9d5aaf62..03237451 100644 --- a/test/MultiFileAllocationIteratorTest.cc +++ b/test/MultiFileAllocationIteratorTest.cc @@ -209,11 +209,11 @@ void MultiFileAllocationIteratorTest::testAllocate() while(!itr->finished()) { itr->allocateChunk(); } - CPPUNIT_ASSERT_EQUAL((uint64_t)length1, File(fileEntry1->getPath()).size()); - CPPUNIT_ASSERT_EQUAL((uint64_t)length2, File(fileEntry2->getPath()).size()); - CPPUNIT_ASSERT_EQUAL((uint64_t)length3, File(fileEntry3->getPath()).size()); + CPPUNIT_ASSERT_EQUAL((off_t)length1, File(fileEntry1->getPath()).size()); + CPPUNIT_ASSERT_EQUAL((off_t)length2, File(fileEntry2->getPath()).size()); + CPPUNIT_ASSERT_EQUAL((off_t)length3, File(fileEntry3->getPath()).size()); CPPUNIT_ASSERT(!File(fileEntry4->getPath()).isFile()); - CPPUNIT_ASSERT_EQUAL((uint64_t)length5, File(fileEntry5->getPath()).size()); + CPPUNIT_ASSERT_EQUAL((off_t)length5, File(fileEntry5->getPath()).size()); CPPUNIT_ASSERT(!File(fileEntry6->getPath()).isFile()); } catch(Exception& e) { CPPUNIT_FAIL(e.stackTrace()); diff --git a/test/PeerSessionResourceTest.cc b/test/PeerSessionResourceTest.cc index ff7c2fcf..1ced80ac 100644 --- a/test/PeerSessionResourceTest.cc +++ b/test/PeerSessionResourceTest.cc @@ -106,20 +106,20 @@ void PeerSessionResourceTest::testUpdateUploadLength() { PeerSessionResource res(1024, 1024*1024); - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, res.uploadLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.uploadLength()); res.updateUploadLength(100); res.updateUploadLength(200); - CPPUNIT_ASSERT_EQUAL((uint64_t)300ULL, res.uploadLength()); + CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.uploadLength()); } void PeerSessionResourceTest::testUpdateDownloadLength() { PeerSessionResource res(1024, 1024*1024); - CPPUNIT_ASSERT_EQUAL((uint64_t)0ULL, res.downloadLength()); + CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.downloadLength()); res.updateDownloadLength(100); res.updateDownloadLength(200); - CPPUNIT_ASSERT_EQUAL((uint64_t)300ULL, res.downloadLength()); + CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.downloadLength()); } void PeerSessionResourceTest::testExtendedMessageEnabled() diff --git a/test/SingleFileAllocationIteratorTest.cc b/test/SingleFileAllocationIteratorTest.cc index 04387a19..ace14d9f 100644 --- a/test/SingleFileAllocationIteratorTest.cc +++ b/test/SingleFileAllocationIteratorTest.cc @@ -32,11 +32,11 @@ void SingleFileAllocationIteratorTest::testAllocate() of.close(); File x(fn); - CPPUNIT_ASSERT_EQUAL((uint64_t)10, x.size()); + CPPUNIT_ASSERT_EQUAL((off_t)10, x.size()); DefaultDiskWriter writer(fn); - int64_t offset = 10; - int64_t totalLength = 16*1024*2+8*1024; + off_t offset = 10; + off_t totalLength = 16*1024*2+8*1024; // we have to open file first. writer.openExistingFile(); @@ -47,7 +47,7 @@ void SingleFileAllocationIteratorTest::testAllocate() itr.allocateChunk(); } File f(fn); - CPPUNIT_ASSERT_EQUAL((uint64_t)40960, f.size()); + CPPUNIT_ASSERT_EQUAL((off_t)40960, f.size()); } } // namespace aria2 diff --git a/test/UtilTest.cc b/test/UtilTest.cc index 5f3c99b5..cb04d27c 100644 --- a/test/UtilTest.cc +++ b/test/UtilTest.cc @@ -60,7 +60,6 @@ class UtilTest:public CppUnit::TestFixture { CPPUNIT_TEST(testParseInt); CPPUNIT_TEST(testParseUInt); CPPUNIT_TEST(testParseLLInt); - CPPUNIT_TEST(testParseULLInt); CPPUNIT_TEST(testParseIntNoThrow); CPPUNIT_TEST(testParseUIntNoThrow); CPPUNIT_TEST(testParseLLIntNoThrow); @@ -132,7 +131,6 @@ public: void testParseInt(); void testParseUInt(); void testParseLLInt(); - void testParseULLInt(); void testParseIntNoThrow(); void testParseUIntNoThrow(); void testParseLLIntNoThrow(); @@ -1345,26 +1343,6 @@ void UtilTest::testParseLLInt() } } -void UtilTest::testParseULLInt() -{ - std::string s; - s = "9223372036854775807"; - CPPUNIT_ASSERT_EQUAL((uint64_t)9223372036854775807LL, - util::parseULLInt(s)); - try { - s = "-1"; - util::parseULLInt(s); - CPPUNIT_FAIL("exception must be thrown."); - } catch(Exception& e) { - } - try { - s = "9223372036854775808"; - util::parseULLInt(s); - CPPUNIT_FAIL("exception must be thrown."); - } catch(Exception& e) { - } -} - void UtilTest::testParseIntNoThrow() { std::string s; |