Use int64_t instead of off_t

Some classes such as DiskAdaptor, DiskWriter, FileAllocationIterator
and ChecksumValidator are left unchanged.

src/BitfieldMan.cc

@@ -44,7 +44,7 @@ using namespace aria2::expr;
 
 namespace aria2 {
 
-BitfieldMan::BitfieldMan(int32_t blockLength, off_t totalLength)
+BitfieldMan::BitfieldMan(int32_t blockLength, int64_t totalLength)
   :blockLength_(blockLength),
    totalLength_(totalLength),
    bitfieldLength_(0),
@@ -663,7 +663,7 @@ void BitfieldMan::ensureFilterBitfield()
   }
 }
 
-void BitfieldMan::addFilter(off_t offset, off_t length) {
+void BitfieldMan::addFilter(int64_t offset, int64_t length) {
   ensureFilterBitfield();
   if(length > 0) {
     size_t startBlock = offset/blockLength_;
@@ -675,7 +675,7 @@ void BitfieldMan::addFilter(off_t offset, off_t length) {
   updateCache();
 }
 
-void BitfieldMan::removeFilter(off_t offset, off_t length) {
+void BitfieldMan::removeFilter(int64_t offset, int64_t length) {
   ensureFilterBitfield();
   if(length > 0) {
     size_t startBlock = offset/blockLength_;
@@ -687,7 +687,7 @@ void BitfieldMan::removeFilter(off_t offset, off_t length) {
   updateCache();
 }
 
-void BitfieldMan::addNotFilter(off_t offset, off_t length)
+void BitfieldMan::addNotFilter(int64_t offset, int64_t length)
 {
   ensureFilterBitfield();
   if(length > 0 && blocks_ > 0) {
@@ -726,7 +726,7 @@ void BitfieldMan::clearFilter() {
   updateCache();
 }
 
-off_t BitfieldMan::getFilteredTotalLengthNow() const {
+int64_t BitfieldMan::getFilteredTotalLengthNow() const {
   if(!filterBitfield_) {
     return 0;
   }
@@ -735,13 +735,13 @@ off_t BitfieldMan::getFilteredTotalLengthNow() const {
     return 0;
   }
   if(bitfield::test(filterBitfield_, blocks_, blocks_-1)) {
-    return ((off_t)filteredBlocks-1)*blockLength_+getLastBlockLength();
+    return ((int64_t)filteredBlocks-1)*blockLength_+getLastBlockLength();
   } else {
-    return ((off_t)filteredBlocks)*blockLength_;
+    return ((int64_t)filteredBlocks)*blockLength_;
   }
 }
 
-off_t BitfieldMan::getCompletedLength(bool useFilter) const {
+int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
   unsigned char* temp;
   if(useFilter) {
     temp = new unsigned char[bitfieldLength_];
@@ -755,15 +755,15 @@ off_t BitfieldMan::getCompletedLength(bool useFilter) const {
     temp = bitfield_;
   }
   size_t completedBlocks = bitfield::countSetBit(temp, blocks_);
-  off_t completedLength = 0;
+  int64_t completedLength = 0;
   if(completedBlocks == 0) {
     completedLength = 0;
   } else {
     if(bitfield::test(temp, blocks_, blocks_-1)) {
       completedLength =
-        ((off_t)completedBlocks-1)*blockLength_+getLastBlockLength();
+        ((int64_t)completedBlocks-1)*blockLength_+getLastBlockLength();
     } else {
-      completedLength = ((off_t)completedBlocks)*blockLength_;
+      completedLength = ((int64_t)completedBlocks)*blockLength_;
     }
   }
   if(useFilter) {
@@ -772,11 +772,11 @@ off_t BitfieldMan::getCompletedLength(bool useFilter) const {
   return completedLength;
 }
 
-off_t BitfieldMan::getCompletedLengthNow() const {
+int64_t BitfieldMan::getCompletedLengthNow() const {
   return getCompletedLength(false);
 }
 
-off_t BitfieldMan::getFilteredCompletedLengthNow() const {
+int64_t BitfieldMan::getFilteredCompletedLengthNow() const {
   return getCompletedLength(true);
 }
 
@@ -815,7 +815,7 @@ void BitfieldMan::setBitRange(size_t startIndex, size_t endIndex)
   updateCache();
 }
 
-bool BitfieldMan::isBitSetOffsetRange(off_t offset, off_t length) const
+bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
 {
   if(length <= 0) {
     return false;
@@ -836,11 +836,11 @@ bool BitfieldMan::isBitSetOffsetRange(off_t offset, off_t length) const
   return true;
 }
 
-off_t BitfieldMan::getOffsetCompletedLength
-(off_t offset,
- off_t length) const
+int64_t BitfieldMan::getOffsetCompletedLength
+(int64_t offset,
+ int64_t length) const
 {
-  off_t res = 0;
+  int64_t res = 0;
   if(length == 0 || totalLength_ <= offset) {
     return 0;
   }
@@ -869,12 +869,12 @@ off_t BitfieldMan::getOffsetCompletedLength
   return res;
 }
 
-off_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
+int64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
 {
   if(blocks_ <= startingIndex) {
     return 0;
   }
-  off_t length = 0;
+  int64_t length = 0;
   for(size_t i = startingIndex; i < blocks_; ++i) {
     if(isBitSet(i) || isUseBitSet(i)) {
       break;

src/BitfieldMan.h

@@ -46,7 +46,7 @@ namespace aria2 {
 class BitfieldMan {
 private:
   int32_t blockLength_;
-  off_t totalLength_;
+  int64_t totalLength_;
   size_t bitfieldLength_;
   size_t blocks_;
   bool filterEnabled_;
@@ -57,9 +57,9 @@ private:
   // for caching
   size_t cachedNumMissingBlock_;
   size_t cachedNumFilteredBlock_;
-  off_t cachedCompletedLength_;
-  off_t cachedFilteredCompletedLength_;
-  off_t cachedFilteredTotalLength_;
+  int64_t cachedCompletedLength_;
+  int64_t cachedFilteredCompletedLength_;
+  int64_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;
 
-  off_t getCompletedLength(bool useFilter) const;
+  int64_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(int32_t blockLength, off_t totalLength);
+  BitfieldMan(int32_t blockLength, int64_t totalLength);
   BitfieldMan(const BitfieldMan& bitfieldMan);
   ~BitfieldMan();
 
@@ -99,7 +99,7 @@ public:
 
   int32_t getBlockLength(size_t index) const;
 
-  off_t getTotalLength() const { return totalLength_; }
+  int64_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(off_t offset, off_t length);
-  void removeFilter(off_t offset, off_t length);
+  void addFilter(int64_t offset, int64_t length);
+  void removeFilter(int64_t offset, int64_t length);
   // Add filter not in the range of [offset, offset+length) bytes
-  void addNotFilter(off_t offset, off_t length);
+  void addNotFilter(int64_t offset, int64_t length);
 
   // Clears filter and disables filter
   void clearFilter();
@@ -254,29 +254,29 @@ public:
   }
 
   // affected by filter
-  off_t getFilteredTotalLength() const
+  int64_t getFilteredTotalLength() const
   {
     return cachedFilteredTotalLength_;
   }
 
   // affected by filter
-  off_t getFilteredTotalLengthNow() const;
+  int64_t getFilteredTotalLengthNow() const;
 
-  off_t getCompletedLength() const
+  int64_t getCompletedLength() const
   {
     return cachedCompletedLength_;
   }
 
-  off_t getCompletedLengthNow() const;
+  int64_t getCompletedLengthNow() const;
 
   // affected by filter
-  off_t getFilteredCompletedLength() const
+  int64_t getFilteredCompletedLength() const
   {
     return cachedFilteredCompletedLength_;
   }
 
   // affected by filter
-  off_t getFilteredCompletedLengthNow() const;
+  int64_t getFilteredCompletedLengthNow() const;
 
   void updateCache();
 
@@ -286,13 +286,13 @@ public:
 
   void setBitRange(size_t startIndex, size_t endIndex);
 
-  bool isBitSetOffsetRange(off_t offset, off_t length) const;
+  bool isBitSetOffsetRange(int64_t offset, int64_t length) const;
 
   // Returns completed length in bytes in range [offset,
   // offset+length). This function will not affected by filter.
-  off_t getOffsetCompletedLength(off_t offset, off_t length) const;
+  int64_t getOffsetCompletedLength(int64_t offset, int64_t length) const;
 
-  off_t getMissingUnusedLength(size_t startingIndex) const;
+  int64_t getMissingUnusedLength(size_t startingIndex) const;
 
   const unsigned char* getFilterBitfield() const
   {

src/BtRuntime.h

@@ -42,7 +42,7 @@ namespace aria2 {
 
 class BtRuntime {
 private:
-  off_t uploadLengthAtStartup_;
+  int64_t uploadLengthAtStartup_;
   bool halt_;
   int connections_;
   bool ready_;
@@ -57,11 +57,11 @@ public:
 
   ~BtRuntime();
 
-  off_t getUploadLengthAtStartup() const {
+  int64_t getUploadLengthAtStartup() const {
     return uploadLengthAtStartup_;
   }
 
-  void setUploadLengthAtStartup(off_t length) {
+  void setUploadLengthAtStartup(int64_t length) {
     uploadLengthAtStartup_ = length;
   }
 

src/ChunkChecksum.cc

@@ -56,9 +56,9 @@ bool ChunkChecksum::validateChunk
   return !digest.empty() && actualDigest == digest;
 }
 
-off_t ChunkChecksum::getEstimatedDataLength() const
+int64_t ChunkChecksum::getEstimatedDataLength() const
 {
-  return static_cast<off_t>(pieceLength_)*pieceHashes_.size();
+  return static_cast<int64_t>(pieceLength_)*pieceHashes_.size();
 }
 
 size_t ChunkChecksum::countPieceHash() const

src/ChunkChecksum.h

@@ -60,7 +60,7 @@ public:
   bool validateChunk(const std::string& actualDigest,
                      size_t index) const;
 
-  off_t getEstimatedDataLength() const;
+  int64_t getEstimatedDataLength() const;
 
   size_t countPieceHash() const;
 

src/DefaultPieceStorage.cc

@@ -513,28 +513,28 @@ bool DefaultPieceStorage::isPieceUsed(size_t index)
   return bitfieldMan_->isUseBitSet(index);
 }
 
-off_t DefaultPieceStorage::getTotalLength()
+int64_t DefaultPieceStorage::getTotalLength()
 {
   return bitfieldMan_->getTotalLength();
 }
 
-off_t DefaultPieceStorage::getFilteredTotalLength()
+int64_t DefaultPieceStorage::getFilteredTotalLength()
 {
   return bitfieldMan_->getFilteredTotalLength();
 }
 
-off_t DefaultPieceStorage::getCompletedLength()
+int64_t DefaultPieceStorage::getCompletedLength()
 {
-  off_t completedLength =
+  int64_t completedLength =
     bitfieldMan_->getCompletedLength()+getInFlightPieceCompletedLength();
-  off_t totalLength = getTotalLength();
+  int64_t totalLength = getTotalLength();
   if(completedLength > totalLength) {
     completedLength = totalLength;
   }
   return completedLength;
 }
 
-off_t DefaultPieceStorage::getFilteredCompletedLength()
+int64_t DefaultPieceStorage::getFilteredCompletedLength()
 {
   return bitfieldMan_->getFilteredCompletedLength()+
     getInFlightPieceCompletedLength();
@@ -707,7 +707,7 @@ void DefaultPieceStorage::markAllPiecesDone()
   bitfieldMan_->setAllBit();
 }
 
-void DefaultPieceStorage::markPiecesDone(off_t length)
+void DefaultPieceStorage::markPiecesDone(int64_t length)
 {
   if(length == bitfieldMan_->getTotalLength()) {
     bitfieldMan_->setAllBit();

src/DefaultPieceStorage.h

@@ -192,13 +192,13 @@ public:
 
   virtual bool isPieceUsed(size_t index);
 
-  virtual off_t getTotalLength();
+  virtual int64_t getTotalLength();
 
-  virtual off_t getFilteredTotalLength();
+  virtual int64_t getFilteredTotalLength();
 
-  virtual off_t getCompletedLength();
+  virtual int64_t getCompletedLength();
 
-  virtual off_t getFilteredCompletedLength();
+  virtual int64_t getFilteredCompletedLength();
 
   virtual void initStorage();
 
@@ -251,7 +251,7 @@ public:
 
   virtual void markAllPiecesDone();
 
-  virtual void markPiecesDone(off_t length);
+  virtual void markPiecesDone(int64_t length);
 
   virtual void markPieceMissing(size_t index);
 

src/DownloadCommand.cc

@@ -146,7 +146,7 @@ bool DownloadCommand::executeInternal() {
     size_t bufSize;
     if(sinkFilterOnly_) {
       if(segment->getLength() > 0) {
-        if(static_cast<off_t>(segment->getPosition()+segment->getLength()) <=
+        if(segment->getPosition()+segment->getLength() <=
            getFileEntry()->getLastOffset()) {
           bufSize =
             std::min(static_cast<size_t>(segment->getLength()
@@ -188,7 +188,7 @@ bool DownloadCommand::executeInternal() {
       segmentPartComplete = true;
     }
   } else {
-    off_t loff = getFileEntry()->gtoloff(segment->getPositionToWrite());
+    int64_t loff = getFileEntry()->gtoloff(segment->getPositionToWrite());
     if(getFileEntry()->getLength() > 0 && !sinkFilterOnly_ &&
        ((loff == getRequestEndOffset() && streamFilter_->finished())
         || loff < getRequestEndOffset()) &&

src/DownloadCommand.h

@@ -76,7 +76,7 @@ protected:
   virtual bool prepareForNextSegment();
 
   // This is file local offset
-  virtual off_t getRequestEndOffset() const = 0;
+  virtual int64_t getRequestEndOffset() const = 0;
 public:
   DownloadCommand(cuid_t cuid,
                   const SharedHandle<Request>& req,

src/DownloadContext.cc

@@ -57,7 +57,7 @@ DownloadContext::DownloadContext():
   metalinkServerContacted_(false) {}
 
 DownloadContext::DownloadContext(int32_t pieceLength,
-                                 off_t totalLength,
+                                 int64_t totalLength,
                                  const std::string& path):
   pieceLength_(pieceLength),
   checksumVerified_(false),
@@ -95,7 +95,7 @@ int64_t DownloadContext::calculateSessionTime() const
 }
 
 SharedHandle<FileEntry>
-DownloadContext::findFileEntryByOffset(off_t offset) const
+DownloadContext::findFileEntryByOffset(int64_t offset) const
 {
   if(fileEntries_.empty() ||
      (offset > 0 && fileEntries_.back()->getLastOffset() <= offset)) {
@@ -198,7 +198,7 @@ size_t DownloadContext::getNumPieces() const
   }
 }
 
-off_t DownloadContext::getTotalLength() const
+int64_t DownloadContext::getTotalLength() const
 {
   if(fileEntries_.empty()) {
     return 0;

src/DownloadContext.h

@@ -93,7 +93,7 @@ public:
   // Convenient constructor that creates single file download.  path
   // should be escaped with util::escapePath(...).
   DownloadContext(int32_t pieceLength,
-                  off_t totalLength,
+                  int64_t totalLength,
                   const std::string& path = A2STR::NIL);
 
   ~DownloadContext();
@@ -114,7 +114,7 @@ public:
     pieceHashes_.assign(first, last);
   }
 
-  off_t getTotalLength() const;
+  int64_t getTotalLength() const;
 
   bool knowsTotalLength() const { return knowsTotalLength_; }
 
@@ -222,7 +222,7 @@ public:
   
   // Returns FileEntry at given offset. SharedHandle<FileEntry>() is
   // returned if no such FileEntry is found.
-  SharedHandle<FileEntry> findFileEntryByOffset(off_t offset) const;
+  SharedHandle<FileEntry> findFileEntryByOffset(int64_t offset) const;
 
   void releaseRuntimeResource();
 

src/DownloadResult.h

@@ -79,11 +79,11 @@ struct DownloadResult
 
   SharedHandle<MetadataInfo> metadataInfo;
 
-  off_t totalLength;
+  int64_t totalLength;
 
-  off_t completedLength;
+  int64_t completedLength;
 
-  off_t uploadLength;
+  int64_t uploadLength;
 
   std::string bitfield;
 

src/File.cc

@@ -103,7 +103,7 @@ bool File::remove() {
   }
 }
 
-off_t File::size() {
+int64_t File::size() {
   a2_struct_stat fstat;
   if(fillStat(fstat) < 0) {
     return 0;

src/File.h

@@ -94,7 +94,7 @@ public:
    */
   bool mkdirs();
 
-  off_t size();
+  int64_t size();
 
   mode_t mode();
 

src/FileEntry.cc

@@ -68,8 +68,8 @@ bool FileEntry::RequestFaster::operator()
 
 FileEntry::FileEntry
 (const std::string& path,
- off_t length,
- off_t offset,
+ int64_t length,
+ int64_t offset,
  const std::vector<std::string>& uris)
   : path_(path),
     uris_(uris.begin(), uris.end()),
@@ -112,7 +112,7 @@ bool FileEntry::exists() const
   return File(getPath()).exists();
 }
 
-off_t FileEntry::gtoloff(off_t goff) const
+int64_t FileEntry::gtoloff(int64_t goff) const
 {
   assert(offset_ <= goff);
   return goff-offset_;

src/FileEntry.h

@@ -66,8 +66,8 @@ private:
   std::string path_;
   std::deque<std::string> uris_;
   std::deque<std::string> spentUris_;
-  off_t length_;
-  off_t offset_;
+  int64_t length_;
+  int64_t offset_;
   bool requested_;
 
   class RequestFaster {
@@ -92,7 +92,7 @@ private:
 public:
   FileEntry();
 
-  FileEntry(const std::string& path, off_t length, off_t offset,
+  FileEntry(const std::string& path, int64_t length, int64_t offset,
             const std::vector<std::string>& uris = std::vector<std::string>());
 
   ~FileEntry();
@@ -107,15 +107,15 @@ public:
 
   void setPath(const std::string& path);
 
-  off_t getLength() const { return length_; }
+  int64_t getLength() const { return length_; }
 
-  void setLength(off_t length) { length_ = length; }
+  void setLength(int64_t length) { length_ = length; }
 
-  off_t getOffset() const { return offset_; }
+  int64_t getOffset() const { return offset_; }
 
-  void setOffset(off_t offset) { offset_ = offset; }
+  void setOffset(int64_t offset) { offset_ = offset; }
 
-  off_t getLastOffset() { return offset_+length_; }
+  int64_t getLastOffset() { return offset_+length_; }
 
   bool isRequested() const { return requested_; }
 
@@ -209,7 +209,7 @@ public:
   bool exists() const;
 
   // Translate global offset goff to file local offset.
-  off_t gtoloff(off_t goff) const;
+  int64_t gtoloff(int64_t goff) const;
 
   void removeURIWhoseHostnameIs(const std::string& hostname);
 

src/FtpDownloadCommand.cc

@@ -85,7 +85,7 @@ bool FtpDownloadCommand::prepareForNextSegment()
   }
 }
 
-off_t FtpDownloadCommand::getRequestEndOffset() const
+int64_t FtpDownloadCommand::getRequestEndOffset() const
 {
   return getFileEntry()->getLength();
 }

src/FtpDownloadCommand.h

@@ -48,7 +48,7 @@ private:
   SharedHandle<SocketCore> ctrlSocket_;
 protected:
   virtual bool prepareForNextSegment();
-  virtual off_t getRequestEndOffset() const;
+  virtual int64_t getRequestEndOffset() const;
 public:
   FtpDownloadCommand(cuid_t cuid,
                      const SharedHandle<Request>& req,

src/FtpNegotiationCommand.cc

@@ -367,7 +367,7 @@ bool FtpNegotiationCommand::sendSize() {
   return false;
 }
 
-bool FtpNegotiationCommand::onFileSizeDetermined(off_t totalLength)
+bool FtpNegotiationCommand::onFileSizeDetermined(int64_t totalLength)
 {
   getFileEntry()->setLength(totalLength);
   if(getFileEntry()->getPath().empty()) {

src/FtpNegotiationCommand.h

@@ -137,7 +137,7 @@ private:
 
   void poolConnection() const;
 
-  bool onFileSizeDetermined(off_t totalLength);
+  bool onFileSizeDetermined(int64_t totalLength);
 
   void onDryRunFileFound();
 

src/GrowSegment.h

@@ -58,12 +58,12 @@ public:
     return 0;
   }
 
-  virtual off_t getPosition() const
+  virtual int64_t getPosition() const
   {
     return 0;
   }
   
-  virtual off_t getPositionToWrite() const
+  virtual int64_t getPositionToWrite() const
   {
     return writtenLength_;
   }

src/HttpDownloadCommand.cc

@@ -117,9 +117,8 @@ bool HttpDownloadCommand::prepareForNextSegment() {
        !downloadFinished) {
       const SharedHandle<Segment>& segment = getSegments().front();
 
-      off_t lastOffset =getFileEntry()->gtoloff
-        (std::min(static_cast<off_t>
-                  (segment->getPosition()+segment->getLength()),
+      int64_t lastOffset =getFileEntry()->gtoloff
+        (std::min(segment->getPosition()+segment->getLength(),
                   getFileEntry()->getLastOffset()));
       
       if(lastOffset ==
@@ -131,9 +130,9 @@ bool HttpDownloadCommand::prepareForNextSegment() {
   }
 }
 
-off_t HttpDownloadCommand::getRequestEndOffset() const
+int64_t HttpDownloadCommand::getRequestEndOffset() const
 {
-  off_t endByte = httpResponse_->getHttpHeader()->getRange()->getEndByte();
+  int64_t endByte = httpResponse_->getHttpHeader()->getRange()->getEndByte();
   if(endByte > 0) {
     return endByte+1;
   } else {

src/HttpDownloadCommand.h

@@ -48,7 +48,7 @@ private:
   SharedHandle<HttpConnection> httpConnection_;
 protected:
   virtual bool prepareForNextSegment();
-  virtual off_t getRequestEndOffset() const;
+  virtual int64_t getRequestEndOffset() const;
 public:
   HttpDownloadCommand(cuid_t cuid,
                       const SharedHandle<Request>& req,

src/HttpRequest.cc

@@ -75,7 +75,7 @@ void HttpRequest::setRequest(const SharedHandle<Request>& request)
   request_ = request;
 }
 
-off_t HttpRequest::getStartByte() const
+int64_t HttpRequest::getStartByte() const
 {
   if(!segment_) {
     return 0;
@@ -84,15 +84,15 @@ off_t HttpRequest::getStartByte() const
   }
 }
 
-off_t HttpRequest::getEndByte() const
+int64_t HttpRequest::getEndByte() const
 {
   if(!segment_ || !request_) {
     return 0;
   } else {
     if(request_->isPipeliningEnabled()) {
-      off_t endByte =
+      int64_t endByte =
         fileEntry_->gtoloff(segment_->getPosition()+segment_->getLength()-1);
-      return std::min(endByte, static_cast<off_t>(fileEntry_->getLength()-1));
+      return std::min(endByte, fileEntry_->getLength()-1);
     } else {
       return 0;
     }
@@ -367,7 +367,7 @@ const SharedHandle<AuthConfig>& HttpRequest::getAuthConfig() const
   return authConfig_;
 }
 
-off_t HttpRequest::getEntityLength() const
+int64_t HttpRequest::getEntityLength() const
 {
   assert(fileEntry_);
   return fileEntry_->getLength();

src/HttpRequest.h

@@ -87,7 +87,7 @@ private:
 
   bool acceptGzip_;
 
-  off_t endOffsetOverride_;
+  int64_t endOffsetOverride_;
 
   std::string ifModSinceHeader_;
 
@@ -105,7 +105,7 @@ public:
 
   void setRequest(const SharedHandle<Request>& request);
 
-  off_t getEntityLength() const;
+  int64_t getEntityLength() const;
 
   const std::string& getHost() const;
 
@@ -140,9 +140,9 @@ public:
     return request_;
   }
 
-  off_t getStartByte() const;
+  int64_t getStartByte() const;
 
-  off_t getEndByte() const;
+  int64_t getEndByte() const;
 
   /**
    * Returns string representation of http request.  It usually starts
@@ -240,7 +240,7 @@ public:
     return acceptGzip_;
   }
 
-  void setEndOffsetOverride(off_t offset)
+  void setEndOffsetOverride(int64_t offset)
   {
     endOffsetOverride_ = offset;
   }

src/HttpRequestCommand.cc

@@ -86,13 +86,13 @@ SharedHandle<HttpRequest>
 createHttpRequest(const SharedHandle<Request>& req,
                   const SharedHandle<FileEntry>& fileEntry,
                   const SharedHandle<Segment>& segment,
-                  off_t totalLength,
+                  int64_t totalLength,
                   const SharedHandle<Option>& option,
                   const RequestGroup* rg,
                   const SharedHandle<CookieStorage>& cookieStorage,
                   const SharedHandle<AuthConfigFactory>& authConfigFactory,
                   const SharedHandle<Request>& proxyRequest,
-                  off_t endOffset = 0)
+                  int64_t endOffset = 0)
 {
   SharedHandle<HttpRequest> httpRequest(new HttpRequest());
   httpRequest->setUserAgent(option->get(PREF_USER_AGENT));
@@ -180,15 +180,14 @@ bool HttpRequestCommand::executeInternal() {
           itr != eoi; ++itr) {
         const SharedHandle<Segment>& segment = *itr;
         if(!httpConnection_->isIssued(segment)) {
-          off_t endOffset = 0;
-          if(getRequestGroup()->getTotalLength() > 0 &&
-             getPieceStorage()) {
+          int64_t endOffset = 0;
+          if(getRequestGroup()->getTotalLength() > 0 && getPieceStorage()) {
             size_t nextIndex =
               getPieceStorage()->getNextUsedIndex(segment->getIndex());
             endOffset = std::min
-              (static_cast<off_t>(getFileEntry()->getLength()),
+              (getFileEntry()->getLength(),
                getFileEntry()->gtoloff
-               (static_cast<off_t>(segment->getSegmentLength())*nextIndex));
+               (static_cast<int64_t>(segment->getSegmentLength())*nextIndex));
           }
           SharedHandle<HttpRequest> httpRequest
             (createHttpRequest(getRequest(),

src/HttpResponse.cc

@@ -227,7 +227,7 @@ SharedHandle<StreamFilter> HttpResponse::getContentEncodingStreamFilter() const
   return filter;
 }
 
-off_t HttpResponse::getContentLength() const
+int64_t HttpResponse::getContentLength() const
 {
   if(!httpHeader_) {
     return 0;
@@ -236,7 +236,7 @@ off_t HttpResponse::getContentLength() const
   }
 }
 
-off_t HttpResponse::getEntityLength() const
+int64_t HttpResponse::getEntityLength() const
 {
   if(!httpHeader_) {
     return 0;

src/HttpResponse.h

@@ -96,9 +96,9 @@ public:
 
   SharedHandle<StreamFilter> getContentEncodingStreamFilter() const;
 
-  off_t getContentLength() const;
+  int64_t getContentLength() const;
 
-  off_t getEntityLength() const;
+  int64_t getEntityLength() const;
 
   // Returns type "/" subtype. The parameter is removed.
   std::string getContentType() const;

src/HttpResponseCommand.cc

@@ -181,7 +181,7 @@ bool HttpResponseCommand::executeInternal()
   int statusCode = httpResponse->getStatusCode();
 
   if(statusCode == 304) {
-    off_t totalLength = httpResponse->getEntityLength();
+    int64_t totalLength = httpResponse->getEntityLength();
     getFileEntry()->setLength(totalLength);
     getRequestGroup()->initPieceStorage();
     getPieceStorage()->markAllPiecesDone();
@@ -246,7 +246,7 @@ bool HttpResponseCommand::executeInternal()
   }
   if(!getPieceStorage()) {
     util::removeMetalinkContentTypes(getRequestGroup());
-    off_t totalLength = httpResponse->getEntityLength();
+    int64_t totalLength = httpResponse->getEntityLength();
     getFileEntry()->setLength(totalLength);
     if(getFileEntry()->getPath().empty()) {
       getFileEntry()->setPath

src/HttpServer.h

@@ -60,7 +60,7 @@ private:
   DownloadEngine* e_;
   SharedHandle<HttpHeaderProcessor> headerProcessor_;
   SharedHandle<HttpHeader> lastRequestHeader_;
-  off_t lastContentLength_;
+  int64_t lastContentLength_;
   std::stringstream lastBody_;
   bool keepAlive_;
   bool gzip_;
@@ -129,7 +129,7 @@ public:
 
   void disableGZip() { gzip_ = false; }
 
-  off_t getContentLength() const { return lastContentLength_; }
+  int64_t getContentLength() const { return lastContentLength_; }
 
   const SharedHandle<SocketRecvBuffer>& getSocketRecvBuffer() const
   {

src/HttpSkipResponseCommand.cc

@@ -124,7 +124,7 @@ bool HttpSkipResponseCommand::executeInternal()
         if(totalLength_ > 0) {
           bufSize = std::min
             (totalLength_-receivedBytes_,
-             static_cast<off_t>(getSocketRecvBuffer()->getBufferLength()));
+             static_cast<int64_t>(getSocketRecvBuffer()->getBufferLength()));
         } else {
           bufSize = getSocketRecvBuffer()->getBufferLength();
         }

src/HttpSkipResponseCommand.h

@@ -53,9 +53,9 @@ private:
 
   bool sinkFilterOnly_;
 
-  off_t totalLength_;
+  int64_t totalLength_;
 
-  off_t receivedBytes_;
+  int64_t receivedBytes_;
 
   bool processResponse();
 

src/Metalink2RequestGroup.cc

@@ -293,7 +293,7 @@ Metalink2RequestGroup::createRequestGroup
       // piece length is overridden by the one in torrent file.
       dctx->setPieceLength(option->getAsInt(PREF_PIECE_LENGTH));
       std::vector<SharedHandle<FileEntry> > fileEntries;
-      off_t offset = 0;
+      int64_t offset = 0;
       for(std::vector<SharedHandle<MetalinkEntry> >::const_iterator i =
             mes.begin(), eoi = mes.end(); i != eoi; ++i) {
         A2_LOG_INFO(fmt("Metalink: Queueing %s for download as a member.",

src/MetalinkEntry.cc

@@ -101,7 +101,7 @@ const std::string& MetalinkEntry::getPath() const
   return file->getPath();
 }
 
-off_t MetalinkEntry::getLength() const
+int64_t MetalinkEntry::getLength() const
 {
   return file->getLength();
 }

src/MetalinkEntry.h

@@ -79,7 +79,7 @@ public:
 
   const std::string& getPath() const;
 
-  off_t getLength() const;
+  int64_t getLength() const;
 
   const SharedHandle<FileEntry>& getFile() const
   {

src/MetalinkParserController.cc

@@ -87,7 +87,7 @@ void MetalinkParserController::setFileNameOfEntry(const std::string& filename)
   }
 }
 
-void MetalinkParserController::setFileLengthOfEntry(off_t length)
+void MetalinkParserController::setFileLengthOfEntry(int64_t length)
 {
   if(!tEntry_) {
     return;

src/MetalinkParserController.h

@@ -96,7 +96,7 @@ public:
 
   void setFileNameOfEntry(const std::string& filename);
 
-  void setFileLengthOfEntry(off_t length);
+  void setFileLengthOfEntry(int64_t length);
 
   void setVersionOfEntry(const std::string& version);
 

src/MetalinkParserStateMachine.cc

@@ -262,7 +262,7 @@ void MetalinkParserStateMachine::setFileNameOfEntry(const std::string& filename)
   ctrl_->setFileNameOfEntry(filename);
 }
 
-void MetalinkParserStateMachine::setFileLengthOfEntry(off_t length)
+void MetalinkParserStateMachine::setFileLengthOfEntry(int64_t length)
 {
   ctrl_->setFileLengthOfEntry(length);
 }

src/MetalinkParserStateMachine.h

@@ -159,7 +159,7 @@ public:
 
   void setFileNameOfEntry(const std::string& filename);
 
-  void setFileLengthOfEntry(off_t length);
+  void setFileLengthOfEntry(int64_t length);
 
   void setVersionOfEntry(const std::string& version);
 

src/Peer.cc

@@ -73,7 +73,7 @@ void Peer::usedBy(cuid_t cuid)
   cuid_ = cuid;
 }
 
-void Peer::allocateSessionResource(int32_t pieceLength, off_t totalLength)
+void Peer::allocateSessionResource(int32_t pieceLength, int64_t totalLength)
 {
   delete res_;
   res_ = new PeerSessionResource(pieceLength, totalLength);
@@ -81,7 +81,7 @@ void Peer::allocateSessionResource(int32_t pieceLength, off_t totalLength)
   updateSeeder();
 }
 
-void Peer::reconfigureSessionResource(int32_t pieceLength, off_t totalLength)
+void Peer::reconfigureSessionResource(int32_t pieceLength, int64_t totalLength)
 {
   assert(res_);
   res_->reconfigure(pieceLength, totalLength);
@@ -228,13 +228,13 @@ int Peer::calculateDownloadSpeed()
   return res_->getPeerStat().calculateDownloadSpeed();
 }
 
-off_t Peer::getSessionUploadLength() const
+int64_t Peer::getSessionUploadLength() const
 {
   assert(res_);
   return res_->uploadLength();
 }
 
-off_t Peer::getSessionDownloadLength() const
+int64_t Peer::getSessionDownloadLength() const
 {
   assert(res_);
   return res_->downloadLength();
@@ -388,7 +388,7 @@ const Timer& Peer::getLastAmUnchoking() const
   return res_->getLastAmUnchoking();
 }
 
-off_t Peer::getCompletedLength() const
+int64_t Peer::getCompletedLength() const
 {
   assert(res_);
   return res_->getCompletedLength();

src/Peer.h

@@ -160,9 +160,9 @@ public:
 
   bool isGood() const;
 
-  void allocateSessionResource(int32_t pieceLength, off_t totalLength);
+  void allocateSessionResource(int32_t pieceLength, int64_t totalLength);
 
-  void reconfigureSessionResource(int32_t pieceLength, off_t totalLength);
+  void reconfigureSessionResource(int32_t pieceLength, int64_t totalLength);
 
   void releaseSessionResource();
 
@@ -234,12 +234,12 @@ public:
   /**
    * Returns the number of bytes uploaded to the remote host.
    */
-  off_t getSessionUploadLength() const;
+  int64_t getSessionUploadLength() const;
 
   /**
    * Returns the number of bytes downloaded from the remote host.
    */
-  off_t getSessionDownloadLength() const;
+  int64_t getSessionDownloadLength() const;
   
   void setBitfield(const unsigned char* bitfield, size_t bitfieldLength);
 
@@ -293,7 +293,7 @@ public:
 
   const Timer& getLastAmUnchoking() const;
 
-  off_t getCompletedLength() const;
+  int64_t getCompletedLength() const;
 
   bool isIncomingPeer() const
   {

src/PeerSessionResource.cc

@@ -44,7 +44,7 @@
 
 namespace aria2 {
 
-PeerSessionResource::PeerSessionResource(int32_t pieceLength, off_t totalLength)
+PeerSessionResource::PeerSessionResource(int32_t pieceLength, int64_t totalLength)
   :
   amChoking_(true),
   amInterested_(false),
@@ -225,7 +225,7 @@ void PeerSessionResource::dhtEnabled(bool b)
   dhtEnabled_ = b;
 }
 
-off_t PeerSessionResource::uploadLength() const
+int64_t PeerSessionResource::uploadLength() const
 {
   return peerStat_.getSessionUploadLength();
 }
@@ -235,7 +235,7 @@ void PeerSessionResource::updateUploadLength(int32_t bytes)
   peerStat_.updateUploadLength(bytes);
 }
 
-off_t PeerSessionResource::downloadLength() const
+int64_t PeerSessionResource::downloadLength() const
 {
   return peerStat_.getSessionDownloadLength();
 }
@@ -247,7 +247,7 @@ void PeerSessionResource::updateDownloadLength(int32_t bytes)
   lastDownloadUpdate_ = global::wallclock();
 }
 
-off_t PeerSessionResource::getCompletedLength() const
+int64_t PeerSessionResource::getCompletedLength() const
 {
   return bitfieldMan_->getCompletedLength();
 }
@@ -263,7 +263,7 @@ size_t PeerSessionResource::countOutstandingUpload() const
   return dispatcher_->countOutstandingUpload();
 }
 
-void PeerSessionResource::reconfigure(int32_t pieceLength, off_t totalLenth)
+void PeerSessionResource::reconfigure(int32_t pieceLength, int64_t totalLenth)
 {
   delete bitfieldMan_;
   bitfieldMan_ = new BitfieldMan(pieceLength, totalLenth);

src/PeerSessionResource.h

@@ -83,7 +83,7 @@ private:
 
   BtMessageDispatcher* dispatcher_;
 public:
-  PeerSessionResource(int32_t pieceLength, off_t totalLength);
+  PeerSessionResource(int32_t pieceLength, int64_t totalLength);
 
   ~PeerSessionResource();
 
@@ -155,7 +155,7 @@ public:
 
   size_t getBitfieldLength() const;
 
-  void reconfigure(int32_t pieceLength, off_t totalLength);
+  void reconfigure(int32_t pieceLength, int64_t totalLength);
 
   bool hasPiece(size_t index) const;
 
@@ -210,11 +210,11 @@ public:
     return peerStat_;
   }
 
-  off_t uploadLength() const;
+  int64_t uploadLength() const;
 
   void updateUploadLength(int32_t bytes);
 
-  off_t downloadLength() const;
+  int64_t downloadLength() const;
 
   void updateDownloadLength(int32_t bytes);
 
@@ -228,7 +228,7 @@ public:
     return lastAmUnchoking_;
   }
 
-  off_t getCompletedLength() const;
+  int64_t getCompletedLength() const;
 
   void setBtMessageDispatcher(BtMessageDispatcher* dpt);
 

src/PieceStorage.h

@@ -179,13 +179,13 @@ public:
 
   virtual bool isPieceUsed(size_t index) = 0;
 
-  virtual off_t getTotalLength() = 0;
+  virtual int64_t getTotalLength() = 0;
 
-  virtual off_t getFilteredTotalLength() = 0;
+  virtual int64_t getFilteredTotalLength() = 0;
 
-  virtual off_t getCompletedLength() = 0;
+  virtual int64_t getCompletedLength() = 0;
 
-  virtual off_t getFilteredCompletedLength() = 0;
+  virtual int64_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(off_t length) = 0;
+  virtual void markPiecesDone(int64_t length) = 0;
 
   virtual void
   addInFlightPiece(const std::vector<SharedHandle<Piece> >& pieces) = 0;

src/PiecedSegment.cc

@@ -61,12 +61,12 @@ size_t PiecedSegment::getIndex() const
   return piece_->getIndex();
 }
 
-off_t PiecedSegment::getPosition() const
+int64_t PiecedSegment::getPosition() const
 {
-  return ((off_t)piece_->getIndex())*pieceLength_;
+  return ((int64_t)piece_->getIndex())*pieceLength_;
 }
 
-off_t PiecedSegment::getPositionToWrite() const
+int64_t PiecedSegment::getPositionToWrite() const
 {
   return getPosition()+writtenLength_;
 }

src/PiecedSegment.h

@@ -58,9 +58,9 @@ public:
 
   virtual size_t getIndex() const;
 
-  virtual off_t getPosition() const;
+  virtual int64_t getPosition() const;
 
-  virtual off_t getPositionToWrite() const;
+  virtual int64_t getPositionToWrite() const;
 
   virtual int32_t getLength() const;
 

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, off_t entityLength)
+Range::Range(int64_t startByte, int64_t endByte, int64_t entityLength)
   : startByte_(startByte), endByte_(endByte), entityLength_(entityLength)
 {}
 
@@ -72,7 +72,7 @@ bool Range::operator!=(const Range& range) const
   return !(*this == range);
 }
 
-off_t Range::getContentLength() const
+int64_t Range::getContentLength() const
 {
   if(endByte_ >= startByte_) {
     return endByte_-startByte_+1;

src/Range.h

@@ -45,13 +45,13 @@ namespace aria2 {
 
 class Range {
 private:
-  off_t startByte_;
-  off_t endByte_;
-  off_t entityLength_;
+  int64_t startByte_;
+  int64_t endByte_;
+  int64_t entityLength_;
 public:
   Range();
 
-  Range(off_t startByte, off_t endByte, off_t entityLength);
+  Range(int64_t startByte, int64_t endByte, int64_t entityLength);
 
   Range(const Range& c);
 
@@ -63,22 +63,22 @@ public:
 
   bool operator!=(const Range& range) const;
 
-  off_t getStartByte() const
+  int64_t getStartByte() const
   {
     return startByte_;
   }
 
-  off_t getEndByte() const
+  int64_t getEndByte() const
   {
     return endByte_;
   }
 
-  off_t getEntityLength() const
+  int64_t getEntityLength() const
   {
     return entityLength_;
   }
 
-  off_t getContentLength() const;
+  int64_t getContentLength() const;
 };
 
 typedef SharedHandle<Range> RangeHandle;

src/RequestGroup.cc

@@ -386,7 +386,7 @@ void RequestGroup::createInitialCommand
       }
       removeDefunctControlFile(progressInfoFile);
       {
-        off_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
+        int64_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.
@@ -551,7 +551,7 @@ void RequestGroup::processCheckIntegrityEntry
  const SharedHandle<CheckIntegrityEntry>& entry,
  DownloadEngine* e)
 {
-  off_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
+  int64_t actualFileSize = pieceStorage_->getDiskAdaptor()->size();
   if(actualFileSize > downloadContext_->getTotalLength()) {
     entry->cutTrailingGarbage();
   }
@@ -858,7 +858,7 @@ std::string RequestGroup::getFirstFilePath() const
   }
 }
 
-off_t RequestGroup::getTotalLength() const
+int64_t RequestGroup::getTotalLength() const
 {
   if(!pieceStorage_) {
     return 0;
@@ -871,7 +871,7 @@ off_t RequestGroup::getTotalLength() const
   }
 }
 
-off_t RequestGroup::getCompletedLength() const
+int64_t RequestGroup::getCompletedLength() const
 {
   if(!pieceStorage_) {
     return 0;
@@ -897,8 +897,8 @@ void RequestGroup::validateFilename(const std::string& expectedFilename,
   }
 }
 
-void RequestGroup::validateTotalLength(off_t expectedTotalLength,
-                                       off_t actualTotalLength) const
+void RequestGroup::validateTotalLength(int64_t expectedTotalLength,
+                                       int64_t actualTotalLength) const
 {
   if(expectedTotalLength <= 0) {
     return;
@@ -916,7 +916,7 @@ void RequestGroup::validateFilename(const std::string& actualFilename) const
   validateFilename(downloadContext_->getFileEntries().front()->getBasename(), actualFilename);
 }
 
-void RequestGroup::validateTotalLength(off_t actualTotalLength) const
+void RequestGroup::validateTotalLength(int64_t actualTotalLength) const
 {
   validateTotalLength(getTotalLength(), actualTotalLength);
 }
@@ -1199,7 +1199,7 @@ void RequestGroup::reportDownloadFinished()
 #ifdef ENABLE_BITTORRENT
   if(downloadContext_->hasAttribute(bittorrent::BITTORRENT)) {
     TransferStat stat = calculateStat();
-    off_t completedLength = getCompletedLength();
+    int64_t completedLength = getCompletedLength();
     double shareRatio = completedLength == 0 ? 0.0 :
       1.0*stat.getAllTimeUploadLength()/completedLength;
     SharedHandle<TorrentAttribute> attrs =

src/RequestGroup.h

@@ -230,9 +230,9 @@ public:
 
   std::string getFirstFilePath() const;
 
-  off_t getTotalLength() const;
+  int64_t getTotalLength() const;
 
-  off_t getCompletedLength() const;
+  int64_t getCompletedLength() const;
 
   /**
    * Compares expected filename with specified actualFilename.
@@ -241,10 +241,10 @@ public:
    */
   void validateFilename(const std::string& actualFilename) const;
 
-  void validateTotalLength(off_t expectedTotalLength,
-                           off_t actualTotalLength) const;
+  void validateTotalLength(int64_t expectedTotalLength,
+                           int64_t actualTotalLength) const;
 
-  void validateTotalLength(off_t actualTotalLength) const;
+  void validateTotalLength(int64_t actualTotalLength) const;
 
   void setNumConcurrentCommand(int num)
   {

src/RequestGroupMan.cc

@@ -775,7 +775,7 @@ void RequestGroupMan::formatDownloadResultFull
     if((*i)->getLength() == 0 || downloadResult->bitfield.empty()) {
       o << "  -|";
     } else {
-      off_t completedLength =
+      int64_t completedLength =
         bt.getOffsetCompletedLength((*i)->getOffset(), (*i)->getLength());
       o << std::setw(3) << 100*completedLength/(*i)->getLength() << "|";
     }

src/RpcMethodImpl.cc

@@ -585,7 +585,7 @@ void createFileEntry
     entry->put(KEY_PATH, (*first)->getPath());
     entry->put(KEY_SELECTED, (*first)->isRequested()?VLB_TRUE:VLB_FALSE);
     entry->put(KEY_LENGTH, util::itos((*first)->getLength()));
-    off_t completedLength = bf->getOffsetCompletedLength
+    int64_t completedLength = bf->getOffsetCompletedLength
       ((*first)->getOffset(), (*first)->getLength());
     entry->put(KEY_COMPLETED_LENGTH, util::itos(completedLength));
 
@@ -602,7 +602,7 @@ template<typename InputIterator>
 void createFileEntry
 (const SharedHandle<List>& files,
  InputIterator first, InputIterator last,
- off_t totalLength,
+ int64_t totalLength,
  int32_t pieceLength,
  const std::string& bitfield)
 {
@@ -618,7 +618,7 @@ template<typename InputIterator>
 void createFileEntry
 (const SharedHandle<List>& files,
  InputIterator first, InputIterator last,
- off_t totalLength,
+ int64_t totalLength,
  int32_t pieceLength,
  const SharedHandle<PieceStorage>& ps)
 {

src/Segment.h

@@ -54,9 +54,9 @@ public:
 
   virtual size_t getIndex() const = 0;
 
-  virtual off_t getPosition() const = 0;
+  virtual int64_t getPosition() const = 0;
   
-  virtual off_t getPositionToWrite() const = 0;
+  virtual int64_t getPositionToWrite() const = 0;
 
   virtual int32_t getLength() const = 0;
 

src/SegmentMan.cc

@@ -94,7 +94,7 @@ void SegmentMan::init()
   // PieceStorage here?
 }
 
-off_t SegmentMan::getTotalLength() const
+int64_t SegmentMan::getTotalLength() const
 {
   if(!pieceStorage_) {
     return 0;
@@ -340,7 +340,7 @@ bool SegmentMan::hasSegment(size_t index) const {
   return pieceStorage_->hasPiece(index);
 }
 
-off_t SegmentMan::getDownloadLength() const {
+int64_t SegmentMan::getDownloadLength() const {
   if(!pieceStorage_) {
     return 0;
   } else {
@@ -442,14 +442,14 @@ void SegmentMan::updateDownloadSpeedFor(const SharedHandle<PeerStat>& pstat)
 namespace {
 class PeerStatDownloadLengthOperator {
 public:
-  off_t operator()(off_t total, const SharedHandle<PeerStat>& ps)
+  int64_t operator()(int64_t total, const SharedHandle<PeerStat>& ps)
   {
     return ps->getSessionDownloadLength()+total;
   }
 };
 } // namespace
 
-off_t SegmentMan::calculateSessionDownloadLength() const
+int64_t SegmentMan::calculateSessionDownloadLength() const
 {
   return std::accumulate(fastestPeerStats_.begin(), fastestPeerStats_.end(),
                          0LL, PeerStatDownloadLengthOperator());

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.
    */
-  off_t getTotalLength() const;
+  int64_t getTotalLength() const;
 
   /**
    * Returs true when the download has finished.
@@ -202,7 +202,7 @@ public:
   /**
    * Returns the length of bytes downloaded.
    */
-  off_t getDownloadLength() const;
+  int64_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.
    */
-  off_t calculateSessionDownloadLength() const;
+  int64_t calculateSessionDownloadLength() const;
 
   size_t countFreePieceFrom(size_t index) const;
 

src/UnknownLengthPieceStorage.cc

@@ -238,7 +238,7 @@ void UnknownLengthPieceStorage::markAllPiecesDone()
   downloadFinished_ = true;
 }
 
-void UnknownLengthPieceStorage::markPiecesDone(off_t length)
+void UnknownLengthPieceStorage::markPiecesDone(int64_t length)
 {
   // TODO not implemented yet
   abort();

src/UnknownLengthPieceStorage.h

@@ -54,7 +54,7 @@ private:
 
   SharedHandle<DiskWriterFactory> diskWriterFactory_;
 
-  off_t totalLength_;
+  int64_t totalLength_;
 
   bool downloadFinished_;
 
@@ -152,23 +152,23 @@ public:
 
   virtual bool isPieceUsed(size_t index);
 
-  virtual off_t getTotalLength()
+  virtual int64_t getTotalLength()
   {
     return totalLength_;
   }
 
-  virtual off_t getFilteredTotalLength()
+  virtual int64_t getFilteredTotalLength()
   {
     return totalLength_;
   }
 
-  virtual off_t getCompletedLength()
+  virtual int64_t getCompletedLength()
   {
     // TODO we have to return actual completed length here?
     return totalLength_;
   }
 
-  virtual off_t getFilteredCompletedLength()
+  virtual int64_t getFilteredCompletedLength()
   {
     return getCompletedLength();
   }
@@ -259,7 +259,7 @@ public:
    */
   virtual void markAllPiecesDone();
 
-  virtual void markPiecesDone(off_t length);
+  virtual void markPiecesDone(int64_t length);
 
   virtual void markPieceMissing(size_t index);
 

src/bittorrent_helper.cc

@@ -234,7 +234,7 @@ void extractFileEntries
   if(filesList) {
     fileEntries.reserve(filesList->size());
     int64_t length = 0;
-    off_t offset = 0;
+    int64_t offset = 0;
     // multi-file mode
     torrent->mode = MULTI;
     for(List::ValueType::const_iterator itr = filesList->begin(),

src/util.cc

@@ -689,7 +689,7 @@ void computeHeadPieces
 (std::vector<size_t>& indexes,
  const std::vector<SharedHandle<FileEntry> >& fileEntries,
  size_t pieceLength,
- off_t head)
+ int64_t head)
 {
   if(head == 0) {
     return;
@@ -714,7 +714,7 @@ void computeTailPieces
 (std::vector<size_t>& indexes,
  const std::vector<SharedHandle<FileEntry> >& fileEntries,
  size_t pieceLength,
- off_t tail)
+ int64_t tail)
 {
   if(tail == 0) {
     return;
@@ -739,7 +739,7 @@ void parsePrioritizePieceRange
 (std::vector<size_t>& result, const std::string& src,
  const std::vector<SharedHandle<FileEntry> >& fileEntries,
  size_t pieceLength,
- off_t defaultSize)
+ int64_t defaultSize)
 {
   std::vector<size_t> indexes;
   std::vector<Scip> parts;
@@ -1179,7 +1179,7 @@ void convertBitfield(BitfieldMan* dest, const BitfieldMan* src)
 {
   size_t numBlock = dest->countBlock();
   for(size_t index = 0; index < numBlock; ++index) {
-    if(src->isBitSetOffsetRange((off_t)index*dest->getBlockLength(),
+    if(src->isBitSetOffsetRange((int64_t)index*dest->getBlockLength(),
                                 dest->getBlockLength())) {
       dest->setBit(index);
     }

src/util.h

@@ -293,7 +293,7 @@ void parsePrioritizePieceRange
 (std::vector<size_t>& result, const std::string& src,
  const std::vector<SharedHandle<FileEntry> >& fileEntries,
  size_t pieceLength,
- off_t defaultSize = 1048576 /* 1MiB */);
+ int64_t defaultSize = 1048576 /* 1MiB */);
 
 // Converts ISO/IEC 8859-1 string src to utf-8.
 std::string iso8859ToUtf8(const std::string& src);

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((off_t)12ULL, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)4ULL, btman.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)4ULL, btman.getFilteredTotalLength());
   CPPUNIT_ASSERT(btman.isFilteredAllBitSet());
 
   BitfieldMan btman2(2, 31);
   btman2.addFilter(0, 31);
   btman2.enableFilter();
-  CPPUNIT_ASSERT_EQUAL((off_t)31ULL, btman2.getFilteredTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)0, bt.getOffsetCompletedLength(0, 1024));
-  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(0, 0));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(0, 1024));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(0, 0));
   for(size_t i = 2; i <= 4; ++i) {
     bt.setBit(i);
   }
   // 00111|00000|00000|00000
-  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,
+  CPPUNIT_ASSERT_EQUAL((int64_t)3072, bt.getOffsetCompletedLength(2048, 3072));
+  CPPUNIT_ASSERT_EQUAL((int64_t)3071, bt.getOffsetCompletedLength(2047, 3072));
+  CPPUNIT_ASSERT_EQUAL((int64_t)3071, bt.getOffsetCompletedLength(2049, 3072));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(2048, 0));
+  CPPUNIT_ASSERT_EQUAL((int64_t)1, bt.getOffsetCompletedLength(2048, 1));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(2047, 1));
+  CPPUNIT_ASSERT_EQUAL((int64_t)3072, bt.getOffsetCompletedLength(0, 1024*20));
+  CPPUNIT_ASSERT_EQUAL((int64_t)3072,
                        bt.getOffsetCompletedLength(0, 1024*20+10));
-  CPPUNIT_ASSERT_EQUAL((off_t)0, bt.getOffsetCompletedLength(1024*20, 1));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, bt.getOffsetCompletedLength(1024*20, 1));
 }
 
 void BitfieldManTest::testGetMissingUnusedLength()
 {
-  off_t totalLength = 1024*10+10;
+  int64_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((off_t)10ULL, bf.getMissingUnusedLength(10));
+  CPPUNIT_ASSERT_EQUAL((int64_t)10ULL, bf.getMissingUnusedLength(10));
 
   // from index 11
-  CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(11));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0ULL, bf.getMissingUnusedLength(11));
 
   // from index 12
-  CPPUNIT_ASSERT_EQUAL((off_t)0ULL, bf.getMissingUnusedLength(12));
+  CPPUNIT_ASSERT_EQUAL((int64_t)0ULL, bf.getMissingUnusedLength(12));
 
   // from index 0 and 5th block is used.
   bf.setUseBit(5);
-  CPPUNIT_ASSERT_EQUAL((off_t)(5LL*blockLength), bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL((int64_t)(5LL*blockLength), bf.getMissingUnusedLength(0));
 
   // from index 0 and 4th block is acquired.
   bf.setBit(4);
-  CPPUNIT_ASSERT_EQUAL((off_t)(4LL*blockLength), bf.getMissingUnusedLength(0));
+  CPPUNIT_ASSERT_EQUAL((int64_t)(4LL*blockLength), bf.getMissingUnusedLength(0));
 
   // from index 1
-  CPPUNIT_ASSERT_EQUAL((off_t)(3LL*blockLength), bf.getMissingUnusedLength(1));
+  CPPUNIT_ASSERT_EQUAL((int64_t)(3LL*blockLength), bf.getMissingUnusedLength(1));
 }
 
 void BitfieldManTest::testSetBitRange()
 {
   size_t blockLength = 1024*1024;
-  off_t totalLength = 10*blockLength;
+  int64_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((off_t)(5LL*blockLength), bf.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)(5LL*blockLength), bf.getCompletedLength());
 }
 
 void BitfieldManTest::testGetAllMissingIndexes_noarg()
 {
   size_t blockLength = 16*1024;
-  off_t totalLength = 1024*1024;
+  int64_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;
-  off_t totalLength = blockLength*2;
+  int64_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;
-  off_t totalLength = 1024*1024;
+  int64_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;
-  off_t totalLength = 1024*1024;
+  int64_t totalLength = 1024*1024;
   size_t nbits = (totalLength+blockLength-1)/blockLength;
   BitfieldMan bf(blockLength, totalLength);
   BitfieldMan peerBf(blockLength, totalLength);

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((off_t)384LL, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)384LL, dctx->getTotalLength());
 }
 
 void BittorrentHelperTest::testGetTotalLengthSingle() {
   SharedHandle<DownloadContext> dctx(new DownloadContext());
   load(A2_TEST_DIR"/single.torrent", dctx, option_);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)384LL, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)384LL, dctx->getTotalLength());
 }
 
 void BittorrentHelperTest::testGetFileModeMulti() {

test/DefaultBtProgressInfoFileTest.cc

@@ -53,7 +53,7 @@ private:
   SharedHandle<Option> option_;
   SharedHandle<BitfieldMan> bitfield_;
 public:   
-  void initializeMembers(int32_t pieceLength, off_t totalLength)
+  void initializeMembers(int32_t pieceLength, int64_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((off_t)81920, dctx_->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx_->getTotalLength());
 
   // upload length
-  CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)81920, dctx_->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx_->getTotalLength());
 
   // upload length
-  CPPUNIT_ASSERT_EQUAL((off_t)1024, btRuntime_->getUploadLengthAtStartup());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)81920, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)81920, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)81920, dctx->getTotalLength());
 
   // bitfield
   CPPUNIT_ASSERT_EQUAL(std::string("fffffffffffffffffffe"),

test/DefaultPieceStorageTest.cc

@@ -80,7 +80,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DefaultPieceStorageTest);
 void DefaultPieceStorageTest::testGetTotalLength() {
   DefaultPieceStorage pss(dctx_, option_.get());
 
-  CPPUNIT_ASSERT_EQUAL((off_t)384LL, pss.getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)0LL, pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, pss.getCompletedLength());
 
   pss.completePiece(piece);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)128LL, pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)128LL, pss.getCompletedLength());
 
   SharedHandle<Piece> incompletePiece = pss.getMissingPiece(peer, 1);
   incompletePiece->completeBlock(0);
-  CPPUNIT_ASSERT_EQUAL((off_t)256LL, pss.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)256LL, pss.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetPiece() {
@@ -264,7 +264,7 @@ void DefaultPieceStorageTest::testGetPieceCompletedPiece() {
 void DefaultPieceStorageTest::testCancelPiece()
 {
   size_t pieceLength = 256*1024;
-  off_t totalLength = 32*pieceLength; // <-- make the number of piece greater than END_GAME_PIECE_NUM
+  int64_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;
-  off_t totalLength = 4*1024*1024;
+  int64_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((off_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)pieceLength*10+16*1024*2, ps.getCompletedLength());
 
   ps.markPiecesDone(totalLength);
 
@@ -312,7 +312,7 @@ void DefaultPieceStorageTest::testMarkPiecesDone()
   }
 
   ps.markPiecesDone(0);
-  CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, ps.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetCompletedLength()
@@ -322,10 +322,10 @@ void DefaultPieceStorageTest::testGetCompletedLength()
   
   DefaultPieceStorage ps(dctx, option_.get());
   
-  CPPUNIT_ASSERT_EQUAL((off_t)0, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0, ps.getCompletedLength());
 
   ps.markPiecesDone(250*1024*1024);
-  CPPUNIT_ASSERT_EQUAL((off_t)250*1024*1024, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)251*1024*1024, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)251*1024*1024, ps.getCompletedLength());
 
   ps.markPiecesDone(256*1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)256*1024*1024, ps.getCompletedLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)256*1024*1024, ps.getCompletedLength());
 }
 
 void DefaultPieceStorageTest::testGetNextUsedIndex()

test/DirectDiskAdaptorTest.cc

@@ -46,7 +46,7 @@ void DirectDiskAdaptorTest::testCutTrailingGarbage()
 
   adaptor.cutTrailingGarbage();
 
-  CPPUNIT_ASSERT_EQUAL((off_t)entry->getLength(),
+  CPPUNIT_ASSERT_EQUAL((int64_t)entry->getLength(),
                        File(entry->getPath()).size());
 }
 

test/FallocFileAllocationIteratorTest.cc

@@ -35,7 +35,7 @@ void FallocFileAllocationIteratorTest::testAllocate()
   of.close();
 
   File f(fn);
-  CPPUNIT_ASSERT_EQUAL((off_t)10, f.size());
+  CPPUNIT_ASSERT_EQUAL((int64_t)10, f.size());
 
   DefaultDiskWriter writer(fn);
   int64_t offset = 10;
@@ -48,7 +48,7 @@ void FallocFileAllocationIteratorTest::testAllocate()
   itr.allocateChunk();
   CPPUNIT_ASSERT(itr.finished());
 
-  CPPUNIT_ASSERT_EQUAL((off_t)40960, f.size());
+  CPPUNIT_ASSERT_EQUAL((int64_t)40960, f.size());
 #endif // !HAVE_FALLOCATE
 }
 

test/FtpConnectionTest.cc

@@ -287,9 +287,9 @@ void FtpConnectionTest::testReceiveSizeResponse()
 {
   serverSocket_->writeData("213 4294967296\r\n");
   waitRead(clientSocket_);
-  off_t size;
+  int64_t size;
   CPPUNIT_ASSERT_EQUAL(213, ftp_->receiveSizeResponse(size));
-  CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, size);
+  CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, size);
 }
 
 void FtpConnectionTest::testSendRetr()

test/GZipDecodingStreamFilterTest.cc

@@ -26,7 +26,7 @@ class GZipDecodingStreamFilterTest:public CppUnit::TestFixture {
 
   class MockSegment2:public MockSegment {
   private:
-    off_t positionToWrite_;
+    int64_t positionToWrite_;
   public:
     MockSegment2():positionToWrite_(0) {}
 
@@ -35,7 +35,7 @@ class GZipDecodingStreamFilterTest:public CppUnit::TestFixture {
       positionToWrite_ += bytes;
     }
 
-    virtual off_t getPositionToWrite() const
+    virtual int64_t getPositionToWrite() const
     {
       return positionToWrite_;
     }

test/GrowSegmentTest.cc

@@ -27,7 +27,7 @@ void GrowSegmentTest::testUpdateWrittenLength()
   GrowSegment segment(SharedHandle<Piece>(new Piece()));
   segment.updateWrittenLength(32*1024);
   
-  CPPUNIT_ASSERT_EQUAL((off_t)32*1024, segment.getPositionToWrite());
+  CPPUNIT_ASSERT_EQUAL((int64_t)32*1024, segment.getPositionToWrite());
   CPPUNIT_ASSERT(!segment.complete());
   CPPUNIT_ASSERT(segment.getPiece()->pieceComplete());
 }

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((off_t)1024, dctx->getTotalLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)1024, dctx->getTotalLength());
   CPPUNIT_ASSERT(dctx->knowsTotalLength());
 
   // See Peer is not marked as seeder if !attrs->metadata.empty()

test/HttpHeaderTest.cc

@@ -34,9 +34,9 @@ void HttpHeaderTest::testGetRange()
     
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775800LL, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775801LL, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -45,9 +45,9 @@ void HttpHeaderTest::testGetRange()
      
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775800LL, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775801LL, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)9223372036854775807LL, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775800LL, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775801LL, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -55,9 +55,9 @@ void HttpHeaderTest::testGetRange()
 
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -65,9 +65,9 @@ void HttpHeaderTest::testGetRange()
 
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -75,9 +75,9 @@ void HttpHeaderTest::testGetRange()
 
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -85,9 +85,9 @@ void HttpHeaderTest::testGetRange()
 
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;
@@ -95,9 +95,9 @@ void HttpHeaderTest::testGetRange()
 
     SharedHandle<Range> range = httpHeader.getRange();
 
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getStartByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEndByte());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, range->getEntityLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getStartByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEndByte());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, range->getEntityLength());
   }
   {
     HttpHeader httpHeader;

test/HttpRequestTest.cc

@@ -78,12 +78,12 @@ void HttpRequestTest::testGetStartByte()
   SharedHandle<Segment> segment(new PiecedSegment(1024, p));
   SharedHandle<FileEntry> fileEntry(new FileEntry("file", 1024*10, 0));
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getStartByte());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getStartByte());
 
   httpRequest.setSegment(segment);
   httpRequest.setFileEntry(fileEntry);
   
-  CPPUNIT_ASSERT_EQUAL((off_t)1024LL, httpRequest.getStartByte());
+  CPPUNIT_ASSERT_EQUAL((int64_t)1024LL, httpRequest.getStartByte());
 }
 
 void HttpRequestTest::testGetEndByte()
@@ -97,11 +97,11 @@ void HttpRequestTest::testGetEndByte()
   SharedHandle<Segment> segment(new PiecedSegment(segmentLength, piece));
   SharedHandle<FileEntry> fileEntry(new FileEntry("file", segmentLength*10, 0));
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getEndByte());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
 
   httpRequest.setSegment(segment);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getEndByte());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
 
   SharedHandle<Request> request(new Request());
   request->supportsPersistentConnection(true);
@@ -110,18 +110,18 @@ void HttpRequestTest::testGetEndByte()
   httpRequest.setRequest(request);
   httpRequest.setFileEntry(fileEntry);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)(segmentLength*index+length-1),
+  CPPUNIT_ASSERT_EQUAL((int64_t)(segmentLength*index+length-1),
                        httpRequest.getEndByte());
 
   // The end byte of FileEntry are placed inside segment
   fileEntry->setLength(segmentLength+100);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)(segmentLength*index+100-1),
+  CPPUNIT_ASSERT_EQUAL((int64_t)(segmentLength*index+100-1),
                        httpRequest.getEndByte());
 
   request->setPipeliningHint(false);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpRequest.getEndByte());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpRequest.getEndByte());
 }
 
 void HttpRequestTest::testCreateRequest()

test/HttpResponseTest.cc

@@ -101,7 +101,7 @@ void HttpResponseTest::testGetContentLength_null()
 {
   HttpResponse httpResponse;
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, httpResponse.getContentLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, httpResponse.getContentLength());
 }
 
 void HttpResponseTest::testGetContentLength_contentLength()
@@ -113,7 +113,7 @@ void HttpResponseTest::testGetContentLength_contentLength()
 
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getContentLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, httpResponse.getContentLength());
 }
 
 void HttpResponseTest::testGetEntityLength()
@@ -125,11 +125,11 @@ void HttpResponseTest::testGetEntityLength()
 
   httpResponse.setHttpHeader(httpHeader);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)4294967296LL, httpResponse.getEntityLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, httpResponse.getEntityLength());
 
   httpHeader->put("content-range", "bytes 1-4294967296/4294967297");
 
-  CPPUNIT_ASSERT_EQUAL((off_t)4294967297LL, httpResponse.getEntityLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)4294967297LL, httpResponse.getEntityLength());
 
 }
 

test/Metalink2RequestGroupTest.cc

@@ -58,7 +58,7 @@ void Metalink2RequestGroupTest::testGenerate()
     const SharedHandle<DownloadContext>& dctx = rg->getDownloadContext();
 
     CPPUNIT_ASSERT(dctx);
-    CPPUNIT_ASSERT_EQUAL((off_t)0LL, dctx->getTotalLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0LL, dctx->getTotalLength());
 #ifdef ENABLE_MESSAGE_DIGEST
     CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
     CPPUNIT_ASSERT_EQUAL

test/MetalinkParserControllerTest.cc

@@ -68,8 +68,8 @@ 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((off_t)(1024*1024LL), e->file->getLength());
-    CPPUNIT_ASSERT_EQUAL((off_t)0, e->file->getOffset());
+    CPPUNIT_ASSERT_EQUAL((int64_t)(1024*1024LL), e->file->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)0, e->file->getOffset());
     CPPUNIT_ASSERT_EQUAL(std::string("1.0"), e->version);
     CPPUNIT_ASSERT_EQUAL(std::string("ja_JP"), e->languages[0]);
     CPPUNIT_ASSERT_EQUAL(std::string("Linux"), e->oses[0]);

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((off_t)786430LL, e->getLength());
+  CPPUNIT_ASSERT_EQUAL((int64_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((off_t)0LL, entry1->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_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((off_t)345689LL, entry2->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_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((off_t)0LL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_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((off_t)43743838LL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_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((off_t)9223372036854775807LL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_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((off_t)9223372036854775807LL, e->getLength());
+    CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775807LL, e->getLength());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());
   }

test/MockPieceStorage.h

@@ -13,10 +13,10 @@ namespace aria2 {
 
 class MockPieceStorage : public PieceStorage {
 private:
-  off_t totalLength;
-  off_t filteredTotalLength;
-  off_t completedLength;
-  off_t filteredCompletedLength;
+  int64_t totalLength;
+  int64_t filteredTotalLength;
+  int64_t completedLength;
+  int64_t filteredCompletedLength;
   BitfieldMan* bitfieldMan;
   bool selectiveDownloadingMode;
   bool endGame;
@@ -117,7 +117,7 @@ public:
 
   virtual void markPieceMissing(size_t index) {}
 
-  virtual void markPiecesDone(off_t) {}
+  virtual void markPiecesDone(int64_t) {}
 
   virtual SharedHandle<Piece> getPiece(size_t index) {
     return SharedHandle<Piece>(new Piece());
@@ -131,35 +131,35 @@ public:
     return false;
   }
 
-  virtual off_t getTotalLength() {
+  virtual int64_t getTotalLength() {
     return totalLength;
   }
 
-  void setTotalLength(off_t totalLength) {
+  void setTotalLength(int64_t totalLength) {
     this->totalLength = totalLength;
   }
 
-  virtual off_t getFilteredTotalLength() {
+  virtual int64_t getFilteredTotalLength() {
     return filteredTotalLength;
   }
 
-  void setFilteredTotalLength(off_t totalLength) {
+  void setFilteredTotalLength(int64_t totalLength) {
     this->filteredTotalLength = totalLength;
   }
 
-  virtual off_t getCompletedLength() {
+  virtual int64_t getCompletedLength() {
     return completedLength;
   }
 
-  void setCompletedLength(off_t completedLength) {
+  void setCompletedLength(int64_t completedLength) {
     this->completedLength = completedLength;
   }
 
-  virtual off_t getFilteredCompletedLength() {
+  virtual int64_t getFilteredCompletedLength() {
     return filteredCompletedLength;
   }
 
-  void setFilteredCompletedLength(off_t completedLength) {
+  void setFilteredCompletedLength(int64_t completedLength) {
     this->filteredCompletedLength = completedLength;
   }
   

test/MockSegment.h

@@ -19,12 +19,12 @@ public:
     return 0;
   }
 
-  virtual off_t getPosition() const
+  virtual int64_t getPosition() const
   {
     return 0;
   }
   
-  virtual off_t getPositionToWrite() const
+  virtual int64_t getPositionToWrite() const
   {
     return 0;
   }

test/MultiDiskAdaptorTest.cc

@@ -386,9 +386,9 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage()
 
   adaptor.cutTrailingGarbage();
 
-  CPPUNIT_ASSERT_EQUAL((off_t)256,
+  CPPUNIT_ASSERT_EQUAL((int64_t)256,
                        File(entries[0]->getPath()).size());
-  CPPUNIT_ASSERT_EQUAL((off_t)512,
+  CPPUNIT_ASSERT_EQUAL((int64_t)512,
                        File(entries[1]->getPath()).size());
 }
 

test/MultiFileAllocationIteratorTest.cc

@@ -209,11 +209,11 @@ void MultiFileAllocationIteratorTest::testAllocate()
     while(!itr->finished()) {
       itr->allocateChunk();
     }
-    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_EQUAL((int64_t)length1, File(fileEntry1->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)length2, File(fileEntry2->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)length3, File(fileEntry3->getPath()).size());
     CPPUNIT_ASSERT(!File(fileEntry4->getPath()).isFile());
-    CPPUNIT_ASSERT_EQUAL((off_t)length5, File(fileEntry5->getPath()).size());
+    CPPUNIT_ASSERT_EQUAL((int64_t)length5, File(fileEntry5->getPath()).size());
     CPPUNIT_ASSERT(!File(fileEntry6->getPath()).isFile());
   } catch(Exception& e) {
     CPPUNIT_FAIL(e.stackTrace());

test/PeerSessionResourceTest.cc

@@ -106,20 +106,20 @@ void PeerSessionResourceTest::testUpdateUploadLength()
 {
   PeerSessionResource res(1024, 1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.uploadLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, res.uploadLength());
   res.updateUploadLength(100);
   res.updateUploadLength(200);
-  CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.uploadLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)300LL, res.uploadLength());
 }
 
 void PeerSessionResourceTest::testUpdateDownloadLength()
 {
   PeerSessionResource res(1024, 1024*1024);
 
-  CPPUNIT_ASSERT_EQUAL((off_t)0LL, res.downloadLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)0LL, res.downloadLength());
   res.updateDownloadLength(100);
   res.updateDownloadLength(200);
-  CPPUNIT_ASSERT_EQUAL((off_t)300LL, res.downloadLength());
+  CPPUNIT_ASSERT_EQUAL((int64_t)300LL, res.downloadLength());
 }
 
 void PeerSessionResourceTest::testExtendedMessageEnabled()

test/RequestGroupTest.cc

@@ -58,7 +58,7 @@ void RequestGroupTest::testCreateDownloadResult()
   
     CPPUNIT_ASSERT_EQUAL(std::string("/tmp/myfile"),
                          result->fileEntries[0]->getPath());
-    CPPUNIT_ASSERT_EQUAL((off_t)1024*1024,
+    CPPUNIT_ASSERT_EQUAL((int64_t)1024*1024,
                          result->fileEntries.back()->getLastOffset());
     CPPUNIT_ASSERT_EQUAL((uint64_t)0, result->sessionDownloadLength);
     CPPUNIT_ASSERT_EQUAL((int64_t)0, result->sessionTime);

test/SingleFileAllocationIteratorTest.cc

@@ -32,7 +32,7 @@ void SingleFileAllocationIteratorTest::testAllocate()
   of.close();
 
   File x(fn);
-  CPPUNIT_ASSERT_EQUAL((off_t)10, x.size());
+  CPPUNIT_ASSERT_EQUAL((int64_t)10, x.size());
 
   DefaultDiskWriter writer(fn);
   off_t offset = 10;
@@ -47,7 +47,7 @@ void SingleFileAllocationIteratorTest::testAllocate()
     itr.allocateChunk();
   }
   File f(fn);
-  CPPUNIT_ASSERT_EQUAL((off_t)40960, f.size());
+  CPPUNIT_ASSERT_EQUAL((int64_t)40960, f.size());
 }
 
 } // namespace aria2