github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

2008-03-09 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com> 

type cleanup for allmost all remaining files.
pull/1/head
Tatsuhiro Tsujikawa 2008-03-09 12:24:01 +00:00
parent ca3f6e57f3
commit 032c7c2808
278 changed files with 1489 additions and 1517 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -1,3 +1,7 @@
2008-03-09 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>
type cleanup for allmost all remaining files.
2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com> 2008-03-08 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>
Type clarification Type clarification

8
src/AbstractCommand.cc
View File

@ -119,13 +119,13 @@ bool AbstractCommand::execute() {
checkPoint.reset(); checkPoint.reset();
if(!_requestGroup->getPieceStorage().isNull()) { if(!_requestGroup->getPieceStorage().isNull()) {
_segments = _requestGroup->getSegmentMan()->getInFlightSegment(cuid); _segments = _requestGroup->getSegmentMan()->getInFlightSegment(cuid);
int32_t maxSegments; size_t maxSegments;
if(req->isKeepAlive() && e->option->get(PREF_ENABLE_HTTP_PIPELINING) == V_TRUE) { if(req->isKeepAlive() && e->option->get(PREF_ENABLE_HTTP_PIPELINING) == V_TRUE) {
maxSegments = e->option->getAsInt(PREF_MAX_HTTP_PIPELINING); maxSegments = e->option->getAsInt(PREF_MAX_HTTP_PIPELINING);
} else { } else {
maxSegments = 1; maxSegments = 1;
} }
while((int32_t)_segments.size() < maxSegments) { while(_segments.size() < maxSegments) {
SegmentHandle segment = _requestGroup->getSegmentMan()->getSegment(cuid); SegmentHandle segment = _requestGroup->getSegmentMan()->getSegment(cuid);
if(segment.isNull()) { if(segment.isNull()) {
break; break;
@ -156,7 +156,7 @@ bool AbstractCommand::execute() {
logger->info(MSG_RESTARTING_DOWNLOAD, err, cuid, req->getUrl().c_str()); logger->info(MSG_RESTARTING_DOWNLOAD, err, cuid, req->getUrl().c_str());
req->addTryCount(); req->addTryCount();
bool isAbort = e->option->getAsInt(PREF_MAX_TRIES) != 0 && bool isAbort = e->option->getAsInt(PREF_MAX_TRIES) != 0 &&
req->getTryCount() >= e->option->getAsInt(PREF_MAX_TRIES); req->getTryCount() >= (unsigned int)e->option->getAsInt(PREF_MAX_TRIES);
if(isAbort) { if(isAbort) {
onAbort(err); onAbort(err);
} }
@ -184,7 +184,7 @@ void AbstractCommand::tryReserved() {
e->addCommand(commands); e->addCommand(commands);
} }
bool AbstractCommand::prepareForRetry(int32_t wait) { bool AbstractCommand::prepareForRetry(time_t wait) {
if(!_requestGroup->getPieceStorage().isNull()) { if(!_requestGroup->getPieceStorage().isNull()) {
_requestGroup->getSegmentMan()->cancelSegment(cuid); _requestGroup->getSegmentMan()->cancelSegment(cuid);
} }

6
src/AbstractCommand.h
View File

@ -53,7 +53,7 @@ class SocketCore;
class AbstractCommand : public Command, public RequestGroupAware { class AbstractCommand : public Command, public RequestGroupAware {
private: private:
Time checkPoint; Time checkPoint;
int32_t timeout; time_t timeout;
protected: protected:
SharedHandle<Request> req; SharedHandle<Request> req;
DownloadEngine* e; DownloadEngine* e;
@ -61,7 +61,7 @@ protected:
std::deque<SharedHandle<Segment> > _segments; std::deque<SharedHandle<Segment> > _segments;
void tryReserved(); void tryReserved();
virtual bool prepareForRetry(int32_t wait); virtual bool prepareForRetry(time_t wait);
virtual void onAbort(Exception* ex); virtual void onAbort(Exception* ex);
virtual bool executeInternal() = 0; virtual bool executeInternal() = 0;
@ -76,7 +76,7 @@ protected:
void disableNameResolverCheck(const SharedHandle<NameResolver>& resolver); void disableNameResolverCheck(const SharedHandle<NameResolver>& resolver);
virtual bool nameResolveFinished() const; virtual bool nameResolveFinished() const;
#endif // ENABLE_ASYNC_DNS #endif // ENABLE_ASYNC_DNS
void setTimeout(int32_t timeout) { this->timeout = timeout; } void setTimeout(time_t timeout) { this->timeout = timeout; }
void prepareForNextAction(Command* nextCommand = 0); void prepareForNextAction(Command* nextCommand = 0);

34
src/AbstractDiskWriter.cc
View File

@ -54,7 +54,7 @@ AbstractDiskWriter::~AbstractDiskWriter()
closeFile(); closeFile();
} }
void AbstractDiskWriter::openFile(const std::string& filename, int64_t totalLength) void AbstractDiskWriter::openFile(const std::string& filename, uint64_t totalLength)
{ {
File f(filename); File f(filename);
if(f.exists()) { if(f.exists()) {
@ -73,7 +73,7 @@ void AbstractDiskWriter::closeFile()
} }
void AbstractDiskWriter::openExistingFile(const std::string& filename, void AbstractDiskWriter::openExistingFile(const std::string& filename,
int64_t totalLength) uint64_t totalLength)
{ {
this->filename = filename; this->filename = filename;
File f(filename); File f(filename);
@ -86,7 +86,7 @@ void AbstractDiskWriter::openExistingFile(const std::string& filename,
} }
} }
void AbstractDiskWriter::createFile(const std::string& filename, int32_t addFlags) void AbstractDiskWriter::createFile(const std::string& filename, int addFlags)
{ {
this->filename = filename; this->filename = filename;
assert(filename.size()); assert(filename.size());
@ -96,11 +96,11 @@ void AbstractDiskWriter::createFile(const std::string& filename, int32_t addFlag
} }
} }
int32_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, int32_t len) ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, size_t len)
{ {
int32_t writtenLength = 0; ssize_t writtenLength = 0;
while(writtenLength < len) { while((size_t)writtenLength < len) {
int32_t ret = 0; ssize_t ret = 0;
while((ret = write(fd, data+writtenLength, len-writtenLength)) == -1 && errno == EINTR); while((ret = write(fd, data+writtenLength, len-writtenLength)) == -1 && errno == EINTR);
if(ret == -1) { if(ret == -1) {
return -1; return -1;
@ -110,21 +110,21 @@ int32_t AbstractDiskWriter::writeDataInternal(const unsigned char* data, int32_t
return writtenLength; return writtenLength;
} }
int32_t AbstractDiskWriter::readDataInternal(unsigned char* data, int32_t len) ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len)
{ {
int32_t ret = 0; ssize_t ret = 0;
while((ret = read(fd, data, len)) == -1 && errno == EINTR); while((ret = read(fd, data, len)) == -1 && errno == EINTR);
return ret; return ret;
} }
void AbstractDiskWriter::seek(int64_t offset) void AbstractDiskWriter::seek(off_t offset)
{ {
if(offset != lseek(fd, offset, SEEK_SET)) { if(offset != lseek(fd, offset, SEEK_SET)) {
throw new DlAbortEx(EX_FILE_SEEK, filename.c_str(), strerror(errno)); throw new DlAbortEx(EX_FILE_SEEK, filename.c_str(), strerror(errno));
} }
} }
void AbstractDiskWriter::writeData(const unsigned char* data, int32_t len, int64_t offset) void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, off_t offset)
{ {
seek(offset); seek(offset);
if(writeDataInternal(data, len) < 0) { if(writeDataInternal(data, len) < 0) {
@ -132,9 +132,9 @@ void AbstractDiskWriter::writeData(const unsigned char* data, int32_t len, int64
} }
} }
int32_t AbstractDiskWriter::readData(unsigned char* data, int32_t len, int64_t offset) ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offset)
{ {
int32_t ret; ssize_t ret;
seek(offset); seek(offset);
if((ret = readDataInternal(data, len)) < 0) { if((ret = readDataInternal(data, len)) < 0) {
throw new DlAbortEx(EX_FILE_READ, filename.c_str(), strerror(errno)); throw new DlAbortEx(EX_FILE_READ, filename.c_str(), strerror(errno));
@ -142,7 +142,7 @@ int32_t AbstractDiskWriter::readData(unsigned char* data, int32_t len, int64_t o
return ret; return ret;
} }
void AbstractDiskWriter::truncate(int64_t length) void AbstractDiskWriter::truncate(uint64_t length)
{ {
if(fd == -1) { if(fd == -1) {
throw new DlAbortEx("File not opened."); throw new DlAbortEx("File not opened.");
@ -151,7 +151,7 @@ void AbstractDiskWriter::truncate(int64_t length)
} }
// TODO the file descriptor fd must be opened before calling this function. // TODO the file descriptor fd must be opened before calling this function.
int64_t AbstractDiskWriter::size() const uint64_t AbstractDiskWriter::size() const
{ {
if(fd == -1) { if(fd == -1) {
throw new DlAbortEx("File not opened."); throw new DlAbortEx("File not opened.");
@ -167,7 +167,7 @@ void AbstractDiskWriter::enableDirectIO()
{ {
#ifdef ENABLE_DIRECT_IO #ifdef ENABLE_DIRECT_IO
if(_directIOAllowed) { if(_directIOAllowed) {
int32_t flg; int flg;
while((flg = fcntl(fd, F_GETFL)) == -1 && errno == EINTR); while((flg = fcntl(fd, F_GETFL)) == -1 && errno == EINTR);
while(fcntl(fd, F_SETFL, flg|O_DIRECT) == -1 && errno == EINTR); while(fcntl(fd, F_SETFL, flg|O_DIRECT) == -1 && errno == EINTR);
} }
@ -177,7 +177,7 @@ void AbstractDiskWriter::enableDirectIO()
void AbstractDiskWriter::disableDirectIO() void AbstractDiskWriter::disableDirectIO()
{ {
#ifdef ENABLE_DIRECT_IO #ifdef ENABLE_DIRECT_IO
int32_t flg; int flg;
while((flg = fcntl(fd, F_GETFL)) == -1 && errno == EINTR); while((flg = fcntl(fd, F_GETFL)) == -1 && errno == EINTR);
while(fcntl(fd, F_SETFL, flg&(~O_DIRECT)) == -1 && errno == EINTR); while(fcntl(fd, F_SETFL, flg&(~O_DIRECT)) == -1 && errno == EINTR);
#endif // ENABLE_DIRECT_IO #endif // ENABLE_DIRECT_IO

22
src/AbstractDiskWriter.h
View File

@ -45,34 +45,34 @@ class Logger;
class AbstractDiskWriter : public DiskWriter { class AbstractDiskWriter : public DiskWriter {
protected: protected:
std::string filename; std::string filename;
int32_t fd; int fd;
const Logger* logger; const Logger* logger;
void createFile(const std::string& filename, int32_t addFlags = 0); void createFile(const std::string& filename, int addFlags = 0);
private: private:
int32_t writeDataInternal(const unsigned char* data, int32_t len); ssize_t writeDataInternal(const unsigned char* data, size_t len);
int32_t readDataInternal(unsigned char* data, int32_t len); ssize_t readDataInternal(unsigned char* data, size_t len);
void seek(int64_t offset); void seek(off_t offset);
public: public:
AbstractDiskWriter(); AbstractDiskWriter();
virtual ~AbstractDiskWriter(); virtual ~AbstractDiskWriter();
virtual void openFile(const std::string& filename, int64_t totalLength = 0); virtual void openFile(const std::string& filename, uint64_t totalLength = 0);
virtual void closeFile(); virtual void closeFile();
virtual void openExistingFile(const std::string& filename, int64_t totalLength = 0); virtual void openExistingFile(const std::string& filename, uint64_t totalLength = 0);
virtual void writeData(const unsigned char* data, int32_t len, int64_t offset); virtual void writeData(const unsigned char* data, size_t len, off_t offset);
virtual int32_t readData(unsigned char* data, int32_t len, int64_t offset); virtual ssize_t readData(unsigned char* data, size_t len, off_t offset);
virtual void truncate(int64_t length); virtual void truncate(uint64_t length);
virtual int64_t size() const; virtual uint64_t size() const;
virtual void enableDirectIO(); virtual void enableDirectIO();

12
src/AbstractSingleDiskAdaptor.cc
View File

@ -65,12 +65,12 @@ void AbstractSingleDiskAdaptor::openExistingFile()
diskWriter->openExistingFile(getFilePath(), totalLength); diskWriter->openExistingFile(getFilePath(), totalLength);
} }
void AbstractSingleDiskAdaptor::writeData(const unsigned char* data, int32_t len, int64_t offset) void AbstractSingleDiskAdaptor::writeData(const unsigned char* data, size_t len, off_t offset)
{ {
diskWriter->writeData(data, len, offset); diskWriter->writeData(data, len, offset);
} }
int32_t AbstractSingleDiskAdaptor::readData(unsigned char* data, int32_t len, int64_t offset) ssize_t AbstractSingleDiskAdaptor::readData(unsigned char* data, size_t len, off_t offset)
{ {
return diskWriter->readData(data, len, offset); return diskWriter->readData(data, len, offset);
} }
@ -80,12 +80,12 @@ bool AbstractSingleDiskAdaptor::fileExists()
return File(getFilePath()).exists(); return File(getFilePath()).exists();
} }
int64_t AbstractSingleDiskAdaptor::size() const uint64_t AbstractSingleDiskAdaptor::size() const
{ {
return diskWriter->size(); return diskWriter->size();
} }
void AbstractSingleDiskAdaptor::truncate(int64_t length) void AbstractSingleDiskAdaptor::truncate(uint64_t length)
{ {
diskWriter->truncate(length); diskWriter->truncate(length);
} }
@ -123,12 +123,12 @@ DiskWriterHandle AbstractSingleDiskAdaptor::getDiskWriter() const
return diskWriter; return diskWriter;
} }
void AbstractSingleDiskAdaptor::setTotalLength(const int64_t& totalLength) void AbstractSingleDiskAdaptor::setTotalLength(const uint64_t& totalLength)
{ {
this->totalLength = totalLength; this->totalLength = totalLength;
} }
int64_t AbstractSingleDiskAdaptor::getTotalLength() const uint64_t AbstractSingleDiskAdaptor::getTotalLength() const
{ {
return totalLength; return totalLength;
} }

16
src/AbstractSingleDiskAdaptor.h
View File

@ -45,7 +45,7 @@ class FileAllocationIterator;
class AbstractSingleDiskAdaptor : public DiskAdaptor { class AbstractSingleDiskAdaptor : public DiskAdaptor {
protected: protected:
SharedHandle<DiskWriter> diskWriter; SharedHandle<DiskWriter> diskWriter;
int64_t totalLength; uint64_t totalLength;
public: public:
AbstractSingleDiskAdaptor(); AbstractSingleDiskAdaptor();
@ -59,16 +59,16 @@ public:
virtual void openExistingFile(); virtual void openExistingFile();
virtual void writeData(const unsigned char* data, int32_t len, virtual void writeData(const unsigned char* data, size_t len,
int64_t offset); off_t offset);
virtual int32_t readData(unsigned char* data, int32_t len, int64_t offset); virtual ssize_t readData(unsigned char* data, size_t len, off_t offset);
virtual bool fileExists(); virtual bool fileExists();
virtual int64_t size() const; virtual uint64_t size() const;
virtual void truncate(int64_t length); virtual void truncate(uint64_t length);
virtual SharedHandle<FileAllocationIterator> fileAllocationIterator(); virtual SharedHandle<FileAllocationIterator> fileAllocationIterator();
@ -82,9 +82,9 @@ public:
SharedHandle<DiskWriter> getDiskWriter() const; SharedHandle<DiskWriter> getDiskWriter() const;
void setTotalLength(const int64_t& totalLength); void setTotalLength(const uint64_t& totalLength);
int64_t getTotalLength() const; uint64_t getTotalLength() const;
}; };
} // namespace aria2 } // namespace aria2

4
src/ActivePeerConnectionCommand.cc
View File

@ -53,7 +53,7 @@ ActivePeerConnectionCommand::ActivePeerConnectionCommand(int cuid,
RequestGroup* requestGroup, RequestGroup* requestGroup,
DownloadEngine* e, DownloadEngine* e,
const BtContextHandle& btContext, const BtContextHandle& btContext,
int32_t interval) time_t interval)
:Command(cuid), :Command(cuid),
BtContextAwareCommand(btContext), BtContextAwareCommand(btContext),
RequestGroupAware(requestGroup), RequestGroupAware(requestGroup),
@ -62,7 +62,7 @@ ActivePeerConnectionCommand::ActivePeerConnectionCommand(int cuid,
_thresholdSpeed(SLOW_SPEED_THRESHOLD), _thresholdSpeed(SLOW_SPEED_THRESHOLD),
_numNewConnection(5) _numNewConnection(5)
{ {
int32_t maxDownloadSpeed = e->option->getAsInt(PREF_MAX_DOWNLOAD_LIMIT); unsigned int maxDownloadSpeed = e->option->getAsInt(PREF_MAX_DOWNLOAD_LIMIT);
if(maxDownloadSpeed > 0) { if(maxDownloadSpeed > 0) {
_thresholdSpeed = std::min(maxDownloadSpeed, _thresholdSpeed); _thresholdSpeed = std::min(maxDownloadSpeed, _thresholdSpeed);
} }

12
src/ActivePeerConnectionCommand.h
View File

@ -50,17 +50,17 @@ class ActivePeerConnectionCommand : public Command,
public RequestGroupAware public RequestGroupAware
{ {
private: private:
int32_t interval; // UNIT: sec time_t interval; // UNIT: sec
DownloadEngine* e; DownloadEngine* e;
Time checkPoint; Time checkPoint;
int32_t _thresholdSpeed; // UNIT: byte/sec unsigned int _thresholdSpeed; // UNIT: byte/sec
int32_t _numNewConnection; // the number of the connection to establish. size_t _numNewConnection; // the number of the connection to establish.
public: public:
ActivePeerConnectionCommand(int cuid, ActivePeerConnectionCommand(int cuid,
RequestGroup* requestGroup, RequestGroup* requestGroup,
DownloadEngine* e, DownloadEngine* e,
const SharedHandle<BtContext>& btContext, const SharedHandle<BtContext>& btContext,
int32_t interval); time_t interval);
virtual ~ActivePeerConnectionCommand(); virtual ~ActivePeerConnectionCommand();
@ -68,12 +68,12 @@ public:
void connectToPeer(const SharedHandle<Peer>& peer); void connectToPeer(const SharedHandle<Peer>& peer);
void setThresholdSpeed(int32_t speed) void setThresholdSpeed(unsigned int speed)
{ {
_thresholdSpeed = speed; _thresholdSpeed = speed;
} }
void setNumNewConnection(int32_t numNewConnection) void setNumNewConnection(size_t numNewConnection)
{ {
_numNewConnection = numNewConnection; _numNewConnection = numNewConnection;
} }

17
src/AlphaNumberDecorator.h
View File

@ -44,37 +44,34 @@ class AlphaNumberDecorator : public NumberDecorator
{ {
private: private:
int32_t _width; size_t _width;
std::string _zero; std::string _zero;
std::string widen(const std::string& s, int32_t width) std::string widen(const std::string& s, size_t width)
{ {
std::string t = s; std::string t = s;
while(t.size() < (size_t)width) { while(t.size() < width) {
t.insert(0, _zero); t.insert(0, _zero);
} }
return t; return t;
} }
public: public:
AlphaNumberDecorator(int32_t width, bool uppercase = false): AlphaNumberDecorator(size_t width, bool uppercase = false):
_width(width), _zero(uppercase?"A":"a") {} _width(width), _zero(uppercase?"A":"a") {}
virtual ~AlphaNumberDecorator() {} virtual ~AlphaNumberDecorator() {}
virtual std::string decorate(int32_t number) virtual std::string decorate(unsigned int number)
{ {
if(number < 0) {
throw new DlAbortEx("The number must be greater than 0.");
}
if(number == 0) { if(number == 0) {
return widen(_zero, _width); return widen(_zero, _width);
} }
int32_t base = 26; int base = 26;
std::string x; std::string x;
while(number > 0) { while(number > 0) {
int32_t r = number%base; int r = number%base;
char alpha = _zero[0]+r; char alpha = _zero[0]+r;
x.insert(0, std::string(1, alpha)); x.insert(0, std::string(1, alpha));
number /= base; number /= base;

4
src/AnnounceList.cc
View File

@ -187,11 +187,11 @@ public:
} }
}; };
int32_t AnnounceList::countStoppedAllowedTier() const { size_t AnnounceList::countStoppedAllowedTier() const {
return count_if(tiers.begin(), tiers.end(), FindStoppedAllowedTier()); return count_if(tiers.begin(), tiers.end(), FindStoppedAllowedTier());
} }
int32_t AnnounceList::countCompletedAllowedTier() const { size_t AnnounceList::countCompletedAllowedTier() const {
return count_if(tiers.begin(), tiers.end(), FindCompletedAllowedTier()); return count_if(tiers.begin(), tiers.end(), FindCompletedAllowedTier());
} }

6
src/AnnounceList.h
View File

@ -61,7 +61,7 @@ public:
void reconfigure(const MetaEntry* announceListEntry); void reconfigure(const MetaEntry* announceListEntry);
void reconfigure(const std::string& url); void reconfigure(const std::string& url);
int32_t countTier() const { size_t countTier() const {
return tiers.size(); return tiers.size();
} }
@ -102,12 +102,12 @@ public:
/** /**
* Counts the number of tiers to which the "stopped" event can be sent. * Counts the number of tiers to which the "stopped" event can be sent.
*/ */
int32_t countStoppedAllowedTier() const; size_t countStoppedAllowedTier() const;
/** /**
* Counts the number of tiers to which the "completed" event can be sent. * Counts the number of tiers to which the "completed" event can be sent.
*/ */
int32_t countCompletedAllowedTier() const; size_t countCompletedAllowedTier() const;
/** /**
* Moves current tier pointer to the tier to which the "stopped" event can * Moves current tier pointer to the tier to which the "stopped" event can

2
src/AutoSaveCommand.cc
View File

@ -38,7 +38,7 @@
namespace aria2 { namespace aria2 {
AutoSaveCommand::AutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval): AutoSaveCommand::AutoSaveCommand(int32_t cuid, DownloadEngine* e, time_t interval):
TimeBasedCommand(cuid, e, interval) {} TimeBasedCommand(cuid, e, interval) {}
AutoSaveCommand::~AutoSaveCommand() {} AutoSaveCommand::~AutoSaveCommand() {}

2
src/AutoSaveCommand.h
View File

@ -42,7 +42,7 @@ namespace aria2 {
class AutoSaveCommand : public TimeBasedCommand class AutoSaveCommand : public TimeBasedCommand
{ {
public: public:
AutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval); AutoSaveCommand(int32_t cuid, DownloadEngine* e, time_t interval);
virtual ~AutoSaveCommand(); virtual ~AutoSaveCommand();

2
src/BencodeVisitor.cc
View File

@ -68,7 +68,7 @@ void BencodeVisitor::visit(const Dictionary* d)
_bencodedData += "d"; _bencodedData += "d";
for(std::deque<std::string>::const_iterator itr = d->getOrder().begin(); itr != d->getOrder().end(); ++itr) { for(std::deque<std::string>::const_iterator itr = d->getOrder().begin(); itr != d->getOrder().end(); ++itr) {
_bencodedData += Util::itos((int32_t)(*itr).size()); _bencodedData += Util::uitos((*itr).size());
_bencodedData += ":"; _bencodedData += ":";
_bencodedData += *itr; _bencodedData += *itr;
d->get(*itr)->accept(this); d->get(*itr)->accept(this);

6
src/BinaryStream.h
View File

@ -44,11 +44,11 @@ class BinaryStream {
public: public:
virtual ~BinaryStream() {} virtual ~BinaryStream() {}
virtual void writeData(const unsigned char* data, int32_t len, int64_t offset) = 0; virtual void writeData(const unsigned char* data, size_t len, off_t offset) = 0;
virtual int32_t readData(unsigned char* data, int32_t len, int64_t offset) = 0; virtual ssize_t readData(unsigned char* data, size_t len, off_t offset) = 0;
virtual void truncate(int64_t length) = 0; virtual void truncate(uint64_t length) = 0;
virtual void enableDirectIO() = 0; virtual void enableDirectIO() = 0;

2
src/BitfieldManFactory.cc
View File

@ -53,7 +53,7 @@ BitfieldManFactory::BitfieldManFactory():randomizer(0) {}
BitfieldManFactory::~BitfieldManFactory() {} BitfieldManFactory::~BitfieldManFactory() {}
BitfieldMan* BitfieldMan*
BitfieldManFactory::createBitfieldMan(int32_t blockLength, int64_t totalLength) BitfieldManFactory::createBitfieldMan(size_t blockLength, uint64_t totalLength)
{ {
BitfieldMan* bitfieldMan = new BitfieldMan(blockLength, totalLength); BitfieldMan* bitfieldMan = new BitfieldMan(blockLength, totalLength);
bitfieldMan->setRandomizer(randomizer); bitfieldMan->setRandomizer(randomizer);

2
src/BitfieldManFactory.h
View File

@ -55,7 +55,7 @@ public:
static SharedHandle<BitfieldManFactory> getFactoryInstance(); static SharedHandle<BitfieldManFactory> getFactoryInstance();
BitfieldMan* createBitfieldMan(int32_t blockLength, int64_t totalLength); BitfieldMan* createBitfieldMan(size_t blockLength, uint64_t totalLength);
static void setDefaultRandomizer(const SharedHandle<Randomizer>& randomizer); static void setDefaultRandomizer(const SharedHandle<Randomizer>& randomizer);

8
src/BtAllowedFastMessage.cc
View File

@ -41,11 +41,11 @@
namespace aria2 { namespace aria2 {
BtAllowedFastMessageHandle BtAllowedFastMessage::create(const unsigned char* data, int32_t dataLength) { BtAllowedFastMessageHandle BtAllowedFastMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 5) { if(dataLength != 5) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "allowed fast", dataLength, 5); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "allowed fast", dataLength, 5);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "allowed fast", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "allowed fast", ID);
} }
@ -62,7 +62,7 @@ void BtAllowedFastMessage::doReceivedAction() {
peer->addPeerAllowedIndex(index); peer->addPeerAllowedIndex(index);
} }
int32_t BtAllowedFastMessage::MESSAGE_LENGTH = 9; size_t BtAllowedFastMessage::MESSAGE_LENGTH = 9;
const unsigned char* BtAllowedFastMessage::getMessage() { const unsigned char* BtAllowedFastMessage::getMessage() {
if(!msg) { if(!msg) {
@ -79,7 +79,7 @@ const unsigned char* BtAllowedFastMessage::getMessage() {
return msg; return msg;
} }
int32_t BtAllowedFastMessage::getMessageLength() { size_t BtAllowedFastMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

18
src/BtAllowedFastMessage.h
View File

@ -45,12 +45,12 @@ typedef SharedHandle<BtAllowedFastMessage> BtAllowedFastMessageHandle;
class BtAllowedFastMessage : public SimpleBtMessage { class BtAllowedFastMessage : public SimpleBtMessage {
private: private:
int32_t index; size_t index;
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtAllowedFastMessage(int32_t index = 0) BtAllowedFastMessage(size_t index = 0)
:SimpleBtMessage(), :SimpleBtMessage(),
index(index), index(index),
msg(0) {} msg(0) {}
@ -59,22 +59,22 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 17; static const uint8_t ID = 17;
void setIndex(int32_t index) { void setIndex(size_t index) {
this->index = index; this->index = index;
} }
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
static BtAllowedFastMessageHandle create(const unsigned char* data, int32_t dataLength); static BtAllowedFastMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;

4
src/BtAllowedFastMessageValidator.h
View File

@ -44,10 +44,10 @@ namespace aria2 {
class BtAllowedFastMessageValidator : public BtMessageValidator { class BtAllowedFastMessageValidator : public BtMessageValidator {
private: private:
const BtAllowedFastMessage* message; const BtAllowedFastMessage* message;
int32_t numPiece; size_t numPiece;
public: public:
BtAllowedFastMessageValidator(const BtAllowedFastMessage* message, BtAllowedFastMessageValidator(const BtAllowedFastMessage* message,
int32_t numPiece): size_t numPiece):
message(message), message(message),
numPiece(numPiece) {} numPiece(numPiece) {}

8
src/BtBitfieldMessage.cc
View File

@ -42,7 +42,7 @@
namespace aria2 { namespace aria2 {
void BtBitfieldMessage::setBitfield(const unsigned char* bitfield, int32_t bitfieldLength) { void BtBitfieldMessage::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) {
if(this->bitfield == bitfield) { if(this->bitfield == bitfield) {
return; return;
} }
@ -54,12 +54,12 @@ void BtBitfieldMessage::setBitfield(const unsigned char* bitfield, int32_t bitfi
} }
BtBitfieldMessageHandle BtBitfieldMessageHandle
BtBitfieldMessage::create(const unsigned char* data, int32_t dataLength) BtBitfieldMessage::create(const unsigned char* data, size_t dataLength)
{ {
if(dataLength <= 1) { if(dataLength <= 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "bitfield", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "bitfield", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "bitfield", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "bitfield", ID);
} }
@ -89,7 +89,7 @@ const unsigned char* BtBitfieldMessage::getMessage() {
return msg; return msg;
} }
int32_t BtBitfieldMessage::getMessageLength() { size_t BtBitfieldMessage::getMessageLength() {
getMessage(); getMessage();
return msgLength; return msgLength;
} }

18
src/BtBitfieldMessage.h
View File

@ -46,9 +46,9 @@ typedef SharedHandle<BtBitfieldMessage> BtBitfieldMessageHandle;
class BtBitfieldMessage : public SimpleBtMessage { class BtBitfieldMessage : public SimpleBtMessage {
private: private:
unsigned char* bitfield; unsigned char* bitfield;
int32_t bitfieldLength; size_t bitfieldLength;
unsigned char* msg; unsigned char* msg;
int32_t msgLength; size_t msgLength;
void init() { void init() {
bitfield = 0; bitfield = 0;
@ -63,7 +63,7 @@ public:
} }
BtBitfieldMessage(const unsigned char* bitfield, BtBitfieldMessage(const unsigned char* bitfield,
int32_t bitfieldLength):SimpleBtMessage() size_t bitfieldLength):SimpleBtMessage()
{ {
init(); init();
setBitfield(bitfield, bitfieldLength); setBitfield(bitfield, bitfieldLength);
@ -74,23 +74,23 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 5; static const uint8_t ID = 5;
void setBitfield(const unsigned char* bitfield, int32_t bitfieldLength); void setBitfield(const unsigned char* bitfield, size_t bitfieldLength);
const unsigned char* getBitfield() const { return bitfield; } const unsigned char* getBitfield() const { return bitfield; }
int32_t getBitfieldLength() const { return bitfieldLength; } size_t getBitfieldLength() const { return bitfieldLength; }
static BtBitfieldMessageHandle create(const unsigned char* data, int32_t dataLength); static BtBitfieldMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

4
src/BtBitfieldMessageValidator.h
View File

@ -43,10 +43,10 @@ namespace aria2 {
class BtBitfieldMessageValidator : public BtMessageValidator { class BtBitfieldMessageValidator : public BtMessageValidator {
private: private:
const BtBitfieldMessage* message; const BtBitfieldMessage* message;
int32_t numPiece; size_t numPiece;
public: public:
BtBitfieldMessageValidator(const BtBitfieldMessage* message, BtBitfieldMessageValidator(const BtBitfieldMessage* message,
int32_t numPiece): size_t numPiece):
message(message), message(message),
numPiece(numPiece) {} numPiece(numPiece) {}

12
src/BtCancelMessage.cc
View File

@ -41,11 +41,11 @@
namespace aria2 { namespace aria2 {
BtCancelMessageHandle BtCancelMessage::create(const unsigned char* data, int32_t dataLength) { BtCancelMessageHandle BtCancelMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 13) { if(dataLength != 13) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "cancel", dataLength, 13); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "cancel", dataLength, 13);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "cancel", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "cancel", ID);
} }
@ -60,7 +60,7 @@ void BtCancelMessage::doReceivedAction() {
dispatcher->doCancelSendingPieceAction(index, begin, length); dispatcher->doCancelSendingPieceAction(index, begin, length);
} }
int32_t BtCancelMessage::MESSAGE_LENGTH = 17; size_t BtCancelMessage::MESSAGE_LENGTH = 17;
const unsigned char* BtCancelMessage::getMessage() { const unsigned char* BtCancelMessage::getMessage() {
if(!msg) { if(!msg) {
@ -81,13 +81,13 @@ const unsigned char* BtCancelMessage::getMessage() {
return msg; return msg;
} }
int32_t BtCancelMessage::getMessageLength() { size_t BtCancelMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }
std::string BtCancelMessage::toString() const { std::string BtCancelMessage::toString() const {
return "cancel index="+Util::itos(index)+", begin="+Util::itos(begin)+ return "cancel index="+Util::uitos(index)+", begin="+Util::uitos(begin)+
", length="+Util::itos(length); ", length="+Util::uitos(length);
} }
} // namespace aria2 } // namespace aria2

28
src/BtCancelMessage.h
View File

@ -45,14 +45,14 @@ typedef SharedHandle<BtCancelMessage> BtCancelMessageHandle;
class BtCancelMessage : public SimpleBtMessage { class BtCancelMessage : public SimpleBtMessage {
private: private:
int32_t index; size_t index;
int32_t begin; uint32_t begin;
int32_t length; size_t length;
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtCancelMessage(int32_t index = 0, int32_t begin = 0, int32_t length = 0) BtCancelMessage(size_t index = 0, uint32_t begin = 0, size_t length = 0)
:SimpleBtMessage(), :SimpleBtMessage(),
index(index), index(index),
begin(begin), begin(begin),
@ -65,27 +65,27 @@ public:
static const int8_t ID = 8; static const int8_t ID = 8;
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
void setIndex(int32_t index) { this->index = index; } void setIndex(size_t index) { this->index = index; }
int32_t getBegin() const { return begin; } uint32_t getBegin() const { return begin; }
void setBegin(int32_t begin) { this->begin = begin; } void setBegin(uint32_t begin) { this->begin = begin; }
int32_t getLength() const { return length; } size_t getLength() const { return length; }
void setLength(int32_t length) { this->length = length; } void setLength(size_t length) { this->length = length; }
static BtCancelMessageHandle create(const unsigned char* data, int32_t dataLength); static BtCancelMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

8
src/BtCancelMessageValidator.h
View File

@ -44,12 +44,12 @@ namespace aria2 {
class BtCancelMessageValidator : public BtMessageValidator { class BtCancelMessageValidator : public BtMessageValidator {
private: private:
const BtCancelMessage* message; const BtCancelMessage* message;
int32_t numPiece; size_t numPiece;
int32_t pieceLength; size_t pieceLength;
public: public:
BtCancelMessageValidator(const BtCancelMessage* message, BtCancelMessageValidator(const BtCancelMessage* message,
int32_t numPiece, size_t numPiece,
int32_t pieceLength): size_t pieceLength):
message(message), message(message),
numPiece(numPiece), numPiece(numPiece),
pieceLength(pieceLength) {} pieceLength(pieceLength) {}

20
src/BtCancelSendingPieceEvent.h
View File

@ -41,36 +41,36 @@ namespace aria2 {
class BtCancelSendingPieceEvent : public BtEvent { class BtCancelSendingPieceEvent : public BtEvent {
private: private:
int32_t index; size_t index;
int32_t begin; uint32_t begin;
int32_t length; size_t length;
public: public:
BtCancelSendingPieceEvent(int32_t index, int32_t begin, int32_t length): BtCancelSendingPieceEvent(size_t index, uint32_t begin, size_t length):
index(index), begin(begin), length(length) {} index(index), begin(begin), length(length) {}
virtual ~BtCancelSendingPieceEvent() {} virtual ~BtCancelSendingPieceEvent() {}
void setIndex(int32_t index) { void setIndex(size_t index) {
this->index = index; this->index = index;
} }
int32_t getIndex() const { size_t getIndex() const {
return index; return index;
} }
void setBegin(int32_t begin) { void setBegin(uint32_t begin) {
this->begin = begin; this->begin = begin;
} }
int32_t getBegin() const { uint32_t getBegin() const {
return begin; return begin;
} }
void setLength(int32_t length) { void setLength(size_t length) {
this->length = length; this->length = length;
} }
int32_t getLength() const { size_t getLength() const {
return length; return length;
} }
}; };

8
src/BtChokeMessage.cc
View File

@ -42,11 +42,11 @@
namespace aria2 { namespace aria2 {
BtChokeMessageHandle BtChokeMessage::create(const unsigned char* data, int32_t dataLength) { BtChokeMessageHandle BtChokeMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 1) { if(dataLength != 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "choke", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "choke", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "choke", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "choke", ID);
} }
@ -64,7 +64,7 @@ bool BtChokeMessage::sendPredicate() const {
return !peer->amChoking(); return !peer->amChoking();
} }
int32_t BtChokeMessage::MESSAGE_LENGTH = 5; size_t BtChokeMessage::MESSAGE_LENGTH = 5;
const unsigned char* BtChokeMessage::getMessage() { const unsigned char* BtChokeMessage::getMessage() {
if(!msg) { if(!msg) {
@ -79,7 +79,7 @@ const unsigned char* BtChokeMessage::getMessage() {
return msg; return msg;
} }
int32_t BtChokeMessage::getMessageLength() { size_t BtChokeMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

10
src/BtChokeMessage.h
View File

@ -47,7 +47,7 @@ class BtChokeMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtChokeMessage():SimpleBtMessage(), msg(0) {} BtChokeMessage():SimpleBtMessage(), msg(0) {}
@ -55,19 +55,19 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 0; static const uint8_t ID = 0;
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
static BtChokeMessageHandle create(const unsigned char* data, int32_t dataLength); static BtChokeMessageHandle create(const unsigned char* data, size_t dataLength);
virtual bool sendPredicate() const; virtual bool sendPredicate() const;

4
src/BtExtendedMessage.cc
View File

@ -80,7 +80,7 @@ const unsigned char* BtExtendedMessage::getMessage() {
return _msg; return _msg;
} }
int32_t BtExtendedMessage::getMessageLength() { size_t BtExtendedMessage::getMessageLength() {
getMessage(); getMessage();
return _msgLength; return _msgLength;
} }
@ -102,7 +102,7 @@ BtExtendedMessage::create(const BtContextHandle& btContext,
if(dataLength < 2) { if(dataLength < 2) {
throw new DlAbortEx(MSG_TOO_SMALL_PAYLOAD_SIZE, "extended", dataLength); throw new DlAbortEx(MSG_TOO_SMALL_PAYLOAD_SIZE, "extended", dataLength);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "extended", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "extended", ID);
} }

4
src/BtExtendedMessage.h
View File

@ -63,13 +63,13 @@ public:
const unsigned char* data, const unsigned char* data,
size_t dataLength); size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual bool sendPredicate() const; virtual bool sendPredicate() const;

4
src/BtHandshakeMessage.cc
View File

@ -70,7 +70,7 @@ void BtHandshakeMessage::init() {
} }
SharedHandle<BtHandshakeMessage> SharedHandle<BtHandshakeMessage>
BtHandshakeMessage::create(const unsigned char* data, int32_t dataLength) BtHandshakeMessage::create(const unsigned char* data, size_t dataLength)
{ {
SharedHandle<BtHandshakeMessage> message = new BtHandshakeMessage(); SharedHandle<BtHandshakeMessage> message = new BtHandshakeMessage();
message->pstrlen = data[0]; message->pstrlen = data[0];
@ -93,7 +93,7 @@ const unsigned char* BtHandshakeMessage::getMessage() {
return msg; return msg;
} }
int32_t BtHandshakeMessage::getMessageLength() { size_t BtHandshakeMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

18
src/BtHandshakeMessage.h
View File

@ -41,12 +41,12 @@ namespace aria2 {
class BtHandshakeMessage : public SimpleBtMessage { class BtHandshakeMessage : public SimpleBtMessage {
public: public:
static const int32_t PSTR_LENGTH = 19; static const size_t PSTR_LENGTH = 19;
static const unsigned char* BT_PSTR; static const unsigned char* BT_PSTR;
static const int32_t RESERVED_LENGTH = 8; static const size_t RESERVED_LENGTH = 8;
static const int32_t MESSAGE_LENGTH = 68; static const size_t MESSAGE_LENGTH = 68;
private: private:
int8_t pstrlen; uint8_t pstrlen;
unsigned char* pstr; unsigned char* pstr;
unsigned char* reserved; unsigned char* reserved;
unsigned char* infoHash; unsigned char* infoHash;
@ -62,7 +62,7 @@ public:
BtHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId); BtHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId);
static SharedHandle<BtHandshakeMessage> static SharedHandle<BtHandshakeMessage>
create(const unsigned char* data, int32_t dataLength); create(const unsigned char* data, size_t dataLength);
virtual ~BtHandshakeMessage() { virtual ~BtHandshakeMessage() {
delete [] msg; delete [] msg;
@ -72,15 +72,15 @@ public:
delete [] peerId; delete [] peerId;
} }
static const int8_t ID = INT8_MAX; static const uint8_t ID = INT8_MAX;
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction() {}; virtual void doReceivedAction() {};
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
@ -99,7 +99,7 @@ public:
} }
} }
int8_t getPstrlen() const { uint8_t getPstrlen() const {
return pstrlen; return pstrlen;
} }

8
src/BtHaveAllMessage.cc
View File

@ -40,11 +40,11 @@
namespace aria2 { namespace aria2 {
BtHaveAllMessageHandle BtHaveAllMessage::create(const unsigned char* data, int32_t dataLength) { BtHaveAllMessageHandle BtHaveAllMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 1) { if(dataLength != 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "have all", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "have all", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "have all", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "have all", ID);
} }
@ -60,7 +60,7 @@ void BtHaveAllMessage::doReceivedAction() {
peer->setAllBitfield(); peer->setAllBitfield();
} }
int32_t BtHaveAllMessage::MESSAGE_LENGTH = 5; size_t BtHaveAllMessage::MESSAGE_LENGTH = 5;
const unsigned char* BtHaveAllMessage::getMessage() { const unsigned char* BtHaveAllMessage::getMessage() {
if(!msg) { if(!msg) {
@ -75,7 +75,7 @@ const unsigned char* BtHaveAllMessage::getMessage() {
return msg; return msg;
} }
int32_t BtHaveAllMessage::getMessageLength() { size_t BtHaveAllMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

10
src/BtHaveAllMessage.h
View File

@ -47,7 +47,7 @@ class BtHaveAllMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtHaveAllMessage():msg(0) {} BtHaveAllMessage():msg(0) {}
@ -55,17 +55,17 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 14; static const uint8_t ID = 14;
static BtHaveAllMessageHandle create(const unsigned char* data, int32_t dataLength); static BtHaveAllMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

8
src/BtHaveMessage.cc
View File

@ -41,11 +41,11 @@
namespace aria2 { namespace aria2 {
BtHaveMessageHandle BtHaveMessage::create(const unsigned char* data, int32_t dataLength) { BtHaveMessageHandle BtHaveMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 5) { if(dataLength != 5) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "have", dataLength, 5); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "have", dataLength, 5);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "have", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "have", ID);
} }
@ -58,7 +58,7 @@ void BtHaveMessage::doReceivedAction() {
peer->updateBitfield(index, 1); peer->updateBitfield(index, 1);
} }
int32_t BtHaveMessage::MESSAGE_LENGTH = 9; size_t BtHaveMessage::MESSAGE_LENGTH = 9;
const unsigned char* BtHaveMessage::getMessage() { const unsigned char* BtHaveMessage::getMessage() {
if(!msg) { if(!msg) {
@ -75,7 +75,7 @@ const unsigned char* BtHaveMessage::getMessage() {
return msg; return msg;
} }
int32_t BtHaveMessage::getMessageLength() { size_t BtHaveMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

18
src/BtHaveMessage.h
View File

@ -45,33 +45,33 @@ typedef SharedHandle<BtHaveMessage> BtHaveMessageHandle;
class BtHaveMessage : public SimpleBtMessage { class BtHaveMessage : public SimpleBtMessage {
private: private:
int32_t index; size_t index;
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtHaveMessage(int32_t index = 0):index(index), msg(0) {} BtHaveMessage(size_t index = 0):index(index), msg(0) {}
virtual ~BtHaveMessage() { virtual ~BtHaveMessage() {
delete [] msg; delete [] msg;
} }
static const int8_t ID = 4; static const uint8_t ID = 4;
void setIndex(int32_t index) { void setIndex(size_t index) {
this->index = index; this->index = index;
} }
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
static BtHaveMessageHandle create(const unsigned char* data, int32_t dataLength); static BtHaveMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

4
src/BtHaveMessageValidator.h
View File

@ -44,10 +44,10 @@ namespace aria2 {
class BtHaveMessageValidator : public BtMessageValidator { class BtHaveMessageValidator : public BtMessageValidator {
private: private:
const BtHaveMessage* message; const BtHaveMessage* message;
int32_t numPiece; size_t numPiece;
public: public:
BtHaveMessageValidator(const BtHaveMessage* message, BtHaveMessageValidator(const BtHaveMessage* message,
int32_t numPiece): size_t numPiece):
message(message), message(message),
numPiece(numPiece) {} numPiece(numPiece) {}

8
src/BtHaveNoneMessage.cc
View File

@ -40,11 +40,11 @@
namespace aria2 { namespace aria2 {
BtHaveNoneMessageHandle BtHaveNoneMessage::create(const unsigned char* data, int32_t dataLength) { BtHaveNoneMessageHandle BtHaveNoneMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 1) { if(dataLength != 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "have none", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "have none", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "have none", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "have none", ID);
} }
@ -59,7 +59,7 @@ void BtHaveNoneMessage::doReceivedAction() {
} }
} }
int32_t BtHaveNoneMessage::MESSAGE_LENGTH = 5; size_t BtHaveNoneMessage::MESSAGE_LENGTH = 5;
const unsigned char* BtHaveNoneMessage::getMessage() { const unsigned char* BtHaveNoneMessage::getMessage() {
if(!msg) { if(!msg) {
@ -74,7 +74,7 @@ const unsigned char* BtHaveNoneMessage::getMessage() {
return msg; return msg;
} }
int32_t BtHaveNoneMessage::getMessageLength() { size_t BtHaveNoneMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

10
src/BtHaveNoneMessage.h
View File

@ -47,7 +47,7 @@ class BtHaveNoneMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtHaveNoneMessage():msg(0) {} BtHaveNoneMessage():msg(0) {}
@ -55,17 +55,17 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 15; static const uint8_t ID = 15;
static BtHaveNoneMessageHandle create(const unsigned char* data, int32_t dataLength); static BtHaveNoneMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

2
src/BtInteractive.h
View File

@ -60,7 +60,7 @@ public:
virtual void sendPendingMessage() = 0; virtual void sendPendingMessage() = 0;
virtual int32_t countPendingMessage() = 0; virtual size_t countPendingMessage() = 0;
virtual bool isSendingMessageInProgress() = 0; virtual bool isSendingMessageInProgress() = 0;

8
src/BtInterestedMessage.cc
View File

@ -40,11 +40,11 @@
namespace aria2 { namespace aria2 {
BtInterestedMessageHandle BtInterestedMessage::create(const unsigned char* data, int32_t dataLength) { BtInterestedMessageHandle BtInterestedMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 1) { if(dataLength != 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "interested", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "interested", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "interested", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "interested", ID);
} }
@ -60,7 +60,7 @@ bool BtInterestedMessage::sendPredicate() const {
return !peer->amInterested(); return !peer->amInterested();
} }
int32_t BtInterestedMessage::MESSAGE_LENGTH = 5; size_t BtInterestedMessage::MESSAGE_LENGTH = 5;
const unsigned char* BtInterestedMessage::getMessage() { const unsigned char* BtInterestedMessage::getMessage() {
if(!msg) { if(!msg) {
@ -75,7 +75,7 @@ const unsigned char* BtInterestedMessage::getMessage() {
return msg; return msg;
} }
int32_t BtInterestedMessage::getMessageLength() { size_t BtInterestedMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

10
src/BtInterestedMessage.h
View File

@ -47,7 +47,7 @@ class BtInterestedMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtInterestedMessage():msg(0) {} BtInterestedMessage():msg(0) {}
@ -55,17 +55,17 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 2; static const uint8_t ID = 2;
static BtInterestedMessageHandle create(const unsigned char* data, int32_t dataLength); static BtInterestedMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;

4
src/BtKeepAliveMessage.cc
View File

@ -36,7 +36,7 @@
namespace aria2 { namespace aria2 {
int32_t BtKeepAliveMessage::MESSAGE_LENGTH = 4; size_t BtKeepAliveMessage::MESSAGE_LENGTH = 4;
const unsigned char* BtKeepAliveMessage::getMessage() { const unsigned char* BtKeepAliveMessage::getMessage() {
if(!msg) { if(!msg) {
@ -50,7 +50,7 @@ const unsigned char* BtKeepAliveMessage::getMessage() {
return msg; return msg;
} }
int32_t BtKeepAliveMessage::getMessageLength() { size_t BtKeepAliveMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

8
src/BtKeepAliveMessage.h
View File

@ -47,7 +47,7 @@ class BtKeepAliveMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtKeepAliveMessage():msg(0) {} BtKeepAliveMessage():msg(0) {}
@ -55,15 +55,15 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 99; static const uint8_t ID = 99;
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction() {} virtual void doReceivedAction() {}
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const { virtual std::string toString() const {
return "keep alive"; return "keep alive";

2
src/BtMessage.h
View File

@ -54,7 +54,7 @@ public:
virtual bool isUploading() = 0; virtual bool isUploading() = 0;
virtual int8_t getId() = 0; virtual uint8_t getId() = 0;
virtual void doReceivedAction() = 0; virtual void doReceivedAction() = 0;

10
src/BtMessageDispatcher.h
View File

@ -56,7 +56,7 @@ public:
virtual void sendMessages() = 0; virtual void sendMessages() = 0;
virtual void doCancelSendingPieceAction(int32_t index, int32_t begin, int32_t length) = 0; virtual void doCancelSendingPieceAction(size_t index, uint32_t begin, size_t length) = 0;
virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece) = 0; virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece) = 0;
@ -70,13 +70,13 @@ public:
virtual bool isSendingInProgress() = 0; virtual bool isSendingInProgress() = 0;
virtual int32_t countMessageInQueue() = 0; virtual size_t countMessageInQueue() = 0;
virtual int32_t countOutstandingRequest() = 0; virtual size_t countOutstandingRequest() = 0;
virtual bool isOutstandingRequest(int32_t index, int32_t blockIndex) = 0; virtual bool isOutstandingRequest(size_t index, size_t blockIndex) = 0;
virtual RequestSlot getOutstandingRequest(int32_t index, int32_t begin, int32_t length) = 0; virtual RequestSlot getOutstandingRequest(size_t index, uint32_t begin, size_t length) = 0;
virtual void removeOutstandingRequest(const RequestSlot& slot) = 0; virtual void removeOutstandingRequest(const RequestSlot& slot) = 0;

16
src/BtMessageFactory.h
View File

@ -49,25 +49,25 @@ public:
virtual ~BtMessageFactory() {} virtual ~BtMessageFactory() {}
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createBtMessage(const unsigned char* msg, int32_t msgLength) = 0; createBtMessage(const unsigned char* msg, size_t msgLength) = 0;
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createHandshakeMessage(const unsigned char* msg, int32_t msgLength) = 0; createHandshakeMessage(const unsigned char* msg, size_t msgLength) = 0;
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createHandshakeMessage(const unsigned char* infoHash, createHandshakeMessage(const unsigned char* infoHash,
const unsigned char* peerId) = 0; const unsigned char* peerId) = 0;
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createRequestMessage(const SharedHandle<Piece>& piece, int32_t blockIndex) = 0; createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex) = 0;
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createCancelMessage(int32_t index, int32_t begin, int32_t length) = 0; createCancelMessage(size_t index, uint32_t begin, size_t length) = 0;
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createPieceMessage(int32_t index, int32_t begin, int32_t length) = 0; createPieceMessage(size_t index, uint32_t begin, size_t length) = 0;
virtual SharedHandle<BtMessage> createHaveMessage(int32_t index) = 0; virtual SharedHandle<BtMessage> createHaveMessage(size_t index) = 0;
virtual SharedHandle<BtMessage> createChokeMessage() = 0; virtual SharedHandle<BtMessage> createChokeMessage() = 0;
@ -86,9 +86,9 @@ public:
virtual SharedHandle<BtMessage> createHaveNoneMessage() = 0; virtual SharedHandle<BtMessage> createHaveNoneMessage() = 0;
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createRejectMessage(int32_t index, int32_t begin, int32_t length) = 0; createRejectMessage(size_t index, uint32_t begin, size_t length) = 0;
virtual SharedHandle<BtMessage> createAllowedFastMessage(int32_t index) = 0; virtual SharedHandle<BtMessage> createAllowedFastMessage(size_t index) = 0;
virtual SharedHandle<BtMessage> createPortMessage(uint16_t port) = 0; virtual SharedHandle<BtMessage> createPortMessage(uint16_t port) = 0;

8
src/BtNotInterestedMessage.cc
View File

@ -40,11 +40,11 @@
namespace aria2 { namespace aria2 {
BtNotInterestedMessageHandle BtNotInterestedMessage::create(const unsigned char* data, int32_t dataLength) { BtNotInterestedMessageHandle BtNotInterestedMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 1) { if(dataLength != 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "not interested", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "not interested", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "not interested", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "not interested", ID);
} }
@ -60,7 +60,7 @@ bool BtNotInterestedMessage::sendPredicate() const {
return peer->amInterested(); return peer->amInterested();
} }
int32_t BtNotInterestedMessage::MESSAGE_LENGTH = 5; size_t BtNotInterestedMessage::MESSAGE_LENGTH = 5;
const unsigned char* BtNotInterestedMessage::getMessage() { const unsigned char* BtNotInterestedMessage::getMessage() {
if(!msg) { if(!msg) {
@ -75,7 +75,7 @@ const unsigned char* BtNotInterestedMessage::getMessage() {
return msg; return msg;
} }
int32_t BtNotInterestedMessage::getMessageLength() { size_t BtNotInterestedMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

10
src/BtNotInterestedMessage.h
View File

@ -47,7 +47,7 @@ class BtNotInterestedMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtNotInterestedMessage():msg(0) {} BtNotInterestedMessage():msg(0) {}
@ -55,17 +55,17 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 3; static const uint8_t ID = 3;
static BtNotInterestedMessageHandle create(const unsigned char* data, int32_t dataLength); static BtNotInterestedMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;

54
src/BtPieceMessage.cc
View File

@ -54,18 +54,18 @@
namespace aria2 { namespace aria2 {
void BtPieceMessage::setBlock(const unsigned char* block, int32_t blockLength) { void BtPieceMessage::setBlock(const unsigned char* block, size_t blockLength) {
delete [] this->block; delete [] this->block;
this->blockLength = blockLength; this->blockLength = blockLength;
this->block = new unsigned char[this->blockLength]; this->block = new unsigned char[this->blockLength];
memcpy(this->block, block, this->blockLength); memcpy(this->block, block, this->blockLength);
} }
BtPieceMessageHandle BtPieceMessage::create(const unsigned char* data, int32_t dataLength) { BtPieceMessageHandle BtPieceMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength <= 9) { if(dataLength <= 9) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "piece", dataLength, 9); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "piece", dataLength, 9);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "piece", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "piece", ID);
} }
@ -85,16 +85,12 @@ void BtPieceMessage::doReceivedAction() {
peer->snubbing(false); peer->snubbing(false);
peer->updateLatency(slot.getLatencyInMillis()); peer->updateLatency(slot.getLatencyInMillis());
PieceHandle piece = pieceStorage->getPiece(index); PieceHandle piece = pieceStorage->getPiece(index);
int64_t offset = off_t offset = (off_t)index*btContext->getPieceLength()+begin;
((int64_t)index)*btContext->getPieceLength()+begin;
logger->debug(MSG_PIECE_RECEIVED, logger->debug(MSG_PIECE_RECEIVED,
cuid, index, begin, blockLength, offset, slot.getBlockIndex()); cuid, index, begin, blockLength, offset, slot.getBlockIndex());
pieceStorage->getDiskAdaptor()->writeData(block, pieceStorage->getDiskAdaptor()->writeData(block, blockLength, offset);
blockLength,
offset);
piece->completeBlock(slot.getBlockIndex()); piece->completeBlock(slot.getBlockIndex());
logger->debug(MSG_PIECE_BITFIELD, logger->debug(MSG_PIECE_BITFIELD, cuid,
cuid,
Util::toHex(piece->getBitfield(), Util::toHex(piece->getBitfield(),
piece->getBitfieldLength()).c_str()); piece->getBitfieldLength()).c_str());
dispatcher->removeOutstandingRequest(slot); dispatcher->removeOutstandingRequest(slot);
@ -108,7 +104,7 @@ void BtPieceMessage::doReceivedAction() {
} }
} }
int32_t BtPieceMessage::MESSAGE_HEADER_LENGTH = 13; size_t BtPieceMessage::MESSAGE_HEADER_LENGTH = 13;
const unsigned char* BtPieceMessage::getMessageHeader() { const unsigned char* BtPieceMessage::getMessageHeader() {
if(!msgHeader) { if(!msgHeader) {
@ -128,7 +124,7 @@ const unsigned char* BtPieceMessage::getMessageHeader() {
return msgHeader; return msgHeader;
} }
int32_t BtPieceMessage::getMessageHeaderLength() { size_t BtPieceMessage::getMessageHeaderLength() {
return MESSAGE_HEADER_LENGTH; return MESSAGE_HEADER_LENGTH;
} }
@ -145,7 +141,7 @@ void BtPieceMessage::send() {
leftDataLength = getMessageHeaderLength(); leftDataLength = getMessageHeaderLength();
sendingInProgress = true; sendingInProgress = true;
} }
int32_t writtenLength size_t writtenLength
= peerConnection->sendMessage(msgHeader+getMessageHeaderLength()-leftDataLength, = peerConnection->sendMessage(msgHeader+getMessageHeaderLength()-leftDataLength,
leftDataLength); leftDataLength);
if(writtenLength == leftDataLength) { if(writtenLength == leftDataLength) {
@ -157,10 +153,9 @@ void BtPieceMessage::send() {
} }
if(headerSent) { if(headerSent) {
sendingInProgress = false; sendingInProgress = false;
int64_t pieceDataOffset = off_t pieceDataOffset =
((int64_t)index)*btContext->getPieceLength()+begin+blockLength-leftDataLength; (off_t)index*btContext->getPieceLength()+begin+blockLength-leftDataLength;
int32_t writtenLength = size_t writtenLength = sendPieceData(pieceDataOffset, leftDataLength);
sendPieceData(pieceDataOffset, leftDataLength);
peer->updateUploadLength(writtenLength); peer->updateUploadLength(writtenLength);
if(writtenLength < leftDataLength) { if(writtenLength < leftDataLength) {
sendingInProgress = true; sendingInProgress = true;
@ -169,28 +164,26 @@ void BtPieceMessage::send() {
} }
} }
int32_t BtPieceMessage::sendPieceData(int64_t offset, int32_t length) const { size_t BtPieceMessage::sendPieceData(off_t offset, size_t length) const {
int32_t BUF_SIZE = 256; size_t BUF_SIZE = 256;
unsigned char buf[BUF_SIZE]; unsigned char buf[BUF_SIZE];
int32_t iteration = length/BUF_SIZE; div_t res = div(length, BUF_SIZE);
int32_t writtenLength = 0; size_t writtenLength = 0;
for(int32_t i = 0; i < iteration; i++) { for(int i = 0; i < res.quot; i++) {
if(pieceStorage->getDiskAdaptor()->readData(buf, BUF_SIZE, offset+i*BUF_SIZE) < BUF_SIZE) { if((size_t)pieceStorage->getDiskAdaptor()->readData(buf, BUF_SIZE, offset+i*BUF_SIZE) < BUF_SIZE) {
throw new DlAbortEx(EX_DATA_READ); throw new DlAbortEx(EX_DATA_READ);
} }
int32_t ws = peerConnection->sendMessage(buf, BUF_SIZE); size_t ws = peerConnection->sendMessage(buf, BUF_SIZE);
writtenLength += ws; writtenLength += ws;
if(ws != BUF_SIZE) { if(ws != BUF_SIZE) {
return writtenLength; return writtenLength;
} }
} }
if(res.rem > 0) {
int32_t rem = length%BUF_SIZE; if(pieceStorage->getDiskAdaptor()->readData(buf, res.rem, offset+res.quot*BUF_SIZE) < res.rem) {
if(rem > 0) {
if(pieceStorage->getDiskAdaptor()->readData(buf, rem, offset+iteration*BUF_SIZE) < rem) {
throw new DlAbortEx(EX_DATA_READ); throw new DlAbortEx(EX_DATA_READ);
} }
int32_t ws = peerConnection->sendMessage(buf, rem); size_t ws = peerConnection->sendMessage(buf, res.rem);
writtenLength += ws; writtenLength += ws;
} }
return writtenLength; return writtenLength;
@ -202,8 +195,7 @@ std::string BtPieceMessage::toString() const {
} }
bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) { bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
int64_t offset = off_t offset = (off_t)piece->getIndex()*btContext->getPieceLength();
((int64_t)piece->getIndex())*btContext->getPieceLength();
return MessageDigestHelper::staticSHA1Digest(pieceStorage->getDiskAdaptor(), offset, piece->getLength()) return MessageDigestHelper::staticSHA1Digest(pieceStorage->getDiskAdaptor(), offset, piece->getLength())
== btContext->getPieceHash(piece->getIndex()); == btContext->getPieceHash(piece->getIndex());

36
src/BtPieceMessage.h
View File

@ -48,15 +48,15 @@ typedef SharedHandle<BtPieceMessage> BtPieceMessageHandle;
class BtPieceMessage : public AbstractBtMessage { class BtPieceMessage : public AbstractBtMessage {
private: private:
int32_t index; size_t index;
int32_t begin; uint32_t begin;
int32_t blockLength; uint32_t blockLength;
unsigned char* block; unsigned char* block;
int32_t leftDataLength; size_t leftDataLength;
bool headerSent; bool headerSent;
unsigned char* msgHeader; unsigned char* msgHeader;
static int32_t MESSAGE_HEADER_LENGTH; static size_t MESSAGE_HEADER_LENGTH;
bool checkPieceHash(const SharedHandle<Piece>& piece); bool checkPieceHash(const SharedHandle<Piece>& piece);
@ -66,7 +66,7 @@ private:
void erasePieceOnDisk(const SharedHandle<Piece>& piece); void erasePieceOnDisk(const SharedHandle<Piece>& piece);
int32_t sendPieceData(int64_t offset, int32_t length) const; size_t sendPieceData(off_t offset, size_t length) const;
class BtChokingEventListener : public AbstractBtEventListener { class BtChokingEventListener : public AbstractBtEventListener {
private: private:
@ -94,7 +94,7 @@ private:
typedef SharedHandle<BtCancelSendingPieceEventListener> BtCancelSendingPieceEventListenerHandle; typedef SharedHandle<BtCancelSendingPieceEventListener> BtCancelSendingPieceEventListenerHandle;
public: public:
BtPieceMessage(int32_t index = 0, int32_t begin = 0, int32_t blockLength = 0) BtPieceMessage(size_t index = 0, uint32_t begin = 0, size_t blockLength = 0)
:index(index), :index(index),
begin(begin), begin(begin),
blockLength(blockLength), blockLength(blockLength),
@ -113,33 +113,33 @@ public:
delete [] block; delete [] block;
} }
static const int8_t ID = 7; static const uint8_t ID = 7;
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
void setIndex(int32_t index) { this->index = index; } void setIndex(size_t index) { this->index = index; }
int32_t getBegin() const { return begin; } uint32_t getBegin() const { return begin; }
void setBegin(int32_t begin) { this->begin = begin; } void setBegin(uint32_t begin) { this->begin = begin; }
const unsigned char* getBlock() const { return block; } const unsigned char* getBlock() const { return block; }
void setBlock(const unsigned char* block, int32_t blockLength); void setBlock(const unsigned char* block, size_t blockLength);
int32_t getBlockLength() const { return blockLength; } size_t getBlockLength() const { return blockLength; }
void setBlockLength(int32_t blockLength) { this->blockLength = blockLength; } void setBlockLength(size_t blockLength) { this->blockLength = blockLength; }
static BtPieceMessageHandle create(const unsigned char* data, int32_t dataLength); static BtPieceMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
const unsigned char* getMessageHeader(); const unsigned char* getMessageHeader();
int32_t getMessageHeaderLength(); size_t getMessageHeaderLength();
virtual void send(); virtual void send();

8
src/BtPieceMessageValidator.h
View File

@ -44,12 +44,12 @@ namespace aria2 {
class BtPieceMessageValidator : public BtMessageValidator { class BtPieceMessageValidator : public BtMessageValidator {
private: private:
const BtPieceMessage* message; const BtPieceMessage* message;
int32_t numPiece; size_t numPiece;
int32_t pieceLength; size_t pieceLength;
public: public:
BtPieceMessageValidator(const BtPieceMessage* message, BtPieceMessageValidator(const BtPieceMessage* message,
int32_t numPiece, size_t numPiece,
int32_t pieceLength): size_t pieceLength):
message(message), message(message),
numPiece(numPiece), numPiece(numPiece),
pieceLength(pieceLength) {} pieceLength(pieceLength) {}

6
src/BtPortMessage.cc
View File

@ -54,12 +54,12 @@ BtPortMessage::~BtPortMessage()
delete [] _msg; delete [] _msg;
} }
SharedHandle<BtPortMessage> BtPortMessage::create(const unsigned char* data, int32_t dataLength) SharedHandle<BtPortMessage> BtPortMessage::create(const unsigned char* data, size_t dataLength)
{ {
if(dataLength != 3) { if(dataLength != 3) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "port", dataLength, 3); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "port", dataLength, 3);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "piece", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "piece", ID);
} }
@ -105,7 +105,7 @@ const unsigned char* BtPortMessage::getMessage() {
return _msg; return _msg;
} }
int32_t BtPortMessage::getMessageLength() { size_t BtPortMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

8
src/BtPortMessage.h
View File

@ -62,19 +62,19 @@ public:
virtual ~BtPortMessage(); virtual ~BtPortMessage();
static const int8_t ID = 9; static const uint8_t ID = 9;
uint16_t getPort() const { return _port; } uint16_t getPort() const { return _port; }
static SharedHandle<BtPortMessage> create(const unsigned char* data, int32_t dataLength); static SharedHandle<BtPortMessage> create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;

12
src/BtRejectMessage.cc
View File

@ -43,11 +43,11 @@
namespace aria2 { namespace aria2 {
BtRejectMessageHandle BtRejectMessage::create(const unsigned char* data, int32_t dataLength) { BtRejectMessageHandle BtRejectMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 13) { if(dataLength != 13) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "reject", dataLength, 13); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "reject", dataLength, 13);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "reject", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "reject", ID);
} }
@ -74,7 +74,7 @@ void BtRejectMessage::doReceivedAction() {
} }
int32_t BtRejectMessage::MESSAGE_LENGTH = 17; size_t BtRejectMessage::MESSAGE_LENGTH = 17;
const unsigned char* BtRejectMessage::getMessage() { const unsigned char* BtRejectMessage::getMessage() {
if(!msg) { if(!msg) {
@ -95,13 +95,13 @@ const unsigned char* BtRejectMessage::getMessage() {
return msg; return msg;
} }
int32_t BtRejectMessage::getMessageLength() { size_t BtRejectMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }
std::string BtRejectMessage::toString() const { std::string BtRejectMessage::toString() const {
return "reject index="+Util::itos(index)+", begin="+Util::itos(begin)+ return "reject index="+Util::uitos(index)+", begin="+Util::uitos(begin)+
", length="+Util::itos(length); ", length="+Util::uitos(length);
} }
} // namespace aria2 } // namespace aria2

30
src/BtRejectMessage.h
View File

@ -45,13 +45,13 @@ typedef SharedHandle<BtRejectMessage> BtRejectMessageHandle;
class BtRejectMessage : public SimpleBtMessage { class BtRejectMessage : public SimpleBtMessage {
private: private:
int32_t index; size_t index;
int32_t begin; uint32_t begin;
int32_t length; size_t length;
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtRejectMessage(int32_t index = 0, int32_t begin = 0, int32_t length = 0) BtRejectMessage(size_t index = 0, uint32_t begin = 0, size_t length = 0)
:index(index), :index(index),
begin(begin), begin(begin),
length(length), length(length),
@ -61,26 +61,26 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 16; static const uint8_t ID = 16;
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
void setIndex(int32_t index) { this->index = index; } void setIndex(size_t index) { this->index = index; }
int32_t getBegin() const { return begin; } uint32_t getBegin() const { return begin; }
void setBegin(int32_t begin) { this->begin = begin; } void setBegin(uint32_t begin) { this->begin = begin; }
int32_t getLength() const { return length; } size_t getLength() const { return length; }
void setLength(int32_t length) { this->length = length; } void setLength(size_t length) { this->length = length; }
static BtRejectMessageHandle create(const unsigned char* data, int32_t dataLength); static BtRejectMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

8
src/BtRejectMessageValidator.h
View File

@ -44,12 +44,12 @@ namespace aria2 {
class BtRejectMessageValidator : public BtMessageValidator { class BtRejectMessageValidator : public BtMessageValidator {
private: private:
const BtRejectMessage* message; const BtRejectMessage* message;
int32_t numPiece; size_t numPiece;
int32_t pieceLength; size_t pieceLength;
public: public:
BtRejectMessageValidator(const BtRejectMessage* message, BtRejectMessageValidator(const BtRejectMessage* message,
int32_t numPiece, size_t numPiece,
int32_t pieceLength): size_t pieceLength):
message(message), message(message),
numPiece(numPiece), numPiece(numPiece),
pieceLength(pieceLength) {} pieceLength(pieceLength) {}

2
src/BtRequestFactory.h
View File

@ -54,7 +54,7 @@ public:
virtual void removeAllTargetPiece() = 0; virtual void removeAllTargetPiece() = 0;
virtual int32_t countTargetPiece() = 0; virtual size_t countTargetPiece() = 0;
virtual void removeCompletedPiece() = 0; virtual void removeCompletedPiece() = 0;

12
src/BtRequestMessage.cc
View File

@ -47,11 +47,11 @@
namespace aria2 { namespace aria2 {
BtRequestMessageHandle BtRequestMessage::create(const unsigned char* data, int32_t dataLength) { BtRequestMessageHandle BtRequestMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 13) { if(dataLength != 13) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "request", dataLength, 13); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "request", dataLength, 13);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "request", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "request", ID);
} }
@ -80,7 +80,7 @@ void BtRequestMessage::doReceivedAction() {
} }
} }
int32_t BtRequestMessage::MESSAGE_LENGTH = 17; size_t BtRequestMessage::MESSAGE_LENGTH = 17;
const unsigned char* BtRequestMessage::getMessage() { const unsigned char* BtRequestMessage::getMessage() {
if(!msg) { if(!msg) {
@ -101,13 +101,13 @@ const unsigned char* BtRequestMessage::getMessage() {
return msg; return msg;
} }
int32_t BtRequestMessage::getMessageLength() { size_t BtRequestMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }
std::string BtRequestMessage::toString() const { std::string BtRequestMessage::toString() const {
return "request index="+Util::itos(index)+", begin="+Util::itos(begin)+ return "request index="+Util::uitos(index)+", begin="+Util::uitos(begin)+
", length="+Util::itos(length); ", length="+Util::uitos(length);
} }
void BtRequestMessage::onQueued() { void BtRequestMessage::onQueued() {

42
src/BtRequestMessage.h
View File

@ -46,13 +46,13 @@ typedef SharedHandle<BtRequestMessage> BtRequestMessageHandle;
class BtRequestMessage : public SimpleBtMessage { class BtRequestMessage : public SimpleBtMessage {
private: private:
int32_t index; size_t index;
int32_t begin; uint32_t begin;
int32_t length; uint32_t length;
int32_t blockIndex; size_t blockIndex;
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
class BtAbortOutstandingRequestEventListener : public AbstractBtEventListener { class BtAbortOutstandingRequestEventListener : public AbstractBtEventListener {
private: private:
@ -67,10 +67,10 @@ private:
typedef SharedHandle<BtAbortOutstandingRequestEventListener> BtAbortOutstandingRequestEventListenerHandle; typedef SharedHandle<BtAbortOutstandingRequestEventListener> BtAbortOutstandingRequestEventListenerHandle;
public: public:
BtRequestMessage(int32_t index = 0, BtRequestMessage(size_t index = 0,
int32_t begin = 0, uint32_t begin = 0,
int32_t length = 0, uint32_t length = 0,
int32_t blockIndex = 0) size_t blockIndex = 0)
:index(index), :index(index),
begin(begin), begin(begin),
length(length), length(length),
@ -84,29 +84,29 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 6; static const uint8_t ID = 6;
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
void setIndex(int32_t index) { this->index = index; } void setIndex(size_t index) { this->index = index; }
int32_t getBegin() const { return begin; } uint32_t getBegin() const { return begin; }
void setBegin(int32_t begin) { this->begin = begin; } void setBegin(uint32_t begin) { this->begin = begin; }
int32_t getLength() const { return length; } uint32_t getLength() const { return length; }
void setLength(int32_t length) { this->length = length; } void setLength(uint32_t length) { this->length = length; }
int32_t getBlockIndex() const { return blockIndex; } size_t getBlockIndex() const { return blockIndex; }
void setBlockIndex(int32_t blockIndex) { this->blockIndex = blockIndex; } void setBlockIndex(size_t blockIndex) { this->blockIndex = blockIndex; }
static BtRequestMessageHandle create(const unsigned char* data, int32_t dataLength); static BtRequestMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;

8
src/BtRequestMessageValidator.h
View File

@ -44,12 +44,12 @@ namespace aria2 {
class BtRequestMessageValidator : public BtMessageValidator { class BtRequestMessageValidator : public BtMessageValidator {
private: private:
const BtRequestMessage* message; const BtRequestMessage* message;
int32_t numPiece; size_t numPiece;
int32_t pieceLength; size_t pieceLength;
public: public:
BtRequestMessageValidator(const BtRequestMessage* message, BtRequestMessageValidator(const BtRequestMessage* message,
int32_t numPiece, size_t numPiece,
int32_t pieceLength): size_t pieceLength):
message(message), message(message),
numPiece(numPiece), numPiece(numPiece),
pieceLength(pieceLength) {} pieceLength(pieceLength) {}

16
src/BtRuntime.h
View File

@ -44,10 +44,10 @@ namespace aria2 {
class BtRuntime { class BtRuntime {
private: private:
int64_t uploadLengthAtStartup; uint64_t uploadLengthAtStartup;
int32_t port; uint16_t port;
bool halt; bool halt;
int32_t connections; unsigned int connections;
bool _ready; bool _ready;
public: public:
BtRuntime(): BtRuntime():
@ -60,19 +60,19 @@ public:
~BtRuntime() {} ~BtRuntime() {}
int64_t getUploadLengthAtStartup() const { uint64_t getUploadLengthAtStartup() const {
return uploadLengthAtStartup; return uploadLengthAtStartup;
} }
void setUploadLengthAtStartup(int64_t length) { void setUploadLengthAtStartup(uint64_t length) {
this->uploadLengthAtStartup = length; this->uploadLengthAtStartup = length;
} }
void setListenPort(int32_t port) { void setListenPort(uint16_t port) {
this->port = port; this->port = port;
} }
int32_t getListenPort() const { return port; } uint16_t getListenPort() const { return port; }
bool isHalt() const { return halt; } bool isHalt() const { return halt; }
@ -80,7 +80,7 @@ public:
this->halt = halt; this->halt = halt;
} }
int32_t getConnections() const { return connections; } unsigned int getConnections() const { return connections; }
void increaseConnections() { connections++; } void increaseConnections() { connections++; }

8
src/BtSuggestPieceMessage.cc
View File

@ -40,11 +40,11 @@
namespace aria2 { namespace aria2 {
BtSuggestPieceMessageHandle BtSuggestPieceMessage::create(const unsigned char* data, int32_t dataLength) { BtSuggestPieceMessageHandle BtSuggestPieceMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 5) { if(dataLength != 5) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "suggest piece", dataLength, 5); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "suggest piece", dataLength, 5);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "suggest piece", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "suggest piece", ID);
} }
@ -53,7 +53,7 @@ BtSuggestPieceMessageHandle BtSuggestPieceMessage::create(const unsigned char* d
return message; return message;
} }
int32_t BtSuggestPieceMessage::MESSAGE_LENGTH = 9; size_t BtSuggestPieceMessage::MESSAGE_LENGTH = 9;
const unsigned char* BtSuggestPieceMessage::getMessage() { const unsigned char* BtSuggestPieceMessage::getMessage() {
if(!msg) { if(!msg) {
@ -70,7 +70,7 @@ const unsigned char* BtSuggestPieceMessage::getMessage() {
return msg; return msg;
} }
int32_t BtSuggestPieceMessage::getMessageLength() { size_t BtSuggestPieceMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

16
src/BtSuggestPieceMessage.h
View File

@ -45,9 +45,9 @@ typedef SharedHandle<BtSuggestPieceMessage> BtSuggestPieceMessageHandle;
class BtSuggestPieceMessage : public SimpleBtMessage { class BtSuggestPieceMessage : public SimpleBtMessage {
private: private:
int32_t index; size_t index;
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtSuggestPieceMessage():index(0), msg(0) {} BtSuggestPieceMessage():index(0), msg(0) {}
@ -55,17 +55,17 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 13; static const uint8_t ID = 13;
void setIndex(int32_t index) { void setIndex(size_t index) {
this->index = index; this->index = index;
} }
int32_t getIndex() const { return index; } size_t getIndex() const { return index; }
static BtSuggestPieceMessageHandle create(const unsigned char* data, int32_t dataLength); static BtSuggestPieceMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction() { virtual void doReceivedAction() {
// TODO Current implementation ignores this message. // TODO Current implementation ignores this message.
@ -73,7 +73,7 @@ public:
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;
}; };

4
src/BtSuggestPieceMessageValidator.h
View File

@ -44,10 +44,10 @@ namespace aria2 {
class BtSuggestPieceMessageValidator : public BtMessageValidator { class BtSuggestPieceMessageValidator : public BtMessageValidator {
private: private:
const BtSuggestPieceMessage* message; const BtSuggestPieceMessage* message;
int32_t numPiece; size_t numPiece;
public: public:
BtSuggestPieceMessageValidator(const BtSuggestPieceMessage* message, BtSuggestPieceMessageValidator(const BtSuggestPieceMessage* message,
int32_t numPiece): size_t numPiece):
message(message), message(message),
numPiece(numPiece) {} numPiece(numPiece) {}

8
src/BtUnchokeMessage.cc
View File

@ -40,11 +40,11 @@
namespace aria2 { namespace aria2 {
BtUnchokeMessageHandle BtUnchokeMessage::create(const unsigned char* data, int32_t dataLength) { BtUnchokeMessageHandle BtUnchokeMessage::create(const unsigned char* data, size_t dataLength) {
if(dataLength != 1) { if(dataLength != 1) {
throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "unchoke", dataLength, 1); throw new DlAbortEx(EX_INVALID_PAYLOAD_SIZE, "unchoke", dataLength, 1);
} }
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
if(id != ID) { if(id != ID) {
throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "unchoke", ID); throw new DlAbortEx(EX_INVALID_BT_MESSAGE_ID, id, "unchoke", ID);
} }
@ -60,7 +60,7 @@ bool BtUnchokeMessage::sendPredicate() const {
return peer->amChoking(); return peer->amChoking();
} }
int32_t BtUnchokeMessage::MESSAGE_LENGTH = 5; size_t BtUnchokeMessage::MESSAGE_LENGTH = 5;
const unsigned char* BtUnchokeMessage::getMessage() { const unsigned char* BtUnchokeMessage::getMessage() {
if(!msg) { if(!msg) {
@ -75,7 +75,7 @@ const unsigned char* BtUnchokeMessage::getMessage() {
return msg; return msg;
} }
int32_t BtUnchokeMessage::getMessageLength() { size_t BtUnchokeMessage::getMessageLength() {
return MESSAGE_LENGTH; return MESSAGE_LENGTH;
} }

10
src/BtUnchokeMessage.h
View File

@ -46,7 +46,7 @@ typedef SharedHandle<BtUnchokeMessage> BtUnchokeMessageHandle;
class BtUnchokeMessage : public SimpleBtMessage { class BtUnchokeMessage : public SimpleBtMessage {
private: private:
unsigned char* msg; unsigned char* msg;
static int32_t MESSAGE_LENGTH; static size_t MESSAGE_LENGTH;
public: public:
BtUnchokeMessage():msg(0) {} BtUnchokeMessage():msg(0) {}
@ -54,17 +54,17 @@ public:
delete [] msg; delete [] msg;
} }
static const int8_t ID = 1; static const uint8_t ID = 1;
static BtUnchokeMessageHandle create(const unsigned char* data, int32_t dataLength); static BtUnchokeMessageHandle create(const unsigned char* data, size_t dataLength);
virtual int8_t getId() { return ID; } virtual uint8_t getId() { return ID; }
virtual void doReceivedAction(); virtual void doReceivedAction();
virtual const unsigned char* getMessage(); virtual const unsigned char* getMessage();
virtual int32_t getMessageLength(); virtual size_t getMessageLength();
virtual std::string toString() const; virtual std::string toString() const;

14
src/ByteArrayDiskWriter.cc
View File

@ -47,27 +47,27 @@ void ByteArrayDiskWriter::clear()
} }
void ByteArrayDiskWriter::initAndOpenFile(const std::string& filename, void ByteArrayDiskWriter::initAndOpenFile(const std::string& filename,
int64_t totalLength) uint64_t totalLength)
{ {
clear(); clear();
} }
void ByteArrayDiskWriter::openFile(const std::string& filename, void ByteArrayDiskWriter::openFile(const std::string& filename,
int64_t totalLength) {} uint64_t totalLength) {}
void ByteArrayDiskWriter::closeFile() {} void ByteArrayDiskWriter::closeFile() {}
void ByteArrayDiskWriter::openExistingFile(const std::string& filename, void ByteArrayDiskWriter::openExistingFile(const std::string& filename,
int64_t totalLength) uint64_t totalLength)
{ {
openFile(filename); openFile(filename);
} }
void ByteArrayDiskWriter::writeData(const unsigned char* data, int32_t dataLength, int64_t position) void ByteArrayDiskWriter::writeData(const unsigned char* data, size_t dataLength, off_t position)
{ {
if(size() < position) { if(size() < (uint64_t)position) {
buf.seekp(size(), std::ios::beg); buf.seekp(size(), std::ios::beg);
for(int64_t i = size(); i < position; ++i) { for(uint64_t i = size(); i < (uint64_t)position; ++i) {
buf.put('\0'); buf.put('\0');
} }
} else { } else {
@ -76,7 +76,7 @@ void ByteArrayDiskWriter::writeData(const unsigned char* data, int32_t dataLengt
buf.write(reinterpret_cast<const char*>(data), dataLength); buf.write(reinterpret_cast<const char*>(data), dataLength);
} }
int32_t ByteArrayDiskWriter::readData(unsigned char* data, int32_t len, int64_t position) ssize_t ByteArrayDiskWriter::readData(unsigned char* data, size_t len, off_t position)
{ {
buf.seekg(position, std::ios::beg); buf.seekg(position, std::ios::beg);
buf.read(reinterpret_cast<char*>(data), len); buf.read(reinterpret_cast<char*>(data), len);

14
src/ByteArrayDiskWriter.h
View File

@ -49,21 +49,21 @@ public:
ByteArrayDiskWriter(); ByteArrayDiskWriter();
virtual ~ByteArrayDiskWriter(); virtual ~ByteArrayDiskWriter();
virtual void initAndOpenFile(const std::string& filename, int64_t totalLength = 0); virtual void initAndOpenFile(const std::string& filename, uint64_t totalLength = 0);
virtual void openFile(const std::string& filename, int64_t totalLength = 0); virtual void openFile(const std::string& filename, uint64_t totalLength = 0);
virtual void closeFile(); virtual void closeFile();
virtual void openExistingFile(const std::string& filename, int64_t totalLength = 0); virtual void openExistingFile(const std::string& filename, uint64_t totalLength = 0);
virtual void writeData(const unsigned char* data, int32_t len, int64_t position); virtual void writeData(const unsigned char* data, size_t len, off_t position);
virtual int32_t readData(unsigned char* data, int32_t len, int64_t position); virtual ssize_t readData(unsigned char* data, size_t len, off_t position);
// Not implemented yet // Not implemented yet
virtual void truncate(int64_t length) {} virtual void truncate(uint64_t length) {}
virtual int64_t size() const virtual uint64_t size() const
{ {
return buf.str().size(); return buf.str().size();
} }

4
src/CheckIntegrityEntry.cc
View File

@ -50,7 +50,7 @@ void CheckIntegrityEntry::validateChunk()
_validator->validateChunk(); _validator->validateChunk();
} }
int64_t CheckIntegrityEntry::getTotalLength() uint64_t CheckIntegrityEntry::getTotalLength()
{ {
if(_validator.isNull()) { if(_validator.isNull()) {
return 0; return 0;
@ -59,7 +59,7 @@ int64_t CheckIntegrityEntry::getTotalLength()
} }
} }
int64_t CheckIntegrityEntry::getCurrentLength() off_t CheckIntegrityEntry::getCurrentLength()
{ {
if(_validator.isNull()) { if(_validator.isNull()) {
return 0; return 0;

4
src/CheckIntegrityEntry.h
View File

@ -53,9 +53,9 @@ public:
virtual ~CheckIntegrityEntry(); virtual ~CheckIntegrityEntry();
virtual int64_t getTotalLength(); virtual uint64_t getTotalLength();
virtual int64_t getCurrentLength(); virtual off_t getCurrentLength();
virtual void validateChunk(); virtual void validateChunk();

2
src/CheckIntegrityMan.cc
View File

@ -68,7 +68,7 @@ CheckIntegrityEntryHandle CheckIntegrityMan::getFirstCheckIntegrityEntry() const
} }
} }
int32_t CheckIntegrityMan::countCheckIntegrityEntry() const size_t CheckIntegrityMan::countCheckIntegrityEntry() const
{ {
return _checkIntegrityEntries.size(); return _checkIntegrityEntries.size();
} }

2
src/CheckIntegrityMan.h
View File

@ -57,7 +57,7 @@ public:
SharedHandle<CheckIntegrityEntry> getFirstCheckIntegrityEntry() const; SharedHandle<CheckIntegrityEntry> getFirstCheckIntegrityEntry() const;
int32_t countCheckIntegrityEntry() const; size_t countCheckIntegrityEntry() const;
}; };
typedef SharedHandle<CheckIntegrityMan> CheckIntegrityManHandle; typedef SharedHandle<CheckIntegrityMan> CheckIntegrityManHandle;

22
src/ChunkChecksum.h
View File

@ -46,40 +46,40 @@ class ChunkChecksum {
private: private:
std::string _algo; std::string _algo;
std::deque<std::string> _checksums; std::deque<std::string> _checksums;
int32_t _checksumLength; size_t _checksumLength;
public: public:
ChunkChecksum():_checksumLength(0) {} ChunkChecksum():_checksumLength(0) {}
ChunkChecksum(const std::string& algo, ChunkChecksum(const std::string& algo,
const std::deque<std::string>& checksums, const std::deque<std::string>& checksums,
int32_t checksumLength): size_t checksumLength):
_algo(algo), _algo(algo),
_checksums(checksums), _checksums(checksums),
_checksumLength(checksumLength) {} _checksumLength(checksumLength) {}
bool validateChunk(const std::string& actualChecksum, bool validateChunk(const std::string& actualChecksum,
int32_t checksumIndex) const size_t checksumIndex) const
{ {
if(checksumIndex < (int32_t)_checksums.size()) { if(checksumIndex < _checksums.size()) {
return actualChecksum == getChecksum(checksumIndex); return actualChecksum == getChecksum(checksumIndex);
} else { } else {
return false; return false;
} }
} }
int64_t getEstimatedDataLength() const uint64_t getEstimatedDataLength() const
{ {
return ((int64_t)_checksumLength)*_checksums.size(); return ((uint64_t)_checksumLength)*_checksums.size();
} }
int32_t countChecksum() const size_t countChecksum() const
{ {
return _checksums.size(); return _checksums.size();
} }
std::string getChecksum(int32_t index) const std::string getChecksum(size_t index) const
{ {
if(index < (int32_t)_checksums.size()) { if(index < _checksums.size()) {
return _checksums[index]; return _checksums[index];
} else { } else {
return ""; return "";
@ -91,7 +91,7 @@ public:
return _checksums; return _checksums;
} }
int32_t getChecksumLength() const size_t getChecksumLength() const
{ {
return _checksumLength; return _checksumLength;
} }
@ -106,7 +106,7 @@ public:
_algo = algo; _algo = algo;
} }
void setChecksumLength(int32_t length) void setChecksumLength(size_t length)
{ {
_checksumLength = length; _checksumLength = length;
} }

30
src/ChunkedEncoding.cc
View File

@ -63,11 +63,11 @@ bool ChunkedEncoding::finished() {
void ChunkedEncoding::end() {} void ChunkedEncoding::end() {}
void ChunkedEncoding::inflate(unsigned char* outbuf, int32_t& outlen, void ChunkedEncoding::inflate(unsigned char* outbuf, size_t& outlen,
const unsigned char* inbuf, int32_t inlen) { const unsigned char* inbuf, size_t inlen) {
addBuffer(inbuf, inlen); addBuffer(inbuf, inlen);
unsigned char* p = strbuf; unsigned char* p = strbuf;
int32_t clen = 0; size_t clen = 0;
while(1) { while(1) {
if(state == READ_SIZE) { if(state == READ_SIZE) {
if(readChunkSize(&p) == 0) { if(readChunkSize(&p) == 0) {
@ -98,7 +98,7 @@ void ChunkedEncoding::inflate(unsigned char* outbuf, int32_t& outlen,
strbufTail = strbuf; strbufTail = strbuf;
} else { } else {
// copy string between [p, strbufTail] // copy string between [p, strbufTail]
int32_t unreadSize = strbufTail-p; size_t unreadSize = strbufTail-p;
unsigned char* temp = new unsigned char[strbufSize]; unsigned char* temp = new unsigned char[strbufSize];
memcpy(temp, p, unreadSize); memcpy(temp, p, unreadSize);
delete [] strbuf; delete [] strbuf;
@ -108,9 +108,9 @@ void ChunkedEncoding::inflate(unsigned char* outbuf, int32_t& outlen,
outlen = clen; outlen = clen;
} }
int32_t ChunkedEncoding::readData(unsigned char** pp, int ChunkedEncoding::readData(unsigned char** pp,
unsigned char* buf, int32_t& len, unsigned char* buf, size_t& len,
int32_t maxlen) size_t maxlen)
{ {
if(buf+len == buf+maxlen) { if(buf+len == buf+maxlen) {
return -1; return -1;
@ -118,11 +118,11 @@ int32_t ChunkedEncoding::readData(unsigned char** pp,
if(chunkSize == 0) { if(chunkSize == 0) {
return readDataEOL(pp); return readDataEOL(pp);
} }
int32_t wsize; size_t wsize;
if(strbufTail-*pp < chunkSize) { if((size_t)(strbufTail-*pp) < chunkSize) {
wsize = strbufTail-*pp <= maxlen-len ? strbufTail-*pp : maxlen-len; wsize = std::min((size_t)(strbufTail-*pp), maxlen-len);
} else { } else {
wsize = chunkSize <= maxlen-len ? chunkSize : maxlen-len; wsize = std::min(chunkSize, maxlen-len);
} }
memcpy(buf+len, *pp, wsize); memcpy(buf+len, *pp, wsize);
chunkSize -= wsize; chunkSize -= wsize;
@ -135,7 +135,7 @@ int32_t ChunkedEncoding::readData(unsigned char** pp,
} }
} }
int32_t ChunkedEncoding::readDataEOL(unsigned char** pp) { int ChunkedEncoding::readDataEOL(unsigned char** pp) {
unsigned char* np = reinterpret_cast<unsigned char*>(memchr(*pp, '\n', strbufTail-*pp)); unsigned char* np = reinterpret_cast<unsigned char*>(memchr(*pp, '\n', strbufTail-*pp));
unsigned char* rp = reinterpret_cast<unsigned char*>(memchr(*pp, '\r', strbufTail-*pp)); unsigned char* rp = reinterpret_cast<unsigned char*>(memchr(*pp, '\r', strbufTail-*pp));
if(np != NULL && rp != NULL && np-rp == 1 && *pp == rp) { if(np != NULL && rp != NULL && np-rp == 1 && *pp == rp) {
@ -148,7 +148,7 @@ int32_t ChunkedEncoding::readDataEOL(unsigned char** pp) {
} }
} }
int32_t ChunkedEncoding::readChunkSize(unsigned char** pp) { int ChunkedEncoding::readChunkSize(unsigned char** pp) {
// we read chunk-size from *pp // we read chunk-size from *pp
unsigned char* p; unsigned char* p;
unsigned char* np = reinterpret_cast<unsigned char*>(memchr(*pp, '\n', strbufTail-*pp)); unsigned char* np = reinterpret_cast<unsigned char*>(memchr(*pp, '\n', strbufTail-*pp));
@ -172,8 +172,8 @@ int32_t ChunkedEncoding::readChunkSize(unsigned char** pp) {
return 0; return 0;
} }
void ChunkedEncoding::addBuffer(const unsigned char* inbuf, int32_t inlen) { void ChunkedEncoding::addBuffer(const unsigned char* inbuf, size_t inlen) {
int32_t realbufSize = strbufTail-strbuf; size_t realbufSize = strbufTail-strbuf;
if(realbufSize+inlen >= strbufSize) { if(realbufSize+inlen >= strbufSize) {
if(realbufSize+inlen > MAX_BUFSIZE) { if(realbufSize+inlen > MAX_BUFSIZE) {
throw new DlAbortEx(EX_TOO_LARGE_CHUNK, realbufSize+inlen); throw new DlAbortEx(EX_TOO_LARGE_CHUNK, realbufSize+inlen);

20
src/ChunkedEncoding.h
View File

@ -46,21 +46,21 @@ private:
READ_DATA, READ_DATA,
FINISH FINISH
}; };
int32_t chunkSize; size_t chunkSize;
int32_t state; STATE state;
unsigned char* strbuf; unsigned char* strbuf;
int32_t strbufSize; size_t strbufSize;
unsigned char* strbufTail; unsigned char* strbufTail;
/** /**
* Returns 0 if the size of chunk is retrieved successfully, * Returns 0 if the size of chunk is retrieved successfully,
* otherwise returns non-zero value. * otherwise returns non-zero value.
*/ */
int32_t readChunkSize(unsigned char** pp); int readChunkSize(unsigned char** pp);
int32_t readData(unsigned char** pp, unsigned char* buf, int32_t& len, int readData(unsigned char** pp, unsigned char* buf, size_t& len,
int32_t maxlen); size_t maxlen);
void addBuffer(const unsigned char* inbuf, int32_t inlen); void addBuffer(const unsigned char* inbuf, size_t inlen);
int32_t readDataEOL(unsigned char** pp); int readDataEOL(unsigned char** pp);
public: public:
@ -68,8 +68,8 @@ public:
~ChunkedEncoding(); ~ChunkedEncoding();
void init(); void init();
void inflate(unsigned char* outbuf, int32_t& outlen, void inflate(unsigned char* outbuf, size_t& outlen,
const unsigned char* inbuf, int32_t inlen); const unsigned char* inbuf, size_t inlen);
bool finished(); bool finished();
void end(); void end();
}; };

6
src/CompactPeerListProcessor.cc
View File

@ -38,9 +38,7 @@
namespace aria2 { namespace aria2 {
CompactPeerListProcessor::CompactPeerListProcessor(int32_t pieceLength, int64_t totalLength): CompactPeerListProcessor::CompactPeerListProcessor() {}
pieceLength(pieceLength),
totalLength(totalLength) {}
CompactPeerListProcessor::~CompactPeerListProcessor() {} CompactPeerListProcessor::~CompactPeerListProcessor() {}
@ -55,7 +53,7 @@ Peers CompactPeerListProcessor::extractPeer(const MetaEntry* peersEntry) {
return peers; return peers;
} }
if(peersData->getLen()%6 == 0) { if(peersData->getLen()%6 == 0) {
for(int32_t i = 0; i < peersData->getLen(); i += 6) { for(size_t i = 0; i < peersData->getLen(); i += 6) {
struct in_addr in; struct in_addr in;
in.s_addr = *(uint32_t*)(peersData->getData()+i); in.s_addr = *(uint32_t*)(peersData->getData()+i);
std::string ipaddr = inet_ntoa(in); std::string ipaddr = inet_ntoa(in);

5
src/CompactPeerListProcessor.h
View File

@ -39,11 +39,8 @@
namespace aria2 { namespace aria2 {
class CompactPeerListProcessor : public PeerListProcessor { class CompactPeerListProcessor : public PeerListProcessor {
private:
int32_t pieceLength;
int64_t totalLength;
public: public:
CompactPeerListProcessor(int32_t pieceLength, int64_t totalLength); CompactPeerListProcessor();
virtual ~CompactPeerListProcessor(); virtual ~CompactPeerListProcessor();

2
src/ConsoleStatCalc.cc
View File

@ -63,7 +63,7 @@ ConsoleStatCalc::calculateStat(const RequestGroupManHandle& requestGroupMan,
if(requestGroupMan->countRequestGroup() > 0) { if(requestGroupMan->countRequestGroup() > 0) {
RequestGroupHandle firstRequestGroup = requestGroupMan->getRequestGroup(0); RequestGroupHandle firstRequestGroup = requestGroupMan->getRequestGroup(0);
TransferStat stat = firstRequestGroup->calculateStat(); TransferStat stat = firstRequestGroup->calculateStat();
int32_t eta = 0; unsigned int eta = 0;
if(firstRequestGroup->getTotalLength() > 0 && stat.getDownloadSpeed() > 0) { if(firstRequestGroup->getTotalLength() > 0 && stat.getDownloadSpeed() > 0) {
eta = (firstRequestGroup->getTotalLength()-firstRequestGroup->getCompletedLength())/stat.getDownloadSpeed(); eta = (firstRequestGroup->getTotalLength()-firstRequestGroup->getCompletedLength())/stat.getDownloadSpeed();
} }

2
src/CopyDiskAdaptor.cc
View File

@ -49,7 +49,7 @@ void CopyDiskAdaptor::onDownloadComplete()
void CopyDiskAdaptor::fixFilename() void CopyDiskAdaptor::fixFilename()
{ {
int64_t offset = 0; off_t offset = 0;
for(FileEntries::iterator itr = fileEntries.begin(); for(FileEntries::iterator itr = fileEntries.begin();
itr != fileEntries.end(); itr++) { itr != fileEntries.end(); itr++) {
if(!(*itr)->isExtracted() && (*itr)->isRequested()) { if(!(*itr)->isExtracted() && (*itr)->isRequested()) {

2
src/DHTAutoSaveCommand.cc
View File

@ -51,7 +51,7 @@
namespace aria2 { namespace aria2 {
DHTAutoSaveCommand::DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval): DHTAutoSaveCommand::DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, time_t interval):
TimeBasedCommand(cuid, e, interval), TimeBasedCommand(cuid, e, interval),
_localNode(0), _localNode(0),
_routingTable(0) {} _routingTable(0) {}

2
src/DHTAutoSaveCommand.h
View File

@ -52,7 +52,7 @@ private:
void save(); void save();
public: public:
DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, int32_t interval); DHTAutoSaveCommand(int32_t cuid, DownloadEngine* e, time_t interval);
virtual ~DHTAutoSaveCommand(); virtual ~DHTAutoSaveCommand();

2
src/DHTConnectionImpl.cc
View File

@ -62,7 +62,7 @@ uint16_t DHTConnectionImpl::bind(uint16_t port)
{ {
try { try {
_socket->bind(port); _socket->bind(port);
std::pair<std::string, int32_t> svaddr; std::pair<std::string, uint16_t> svaddr;
_socket->getAddrInfo(svaddr); _socket->getAddrInfo(svaddr);
_logger->info("Bind socket for DHT. port=%u", port); _logger->info("Bind socket for DHT. port=%u", port);
return svaddr.second; return svaddr.second;

2
src/DHTNode.cc
View File

@ -113,7 +113,7 @@ std::string DHTNode::toString() const
return "DHTNode ID="+Util::toHex(_id, DHT_ID_LENGTH)+ return "DHTNode ID="+Util::toHex(_id, DHT_ID_LENGTH)+
", Host="+_ipaddr+":"+Util::uitos(_port)+ ", Host="+_ipaddr+":"+Util::uitos(_port)+
", Condition="+Util::uitos(_condition)+ ", Condition="+Util::uitos(_condition)+
", RTT="+Util::itos(_rtt); ", RTT="+Util::uitos(_rtt);
} }
} // namespace aria2 } // namespace aria2

6
src/DHTNode.h
View File

@ -52,9 +52,9 @@ private:
uint16_t _port; uint16_t _port;
// in milli sec // in milli sec
int32_t _rtt; unsigned int _rtt;
uint32_t _condition; unsigned int _condition;
Time _lastContact; Time _lastContact;
public: public:
@ -72,7 +72,7 @@ public:
return _id; return _id;
} }
void updateRTT(int32_t millisec) void updateRTT(unsigned int millisec)
{ {
_rtt = millisec; _rtt = millisec;
} }

8
src/Data.cc
View File

@ -38,12 +38,12 @@
namespace aria2 { namespace aria2 {
Data::Data(const unsigned char* data, int32_t len, bool number):number(number) Data::Data(const unsigned char* data, size_t len, bool number):number(number)
{ {
init(data, len); init(data, len);
} }
Data::Data(const char* data, int32_t len, bool number):number(number) { Data::Data(const char* data, size_t len, bool number):number(number) {
init(reinterpret_cast<const unsigned char*>(data), len); init(reinterpret_cast<const unsigned char*>(data), len);
} }
@ -52,7 +52,7 @@ Data::Data(const std::string& data, bool number):number(number)
init(reinterpret_cast<const unsigned char*>(data.c_str()), data.size()); init(reinterpret_cast<const unsigned char*>(data.c_str()), data.size());
} }
void Data::init(const unsigned char* src, int32_t slen) void Data::init(const unsigned char* src, size_t slen)
{ {
if(src) { if(src) {
data = new unsigned char[slen]; data = new unsigned char[slen];
@ -80,7 +80,7 @@ const unsigned char* Data::getData() const {
} }
} }
int32_t Data::getLen() const { size_t Data::getLen() const {
return len; return len;
} }

10
src/Data.h
View File

@ -42,19 +42,19 @@ namespace aria2 {
class Data : public MetaEntry { class Data : public MetaEntry {
private: private:
int32_t len; size_t len;
unsigned char* data; unsigned char* data;
bool number; bool number;
void init(const unsigned char* data, int32_t len); void init(const unsigned char* data, size_t len);
public: public:
/** /**
* This class stores the copy of data. So caller must take care of freeing * This class stores the copy of data. So caller must take care of freeing
* memory of data. * memory of data.
*/ */
Data(const char* data, int32_t len, bool number = false); Data(const char* data, size_t len, bool number = false);
Data(const unsigned char* data, int32_t len, bool number = false); Data(const unsigned char* data, size_t len, bool number = false);
Data(const std::string& data, bool number = false); Data(const std::string& data, bool number = false);
@ -65,7 +65,7 @@ public:
int64_t toLLInt() const; int64_t toLLInt() const;
const unsigned char* getData() const; const unsigned char* getData() const;
int32_t getLen() const; size_t getLen() const;
bool isNumber() const; bool isNumber() const;
void accept(MetaEntryVisitor* v) const; void accept(MetaEntryVisitor* v) const;

24
src/DefaultBtAnnounce.cc
View File

@ -129,13 +129,12 @@ std::string DefaultBtAnnounce::getAnnounceUrl() {
} else { } else {
return ""; return "";
} }
int32_t numWant = 50; unsigned int numWant = 50;
if(!btRuntime->lessThanEqMinPeer() || if(!btRuntime->lessThanEqMinPeer() || btRuntime->isHalt()) {
btRuntime->isHalt()) {
numWant = 0; numWant = 0;
} }
TransferStat stat = peerStorage->calculateStat(); TransferStat stat = peerStorage->calculateStat();
int64_t left = pieceStorage->getTotalLength()-pieceStorage->getCompletedLength(); uint64_t left = pieceStorage->getTotalLength()-pieceStorage->getCompletedLength();
if(left < 0) { if(left < 0) {
left = 0; left = 0;
} }
@ -143,15 +142,15 @@ std::string DefaultBtAnnounce::getAnnounceUrl() {
"info_hash="+Util::torrentUrlencode(btContext->getInfoHash(), "info_hash="+Util::torrentUrlencode(btContext->getInfoHash(),
btContext->getInfoHashLength())+"&"+ btContext->getInfoHashLength())+"&"+
"peer_id="+Util::torrentUrlencode(btContext->getPeerId(), 20)+"&"+ "peer_id="+Util::torrentUrlencode(btContext->getPeerId(), 20)+"&"+
"uploaded="+Util::itos(stat.getSessionUploadLength())+"&"+ "uploaded="+Util::uitos(stat.getSessionUploadLength())+"&"+
"downloaded="+Util::itos(stat.getSessionDownloadLength())+"&"+ "downloaded="+Util::uitos(stat.getSessionDownloadLength())+"&"+
"left="+Util::itos(left)+"&"+ "left="+Util::uitos(left)+"&"+
"compact=1"+"&"+ "compact=1"+"&"+
"key="+key+"&"+ "key="+key+"&"+
"numwant="+Util::itos(numWant)+"&"+ "numwant="+Util::uitos(numWant)+"&"+
"no_peer_id=1"; "no_peer_id=1";
if(btRuntime->getListenPort() > 0) { if(btRuntime->getListenPort() > 0) {
url += std::string("&")+"port="+Util::itos(btRuntime->getListenPort()); url += std::string("&")+"port="+Util::uitos(btRuntime->getListenPort());
} }
std::string event = announceList.getEventString(); std::string event = announceList.getEventString();
if(!event.empty()) { if(!event.empty()) {
@ -218,7 +217,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
} }
const Data* intervalData = dynamic_cast<const Data*>(response->get("interval")); const Data* intervalData = dynamic_cast<const Data*>(response->get("interval"));
if(intervalData) { if(intervalData) {
int32_t t = intervalData->toInt(); time_t t = intervalData->toInt();
if(t > 0) { if(t > 0) {
interval = intervalData->toInt(); interval = intervalData->toInt();
logger->debug("Interval:%d", interval); logger->debug("Interval:%d", interval);
@ -226,7 +225,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
} }
const Data* minIntervalData = dynamic_cast<const Data*>(response->get("min interval")); const Data* minIntervalData = dynamic_cast<const Data*>(response->get("min interval"));
if(minIntervalData) { if(minIntervalData) {
int32_t t = minIntervalData->toInt(); time_t t = minIntervalData->toInt();
if(t > 0) { if(t > 0) {
minInterval = minIntervalData->toInt(); minInterval = minIntervalData->toInt();
logger->debug("Min interval:%d", minInterval); logger->debug("Min interval:%d", minInterval);
@ -249,8 +248,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
if(peersEntry && if(peersEntry &&
!btRuntime->isHalt() && !btRuntime->isHalt() &&
btRuntime->lessThanMinPeer()) { btRuntime->lessThanMinPeer()) {
DelegatingPeerListProcessor proc(btContext->getPieceLength(), DelegatingPeerListProcessor proc;
btContext->getTotalLength());
Peers peers = proc.extractPeer(peersEntry); Peers peers = proc.extractPeer(peersEntry);
peerStorage->addPeer(peers); peerStorage->addPeer(peers);
} }

18
src/DefaultBtAnnounce.h
View File

@ -54,12 +54,12 @@ class Randomizer;
class DefaultBtAnnounce : public BtAnnounce { class DefaultBtAnnounce : public BtAnnounce {
private: private:
SharedHandle<BtContext> btContext; SharedHandle<BtContext> btContext;
int32_t trackers; unsigned int trackers;
Time prevAnnounceTime; Time prevAnnounceTime;
int32_t interval; time_t interval;
int32_t minInterval; time_t minInterval;
int32_t complete; unsigned int complete;
int32_t incomplete; unsigned int incomplete;
AnnounceList announceList; AnnounceList announceList;
std::string trackerId; std::string trackerId;
std::string key; std::string key;
@ -118,22 +118,22 @@ public:
void setRandomizer(const SharedHandle<Randomizer>& randomizer); void setRandomizer(const SharedHandle<Randomizer>& randomizer);
int32_t getInterval() const time_t getInterval() const
{ {
return interval; return interval;
} }
int32_t getMinInterval() const time_t getMinInterval() const
{ {
return minInterval; return minInterval;
} }
int32_t getComplete() const unsigned int getComplete() const
{ {
return complete; return complete;
} }
int32_t getIncomplete() const unsigned int getIncomplete() const
{ {
return incomplete; return incomplete;
} }

4
src/DefaultBtContext.cc
View File

@ -101,8 +101,8 @@ void DefaultBtContext::clear() {
void DefaultBtContext::extractPieceHash(const unsigned char* hashData, void DefaultBtContext::extractPieceHash(const unsigned char* hashData,
size_t hashDataLength, size_t hashDataLength,
size_t hashLength) { size_t hashLength) {
int32_t numPieces = hashDataLength/hashLength; size_t numPieces = hashDataLength/hashLength;
for(int32_t i = 0; i < numPieces; i++) { for(size_t i = 0; i < numPieces; i++) {
pieceHashes.push_back(Util::toHex(&hashData[i*hashLength], pieceHashes.push_back(Util::toHex(&hashData[i*hashLength],
hashLength)); hashLength));
} }

12
src/DefaultBtInteractive.cc
View File

@ -281,7 +281,7 @@ void DefaultBtInteractive::decideInterest() {
} }
} }
void DefaultBtInteractive::fillPiece(int maxPieceNum) { void DefaultBtInteractive::fillPiece(size_t maxPieceNum) {
if(pieceStorage->hasMissingPiece(peer)) { if(pieceStorage->hasMissingPiece(peer)) {
if(peer->peerChoking()) { if(peer->peerChoking()) {
if(peer->isFastExtensionEnabled()) { if(peer->isFastExtensionEnabled()) {
@ -308,7 +308,7 @@ void DefaultBtInteractive::fillPiece(int maxPieceNum) {
} }
void DefaultBtInteractive::addRequests() { void DefaultBtInteractive::addRequests() {
int32_t MAX_PENDING_REQUEST; size_t MAX_PENDING_REQUEST;
if(peer->getLatency() < 500) { if(peer->getLatency() < 500) {
MAX_PENDING_REQUEST = 24; MAX_PENDING_REQUEST = 24;
} else if(peer->getLatency() < 1500) { } else if(peer->getLatency() < 1500) {
@ -316,16 +316,16 @@ void DefaultBtInteractive::addRequests() {
} else { } else {
MAX_PENDING_REQUEST = 6; MAX_PENDING_REQUEST = 6;
} }
int32_t pieceNum; size_t pieceNum;
if(pieceStorage->isEndGame()) { if(pieceStorage->isEndGame()) {
pieceNum = 1; pieceNum = 1;
} else { } else {
int32_t blocks = DIV_FLOOR(btContext->getPieceLength(), Piece::BLOCK_LENGTH); size_t blocks = DIV_FLOOR(btContext->getPieceLength(), Piece::BLOCK_LENGTH);
pieceNum = DIV_FLOOR(MAX_PENDING_REQUEST, blocks); pieceNum = DIV_FLOOR(MAX_PENDING_REQUEST, blocks);
} }
fillPiece(pieceNum); fillPiece(pieceNum);
int32_t reqNumToCreate = size_t reqNumToCreate =
MAX_PENDING_REQUEST <= dispatcher->countOutstandingRequest() ? MAX_PENDING_REQUEST <= dispatcher->countOutstandingRequest() ?
0 : MAX_PENDING_REQUEST-dispatcher->countOutstandingRequest(); 0 : MAX_PENDING_REQUEST-dispatcher->countOutstandingRequest();
if(reqNumToCreate > 0) { if(reqNumToCreate > 0) {
@ -453,7 +453,7 @@ void DefaultBtInteractive::setLocalNode(const WeakHandle<DHTNode>& node)
_localNode = node; _localNode = node;
} }
int32_t DefaultBtInteractive::countPendingMessage() size_t DefaultBtInteractive::countPendingMessage()
{ {
return dispatcher->countMessageInQueue(); return dispatcher->countMessageInQueue();
} }

29
src/DefaultBtInteractive.h
View File

@ -38,6 +38,7 @@
#include "BtInteractive.h" #include "BtInteractive.h"
#include "BtContextAwareCommand.h" #include "BtContextAwareCommand.h"
#include "TimeA2.h" #include "TimeA2.h"
#include <limits.h>
namespace aria2 { namespace aria2 {
@ -53,28 +54,28 @@ class Logger;
class FloodingStat { class FloodingStat {
private: private:
int32_t chokeUnchokeCount; unsigned int chokeUnchokeCount;
int32_t keepAliveCount; unsigned int keepAliveCount;
public: public:
FloodingStat():chokeUnchokeCount(0), keepAliveCount(0) {} FloodingStat():chokeUnchokeCount(0), keepAliveCount(0) {}
void incChokeUnchokeCount() { void incChokeUnchokeCount() {
if(chokeUnchokeCount < INT32_MAX) { if(chokeUnchokeCount < UINT_MAX) {
chokeUnchokeCount++; chokeUnchokeCount++;
} }
} }
void incKeepAliveCount() { void incKeepAliveCount() {
if(keepAliveCount < INT32_MAX) { if(keepAliveCount < UINT_MAX) {
keepAliveCount++; keepAliveCount++;
} }
} }
int32_t getChokeUnchokeCount() const { unsigned int getChokeUnchokeCount() const {
return chokeUnchokeCount; return chokeUnchokeCount;
} }
int32_t getKeepAliveCount() const { unsigned int getKeepAliveCount() const {
return keepAliveCount; return keepAliveCount;
} }
@ -98,21 +99,21 @@ private:
WeakHandle<DHTNode> _localNode; WeakHandle<DHTNode> _localNode;
const Logger* logger; const Logger* logger;
int32_t allowedFastSetSize; size_t allowedFastSetSize;
Time haveCheckPoint; Time haveCheckPoint;
Time keepAliveCheckPoint; Time keepAliveCheckPoint;
Time floodingCheckPoint; Time floodingCheckPoint;
FloodingStat floodingStat; FloodingStat floodingStat;
Time inactiveCheckPoint; Time inactiveCheckPoint;
Time _pexCheckPoint; Time _pexCheckPoint;
int32_t keepAliveInterval; time_t keepAliveInterval;
int32_t maxDownloadSpeedLimit; unsigned int maxDownloadSpeedLimit;
bool _utPexEnabled; bool _utPexEnabled;
bool _dhtEnabled; bool _dhtEnabled;
size_t _numReceivedMessage; size_t _numReceivedMessage;
static const int32_t FLOODING_CHECK_INTERVAL = 5; static const time_t FLOODING_CHECK_INTERVAL = 5;
void addBitfieldMessageToQueue(); void addBitfieldMessageToQueue();
void addAllowedFastMessageToQueue(); void addAllowedFastMessageToQueue();
@ -121,7 +122,7 @@ private:
void checkHave(); void checkHave();
void sendKeepAlive(); void sendKeepAlive();
void decideInterest(); void decideInterest();
void fillPiece(int maxPieceNum); void fillPiece(size_t maxPieceNum);
void addRequests(); void addRequests();
void detectMessageFlooding(); void detectMessageFlooding();
void checkActiveInteraction(); void checkActiveInteraction();
@ -150,7 +151,7 @@ public:
size_t receiveMessages(); size_t receiveMessages();
virtual int32_t countPendingMessage(); virtual size_t countPendingMessage();
virtual bool isSendingMessageInProgress(); virtual bool isSendingMessageInProgress();
@ -174,11 +175,11 @@ public:
void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory); void setBtMessageFactory(const WeakHandle<BtMessageFactory>& factory);
void setKeepAliveInterval(int32_t keepAliveInterval) { void setKeepAliveInterval(time_t keepAliveInterval) {
this->keepAliveInterval = keepAliveInterval; this->keepAliveInterval = keepAliveInterval;
} }
void setMaxDownloadSpeedLimit(int32_t maxDownloadSpeedLimit) { void setMaxDownloadSpeedLimit(unsigned int maxDownloadSpeedLimit) {
this->maxDownloadSpeedLimit = maxDownloadSpeedLimit; this->maxDownloadSpeedLimit = maxDownloadSpeedLimit;
} }

8
src/DefaultBtMessageDispatcher.cc
View File

@ -105,7 +105,7 @@ void DefaultBtMessageDispatcher::sendMessages() {
} }
// Cancel sending piece message to peer. // Cancel sending piece message to peer.
void DefaultBtMessageDispatcher::doCancelSendingPieceAction(int32_t index, int32_t begin, int32_t length) void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32_t begin, size_t length)
{ {
BtCancelSendingPieceEventHandle event = BtCancelSendingPieceEventHandle event =
new BtCancelSendingPieceEvent(index, begin, length); new BtCancelSendingPieceEvent(index, begin, length);
@ -222,12 +222,12 @@ bool DefaultBtMessageDispatcher::isSendingInProgress()
} }
} }
int32_t DefaultBtMessageDispatcher::countOutstandingRequest() size_t DefaultBtMessageDispatcher::countOutstandingRequest()
{ {
return requestSlots.size(); return requestSlots.size();
} }
bool DefaultBtMessageDispatcher::isOutstandingRequest(int32_t index, int32_t blockIndex) { bool DefaultBtMessageDispatcher::isOutstandingRequest(size_t index, size_t blockIndex) {
for(RequestSlots::const_iterator itr = requestSlots.begin(); for(RequestSlots::const_iterator itr = requestSlots.begin();
itr != requestSlots.end(); itr++) { itr != requestSlots.end(); itr++) {
const RequestSlot& slot = *itr; const RequestSlot& slot = *itr;
@ -239,7 +239,7 @@ bool DefaultBtMessageDispatcher::isOutstandingRequest(int32_t index, int32_t blo
} }
RequestSlot RequestSlot
DefaultBtMessageDispatcher::getOutstandingRequest(int32_t index, int32_t begin, int32_t length) DefaultBtMessageDispatcher::getOutstandingRequest(size_t index, uint32_t begin, size_t length)
{ {
for(RequestSlots::iterator itr = requestSlots.begin(); for(RequestSlots::iterator itr = requestSlots.begin();
itr != requestSlots.end(); itr++) { itr != requestSlots.end(); itr++) {

18
src/DefaultBtMessageDispatcher.h
View File

@ -58,8 +58,8 @@ private:
SharedHandle<PieceStorage> pieceStorage; SharedHandle<PieceStorage> pieceStorage;
WeakHandle<BtMessageFactory> messageFactory; WeakHandle<BtMessageFactory> messageFactory;
SharedHandle<Peer> peer; SharedHandle<Peer> peer;
int32_t maxUploadSpeedLimit; unsigned int maxUploadSpeedLimit;
int32_t requestTimeout; time_t requestTimeout;
const Logger* logger; const Logger* logger;
public: public:
DefaultBtMessageDispatcher(); DefaultBtMessageDispatcher();
@ -72,7 +72,7 @@ public:
virtual void sendMessages(); virtual void sendMessages();
virtual void doCancelSendingPieceAction(int32_t index, int32_t begin, int32_t length); virtual void doCancelSendingPieceAction(size_t index, uint32_t begin, size_t length);
virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece); virtual void doCancelSendingPieceAction(const SharedHandle<Piece>& piece);
@ -86,15 +86,15 @@ public:
virtual bool isSendingInProgress(); virtual bool isSendingInProgress();
virtual int32_t countMessageInQueue() { virtual size_t countMessageInQueue() {
return messageQueue.size(); return messageQueue.size();
} }
virtual int32_t countOutstandingRequest(); virtual size_t countOutstandingRequest();
virtual bool isOutstandingRequest(int32_t index, int32_t blockIndex); virtual bool isOutstandingRequest(size_t index, size_t blockIndex);
virtual RequestSlot getOutstandingRequest(int32_t index, int32_t begin, int32_t length); virtual RequestSlot getOutstandingRequest(size_t index, uint32_t begin, size_t length);
virtual void removeOutstandingRequest(const RequestSlot& slot); virtual void removeOutstandingRequest(const RequestSlot& slot);
@ -114,11 +114,11 @@ public:
this->cuid = cuid; this->cuid = cuid;
} }
void setMaxUploadSpeedLimit(int32_t maxUploadSpeedLimit) { void setMaxUploadSpeedLimit(unsigned int maxUploadSpeedLimit) {
this->maxUploadSpeedLimit = maxUploadSpeedLimit; this->maxUploadSpeedLimit = maxUploadSpeedLimit;
} }
void setRequestTimeout(int32_t requestTimeout) { void setRequestTimeout(time_t requestTimeout) {
this->requestTimeout = requestTimeout; this->requestTimeout = requestTimeout;
} }

20
src/DefaultBtMessageFactory.cc
View File

@ -81,14 +81,14 @@ DefaultBtMessageFactory::DefaultBtMessageFactory():cuid(0),
DefaultBtMessageFactory::~DefaultBtMessageFactory() {} DefaultBtMessageFactory::~DefaultBtMessageFactory() {}
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createBtMessage(const unsigned char* data, int32_t dataLength) DefaultBtMessageFactory::createBtMessage(const unsigned char* data, size_t dataLength)
{ {
AbstractBtMessageHandle msg(0); AbstractBtMessageHandle msg(0);
if(dataLength == 0) { if(dataLength == 0) {
// keep-alive // keep-alive
msg = new BtKeepAliveMessage(); msg = new BtKeepAliveMessage();
} else { } else {
int8_t id = PeerMessageUtil::getId(data); uint8_t id = PeerMessageUtil::getId(data);
switch(id) { switch(id) {
case BtChokeMessage::ID: case BtChokeMessage::ID:
msg = BtChokeMessage::create(data, dataLength); msg = BtChokeMessage::create(data, dataLength);
@ -194,7 +194,7 @@ DefaultBtMessageFactory::createBtMessage(const unsigned char* data, int32_t data
break; break;
} }
default: default:
throw new DlAbortEx("Invalid message ID. id=%d", id); throw new DlAbortEx("Invalid message ID. id=%u", id);
} }
} }
setCommonProperty(msg); setCommonProperty(msg);
@ -212,7 +212,7 @@ void DefaultBtMessageFactory::setCommonProperty(const AbstractBtMessageHandle& m
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* data, int32_t dataLength) DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* data, size_t dataLength)
{ {
SharedHandle<BtHandshakeMessage> msg = BtHandshakeMessage::create(data, dataLength); SharedHandle<BtHandshakeMessage> msg = BtHandshakeMessage::create(data, dataLength);
BtMessageValidatorHandle validator = BtMessageValidatorHandle validator =
@ -238,7 +238,7 @@ DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createRequestMessage(const PieceHandle& piece, int32_t blockIndex) DefaultBtMessageFactory::createRequestMessage(const PieceHandle& piece, size_t blockIndex)
{ {
BtRequestMessageHandle msg = BtRequestMessageHandle msg =
new BtRequestMessage(piece->getIndex(), new BtRequestMessage(piece->getIndex(),
@ -255,7 +255,7 @@ DefaultBtMessageFactory::createRequestMessage(const PieceHandle& piece, int32_t
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createCancelMessage(int32_t index, int32_t begin, int32_t length) DefaultBtMessageFactory::createCancelMessage(size_t index, uint32_t begin, size_t length)
{ {
BtCancelMessageHandle msg = new BtCancelMessage(index, begin, length); BtCancelMessageHandle msg = new BtCancelMessage(index, begin, length);
BtMessageValidatorHandle validator = BtMessageValidatorHandle validator =
@ -268,7 +268,7 @@ DefaultBtMessageFactory::createCancelMessage(int32_t index, int32_t begin, int32
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createPieceMessage(int32_t index, int32_t begin, int32_t length) DefaultBtMessageFactory::createPieceMessage(size_t index, uint32_t begin, size_t length)
{ {
BtPieceMessageHandle msg = new BtPieceMessage(index, begin, length); BtPieceMessageHandle msg = new BtPieceMessage(index, begin, length);
BtMessageValidatorHandle validator = BtMessageValidatorHandle validator =
@ -281,7 +281,7 @@ DefaultBtMessageFactory::createPieceMessage(int32_t index, int32_t begin, int32_
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createHaveMessage(int32_t index) DefaultBtMessageFactory::createHaveMessage(size_t index)
{ {
BtHaveMessageHandle msg = new BtHaveMessage(index); BtHaveMessageHandle msg = new BtHaveMessage(index);
msg->setBtMessageValidator(new BtHaveMessageValidator(msg.get(), msg->setBtMessageValidator(new BtHaveMessageValidator(msg.get(),
@ -359,7 +359,7 @@ DefaultBtMessageFactory::createHaveNoneMessage()
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createRejectMessage(int32_t index, int32_t begin, int32_t length) DefaultBtMessageFactory::createRejectMessage(size_t index, uint32_t begin, size_t length)
{ {
BtRejectMessageHandle msg = new BtRejectMessage(index, begin, length); BtRejectMessageHandle msg = new BtRejectMessage(index, begin, length);
BtMessageValidatorHandle validator = BtMessageValidatorHandle validator =
@ -372,7 +372,7 @@ DefaultBtMessageFactory::createRejectMessage(int32_t index, int32_t begin, int32
} }
BtMessageHandle BtMessageHandle
DefaultBtMessageFactory::createAllowedFastMessage(int32_t index) DefaultBtMessageFactory::createAllowedFastMessage(size_t index)
{ {
BtAllowedFastMessageHandle msg = new BtAllowedFastMessage(index); BtAllowedFastMessageHandle msg = new BtAllowedFastMessage(index);
BtMessageValidatorHandle validator = BtMessageValidatorHandle validator =

16
src/DefaultBtMessageFactory.h
View File

@ -81,25 +81,25 @@ public:
virtual ~DefaultBtMessageFactory(); virtual ~DefaultBtMessageFactory();
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createBtMessage(const unsigned char* msg, int32_t msgLength); createBtMessage(const unsigned char* msg, size_t msgLength);
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createHandshakeMessage(const unsigned char* msg, int32_t msgLength); createHandshakeMessage(const unsigned char* msg, size_t msgLength);
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createHandshakeMessage(const unsigned char* infoHash, createHandshakeMessage(const unsigned char* infoHash,
const unsigned char* peerId); const unsigned char* peerId);
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createRequestMessage(const SharedHandle<Piece>& piece, int32_t blockIndex); createRequestMessage(const SharedHandle<Piece>& piece, size_t blockIndex);
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createCancelMessage(int32_t index, int32_t begin, int32_t length); createCancelMessage(size_t index, uint32_t begin, size_t length);
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createPieceMessage(int32_t index, int32_t begin, int32_t length); createPieceMessage(size_t index, uint32_t begin, size_t length);
virtual SharedHandle<BtMessage> createHaveMessage(int32_t index); virtual SharedHandle<BtMessage> createHaveMessage(size_t index);
virtual SharedHandle<BtMessage> createChokeMessage(); virtual SharedHandle<BtMessage> createChokeMessage();
@ -118,9 +118,9 @@ public:
virtual SharedHandle<BtMessage> createHaveNoneMessage(); virtual SharedHandle<BtMessage> createHaveNoneMessage();
virtual SharedHandle<BtMessage> virtual SharedHandle<BtMessage>
createRejectMessage(int32_t index, int32_t begin, int32_t length); createRejectMessage(size_t index, uint32_t begin, size_t length);
virtual SharedHandle<BtMessage> createAllowedFastMessage(int32_t index); virtual SharedHandle<BtMessage> createAllowedFastMessage(size_t index);
virtual SharedHandle<BtMessage> createPortMessage(uint16_t port); virtual SharedHandle<BtMessage> createPortMessage(uint16_t port);

4
src/DefaultBtMessageReceiver.cc
View File

@ -66,7 +66,7 @@ DefaultBtMessageReceiver::~DefaultBtMessageReceiver()
BtMessageHandle DefaultBtMessageReceiver::receiveHandshake(bool quickReply) { BtMessageHandle DefaultBtMessageReceiver::receiveHandshake(bool quickReply) {
unsigned char data[BtHandshakeMessage::MESSAGE_LENGTH]; unsigned char data[BtHandshakeMessage::MESSAGE_LENGTH];
int32_t dataLength = BtHandshakeMessage::MESSAGE_LENGTH; size_t dataLength = BtHandshakeMessage::MESSAGE_LENGTH;
bool retval = peerConnection->receiveHandshake(data, dataLength); bool retval = peerConnection->receiveHandshake(data, dataLength);
// To handle tracker's NAT-checking feature // To handle tracker's NAT-checking feature
if(!handshakeSent && quickReply && dataLength >= 48) { if(!handshakeSent && quickReply && dataLength >= 48) {
@ -99,7 +99,7 @@ void DefaultBtMessageReceiver::sendHandshake() {
BtMessageHandle DefaultBtMessageReceiver::receiveMessage() { BtMessageHandle DefaultBtMessageReceiver::receiveMessage() {
unsigned char data[MAX_PAYLOAD_LEN]; unsigned char data[MAX_PAYLOAD_LEN];
int32_t dataLength = 0; size_t dataLength = 0;
if(!peerConnection->receiveMessage(data, dataLength)) { if(!peerConnection->receiveMessage(data, dataLength)) {
return 0; return 0;
} }

2
src/DefaultBtRequestFactory.h
View File

@ -66,7 +66,7 @@ public:
virtual void removeAllTargetPiece(); virtual void removeAllTargetPiece();
virtual int32_t countTargetPiece() { virtual size_t countTargetPiece() {
return pieces.size(); return pieces.size();
} }

Some files were not shown because too many files have changed in this diff Show More