From 6574e44f886740273676b6d73ef754385a36197f Mon Sep 17 00:00:00 2001 From: Tatsuhiro Tsujikawa Date: Sat, 21 Jul 2007 08:56:16 +0000 Subject: [PATCH] 2007-07-21 Tatsuhiro Tsujikawa Converted int's to in32_t. long long int's are also converted to int64_t --- ChangeLog | 5 ++ TODO | 8 ++ src/AbstractCommand.cc | 4 +- src/AbstractCommand.h | 8 +- src/AnnounceList.cc | 4 +- src/AnnounceList.h | 6 +- src/Base64.cc | 30 ++++---- src/Base64.h | 10 +-- src/BitfieldManFactory.h | 2 +- src/BtBitfieldMessageValidator.h | 4 +- src/BtHaveMessageValidator.h | 4 +- src/BtRequestFactory.h | 2 +- src/BtRuntime.h | 16 ++-- src/BtSuggestPieceMessageValidator.h | 4 +- src/ByteArrayDiskWriter.cc | 2 +- src/ByteArrayDiskWriter.h | 2 +- src/ChunkedEncoding.cc | 20 ++--- src/ChunkedEncoding.h | 20 +++-- src/Command.cc | 2 +- src/Command.h | 10 +-- src/CompactPeerListProcessor.cc | 15 ++-- src/CompactPeerListProcessor.h | 6 +- src/ConsoleDownloadEngine.cc | 25 ++----- src/ConsoleDownloadEngine.h | 12 +-- src/Data.cc | 10 +-- src/Data.h | 10 +-- src/DefaultBtAnnounce.cc | 4 +- src/DefaultBtAnnounce.h | 12 +-- src/DefaultBtProgressInfoFile.cc | 8 +- src/DefaultBtRequestFactory.h | 2 +- src/DefaultPeerListProcessor.cc | 6 +- src/DefaultPeerListProcessor.h | 6 +- src/DefaultPeerStorage.cc | 8 +- src/DefaultPeerStorage.h | 14 ++-- src/DefaultPieceStorage.cc | 64 ++++++++-------- src/DefaultPieceStorage.h | 46 ++++++------ src/DelegatingPeerListProcessor.h | 6 +- src/DiskWriter.h | 5 +- src/DownloadEngine.cc | 10 +-- src/DownloadEngine.h | 2 +- src/DownloadEngineFactory.cc | 4 +- src/FeatureConfig.cc | 6 +- src/FeatureConfig.h | 4 +- src/File.cc | 2 +- src/File.h | 6 +- src/FileEntry.cc | 4 +- src/FileEntry.h | 8 +- src/FtpConnection.cc | 32 ++++---- src/FtpConnection.h | 16 ++-- src/FtpNegotiationCommand.cc | 26 +++---- src/FtpNegotiationCommand.h | 4 +- src/HaveEraseCommand.cc | 4 +- src/HaveEraseCommand.h | 6 +- src/HttpConnection.cc | 2 +- src/HttpConnection.h | 4 +- src/HttpHeader.cc | 6 +- src/HttpHeader.h | 4 +- src/HttpRequest.cc | 2 +- src/HttpRequest.h | 4 +- src/MetaFileUtil.cc | 10 +-- src/MetaFileUtil.h | 2 +- src/MetalinkEntry.cc | 6 +- src/MetalinkEntry.h | 2 +- src/MetalinkRequestInfo.cc | 7 +- src/MetalinkResource.h | 4 +- src/MultiDiskAdaptor.cc | 2 +- src/MultiDiskAdaptor.h | 2 +- src/NameResolver.cc | 4 +- src/NameResolver.h | 6 +- src/Option.cc | 6 +- src/Option.h | 4 +- src/Peer.cc | 20 ++--- src/Peer.h | 52 ++++++------- src/PeerAbstractCommand.cc | 8 +- src/PeerAbstractCommand.h | 14 ++-- src/PeerChokeCommand.cc | 8 +- src/PeerChokeCommand.h | 8 +- src/PeerInteractionCommand.cc | 8 +- src/PeerInteractionCommand.h | 25 ++++--- src/PeerListenCommand.cc | 12 +-- src/PeerListenCommand.h | 6 +- src/PeerStat.h | 18 ++--- src/Piece.cc | 14 ++-- src/Piece.h | 38 +++++----- src/PieceStorage.h | 24 +++--- src/Randomizer.h | 4 +- src/Request.cc | 4 +- src/Request.h | 30 ++++---- src/RequestGroupEntry.h | 6 +- src/RequestSlot.cc | 2 +- src/RequestSlot.h | 2 +- src/Segment.h | 10 +-- src/SegmentMan.cc | 22 +++--- src/SegmentMan.h | 14 ++-- src/ShareRatioSeedCriteria.h | 2 +- src/SimpleBtMessage.cc | 4 +- src/SimpleBtMessage.h | 2 +- src/SimpleLogger.cc | 6 +- src/SimpleLogger.h | 8 +- src/SimpleRandomizer.h | 6 +- src/SleepCommand.cc | 2 +- src/SleepCommand.h | 6 +- src/Socket.cc | 18 ++--- src/SocketCore.cc | 62 ++++++++-------- src/SocketCore.h | 38 +++++----- src/TimeA2.cc | 12 +-- src/TimeA2.h | 22 +++--- src/TimeSeedCriteria.h | 8 +- src/TimeoutException.h | 6 +- src/TorrentAutoSaveCommand.cc | 4 +- src/TorrentAutoSaveCommand.h | 6 +- src/TorrentDownloadEngine.cc | 4 +- src/TorrentDownloadEngine.h | 20 ++--- src/TrackerUpdateCommand.cc | 4 +- src/TransferEncoding.h | 2 +- src/UrlRequestInfo.h | 6 +- src/Util.cc | 107 ++++++++++++--------------- src/Util.h | 26 +++---- src/main.cc | 8 +- src/messageDigest.h | 26 +++---- test/FixedNumberRandomizer.h | 10 +-- test/MetalinkEntryTest.cc | 8 +- test/Xml2MetalinkProcessorTest.cc | 4 +- 123 files changed, 706 insertions(+), 713 deletions(-) diff --git a/ChangeLog b/ChangeLog index e20413c8..4a5b8026 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2007-07-21 Tatsuhiro Tsujikawa + + Converted int's to in32_t. long long int's are also converted to + int64_t + 2007-07-20 Tatsuhiro Tsujikawa Fixed the bug that prevents cookies from being sent to the server diff --git a/TODO b/TODO index da7fcf49..6fb500a9 100644 --- a/TODO +++ b/TODO @@ -25,3 +25,11 @@ * consider life cycle of requestGroup and segmentMan * exit status: all downloads have been successful-> EXIT_SUCCESS, some of downloads have been failed -> EXIT_FAILURE + +* Fix log and stdout message in Metalink related class. +* Fix Cookie header's value. ';' is not necessary at the end of it. +* It is possible to replace all %lld to %s, using Util::llitos(...) ?. +* Time::getTimeInMillis() returns int64_t. +* Util::secfmt, What happens if sec is less than 0? +* Rewrite ChunkedEncoding +* typedef int32_t CUID in common.h or a2types.h \ No newline at end of file diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc index af49291f..38a49a01 100644 --- a/src/AbstractCommand.cc +++ b/src/AbstractCommand.cc @@ -43,7 +43,7 @@ #include "DNSCache.h" #include "FatalException.h" -AbstractCommand::AbstractCommand(int cuid, +AbstractCommand::AbstractCommand(int32_t cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e, @@ -147,7 +147,7 @@ void AbstractCommand::tryReserved() { e->addCommand(commands); } -bool AbstractCommand::prepareForRetry(int wait) { +bool AbstractCommand::prepareForRetry(int32_t wait) { _requestGroup->getSegmentMan()->cancelSegment(cuid); Command* command = InitiateConnectionCommandFactory::createInitiateConnectionCommand(cuid, req, _requestGroup, e); if(wait == 0) { diff --git a/src/AbstractCommand.h b/src/AbstractCommand.h index 7e6bcd7a..89f1d975 100644 --- a/src/AbstractCommand.h +++ b/src/AbstractCommand.h @@ -46,7 +46,7 @@ class AbstractCommand : public Command { private: Time checkPoint; - int timeout; + int32_t timeout; protected: RequestHandle req; RequestGroup* _requestGroup; @@ -55,7 +55,7 @@ protected: SegmentHandle segment; void tryReserved(); - virtual bool prepareForRetry(int wait); + virtual bool prepareForRetry(int32_t wait); virtual void onAbort(Exception* ex); virtual bool executeInternal() = 0; @@ -69,7 +69,7 @@ protected: void disableNameResolverCheck(const NameResolverHandle& resolver); virtual bool nameResolveFinished() const; #endif // ENABLE_ASYNC_DNS - void setTimeout(int timeout) { this->timeout = timeout; } + void setTimeout(int32_t timeout) { this->timeout = timeout; } private: bool checkSocketIsReadable; bool checkSocketIsWritable; @@ -77,7 +77,7 @@ private: SocketHandle writeCheckTarget; bool nameResolverCheck; public: - AbstractCommand(int cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e, const SocketHandle& s = SocketHandle()); + AbstractCommand(int32_t cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e, const SocketHandle& s = SocketHandle()); virtual ~AbstractCommand(); bool execute(); }; diff --git a/src/AnnounceList.cc b/src/AnnounceList.cc index fbe8025a..a7166252 100644 --- a/src/AnnounceList.cc +++ b/src/AnnounceList.cc @@ -176,11 +176,11 @@ public: } }; -int AnnounceList::countStoppedAllowedTier() const { +int32_t AnnounceList::countStoppedAllowedTier() const { return count_if(tiers.begin(), tiers.end(), FindStoppedAllowedTier()); } -int AnnounceList::countCompletedAllowedTier() const { +int32_t AnnounceList::countCompletedAllowedTier() const { return count_if(tiers.begin(), tiers.end(), FindCompletedAllowedTier()); } diff --git a/src/AnnounceList.h b/src/AnnounceList.h index fdd19a49..c0123d67 100644 --- a/src/AnnounceList.h +++ b/src/AnnounceList.h @@ -57,7 +57,7 @@ public: void reconfigure(const MetaEntry* announceListEntry); void reconfigure(const string& url); - int countTier() const { + int32_t countTier() const { return tiers.size(); } @@ -98,12 +98,12 @@ public: /** * Counts the number of tiers to which the "stopped" event can be sent. */ - int countStoppedAllowedTier() const; + int32_t countStoppedAllowedTier() const; /** * Counts the number of tiers to which the "completed" event can be sent. */ - int countCompletedAllowedTier() const; + int32_t countCompletedAllowedTier() const; /** * Moves current tier pointer to the tier to which the "stopped" event can diff --git a/src/Base64.cc b/src/Base64.cc index 0bf1d575..97d620d0 100644 --- a/src/Base64.cc +++ b/src/Base64.cc @@ -45,34 +45,34 @@ static char base64_table[64] = { '4', '5', '6', '7', '8', '9', '+', '/', }; -void Base64::part_encode(const unsigned char* sub, int subLength, +void Base64::part_encode(const unsigned char* sub, int32_t subLength, unsigned char* buf) { - int shift = 2; + int32_t shift = 2; unsigned char carry = 0; - int index; + int32_t index; for(index = 0; index < subLength; index++) { unsigned char cur = sub[index] >> shift | carry; carry = (sub[index] << (6-shift)) & 0x3f; shift += 2; - buf[index] = base64_table[(unsigned int)cur]; + buf[index] = base64_table[(uint32_t)cur]; } if(subLength == 1) { - buf[index] = base64_table[(unsigned int)carry]; + buf[index] = base64_table[(uint32_t)carry]; buf[index+1] = buf[index+2] = '='; } else if(subLength == 2) { - buf[index] = base64_table[(unsigned int)carry]; + buf[index] = base64_table[(uint32_t)carry]; buf[index+1] = '='; } else { unsigned char cur = sub[subLength-1] & 0x3f; - buf[index] = base64_table[(unsigned int)cur]; + buf[index] = base64_table[(uint32_t)cur]; } } string Base64::encode(const string& plainSrc) { unsigned char* result = 0; - int resultLength = 0; + int32_t resultLength = 0; encode((const unsigned char*)plainSrc.c_str(), plainSrc.size(), result, resultLength); @@ -81,12 +81,12 @@ string Base64::encode(const string& plainSrc) return encoded; } -void Base64::encode(const unsigned char* src, int srcLength, - unsigned char*& result, int& resultLength) { +void Base64::encode(const unsigned char* src, int32_t srcLength, + unsigned char*& result, int32_t& resultLength) { resultLength = (srcLength+(srcLength%3 == 0 ? 0 : 3-srcLength%3))/3*4; result = new unsigned char[resultLength]; unsigned char* tail = result; - for(int index = 0; srcLength > index; index += 3) { + for(int32_t index = 0; srcLength > index; index += 3) { unsigned char temp[4]; part_encode(&src[index], srcLength >= index+3 ? 3 : srcLength-index, @@ -119,10 +119,10 @@ char Base64::getValue(char ch) string Base64::part_decode(const string& subCrypted) { - int shift = 2; + int32_t shift = 2; string plain; - for(unsigned int index = 0; index < subCrypted.size()-1; ++index) { + for(uint32_t index = 0; index < subCrypted.size()-1; ++index) { if(subCrypted.at(index) == '=') break; char cur = getValue(subCrypted.at(index)) << shift; char carry = getValue(subCrypted.at(index+1)) >> (6-shift); @@ -136,8 +136,8 @@ string Base64::part_decode(const string& subCrypted) string Base64::decode(const string& crypted) { string plain; - int sIndex = 0; - for(int index = 0; crypted.size() > (unsigned int)index; index +=4) { + int32_t sIndex = 0; + for(int32_t index = 0; crypted.size() > (uint32_t)index; index +=4) { string subCrypted = crypted.substr(sIndex, 4); string subPlain = part_decode(subCrypted); sIndex += 4; diff --git a/src/Base64.h b/src/Base64.h index 03636bc9..4d363a66 100644 --- a/src/Base64.h +++ b/src/Base64.h @@ -41,7 +41,7 @@ using namespace std; class Base64 { private: - static void part_encode(const unsigned char* sub, int subLength, + static void part_encode(const unsigned char* sub, int32_t subLength, unsigned char* buf); static string part_encode(const string& subplain); @@ -50,12 +50,12 @@ private: public: static string encode(const string& plain); // caller must deallocate the memory used by result. - static void encode(const unsigned char* src, int srcLength, - unsigned char*& result, int& resultLength); + static void encode(const unsigned char* src, int32_t srcLength, + unsigned char*& result, int32_t& resultLength); static string decode(const string& crypted); // caller must deallocate the memory used by result. - static void decode(const unsigned char* src, int srcLength, - unsigned char*& result, int& resultLength); + static void decode(const unsigned char* src, int32_t srcLength, + unsigned char*& result, int32_t& resultLength); }; #endif // _BASE64_H_ diff --git a/src/BitfieldManFactory.h b/src/BitfieldManFactory.h index 8b7d9ca8..dfc86487 100644 --- a/src/BitfieldManFactory.h +++ b/src/BitfieldManFactory.h @@ -60,7 +60,7 @@ public: return factory; } - BitfieldMan* createBitfieldMan(int blockLength, long long int totalLength) { + BitfieldMan* createBitfieldMan(int32_t blockLength, int64_t totalLength) { BitfieldMan* bitfieldMan = new BitfieldMan(blockLength, totalLength); bitfieldMan->setRandomizer(randomizer); return bitfieldMan; diff --git a/src/BtBitfieldMessageValidator.h b/src/BtBitfieldMessageValidator.h index d7a8ddb0..6d69d622 100644 --- a/src/BtBitfieldMessageValidator.h +++ b/src/BtBitfieldMessageValidator.h @@ -41,10 +41,10 @@ class BtBitfieldMessageValidator : public BtMessageValidator { private: const BtBitfieldMessage* message; - int numPiece; + int32_t numPiece; public: BtBitfieldMessageValidator(const BtBitfieldMessage* message, - int numPiece): + int32_t numPiece): message(message), numPiece(numPiece) {} diff --git a/src/BtHaveMessageValidator.h b/src/BtHaveMessageValidator.h index acf2b351..0f7017cf 100644 --- a/src/BtHaveMessageValidator.h +++ b/src/BtHaveMessageValidator.h @@ -42,10 +42,10 @@ class BtHaveMessageValidator : public BtMessageValidator { private: const BtHaveMessage* message; - int numPiece; + int32_t numPiece; public: BtHaveMessageValidator(const BtHaveMessage* message, - int numPiece): + int32_t numPiece): message(message), numPiece(numPiece) {} diff --git a/src/BtRequestFactory.h b/src/BtRequestFactory.h index d3e17ad3..9cc07fcf 100644 --- a/src/BtRequestFactory.h +++ b/src/BtRequestFactory.h @@ -49,7 +49,7 @@ public: virtual void removeAllTargetPiece() = 0; - virtual int countTargetPiece() = 0; + virtual int32_t countTargetPiece() = 0; virtual void removeCompletedPiece() = 0; diff --git a/src/BtRuntime.h b/src/BtRuntime.h index 7c2313e7..4e1b7892 100644 --- a/src/BtRuntime.h +++ b/src/BtRuntime.h @@ -42,10 +42,10 @@ class BtRuntime { private: - long long int uploadLengthAtStartup; - int port; + int64_t uploadLengthAtStartup; + int32_t port; bool halt; - int connections; + int32_t connections; public: BtRuntime(): uploadLengthAtStartup(0), @@ -55,19 +55,19 @@ public: {} ~BtRuntime() {} - long long int getUploadLengthAtStartup() const { + int64_t getUploadLengthAtStartup() const { return uploadLengthAtStartup; } - void setUploadLengthAtStartup(long long int length) { + void setUploadLengthAtStartup(int64_t length) { this->uploadLengthAtStartup = length; } - void setListenPort(int port) { + void setListenPort(int32_t port) { this->port = port; } - int getListenPort() const { return port; } + int32_t getListenPort() const { return port; } bool isHalt() const { return halt; } @@ -75,7 +75,7 @@ public: this->halt = halt; } - int getConnections() const { return connections; } + int32_t getConnections() const { return connections; } void increaseConnections() { connections++; } diff --git a/src/BtSuggestPieceMessageValidator.h b/src/BtSuggestPieceMessageValidator.h index 293b3c71..4274f1de 100644 --- a/src/BtSuggestPieceMessageValidator.h +++ b/src/BtSuggestPieceMessageValidator.h @@ -41,10 +41,10 @@ class BtSuggestPieceMessageValidator : public BtMessageValidator { private: const BtSuggestPieceMessage* message; - int numPiece; + int32_t numPiece; public: BtSuggestPieceMessageValidator(const BtSuggestPieceMessage* message, - int numPiece): + int32_t numPiece): message(message), numPiece(numPiece) {} diff --git a/src/ByteArrayDiskWriter.cc b/src/ByteArrayDiskWriter.cc index 2a71ed38..dc284160 100644 --- a/src/ByteArrayDiskWriter.cc +++ b/src/ByteArrayDiskWriter.cc @@ -77,7 +77,7 @@ void ByteArrayDiskWriter::writeData(const char* data, int32_t dataLength, int64_ buf.write(data, dataLength); } -int ByteArrayDiskWriter::readData(char* data, int32_t len, int64_t position) { +int32_t ByteArrayDiskWriter::readData(char* data, int32_t len, int64_t position) { buf.seekg(position, ios_base::beg); buf.read(data, len); // TODO we have to call buf.clear() here? YES diff --git a/src/ByteArrayDiskWriter.h b/src/ByteArrayDiskWriter.h index 4e60bcda..227cac74 100644 --- a/src/ByteArrayDiskWriter.h +++ b/src/ByteArrayDiskWriter.h @@ -57,7 +57,7 @@ public: // position is ignored virtual void writeData(const char* data, int32_t len, int64_t position = 0); - virtual int readData(char* data, int32_t len, int64_t position); + virtual int32_t readData(char* data, int32_t len, int64_t position); // Not implemented yet virtual void truncate(int64_t length) {} diff --git a/src/ChunkedEncoding.cc b/src/ChunkedEncoding.cc index 31522378..b66439a4 100644 --- a/src/ChunkedEncoding.cc +++ b/src/ChunkedEncoding.cc @@ -64,10 +64,10 @@ bool ChunkedEncoding::finished() { void ChunkedEncoding::end() {} -void ChunkedEncoding::inflate(char* outbuf, int& outlen, const char* inbuf, int inlen) { +void ChunkedEncoding::inflate(char* outbuf, int32_t& outlen, const char* inbuf, int32_t inlen) { addBuffer(inbuf, inlen); char* p = strbuf; - int clen = 0; + int32_t clen = 0; while(1) { if(state == READ_SIZE) { if(readChunkSize(&p) == 0) { @@ -98,7 +98,7 @@ void ChunkedEncoding::inflate(char* outbuf, int& outlen, const char* inbuf, int strbufTail = strbuf; } else { // copy string between [p, strbufTail] - int unreadSize = strbufTail-p; + int32_t unreadSize = strbufTail-p; char* temp = new char[strbufSize]; memcpy(temp, p, unreadSize); delete [] strbuf; @@ -108,14 +108,14 @@ void ChunkedEncoding::inflate(char* outbuf, int& outlen, const char* inbuf, int outlen = clen; } -int ChunkedEncoding::readData(char** pp, char* buf, int& len, int maxlen) { +int32_t ChunkedEncoding::readData(char** pp, char* buf, int32_t& len, int32_t maxlen) { if(buf+len == buf+maxlen) { return -1; } if(chunkSize == 0) { return readDataEOL(pp); } - int wsize; + int32_t wsize; if(strbufTail-*pp < chunkSize) { wsize = strbufTail-*pp <= maxlen-len ? strbufTail-*pp : maxlen-len; } else { @@ -132,7 +132,7 @@ int ChunkedEncoding::readData(char** pp, char* buf, int& len, int maxlen) { } } -int ChunkedEncoding::readDataEOL(char** pp) { +int32_t ChunkedEncoding::readDataEOL(char** pp) { char* np = (char*)memchr(*pp, '\n', strbufTail-*pp); char* rp = (char*)memchr(*pp, '\r', strbufTail-*pp); if(np != NULL && rp != NULL && np-rp == 1 && *pp == rp) { @@ -145,7 +145,7 @@ int ChunkedEncoding::readDataEOL(char** pp) { } } -int ChunkedEncoding::readChunkSize(char** pp) { +int32_t ChunkedEncoding::readChunkSize(char** pp) { // we read chunk-size from *pp char* p; char* np = (char*)memchr(*pp, '\n', strbufTail-*pp); @@ -170,15 +170,15 @@ int ChunkedEncoding::readChunkSize(char** pp) { delete [] temp; if(chunkSize < 0) { throw new DlAbortEx(EX_INVALID_CHUNK_SIZE); - } else if(errno == ERANGE && (chunkSize == LONG_MAX || chunkSize == LONG_MIN)) { + } else if(errno == ERANGE && (chunkSize == INT32_MAX || chunkSize == INT32_MIN)) { throw new DlAbortEx(strerror(errno)); } *pp = p+2; return 0; } -void ChunkedEncoding::addBuffer(const char* inbuf, int inlen) { - int realbufSize = strbufTail-strbuf; +void ChunkedEncoding::addBuffer(const char* inbuf, int32_t inlen) { + int32_t realbufSize = strbufTail-strbuf; if(realbufSize+inlen >= strbufSize) { if(realbufSize+inlen > MAX_BUFSIZE) { throw new DlAbortEx(EX_TOO_LARGE_CHUNK, realbufSize+inlen); diff --git a/src/ChunkedEncoding.h b/src/ChunkedEncoding.h index 44bb72cb..2e73ed5b 100644 --- a/src/ChunkedEncoding.h +++ b/src/ChunkedEncoding.h @@ -44,16 +44,20 @@ private: READ_DATA, FINISH }; - long int chunkSize; - int state; + int32_t chunkSize; + int32_t state; char* strbuf; - int strbufSize; + int32_t strbufSize; char* strbufTail; - int readChunkSize(char** pp); - int readData(char** pp, char* buf, int& len, int maxlen); - void addBuffer(const char* inbuf, int inlen); - int readDataEOL(char** pp); + /** + * Returns 0 if the size of chunk is retrieved successfully, + * otherwise returns non-zero value. + */ + int32_t readChunkSize(char** pp); + int32_t readData(char** pp, char* buf, int32_t& len, int32_t maxlen); + void addBuffer(const char* inbuf, int32_t inlen); + int32_t readDataEOL(char** pp); public: @@ -61,7 +65,7 @@ public: ~ChunkedEncoding(); void init(); - void inflate(char* outbuf, int& outlen, const char* inbuf, int inlen); + void inflate(char* outbuf, int32_t& outlen, const char* inbuf, int32_t inlen); bool finished(); void end(); }; diff --git a/src/Command.cc b/src/Command.cc index 7f701883..b24d74fd 100644 --- a/src/Command.cc +++ b/src/Command.cc @@ -34,4 +34,4 @@ /* copyright --> */ #include "Command.h" -int Command::uuidGen = 0; +int32_t Command::uuidGen = 0; diff --git a/src/Command.h b/src/Command.h index 49f4b3d4..c83be85c 100644 --- a/src/Command.h +++ b/src/Command.h @@ -38,7 +38,7 @@ #include "common.h" #include "LogFactory.h" -typedef int CommandUuid; +typedef int32_t CommandUuid; class Command { public: @@ -50,19 +50,19 @@ public: }; private: CommandUuid uuid; - static int uuidGen; + static int32_t uuidGen; STATUS status; protected: - int cuid; + int32_t cuid; const Logger* logger; public: - Command(int cuid):uuid(uuidGen++), status(STATUS_INACTIVE), cuid(cuid) { + Command(int32_t cuid):uuid(uuidGen++), status(STATUS_INACTIVE), cuid(cuid) { logger = LogFactory::getInstance(); } virtual ~Command() {} virtual bool execute() = 0; - int getCuid() const { return cuid; } + int32_t getCuid() const { return cuid; } const CommandUuid& getUuid() const { return uuid; } void setStatusActive() { this->status = STATUS_ACTIVE; } diff --git a/src/CompactPeerListProcessor.cc b/src/CompactPeerListProcessor.cc index bae88c2b..0d597c36 100644 --- a/src/CompactPeerListProcessor.cc +++ b/src/CompactPeerListProcessor.cc @@ -44,18 +44,17 @@ Peers CompactPeerListProcessor::extractPeer(const MetaEntry* peersEntry) { const Data* peersData = (const Data*)peersEntry; if(peersData->getLen() > 0) { - for(int i = 0; i < peersData->getLen(); i += 6) { - unsigned int ipaddr1 = (unsigned char)*(peersData->getData()+i); - unsigned int ipaddr2 = (unsigned char)*(peersData->getData()+i+1); - unsigned int ipaddr3 = (unsigned char)*(peersData->getData()+i+2); - unsigned int ipaddr4 = (unsigned char)*(peersData->getData()+i+3); - unsigned int port = ntohs(*(unsigned short int*)(peersData->getData()+i+4)); + for(int32_t i = 0; i < peersData->getLen(); i += 6) { + uint32_t ipaddr1 = (unsigned char)*(peersData->getData()+i); + uint32_t ipaddr2 = (unsigned char)*(peersData->getData()+i+1); + uint32_t ipaddr3 = (unsigned char)*(peersData->getData()+i+2); + uint32_t ipaddr4 = (unsigned char)*(peersData->getData()+i+3); + int32_t port = ntohs(*(uint16_t*)(peersData->getData()+i+4)); char ipaddr[16]; snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", ipaddr1, ipaddr2, ipaddr3, ipaddr4); - PeerHandle peer = - PeerHandle(new Peer(ipaddr, port, pieceLength, totalLength)); + PeerHandle peer = new Peer(ipaddr, port, pieceLength, totalLength); peers.push_back(peer); } diff --git a/src/CompactPeerListProcessor.h b/src/CompactPeerListProcessor.h index 31f64f86..e81cfae8 100644 --- a/src/CompactPeerListProcessor.h +++ b/src/CompactPeerListProcessor.h @@ -38,10 +38,10 @@ class CompactPeerListProcessor : public PeerListProcessor { private: - int pieceLength; - long long int totalLength; + int32_t pieceLength; + int64_t totalLength; public: - CompactPeerListProcessor(int pieceLength, long long int totalLength) + CompactPeerListProcessor(int32_t pieceLength, int64_t totalLength) :pieceLength(pieceLength), totalLength(totalLength) {} diff --git a/src/ConsoleDownloadEngine.cc b/src/ConsoleDownloadEngine.cc index 486e5b32..5237ba16 100644 --- a/src/ConsoleDownloadEngine.cc +++ b/src/ConsoleDownloadEngine.cc @@ -43,20 +43,7 @@ ConsoleDownloadEngine::ConsoleDownloadEngine() {} ConsoleDownloadEngine::~ConsoleDownloadEngine() {} -void ConsoleDownloadEngine::sendStatistics(long long int currentSize, long long int totalSize) { - /* - printf("\r "); - printf("\r"); - printf("%s/%s Bytes %d%% %s %.2f KB/s %d connections", - Util::llitos(currentSize, true).c_str(), - Util::llitos(totalSize, true).c_str(), - (totalSize == 0 ? 0 : (int)((currentSize*100)/totalSize)), - avgSpeed == 0 ? "-" : Util::secfmt(eta).c_str(), - speed/1024.0, - commands.size()); - fflush(stdout); - */ - +void ConsoleDownloadEngine::sendStatistics(int64_t currentSize, int64_t totalSize) { cout << "\r "; cout << "\r"; if(_requestGroupMan->countRequestGroup() > 0) { @@ -166,15 +153,15 @@ void ConsoleDownloadEngine::initStatistics() { } void ConsoleDownloadEngine::calculateStatistics() { - long long int dlSize = _requestGroupMan->getDownloadLength(); + int64_t dlSize = _requestGroupMan->getDownloadLength(); if(!isStartupLengthSet && dlSize > 0) { startupLength = dlSize; psize = dlSize; isStartupLengthSet = true; } - int elapsed = cp.difference(); + int32_t elapsed = cp.difference(); if(elapsed >= 1) { - int nspeed = (int)((dlSize-psize)/elapsed); + int32_t nspeed = (dlSize-psize)/elapsed; if(nspeed < 0) { nspeed = 0; } @@ -182,9 +169,9 @@ void ConsoleDownloadEngine::calculateStatistics() { cp.reset(); psize = dlSize; - int elapsedFromStartup = startup.difference(); + int32_t elapsedFromStartup = startup.difference(); if(elapsedFromStartup > 0) { - avgSpeed = (int)((dlSize-startupLength)/elapsedFromStartup); + avgSpeed = (dlSize-startupLength)/elapsedFromStartup; } int64_t totalLength = _requestGroupMan->getTotalLength(); if(avgSpeed < 0) { diff --git a/src/ConsoleDownloadEngine.h b/src/ConsoleDownloadEngine.h index 0a0fae80..a1f61fcd 100644 --- a/src/ConsoleDownloadEngine.h +++ b/src/ConsoleDownloadEngine.h @@ -41,19 +41,19 @@ class ConsoleDownloadEngine : public DownloadEngine { private: Time cp; - long long int psize; - int speed; + int64_t psize; + int32_t speed; // The time when startup Time startup; // The number of bytes downloaded at startup - long long int startupLength; + int64_t startupLength; bool isStartupLengthSet; // The average speed(bytes per second) since startup - int avgSpeed; + int32_t avgSpeed; // The estimated remaining time to complete the download. - int eta; + int32_t eta; protected: - void sendStatistics(long long int currentSize, long long int totalSize); + void sendStatistics(int64_t currentSize, int64_t totalSize); virtual void initStatistics(); virtual void calculateStatistics(); virtual void onEndOfRun(); diff --git a/src/Data.cc b/src/Data.cc index 40f15867..e57873aa 100644 --- a/src/Data.cc +++ b/src/Data.cc @@ -35,7 +35,7 @@ #include "Data.h" #include "MetaEntryVisitor.h" -Data::Data(const char* data, int len, bool number):number(number) { +Data::Data(const char* data, int32_t len, bool number):number(number) { if(data == NULL) { this->data = NULL; this->len = 0; @@ -71,15 +71,15 @@ const char* Data::getData() const { } } -int Data::getLen() const { +int32_t Data::getLen() const { return len; } -int Data::toInt() const { - return (int)toLLInt(); +int32_t Data::toInt() const { + return toLLInt(); } -long long int Data::toLLInt() const { +int64_t Data::toLLInt() const { if(len == 0) { return 0; } else { diff --git a/src/Data.h b/src/Data.h index 116bc442..46905933 100644 --- a/src/Data.h +++ b/src/Data.h @@ -42,7 +42,7 @@ using namespace std; class Data : public MetaEntry { private: - int len; + int32_t len; char* data; bool number; public: @@ -50,15 +50,15 @@ public: * This class stores the copy of data. So caller must take care of freeing * memory of data. */ - Data(const char* data, int len, bool number = false); + Data(const char* data, int32_t len, bool number = false); ~Data(); string toString() const; - int toInt() const; - long long int toLLInt() const; + int32_t toInt() const; + int64_t toLLInt() const; const char* getData() const; - int getLen() const; + int32_t getLen() const; bool isNumber() const; void accept(MetaEntryVisitor* v) const; diff --git a/src/DefaultBtAnnounce.cc b/src/DefaultBtAnnounce.cc index fd286af4..9345eb7d 100644 --- a/src/DefaultBtAnnounce.cc +++ b/src/DefaultBtAnnounce.cc @@ -111,13 +111,13 @@ string DefaultBtAnnounce::getAnnounceUrl() { announceList.setEvent(AnnounceTier::STARTED_AFTER_COMPLETION); } } - int numWant = 50; + int32_t numWant = 50; if(!btRuntime->lessThanEqMinPeer() || btRuntime->isHalt()) { numWant = 0; } TransferStat stat = peerStorage->calculateStat(); - long long int left = pieceStorage->getTotalLength()-pieceStorage->getCompletedLength(); + int64_t left = pieceStorage->getTotalLength()-pieceStorage->getCompletedLength(); if(left < 0) { left = 0; } diff --git a/src/DefaultBtAnnounce.h b/src/DefaultBtAnnounce.h index 128c02fd..03a873ff 100644 --- a/src/DefaultBtAnnounce.h +++ b/src/DefaultBtAnnounce.h @@ -50,16 +50,16 @@ class DefaultBtAnnounce : public BtAnnounce { private: BtContextHandle btContext; - int trackers; + int32_t trackers; Time prevAnnounceTime; - int interval; - int minInterval; - int complete; - int incomplete; + int32_t interval; + int32_t minInterval; + int32_t complete; + int32_t incomplete; AnnounceList announceList; string trackerId; string key; - int trackerNumTry; + int32_t trackerNumTry; const Option* option; Logger* logger; BtRuntimeHandle btRuntime; diff --git a/src/DefaultBtProgressInfoFile.cc b/src/DefaultBtProgressInfoFile.cc index f0286c52..d8ff303f 100644 --- a/src/DefaultBtProgressInfoFile.cc +++ b/src/DefaultBtProgressInfoFile.cc @@ -70,12 +70,12 @@ void DefaultBtProgressInfoFile::save() { throw string("writeError:bitfield"); } TransferStat stat = peerStorage->calculateStat(); - long long int allTimeDownloadLength = pieceStorage->getCompletedLength(); + int64_t allTimeDownloadLength = pieceStorage->getCompletedLength(); if(fwrite(&allTimeDownloadLength, sizeof(allTimeDownloadLength), 1, file) < 1) { throw string("writeError:download length"); } - long long int allTimeUploadLength = + int64_t allTimeUploadLength = btRuntime->getUploadLengthAtStartup()+ stat.getSessionUploadLength(); if(fwrite(&allTimeUploadLength, @@ -112,12 +112,12 @@ void DefaultBtProgressInfoFile::load() { pieceStorage->setBitfield(savedBitfield, pieceStorage->getBitfieldLength()); // allTimeDownloadLength exists for only a compatibility reason. - long long int allTimeDownloadLength; + int64_t allTimeDownloadLength; if(fread(&allTimeDownloadLength, sizeof(allTimeDownloadLength), 1, file) < 1) { throw string("readError"); } - long long int allTimeUploadLength; + int64_t allTimeUploadLength; if(fread(&allTimeUploadLength, sizeof(allTimeUploadLength), 1, file) < 1) { throw string("readError"); diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h index 8ca99ef9..ab93d6aa 100644 --- a/src/DefaultBtRequestFactory.h +++ b/src/DefaultBtRequestFactory.h @@ -77,7 +77,7 @@ public: virtual void removeAllTargetPiece(); - virtual int countTargetPiece() { + virtual int32_t countTargetPiece() { return pieces.size(); } diff --git a/src/DefaultPeerListProcessor.cc b/src/DefaultPeerListProcessor.cc index 9f79f3fd..e731be03 100644 --- a/src/DefaultPeerListProcessor.cc +++ b/src/DefaultPeerListProcessor.cc @@ -60,10 +60,8 @@ Peers DefaultPeerListProcessor::extractPeer(const MetaEntry* peersEntry) { if(!ip || !port || !port->isNumber()) { continue; } - PeerHandle peer = PeerHandle(new Peer(ip->toString(), - port->toInt(), - pieceLength, - totalLength)); + PeerHandle peer = new Peer(ip->toString(), port->toInt(), pieceLength, + totalLength); peers.push_back(peer); } return peers; diff --git a/src/DefaultPeerListProcessor.h b/src/DefaultPeerListProcessor.h index 659e168c..223322d0 100644 --- a/src/DefaultPeerListProcessor.h +++ b/src/DefaultPeerListProcessor.h @@ -39,10 +39,10 @@ class DefaultPeerListProcessor : public PeerListProcessor { private: - int pieceLength; - long long int totalLength; + int32_t pieceLength; + int64_t totalLength; public: - DefaultPeerListProcessor(int pieceLength, long long int totalLength) + DefaultPeerListProcessor(int32_t pieceLength, int64_t totalLength) :pieceLength(pieceLength), totalLength(totalLength) {} diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc index 5a18bf82..1d53b42e 100644 --- a/src/DefaultPeerStorage.cc +++ b/src/DefaultPeerStorage.cc @@ -111,9 +111,9 @@ PeerHandle DefaultPeerStorage::getUnusedPeer() { class FindPeer { private: string ipaddr; - int port; + int32_t port; public: - FindPeer(const string& ipaddr, int port):ipaddr(ipaddr), port(port) {} + FindPeer(const string& ipaddr, int32_t port):ipaddr(ipaddr), port(port) {} bool operator()(const PeerHandle& peer) const { return ipaddr == peer->ipaddr && port == peer->port; @@ -121,7 +121,7 @@ public: }; PeerHandle DefaultPeerStorage::getPeer(const string& ipaddr, - int port) const { + int32_t port) const { Peers::const_iterator itr = find_if(peers.begin(), peers.end(), FindPeer(ipaddr, port)); if(itr == peers.end()) { @@ -194,7 +194,7 @@ TransferStat DefaultPeerStorage::calculateStat() { return stat; } -void DefaultPeerStorage::deleteUnusedPeer(int delSize) { +void DefaultPeerStorage::deleteUnusedPeer(int32_t delSize) { Peers temp; for(Peers::reverse_iterator itr = peers.rbegin(); itr != peers.rend(); ++itr) { diff --git a/src/DefaultPeerStorage.h b/src/DefaultPeerStorage.h index 05ad4940..3b9c0071 100644 --- a/src/DefaultPeerStorage.h +++ b/src/DefaultPeerStorage.h @@ -50,11 +50,11 @@ private: const Option* option; Peers peers; Peers incomingPeers; - int maxPeerListSize; + int32_t maxPeerListSize; Logger* logger; BtRuntimeHandle btRuntime; - long long int removedPeerSessionDownloadLength; - long long int removedPeerSessionUploadLength; + int64_t removedPeerSessionDownloadLength; + int64_t removedPeerSessionUploadLength; public: DefaultPeerStorage(BtContextHandle btContext, const Option* option); virtual ~DefaultPeerStorage(); @@ -72,7 +72,7 @@ public: virtual PeerHandle getUnusedPeer(); - PeerHandle getPeer(const string& ipaddr, int port) const; + PeerHandle getPeer(const string& ipaddr, int32_t port) const; virtual void addPeer(const Peers& peers); @@ -86,11 +86,11 @@ public: virtual void returnPeer(const PeerHandle& peer); - void setMaxPeerListSize(int size) { this->maxPeerListSize = size; } + void setMaxPeerListSize(int32_t size) { this->maxPeerListSize = size; } - int getMaxPeerListSize() const { return maxPeerListSize; } + int32_t getMaxPeerListSize() const { return maxPeerListSize; } - void deleteUnusedPeer(int delSize); + void deleteUnusedPeer(int32_t delSize); void onErasingPeer(const PeerHandle& peer); diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc index 143b671d..00c8c65d 100644 --- a/src/DefaultPieceStorage.cc +++ b/src/DefaultPieceStorage.cc @@ -72,8 +72,8 @@ bool DefaultPieceStorage::isEndGame() { return bitfieldMan->countMissingBlock() <= endGamePieceNum; } -int DefaultPieceStorage::getMissingPieceIndex(const PeerHandle& peer) { - int index = -1; +int32_t DefaultPieceStorage::getMissingPieceIndex(const PeerHandle& peer) { + int32_t index = -1; if(isEndGame()) { index = bitfieldMan->getMissingIndex(peer->getBitfield(), peer->getBitfieldLength()); @@ -84,7 +84,7 @@ int DefaultPieceStorage::getMissingPieceIndex(const PeerHandle& peer) { return index; } -PieceHandle DefaultPieceStorage::checkOutPiece(int index) { +PieceHandle DefaultPieceStorage::checkOutPiece(int32_t index) { if(index == -1) { return 0; } @@ -104,7 +104,7 @@ PieceHandle DefaultPieceStorage::checkOutPiece(int index) { * Newly instantiated piece is not added to usedPieces. * Because it is waste of memory and there is no chance to use them later. */ -PieceHandle DefaultPieceStorage::getPiece(int index) { +PieceHandle DefaultPieceStorage::getPiece(int32_t index) { if(0 <= index && index <= bitfieldMan->getMaxIndex()) { PieceHandle piece = findUsedPiece(index); if(piece.isNull()) { @@ -125,16 +125,16 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece) { class FindPiece { private: - int index; + int32_t index; public: - FindPiece(int index):index(index) {} + FindPiece(int32_t index):index(index) {} bool operator()(const PieceHandle& piece) { return piece->getIndex() == index; } }; -PieceHandle DefaultPieceStorage::findUsedPiece(int index) const { +PieceHandle DefaultPieceStorage::findUsedPiece(int32_t index) const { Pieces::const_iterator itr = find_if(usedPieces.begin(), usedPieces.end(), FindPiece(index)); @@ -146,12 +146,12 @@ PieceHandle DefaultPieceStorage::findUsedPiece(int index) const { } PieceHandle DefaultPieceStorage::getMissingPiece(const PeerHandle& peer) { - int index = getMissingPieceIndex(peer); + int32_t index = getMissingPieceIndex(peer); return checkOutPiece(index); } -int DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer) { - int index = -1; +int32_t DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer) { + int32_t index = -1; if(peer->isFastExtensionEnabled() && peer->countFastSet() > 0) { BitfieldMan tempBitfield(bitfieldMan->getBlockLength(), bitfieldMan->getTotalLength()); @@ -173,7 +173,7 @@ int DefaultPieceStorage::getMissingFastPieceIndex(const PeerHandle& peer) { } PieceHandle DefaultPieceStorage::getMissingFastPiece(const PeerHandle& peer) { - int index = getMissingFastPieceIndex(peer); + int32_t index = getMissingFastPieceIndex(peer); return checkOutPiece(index); } @@ -187,14 +187,14 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece) { } } -void DefaultPieceStorage::reduceUsedPieces(int delMax) { - int toDelete = usedPieces.size()-delMax; +void DefaultPieceStorage::reduceUsedPieces(int32_t delMax) { + int32_t toDelete = usedPieces.size()-delMax; if(toDelete <= 0) { return; } - int fillRate = 10; + int32_t fillRate = 10; while(fillRate < 50) { - int deleted = deleteUsedPiecesByFillRate(fillRate, toDelete); + int32_t deleted = deleteUsedPiecesByFillRate(fillRate, toDelete); if(deleted == 0) { break; } @@ -203,9 +203,9 @@ void DefaultPieceStorage::reduceUsedPieces(int delMax) { } } -int DefaultPieceStorage::deleteUsedPiecesByFillRate(int fillRate, - int toDelete) { - int deleted = 0; +int32_t DefaultPieceStorage::deleteUsedPiecesByFillRate(int32_t fillRate, + int32_t toDelete) { + int32_t deleted = 0; for(Pieces::iterator itr = usedPieces.begin(); itr != usedPieces.end() && deleted < toDelete;) { PieceHandle& piece = *itr; @@ -272,23 +272,23 @@ void DefaultPieceStorage::cancelPiece(const PieceHandle& piece) { } } -bool DefaultPieceStorage::hasPiece(int index) { +bool DefaultPieceStorage::hasPiece(int32_t index) { return bitfieldMan->isBitSet(index); } -long long int DefaultPieceStorage::getTotalLength() { +int64_t DefaultPieceStorage::getTotalLength() { return bitfieldMan->getTotalLength(); } -long long int DefaultPieceStorage::getFilteredTotalLength() { +int64_t DefaultPieceStorage::getFilteredTotalLength() { return bitfieldMan->getFilteredTotalLength(); } -long long int DefaultPieceStorage::getCompletedLength() { +int64_t DefaultPieceStorage::getCompletedLength() { return bitfieldMan->getCompletedLength(); } -long long int DefaultPieceStorage::getFilteredCompletedLength() { +int64_t DefaultPieceStorage::getFilteredCompletedLength() { return bitfieldMan->getFilteredCompletedLength(); } @@ -312,7 +312,7 @@ void DefaultPieceStorage::setFileFilter(const Strings& filePaths) { void DefaultPieceStorage::setFileFilter(const Integers& fileIndexes) { Strings filePaths; const FileEntries& entries = diskAdaptor->getFileEntries(); - for(int i = 0; i < (int)entries.size(); i++) { + for(int32_t i = 0; i < (int32_t)entries.size(); i++) { if(find(fileIndexes.begin(), fileIndexes.end(), i+1) != fileIndexes.end()) { logger->debug("index=%d is %s", i+1, entries[i]->getPath().c_str()); filePaths.push_back(entries[i]->getPath()); @@ -373,11 +373,11 @@ void DefaultPieceStorage::initStorage() { } void DefaultPieceStorage::setBitfield(const unsigned char* bitfield, - int bitfieldLength) { + int32_t bitfieldLength) { bitfieldMan->setBitfield(bitfield, bitfieldLength); } -int DefaultPieceStorage::getBitfieldLength() { +int32_t DefaultPieceStorage::getBitfieldLength() { return bitfieldMan->getBitfieldLength(); } @@ -389,16 +389,16 @@ DiskAdaptorHandle DefaultPieceStorage::getDiskAdaptor() { return diskAdaptor; } -int DefaultPieceStorage::getPieceLength(int index) { +int32_t DefaultPieceStorage::getPieceLength(int32_t index) { return bitfieldMan->getBlockLength(index); } -void DefaultPieceStorage::advertisePiece(int cuid, int index) { +void DefaultPieceStorage::advertisePiece(int32_t cuid, int32_t index) { HaveEntry entry(cuid, index); haves.push_front(entry); } -Integers DefaultPieceStorage::getAdvertisedPieceIndexes(int myCuid, +Integers DefaultPieceStorage::getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) { Integers indexes; for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) { @@ -417,9 +417,9 @@ Integers DefaultPieceStorage::getAdvertisedPieceIndexes(int myCuid, class FindElapsedHave { private: - int elapsed; + int32_t elapsed; public: - FindElapsedHave(int elapsed):elapsed(elapsed) {} + FindElapsedHave(int32_t elapsed):elapsed(elapsed) {} bool operator()(const HaveEntry& have) { if(have.getRegisteredTime().elapsed(elapsed)) { @@ -430,7 +430,7 @@ public: } }; -void DefaultPieceStorage::removeAdvertisedPiece(int elapsed) { +void DefaultPieceStorage::removeAdvertisedPiece(int32_t elapsed) { Haves::iterator itr = find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed)); if(itr != haves.end()) { diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h index 33834b34..97ae031e 100644 --- a/src/DefaultPieceStorage.h +++ b/src/DefaultPieceStorage.h @@ -48,17 +48,17 @@ class HaveEntry { private: - int cuid; - int index; + int32_t cuid; + int32_t index; Time registeredTime; public: - HaveEntry(int cuid, int index): + HaveEntry(int32_t cuid, int32_t index): cuid(cuid), index(index) {} - int getCuid() const { return cuid; } + int32_t getCuid() const { return cuid; } - int getIndex() const { return index; } + int32_t getIndex() const { return index; } const Time& getRegisteredTime() const { return registeredTime; } }; @@ -77,13 +77,13 @@ private: Haves haves; FileAllocatorHandle createFileAllocator(); - int getMissingPieceIndex(const PeerHandle& peer); - int getMissingFastPieceIndex(const PeerHandle& peer); - PieceHandle checkOutPiece(int index); - int deleteUsedPiecesByFillRate(int fillRate, int toDelete); - void reduceUsedPieces(int delMax); + int32_t getMissingPieceIndex(const PeerHandle& peer); + int32_t getMissingFastPieceIndex(const PeerHandle& peer); + PieceHandle checkOutPiece(int32_t index); + int32_t deleteUsedPiecesByFillRate(int32_t fillRate, int32_t toDelete); + void reduceUsedPieces(int32_t delMax); void deleteUsedPiece(const PieceHandle& piece); - PieceHandle findUsedPiece(int index) const; + PieceHandle findUsedPiece(int32_t index) const; public: DefaultPieceStorage(BtContextHandle btContext, const Option* option); virtual ~DefaultPieceStorage(); @@ -94,21 +94,21 @@ public: virtual PieceHandle getMissingFastPiece(const PeerHandle& peer); - virtual PieceHandle getPiece(int index); + virtual PieceHandle getPiece(int32_t index); virtual void completePiece(const PieceHandle& piece); virtual void cancelPiece(const PieceHandle& piece); - virtual bool hasPiece(int index); + virtual bool hasPiece(int32_t index); - virtual long long int getTotalLength(); + virtual int64_t getTotalLength(); - virtual long long int getFilteredTotalLength(); + virtual int64_t getFilteredTotalLength(); - virtual long long int getCompletedLength(); + virtual int64_t getCompletedLength(); - virtual long long int getFilteredCompletedLength(); + virtual int64_t getFilteredCompletedLength(); virtual void initStorage(); @@ -123,9 +123,9 @@ public: virtual bool allDownloadFinished(); virtual void setBitfield(const unsigned char* bitfield, - int bitfieldLength); + int32_t bitfieldLength); - virtual int getBitfieldLength(); + virtual int32_t getBitfieldLength(); virtual const unsigned char* getBitfield(); @@ -145,14 +145,14 @@ public: virtual DiskAdaptorHandle getDiskAdaptor(); - virtual int getPieceLength(int index); + virtual int32_t getPieceLength(int32_t index); - virtual void advertisePiece(int cuid, int index); + virtual void advertisePiece(int32_t cuid, int32_t index); - virtual Integers getAdvertisedPieceIndexes(int myCuid, + virtual Integers getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime); - virtual void removeAdvertisedPiece(int elapsed); + virtual void removeAdvertisedPiece(int32_t elapsed); virtual void markAllPiecesDone(); diff --git a/src/DelegatingPeerListProcessor.h b/src/DelegatingPeerListProcessor.h index 19ff37ea..a0688641 100644 --- a/src/DelegatingPeerListProcessor.h +++ b/src/DelegatingPeerListProcessor.h @@ -42,11 +42,11 @@ typedef deque PeerListProcessors; class DelegatingPeerListProcessor : public PeerListProcessor { private: - int pieceLength; - long long int totalLength; + int32_t pieceLength; + int64_t totalLength; PeerListProcessors processors; public: - DelegatingPeerListProcessor(int pieceLength, long long int totalLength) + DelegatingPeerListProcessor(int32_t pieceLength, int64_t totalLength) :pieceLength(pieceLength), totalLength(totalLength) { processors.push_back(new DefaultPeerListProcessor(pieceLength, totalLength)); diff --git a/src/DiskWriter.h b/src/DiskWriter.h index 785c20f7..9ff7602f 100644 --- a/src/DiskWriter.h +++ b/src/DiskWriter.h @@ -35,7 +35,6 @@ #ifndef _D_DISK_WRITER_H_ #define _D_DISK_WRITER_H_ -#include #include "common.h" #ifdef ENABLE_MESSAGE_DIGEST #include "messageDigest.h" @@ -87,8 +86,8 @@ public: writeData((const char*)data, len, position); } - virtual int readData(char* data, int32_t len, int64_t position) = 0; - virtual int readData(unsigned char* data, int32_t len, int64_t position) { + virtual int32_t readData(char* data, int32_t len, int64_t position) = 0; + virtual int32_t readData(unsigned char* data, int32_t len, int64_t position) { return readData((char*)data, len, position); } #ifdef ENABLE_MESSAGE_DIGEST diff --git a/src/DownloadEngine.cc b/src/DownloadEngine.cc index 04296697..62dd7637 100644 --- a/src/DownloadEngine.cc +++ b/src/DownloadEngine.cc @@ -66,8 +66,8 @@ void DownloadEngine::cleanQueue() { void DownloadEngine::executeCommand(Command::STATUS statusFilter) { - int max = commands.size(); - for(int i = 0; i < max; i++) { + int32_t max = commands.size(); + for(int32_t i = 0; i < max; i++) { Command* com = commands.front(); commands.pop_front(); if(com->statusMatch(statusFilter)) { @@ -116,7 +116,7 @@ void DownloadEngine::shortSleep() const { void DownloadEngine::waitData() { fd_set rfds; fd_set wfds; - int retval = 0; + int32_t retval = 0; struct timeval tv; memcpy(&rfds, &rfdset, sizeof(fd_set)); @@ -160,7 +160,7 @@ void DownloadEngine::updateFdSet() { for(NameResolverEntries::iterator itr = nameResolverEntries.begin(); itr != nameResolverEntries.end(); ++itr) { NameResolverEntry& entry = *itr; - int fd = entry.nameResolver->getFds(&rfdset, &wfdset); + int32_t fd = entry.nameResolver->getFds(&rfdset, &wfdset); if(fdmax < fd) { fdmax = fd; } @@ -169,7 +169,7 @@ void DownloadEngine::updateFdSet() { for(SocketEntries::iterator itr = socketEntries.begin(); itr != socketEntries.end(); ++itr) { SocketEntry& entry = *itr; - int fd = entry.socket->getSockfd(); + int32_t fd = entry.socket->getSockfd(); switch(entry.type) { case SocketEntry::TYPE_RD: FD_SET(fd, &rfdset); diff --git a/src/DownloadEngine.h b/src/DownloadEngine.h index f60679c8..2ce84dcb 100644 --- a/src/DownloadEngine.h +++ b/src/DownloadEngine.h @@ -106,7 +106,7 @@ private: #endif // ENABLE_ASYNC_DNS fd_set rfdset; fd_set wfdset; - int fdmax; + int32_t fdmax; void shortSleep() const; bool addSocket(const SocketEntry& socketEntry); diff --git a/src/DownloadEngineFactory.cc b/src/DownloadEngineFactory.cc index 1ab26688..eb3ea985 100644 --- a/src/DownloadEngineFactory.cc +++ b/src/DownloadEngineFactory.cc @@ -184,8 +184,8 @@ DownloadEngineFactory::newTorrentConsoleEngine(const BtContextHandle& btContext, PeerListenCommand* listenCommand = new PeerListenCommand(CUIDCounterSingletonHolder::instance()->newID(), te, btContext); - int port; - int listenPort = op->getAsInt(PREF_LISTEN_PORT); + int32_t port; + int32_t listenPort = op->getAsInt(PREF_LISTEN_PORT); if(listenPort == -1) { port = listenCommand->bindPort(6881, 6999); } else { diff --git a/src/FeatureConfig.cc b/src/FeatureConfig.cc index 24b4a3f2..6bbc6a85 100644 --- a/src/FeatureConfig.cc +++ b/src/FeatureConfig.cc @@ -50,7 +50,7 @@ FeatureConfig::FeatureConfig() { PortMap::value_type("https", 443), PortMap::value_type("ftp", 21), }; - int portArraySize = sizeof(portArray)/sizeof(PortMap::value_type); + int32_t portArraySize = sizeof(portArray)/sizeof(PortMap::value_type); defaultPorts.insert(&portArray[0], &portArray[portArraySize]); @@ -94,11 +94,11 @@ FeatureConfig::FeatureConfig() { ), }; - int featureArraySize = sizeof(featureArray)/sizeof(FeatureMap::value_type); + int32_t featureArraySize = sizeof(featureArray)/sizeof(FeatureMap::value_type); supportedFeatures.insert(&featureArray[0], &featureArray[featureArraySize]); - for(int i = 0; i < featureArraySize; i++) { + for(int32_t i = 0; i < featureArraySize; i++) { features.push_back(featureArray[i].first); } } diff --git a/src/FeatureConfig.h b/src/FeatureConfig.h index ee1ef5c4..788912b3 100644 --- a/src/FeatureConfig.h +++ b/src/FeatureConfig.h @@ -38,7 +38,7 @@ #include "common.h" #include -typedef map PortMap; +typedef map PortMap; typedef map FeatureMap; class FeatureConfig { @@ -64,7 +64,7 @@ public: featureConfig = 0; } - int getDefaultPort(const string& protocol) const { + int32_t getDefaultPort(const string& protocol) const { PortMap::const_iterator itr = defaultPorts.find(protocol); if(itr == defaultPorts.end()) { return 0; diff --git a/src/File.cc b/src/File.cc index 0d55a250..a3d80dd9 100644 --- a/src/File.cc +++ b/src/File.cc @@ -43,7 +43,7 @@ File::File(const string& name):name(name) {} File::~File() {} -int File::fillStat(struct stat& fstat) { +int32_t File::fillStat(struct stat& fstat) { return stat(name.c_str(), &fstat); } diff --git a/src/File.h b/src/File.h index 32519089..8ab22044 100644 --- a/src/File.h +++ b/src/File.h @@ -48,7 +48,11 @@ using namespace std; class File { private: string name; - int fillStat(struct stat& fstat); + + /** + * Returns the return value of stat(...) + */ + int32_t fillStat(struct stat& fstat); public: File(const string& name); ~File(); diff --git a/src/FileEntry.cc b/src/FileEntry.cc index 1e74ffa8..d0c72de0 100644 --- a/src/FileEntry.cc +++ b/src/FileEntry.cc @@ -38,8 +38,8 @@ #include FileEntry::FileEntry(const string& path, - long long int length, - long long int offset): + int64_t length, + int64_t offset): path(path), length(length), offset(offset), extracted(false), requested(true) {} diff --git a/src/FileEntry.h b/src/FileEntry.h index eb162bfe..b395ce84 100644 --- a/src/FileEntry.h +++ b/src/FileEntry.h @@ -48,7 +48,7 @@ private: public: FileEntry():length(0), offset(0), extracted(false), requested(false) {} - FileEntry(const string& path, long long int length, long long int offset); + FileEntry(const string& path, int64_t length, int64_t offset); FileEntry& operator=(const FileEntry& entry) { @@ -80,11 +80,11 @@ public: int64_t getLength() const { return length; } - void setLength(long long int length) { this->length = length; } + void setLength(int64_t length) { this->length = length; } - long long int getOffset() const { return offset; } + int64_t getOffset() const { return offset; } - void setOffset(long long int offset) { this->offset = offset; } + void setOffset(int64_t offset) { this->offset = offset; } bool isExtracted() const { return extracted; } diff --git a/src/FtpConnection.cc b/src/FtpConnection.cc index 82a97d48..a40c0303 100644 --- a/src/FtpConnection.cc +++ b/src/FtpConnection.cc @@ -40,7 +40,7 @@ #include "prefs.h" #include "LogFactory.h" -FtpConnection::FtpConnection(int cuid, const SocketHandle& socket, +FtpConnection::FtpConnection(int32_t cuid, const SocketHandle& socket, const RequestHandle req, const Option* op) :cuid(cuid), socket(socket), req(req), option(op) { logger = LogFactory::getInstance(); @@ -94,9 +94,9 @@ SocketHandle FtpConnection::sendPort() const { SocketHandle serverSocket; serverSocket->beginListen(); - pair addrinfo; + pair addrinfo; socket->getAddrInfo(addrinfo); - int ipaddr[4]; + int32_t ipaddr[4]; sscanf(addrinfo.first.c_str(), "%d.%d.%d.%d", &ipaddr[0], &ipaddr[1], &ipaddr[2], &ipaddr[3]); serverSocket->getAddrInfo(addrinfo); @@ -121,8 +121,8 @@ void FtpConnection::sendRetr() const { socket->writeData(request); } -int FtpConnection::getStatus(const string& response) const { - int status; +int32_t FtpConnection::getStatus(const string& response) const { + int32_t status; // When the response is not like "%d %*s", // we return 0. if(response.find_first_not_of("0123456789") != 3 @@ -136,7 +136,7 @@ int FtpConnection::getStatus(const string& response) const { } } -bool FtpConnection::isEndOfResponse(int status, const string& response) const { +bool FtpConnection::isEndOfResponse(int32_t status, const string& response) const { if(response.size() <= 4) { return false; } @@ -156,10 +156,10 @@ bool FtpConnection::isEndOfResponse(int status, const string& response) const { } } -bool FtpConnection::bulkReceiveResponse(pair& response) { +bool FtpConnection::bulkReceiveResponse(pair& response) { char buf[1024]; while(socket->isReadable(0)) { - int size = sizeof(buf)-1; + int32_t size = sizeof(buf)-1; socket->readData(buf, size); if(size == 0) { throw new DlRetryEx(EX_GOT_EOF); @@ -167,7 +167,7 @@ bool FtpConnection::bulkReceiveResponse(pair& response) { buf[size] = '\0'; strbuf += buf; } - int status; + int32_t status; if(strbuf.size() >= 4) { status = getStatus(strbuf); if(status == 0) { @@ -188,8 +188,8 @@ bool FtpConnection::bulkReceiveResponse(pair& response) { } } -int FtpConnection::receiveResponse() { - pair response; +int32_t FtpConnection::receiveResponse() { + pair response; if(bulkReceiveResponse(response)) { return response.first; } else { @@ -197,8 +197,8 @@ int FtpConnection::receiveResponse() { } } -int FtpConnection::receiveSizeResponse(long long int& size) { - pair response; +int32_t FtpConnection::receiveSizeResponse(int64_t& size) { + pair response; if(bulkReceiveResponse(response)) { if(response.first == 213) { sscanf(response.second.c_str(), "%*d %Ld", &size); @@ -209,12 +209,12 @@ int FtpConnection::receiveSizeResponse(long long int& size) { } } -int FtpConnection::receivePasvResponse(pair& dest) { - pair response; +int32_t FtpConnection::receivePasvResponse(pair& dest) { + pair response; if(bulkReceiveResponse(response)) { if(response.first == 227) { // we assume the format of response is "227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)." - int h1, h2, h3, h4, p1, p2; + int32_t h1, h2, h3, h4, p1, p2; string::size_type p = response.second.find("("); if(p >= 4) { sscanf(response.second.substr(response.second.find("(")).c_str(), diff --git a/src/FtpConnection.h b/src/FtpConnection.h index ed3697a6..766d3720 100644 --- a/src/FtpConnection.h +++ b/src/FtpConnection.h @@ -47,7 +47,7 @@ using namespace std; class FtpConnection { private: - int cuid; + int32_t cuid; SocketHandle socket; RequestHandle req; const Option* option; @@ -55,11 +55,11 @@ private: string strbuf; - int getStatus(const string& response) const; - bool isEndOfResponse(int status, const string& response) const; - bool bulkReceiveResponse(pair& response); + int32_t getStatus(const string& response) const; + bool isEndOfResponse(int32_t status, const string& response) const; + bool bulkReceiveResponse(pair& response); public: - FtpConnection(int cuid, const SocketHandle& socket, + FtpConnection(int32_t cuid, const SocketHandle& socket, const RequestHandle req, const Option* op); ~FtpConnection(); void sendUser() const; @@ -72,9 +72,9 @@ public: void sendRest(const SegmentHandle& segment) const; void sendRetr() const; - int receiveResponse(); - int receiveSizeResponse(long long int& size); - int receivePasvResponse(pair& dest); + int32_t receiveResponse(); + int32_t receiveSizeResponse(int64_t& size); + int32_t receivePasvResponse(pair& dest); }; #endif // _D_FTP_CONNECTION_H_ diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc index ef39ce35..b9c03440 100644 --- a/src/FtpNegotiationCommand.cc +++ b/src/FtpNegotiationCommand.cc @@ -41,7 +41,7 @@ #include "Util.h" #include "FatalException.h" -FtpNegotiationCommand::FtpNegotiationCommand(int cuid, +FtpNegotiationCommand::FtpNegotiationCommand(int32_t cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e, @@ -82,7 +82,7 @@ bool FtpNegotiationCommand::recvGreeting() { disableWriteCheckSocket(); setReadCheckSocket(socket); - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } @@ -101,7 +101,7 @@ bool FtpNegotiationCommand::sendUser() { } bool FtpNegotiationCommand::recvUser() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); switch(status) { case 0: return false; @@ -124,7 +124,7 @@ bool FtpNegotiationCommand::sendPass() { } bool FtpNegotiationCommand::recvPass() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } @@ -142,7 +142,7 @@ bool FtpNegotiationCommand::sendType() { } bool FtpNegotiationCommand::recvType() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } @@ -160,7 +160,7 @@ bool FtpNegotiationCommand::sendCwd() { } bool FtpNegotiationCommand::recvCwd() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } @@ -178,8 +178,8 @@ bool FtpNegotiationCommand::sendSize() { } bool FtpNegotiationCommand::recvSize() { - long long int size = 0; - int status = ftp->receiveSizeResponse(size); + int64_t size = 0; + int32_t status = ftp->receiveSizeResponse(size); if(status == 0) { return false; } @@ -253,7 +253,7 @@ bool FtpNegotiationCommand::sendPort() { } bool FtpNegotiationCommand::recvPort() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } @@ -271,8 +271,8 @@ bool FtpNegotiationCommand::sendPasv() { } bool FtpNegotiationCommand::recvPasv() { - pair dest; - int status = ftp->receivePasvResponse(dest); + pair dest; + int32_t status = ftp->receivePasvResponse(dest); if(status == 0) { return false; } @@ -306,7 +306,7 @@ bool FtpNegotiationCommand::sendRest(const SegmentHandle& segment) { } bool FtpNegotiationCommand::recvRest() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } @@ -325,7 +325,7 @@ bool FtpNegotiationCommand::sendRetr() { } bool FtpNegotiationCommand::recvRetr() { - int status = ftp->receiveResponse(); + int32_t status = ftp->receiveResponse(); if(status == 0) { return false; } diff --git a/src/FtpNegotiationCommand.h b/src/FtpNegotiationCommand.h index 2413f586..6b9fc8c6 100644 --- a/src/FtpNegotiationCommand.h +++ b/src/FtpNegotiationCommand.h @@ -91,12 +91,12 @@ private: SocketHandle dataSocket; SocketHandle serverSocket; - int sequence; + int32_t sequence; FtpConnection* ftp; protected: virtual bool executeInternal(); public: - FtpNegotiationCommand(int cuid, + FtpNegotiationCommand(int32_t cuid, const RequestHandle& req, RequestGroup* requestGroup, DownloadEngine* e, diff --git a/src/HaveEraseCommand.cc b/src/HaveEraseCommand.cc index 0758d10a..ecb209c9 100644 --- a/src/HaveEraseCommand.cc +++ b/src/HaveEraseCommand.cc @@ -34,10 +34,10 @@ /* copyright --> */ #include "HaveEraseCommand.h" -HaveEraseCommand::HaveEraseCommand(int cuid, +HaveEraseCommand::HaveEraseCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext, - int interval) + int32_t interval) :BtContextAwareCommand(cuid, btContext), e(e), interval(interval) {} diff --git a/src/HaveEraseCommand.h b/src/HaveEraseCommand.h index 59a663bf..4875df23 100644 --- a/src/HaveEraseCommand.h +++ b/src/HaveEraseCommand.h @@ -42,12 +42,12 @@ class HaveEraseCommand : public BtContextAwareCommand { private: TorrentDownloadEngine* e; Time cp; - int interval; + int32_t interval; public: - HaveEraseCommand(int cuid, + HaveEraseCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext, - int interval); + int32_t interval); virtual ~HaveEraseCommand() {} diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc index bc989cde..6f0e2c67 100644 --- a/src/HttpConnection.cc +++ b/src/HttpConnection.cc @@ -42,7 +42,7 @@ #include "LogFactory.h" #include -HttpConnection::HttpConnection(int cuid, +HttpConnection::HttpConnection(int32_t cuid, const SocketHandle& socket, const Option* op): cuid(cuid), socket(socket), option(op), logger(LogFactory::getInstance()) diff --git a/src/HttpConnection.h b/src/HttpConnection.h index 96ab0f77..87384b44 100644 --- a/src/HttpConnection.h +++ b/src/HttpConnection.h @@ -75,7 +75,7 @@ typedef deque HttpRequestEntries; class HttpConnection { private: - int cuid; + int32_t cuid; SocketHandle socket; const Option* option; const Logger* logger; @@ -84,7 +84,7 @@ private: string eraseConfidentialInfo(const string& request); public: - HttpConnection(int cuid, + HttpConnection(int32_t cuid, const SocketHandle& socket, const Option* op); diff --git a/src/HttpHeader.cc b/src/HttpHeader.cc index 9cf6b002..630fcec1 100644 --- a/src/HttpHeader.cc +++ b/src/HttpHeader.cc @@ -61,11 +61,11 @@ Strings HttpHeader::get(const string& name) const { return v; } -int HttpHeader::getFirstAsInt(const string& name) const { - return (int)getFirstAsLLInt(name); +int32_t HttpHeader::getFirstAsInt(const string& name) const { + return getFirstAsLLInt(name); } -long long int HttpHeader::getFirstAsLLInt(const string& name) const { +int64_t HttpHeader::getFirstAsLLInt(const string& name) const { string value = getFirst(name); if(value == "") { return 0; diff --git a/src/HttpHeader.h b/src/HttpHeader.h index d2cacce8..8b90f985 100644 --- a/src/HttpHeader.h +++ b/src/HttpHeader.h @@ -52,8 +52,8 @@ public: bool defined(const string& name) const; string getFirst(const string& name) const; Strings get(const string& name) const; - int getFirstAsInt(const string& name) const; - long long int getFirstAsLLInt(const string& name) const; + int32_t getFirstAsInt(const string& name) const; + int64_t getFirstAsLLInt(const string& name) const; RangeHandle getRange() const; }; diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc index 851ebdc5..603523d8 100644 --- a/src/HttpRequest.cc +++ b/src/HttpRequest.cc @@ -63,7 +63,7 @@ bool HttpRequest::isRangeSatisfied(const RangeHandle& range) const } } -string HttpRequest::getHostText(const string& host, in_port_t port) const +string HttpRequest::getHostText(const string& host, int32_t port) const { return host+(port == 80 || port == 443 ? "" : ":"+Util::llitos(port)); } diff --git a/src/HttpRequest.h b/src/HttpRequest.h index 8cfe45d9..753302b3 100644 --- a/src/HttpRequest.h +++ b/src/HttpRequest.h @@ -59,7 +59,7 @@ private: string userAgent; - string getHostText(const string& host, in_port_t port) const; + string getHostText(const string& host, int32_t port) const; string getProxyAuthString() const; @@ -106,7 +106,7 @@ public: return request->getHost(); } - in_port_t getPort() const + int32_t getPort() const { return request->getPort(); } diff --git a/src/MetaFileUtil.cc b/src/MetaFileUtil.cc index 58ab78c3..35c84d38 100644 --- a/src/MetaFileUtil.cc +++ b/src/MetaFileUtil.cc @@ -41,7 +41,7 @@ MetaEntry* MetaFileUtil::parseMetaFile(const string& file) { File f(file); - int len = f.size(); + int32_t len = f.size(); char* buf = new char[len]; FILE* fp = fopen(file.c_str(), "r+"); try { @@ -66,7 +66,7 @@ MetaEntry* MetaFileUtil::parseMetaFile(const string& file) { } } -MetaEntry* MetaFileUtil::bdecoding(const char* buf, int len) { +MetaEntry* MetaFileUtil::bdecoding(const char* buf, int32_t len) { MetaEntry* entry = NULL; try{ const char* p = buf; @@ -157,7 +157,7 @@ Data* MetaFileUtil::decodeInt(const char** pp, const char* end) { if(endTerm == NULL) { throw new DlAbortEx(EX_MULFORMED_META_INFO); } - int numSize = endTerm-*pp; + int32_t numSize = endTerm-*pp; Data* data = new Data(*pp, numSize, true); *pp += numSize+1; @@ -173,12 +173,12 @@ Data* MetaFileUtil::decodeWord(const char** pp, const char* end) { if(delim == *pp || delim == NULL) { throw new DlAbortEx(EX_MULFORMED_META_INFO); } - int numSize = delim-*pp; + int32_t numSize = delim-*pp; char* temp = new char[numSize+1]; memcpy(temp, *pp, numSize); temp[numSize] = '\0'; char* endptr; - int size = strtol(temp, &endptr, 10); + int32_t size = strtol(temp, &endptr, 10); if(*endptr != '\0') { delete [] temp; throw new DlAbortEx(EX_MULFORMED_META_INFO); diff --git a/src/MetaFileUtil.h b/src/MetaFileUtil.h index 593cc563..48693b7f 100644 --- a/src/MetaFileUtil.h +++ b/src/MetaFileUtil.h @@ -57,7 +57,7 @@ private: public: static MetaEntry* parseMetaFile(const string& file); - static MetaEntry* bdecoding(const char* buf, int len); + static MetaEntry* bdecoding(const char* buf, int32_t len); }; #endif // _D_META_FILE_UTIL_H_ diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc index e4c1497d..b82129fa 100644 --- a/src/MetalinkEntry.cc +++ b/src/MetalinkEntry.cc @@ -48,9 +48,9 @@ MetalinkEntry::~MetalinkEntry() {} class AddLocationPreference { private: string location; - int preferenceToAdd; + int32_t preferenceToAdd; public: - AddLocationPreference(const string& location, int preferenceToAdd): + AddLocationPreference(const string& location, int32_t preferenceToAdd): location(location), preferenceToAdd(preferenceToAdd) {} void operator()(MetalinkResourceHandle& res) { @@ -60,7 +60,7 @@ public: } }; -void MetalinkEntry::setLocationPreference(const string& location, int preferenceToAdd) { +void MetalinkEntry::setLocationPreference(const string& location, int32_t preferenceToAdd) { for_each(resources.begin(), resources.end(), AddLocationPreference(location, preferenceToAdd)); } diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h index dd68720b..783e9d1f 100644 --- a/src/MetalinkEntry.h +++ b/src/MetalinkEntry.h @@ -94,7 +94,7 @@ public: void reorderResourcesByPreference(); - void setLocationPreference(const string& location, int preferenceToAdd); + void setLocationPreference(const string& location, int32_t preferenceToAdd); static FileEntries toFileEntry(const MetalinkEntries& metalinkEntries); }; diff --git a/src/MetalinkRequestInfo.cc b/src/MetalinkRequestInfo.cc index af991a0a..abacfd4d 100644 --- a/src/MetalinkRequestInfo.cc +++ b/src/MetalinkRequestInfo.cc @@ -43,10 +43,9 @@ class AccumulateNonP2PUrl { private: Strings* urlsPtr; - int split; + int32_t split; public: - AccumulateNonP2PUrl(Strings* urlsPtr, - int split) + AccumulateNonP2PUrl(Strings* urlsPtr, int32_t split) :urlsPtr(urlsPtr), split(split) {} @@ -55,7 +54,7 @@ public: case MetalinkResource::TYPE_HTTP: case MetalinkResource::TYPE_HTTPS: case MetalinkResource::TYPE_FTP: - for(int s = 1; s <= split; s++) { + for(int32_t s = 1; s <= split; s++) { urlsPtr->push_back(resource->url); } break; diff --git a/src/MetalinkResource.h b/src/MetalinkResource.h index 8fca4c20..6ea68a48 100644 --- a/src/MetalinkResource.h +++ b/src/MetalinkResource.h @@ -48,9 +48,9 @@ public: }; public: string url; - int type; + TYPE type; string location; - int preference; + int32_t preference; public: MetalinkResource(); ~MetalinkResource(); diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc index 86a45df5..7d96d29a 100644 --- a/src/MultiDiskAdaptor.cc +++ b/src/MultiDiskAdaptor.cc @@ -145,7 +145,7 @@ int32_t MultiDiskAdaptor::calculateLength(const DiskWriterEntryHandle entry, return length; } -int MultiDiskAdaptor::readData(unsigned char* data, int32_t len, int64_t offset) +int32_t MultiDiskAdaptor::readData(unsigned char* data, int32_t len, int64_t offset) { int64_t fileOffset = offset; bool reading = false; diff --git a/src/MultiDiskAdaptor.h b/src/MultiDiskAdaptor.h index bcb363a6..0610517e 100644 --- a/src/MultiDiskAdaptor.h +++ b/src/MultiDiskAdaptor.h @@ -140,7 +140,7 @@ public: virtual void writeData(const unsigned char* data, int32_t len, int64_t offset); - virtual int readData(unsigned char* data, int32_t len, int64_t offset); + virtual int32_t readData(unsigned char* data, int32_t len, int64_t offset); virtual string messageDigest(int64_t offset, int64_t length, const MessageDigestContext::DigestAlgo& algo); diff --git a/src/NameResolver.cc b/src/NameResolver.cc index 657a621a..6015bade 100644 --- a/src/NameResolver.cc +++ b/src/NameResolver.cc @@ -36,7 +36,7 @@ #ifdef ENABLE_ASYNC_DNS -void callback(void* arg, int status, struct hostent* host) { +void callback(void* arg, int32_t status, struct hostent* host) { NameResolver* resolverPtr = (NameResolver*)arg; #ifdef HAVE_LIBARES // This block is required since the assertion in ares_strerror fails @@ -75,7 +75,7 @@ void NameResolver::resolve(const string& hostname) ai.ai_socktype = SOCK_STREAM; ai.ai_protocol = 0; struct addrinfo* res; - int ec; + int32_t ec; if((ec = getaddrinfo(hostname.c_str(), 0, &ai, &res)) != 0) { throw new DlAbortEx(EX_RESOLVE_HOSTNAME, hostname.c_str(), gai_strerror(ec)); diff --git a/src/NameResolver.h b/src/NameResolver.h index 3a7d8477..e4da707c 100644 --- a/src/NameResolver.h +++ b/src/NameResolver.h @@ -51,10 +51,10 @@ extern "C" { } /* end of extern "C" */ #endif -void callback(void* arg, int status, struct hostent* host); +void callback(void* arg, int32_t status, struct hostent* host); class NameResolver { - friend void callback(void* arg, int status, struct hostent* host); + friend void callback(void* arg, int32_t status, struct hostent* host); public: enum STATUS { @@ -100,7 +100,7 @@ public: return status; } - int getFds(fd_set* rfdsPtr, fd_set* wfdsPtr) const { + int32_t getFds(fd_set* rfdsPtr, fd_set* wfdsPtr) const { return ares_fds(channel, rfdsPtr, wfdsPtr); } diff --git a/src/Option.cc b/src/Option.cc index b8758af1..67ecb047 100644 --- a/src/Option.cc +++ b/src/Option.cc @@ -56,16 +56,16 @@ string Option::get(const string& name) const { } } -int Option::getAsInt(const string& name) const { +int32_t Option::getAsInt(const string& name) const { string value = get(name); if(value == "") { return 0; } else { - return (int)strtol(value.c_str(), NULL, 10); + return strtol(value.c_str(), NULL, 10); } } -long long int Option::getAsLLInt(const string& name) const { +int64_t Option::getAsLLInt(const string& name) const { string value = get(name); if(value == "") { return 0; diff --git a/src/Option.h b/src/Option.h index df1c1694..9552ccad 100644 --- a/src/Option.h +++ b/src/Option.h @@ -51,8 +51,8 @@ public: void put(const string& name, const string& value); bool defined(const string& name) const; string get(const string& name) const; - int getAsInt(const string& name) const; - long long int getAsLLInt(const string& name) const; + int32_t getAsInt(const string& name) const; + int64_t getAsLLInt(const string& name) const; bool getAsBool(const string& name) const; double getAsDouble(const string& name) const; diff --git a/src/Peer.cc b/src/Peer.cc index d4b64452..685b1b36 100644 --- a/src/Peer.cc +++ b/src/Peer.cc @@ -36,7 +36,7 @@ #include "BitfieldManFactory.h" #include "Util.h" -Peer::Peer(string ipaddr, int port, int pieceLength, long long int totalLength): +Peer::Peer(string ipaddr, int32_t port, int32_t pieceLength, int64_t totalLength): ipaddr(ipaddr), port(port), sessionUploadLength(0), @@ -62,7 +62,7 @@ Peer::Peer():entryId(0), ipaddr(""), port(0), bitfield(0), } */ -void Peer::updateBitfield(int index, int operation) { +void Peer::updateBitfield(int32_t index, int32_t operation) { if(operation == 1) { bitfield->setBit(index); } else if(operation == 0) { @@ -79,7 +79,7 @@ bool Peer::shouldBeChoking() const { return chokingRequired; } -bool Peer::hasPiece(int index) const { +bool Peer::hasPiece(int32_t index) const { return bitfield->isBitSet(index); } @@ -105,33 +105,33 @@ void Peer::resetStatus() { peerStat.reset(); } -bool Peer::isInFastSet(int index) const { +bool Peer::isInFastSet(int32_t index) const { return find(fastSet.begin(), fastSet.end(), index) != fastSet.end(); } -void Peer::addFastSetIndex(int index) { +void Peer::addFastSetIndex(int32_t index) { if(!isInFastSet(index)) { fastSet.push_back(index); } } -bool Peer::isInPeerAllowedIndexSet(int index) const { +bool Peer::isInPeerAllowedIndexSet(int32_t index) const { return find(peerAllowedIndexSet.begin(), peerAllowedIndexSet.end(), index) != peerAllowedIndexSet.end(); } -void Peer::addPeerAllowedIndex(int index) { +void Peer::addPeerAllowedIndex(int32_t index) { if(!isInPeerAllowedIndexSet(index)) { peerAllowedIndexSet.push_back(index); } } -bool Peer::isInAmAllowedIndexSet(int index) const { +bool Peer::isInAmAllowedIndexSet(int32_t index) const { return find(amAllowedIndexSet.begin(), amAllowedIndexSet.end(), index) != amAllowedIndexSet.end(); } -void Peer::addAmAllowedIndex(int index) { +void Peer::addAmAllowedIndex(int32_t index) { if(!isInAmAllowedIndexSet(index)) { amAllowedIndexSet.push_back(index); } @@ -141,7 +141,7 @@ void Peer::setAllBitfield() { bitfield->setAllBit(); } -void Peer::updateLatency(int latency) { +void Peer::updateLatency(int32_t latency) { this->latency = (this->latency*20+latency*80)/200; } diff --git a/src/Peer.h b/src/Peer.h index a15464f2..63b5f07c 100644 --- a/src/Peer.h +++ b/src/Peer.h @@ -53,13 +53,13 @@ class Peer { friend bool operator!=(const Peer& p1, const Peer& p2); public: string ipaddr; - int port; + int32_t port; bool amChoking; bool amInterested; bool peerChoking; bool peerInterested; - int tryCount; - int cuid; + int32_t tryCount; + int32_t cuid; bool chokingRequired; bool optUnchoking; bool snubbing; @@ -74,16 +74,16 @@ private: // fast index set which localhost has sent to a peer. Integers amAllowedIndexSet; PeerStat peerStat; - long long int sessionUploadLength; - long long int sessionDownloadLength; - int pieceLength; - int latency; + int64_t sessionUploadLength; + int64_t sessionDownloadLength; + int32_t pieceLength; + int32_t latency; bool active; string id; Time _badConditionStartTime; - int _badConditionInterval; + int32_t _badConditionInterval; public: - Peer(string ipaddr, int port, int pieceLength, long long int totalLength); + Peer(string ipaddr, int32_t port, int32_t pieceLength, int64_t totalLength); ~Peer() { delete bitfield; @@ -100,12 +100,12 @@ public: void resetStatus(); - void updateUploadLength(int bytes) { + void updateUploadLength(int32_t bytes) { peerStat.updateUploadLength(bytes); sessionUploadLength += bytes; } - void updateDownloadLength(int bytes) { + void updateDownloadLength(int32_t bytes) { peerStat.updateDownloadLength(bytes); sessionDownloadLength += bytes; } @@ -135,14 +135,14 @@ public: /** * Returns the number of bytes uploaded to the remote host. */ - long long int getSessionUploadLength() const { + int64_t getSessionUploadLength() const { return sessionUploadLength; } /** * Returns the number of bytes downloaded from the remote host. */ - long long int getSessionDownloadLength() const { + int64_t getSessionDownloadLength() const { return sessionDownloadLength; } @@ -165,43 +165,43 @@ public: } const unsigned char* getPeerId() const { return this->peerId; } - void setBitfield(const unsigned char* bitfield, int bitfieldLength) { + void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) { this->bitfield->setBitfield(bitfield, bitfieldLength); } const unsigned char* getBitfield() const { return bitfield->getBitfield(); } - int getBitfieldLength() const { return bitfield->getBitfieldLength(); } + int32_t getBitfieldLength() const { return bitfield->getBitfieldLength(); } void setAllBitfield(); /** * operation = 1: set index-th bit to 1 * operation = 0: set index-th bit to 0 */ - void updateBitfield(int index, int operation); + void updateBitfield(int32_t index, int32_t operation); void setFastExtensionEnabled(bool enabled) { fastExtensionEnabled = enabled; } bool isFastExtensionEnabled() const { return fastExtensionEnabled; } - void addFastSetIndex(int index); + void addFastSetIndex(int32_t index); const Integers& getFastSet() const { return fastSet; } - bool isInFastSet(int index) const; - int countFastSet() const { return fastSet.size(); } + bool isInFastSet(int32_t index) const; + int32_t countFastSet() const { return fastSet.size(); } - void addPeerAllowedIndex(int index); - bool isInPeerAllowedIndexSet(int index) const; + void addPeerAllowedIndex(int32_t index); + bool isInPeerAllowedIndexSet(int32_t index) const; - void addAmAllowedIndex(int index); - bool isInAmAllowedIndexSet(int index) const; + void addAmAllowedIndex(int32_t index); + bool isInAmAllowedIndexSet(int32_t index) const; bool shouldBeChoking() const; - bool hasPiece(int index) const; + bool hasPiece(int32_t index) const; bool isSeeder() const; - void updateLatency(int latency); - int getLatency() const { return latency; } + void updateLatency(int32_t latency); + int32_t getLatency() const { return latency; } const string& getId() const { return id; diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc index 0fdf317e..86c44338 100644 --- a/src/PeerAbstractCommand.cc +++ b/src/PeerAbstractCommand.cc @@ -39,7 +39,7 @@ #include "message.h" #include "prefs.h" -PeerAbstractCommand::PeerAbstractCommand(int cuid, const PeerHandle& peer, +PeerAbstractCommand::PeerAbstractCommand(int32_t cuid, const PeerHandle& peer, TorrentDownloadEngine* e, const BtContextHandle& btContext, const SocketHandle& s) @@ -88,11 +88,11 @@ bool PeerAbstractCommand::execute() { } // TODO this method removed when PeerBalancerCommand is implemented -bool PeerAbstractCommand::prepareForNextPeer(int wait) { +bool PeerAbstractCommand::prepareForNextPeer(int32_t wait) { return true; } -bool PeerAbstractCommand::prepareForRetry(int wait) { +bool PeerAbstractCommand::prepareForRetry(int32_t wait) { return true; } @@ -152,7 +152,7 @@ void PeerAbstractCommand::setWriteCheckSocket(const SocketHandle& socket) { } } -void PeerAbstractCommand::setUploadLimit(int uploadLimit) { +void PeerAbstractCommand::setUploadLimit(int32_t uploadLimit) { this->uploadLimit = uploadLimit; } diff --git a/src/PeerAbstractCommand.h b/src/PeerAbstractCommand.h index 0aed6824..e50aabde 100644 --- a/src/PeerAbstractCommand.h +++ b/src/PeerAbstractCommand.h @@ -44,22 +44,22 @@ class PeerAbstractCommand : public BtContextAwareCommand { private: Time checkPoint; - int timeout; + int32_t timeout; protected: TorrentDownloadEngine* e; SocketHandle socket; PeerHandle peer; - void setTimeout(int timeout) { this->timeout = timeout; } - virtual bool prepareForNextPeer(int wait); - virtual bool prepareForRetry(int wait); + void setTimeout(int32_t timeout) { this->timeout = timeout; } + virtual bool prepareForNextPeer(int32_t wait); + virtual bool prepareForRetry(int32_t wait); virtual void onAbort(Exception* ex); virtual bool executeInternal() = 0; void setReadCheckSocket(const SocketHandle& socket); void setWriteCheckSocket(const SocketHandle& socket); void disableReadCheckSocket(); void disableWriteCheckSocket(); - void setUploadLimit(int uploadLimit); + void setUploadLimit(int32_t uploadLimit); void setUploadLimitCheck(bool check); void setNoCheck(bool check); private: @@ -68,10 +68,10 @@ private: SocketHandle readCheckTarget; SocketHandle writeCheckTarget; bool uploadLimitCheck; - int uploadLimit; + int32_t uploadLimit; bool noCheck; public: - PeerAbstractCommand(int cuid, const PeerHandle& peer, + PeerAbstractCommand(int32_t cuid, const PeerHandle& peer, TorrentDownloadEngine* e, const BtContextHandle& btContext, const SocketHandle& s = SocketHandle()); diff --git a/src/PeerChokeCommand.cc b/src/PeerChokeCommand.cc index 5094a1b0..de06502b 100644 --- a/src/PeerChokeCommand.cc +++ b/src/PeerChokeCommand.cc @@ -35,10 +35,10 @@ #include "PeerChokeCommand.h" #include "Util.h" -PeerChokeCommand::PeerChokeCommand(int cuid, +PeerChokeCommand::PeerChokeCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext, - int interval): + int32_t interval): BtContextAwareCommand(cuid, btContext), interval(interval), e(e), @@ -59,7 +59,7 @@ void PeerChokeCommand::optUnchokingPeer(Peers& peers) const { return; } random_shuffle(peers.begin(), peers.end()); - int optUnchokCount = 1; + int32_t optUnchokCount = 1; for(Peers::iterator itr = peers.begin(); itr != peers.end(); itr++) { Peers::value_type peer = *itr; if(optUnchokCount > 0 && !peer->snubbing) { @@ -108,7 +108,7 @@ bool PeerChokeCommand::execute() { } else { orderByDownloadRate(peers); } - int unchokingCount = 4;//peers.size() >= 4 ? 4 : peers.size(); + int32_t unchokingCount = 4;//peers.size() >= 4 ? 4 : peers.size(); for(Peers::iterator itr = peers.begin(); itr != peers.end() && unchokingCount > 0; ) { PeerHandle peer = *itr; if(peer->peerInterested && !peer->snubbing) { diff --git a/src/PeerChokeCommand.h b/src/PeerChokeCommand.h index 6b03ccac..687f405c 100644 --- a/src/PeerChokeCommand.h +++ b/src/PeerChokeCommand.h @@ -41,9 +41,9 @@ class PeerChokeCommand : public BtContextAwareCommand { private: - int interval; + int32_t interval; TorrentDownloadEngine* e; - int rotate; + int32_t rotate; Time checkPoint; void orderByUploadRate(Peers& peers) const; @@ -51,10 +51,10 @@ private: void optUnchokingPeer(Peers& peers) const; public: - PeerChokeCommand(int cuid, + PeerChokeCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext, - int interval); + int32_t interval); virtual ~PeerChokeCommand(); diff --git a/src/PeerInteractionCommand.cc b/src/PeerInteractionCommand.cc index 9ed21cf7..522b02ab 100644 --- a/src/PeerInteractionCommand.cc +++ b/src/PeerInteractionCommand.cc @@ -49,12 +49,12 @@ #include "CUIDCounter.h" #include -PeerInteractionCommand::PeerInteractionCommand(int cuid, +PeerInteractionCommand::PeerInteractionCommand(int32_t cuid, const PeerHandle& p, TorrentDownloadEngine* e, const BtContextHandle& btContext, const SocketHandle& s, - int sequence) + Seq sequence) :PeerAbstractCommand(cuid, p, e, btContext, s), sequence(sequence), btInteractive(0), @@ -199,7 +199,7 @@ bool PeerInteractionCommand::executeInternal() { } // TODO this method removed when PeerBalancerCommand is implemented -bool PeerInteractionCommand::prepareForNextPeer(int wait) { +bool PeerInteractionCommand::prepareForNextPeer(int32_t wait) { if(peerStorage->isPeerAvailable() && btRuntime->lessThanEqMinPeer()) { PeerHandle peer = peerStorage->getUnusedPeer(); peer->cuid = CUIDCounterSingletonHolder::instance()->newID(); @@ -213,7 +213,7 @@ bool PeerInteractionCommand::prepareForNextPeer(int wait) { return true; } -bool PeerInteractionCommand::prepareForRetry(int wait) { +bool PeerInteractionCommand::prepareForRetry(int32_t wait) { e->commands.push_back(this); return false; } diff --git a/src/PeerInteractionCommand.h b/src/PeerInteractionCommand.h index ebb62359..0f999611 100644 --- a/src/PeerInteractionCommand.h +++ b/src/PeerInteractionCommand.h @@ -39,31 +39,32 @@ #include "BtInteractive.h" class PeerInteractionCommand : public PeerAbstractCommand { +public: + enum Seq { + INITIATOR_SEND_HANDSHAKE, + INITIATOR_WAIT_HANDSHAKE, + //RECEIVER_SEND_HANDSHAKE, + RECEIVER_WAIT_HANDSHAKE, + WIRED}; private: - int sequence; + Seq sequence; BtInteractiveHandle btInteractive; int32_t maxDownloadSpeedLimit; protected: virtual bool executeInternal(); - virtual bool prepareForRetry(int wait); - virtual bool prepareForNextPeer(int wait); + virtual bool prepareForRetry(int32_t wait); + virtual bool prepareForNextPeer(int32_t wait); virtual void onAbort(Exception* ex); public: - PeerInteractionCommand(int cuid, + PeerInteractionCommand(int32_t cuid, const PeerHandle& peer, TorrentDownloadEngine* e, const BtContextHandle& btContext, const SocketHandle& s, - int sequence); + Seq sequence); - ~PeerInteractionCommand(); + virtual ~PeerInteractionCommand(); - enum Seq { - INITIATOR_SEND_HANDSHAKE, - INITIATOR_WAIT_HANDSHAKE, - RECEIVER_SEND_HANDSHAKE, - RECEIVER_WAIT_HANDSHAKE, - WIRED}; }; #endif // _D_PEER_INTERACTION_COMMAND_H_ diff --git a/src/PeerListenCommand.cc b/src/PeerListenCommand.cc index 1eab4818..e9e7b11c 100644 --- a/src/PeerListenCommand.cc +++ b/src/PeerListenCommand.cc @@ -38,7 +38,7 @@ #include "CUIDCounter.h" #include "message.h" -PeerListenCommand::PeerListenCommand(int cuid, +PeerListenCommand::PeerListenCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext) :BtContextAwareCommand(cuid, btContext), @@ -47,11 +47,11 @@ PeerListenCommand::PeerListenCommand(int cuid, PeerListenCommand::~PeerListenCommand() {} -int PeerListenCommand::bindPort(int portRangeStart, int portRangeEnd) { +int32_t PeerListenCommand::bindPort(int32_t portRangeStart, int32_t portRangeEnd) { if(portRangeStart > portRangeEnd) { return -1; } - for(int port = portRangeStart; port <= portRangeEnd; port++) { + for(int32_t port = portRangeStart; port <= portRangeEnd; port++) { try { socket->beginListen(port); logger->info(MSG_LISTENING_PORT, @@ -71,13 +71,13 @@ bool PeerListenCommand::execute() { if(btRuntime->isHalt()) { return true; } - for(int i = 0; i < 3 && socket->isReadable(0); i++) { + for(int32_t i = 0; i < 3 && socket->isReadable(0); i++) { SocketHandle peerSocket; try { peerSocket = socket->acceptConnection(); - pair peerInfo; + pair peerInfo; peerSocket->getPeerInfo(peerInfo); - pair localInfo; + pair localInfo; peerSocket->getAddrInfo(localInfo); TransferStat tstat = peerStorage->calculateStat(); diff --git a/src/PeerListenCommand.h b/src/PeerListenCommand.h index 815b622f..e385da2d 100644 --- a/src/PeerListenCommand.h +++ b/src/PeerListenCommand.h @@ -44,15 +44,15 @@ private: SocketHandle socket; int32_t _lowestSpeedLimit; public: - PeerListenCommand(int cuid, + PeerListenCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext); - ~PeerListenCommand(); + virtual ~PeerListenCommand(); bool execute(); - int bindPort(int portRangeStart, int portRangeEnd); + int32_t bindPort(int32_t portRangeStart, int32_t portRangeEnd); void setLowestSpeedLimit(int32_t speed) { diff --git a/src/PeerStat.h b/src/PeerStat.h index 9b90eac0..176cf9b0 100644 --- a/src/PeerStat.h +++ b/src/PeerStat.h @@ -48,14 +48,14 @@ public: REQUEST_IDLE, }; private: - int cuid; + int32_t cuid; SpeedCalc downloadSpeed; SpeedCalc uploadSpeed; Time downloadStartTime; PeerStat::STATUS status; public: - PeerStat(int cuid = 0):cuid(cuid), status(PeerStat::IDLE) {} + PeerStat(int32_t cuid = 0):cuid(cuid), status(PeerStat::IDLE) {} ~PeerStat() {} @@ -78,27 +78,27 @@ public: return uploadSpeed.calculateSpeed(now); } - void updateDownloadLength(int bytes) { + void updateDownloadLength(int32_t bytes) { downloadSpeed.update(bytes); } - void updateUploadLength(int bytes) { + void updateUploadLength(int32_t bytes) { uploadSpeed.update(bytes); } - int getMaxDownloadSpeed() const { + int32_t getMaxDownloadSpeed() const { return downloadSpeed.getMaxSpeed(); } - int getMaxUploadSpeed() const { + int32_t getMaxUploadSpeed() const { return uploadSpeed.getMaxSpeed(); } - int getAvgDownloadSpeed() const { + int32_t getAvgDownloadSpeed() const { return downloadSpeed.getAvgSpeed(); } - int getAvgUploadSpeed() const { + int32_t getAvgUploadSpeed() const { return uploadSpeed.getAvgSpeed(); } @@ -130,7 +130,7 @@ public: return status; } - int getCuid() const { + int32_t getCuid() const { return cuid; } }; diff --git a/src/Piece.cc b/src/Piece.cc index f73cf83c..e227bbaa 100644 --- a/src/Piece.cc +++ b/src/Piece.cc @@ -38,7 +38,7 @@ Piece::Piece():index(0), length(0), bitfield(0) {} -Piece::Piece(int index, int length):index(index), length(length) { +Piece::Piece(int32_t index, int32_t length):index(index), length(length) { bitfield = BitfieldManFactory::getFactoryInstance()->createBitfieldMan(BLOCK_LENGTH, length); } @@ -54,7 +54,7 @@ Piece::Piece(const Piece& piece) { } -void Piece::completeBlock(int blockIndex) { +void Piece::completeBlock(int32_t blockIndex) { bitfield->setBit(blockIndex); bitfield->unsetUseBit(blockIndex); } @@ -72,12 +72,12 @@ bool Piece::pieceComplete() const { return bitfield->isAllBitSet(); } -void Piece::cancelBlock(int blockIndex) { +void Piece::cancelBlock(int32_t blockIndex) { bitfield->unsetUseBit(blockIndex); } -int Piece::getMissingUnusedBlockIndex() const { - int blockIndex = bitfield->getFirstMissingUnusedIndex(); +int32_t Piece::getMissingUnusedBlockIndex() const { + int32_t blockIndex = bitfield->getFirstMissingUnusedIndex(); if(blockIndex == -1) { return blockIndex; } @@ -85,8 +85,8 @@ int Piece::getMissingUnusedBlockIndex() const { return blockIndex; } -int Piece::getMissingBlockIndex() const { - int blockIndex = bitfield->getMissingIndex(); +int32_t Piece::getMissingBlockIndex() const { + int32_t blockIndex = bitfield->getMissingIndex(); if(blockIndex == -1) { return blockIndex; } diff --git a/src/Piece.h b/src/Piece.h index 26d83bd3..8b779560 100644 --- a/src/Piece.h +++ b/src/Piece.h @@ -42,13 +42,13 @@ class Piece { private: - int index; - int length; + int32_t index; + int32_t length; BitfieldMan* bitfield; public: Piece(); - Piece(int index, int length); + Piece(int32_t index, int32_t length); Piece(const Piece& piece); @@ -76,15 +76,15 @@ public: return index == piece.index; } - int getMissingUnusedBlockIndex() const; - int getMissingBlockIndex() const; + int32_t getMissingUnusedBlockIndex() const; + int32_t getMissingBlockIndex() const; BlockIndexes getAllMissingBlockIndexes() const; - void completeBlock(int blockIndex); - void cancelBlock(int blockIndex); - int countCompleteBlock() const { + void completeBlock(int32_t blockIndex); + void cancelBlock(int32_t blockIndex); + int32_t countCompleteBlock() const { return bitfield->countBlock()-bitfield->countMissingBlock(); } - bool hasBlock(int blockIndex) const { + bool hasBlock(int32_t blockIndex) const { return bitfield->isBitSet(blockIndex); } /** @@ -92,20 +92,20 @@ public: * returns false. */ bool pieceComplete() const; - int countBlock() const { return bitfield->countBlock(); } - int getBlockLength(int index) const { + int32_t countBlock() const { return bitfield->countBlock(); } + int32_t getBlockLength(int32_t index) const { return bitfield->getBlockLength(index); } - int getBlockLength() const { return bitfield->getBlockLength(); } - int getIndex() const { return index; } - void setIndex(int index) { this->index = index; } - int getLength() const { return length; } - void setLength(int index) { this->length = length; } + int32_t getBlockLength() const { return bitfield->getBlockLength(); } + int32_t getIndex() const { return index; } + void setIndex(int32_t index) { this->index = index; } + int32_t getLength() const { return length; } + void setLength(int32_t index) { this->length = length; } const unsigned char* getBitfield() const { return bitfield->getBitfield(); } - void setBitfield(const unsigned char* bitfield, int len); + void setBitfield(const unsigned char* bitfield, int32_t len); - int getBitfieldLength() const { + int32_t getBitfieldLength() const { return bitfield->getBitfieldLength(); } @@ -114,7 +114,7 @@ public: string toString() const; - bool isBlockUsed(int index) const { + bool isBlockUsed(int32_t index) const { return bitfield->isUseBitSet(index); } }; diff --git a/src/PieceStorage.h b/src/PieceStorage.h index b96d70bf..e41aeea6 100644 --- a/src/PieceStorage.h +++ b/src/PieceStorage.h @@ -70,7 +70,7 @@ public: * Returns the piece denoted by index. * No status of the piece is changed in this method. */ - virtual PieceHandle getPiece(int index) = 0; + virtual PieceHandle getPiece(int32_t index) = 0; /** * Tells that the download of the specfied piece completes. @@ -86,15 +86,15 @@ public: * Returns true if the specified piece is already downloaded. * Otherwise returns false. */ - virtual bool hasPiece(int index) = 0; + virtual bool hasPiece(int32_t index) = 0; - virtual long long int getTotalLength() = 0; + virtual int64_t getTotalLength() = 0; - virtual long long int getFilteredTotalLength() = 0; + virtual int64_t getFilteredTotalLength() = 0; - virtual long long int getCompletedLength() = 0; + virtual int64_t getCompletedLength() = 0; - virtual long long int getFilteredCompletedLength() = 0; + virtual int64_t getFilteredCompletedLength() = 0; virtual void setFileFilter(const Strings& filePaths) = 0; @@ -124,9 +124,9 @@ public: virtual const unsigned char* getBitfield() = 0; virtual void setBitfield(const unsigned char* bitfield, - int bitfieldLength) = 0; + int32_t bitfieldLength) = 0; - virtual int getBitfieldLength() = 0; + virtual int32_t getBitfieldLength() = 0; virtual bool isSelectiveDownloadingMode() = 0; @@ -136,26 +136,26 @@ public: virtual DiskAdaptorHandle getDiskAdaptor() = 0; - virtual int getPieceLength(int index) = 0; + virtual int32_t getPieceLength(int32_t index) = 0; /** * Adds piece index to advertise to other commands. They send have message * based on this information. */ - virtual void advertisePiece(int cuid, int index) = 0; + virtual void advertisePiece(int32_t cuid, int32_t index) = 0; /** * Returns piece index which is not advertised by the caller command and * newer than lastCheckTime. */ - virtual Integers getAdvertisedPieceIndexes(int myCuid, + virtual Integers getAdvertisedPieceIndexes(int32_t myCuid, const Time& lastCheckTime) = 0; /** * Removes have entry if specified seconds have elapsed since its * registration. */ - virtual void removeAdvertisedPiece(int elapsed) = 0; + virtual void removeAdvertisedPiece(int32_t elapsed) = 0; /** * Sets all bits in bitfield to 1. diff --git a/src/Randomizer.h b/src/Randomizer.h index cbfcc8bb..aa4be677 100644 --- a/src/Randomizer.h +++ b/src/Randomizer.h @@ -41,9 +41,9 @@ class Randomizer { public: virtual ~Randomizer() {} - virtual int getRandomNumber() = 0; + virtual long int getRandomNumber() = 0; - virtual int getMaxRandomNumber() = 0; + virtual long int getMaxRandomNumber() = 0; }; typedef SharedHandle RandomizerHandle; diff --git a/src/Request.cc b/src/Request.cc index ffc9455e..938c6186 100644 --- a/src/Request.cc +++ b/src/Request.cc @@ -95,7 +95,7 @@ bool Request::parseUrl(const string& url) { string::size_type hp = tempUrl.find("://"); if(hp == string::npos) return false; protocol = tempUrl.substr(0, hp); - int defPort; + int32_t defPort; if((defPort = FeatureConfig::getInstance()->getDefaultPort(protocol)) == 0) { return false; } @@ -109,7 +109,7 @@ bool Request::parseUrl(const string& url) { Util::split(hostAndPort, tempUrl.substr(hp, hep-hp), ':'); host = hostAndPort.first; if(hostAndPort.second != "") { - port = (int)strtol(hostAndPort.second.c_str(), NULL, 10); + port = strtol(hostAndPort.second.c_str(), NULL, 10); if(!(0 < port && port <= 65535)) { return false; } diff --git a/src/Request.h b/src/Request.h index 0b4f71c7..73fdd833 100644 --- a/src/Request.h +++ b/src/Request.h @@ -51,6 +51,14 @@ #define METALINK_MARK "#!metalink3!" class Request { +public: + enum TRACKER_EVENT { + AUTO, + STARTED, + STOPPED, + COMPLETED, + AFTER_COMPLETED + }; private: string url; string currentUrl; @@ -64,11 +72,11 @@ private: string referer; string protocol; string host; - int port; + int32_t port; string dir; string file; - int tryCount; - int trackerEvent; + int32_t tryCount; + TRACKER_EVENT trackerEvent; bool keepAlive; string method; @@ -95,7 +103,7 @@ public: bool resetUrl(); void resetTryCount() { tryCount = 0; } void addTryCount() { tryCount++; } - int getTryCount() const { return tryCount; } + int32_t getTryCount() const { return tryCount; } //bool noMoreTry() const { return tryCount >= PREF_MAX_TRY; } string getUrl() const { return url; } @@ -105,13 +113,13 @@ public: void setReferer(const string& url) { referer = previousUrl = url; } string getProtocol() const { return protocol; } string getHost() const { return host; } - int getPort() const { return port; } + int32_t getPort() const { return port; } string getDir() const { return dir; } string getFile() const { return file;} bool isKeepAlive() const { return keepAlive; } void setKeepAlive(bool keepAlive) { this->keepAlive = keepAlive; } - void setTrackerEvent(int event) { trackerEvent = event; } - int getTrackerEvent() const { return trackerEvent; } + void setTrackerEvent(TRACKER_EVENT event) { trackerEvent = event; } + TRACKER_EVENT getTrackerEvent() const { return trackerEvent; } void setMethod(const string& method) { this->method = method; @@ -145,14 +153,6 @@ public: static const string METHOD_GET; static const string METHOD_HEAD; - enum TRACKER_EVENT { - AUTO, - STARTED, - STOPPED, - COMPLETED, - AFTER_COMPLETED - }; - }; typedef SharedHandle RequestHandle; diff --git a/src/RequestGroupEntry.h b/src/RequestGroupEntry.h index a294d7fc..157f3048 100644 --- a/src/RequestGroupEntry.h +++ b/src/RequestGroupEntry.h @@ -43,13 +43,13 @@ class DownloadCommand; class RequestGroupEntry : public ProgressAwareEntry { protected: - int _cuid; + int32_t _cuid; RequestHandle _currentRequest; RequestGroup* _requestGroup; DownloadCommand* _nextDownloadCommand; bool _shouldAddNumConnection; public: - RequestGroupEntry(int cuid, + RequestGroupEntry(int32_t cuid, const RequestHandle& currentRequest, RequestGroup* requestGroup, DownloadCommand* nextDownloadCommand = 0): @@ -73,7 +73,7 @@ public: return _requestGroup->getTotalLength(); } - int getCUID() const + int32_t getCUID() const { return _cuid; } diff --git a/src/RequestSlot.cc b/src/RequestSlot.cc index eae5de48..bba41f5a 100644 --- a/src/RequestSlot.cc +++ b/src/RequestSlot.cc @@ -64,7 +64,7 @@ bool RequestSlot::isTimeout(time_t timeoutSec) const { return dispatchedTime.elapsed(timeoutSec); } -int RequestSlot::getLatencyInMillis() const { +int32_t RequestSlot::getLatencyInMillis() const { return dispatchedTime.differenceInMillis(); } diff --git a/src/RequestSlot.h b/src/RequestSlot.h index d457b9ff..aaa2c307 100644 --- a/src/RequestSlot.h +++ b/src/RequestSlot.h @@ -68,7 +68,7 @@ public: void setDispatchedTime(time_t secFromEpoch); bool isTimeout(time_t timeoutSec) const; - int getLatencyInMillis() const; + int32_t getLatencyInMillis() const; int32_t getIndex() const { return index; } void setIndex(int32_t index) { this->index = index; } diff --git a/src/Segment.h b/src/Segment.h index 20e72a58..d082fbc1 100644 --- a/src/Segment.h +++ b/src/Segment.h @@ -42,12 +42,12 @@ using namespace std; class Segment { public: - int index; - int length; - int segmentLength; - int writtenLength; + int32_t index; + int32_t length; + int32_t segmentLength; + int32_t writtenLength; - Segment(int index, int length, int segmentLength, int writtenLength = 0) + Segment(int32_t index, int32_t length, int32_t segmentLength, int32_t writtenLength = 0) :index(index), length(length), segmentLength(segmentLength), writtenLength(writtenLength) {} diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc index 0664fe81..60547d8b 100644 --- a/src/SegmentMan.cc +++ b/src/SegmentMan.cc @@ -111,12 +111,12 @@ void SegmentMan::save() const { if(fwrite(&totalSize, sizeof(totalSize), 1, segFile) < 1) { throw string("writeError"); } - int segmentLength = bitfield->getBlockLength(); + int32_t segmentLength = bitfield->getBlockLength(); if(fwrite(&segmentLength, sizeof(segmentLength), 1, segFile) < 1) { throw string("writeError"); } if(bitfield) { - int bitfieldLength = bitfield->getBitfieldLength(); + int32_t bitfieldLength = bitfield->getBitfieldLength(); if(fwrite(&bitfieldLength, sizeof(bitfieldLength), 1, segFile) < 1) { throw string("writeError"); } @@ -125,12 +125,12 @@ void SegmentMan::save() const { throw string("writeError"); } } else { - int i = 0; + int32_t i = 0; if(fwrite(&i, sizeof(i), 1, segFile) < 1) { throw string("writeError"); } } - int usedSegmentCount = usedSegmentEntries.size(); + int32_t usedSegmentCount = usedSegmentEntries.size(); if(fwrite(&usedSegmentCount, sizeof(usedSegmentCount), 1, segFile) < 1) { throw string("writeError"); } @@ -163,11 +163,11 @@ void SegmentMan::read(FILE* file) { if(fread(&totalSize, sizeof(totalSize), 1, file) < 1) { throw string("readError"); } - int segmentSize; + int32_t segmentSize; if(fread(&segmentSize, sizeof(segmentSize), 1, file) < 1) { throw string("readError"); } - int bitfieldLength; + int32_t bitfieldLength; if(fread(&bitfieldLength, sizeof(bitfieldLength), 1, file) < 1) { throw string("readError"); } @@ -182,7 +182,7 @@ void SegmentMan::read(FILE* file) { delete [] savedBitfield; } } - int segmentCount; + int32_t segmentCount; if(fread(&segmentCount, sizeof(segmentCount), 1, file) < 1) { throw string("readError"); } @@ -277,7 +277,7 @@ SegmentHandle SegmentMan::onNullBitfield(int32_t cuid) { } SegmentEntryHandle SegmentMan::findSlowerSegmentEntry(const PeerStatHandle& peerStat) const { - int speed = (int)(peerStat->getAvgDownloadSpeed()*0.8); + int32_t speed = (int32_t)(peerStat->getAvgDownloadSpeed()*0.8); SegmentEntryHandle slowSegmentEntry(0); for(SegmentEntries::const_iterator itr = usedSegmentEntries.begin(); itr != usedSegmentEntries.end(); ++itr) { @@ -291,7 +291,7 @@ SegmentEntryHandle SegmentMan::findSlowerSegmentEntry(const PeerStatHandle& peer !p->getDownloadStartTime().elapsed(option->getAsInt(PREF_STARTUP_IDLE_TIME))) { continue; } - int pSpeed = p->calculateDownloadSpeed(); + int32_t pSpeed = p->calculateDownloadSpeed(); if(pSpeed < speed) { speed = pSpeed; slowSegmentEntry = segmentEntry; @@ -308,7 +308,7 @@ SegmentHandle SegmentMan::getSegment(int32_t cuid) { if(!segmentEntry.isNull()) { return segmentEntry->segment; } - int index = bitfield->getSparseMissingUnusedIndex(); + int32_t index = bitfield->getSparseMissingUnusedIndex(); if(index == -1) { PeerStatHandle myPeerStat = getPeerStat(cuid); if(!myPeerStat.get()) { @@ -423,7 +423,7 @@ void SegmentMan::registerPeerStat(const PeerStatHandle& peerStat) { } int32_t SegmentMan::calculateDownloadSpeed() const { - int speed = 0; + int32_t speed = 0; for(PeerStats::const_iterator itr = peerStats.begin(); itr != peerStats.end(); itr++) { const PeerStatHandle& peerStat = *itr; diff --git a/src/SegmentMan.h b/src/SegmentMan.h index 33f84cfc..1dc869c2 100644 --- a/src/SegmentMan.h +++ b/src/SegmentMan.h @@ -50,10 +50,10 @@ using namespace std; class SegmentEntry { public: - int cuid; + int32_t cuid; SegmentHandle segment; public: - SegmentEntry(int cuid, const SegmentHandle& segment) + SegmentEntry(int32_t cuid, const SegmentHandle& segment) :cuid(cuid), segment(segment) {} ~SegmentEntry() {} }; @@ -77,7 +77,7 @@ private: SegmentHandle onNullBitfield(int32_t cuid); SegmentHandle checkoutSegment(int32_t cuid, int32_t index); SegmentEntryHandle findSlowerSegmentEntry(const PeerStatHandle& peerStat) const; - SegmentEntryHandle getSegmentEntryByIndex(int index) { + SegmentEntryHandle getSegmentEntryByIndex(int32_t index) { for(SegmentEntries::const_iterator itr = usedSegmentEntries.begin(); itr != usedSegmentEntries.end(); ++itr) { const SegmentEntryHandle& segmentEntry = *itr; @@ -88,7 +88,7 @@ private: return 0; } - SegmentEntryHandle getSegmentEntryByCuid(int cuid) { + SegmentEntryHandle getSegmentEntryByCuid(int32_t cuid) { for(SegmentEntries::const_iterator itr = usedSegmentEntries.begin(); itr != usedSegmentEntries.end(); ++itr) { const SegmentEntryHandle& segmentEntry = *itr; @@ -99,7 +99,7 @@ private: return 0; } - SegmentEntries::iterator getSegmentEntryIteratorByCuid(int cuid) { + SegmentEntries::iterator getSegmentEntryIteratorByCuid(int32_t cuid) { for(SegmentEntries::iterator itr = usedSegmentEntries.begin(); itr != usedSegmentEntries.end(); ++itr) { const SegmentEntryHandle& segmentEntry = *itr; @@ -151,7 +151,7 @@ public: /** * Represents the number of failures(usually, DlAbortEx) in downloads. */ - int errors; + int32_t errors; const Option* option; DiskWriterHandle diskWriter; @@ -268,7 +268,7 @@ public: * Returns peerStat whose cuid is given cuid. If it is not found, returns * 0. */ - PeerStatHandle getPeerStat(int cuid) const { + PeerStatHandle getPeerStat(int32_t cuid) const { for(PeerStats::const_iterator itr = peerStats.begin(); itr != peerStats.end(); ++itr) { const PeerStatHandle& peerStat = *itr; if(peerStat->getCuid() == cuid) { diff --git a/src/ShareRatioSeedCriteria.h b/src/ShareRatioSeedCriteria.h index 8a7b9a27..0b5b9f55 100644 --- a/src/ShareRatioSeedCriteria.h +++ b/src/ShareRatioSeedCriteria.h @@ -66,7 +66,7 @@ public: return false; } TransferStat stat = peerStorage->calculateStat(); - long long int allTimeUploadLength = + int64_t allTimeUploadLength = btRuntime->getUploadLengthAtStartup()+stat.getSessionUploadLength(); return ratio <= ((double)allTimeUploadLength)/pieceStorage->getCompletedLength(); diff --git a/src/SimpleBtMessage.cc b/src/SimpleBtMessage.cc index 587c3c9e..d9b24195 100644 --- a/src/SimpleBtMessage.cc +++ b/src/SimpleBtMessage.cc @@ -46,14 +46,14 @@ void SimpleBtMessage::send() { } if(sendPredicate() || sendingInProgress) { const unsigned char* msg = getMessage(); - int msgLength = getMessageLength(); + int32_t msgLength = getMessageLength(); if(!sendingInProgress) { logger->info(MSG_SEND_PEER_MESSAGE, cuid, peer->ipaddr.c_str(), peer->port, toString().c_str()); leftDataLength = getMessageLength(); } sendingInProgress = false; - int writtenLength = peerConnection->sendMessage(msg+msgLength-leftDataLength, leftDataLength); + int32_t writtenLength = peerConnection->sendMessage(msg+msgLength-leftDataLength, leftDataLength); if(writtenLength == leftDataLength) { onSendComplete(); } else { diff --git a/src/SimpleBtMessage.h b/src/SimpleBtMessage.h index 241398a8..6747d95b 100644 --- a/src/SimpleBtMessage.h +++ b/src/SimpleBtMessage.h @@ -39,7 +39,7 @@ class SimpleBtMessage : public AbstractBtMessage { private: - int leftDataLength; + int32_t leftDataLength; public: SimpleBtMessage(); diff --git a/src/SimpleLogger.cc b/src/SimpleLogger.cc index cddead03..68c56e5c 100644 --- a/src/SimpleLogger.cc +++ b/src/SimpleLogger.cc @@ -72,7 +72,7 @@ void SimpleLogger::closeFile() { } } -void SimpleLogger::setStdout(int level, bool enabled) { +void SimpleLogger::setStdout(Logger::LEVEL level, bool enabled) { if(enabled) { stdoutField |= level; } else { @@ -84,7 +84,7 @@ void SimpleLogger::writeHeader(FILE* file, string date, string level) const { fprintf(file, "%s %s - ", date.c_str(), level.c_str()); } -void SimpleLogger::writeLog(FILE* file, int level, const char* msg, va_list ap, Exception* e, bool printHeader) const +void SimpleLogger::writeLog(FILE* file, Logger::LEVEL level, const char* msg, va_list ap, Exception* e, bool printHeader) const { string levelStr; switch(level) { @@ -125,7 +125,7 @@ void SimpleLogger::writeLog(FILE* file, int level, const char* msg, va_list ap, fflush(file); } -void SimpleLogger::writeFile(int level, const char* msg, va_list ap, Exception* e) const { +void SimpleLogger::writeFile(Logger::LEVEL level, const char* msg, va_list ap, Exception* e) const { writeLog(file, level, msg, ap, e); if(stdoutField&level) { fprintf(stdout, "\n"); diff --git a/src/SimpleLogger.h b/src/SimpleLogger.h index e3e83c30..1773a79e 100644 --- a/src/SimpleLogger.h +++ b/src/SimpleLogger.h @@ -39,11 +39,11 @@ class SimpleLogger:public Logger { private: - void writeFile(int level, const char* msg, va_list ap, Exception* e = 0) const; + void writeFile(Logger::LEVEL level, const char* msg, va_list ap, Exception* e = 0) const; void writeHeader(FILE* file, string date, string level) const; - void writeLog(FILE* file, int level, const char* msg, va_list ap, Exception* e = 0, bool printHeader = true) const; + void writeLog(FILE* file, Logger::LEVEL level, const char* msg, va_list ap, Exception* e = 0, bool printHeader = true) const; FILE* file; - int stdoutField; + int32_t stdoutField; public: SimpleLogger(FILE* logfile = 0); ~SimpleLogger(); @@ -61,7 +61,7 @@ public: virtual void error(const char* msg, ...) const; virtual void error(const char* msg, Exception* ex, ...) const; - void setStdout(int level, bool enabled); + void setStdout(Logger::LEVEL level, bool enabled); }; #endif // _D_SIMPLE_LOGGER_H_ diff --git a/src/SimpleRandomizer.h b/src/SimpleRandomizer.h index 13534034..bdbcfc57 100644 --- a/src/SimpleRandomizer.h +++ b/src/SimpleRandomizer.h @@ -59,12 +59,12 @@ public: virtual ~SimpleRandomizer() {} - virtual int getRandomNumber() { + virtual long int getRandomNumber() { return random(); } - virtual int getMaxRandomNumber() { - return RAND_MAX; + virtual long int getMaxRandomNumber() { + return RAND_MAX; } }; diff --git a/src/SleepCommand.cc b/src/SleepCommand.cc index 5390c70f..aa13c07f 100644 --- a/src/SleepCommand.cc +++ b/src/SleepCommand.cc @@ -35,7 +35,7 @@ #include "SleepCommand.h" #include "Util.h" -SleepCommand::SleepCommand(int cuid, DownloadEngine* e, Command* nextCommand, int wait): +SleepCommand::SleepCommand(int32_t cuid, DownloadEngine* e, Command* nextCommand, int32_t wait): Command(cuid), engine(e), nextCommand(nextCommand), wait(wait) {} SleepCommand::~SleepCommand() { diff --git a/src/SleepCommand.h b/src/SleepCommand.h index 33d9f4d1..f4f1ee20 100644 --- a/src/SleepCommand.h +++ b/src/SleepCommand.h @@ -43,11 +43,11 @@ class SleepCommand:public Command { private: DownloadEngine* engine; Command* nextCommand; - int wait; + int32_t wait; Time checkPoint; public: - SleepCommand(int cuid, DownloadEngine* e, Command* nextCommand, int wait); - ~SleepCommand(); + SleepCommand(int32_t cuid, DownloadEngine* e, Command* nextCommand, int32_t wait); + virtual ~SleepCommand(); bool execute(); }; diff --git a/src/Socket.cc b/src/Socket.cc index c94dc696..b8a01f6d 100644 --- a/src/Socket.cc +++ b/src/Socket.cc @@ -66,15 +66,15 @@ Socket& Socket::operator=(const Socket& s) { return *this; } -void Socket::beginListen(int port) const { +void Socket::beginListen(int32_t port) const { core->beginListen(port); } -void Socket::getAddrInfo(pair& addrinfo) const { +void Socket::getAddrInfo(pair& addrinfo) const { core->getAddrInfo(addrinfo); } -void Socket::getPeerInfo(pair& peerinfo) const { +void Socket::getPeerInfo(pair& peerinfo) const { core->getPeerInfo(peerinfo); } @@ -82,7 +82,7 @@ Socket* Socket::acceptConnection() const { return new Socket(core->acceptConnection()); } -void Socket::establishConnection(const string& host, int port) const { +void Socket::establishConnection(const string& host, int32_t port) const { core->establishConnection(host, port); } @@ -94,15 +94,15 @@ void Socket::closeConnection() const { core->closeConnection(); } -bool Socket::isWritable(int timeout) const { +bool Socket::isWritable(int32_t timeout) const { return core->isWritable(timeout); } -bool Socket::isReadable(int timeout) const { +bool Socket::isReadable(int32_t timeout) const { return core->isReadable(timeout); } -void Socket::writeData(const char* data, int len) const { +void Socket::writeData(const char* data, int32_t len) const { core->writeData(data, len); } @@ -110,11 +110,11 @@ void Socket::writeData(const string& str) const { core->writeData(str.c_str(), str.size()); } -void Socket::readData(char* data, int& len) const { +void Socket::readData(char* data, int32_t& len) const { core->readData(data, len); } -void Socket::peekData(char* data, int& len) const { +void Socket::peekData(char* data, int32_t& len) const { core->peekData(data, len); } diff --git a/src/SocketCore.cc b/src/SocketCore.cc index 2c67a66d..8422ed74 100644 --- a/src/SocketCore.cc +++ b/src/SocketCore.cc @@ -51,7 +51,7 @@ SocketCore::SocketCore():sockfd(-1) { init(); } -SocketCore::SocketCore(int sockfd):sockfd(sockfd) { +SocketCore::SocketCore(int32_t sockfd):sockfd(sockfd) { init(); } @@ -79,7 +79,7 @@ SocketCore::~SocketCore() { #endif // HAVE_LIBGNUTLS } -void SocketCore::beginListen(int port) { +void SocketCore::beginListen(int32_t port) { closeConnection(); //sockfd = socket(AF_UNSPEC, SOCK_STREAM, PF_UNSPEC); sockfd = socket(AF_INET, SOCK_STREAM, 0); @@ -114,7 +114,7 @@ SocketCore* SocketCore::acceptConnection() const { struct sockaddr_in sockaddr; socklen_t len = sizeof(sockaddr); memset((char*)&sockaddr, 0, sizeof(sockaddr)); - int fd; + int32_t fd; if((fd = accept(sockfd, (struct sockaddr*)&sockaddr, &len)) == -1) { throw new DlAbortEx(EX_SOCKET_ACCEPT, strerror(errno)); } @@ -123,7 +123,7 @@ SocketCore* SocketCore::acceptConnection() const { return s; } -void SocketCore::getAddrInfo(pair& addrinfo) const { +void SocketCore::getAddrInfo(pair& addrinfo) const { struct sockaddr_in listenaddr; memset((char*)&listenaddr, 0, sizeof(listenaddr)); socklen_t len = sizeof(listenaddr); @@ -134,10 +134,10 @@ void SocketCore::getAddrInfo(pair& addrinfo) const { addrinfo.second = ntohs(listenaddr.sin_port); } -void SocketCore::getPeerInfo(pair& peerinfo) const { +void SocketCore::getPeerInfo(pair& peerinfo) const { struct sockaddr_in peerin; memset(&peerin, 0, sizeof(peerin)); - int len = sizeof(peerin); + int32_t len = sizeof(peerin); if(getpeername(sockfd, (struct sockaddr*)&peerin, (socklen_t*)&len) < 0) { throw new DlAbortEx(EX_SOCKET_GET_PEER, strerror(errno)); } @@ -145,7 +145,7 @@ void SocketCore::getPeerInfo(pair& peerinfo) const { peerinfo.second = ntohs(peerin.sin_port); } -void SocketCore::establishConnection(const string& host, int port) { +void SocketCore::establishConnection(const string& host, int32_t port) { closeConnection(); sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd == -1) { @@ -172,7 +172,7 @@ void SocketCore::establishConnection(const string& host, int port) { ai.ai_socktype = SOCK_STREAM; ai.ai_protocol = 0; struct addrinfo* res; - int ec; + int32_t ec; if((ec = getaddrinfo(host.c_str(), NULL, &ai, &res)) != 0) { throw new DlAbortEx(EX_RESOLVE_HOSTNAME, host.c_str(), gai_strerror(ec)); @@ -188,13 +188,13 @@ void SocketCore::establishConnection(const string& host, int port) { } void SocketCore::setNonBlockingMode() const { - int flags = fcntl(sockfd, F_GETFL, 0); + int32_t flags = fcntl(sockfd, F_GETFL, 0); // TODO add error handling fcntl(sockfd, F_SETFL, flags|O_NONBLOCK); } void SocketCore::setBlockingMode() const { - int flags = fcntl(sockfd, F_GETFL, 0); + int32_t flags = fcntl(sockfd, F_GETFL, 0); // TODO add error handling fcntl(sockfd, F_SETFL, flags&(~O_NONBLOCK)); } @@ -230,7 +230,7 @@ void SocketCore::closeConnection() { #endif // HAVE_LIBGNUTLS } -bool SocketCore::isWritable(int timeout) const { +bool SocketCore::isWritable(int32_t timeout) const { fd_set fds; FD_ZERO(&fds); FD_SET(sockfd, &fds); @@ -239,7 +239,7 @@ bool SocketCore::isWritable(int timeout) const { tv.tv_sec = timeout; tv.tv_usec = 0; - int r = select(sockfd+1, NULL, &fds, NULL, &tv); + int32_t r = select(sockfd+1, NULL, &fds, NULL, &tv); if(r == 1) { return true; } else if(r == 0) { @@ -254,7 +254,7 @@ bool SocketCore::isWritable(int timeout) const { } } -bool SocketCore::isReadable(int timeout) const { +bool SocketCore::isReadable(int32_t timeout) const { #ifdef HAVE_LIBGNUTLS if(secure && peekBufLength > 0) { return true; @@ -268,7 +268,7 @@ bool SocketCore::isReadable(int timeout) const { tv.tv_sec = timeout; tv.tv_usec = 0; - int r = select(sockfd+1, &fds, NULL, NULL, &tv); + int32_t r = select(sockfd+1, &fds, NULL, NULL, &tv); if(r == 1) { return true; } else if(r == 0) { @@ -283,8 +283,8 @@ bool SocketCore::isReadable(int timeout) const { } } -void SocketCore::writeData(const char* data, int len) { - int ret = 0; +void SocketCore::writeData(const char* data, int32_t len) { + int32_t ret = 0; if(!secure && (ret = send(sockfd, data, (size_t)len, 0)) != len #ifdef HAVE_LIBSSL // for SSL @@ -309,8 +309,8 @@ void SocketCore::writeData(const char* data, int len) { } } -void SocketCore::readData(char* data, int& len) { - int ret = 0; +void SocketCore::readData(char* data, int32_t& len) { + int32_t ret = 0; if(!secure && (ret = recv(sockfd, data, (size_t)len, 0)) < 0 #ifdef HAVE_LIBSSL // for SSL @@ -336,8 +336,8 @@ void SocketCore::readData(char* data, int& len) { len = ret; } -void SocketCore::peekData(char* data, int& len) { - int ret = 0; +void SocketCore::peekData(char* data, int32_t& len) { + int32_t ret = 0; if(!secure && (ret = recv(sockfd, data, (size_t)len, MSG_PEEK)) < 0 #ifdef HAVE_LIBSSL // for SSL @@ -364,10 +364,10 @@ void SocketCore::peekData(char* data, int& len) { } #ifdef HAVE_LIBGNUTLS -int SocketCore::shiftPeekData(char* data, int len) { +int32_t SocketCore::shiftPeekData(char* data, int32_t len) { if(peekBufLength <= len) { memcpy(data, peekBuf, peekBufLength); - int ret = peekBufLength; + int32_t ret = peekBufLength; peekBufLength = 0; return ret; } else { @@ -382,7 +382,7 @@ int SocketCore::shiftPeekData(char* data, int len) { } -void SocketCore::addPeekData(char* data, int len) { +void SocketCore::addPeekData(char* data, int32_t len) { if(peekBufLength+len > peekBufMax) { char* temp = new char[peekBufMax+len]; memcpy(temp, peekBuf, peekBufLength); @@ -394,10 +394,10 @@ void SocketCore::addPeekData(char* data, int len) { peekBufLength += len; } -int SocketCore::gnutlsRecv(char* data, int len) { - int plen = shiftPeekData(data, len); +int32_t SocketCore::gnutlsRecv(char* data, int32_t len) { + int32_t plen = shiftPeekData(data, len); if(plen < len) { - int ret = gnutls_record_recv(sslSession, data+plen, len-plen); + int32_t ret = gnutls_record_recv(sslSession, data+plen, len-plen); if(ret < 0) { throw new DlRetryEx(EX_SOCKET_RECV, gnutls_strerror(ret)); } @@ -407,13 +407,13 @@ int SocketCore::gnutlsRecv(char* data, int len) { } } -int SocketCore::gnutlsPeek(char* data, int len) { +int32_t SocketCore::gnutlsPeek(char* data, int32_t len) { if(peekBufLength >= len) { memcpy(data, peekBuf, len); return len; } else { memcpy(data, peekBuf, peekBufLength); - int ret = gnutls_record_recv(sslSession, data+peekBufLength, len-peekBufLength); + int32_t ret = gnutls_record_recv(sslSession, data+peekBufLength, len-peekBufLength); if(ret < 0) { throw new DlRetryEx(EX_SOCKET_PEEK, gnutls_strerror(ret)); } @@ -448,8 +448,8 @@ void SocketCore::initiateSecureConnection() { #endif // HAVE_LIBSSL #ifdef HAVE_LIBGNUTLS if(!secure) { - const int cert_type_priority[3] = { GNUTLS_CRT_X509, - GNUTLS_CRT_OPENPGP, 0 + const int32_t cert_type_priority[3] = { GNUTLS_CRT_X509, + GNUTLS_CRT_OPENPGP, 0 }; // while we do not support X509 certificate, most web servers require // X509 stuff. @@ -460,7 +460,7 @@ void SocketCore::initiateSecureConnection() { // put the x509 credentials to the current session gnutls_credentials_set(sslSession, GNUTLS_CRD_CERTIFICATE, sslXcred); gnutls_transport_set_ptr(sslSession, (gnutls_transport_ptr_t)sockfd); - int ret = gnutls_handshake(sslSession); + int32_t ret = gnutls_handshake(sslSession); if(ret < 0) { throw new DlAbortEx(gnutls_strerror(ret)); } diff --git a/src/SocketCore.h b/src/SocketCore.h index a5711191..4ec5f36d 100644 --- a/src/SocketCore.h +++ b/src/SocketCore.h @@ -55,9 +55,9 @@ class SocketCore { friend bool operator<(const SocketCore& s1, const SocketCore& s2); private: // socket endpoint descriptor - int sockfd; + int32_t sockfd; // reference counter for this object. - int use; + int32_t use; bool secure; #ifdef HAVE_LIBSSL // for SSL @@ -68,22 +68,22 @@ private: gnutls_session_t sslSession; gnutls_certificate_credentials_t sslXcred; char* peekBuf; - int peekBufLength; - int peekBufMax; + int32_t peekBufLength; + int32_t peekBufMax; - int shiftPeekData(char* data, int len); - void addPeekData(char* data, int len); - int gnutlsRecv(char* data, int len); - int gnutlsPeek(char* data, int len); + int32_t shiftPeekData(char* data, int32_t len); + void addPeekData(char* data, int32_t len); + int32_t gnutlsRecv(char* data, int32_t len); + int32_t gnutlsPeek(char* data, int32_t len); #endif // HAVE_LIBGNUTLS void init(); - SocketCore(int sockfd); + SocketCore(int32_t sockfd); public: SocketCore(); ~SocketCore(); - int getSockfd() const { return sockfd; } + int32_t getSockfd() const { return sockfd; } bool isOpen() const { return sockfd != -1; } @@ -92,19 +92,19 @@ public: * @param port port to listen. If 0 is specified, os automaticaly * choose avaiable port. */ - void beginListen(int port = 0); + void beginListen(int32_t port = 0); /** * Stores host address and port of this socket to addrinfo. * @param addrinfo placeholder to store host address and port. */ - void getAddrInfo(pair& addrinfo) const; + void getAddrInfo(pair& addrinfo) const; /** * Stores peer's address and port to peerinfo. * @param peerinfo placeholder to store peer's address and port. */ - void getPeerInfo(pair& peerinfo) const; + void getPeerInfo(pair& peerinfo) const; /** * Accepts incoming connection on this socket. @@ -121,7 +121,7 @@ public: * @param host hostname or ip address to connect to * @param port service port number to connect to */ - void establishConnection(const string& host, int port); + void establishConnection(const string& host, int32_t port); void setNonBlockingMode() const; @@ -142,7 +142,7 @@ public: * @return true if the socket is available for writing, * otherwise returns false. */ - bool isWritable(int timeout) const; + bool isWritable(int32_t timeout) const; /** * Checks whether this socket is available for reading. @@ -151,7 +151,7 @@ public: * @return true if the socket is available for reading, * otherwise returns false. */ - bool isReadable(int timeout) const; + bool isReadable(int32_t timeout) const; /** * Writes characters into this socket. data is a pointer pointing the first @@ -161,7 +161,7 @@ public: * @param data data to write * @param len length of data */ - void writeData(const char* data, int len); + void writeData(const char* data, int32_t len); void writeData(const string& msg) { writeData(msg.c_str(), msg.size()); } /** @@ -176,7 +176,7 @@ public: * @param len the maximum size data can store. This method assigns * the number of bytes read to len. */ - void readData(char* data, int& len); + void readData(char* data, int32_t& len); /** * Reads up to len bytes from this socket, but bytes are not removed from @@ -187,7 +187,7 @@ public: * @param len the maximum size data can store. This method assigns * the number of bytes read to len. */ - void peekData(char* data, int& len); + void peekData(char* data, int32_t& len); /** * Makes this socket secure. diff --git a/src/TimeA2.cc b/src/TimeA2.cc index 421760cd..c62d3a55 100644 --- a/src/TimeA2.cc +++ b/src/TimeA2.cc @@ -43,7 +43,7 @@ Time::Time(const Time& time) { tv = time.tv; } -Time::Time(int sec) { +Time::Time(int32_t sec) { setTimeInSec(sec); } @@ -59,11 +59,11 @@ struct timeval Time::getCurrentTime() const { return now; } -bool Time::elapsed(int sec) const { +bool Time::elapsed(int32_t sec) const { return Util::difftvsec(getCurrentTime(), tv) >= sec; } -bool Time::elapsedInMillis(int millis) const { +bool Time::elapsedInMillis(int32_t millis) const { return Util::difftv(getCurrentTime(), tv)/1000 >= millis; } @@ -71,11 +71,11 @@ bool Time::isNewer(const Time& time) const { return Util::difftv(this->tv, time.tv) > 0; } -int Time::difference() const { +int32_t Time::difference() const { return Util::difftvsec(getCurrentTime(), tv); } -long long int Time::differenceInMillis() const { +int64_t Time::differenceInMillis() const { return Util::difftv(getCurrentTime(), tv)/1000; } @@ -84,7 +84,7 @@ int64_t Time::differenceInMillis(const struct timeval& now) const return Util::difftv(now, tv)/1000; } -void Time::setTimeInSec(int sec) { +void Time::setTimeInSec(int32_t sec) { tv.tv_sec = sec; tv.tv_usec = 0; } diff --git a/src/TimeA2.h b/src/TimeA2.h index 5ac66416..d5100405 100644 --- a/src/TimeA2.h +++ b/src/TimeA2.h @@ -48,7 +48,7 @@ public: // this object was created. Time(); Time(const Time& time); - Time(int sec); + Time(int32_t sec); Time& operator=(const Time& time) { if(this != &time) { @@ -62,32 +62,32 @@ public: // Makes this object's time value up to date. void reset(); - bool elapsed(int sec) const; + bool elapsed(int32_t sec) const; - bool elapsedInMillis(int millis) const; + bool elapsedInMillis(int32_t millis) const; - int difference() const; - long long int differenceInMillis() const; + int32_t difference() const; + int64_t differenceInMillis() const; int64_t differenceInMillis(const struct timeval& now) const; // Returns true if this object's time value is zero. bool isZero() const { return tv.tv_sec == 0 && tv.tv_usec == 0; } - long long int getTimeInMicros() const { - return (long long int)tv.tv_sec*1000*1000+tv.tv_usec; + int64_t getTimeInMicros() const { + return (int64_t)tv.tv_sec*1000*1000+tv.tv_usec; } - long long int getTimeInMillis() const { - return (long long int)tv.tv_sec*1000+tv.tv_usec/1000; + int64_t getTimeInMillis() const { + return (int64_t)tv.tv_sec*1000+tv.tv_usec/1000; } // Returns this object's time value in seconds. - int getTime() const { + int32_t getTime() const { return tv.tv_sec; } - void setTimeInSec(int sec); + void setTimeInSec(int32_t sec); bool isNewer(const Time& time) const; }; diff --git a/src/TimeSeedCriteria.h b/src/TimeSeedCriteria.h index 7dca9f37..84eb63d8 100644 --- a/src/TimeSeedCriteria.h +++ b/src/TimeSeedCriteria.h @@ -41,10 +41,10 @@ class TimeSeedCriteria : public SeedCriteria { private: // How much time the client does seeding in seconds. - int duration; + int32_t duration; Time watch; public: - TimeSeedCriteria(int duration):duration(duration) {} + TimeSeedCriteria(int32_t duration):duration(duration) {} virtual ~TimeSeedCriteria() {} virtual void reset() { @@ -55,11 +55,11 @@ public: return watch.elapsed(duration); } - void setDuration(int duration) { + void setDuration(int32_t duration) { this->duration = duration; } - int getDuration() const { + int32_t getDuration() const { return duration; } }; diff --git a/src/TimeoutException.h b/src/TimeoutException.h index 33744fc3..d3821d2d 100644 --- a/src/TimeoutException.h +++ b/src/TimeoutException.h @@ -37,13 +37,13 @@ class TimeoutException { public: - int err; + int32_t err; string msg; public: TimeoutException():err(0), msg("") {}; - TimeoutException(int err):err(err), msg("") {}; + TimeoutException(int32_t err):err(err), msg("") {}; TimeoutException(string msg):err(0), msg(msg) {}; - TimeoutException(int err, string msg):err(err), msg(msg) {} + TimeoutException(int32_t err, string msg):err(err), msg(msg) {} }; #endif // _D_TIMEOUT_EXCEPTION_H_ diff --git a/src/TorrentAutoSaveCommand.cc b/src/TorrentAutoSaveCommand.cc index b363e3ca..28f343dd 100644 --- a/src/TorrentAutoSaveCommand.cc +++ b/src/TorrentAutoSaveCommand.cc @@ -35,10 +35,10 @@ #include "TorrentAutoSaveCommand.h" #include "Util.h" -TorrentAutoSaveCommand::TorrentAutoSaveCommand(int cuid, +TorrentAutoSaveCommand::TorrentAutoSaveCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext, - int interval): + int32_t interval): BtContextAwareCommand(cuid, btContext), e(e), interval(interval) {} diff --git a/src/TorrentAutoSaveCommand.h b/src/TorrentAutoSaveCommand.h index d0f511a3..86d31641 100644 --- a/src/TorrentAutoSaveCommand.h +++ b/src/TorrentAutoSaveCommand.h @@ -43,13 +43,13 @@ class TorrentAutoSaveCommand : public BtContextAwareCommand { private: TorrentDownloadEngine* e; - int interval; + int32_t interval; Time checkPoint; public: - TorrentAutoSaveCommand(int cuid, + TorrentAutoSaveCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext, - int interval); + int32_t interval); ~TorrentAutoSaveCommand(); diff --git a/src/TorrentDownloadEngine.cc b/src/TorrentDownloadEngine.cc index 75491129..1a5f4017 100644 --- a/src/TorrentDownloadEngine.cc +++ b/src/TorrentDownloadEngine.cc @@ -78,8 +78,8 @@ void TorrentDownloadEngine::initStatistics() { totalLength = 0; } -int TorrentDownloadEngine::calculateSpeed(long long int length, int elapsed) { - int nowSpeed = (int)(length/elapsed); +int32_t TorrentDownloadEngine::calculateSpeed(int64_t length, int32_t elapsed) { + int32_t nowSpeed = length/elapsed; return nowSpeed; } diff --git a/src/TorrentDownloadEngine.h b/src/TorrentDownloadEngine.h index f87cd32e..ba0cfda1 100644 --- a/src/TorrentDownloadEngine.h +++ b/src/TorrentDownloadEngine.h @@ -53,19 +53,19 @@ private: protected: Time cp; Time lastCalcStat; - int downloadSpeed; - int uploadSpeed; - long long int selectedDownloadLengthDiff; - long long int selectedTotalLength; + int32_t downloadSpeed; + int32_t uploadSpeed; + int64_t selectedDownloadLengthDiff; + int64_t selectedTotalLength; // The time when startup Time startup; // The average speed(bytes per second) since startup - int avgSpeed; + int32_t avgSpeed; // The estimated remaining time to complete the download. - int eta; - long long int downloadLength; - long long int uploadLength; - long long int totalLength; + int32_t eta; + int64_t downloadLength; + int64_t uploadLength; + int64_t totalLength; BtContextHandle btContext; BtRuntimeHandle btRuntime; @@ -74,7 +74,7 @@ protected: BtAnnounceHandle btAnnounce; BtProgressInfoFileHandle btProgressInfoFile; - int calculateSpeed(long long int sessionLength, int elapsed); + int32_t calculateSpeed(int64_t sessionLength, int32_t elapsed); void calculateStat(); virtual void onEndOfRun(); diff --git a/src/TrackerUpdateCommand.cc b/src/TrackerUpdateCommand.cc index a0382ebe..b66cda17 100644 --- a/src/TrackerUpdateCommand.cc +++ b/src/TrackerUpdateCommand.cc @@ -42,7 +42,7 @@ #include "CUIDCounter.h" #include -TrackerUpdateCommand::TrackerUpdateCommand(int cuid, +TrackerUpdateCommand::TrackerUpdateCommand(int32_t cuid, TorrentDownloadEngine* e, const BtContextHandle& btContext): BtContextAwareCommand(cuid, btContext), e(e) @@ -62,7 +62,7 @@ string TrackerUpdateCommand::getTrackerResponse() { char data[2048]; try { while(1) { - int dataLength = e->_requestGroupMan->getRequestGroup(0)->getSegmentMan()->diskWriter->readData(data, sizeof(data), strm.tellp()); + int32_t dataLength = e->_requestGroupMan->getRequestGroup(0)->getSegmentMan()->diskWriter->readData(data, sizeof(data), strm.tellp()); strm.write(data, dataLength); if(dataLength != sizeof(data)) { break; diff --git a/src/TransferEncoding.h b/src/TransferEncoding.h index 080c9b36..04d3056d 100644 --- a/src/TransferEncoding.h +++ b/src/TransferEncoding.h @@ -41,7 +41,7 @@ class TransferEncoding { public: virtual ~TransferEncoding() {} virtual void init() = 0; - virtual void inflate(char* outbuf, int& outlen, const char* inbuf, int inlen) = 0; + virtual void inflate(char* outbuf, int32_t& outlen, const char* inbuf, int32_t inlen) = 0; virtual bool finished() = 0; virtual void end() = 0; }; diff --git a/src/UrlRequestInfo.h b/src/UrlRequestInfo.h index 40f0152d..210e9b51 100644 --- a/src/UrlRequestInfo.h +++ b/src/UrlRequestInfo.h @@ -52,7 +52,7 @@ typedef SharedHandle HeadResultHandle; class UrlRequestInfo : public RequestInfo { private: Strings urls; - int maxConnections; + int32_t maxConnections; string _filename; int64_t _totalLength; #ifdef ENABLE_MESSAGE_DIGEST @@ -64,11 +64,11 @@ private: RequestInfo* createNextRequestInfo() const; void adjustRequestSize(Requests& requests, Requests& reserved, - int maxConnections) const; + int32_t maxConnections) const; void printUrls(const Strings& urls) const; HeadResultHandle getHeadResult(); public: - UrlRequestInfo(const Strings& urls, int maxConnections, Option* op): + UrlRequestInfo(const Strings& urls, int32_t maxConnections, Option* op): RequestInfo(op), urls(urls), maxConnections(maxConnections), diff --git a/src/Util.cc b/src/Util.cc index b6cc6ad7..9607a9e0 100644 --- a/src/Util.cc +++ b/src/Util.cc @@ -57,7 +57,7 @@ string uint2str(T value, bool comma) { str = "0"; return str; } - int count = 0; + int32_t count = 0; while(value) { ++count; char digit = value%10+'0'; @@ -150,15 +150,15 @@ pair Util::split(const string& src, const string& delims) return hp; } -long long int Util::difftv(struct timeval tv1, struct timeval tv2) { +int64_t Util::difftv(struct timeval tv1, struct timeval tv2) { if(tv1.tv_sec < tv2.tv_sec || tv1.tv_sec == tv2.tv_sec && tv1.tv_usec < tv2.tv_usec) { return 0; } - return ((long long int)(tv1.tv_sec-tv2.tv_sec)*1000000+ + return ((int64_t)(tv1.tv_sec-tv2.tv_sec)*1000000+ tv1.tv_usec-tv2.tv_usec); } -int Util::difftvsec(struct timeval tv1, struct timeval tv2) { +int32_t Util::difftvsec(struct timeval tv1, struct timeval tv2) { if(tv1.tv_sec < tv2.tv_sec) { return 0; } @@ -235,9 +235,9 @@ string Util::replace(const string& target, const string& oldstr, const string& n return result; } -string Util::urlencode(const unsigned char* target, int len) { +string Util::urlencode(const unsigned char* target, int32_t len) { string dest; - for(int i = 0; i < len; i++) { + for(int32_t i = 0; i < len; i++) { if(!('0' <= target[i] && target[i] <= '9' || 'A' <= target[i] && target[i] <= 'Z' || 'a' <= target[i] && target[i] <= 'z' || @@ -258,9 +258,9 @@ string Util::urlencode(const unsigned char* target, int len) { return dest; } -string Util::torrentUrlencode(const unsigned char* target, int len) { +string Util::torrentUrlencode(const unsigned char* target, int32_t len) { string dest; - for(int i = 0; i < len; i++) { + for(int32_t i = 0; i < len; i++) { if('0' <= target[i] && target[i] <= '9' || 'A' <= target[i] && target[i] <= 'Z' || 'a' <= target[i] && target[i] <= 'z') { @@ -298,9 +298,9 @@ string Util::urldecode(const string& target) { return result; } -string Util::toHex(const unsigned char* src, int len) { +string Util::toHex(const unsigned char* src, int32_t len) { char* temp = new char[len*2+1]; - for(int i = 0; i < len; i++) { + for(int32_t i = 0; i < len; i++) { sprintf(temp+i*2, "%02x", src[i]); } temp[len*2] = '\0'; @@ -319,11 +319,11 @@ void Util::fileCopy(const string& dest, const string& src) { rangedFileCopy(dest, src, 0, file.size()); } -void Util::rangedFileCopy(const string& dest, const string& src, long long int srcOffset, long long int length) { - int bufSize = 4096; +void Util::rangedFileCopy(const string& dest, const string& src, int64_t srcOffset, int64_t length) { + int32_t bufSize = 4096; char buf[bufSize]; - int destFd = -1; - int srcFd = -1; + int32_t destFd = -1; + int32_t srcFd = -1; try { if((destFd = open(dest.c_str(), O_CREAT|O_WRONLY|O_TRUNC, OPEN_MODE)) == -1) { throw new DlAbortEx(EX_FILE_OPEN, dest.c_str(), strerror(errno)); @@ -334,10 +334,10 @@ void Util::rangedFileCopy(const string& dest, const string& src, long long int s if(lseek(srcFd, srcOffset, SEEK_SET) != srcOffset) { throw new DlAbortEx(EX_FILE_SEEK, src.c_str(), strerror(errno)); } - int x = length/bufSize; - int r = length%bufSize; - for(int i = 0; i < x; i++) { - int readLength; + int32_t x = length/bufSize; + int32_t r = length%bufSize; + for(int32_t i = 0; i < x; i++) { + int32_t readLength; if((readLength = read(srcFd, buf, bufSize)) == -1 || readLength != bufSize) { throw new DlAbortEx(EX_FILE_READ, src.c_str(), strerror(errno)); } @@ -346,7 +346,7 @@ void Util::rangedFileCopy(const string& dest, const string& src, long long int s } } if(r > 0) { - int readLength; + int32_t readLength; if((readLength = read(srcFd, buf, r)) == -1 || readLength != r) { throw new DlAbortEx(EX_FILE_READ, src.c_str(), strerror(errno)); } @@ -369,7 +369,7 @@ void Util::rangedFileCopy(const string& dest, const string& src, long long int s } } -bool Util::isPowerOf(int num, int base) { +bool Util::isPowerOf(int32_t num, int32_t base) { if(base <= 0) { return false; } if(base == 1) { return true; } @@ -382,14 +382,14 @@ bool Util::isPowerOf(int num, int base) { return false; } -string Util::secfmt(int sec) { +string Util::secfmt(int32_t sec) { string str; if(sec >= 3600) { str = itos(sec/3600)+"h"; sec %= 3600; } if(sec >= 60) { - int min = sec/60; + int32_t min = sec/60; if(min < 10) { str += "0"; } @@ -403,7 +403,7 @@ string Util::secfmt(int sec) { return str; } -int Util::expandBuffer(char** pbuf, int curLength, int newLength) { +int32_t Util::expandBuffer(char** pbuf, int32_t curLength, int32_t newLength) { char* newbuf = new char[newLength]; memcpy(newbuf, *pbuf, curLength); delete [] *pbuf; @@ -411,11 +411,11 @@ int Util::expandBuffer(char** pbuf, int curLength, int newLength) { return newLength; } -int getNum(const char* buf, int offset, int length) { +int32_t getNum(const char* buf, int32_t offset, int32_t length) { char* temp = new char[length+1]; memcpy(temp, buf+offset, length); temp[length] = '\0'; - int x = strtol(temp, NULL, 10); + int32_t x = strtol(temp, NULL, 10); delete [] temp; return x; } @@ -431,18 +431,18 @@ void unfoldSubRange(const string& src, Integers& range) { range.push_back(atoi(src.c_str())); } else { if(src.at(p) == ',') { - int num = getNum(src.c_str(), 0, p); + int32_t num = getNum(src.c_str(), 0, p); range.push_back(num); unfoldSubRange(src.substr(p+1), range); } else if(src.at(p) == '-') { - int rightNumBegin = p+1; + int32_t rightNumBegin = p+1; string::size_type nextDelim = src.find_first_of(",", rightNumBegin); if(nextDelim == string::npos) { nextDelim = src.size(); } - int left = getNum(src.c_str(), 0, p); - int right = getNum(src.c_str(), rightNumBegin, nextDelim-rightNumBegin); - for(int i = left; i <= right; i++) { + int32_t left = getNum(src.c_str(), 0, p); + int32_t right = getNum(src.c_str(), rightNumBegin, nextDelim-rightNumBegin); + for(int32_t i = left; i <= right; i++) { range.push_back(i); } if(src.size() > nextDelim) { @@ -483,7 +483,7 @@ string Util::getContentDispositionFilename(const string& header) { } #ifdef ENABLE_MESSAGE_DIGEST -void Util::sha1Sum(unsigned char* digest, const void* data, int dataLength) { +void Util::sha1Sum(unsigned char* digest, const void* data, int32_t dataLength) { MessageDigestContext ctx(DIGEST_ALGO_SHA1); ctx.digestInit(); ctx.digestUpdate(data, dataLength); @@ -504,15 +504,15 @@ void Util::fileChecksum(const string& filename, unsigned char* digest, MessageDigestContext ctx(algo); ctx.digestInit(); - int BUFLEN = 4096; + int32_t BUFLEN = 4096; char buf[BUFLEN]; - int fd; + int32_t fd; if((fd = open(filename.c_str(), O_RDWR, OPEN_MODE)) < 0) { throw new DlAbortEx(EX_FILE_OPEN, filename.c_str(), strerror(errno)); } while(1) { - int size = read(fd, buf, BUFLEN); + int32_t size = read(fd, buf, BUFLEN); if(size == -1) { if(errno == EINTR) { continue; @@ -533,7 +533,7 @@ void Util::fileChecksum(const string& filename, unsigned char* digest, #ifdef ENABLE_BITTORRENT Integers Util::computeFastSet(string ipaddr, const unsigned char* infoHash, - int pieces, int fastSetSize) { + int32_t pieces, int32_t fastSetSize) { Integers fastSet; struct in_addr saddr; if(inet_aton(ipaddr.c_str(), &saddr) == 0) { @@ -550,13 +550,13 @@ Integers Util::computeFastSet(string ipaddr, const unsigned char* infoHash, memcpy(tx+4, infoHash, 20); unsigned char x[20]; sha1Sum(x, tx, 24); - while((int)fastSet.size() < fastSetSize) { - for(int i = 0; i < 5 && (int)fastSet.size() < fastSetSize; i++) { - int j = i*4; - unsigned int ny; + while((int32_t)fastSet.size() < fastSetSize) { + for(int32_t i = 0; i < 5 && (int32_t)fastSet.size() < fastSetSize; i++) { + int32_t j = i*4; + uint32_t ny; memcpy(&ny, x+j, 4); - unsigned int y = ntohl(ny); - int index = y%pieces; + uint32_t y = ntohl(ny); + int32_t index = y%pieces; if(find(fastSet.begin(), fastSet.end(), index) == fastSet.end()) { fastSet.push_back(index); } @@ -569,18 +569,7 @@ Integers Util::computeFastSet(string ipaddr, const unsigned char* infoHash, } #endif // ENABLE_BITTORRENT -/* -int Util::countBit(unsigned int n) { - int count = 0; - while(n > 0) { - count++; - n &= (n-1); - } - return count; -} -*/ - -static int nbits[] = { +static int32_t nbits[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, @@ -607,10 +596,10 @@ int32_t Util::countBit(uint32_t n) { nbits[(n >> 24)&0xffu]; } -string Util::randomAlpha(int length) { +string Util::randomAlpha(int32_t length) { string str; - for(int i = 0; i < length; i++) { - int index = (int)(((double)52)*random()/(RAND_MAX+1.0)); + for(int32_t i = 0; i < length; i++) { + int32_t index = (int32_t)(((double)52)*random()/(RAND_MAX+1.0)); char ch; if(index < 26) { ch = (char)('A'+index); @@ -657,7 +646,7 @@ bool Util::isNumbersAndDotsNotation(const string& name) { } } -void Util::setGlobalSignalHandler(int signal, void (*handler)(int), int flags) { +void Util::setGlobalSignalHandler(int32_t signal, void (*handler)(int32_t), int32_t flags) { struct sigaction sigact; sigact.sa_handler = handler; sigact.sa_flags = flags; @@ -690,7 +679,7 @@ int64_t Util::getRealSize(const string& sizeWithUnit) { string::size_type p = sizeWithUnit.find_first_of("KM"); string size; - int mult = 1; + int32_t mult = 1; if(p == string::npos) { size = sizeWithUnit; } else { @@ -735,7 +724,7 @@ void Util::toStream(ostream& os, const FileEntries& fileEntries) os << _("Files:") << "\n"; os << "idx|path/length" << "\n"; os << "===+===========================================================================" << "\n"; - int count = 1; + int32_t count = 1; for(FileEntries::const_iterator itr = fileEntries.begin(); itr != fileEntries.end(); count++, itr++) { os << setw(3) << count << "|" << (*itr)->getPath() << "\n"; diff --git a/src/Util.h b/src/Util.h index d165a589..a5e1ac28 100644 --- a/src/Util.h +++ b/src/Util.h @@ -65,8 +65,8 @@ public: * assuming tv1 is newer than tv2. * If tv1 is older than tv2, then this method returns 0. */ - static long long int difftv(struct timeval tv1, struct timeval tv2); - static int difftvsec(struct timeval tv1, struct timeval tv2); + static int64_t difftv(struct timeval tv1, struct timeval tv2); + static int32_t difftvsec(struct timeval tv1, struct timeval tv2); /** * Take a string src which is a deliminated list and add its elements * into result. result is not cleared before conversion begins. @@ -81,7 +81,7 @@ public: static string replace(const string& target, const string& oldstr, const string& newstr); - static string urlencode(const unsigned char* target, int len); + static string urlencode(const unsigned char* target, int32_t len); static string urlencode(const string& target) { @@ -90,21 +90,21 @@ public: static string urldecode(const string& target); - static string torrentUrlencode(const unsigned char* target, int len); + static string torrentUrlencode(const unsigned char* target, int32_t len); - static string toHex(const unsigned char* src, int len); + static string toHex(const unsigned char* src, int32_t len); static FILE* openFile(const string& filename, const string& mode); static void fileCopy(const string& destFile, const string& src); - static void rangedFileCopy(const string& destFile, const string& src, long long int srcOffset, long long int length); + static void rangedFileCopy(const string& destFile, const string& src, int64_t srcOffset, int64_t length); - static bool isPowerOf(int num, int base); + static bool isPowerOf(int32_t num, int32_t base); - static string secfmt(int sec); + static string secfmt(int32_t sec); - static int expandBuffer(char** pbuf, int curLength, int newLength); + static int32_t expandBuffer(char** pbuf, int32_t curLength, int32_t newLength); static void unfoldRange(const string& src, Integers& range); @@ -113,7 +113,7 @@ public: // digest must be at least 20 bytes long. #ifdef ENABLE_MESSAGE_DIGEST - static void sha1Sum(unsigned char* digest, const void* data, int dataLength); + static void sha1Sum(unsigned char* digest, const void* data, int32_t dataLength); static string simpleMessageDigest(const string& data); #endif // ENABLE_MESSAGE_DIGEST @@ -126,12 +126,12 @@ public: #ifdef ENABLE_BITTORRENT static Integers computeFastSet(string ipaddr, const unsigned char* infoHash, - int pieces, int fastSetSize); + int32_t pieces, int32_t fastSetSize); #endif // ENABLE_BITTORRENT static int32_t countBit(uint32_t n); - static string randomAlpha(int length); + static string randomAlpha(int32_t length); static string toUpper(const string& src); @@ -139,7 +139,7 @@ public: static bool isNumbersAndDotsNotation(const string& name); - static void setGlobalSignalHandler(int signal, void (*handler)(int), int flags); + static void setGlobalSignalHandler(int32_t signal, void (*handler)(int32_t), int32_t flags); static void indexRange(int32_t& startIndex, int32_t& endIndex, int64_t offset, diff --git a/src/main.cc b/src/main.cc index 3f6a59b2..cd5a5221 100644 --- a/src/main.cc +++ b/src/main.cc @@ -330,7 +330,7 @@ int main(int argc, char* argv[]) { textdomain (PACKAGE); #endif // ENABLE_NLS stringstream cmdstream; - int c; + int32_t c; Option* op = new Option(); op->put(PREF_STDOUT_LOG, V_FALSE); op->put(PREF_DIR, "."); @@ -385,8 +385,8 @@ int main(int argc, char* argv[]) { op->put(PREF_MAX_CONCURRENT_DOWNLOADS, "5"); op->put(PREF_DIRECT_DOWNLOAD_TIMEOUT, "15"); while(1) { - int optIndex = 0; - int lopt; + int32_t optIndex = 0; + int32_t lopt; static struct option longOpts[] = { { "daemon", no_argument, NULL, 'D' }, { "dir", required_argument, NULL, 'd' }, @@ -699,7 +699,7 @@ int main(int argc, char* argv[]) { } else { LogFactory::setLogFile("/dev/null"); } - int exitStatus = EXIT_SUCCESS; + int32_t exitStatus = EXIT_SUCCESS; try { Logger* logger = LogFactory::getInstance(); logger->info("%s %s", PACKAGE, PACKAGE_VERSION); diff --git a/src/messageDigest.h b/src/messageDigest.h index d7743586..345a5483 100644 --- a/src/messageDigest.h +++ b/src/messageDigest.h @@ -57,7 +57,7 @@ public: # define DIGEST_ALGO_SHA1 EVP_sha1() #endif // HAVE_LIBSSL #ifdef HAVE_LIBGCRYPT - typedef int DigestAlgo; + typedef int32_t DigestAlgo; # define DIGEST_ALGO_MD5 GCRY_MD_MD5 # define DIGEST_ALGO_SHA1 GCRY_MD_SHA1 #endif // HAVE_LIBGCRYPT @@ -83,16 +83,16 @@ public: #if defined(HAVE_OLD_LIBSSL) void digestInit() {EVP_DigestInit(&ctx, algo);} void digestReset() {EVP_DigestInit(&ctx, algo);} - void digestUpdate(const void* data, int length) {EVP_DigestUpdate(&ctx, data, length);} + void digestUpdate(const void* data, int32_t length) {EVP_DigestUpdate(&ctx, data, length);} void digestFinal(unsigned char* md) { - int len; - EVP_DigestFinal(&ctx, md, (unsigned int*)&len); + int32_t len; + EVP_DigestFinal(&ctx, md, (uint32_t*)&len); } void digestFree() {/*empty*/} - int digestLength() const { + int32_t digestLength() const { return digestLength(algo); } - static int digestLength(DigestAlgo algo) { + static int32_t digestLength(DigestAlgo algo) { return EVP_MD_size(algo); } @@ -104,20 +104,20 @@ public: void digestReset() { EVP_DigestInit_ex(&ctx, algo, 0); } - void digestUpdate(const void* data, int length) { + void digestUpdate(const void* data, int32_t length) { EVP_DigestUpdate(&ctx, data, length); } void digestFinal(unsigned char* md) { - int len; - EVP_DigestFinal_ex(&ctx, md, (unsigned int*)&len); + int32_t len; + EVP_DigestFinal_ex(&ctx, md, (uint32_t*)&len); } void digestFree() { EVP_MD_CTX_cleanup(&ctx); } - int digestLength() const { + int32_t digestLength() const { return digestLength(algo); } - static int digestLength(DigestAlgo algo) { + static int32_t digestLength(DigestAlgo algo) { return EVP_MD_size(algo); } @@ -128,7 +128,7 @@ public: void digestReset() { gcry_md_reset(ctx); } - void digestUpdate(const void* data, int length) { + void digestUpdate(const void* data, int32_t length) { gcry_md_write(ctx, data, length); } void digestFinal(unsigned char* md) { @@ -138,7 +138,7 @@ public: void digestFree() { gcry_md_close(ctx); } - int digestLength() const { + int32_t digestLength() const { return digestLength(algo); } static int digestLength(DigestAlgo algo) { diff --git a/test/FixedNumberRandomizer.h b/test/FixedNumberRandomizer.h index bd4ed7df..5d96ae00 100644 --- a/test/FixedNumberRandomizer.h +++ b/test/FixedNumberRandomizer.h @@ -5,25 +5,25 @@ class FixedNumberRandomizer : public Randomizer { private: - int fixedNumber; + int32_t fixedNumber; public: FixedNumberRandomizer():fixedNumber(0) {} virtual ~FixedNumberRandomizer() {} - virtual int getRandomNumber() { + virtual long int getRandomNumber() { return fixedNumber; } - virtual int getMaxRandomNumber() { + virtual long int getMaxRandomNumber() { return RAND_MAX; } - void setFixedNumber(int num) { + void setFixedNumber(int32_t num) { this->fixedNumber = num; } - int getFixedNumber() const { + int32_t getFixedNumber() const { return fixedNumber; } }; diff --git a/test/MetalinkEntryTest.cc b/test/MetalinkEntryTest.cc index 2f924907..0a3f9253 100644 --- a/test/MetalinkEntryTest.cc +++ b/test/MetalinkEntryTest.cc @@ -67,13 +67,13 @@ void MetalinkEntryTest::testDropUnsupportedResource() { CPPUNIT_ASSERT_EQUAL(4, (int)entry->resources.size()); - CPPUNIT_ASSERT_EQUAL((int)MetalinkResource::TYPE_FTP, + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, entry->resources.at(0)->type); - CPPUNIT_ASSERT_EQUAL((int)MetalinkResource::TYPE_HTTP, + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, entry->resources.at(1)->type); - CPPUNIT_ASSERT_EQUAL((int)MetalinkResource::TYPE_BITTORRENT, + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_BITTORRENT, entry->resources.at(2)->type); - CPPUNIT_ASSERT_EQUAL((int)MetalinkResource::TYPE_HTTPS, + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTPS, entry->resources.at(3)->type); } diff --git a/test/Xml2MetalinkProcessorTest.cc b/test/Xml2MetalinkProcessorTest.cc index 3e1d079a..17f6aa9e 100644 --- a/test/Xml2MetalinkProcessorTest.cc +++ b/test/Xml2MetalinkProcessorTest.cc @@ -43,14 +43,14 @@ void Xml2MetalinkProcessorTest::testParseFile() { MetalinkResources::iterator resourceItr1 = entry1->resources.begin(); MetalinkResourceHandle resource1 = *resourceItr1; - CPPUNIT_ASSERT_EQUAL((int)MetalinkResource::TYPE_FTP, resource1->type); + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_FTP, resource1->type); CPPUNIT_ASSERT_EQUAL(string("jp"), resource1->location); CPPUNIT_ASSERT_EQUAL(100, resource1->preference); CPPUNIT_ASSERT_EQUAL(string("ftp://ftphost/aria2-0.5.2.tar.bz2"), resource1->url); resourceItr1++; MetalinkResourceHandle resource2 = *resourceItr1; - CPPUNIT_ASSERT_EQUAL((int)MetalinkResource::TYPE_HTTP, resource2->type); + CPPUNIT_ASSERT_EQUAL(MetalinkResource::TYPE_HTTP, resource2->type); CPPUNIT_ASSERT_EQUAL(string("us"), resource2->location); CPPUNIT_ASSERT_EQUAL(100, resource2->preference); CPPUNIT_ASSERT_EQUAL(string("http://httphost/aria2-0.5.2.tar.bz2"),