From 860f4dd06ace859470e118d4b9a8d10ddf92d076 Mon Sep 17 00:00:00 2001 From: Tatsuhiro Tsujikawa Date: Mon, 23 Jul 2012 21:36:24 +0900 Subject: [PATCH] Use int64_t instead of off_t Using off_t, at least, in DiskAdaptor layer is problematic because torrent can contain under 2GiB files but total sum of those files may exceed 2GiB limit, which makes off_t overflow in 32 bit system without large file support. So we use int64_t in API. We'll check the file length before download so that it does not exceed max off_t. --- src/AbstractDiskWriter.cc | 28 +++++++++---------- src/AbstractDiskWriter.h | 24 ++++++++--------- src/AbstractSingleDiskAdaptor.cc | 10 +++---- src/AbstractSingleDiskAdaptor.h | 14 +++++----- src/AdaptiveFileAllocationIterator.cc | 9 ++++--- src/AdaptiveFileAllocationIterator.h | 10 +++---- src/BinaryStream.h | 9 ++++--- src/BtPieceMessage.cc | 15 ++++++----- src/BtPieceMessage.h | 2 +- src/ByteArrayDiskWriter.cc | 26 +++++++++--------- src/ByteArrayDiskWriter.h | 12 ++++----- src/CheckIntegrityEntry.cc | 4 +-- src/CheckIntegrityEntry.h | 4 +-- src/DefaultDiskWriter.cc | 2 +- src/DefaultDiskWriter.h | 2 +- src/DiskAdaptor.h | 2 +- src/DiskWriter.h | 8 +++--- src/ExpatXmlParser.cc | 2 +- src/FallocFileAllocationIterator.cc | 6 ++--- src/FallocFileAllocationIterator.h | 12 ++++----- src/FileAllocationEntry.cc | 4 +-- src/FileAllocationEntry.h | 4 +-- src/FileAllocationIterator.h | 4 +-- src/IteratableChecksumValidator.cc | 2 +- src/IteratableChecksumValidator.h | 6 ++--- src/IteratableChunkChecksumValidator.cc | 14 +++++----- src/IteratableChunkChecksumValidator.h | 6 ++--- src/IteratableValidator.h | 4 +-- src/JsonDiskWriter.cc | 4 +-- src/JsonDiskWriter.h | 12 ++++----- src/MultiDiskAdaptor.cc | 34 ++++++++++++------------ src/MultiDiskAdaptor.h | 8 +++--- src/MultiFileAllocationIterator.cc | 4 +-- src/MultiFileAllocationIterator.h | 6 ++--- src/ProgressAwareEntry.h | 4 +-- src/ShareRatioSeedCriteria.cc | 2 +- src/SingleFileAllocationIterator.cc | 4 +-- src/SingleFileAllocationIterator.h | 12 ++++----- src/XmlRpcDiskWriter.cc | 4 +-- src/XmlRpcDiskWriter.h | 12 ++++----- src/bittorrent_helper.cc | 2 +- src/message_digest_helper.cc | 4 +-- src/message_digest_helper.h | 4 +-- src/metalink_helper.cc | 2 +- test/ByteArrayDiskWriterTest.cc | 4 +-- test/DefaultDiskWriterTest.cc | 2 +- test/MultiDiskAdaptorTest.cc | 2 +- test/SingleFileAllocationIteratorTest.cc | 4 +-- 48 files changed, 191 insertions(+), 184 deletions(-) diff --git a/src/AbstractDiskWriter.cc b/src/AbstractDiskWriter.cc index 1e4a66e4..af3fd526 100644 --- a/src/AbstractDiskWriter.cc +++ b/src/AbstractDiskWriter.cc @@ -69,7 +69,7 @@ AbstractDiskWriter::~AbstractDiskWriter() closeFile(); } -void AbstractDiskWriter::openFile(off_t totalLength) +void AbstractDiskWriter::openFile(int64_t totalLength) { try { openExistingFile(totalLength); @@ -104,7 +104,7 @@ void AbstractDiskWriter::closeFile() } } -void AbstractDiskWriter::openExistingFile(off_t totalLength) +void AbstractDiskWriter::openExistingFile(int64_t totalLength) { int flags = O_BINARY; if(readOnly_) { @@ -146,7 +146,7 @@ void AbstractDiskWriter::createFile(int addFlags) } ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, - size_t len, off_t offset) + size_t len, int64_t offset) { if(mapaddr_) { memcpy(mapaddr_ + offset, data, len); @@ -168,7 +168,7 @@ ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, } ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len, - off_t offset) + int64_t offset) { if(mapaddr_) { ssize_t readlen; @@ -187,7 +187,7 @@ ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len, } } -void AbstractDiskWriter::seek(off_t offset) +void AbstractDiskWriter::seek(int64_t offset) { if(a2lseek(fd_, offset, SEEK_SET) == (off_t)-1) { int errNum = errno; @@ -198,20 +198,20 @@ void AbstractDiskWriter::seek(off_t offset) } } -void AbstractDiskWriter::ensureMmapWrite(size_t len, off_t offset) +void AbstractDiskWriter::ensureMmapWrite(size_t len, int64_t offset) { #ifdef HAVE_MMAP if(enableMmap_) { if(mapaddr_) { - if(static_cast(len + offset) > maplen_) { + if(static_cast(len + offset) > maplen_) { munmap(mapaddr_, maplen_); mapaddr_ = 0; maplen_ = 0; enableMmap_ = false; } } else { - off_t filesize = size(); - if(static_cast(len + offset) <= filesize) { + int64_t filesize = size(); + if(static_cast(len + offset) <= filesize) { mapaddr_ = reinterpret_cast (mmap(0, size(), PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0)); if(mapaddr_) { @@ -231,7 +231,7 @@ void AbstractDiskWriter::ensureMmapWrite(size_t len, off_t offset) #endif // HAVE_MMAP } -void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, off_t offset) +void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, int64_t offset) { ensureMmapWrite(len, offset); if(writeDataInternal(data, len, offset) < 0) { @@ -256,7 +256,7 @@ void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, off_t } } -ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offset) +ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, int64_t offset) { ssize_t ret; if((ret = readDataInternal(data, len, offset)) < 0) { @@ -271,7 +271,7 @@ ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offs return ret; } -void AbstractDiskWriter::truncate(off_t length) +void AbstractDiskWriter::truncate(int64_t length) { if(fd_ == -1) { throw DL_ABORT_EX("File not opened."); @@ -297,7 +297,7 @@ void AbstractDiskWriter::truncate(off_t length) #endif } -void AbstractDiskWriter::allocate(off_t offset, off_t length) +void AbstractDiskWriter::allocate(int64_t offset, int64_t length) { #ifdef HAVE_SOME_FALLOCATE if(fd_ == -1) { @@ -346,7 +346,7 @@ void AbstractDiskWriter::allocate(off_t offset, off_t length) #endif // HAVE_SOME_FALLOCATE } -off_t AbstractDiskWriter::size() +int64_t AbstractDiskWriter::size() { return File(filename_).size(); } diff --git a/src/AbstractDiskWriter.h b/src/AbstractDiskWriter.h index ee177f7c..8ba9292c 100644 --- a/src/AbstractDiskWriter.h +++ b/src/AbstractDiskWriter.h @@ -49,37 +49,37 @@ private: bool enableMmap_; unsigned char* mapaddr_; - off_t maplen_; + int64_t maplen_; ssize_t writeDataInternal(const unsigned char* data, size_t len, - off_t offset); - ssize_t readDataInternal(unsigned char* data, size_t len, off_t offset); + int64_t offset); + ssize_t readDataInternal(unsigned char* data, size_t len, int64_t offset); - void seek(off_t offset); + void seek(int64_t offset); - void ensureMmapWrite(size_t len, off_t offset); + void ensureMmapWrite(size_t len, int64_t offset); protected: void createFile(int addFlags = 0); public: AbstractDiskWriter(const std::string& filename); virtual ~AbstractDiskWriter(); - virtual void openFile(off_t totalLength = 0); + virtual void openFile(int64_t totalLength = 0); virtual void closeFile(); - virtual void openExistingFile(off_t totalLength = 0); + virtual void openExistingFile(int64_t totalLength = 0); - virtual void writeData(const unsigned char* data, size_t len, off_t offset); + virtual void writeData(const unsigned char* data, size_t len, int64_t offset); - virtual ssize_t readData(unsigned char* data, size_t len, off_t offset); + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset); - virtual void truncate(off_t length); + virtual void truncate(int64_t length); // File must be opened before calling this function. - virtual void allocate(off_t offset, off_t length); + virtual void allocate(int64_t offset, int64_t length); - virtual off_t size(); + virtual int64_t size(); virtual void enableReadOnly(); diff --git a/src/AbstractSingleDiskAdaptor.cc b/src/AbstractSingleDiskAdaptor.cc index 34ee4b9d..a6d23d74 100644 --- a/src/AbstractSingleDiskAdaptor.cc +++ b/src/AbstractSingleDiskAdaptor.cc @@ -69,13 +69,13 @@ void AbstractSingleDiskAdaptor::openExistingFile() } void AbstractSingleDiskAdaptor::writeData -(const unsigned char* data, size_t len, off_t offset) +(const unsigned char* data, size_t len, int64_t offset) { diskWriter_->writeData(data, len, offset); } ssize_t AbstractSingleDiskAdaptor::readData -(unsigned char* data, size_t len, off_t offset) +(unsigned char* data, size_t len, int64_t offset) { return diskWriter_->readData(data, len, offset); } @@ -85,12 +85,12 @@ bool AbstractSingleDiskAdaptor::fileExists() return File(getFilePath()).exists(); } -off_t AbstractSingleDiskAdaptor::size() +int64_t AbstractSingleDiskAdaptor::size() { return File(getFilePath()).size(); } -void AbstractSingleDiskAdaptor::truncate(off_t length) +void AbstractSingleDiskAdaptor::truncate(int64_t length) { diskWriter_->truncate(length); } @@ -144,7 +144,7 @@ void AbstractSingleDiskAdaptor::setDiskWriter diskWriter_ = diskWriter; } -void AbstractSingleDiskAdaptor::setTotalLength(const off_t& totalLength) +void AbstractSingleDiskAdaptor::setTotalLength(int64_t totalLength) { totalLength_ = totalLength; } diff --git a/src/AbstractSingleDiskAdaptor.h b/src/AbstractSingleDiskAdaptor.h index dc6f1eff..172b87b0 100644 --- a/src/AbstractSingleDiskAdaptor.h +++ b/src/AbstractSingleDiskAdaptor.h @@ -45,7 +45,7 @@ class FileAllocationIterator; class AbstractSingleDiskAdaptor : public DiskAdaptor { private: SharedHandle diskWriter_; - off_t totalLength_; + int64_t totalLength_; bool readOnly_; public: AbstractSingleDiskAdaptor(); @@ -61,15 +61,15 @@ public: virtual void openExistingFile(); virtual void writeData(const unsigned char* data, size_t len, - off_t offset); + int64_t offset); - virtual ssize_t readData(unsigned char* data, size_t len, off_t offset); + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset); virtual bool fileExists(); - virtual off_t size(); + virtual int64_t size(); - virtual void truncate(off_t length); + virtual void truncate(int64_t length); virtual SharedHandle fileAllocationIterator(); @@ -94,9 +94,9 @@ public: return diskWriter_; } - void setTotalLength(const off_t& totalLength); + void setTotalLength(int64_t totalLength); - off_t getTotalLength() const + int64_t getTotalLength() const { return totalLength_; } diff --git a/src/AdaptiveFileAllocationIterator.cc b/src/AdaptiveFileAllocationIterator.cc index a96c9f4a..c343af1e 100644 --- a/src/AdaptiveFileAllocationIterator.cc +++ b/src/AdaptiveFileAllocationIterator.cc @@ -45,7 +45,7 @@ namespace aria2 { AdaptiveFileAllocationIterator::AdaptiveFileAllocationIterator -(BinaryStream* stream, off_t offset, off_t totalLength) +(BinaryStream* stream, int64_t offset, int64_t totalLength) : stream_(stream), offset_(offset), totalLength_(totalLength) @@ -60,7 +60,8 @@ void AdaptiveFileAllocationIterator::allocateChunk() try { A2_LOG_DEBUG("Testing file system supports fallocate."); if(offset_ < totalLength_) { - off_t len = std::min(totalLength_-offset_, static_cast(4096)); + int64_t len = std::min(totalLength_-offset_, + static_cast(4096)); stream_->allocate(offset_, len); offset_ += len; } @@ -95,7 +96,7 @@ bool AdaptiveFileAllocationIterator::finished() } } -off_t AdaptiveFileAllocationIterator::getCurrentLength() +int64_t AdaptiveFileAllocationIterator::getCurrentLength() { if(!allocator_) { return offset_; @@ -104,7 +105,7 @@ off_t AdaptiveFileAllocationIterator::getCurrentLength() } } -off_t AdaptiveFileAllocationIterator::getTotalLength() +int64_t AdaptiveFileAllocationIterator::getTotalLength() { return totalLength_; } diff --git a/src/AdaptiveFileAllocationIterator.h b/src/AdaptiveFileAllocationIterator.h index 36217e6f..4ad4b210 100644 --- a/src/AdaptiveFileAllocationIterator.h +++ b/src/AdaptiveFileAllocationIterator.h @@ -48,12 +48,12 @@ private: BinaryStream* stream_; - off_t offset_; + int64_t offset_; - off_t totalLength_; + int64_t totalLength_; public: AdaptiveFileAllocationIterator - (BinaryStream* stream, off_t offset, off_t totalLength); + (BinaryStream* stream, int64_t offset, int64_t totalLength); virtual ~AdaptiveFileAllocationIterator(); @@ -61,9 +61,9 @@ public: virtual bool finished(); - virtual off_t getCurrentLength(); + virtual int64_t getCurrentLength(); - virtual off_t getTotalLength(); + virtual int64_t getTotalLength(); }; } // namespace aria2 diff --git a/src/BinaryStream.h b/src/BinaryStream.h index bb7853a5..585fa5e9 100644 --- a/src/BinaryStream.h +++ b/src/BinaryStream.h @@ -47,17 +47,18 @@ class BinaryStream { public: virtual ~BinaryStream() {} - virtual void writeData(const unsigned char* data, size_t len, off_t offset) = 0; + virtual void writeData(const unsigned char* data, size_t len, + int64_t offset) = 0; - virtual ssize_t readData(unsigned char* data, size_t len, off_t offset) = 0; + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset) = 0; // Truncates a file to given length. The default implementation does // nothing. - virtual void truncate(off_t length) {} + virtual void truncate(int64_t length) {} // Allocates given length bytes of disk space from given offset. The // default implementation does nothing. - virtual void allocate(off_t offset, off_t length) {} + virtual void allocate(int64_t offset, int64_t length) {} }; typedef SharedHandle BinaryStreamHandle; diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc index 80a67541..50afd684 100644 --- a/src/BtPieceMessage.cc +++ b/src/BtPieceMessage.cc @@ -103,7 +103,8 @@ void BtPieceMessage::doReceivedAction() if(!RequestSlot::isNull(slot)) { getPeer()->snubbing(false); SharedHandle piece = getPieceStorage()->getPiece(index_); - off_t offset = (off_t)index_*downloadContext_->getPieceLength()+begin_; + int64_t offset = + static_cast(index_)*downloadContext_->getPieceLength()+begin_; A2_LOG_DEBUG(fmt(MSG_PIECE_RECEIVED, getCuid(), static_cast(index_), @@ -181,8 +182,8 @@ void BtPieceMessage::send() A2_LOG_DEBUG(fmt("msglength = %lu bytes", static_cast(msgHdrLen+blockLength_))); getPeerConnection()->pushBytes(msgHdr, msgHdrLen); - off_t pieceDataOffset = - (off_t)index_*downloadContext_->getPieceLength()+begin_; + int64_t pieceDataOffset = + static_cast(index_)*downloadContext_->getPieceLength()+begin_; pushPieceData(pieceDataOffset, blockLength_); } writtenLength = getPeerConnection()->sendPendingData(); @@ -190,7 +191,7 @@ void BtPieceMessage::send() setSendingInProgress(!getPeerConnection()->sendBufferIsEmpty()); } -void BtPieceMessage::pushPieceData(off_t offset, int32_t length) const +void BtPieceMessage::pushPieceData(int64_t offset, int32_t length) const { assert(length <= 16*1024); unsigned char* buf = new unsigned char[length]; @@ -224,7 +225,8 @@ bool BtPieceMessage::checkPieceHash(const SharedHandle& piece) return piece->getDigest() == downloadContext_->getPieceHash(piece->getIndex()); } else { - off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength(); + int64_t offset = static_cast(piece->getIndex()) + *downloadContext_->getPieceLength(); return message_digest::staticSHA1Digest (getPieceStorage()->getDiskAdaptor(), offset, piece->getLength()) == downloadContext_->getPieceHash(piece->getIndex()); @@ -256,7 +258,8 @@ void BtPieceMessage::erasePieceOnDisk(const SharedHandle& piece) size_t BUFSIZE = 4096; unsigned char buf[BUFSIZE]; memset(buf, 0, BUFSIZE); - off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength(); + int64_t offset = + static_cast(piece->getIndex())*downloadContext_->getPieceLength(); div_t res = div(piece->getLength(), BUFSIZE); for(int i = 0; i < res.quot; ++i) { getPieceStorage()->getDiskAdaptor()->writeData(buf, BUFSIZE, offset); diff --git a/src/BtPieceMessage.h b/src/BtPieceMessage.h index f9756f9b..fb6ca213 100644 --- a/src/BtPieceMessage.h +++ b/src/BtPieceMessage.h @@ -65,7 +65,7 @@ private: void erasePieceOnDisk(const SharedHandle& piece); - void pushPieceData(off_t offset, int32_t length) const; + void pushPieceData(int64_t offset, int32_t length) const; public: BtPieceMessage(size_t index = 0, int32_t begin = 0, int32_t blockLength = 0); diff --git a/src/ByteArrayDiskWriter.cc b/src/ByteArrayDiskWriter.cc index e83a573a..8f638dff 100644 --- a/src/ByteArrayDiskWriter.cc +++ b/src/ByteArrayDiskWriter.cc @@ -50,47 +50,49 @@ void ByteArrayDiskWriter::clear() buf_.str(A2STR::NIL); } -void ByteArrayDiskWriter::initAndOpenFile(off_t totalLength) +void ByteArrayDiskWriter::initAndOpenFile(int64_t totalLength) { clear(); } -void ByteArrayDiskWriter::openFile(off_t totalLength) {} +void ByteArrayDiskWriter::openFile(int64_t totalLength) {} void ByteArrayDiskWriter::closeFile() {} -void ByteArrayDiskWriter::openExistingFile(off_t totalLength) +void ByteArrayDiskWriter::openExistingFile(int64_t totalLength) { openFile(); } -void ByteArrayDiskWriter::writeData(const unsigned char* data, size_t dataLength, off_t position) +void ByteArrayDiskWriter::writeData(const unsigned char* data, + size_t dataLength, int64_t offset) { - if(position+dataLength > maxLength_) { + if(offset+dataLength > maxLength_) { throw DL_ABORT_EX(fmt("Maximum length(%lu) exceeded.", static_cast(maxLength_))); } - off_t length = size(); - if(length < position) { + int64_t length = size(); + if(length < offset) { buf_.seekp(length, std::ios::beg); - for(off_t i = length; i < position; ++i) { + for(int64_t i = length; i < offset; ++i) { buf_.put('\0'); } } else { - buf_.seekp(position, std::ios::beg); + buf_.seekp(offset, std::ios::beg); } buf_.write(reinterpret_cast(data), dataLength); } -ssize_t ByteArrayDiskWriter::readData(unsigned char* data, size_t len, off_t position) +ssize_t ByteArrayDiskWriter::readData(unsigned char* data, size_t len, + int64_t offset) { - buf_.seekg(position, std::ios::beg); + buf_.seekg(offset, std::ios::beg); buf_.read(reinterpret_cast(data), len); buf_.clear(); return buf_.gcount(); } -off_t ByteArrayDiskWriter::size() +int64_t ByteArrayDiskWriter::size() { buf_.seekg(0, std::ios::end); buf_.clear(); diff --git a/src/ByteArrayDiskWriter.h b/src/ByteArrayDiskWriter.h index 6899d63f..864b1b1e 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(off_t totalLength = 0); + virtual void initAndOpenFile(int64_t totalLength = 0); - virtual void openFile(off_t totalLength = 0); + virtual void openFile(int64_t totalLength = 0); virtual void closeFile(); - virtual void openExistingFile(off_t totalLength = 0); + virtual void openExistingFile(int64_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 void writeData(const unsigned char* data, size_t len, int64_t offset); + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset); - virtual off_t size(); + virtual int64_t size(); void setString(const std::string& s); diff --git a/src/CheckIntegrityEntry.cc b/src/CheckIntegrityEntry.cc index c635a540..3430fedb 100644 --- a/src/CheckIntegrityEntry.cc +++ b/src/CheckIntegrityEntry.cc @@ -56,7 +56,7 @@ void CheckIntegrityEntry::validateChunk() validator_->validateChunk(); } -off_t CheckIntegrityEntry::getTotalLength() +int64_t CheckIntegrityEntry::getTotalLength() { if(!validator_) { return 0; @@ -65,7 +65,7 @@ off_t CheckIntegrityEntry::getTotalLength() } } -off_t CheckIntegrityEntry::getCurrentLength() +int64_t CheckIntegrityEntry::getCurrentLength() { if(!validator_) { return 0; diff --git a/src/CheckIntegrityEntry.h b/src/CheckIntegrityEntry.h index 5f5dcd58..4025d7af 100644 --- a/src/CheckIntegrityEntry.h +++ b/src/CheckIntegrityEntry.h @@ -61,9 +61,9 @@ public: virtual ~CheckIntegrityEntry(); - virtual off_t getTotalLength(); + virtual int64_t getTotalLength(); - virtual off_t getCurrentLength(); + virtual int64_t getCurrentLength(); virtual void validateChunk(); diff --git a/src/DefaultDiskWriter.cc b/src/DefaultDiskWriter.cc index afa02072..7e3d4d14 100644 --- a/src/DefaultDiskWriter.cc +++ b/src/DefaultDiskWriter.cc @@ -41,7 +41,7 @@ DefaultDiskWriter::DefaultDiskWriter(const std::string& filename): DefaultDiskWriter::~DefaultDiskWriter() {} -void DefaultDiskWriter::initAndOpenFile(off_t totalLength) +void DefaultDiskWriter::initAndOpenFile(int64_t totalLength) { createFile(); } diff --git a/src/DefaultDiskWriter.h b/src/DefaultDiskWriter.h index 2bc5a488..a854cab7 100644 --- a/src/DefaultDiskWriter.h +++ b/src/DefaultDiskWriter.h @@ -45,7 +45,7 @@ public: virtual ~DefaultDiskWriter(); - virtual void initAndOpenFile(off_t totalLength = 0); + virtual void initAndOpenFile(int64_t totalLength = 0); }; typedef SharedHandle DefaultDiskWriterHandle; diff --git a/src/DiskAdaptor.h b/src/DiskAdaptor.h index 105b7520..962f42d0 100644 --- a/src/DiskAdaptor.h +++ b/src/DiskAdaptor.h @@ -66,7 +66,7 @@ public: virtual bool fileExists() = 0; - virtual off_t size() = 0; + virtual int64_t size() = 0; template void setFileEntries(InputIterator first, InputIterator last) diff --git a/src/DiskWriter.h b/src/DiskWriter.h index 27da9ff5..2d9c06e9 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(off_t totalLength = 0) = 0; + virtual void initAndOpenFile(int64_t totalLength = 0) = 0; - virtual void openFile(off_t totalLength = 0) = 0; + virtual void openFile(int64_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(off_t totalLength = 0) = 0; + virtual void openExistingFile(int64_t totalLength = 0) = 0; // Returns file length - virtual off_t size() = 0; + virtual int64_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/ExpatXmlParser.cc b/src/ExpatXmlParser.cc index d0345d3a..c3e3831e 100644 --- a/src/ExpatXmlParser.cc +++ b/src/ExpatXmlParser.cc @@ -197,7 +197,7 @@ bool XmlParser::parseBinaryStream(BinaryStream* bs) SessionData sessionData(psm_); XML_Parser parser = createParser(&sessionData); auto_delete deleter(parser, XML_ParserFree); - off_t readOffset = 0; + int64_t readOffset = 0; while(1) { ssize_t res = bs->readData(buf, bufSize, readOffset); if(res == 0) { diff --git a/src/FallocFileAllocationIterator.cc b/src/FallocFileAllocationIterator.cc index f337bf7a..64d0a5ab 100644 --- a/src/FallocFileAllocationIterator.cc +++ b/src/FallocFileAllocationIterator.cc @@ -38,7 +38,7 @@ namespace aria2 { FallocFileAllocationIterator::FallocFileAllocationIterator -(BinaryStream* stream, off_t offset, off_t totalLength): +(BinaryStream* stream, int64_t offset, int64_t totalLength): stream_(stream), offset_(offset), totalLength_(totalLength) {} void FallocFileAllocationIterator::allocateChunk() @@ -57,12 +57,12 @@ bool FallocFileAllocationIterator::finished() return offset_ == totalLength_; } -off_t FallocFileAllocationIterator::getCurrentLength() +int64_t FallocFileAllocationIterator::getCurrentLength() { return offset_; } -off_t FallocFileAllocationIterator::getTotalLength() +int64_t FallocFileAllocationIterator::getTotalLength() { return totalLength_; } diff --git a/src/FallocFileAllocationIterator.h b/src/FallocFileAllocationIterator.h index d43db3a6..dbe47e5d 100644 --- a/src/FallocFileAllocationIterator.h +++ b/src/FallocFileAllocationIterator.h @@ -44,19 +44,19 @@ namespace aria2 { class FallocFileAllocationIterator:public FileAllocationIterator { private: BinaryStream* stream_; - off_t offset_; - off_t totalLength_; + int64_t offset_; + int64_t totalLength_; public: - FallocFileAllocationIterator(BinaryStream* stream, off_t offset, - off_t totalLength); + FallocFileAllocationIterator(BinaryStream* stream, int64_t offset, + int64_t totalLength); virtual void allocateChunk(); virtual bool finished(); - virtual off_t getCurrentLength(); + virtual int64_t getCurrentLength(); - virtual off_t getTotalLength(); + virtual int64_t getTotalLength(); }; } // namespace aria2 diff --git a/src/FileAllocationEntry.cc b/src/FileAllocationEntry.cc index ff4e0f29..143b0b33 100644 --- a/src/FileAllocationEntry.cc +++ b/src/FileAllocationEntry.cc @@ -49,12 +49,12 @@ FileAllocationEntry::FileAllocationEntry(RequestGroup* requestGroup, Command* ne FileAllocationEntry:: ~FileAllocationEntry() {} -off_t FileAllocationEntry::getCurrentLength() +int64_t FileAllocationEntry::getCurrentLength() { return fileAllocationIterator_->getCurrentLength(); } -off_t FileAllocationEntry::getTotalLength() +int64_t FileAllocationEntry::getTotalLength() { return fileAllocationIterator_->getTotalLength(); } diff --git a/src/FileAllocationEntry.h b/src/FileAllocationEntry.h index 4d47123f..4114d515 100644 --- a/src/FileAllocationEntry.h +++ b/src/FileAllocationEntry.h @@ -54,9 +54,9 @@ public: ~FileAllocationEntry(); - virtual off_t getCurrentLength(); + virtual int64_t getCurrentLength(); - virtual off_t getTotalLength(); + virtual int64_t getTotalLength(); virtual bool finished(); diff --git a/src/FileAllocationIterator.h b/src/FileAllocationIterator.h index 57f4e294..f2b8b2c8 100644 --- a/src/FileAllocationIterator.h +++ b/src/FileAllocationIterator.h @@ -50,9 +50,9 @@ public: virtual bool finished() = 0; - virtual off_t getCurrentLength() = 0; + virtual int64_t getCurrentLength() = 0; - virtual off_t getTotalLength() = 0; + virtual int64_t getTotalLength() = 0; }; } // namespace aria2 diff --git a/src/IteratableChecksumValidator.cc b/src/IteratableChecksumValidator.cc index 4c489efa..deb177a8 100644 --- a/src/IteratableChecksumValidator.cc +++ b/src/IteratableChecksumValidator.cc @@ -92,7 +92,7 @@ bool IteratableChecksumValidator::finished() const } } -off_t IteratableChecksumValidator::getTotalLength() const +int64_t IteratableChecksumValidator::getTotalLength() const { return dctx_->getTotalLength(); } diff --git a/src/IteratableChecksumValidator.h b/src/IteratableChecksumValidator.h index 2c4e60d5..a4300763 100644 --- a/src/IteratableChecksumValidator.h +++ b/src/IteratableChecksumValidator.h @@ -50,7 +50,7 @@ private: SharedHandle pieceStorage_; - off_t currentOffset_; + int64_t currentOffset_; SharedHandle ctx_; public: @@ -65,12 +65,12 @@ public: virtual bool finished() const; - virtual off_t getCurrentOffset() const + virtual int64_t getCurrentOffset() const { return currentOffset_; } - virtual off_t getTotalLength() const; + virtual int64_t getTotalLength() const; }; typedef SharedHandle IteratableChecksumValidatorHandle; diff --git a/src/IteratableChunkChecksumValidator.cc b/src/IteratableChunkChecksumValidator.cc index f9f03ce7..b3401ae5 100644 --- a/src/IteratableChunkChecksumValidator.cc +++ b/src/IteratableChunkChecksumValidator.cc @@ -101,7 +101,7 @@ void IteratableChunkChecksumValidator::validateChunk() std::string IteratableChunkChecksumValidator::calculateActualChecksum() { - off_t offset = getCurrentOffset(); + int64_t offset = getCurrentOffset(); size_t length; // When validating last piece if(currentIndex_+1 == dctx_->getNumPieces()) { @@ -119,14 +119,14 @@ void IteratableChunkChecksumValidator::init() currentIndex_ = 0; } -std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length) +std::string IteratableChunkChecksumValidator::digest(int64_t offset, size_t length) { unsigned char buf[4096]; ctx_->reset(); - off_t max = offset+length; + int64_t max = offset+length; while(offset < max) { size_t r = pieceStorage_->getDiskAdaptor()->readData - (buf, std::min(static_cast(sizeof(buf)), max-offset), offset); + (buf, std::min(static_cast(sizeof(buf)), max-offset), offset); if(r == 0) { throw DL_ABORT_EX (fmt(EX_FILE_READ, dctx_->getBasePath().c_str(), @@ -147,12 +147,12 @@ bool IteratableChunkChecksumValidator::finished() const } } -off_t IteratableChunkChecksumValidator::getCurrentOffset() const +int64_t IteratableChunkChecksumValidator::getCurrentOffset() const { - return static_cast(currentIndex_)*dctx_->getPieceLength(); + return static_cast(currentIndex_)*dctx_->getPieceLength(); } -off_t IteratableChunkChecksumValidator::getTotalLength() const +int64_t IteratableChunkChecksumValidator::getTotalLength() const { return dctx_->getTotalLength(); } diff --git a/src/IteratableChunkChecksumValidator.h b/src/IteratableChunkChecksumValidator.h index 314e5765..052d22af 100644 --- a/src/IteratableChunkChecksumValidator.h +++ b/src/IteratableChunkChecksumValidator.h @@ -57,7 +57,7 @@ private: std::string calculateActualChecksum(); - std::string digest(off_t offset, size_t length); + std::string digest(int64_t offset, size_t length); public: IteratableChunkChecksumValidator(const SharedHandle& dctx, @@ -71,9 +71,9 @@ public: virtual bool finished() const; - virtual off_t getCurrentOffset() const; + virtual int64_t getCurrentOffset() const; - virtual off_t getTotalLength() const; + virtual int64_t getTotalLength() const; }; typedef SharedHandle IteratableChunkChecksumValidatorHandle; diff --git a/src/IteratableValidator.h b/src/IteratableValidator.h index ca339ccc..405df202 100644 --- a/src/IteratableValidator.h +++ b/src/IteratableValidator.h @@ -60,9 +60,9 @@ public: virtual bool finished() const = 0; - virtual off_t getCurrentOffset() const = 0; + virtual int64_t getCurrentOffset() const = 0; - virtual off_t getTotalLength() const = 0; + virtual int64_t getTotalLength() const = 0; }; typedef SharedHandle IteratableValidatorHandle; diff --git a/src/JsonDiskWriter.cc b/src/JsonDiskWriter.cc index 80ed2953..b616e2bd 100644 --- a/src/JsonDiskWriter.cc +++ b/src/JsonDiskWriter.cc @@ -46,13 +46,13 @@ JsonDiskWriter::JsonDiskWriter() JsonDiskWriter::~JsonDiskWriter() {} -void JsonDiskWriter::initAndOpenFile(off_t totalLength) +void JsonDiskWriter::initAndOpenFile(int64_t totalLength) { parser_.reset(); } void JsonDiskWriter::writeData(const unsigned char* data, size_t len, - off_t offset) + int64_t offset) { // Return value is ignored here but handled in finalize() parser_.parseUpdate(reinterpret_cast(data), len); diff --git a/src/JsonDiskWriter.h b/src/JsonDiskWriter.h index b683d6d9..72a4a1c1 100644 --- a/src/JsonDiskWriter.h +++ b/src/JsonDiskWriter.h @@ -53,28 +53,28 @@ public: virtual ~JsonDiskWriter(); - virtual void initAndOpenFile(off_t totalLength = 0); + virtual void initAndOpenFile(int64_t totalLength = 0); - virtual void openFile(off_t totalLength = 0) + virtual void openFile(int64_t totalLength = 0) { initAndOpenFile(totalLength); } virtual void closeFile() {} - virtual void openExistingFile(off_t totalLength = 0) + virtual void openExistingFile(int64_t totalLength = 0) { initAndOpenFile(totalLength); } - virtual off_t size() + virtual int64_t size() { return 0; } - virtual void writeData(const unsigned char* data, size_t len, off_t offset); + virtual void writeData(const unsigned char* data, size_t len, int64_t offset); - virtual ssize_t readData(unsigned char* data, size_t len, off_t offset) + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset) { return 0; } diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc index 4115c296..af83cd95 100644 --- a/src/MultiDiskAdaptor.cc +++ b/src/MultiDiskAdaptor.cc @@ -101,7 +101,7 @@ bool DiskWriterEntry::fileExists() return fileEntry_->exists(); } -off_t DiskWriterEntry::size() const +int64_t DiskWriterEntry::size() const { return File(getFilePath()).size(); } @@ -163,7 +163,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() ++itr; continue; } - off_t pieceStartOffset = + int64_t pieceStartOffset = (fileEntry->getOffset()/pieceLength_)*pieceLength_; if(itr != diskWriterEntries_.begin()) { for(std::vector >::const_iterator i = @@ -182,7 +182,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() } if(fileEntry->getLength() > 0) { - off_t lastPieceStartOffset = + int64_t lastPieceStartOffset = (fileEntry->getOffset()+fileEntry->getLength()-1)/ pieceLength_*pieceLength_; A2_LOG_DEBUG(fmt("Checking adjacent backward file to %s" @@ -201,7 +201,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries() (*itr)->getFileEntry()->getPath().c_str(), (*itr)->getFileEntry()->getOffset())); if((*itr)->getFileEntry()->getOffset() < - static_cast(lastPieceStartOffset+pieceLength_)) { + lastPieceStartOffset+pieceLength_) { A2_LOG_DEBUG (fmt("%s needs diskwriter", (*itr)->getFileEntry()->getPath().c_str())); @@ -305,7 +305,7 @@ void MultiDiskAdaptor::closeFile() } namespace { -bool isInRange(const DiskWriterEntryHandle entry, off_t offset) +bool isInRange(const DiskWriterEntryHandle entry, int64_t offset) { return entry->getFileEntry()->getOffset() <= offset && offset < entry->getFileEntry()->getLastOffset(); @@ -314,7 +314,7 @@ bool isInRange(const DiskWriterEntryHandle entry, off_t offset) namespace { ssize_t calculateLength(const DiskWriterEntryHandle entry, - off_t fileOffset, ssize_t rem) + int64_t fileOffset, ssize_t rem) { if(entry->getFileEntry()->getLength() < fileOffset+rem) { return entry->getFileEntry()->getLength()-fileOffset; @@ -327,7 +327,7 @@ ssize_t calculateLength(const DiskWriterEntryHandle entry, namespace { class OffsetCompare { public: - bool operator()(off_t offset, const SharedHandle& dwe) + bool operator()(int64_t offset, const SharedHandle& dwe) { return offset < dwe->getFileEntry()->getOffset(); } @@ -336,7 +336,7 @@ public: namespace { DiskWriterEntries::const_iterator findFirstDiskWriterEntry -(const DiskWriterEntries& diskWriterEntries, off_t offset) +(const DiskWriterEntries& diskWriterEntries, int64_t offset) { DiskWriterEntries::const_iterator first = std::upper_bound(diskWriterEntries.begin(), diskWriterEntries.end(), @@ -355,7 +355,7 @@ DiskWriterEntries::const_iterator findFirstDiskWriterEntry namespace { void throwOnDiskWriterNotOpened(const SharedHandle& e, - off_t offset) + int64_t offset) { throw DL_ABORT_EX (fmt("DiskWriter for offset=%" PRId64 ", filename=%s is not opened.", @@ -365,13 +365,13 @@ void throwOnDiskWriterNotOpened(const SharedHandle& e, } // namespace void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len, - off_t offset) + int64_t offset) { DiskWriterEntries::const_iterator first = findFirstDiskWriterEntry(diskWriterEntries_, offset); ssize_t rem = len; - off_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); + int64_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); for(DiskWriterEntries::const_iterator i = first, eoi = diskWriterEntries_.end(); i != eoi; ++i) { ssize_t writeLength = calculateLength(*i, fileOffset, rem); @@ -392,14 +392,14 @@ void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len, } ssize_t MultiDiskAdaptor::readData -(unsigned char* data, size_t len, off_t offset) +(unsigned char* data, size_t len, int64_t offset) { DiskWriterEntries::const_iterator first = findFirstDiskWriterEntry(diskWriterEntries_, offset); ssize_t rem = len; ssize_t totalReadLength = 0; - off_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); + int64_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); for(DiskWriterEntries::const_iterator i = first, eoi = diskWriterEntries_.end(); i != eoi; ++i) { ssize_t readLength = calculateLength(*i, fileOffset, rem); @@ -428,9 +428,9 @@ bool MultiDiskAdaptor::fileExists() getFileEntries().end(); } -off_t MultiDiskAdaptor::size() +int64_t MultiDiskAdaptor::size() { - off_t size = 0; + int64_t size = 0; for(std::vector >::const_iterator i = getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) { size += File((*i)->getPath()).size(); @@ -464,9 +464,9 @@ void MultiDiskAdaptor::cutTrailingGarbage() for(std::vector >::const_iterator i = diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); i != eoi; ++i) { - off_t length = (*i)->getFileEntry()->getLength(); + int64_t length = (*i)->getFileEntry()->getLength(); if(File((*i)->getFilePath()).size() > length) { - // We need open file before calling DiskWriter::truncate(off_t) + // We need open file before calling DiskWriter::truncate(int64_t) openIfNot(*i, &DiskWriterEntry::openFile); (*i)->getDiskWriter()->truncate(length); } diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h index 7d309307..9c96e398 100644 --- a/src/MultiDiskAdaptor.h +++ b/src/MultiDiskAdaptor.h @@ -69,7 +69,7 @@ public: bool fileExists(); - off_t size() const; + int64_t size() const; const SharedHandle& getFileEntry() const { @@ -134,13 +134,13 @@ public: virtual void closeFile(); virtual void writeData(const unsigned char* data, size_t len, - off_t offset); + int64_t offset); - virtual ssize_t readData(unsigned char* data, size_t len, off_t offset); + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset); virtual bool fileExists(); - virtual off_t size(); + virtual int64_t size(); virtual SharedHandle fileAllocationIterator(); diff --git a/src/MultiFileAllocationIterator.cc b/src/MultiFileAllocationIterator.cc index 6b6a89fa..e45c71e6 100644 --- a/src/MultiFileAllocationIterator.cc +++ b/src/MultiFileAllocationIterator.cc @@ -95,7 +95,7 @@ bool MultiFileAllocationIterator::finished() (!fileAllocationIterator_ || fileAllocationIterator_->finished()); } -off_t MultiFileAllocationIterator::getCurrentLength() +int64_t MultiFileAllocationIterator::getCurrentLength() { if(!fileAllocationIterator_) { return 0; @@ -104,7 +104,7 @@ off_t MultiFileAllocationIterator::getCurrentLength() } } -off_t MultiFileAllocationIterator::getTotalLength() +int64_t MultiFileAllocationIterator::getTotalLength() { if(!fileAllocationIterator_) { return 0; diff --git a/src/MultiFileAllocationIterator.h b/src/MultiFileAllocationIterator.h index 55d607b6..a0359e89 100644 --- a/src/MultiFileAllocationIterator.h +++ b/src/MultiFileAllocationIterator.h @@ -49,7 +49,7 @@ private: MultiDiskAdaptor* diskAdaptor_; std::deque > entries_; SharedHandle fileAllocationIterator_; - off_t offset_; + int64_t offset_; public: MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor); @@ -59,9 +59,9 @@ public: virtual bool finished(); - virtual off_t getCurrentLength(); + virtual int64_t getCurrentLength(); - virtual off_t getTotalLength(); + virtual int64_t getTotalLength(); const std::deque >& getDiskWriterEntries() const; diff --git a/src/ProgressAwareEntry.h b/src/ProgressAwareEntry.h index 82d78217..7b189595 100644 --- a/src/ProgressAwareEntry.h +++ b/src/ProgressAwareEntry.h @@ -48,9 +48,9 @@ class ProgressAwareEntry { public: virtual ~ProgressAwareEntry() {} - virtual off_t getCurrentLength() = 0; + virtual int64_t getCurrentLength() = 0; - virtual off_t getTotalLength() = 0; + virtual int64_t getTotalLength() = 0; virtual bool finished() = 0; }; diff --git a/src/ShareRatioSeedCriteria.cc b/src/ShareRatioSeedCriteria.cc index fa1aac2c..8c7105f7 100644 --- a/src/ShareRatioSeedCriteria.cc +++ b/src/ShareRatioSeedCriteria.cc @@ -51,7 +51,7 @@ void ShareRatioSeedCriteria::reset() {} bool ShareRatioSeedCriteria::evaluate() { - off_t completedLength = pieceStorage_->getCompletedLength(); + int64_t completedLength = pieceStorage_->getCompletedLength(); if(completedLength == 0) { return true; } diff --git a/src/SingleFileAllocationIterator.cc b/src/SingleFileAllocationIterator.cc index 5a1d5598..2e97b124 100644 --- a/src/SingleFileAllocationIterator.cc +++ b/src/SingleFileAllocationIterator.cc @@ -50,8 +50,8 @@ namespace aria2 { SingleFileAllocationIterator::SingleFileAllocationIterator (BinaryStream* stream, - off_t offset, - off_t totalLength) + int64_t offset, + int64_t totalLength) : stream_(stream), offset_(offset), totalLength_(totalLength), diff --git a/src/SingleFileAllocationIterator.h b/src/SingleFileAllocationIterator.h index b905aaea..21503a02 100644 --- a/src/SingleFileAllocationIterator.h +++ b/src/SingleFileAllocationIterator.h @@ -46,16 +46,16 @@ class SingleFileAllocationIterator:public FileAllocationIterator private: BinaryStream* stream_; - off_t offset_; + int64_t offset_; - off_t totalLength_; + int64_t totalLength_; unsigned char* buffer_; public: SingleFileAllocationIterator (BinaryStream* stream, - off_t offset, - off_t totalLength); + int64_t offset, + int64_t totalLength); virtual ~SingleFileAllocationIterator(); @@ -63,12 +63,12 @@ public: virtual bool finished(); - virtual off_t getCurrentLength() + virtual int64_t getCurrentLength() { return offset_; } - virtual off_t getTotalLength() + virtual int64_t getTotalLength() { return totalLength_; } diff --git a/src/XmlRpcDiskWriter.cc b/src/XmlRpcDiskWriter.cc index fdf45411..59f622fd 100644 --- a/src/XmlRpcDiskWriter.cc +++ b/src/XmlRpcDiskWriter.cc @@ -48,13 +48,13 @@ XmlRpcDiskWriter::XmlRpcDiskWriter() XmlRpcDiskWriter::~XmlRpcDiskWriter() {} -void XmlRpcDiskWriter::initAndOpenFile(off_t totalLength) +void XmlRpcDiskWriter::initAndOpenFile(int64_t totalLength) { parser_.reset(); } void XmlRpcDiskWriter::writeData(const unsigned char* data, size_t len, - off_t offset) + int64_t offset) { // Return value is ignored here but handled in finalize() parser_.parseUpdate(reinterpret_cast(data), len); diff --git a/src/XmlRpcDiskWriter.h b/src/XmlRpcDiskWriter.h index 3da3a6cd..98d40c8b 100644 --- a/src/XmlRpcDiskWriter.h +++ b/src/XmlRpcDiskWriter.h @@ -54,28 +54,28 @@ public: virtual ~XmlRpcDiskWriter(); - virtual void initAndOpenFile(off_t totalLength = 0); + virtual void initAndOpenFile(int64_t totalLength = 0); - virtual void openFile(off_t totalLength = 0) + virtual void openFile(int64_t totalLength = 0) { initAndOpenFile(totalLength); } virtual void closeFile() {} - virtual void openExistingFile(off_t totalLength = 0) + virtual void openExistingFile(int64_t totalLength = 0) { initAndOpenFile(totalLength); } - virtual off_t size() + virtual int64_t size() { return 0; } - virtual void writeData(const unsigned char* data, size_t len, off_t offset); + virtual void writeData(const unsigned char* data, size_t len, int64_t offset); - virtual ssize_t readData(unsigned char* data, size_t len, off_t offset) + virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset) { return 0; } diff --git a/src/bittorrent_helper.cc b/src/bittorrent_helper.cc index 3b1ff3da..46d6109c 100644 --- a/src/bittorrent_helper.cc +++ b/src/bittorrent_helper.cc @@ -249,7 +249,7 @@ void extractFileEntries error_code::BITTORRENT_PARSE_ERROR); } length += fileLengthData->i(); - if(length > std::numeric_limits::max()) { + if(fileLengthData->i() > std::numeric_limits::max()) { throw DOWNLOAD_FAILURE_EXCEPTION(fmt(EX_TOO_LARGE_FILE, length)); } std::string pathKey; diff --git a/src/message_digest_helper.cc b/src/message_digest_helper.cc index 26e26a23..63457626 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, off_t length) +(const BinaryStreamHandle& bs, int64_t offset, int64_t length) { sha1Ctx_->reset(); return digest(sha1Ctx_, bs, offset, length); @@ -75,7 +75,7 @@ std::string staticSHA1Digest std::string digest (const SharedHandle& ctx, const SharedHandle& bs, - off_t offset, off_t length) + int64_t offset, int64_t length) { size_t BUFSIZE = 4096; unsigned char BUF[BUFSIZE]; diff --git a/src/message_digest_helper.h b/src/message_digest_helper.h index b6179d92..e31e8586 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& bs, off_t offset, off_t length); +(const SharedHandle& bs, int64_t offset, int64_t length); /** * ctx must be initialized or reseted before calling this function. @@ -72,7 +72,7 @@ std::string staticSHA1Digest std::string digest (const SharedHandle& ctx, const SharedHandle& bs, - off_t offset, off_t length); + int64_t offset, int64_t length); /** * Stores *raw* message digest into md. diff --git a/src/metalink_helper.cc b/src/metalink_helper.cc index 639d98e0..c6db06c2 100644 --- a/src/metalink_helper.cc +++ b/src/metalink_helper.cc @@ -145,7 +145,7 @@ SharedHandle parseBinaryStream xml::XmlParser ps(&psm); unsigned char buf[4096]; ssize_t nread; - off_t offread = 0; + int64_t offread = 0; bool retval = true; while((nread = bs->readData(buf, sizeof(buf), offread)) > 0) { if(ps.parseUpdate(reinterpret_cast(buf), nread) < 0) { diff --git a/test/ByteArrayDiskWriterTest.cc b/test/ByteArrayDiskWriterTest.cc index 6630f970..f88dd30a 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((off_t)14, bw.size()); + CPPUNIT_ASSERT_EQUAL((int64_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((off_t)15, bw.size()); + CPPUNIT_ASSERT_EQUAL((int64_t)15, bw.size()); } } // namespace aria2 diff --git a/test/DefaultDiskWriterTest.cc b/test/DefaultDiskWriterTest.cc index 19b05936..8f2d8b2d 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((off_t)4096LL, dw.size()); + CPPUNIT_ASSERT_EQUAL((int64_t)4096LL, dw.size()); } } // namespace aria2 diff --git a/test/MultiDiskAdaptorTest.cc b/test/MultiDiskAdaptorTest.cc index 5e86b2e1..7d9c5b9a 100644 --- a/test/MultiDiskAdaptorTest.cc +++ b/test/MultiDiskAdaptorTest.cc @@ -413,7 +413,7 @@ void MultiDiskAdaptorTest::testSize() adaptor.openFile(); - CPPUNIT_ASSERT_EQUAL((off_t)2, adaptor.size()); + CPPUNIT_ASSERT_EQUAL((int64_t)2, adaptor.size()); } void MultiDiskAdaptorTest::testUtime() diff --git a/test/SingleFileAllocationIteratorTest.cc b/test/SingleFileAllocationIteratorTest.cc index 3e3e4eb0..ea6ca21a 100644 --- a/test/SingleFileAllocationIteratorTest.cc +++ b/test/SingleFileAllocationIteratorTest.cc @@ -35,8 +35,8 @@ void SingleFileAllocationIteratorTest::testAllocate() CPPUNIT_ASSERT_EQUAL((int64_t)10, x.size()); DefaultDiskWriter writer(fn); - off_t offset = 10; - off_t totalLength = 16*1024*2+8*1024; + int64_t offset = 10; + int64_t totalLength = 16*1024*2+8*1024; // we have to open file first. writer.openExistingFile();