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

2009-05-18 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 

Added source filename(__FILE__) and line number(__LINE__) to
	exception message.	
	* src/AbstractCommand.cc
	* src/AbstractDiskWriter.cc
	* src/AbstractProxyResponseCommand.cc
	* src/BDE.h
	* src/BtAllowedFastMessage.cc
	* src/BtHandshakeMessageValidator.h
	* src/BtHaveAllMessage.cc
	* src/BtHaveNoneMessage.cc
	* src/BtPieceMessage.cc
	* src/BtRejectMessage.cc
	* src/ChunkedDecoder.cc
	* src/CookieStorage.cc
	* src/DHTAnnouncePeerMessage.cc
	* src/DHTEntryPointNameResolveCommand.cc
	* src/DHTMessageFactoryImpl.cc
	* src/DHTMessageTracker.cc
	* src/DHTRoutingTableDeserializer.cc
	* src/DHTRoutingTableSerializer.cc
	* src/DHTSetup.cc
	* src/DHTTokenTracker.cc
	* src/DefaultBtAnnounce.cc
	* src/DefaultBtContext.cc
	* src/DefaultBtInteractive.cc
	* src/DefaultBtMessageFactory.cc
	* src/DefaultBtProgressInfoFile.cc
	* src/DefaultExtensionMessageFactory.cc
	* src/DlAbortEx.h
	* src/DlRetryEx.h
	* src/DownloadCommand.cc
	* src/DownloadEngineFactory.cc
	* src/DownloadFailureException.h
	* src/Exception.cc
	* src/Exception.h
	* src/ExpatMetalinkProcessor.cc
	* src/ExpatXmlRpcRequestProcessor.cc
	* src/FallocFileAllocationIterator.cc
	* src/FatalException.h
	* src/FtpConnection.cc
	* src/FtpFinishDownloadCommand.cc
	* src/FtpInitiateConnectionCommand.cc
	* src/FtpNegotiationCommand.cc
	* src/GZipDecoder.cc
	* src/HandshakeExtensionMessage.cc
	* src/HttpConnection.cc
	* src/HttpHeaderProcessor.cc
	* src/HttpInitiateConnectionCommand.cc
	* src/HttpResponse.cc
	* src/HttpResponseCommand.cc
	* src/HttpServer.cc
	* src/HttpSkipResponseCommand.cc
	* src/InitiateConnectionCommandFactory.cc
	* src/IteratableChunkChecksumValidator.cc
	* src/LibgcryptARC4Context.h
	* src/LibgcryptARC4Decryptor.h
	* src/LibgcryptARC4Encryptor.h
	* src/LibgcryptDHKeyExchange.h
	* src/LibgnutlsTLSContext.cc
	* src/LibsslARC4Context.h
	* src/LibsslARC4Decryptor.h
	* src/LibsslARC4Encryptor.h
	* src/LibsslDHKeyExchange.h
	* src/LibsslTLSContext.cc
	* src/MSEHandshake.cc
	* src/MessageDigestHelper.cc
	* src/MetalinkHelper.cc
	* src/MultiDiskAdaptor.cc
	* src/NameMatchOptionHandler.h
	* src/NameResolver.cc
	* src/Netrc.cc
	* src/NsCookieParser.cc
	* src/OptionHandlerException.cc
	* src/OptionHandlerException.h
	* src/OptionHandlerImpl.h
	* src/OptionParser.cc
	* src/ParameterizedStringParser.cc
	* src/PeerAbstractCommand.cc
	* src/PeerConnection.cc
	* src/PeerMessageUtil.cc
	* src/PeerReceiveHandshakeCommand.cc
	* src/Platform.cc
	* src/ReceiverMSEHandshakeCommand.cc
	* src/RecoverableException.h
	* src/RequestGroup.cc
	* src/SimpleLogger.cc
	* src/SocketCore.cc
	* src/Sqlite3MozCookieParser.cc
	* src/UTPexExtensionMessage.cc
	* src/Util.cc
	* src/XML2SAXMetalinkProcessor.cc
	* src/Xml2XmlRpcRequestProcessor.cc
	* src/XmlRpcMethodImpl.cc
	* src/bencode.cc
	* src/download_helper.cc
	* src/messageDigest.h
	* test/ExceptionTest.cc
	* test/TestUtil.cc
pull/1/head
Tatsuhiro Tsujikawa 2009-05-18 15:07:15 +00:00
parent ff83fc65df
commit 20e215047c
97 changed files with 638 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
ChangeLog
View File

@ -1,3 +1,104 @@
2009-05-18 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Added source filename(__FILE__) and line number(__LINE__) to
exception message.
* src/AbstractCommand.cc
* src/AbstractDiskWriter.cc
* src/AbstractProxyResponseCommand.cc
* src/BDE.h
* src/BtAllowedFastMessage.cc
* src/BtHandshakeMessageValidator.h
* src/BtHaveAllMessage.cc
* src/BtHaveNoneMessage.cc
* src/BtPieceMessage.cc
* src/BtRejectMessage.cc
* src/ChunkedDecoder.cc
* src/CookieStorage.cc
* src/DHTAnnouncePeerMessage.cc
* src/DHTEntryPointNameResolveCommand.cc
* src/DHTMessageFactoryImpl.cc
* src/DHTMessageTracker.cc
* src/DHTRoutingTableDeserializer.cc
* src/DHTRoutingTableSerializer.cc
* src/DHTSetup.cc
* src/DHTTokenTracker.cc
* src/DefaultBtAnnounce.cc
* src/DefaultBtContext.cc
* src/DefaultBtInteractive.cc
* src/DefaultBtMessageFactory.cc
* src/DefaultBtProgressInfoFile.cc
* src/DefaultExtensionMessageFactory.cc
* src/DlAbortEx.h
* src/DlRetryEx.h
* src/DownloadCommand.cc
* src/DownloadEngineFactory.cc
* src/DownloadFailureException.h
* src/Exception.cc
* src/Exception.h
* src/ExpatMetalinkProcessor.cc
* src/ExpatXmlRpcRequestProcessor.cc
* src/FallocFileAllocationIterator.cc
* src/FatalException.h
* src/FtpConnection.cc
* src/FtpFinishDownloadCommand.cc
* src/FtpInitiateConnectionCommand.cc
* src/FtpNegotiationCommand.cc
* src/GZipDecoder.cc
* src/HandshakeExtensionMessage.cc
* src/HttpConnection.cc
* src/HttpHeaderProcessor.cc
* src/HttpInitiateConnectionCommand.cc
* src/HttpResponse.cc
* src/HttpResponseCommand.cc
* src/HttpServer.cc
* src/HttpSkipResponseCommand.cc
* src/InitiateConnectionCommandFactory.cc
* src/IteratableChunkChecksumValidator.cc
* src/LibgcryptARC4Context.h
* src/LibgcryptARC4Decryptor.h
* src/LibgcryptARC4Encryptor.h
* src/LibgcryptDHKeyExchange.h
* src/LibgnutlsTLSContext.cc
* src/LibsslARC4Context.h
* src/LibsslARC4Decryptor.h
* src/LibsslARC4Encryptor.h
* src/LibsslDHKeyExchange.h
* src/LibsslTLSContext.cc
* src/MSEHandshake.cc
* src/MessageDigestHelper.cc
* src/MetalinkHelper.cc
* src/MultiDiskAdaptor.cc
* src/NameMatchOptionHandler.h
* src/NameResolver.cc
* src/Netrc.cc
* src/NsCookieParser.cc
* src/OptionHandlerException.cc
* src/OptionHandlerException.h
* src/OptionHandlerImpl.h
* src/OptionParser.cc
* src/ParameterizedStringParser.cc
* src/PeerAbstractCommand.cc
* src/PeerConnection.cc
* src/PeerMessageUtil.cc
* src/PeerReceiveHandshakeCommand.cc
* src/Platform.cc
* src/ReceiverMSEHandshakeCommand.cc
* src/RecoverableException.h
* src/RequestGroup.cc
* src/SimpleLogger.cc
* src/SocketCore.cc
* src/Sqlite3MozCookieParser.cc
* src/UTPexExtensionMessage.cc
* src/Util.cc
* src/XML2SAXMetalinkProcessor.cc
* src/Xml2XmlRpcRequestProcessor.cc
* src/XmlRpcMethodImpl.cc
* src/bencode.cc
* src/download_helper.cc
* src/messageDigest.h
* test/ExceptionTest.cc
* test/TestUtil.cc
2009-05-16 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Bump up version number to 1.4.0

16
src/AbstractCommand.cc
View File

@ -140,7 +140,7 @@ bool AbstractCommand::execute() {
}
return executeInternal();
} else if(_errorEvent) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat(MSG_NETWORK_PROBLEM,
socket->getSocketError().c_str()).str());
} else {
@ -151,15 +151,15 @@ bool AbstractCommand::execute() {
req->getProtocol());
ss->setError();
throw DlRetryEx(EX_TIME_OUT, DownloadResult::TIME_OUT);
throw DL_RETRY_EX2(EX_TIME_OUT, DownloadResult::TIME_OUT);
}
e->commands.push_back(this);
return false;
}
} catch(DlAbortEx& err) {
logger->error(MSG_DOWNLOAD_ABORTED,
DlAbortEx(StringFormat
("URI=%s", req->getCurrentUrl().c_str()).str(),err),
DL_ABORT_EX2(StringFormat
("URI=%s", req->getCurrentUrl().c_str()).str(),err),
cuid, req->getUrl().c_str());
_requestGroup->addURIResult(req->getUrl(), err.getCode());
onAbort();
@ -168,8 +168,8 @@ bool AbstractCommand::execute() {
return true;
} catch(DlRetryEx& err) {
logger->info(MSG_RESTARTING_DOWNLOAD,
DlRetryEx(StringFormat
("URI=%s", req->getCurrentUrl().c_str()).str(),err),
DL_RETRY_EX2(StringFormat
("URI=%s", req->getCurrentUrl().c_str()).str(),err),
cuid, req->getUrl().c_str());
req->addTryCount();
req->resetRedirectCount();
@ -432,7 +432,7 @@ bool AbstractCommand::asyncResolveHostname()
e->_requestGroupMan->getOrCreateServerStat
(req->getHost(), req->getProtocol())->setError();
}
throw DlAbortEx(StringFormat(MSG_NAME_RESOLUTION_FAILED, cuid,
throw DL_ABORT_EX(StringFormat(MSG_NAME_RESOLUTION_FAILED, cuid,
_asyncNameResolver->getHostname().c_str(),
_asyncNameResolver->getError().c_str()).str());
default:
@ -491,7 +491,7 @@ void AbstractCommand::checkIfConnectionEstablished
e->_requestGroupMan->getOrCreateServerStat
(req->getHost(), req->getProtocol())->setError();
}
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat(MSG_ESTABLISHING_CONNECTION_FAILED, error.c_str()).str());
}
}

24
src/AbstractDiskWriter.cc
View File

@ -88,7 +88,7 @@ void AbstractDiskWriter::closeFile()
void AbstractDiskWriter::openExistingFile(uint64_t totalLength)
{
if(!File(_filename).exists()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_OPEN, _filename.c_str(), MSG_FILE_NOT_FOUND).str());
}
@ -100,7 +100,7 @@ void AbstractDiskWriter::openExistingFile(uint64_t totalLength)
}
if((fd = open(_filename.c_str(), flags, OPEN_MODE)) < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_OPEN, _filename.c_str(), strerror(errno)).str());
}
}
@ -111,7 +111,7 @@ void AbstractDiskWriter::createFile(int addFlags)
Util::mkdirs(File(_filename).getDirname());
if((fd = open(_filename.c_str(), O_CREAT|O_RDWR|O_TRUNC|O_BINARY|addFlags,
OPEN_MODE)) < 0) {
throw DlAbortEx(StringFormat(EX_FILE_OPEN,
throw DL_ABORT_EX(StringFormat(EX_FILE_OPEN,
_filename.c_str(), strerror(errno)).str());
}
}
@ -140,7 +140,7 @@ ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len)
void AbstractDiskWriter::seek(off_t offset)
{
if(lseek(fd, offset, SEEK_SET) == (off_t)-1) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_SEEK, _filename.c_str(), strerror(errno)).str());
}
}
@ -152,10 +152,10 @@ void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, off_t
// If errno is ENOSPC(not enough space in device), throw
// DownloadFailureException and abort download instantly.
if(errno == ENOSPC) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat(EX_FILE_WRITE, _filename.c_str(), strerror(errno)).str());
}
throw DlAbortEx(StringFormat(EX_FILE_WRITE,
throw DL_ABORT_EX(StringFormat(EX_FILE_WRITE,
_filename.c_str(), strerror(errno)).str());
}
}
@ -165,7 +165,7 @@ ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offs
ssize_t ret;
seek(offset);
if((ret = readDataInternal(data, len)) < 0) {
throw DlAbortEx(StringFormat(EX_FILE_READ,
throw DL_ABORT_EX(StringFormat(EX_FILE_READ,
_filename.c_str(), strerror(errno)).str());
}
return ret;
@ -174,7 +174,7 @@ ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, off_t offs
void AbstractDiskWriter::truncate(uint64_t length)
{
if(fd == -1) {
throw DlAbortEx("File not opened.");
throw DL_ABORT_EX("File not opened.");
}
#ifdef __MINGW32__
// Since mingw32's ftruncate cannot handle over 2GB files, we use SetEndOfFile
@ -182,12 +182,12 @@ void AbstractDiskWriter::truncate(uint64_t length)
HANDLE handle = LongToHandle(_get_osfhandle(fd));
seek(length);
if(SetEndOfFile(handle) == 0) {
throw DlAbortEx(StringFormat("SetEndOfFile failed. cause: %s",
throw DL_ABORT_EX(StringFormat("SetEndOfFile failed. cause: %s",
GetLastError()).str());
}
#else
if(ftruncate(fd, length) == -1) {
throw DlAbortEx(StringFormat("ftruncate failed. cause: %s",
throw DL_ABORT_EX(StringFormat("ftruncate failed. cause: %s",
strerror(errno)).str());
}
#endif
@ -197,11 +197,11 @@ void AbstractDiskWriter::truncate(uint64_t length)
void AbstractDiskWriter::allocate(off_t offset, uint64_t length)
{
if(fd == -1) {
throw DlAbortEx("File not yet opened.");
throw DL_ABORT_EX("File not yet opened.");
}
int r = posix_fallocate(fd, offset, length);
if(r != 0) {
throw DlAbortEx(StringFormat("posix_fallocate failed. cause: %s",
throw DL_ABORT_EX(StringFormat("posix_fallocate failed. cause: %s",
strerror(r)).str());
}
}

2
src/AbstractProxyResponseCommand.cc
View File

@ -67,7 +67,7 @@ bool AbstractProxyResponseCommand::executeInternal() {
return false;
}
if(httpResponse->getResponseStatus() != HttpHeader::S200) {
throw DlRetryEx(EX_PROXY_CONNECTION_FAILED);
throw DL_RETRY_EX(EX_PROXY_CONNECTION_FAILED);
}
e->commands.push_back(getNextCommand());
return true;

32
src/BDE.h
View File

@ -42,7 +42,7 @@
#include <deque>
#include "SharedHandle.h"
#include "RecoverableException.h"
#include "DlAbortEx.h"
namespace aria2 {
@ -72,7 +72,7 @@ private:
// Returns Integer.
virtual Integer i() const
{
throw RecoverableException("Not Integer");
throw DL_ABORT_EX("Not Integer");
}
////////////////////////////////////////////////////////////////////////////
@ -81,14 +81,14 @@ private:
// Returns std::string.
virtual const std::string& s() const
{
throw RecoverableException("Not String");
throw DL_ABORT_EX("Not String");
}
// Returns std::string.data() casted to unsigned char*.
// Use s().size() to get length.
virtual const unsigned char* uc() const
{
throw RecoverableException("Not String");
throw DL_ABORT_EX("Not String");
}
////////////////////////////////////////////////////////////////////////////
@ -100,33 +100,33 @@ private:
// this is the same behavior of std::map's operator[].
virtual BDE& operator[](const std::string& key)
{
throw RecoverableException("Not Dict");
throw DL_ABORT_EX("Not Dict");
}
// Returns true if the given key is found in dict.
virtual bool containsKey(const std::string& key) const
{
throw RecoverableException("Not Dict");
throw DL_ABORT_EX("Not Dict");
}
// Removes specified key from dict.
virtual void removeKey(const std::string& key)
{
throw RecoverableException("Not Dict");
throw DL_ABORT_EX("Not Dict");
}
// Returns a read/write iterator that points to the first pair in
// the dict.
virtual Dict::iterator dictBegin()
{
throw RecoverableException("Not Dict");
throw DL_ABORT_EX("Not Dict");
}
// Returns a read/write read-only iterator that points to one past
// the last pair in the dict.
virtual Dict::iterator dictEnd()
{
throw RecoverableException("Not Dict");
throw DL_ABORT_EX("Not Dict");
}
////////////////////////////////////////////////////////////////////////////
@ -135,45 +135,45 @@ private:
// Appends given bde to list.
virtual void append(const BDE& bde)
{
throw RecoverableException("Not List");
throw DL_ABORT_EX("Not List");
}
// Alias for append()
virtual void operator<<(const BDE& bde)
{
throw RecoverableException("Not List");
throw DL_ABORT_EX("Not List");
}
// Returns the reference of the object at the given index.
virtual BDE& operator[](size_t index)
{
throw RecoverableException("Not List");
throw DL_ABORT_EX("Not List");
}
// Returns a read/write iterator that points to the first object
// in list.
virtual List::iterator listBegin()
{
throw RecoverableException("Not List");
throw DL_ABORT_EX("Not List");
}
// Returns a read/write iterator that points to the one past the
// last object in list.
virtual List::iterator listEnd()
{
throw RecoverableException("Not List");
throw DL_ABORT_EX("Not List");
}
// Returns size of list or dict.
virtual size_t size() const
{
throw RecoverableException("Neither Dict nor List");
throw DL_ABORT_EX("Neither Dict nor List");
}
// Returns true if size of list or dict is 0.
virtual bool empty() const
{
throw RecoverableException("Neither Dict nor List");
throw DL_ABORT_EX("Neither Dict nor List");
}
};

2
src/BtAllowedFastMessage.cc
View File

@ -49,7 +49,7 @@ SharedHandle<BtAllowedFastMessage> BtAllowedFastMessage::create
void BtAllowedFastMessage::doReceivedAction() {
if(!peer->isFastExtensionEnabled()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("%s received while fast extension is disabled",
toString().c_str()).str());
}

10
src/BtHandshakeMessageValidator.h
View File

@ -36,11 +36,13 @@
#define _D_BT_HANDSHAKE_MESSAGE_VALIDATOR_H_
#include "BtMessageValidator.h"
#include <cstring>
#include "BtHandshakeMessage.h"
#include "Util.h"
#include "PeerMessageUtil.h"
#include "StringFormat.h"
#include <cstring>
namespace aria2 {
@ -59,16 +61,16 @@ public:
virtual bool validate(Errors& error) {
// TODO
if(message->getPstrlen() != 19) {
throw DlAbortEx(StringFormat("invalid handshake pstrlen=%u",
throw DL_ABORT_EX(StringFormat("invalid handshake pstrlen=%u",
message->getPstrlen()).str());
}
if(memcmp(BtHandshakeMessage::BT_PSTR, message->getPstr(), 19) != 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("invalid handshake pstr=%s",
Util::urlencode(message->getPstr(), 19).c_str()).str());
}
if(memcmp(infoHash, message->getInfoHash(), 20) != 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("invalid handshake info hash: expected:%s, actual:%s",
Util::toHex(infoHash, 20).c_str(),
Util::toHex(message->getInfoHash(), 20).c_str()).str());

2
src/BtHaveAllMessage.cc
View File

@ -51,7 +51,7 @@ SharedHandle<BtHaveAllMessage> BtHaveAllMessage::create
void BtHaveAllMessage::doReceivedAction()
{
if(!peer->isFastExtensionEnabled()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("%s received while fast extension is disabled",
toString().c_str()).str());
}

2
src/BtHaveNoneMessage.cc
View File

@ -50,7 +50,7 @@ SharedHandle<BtHaveNoneMessage> BtHaveNoneMessage::create
void BtHaveNoneMessage::doReceivedAction()
{
if(!peer->isFastExtensionEnabled()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("%s received while fast extension is disabled",
toString().c_str()).str());
}

2
src/BtPieceMessage.cc
View File

@ -163,7 +163,7 @@ size_t BtPieceMessage::sendPieceData(off_t offset, size_t length) const {
static_cast<ssize_t>(length)) {
return peerConnection->sendMessage(buf, length);
} else {
throw DlAbortEx(EX_DATA_READ);
throw DL_ABORT_EX(EX_DATA_READ);
}
}

4
src/BtRejectMessage.cc
View File

@ -52,7 +52,7 @@ SharedHandle<BtRejectMessage> BtRejectMessage::create
void BtRejectMessage::doReceivedAction()
{
if(!peer->isFastExtensionEnabled()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("%s received while fast extension is disabled.",
toString().c_str()).str());
}
@ -61,7 +61,7 @@ void BtRejectMessage::doReceivedAction()
RequestSlot slot =
dispatcher->getOutstandingRequest(getIndex(), getBegin(), getLength());
if(RequestSlot::isNull(slot)) {
//throw DlAbortEx("reject recieved, but it is not in the request slots.");
//throw DL_ABORT_EX("reject recieved, but it is not in the request slots.");
} else {
dispatcher->removeOutstandingRequest(slot);
}

2
src/ChunkedDecoder.cc
View File

@ -75,7 +75,7 @@ static bool readData(std::string& out, uint64_t& chunkSize, std::string& in)
in.erase(0, 2);
return true;
} else {
throw DlAbortEx(EX_INVALID_CHUNK_SIZE);
throw DL_ABORT_EX(EX_INVALID_CHUNK_SIZE);
}
} else {
return false;

14
src/CookieStorage.cc
View File

@ -33,17 +33,19 @@
*/
/* copyright --> */
#include "CookieStorage.h"
#include <algorithm>
#include <fstream>
#include "Util.h"
#include "LogFactory.h"
#include "Logger.h"
#include "RecoverableException.h"
#include "DlAbortEx.h"
#include "StringFormat.h"
#include "NsCookieParser.h"
#ifdef HAVE_SQLITE3
# include "Sqlite3MozCookieParser.h"
#endif // HAVE_SQLITE3
#include <algorithm>
#include <fstream>
namespace aria2 {
@ -145,7 +147,7 @@ void CookieStorage::load(const std::string& filename)
std::ifstream s(filename.c_str(), std::ios::binary);
s.get(header, sizeof(header));
if(s.bad()) {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Failed to read header of cookie file %s",
filename.c_str()).str());
}
@ -155,7 +157,7 @@ void CookieStorage::load(const std::string& filename)
#ifdef HAVE_SQLITE3
storeCookies(Sqlite3MozCookieParser().parse(filename));
#else // !HAVE_SQLITE3
throw RecoverableException
throw DL_ABORT_EX
("Cannot read SQLite3 database because SQLite3 support is disabled by"
" configuration.");
#endif // !HAVE_SQLITE3
@ -163,7 +165,7 @@ void CookieStorage::load(const std::string& filename)
storeCookies(NsCookieParser().parse(filename));
}
} catch(RecoverableException& e) {
throw RecoverableException
throw DL_ABORT_EX2
(StringFormat("Failed to load cookies from %s", filename.c_str()).str(),
e);
}

2
src/DHTAnnouncePeerMessage.cc
View File

@ -104,7 +104,7 @@ void DHTAnnouncePeerMessage::validate() const
if(!_tokenTracker->validateToken(_token, _infoHash,
_remoteNode->getIPAddress(),
_remoteNode->getPort())) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Invalid token=%s from %s:%u",
Util::toHex(_token).c_str(),
_remoteNode->getIPAddress().c_str(),

2
src/DHTEntryPointNameResolveCommand.cc
View File

@ -159,7 +159,7 @@ bool DHTEntryPointNameResolveCommand::resolveHostname
return true;
break;
case AsyncNameResolver::STATUS_ERROR:
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_NAME_RESOLUTION_FAILED, cuid,
hostname.c_str(),
resolver->getError().c_str()).str());

30
src/DHTMessageFactoryImpl.cc
View File

@ -89,7 +89,7 @@ static const BDE& getDictionary(const BDE& dict,
if(d.isDict()) {
return d;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. Missing %s", key.c_str()).str());
}
}
@ -101,7 +101,7 @@ static const BDE& getString(const BDE& dict,
if(c.isString()) {
return c;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. Missing %s", key.c_str()).str());
}
}
@ -113,7 +113,7 @@ static const BDE& getInteger(const BDE& dict,
if(c.isInteger()) {
return c;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. Missing %s", key.c_str()).str());
}
}
@ -124,7 +124,7 @@ static const BDE& getString(const BDE& list, size_t index)
if(c.isString()) {
return c;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. element[%u] is not String.",
index).str());
}
@ -136,7 +136,7 @@ static const BDE& getInteger(const BDE& list, size_t index)
if(c.isInteger()) {
return c;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. element[%u] is not Integer.",
index).str());
}
@ -149,7 +149,7 @@ static const BDE& getList(const BDE& dict,
if(l.isList()) {
return l;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. Missing %s", key.c_str()).str());
}
}
@ -157,7 +157,7 @@ static const BDE& getList(const BDE& dict,
void DHTMessageFactoryImpl::validateID(const BDE& id) const
{
if(id.s().size() != DHT_ID_LENGTH) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. Invalid ID length."
" Expected:%d, Actual:%d",
DHT_ID_LENGTH, id.s().size()).str());
@ -168,7 +168,7 @@ void DHTMessageFactoryImpl::validatePort(const BDE& i) const
{
BDE::Integer port = i.i();
if(!(0 < port && port < UINT16_MAX)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. Invalid port=%s",
Util::itos(port).c_str()).str());
}
@ -184,7 +184,7 @@ SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage
const BDE& y = getString(dict, DHTMessage::Y);
const BDE& aDict = getDictionary(dict, DHTQueryMessage::A);
if(y.s() != DHTQueryMessage::Q) {
throw DlAbortEx("Malformed DHT message. y != q");
throw DL_ABORT_EX("Malformed DHT message. y != q");
}
const BDE& id = getString(aDict, DHTMessage::ID);
validateID(id);
@ -214,7 +214,7 @@ SharedHandle<DHTMessage> DHTMessageFactoryImpl::createQueryMessage
static_cast<uint16_t>(port.i()),
token.s(), transactionID.s());
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Unsupported message type: %s",
messageType.s().c_str()).str());
}
@ -238,9 +238,9 @@ DHTMessageFactoryImpl::createResponseMessage(const std::string& messageType,
} else {
_logger->debug("e doesn't have 2 elements.");
}
throw DlAbortEx("Received Error DHT message.");
throw DL_ABORT_EX("Received Error DHT message.");
} else if(y.s() != DHTResponseMessage::R) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Malformed DHT message. y != r: y=%s",
Util::urlencode(y.s()).c_str()).str());
}
@ -264,13 +264,13 @@ DHTMessageFactoryImpl::createResponseMessage(const std::string& messageType,
return createGetPeersReplyMessageWithNodes(remoteNode, dict,
transactionID.s());
} else {
throw DlAbortEx("Malformed DHT message: missing nodes/values");
throw DL_ABORT_EX("Malformed DHT message: missing nodes/values");
}
}
} else if(messageType == DHTAnnouncePeerReplyMessage::ANNOUNCE_PEER) {
return createAnnouncePeerReplyMessage(remoteNode, transactionID.s());
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Unsupported message type: %s", messageType.c_str()).str());
}
}
@ -326,7 +326,7 @@ std::deque<SharedHandle<DHTNode> >
DHTMessageFactoryImpl::extractNodes(const unsigned char* src, size_t length)
{
if(length%26 != 0) {
throw DlAbortEx("Nodes length is not multiple of 26");
throw DL_ABORT_EX("Nodes length is not multiple of 26");
}
std::deque<SharedHandle<DHTNode> > nodes;
for(size_t offset = 0; offset < length; offset += 26) {

2
src/DHTMessageTracker.cc
View File

@ -74,7 +74,7 @@ DHTMessageTracker::messageArrived(const BDE& dict,
{
const BDE& tid = dict[DHTMessage::T];
if(!tid.isString()) {
throw DlAbortEx(StringFormat("Malformed DHT message. From:%s:%u",
throw DL_ABORT_EX(StringFormat("Malformed DHT message. From:%s:%u",
ipaddr.c_str(), port).str());
}
_logger->debug("Searching tracker entry for TransactionID=%s, Remote=%s:%u",

4
src/DHTRoutingTableDeserializer.cc
View File

@ -114,7 +114,7 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in)
} else if(memcmp(headerCompat, buf, 8) == 0) {
version = 2;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Failed to load DHT routing table. cause:%s",
"bad header").str());
}
@ -192,7 +192,7 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in)
_localNode = localNode;
} catch(std::ios::failure const& exception) {
_nodes.clear();
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Failed to load DHT routing table. cause:%s",
strerror(errno)).str());
}

2
src/DHTRoutingTableSerializer.cc
View File

@ -121,7 +121,7 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o)
o.write(zero, 4);
}
} catch(std::ios::failure const& exception) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Failed to save DHT routing table. cause:%s",
strerror(errno)).str());
}

2
src/DHTSetup.cc
View File

@ -114,7 +114,7 @@ void DHTSetup::setup(std::deque<Command*>& commands,
IntSequence seq = Util::parseIntRange(option->get(PREF_DHT_LISTEN_PORT));
uint16_t port;
if(!connection->bind(port, seq)) {
throw DlAbortEx("Error occurred while binding port for DHT");
throw DL_ABORT_EX("Error occurred while binding port for DHT");
}
localNode->setPort(port);
}

2
src/DHTTokenTracker.cc
View File

@ -63,7 +63,7 @@ std::string DHTTokenTracker::generateToken(const unsigned char* infoHash,
{
unsigned char src[DHT_ID_LENGTH+6+SECRET_SIZE];
if(!PeerMessageUtil::createcompact(src+DHT_ID_LENGTH, ipaddr, port)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Token generation failed: ipaddr=%s, port=%u",
ipaddr.c_str(), port).str());
}

4
src/DefaultBtAnnounce.cc
View File

@ -207,11 +207,11 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
const BDE dict =
bencode::decode(trackerResponse, trackerResponseLength);
if(!dict.isDict()) {
throw DlAbortEx(MSG_NULL_TRACKER_RESPONSE);
throw DL_ABORT_EX(MSG_NULL_TRACKER_RESPONSE);
}
const BDE& failure = dict[BtAnnounce::FAILURE_REASON];
if(failure.isString()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_TRACKER_FAILURE, failure.s().c_str()).str());
}
const BDE& warn = dict[BtAnnounce::WARNING_MESSAGE];

22
src/DefaultBtContext.cc
View File

@ -141,14 +141,14 @@ void DefaultBtContext::extractFileEntries(const BDE& infoDict,
const BDE& fileLengthData = fileDict[BtContext::C_LENGTH];
if(!fileLengthData.isInteger()) {
throw DlAbortEx(StringFormat(MSG_MISSING_BT_INFO,
throw DL_ABORT_EX(StringFormat(MSG_MISSING_BT_INFO,
BtContext::C_LENGTH.c_str()).str());
}
length += fileLengthData.i();
const BDE& pathList = fileDict[BtContext::C_PATH];
if(!pathList.isList() || pathList.empty()) {
throw DlAbortEx("Path is empty.");
throw DL_ABORT_EX("Path is empty.");
}
std::vector<std::string> pathelem(pathList.size());
@ -176,7 +176,7 @@ void DefaultBtContext::extractFileEntries(const BDE& infoDict,
fileMode = BtContext::SINGLE;
const BDE& lengthData = infoDict[BtContext::C_LENGTH];
if(!lengthData.isInteger()) {
throw DlAbortEx(StringFormat(MSG_MISSING_BT_INFO,
throw DL_ABORT_EX(StringFormat(MSG_MISSING_BT_INFO,
BtContext::C_LENGTH.c_str()).str());
}
totalLength = lengthData.i();
@ -310,11 +310,11 @@ void DefaultBtContext::processRootDictionary(const BDE& rootDict,
{
clear();
if(!rootDict.isDict()) {
throw DlAbortEx("torrent file does not contain a root dictionary.");
throw DL_ABORT_EX("torrent file does not contain a root dictionary.");
}
const BDE& infoDict = rootDict[BtContext::C_INFO];
if(!infoDict.isDict()) {
throw DlAbortEx(StringFormat(MSG_MISSING_BT_INFO,
throw DL_ABORT_EX(StringFormat(MSG_MISSING_BT_INFO,
BtContext::C_INFO.c_str()).str());
}
// retrieve infoHash
@ -327,20 +327,20 @@ void DefaultBtContext::processRootDictionary(const BDE& rootDict,
// calculate the number of pieces
const BDE& piecesData = infoDict[BtContext::C_PIECES];
if(!piecesData.isString()) {
throw DlAbortEx(StringFormat(MSG_MISSING_BT_INFO,
throw DL_ABORT_EX(StringFormat(MSG_MISSING_BT_INFO,
BtContext::C_PIECES.c_str()).str());
}
if(piecesData.s().empty()) {
throw DlAbortEx("The length of piece hash is 0.");
throw DL_ABORT_EX("The length of piece hash is 0.");
}
numPieces = piecesData.s().size()/PIECE_HASH_LENGTH;
if(numPieces == 0) {
throw DlAbortEx("The number of pieces is 0.");
throw DL_ABORT_EX("The number of pieces is 0.");
}
// retrieve piece length
const BDE& pieceLengthData = infoDict[BtContext::C_PIECE_LENGTH];
if(!pieceLengthData.isInteger()) {
throw DlAbortEx(StringFormat(MSG_MISSING_BT_INFO,
throw DL_ABORT_EX(StringFormat(MSG_MISSING_BT_INFO,
BtContext::C_PIECE_LENGTH.c_str()).str());
}
pieceLength = pieceLengthData.i();
@ -360,7 +360,7 @@ void DefaultBtContext::processRootDictionary(const BDE& rootDict,
// retrieve file entries
extractFileEntries(infoDict, defaultName, overrideName, urlList);
if((totalLength+pieceLength-1)/pieceLength != numPieces) {
throw DlAbortEx("Too few/many piece hash.");
throw DL_ABORT_EX("Too few/many piece hash.");
}
// retrieve announce
extractAnnounce(rootDict);
@ -509,7 +509,7 @@ void DefaultBtContext::setFilePathWithIndex
if(0 < index && index <= fileEntries.size()) {
fileEntries[index-1]->setPath(path);
} else {
throw DlAbortEx(StringFormat("No such file with index=%u",
throw DL_ABORT_EX(StringFormat("No such file with index=%u",
static_cast<unsigned int>(index)).str());
}
}

8
src/DefaultBtInteractive.cc
View File

@ -102,7 +102,7 @@ BtMessageHandle DefaultBtInteractive::receiveHandshake(bool quickReply) {
}
if(memcmp(message->getPeerId(), _btContext->getPeerId(),
PEER_ID_LENGTH) == 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat
("CUID#%d - Drop connection from the same Peer ID", cuid).str());
}
@ -369,7 +369,7 @@ void DefaultBtInteractive::detectMessageFlooding() {
if(floodingCheckPoint.elapsed(FLOODING_CHECK_INTERVAL)) {
if(floodingStat.getChokeUnchokeCount() >= 2 ||
floodingStat.getKeepAliveCount() >= 2) {
throw DlAbortEx(EX_FLOODING_DETECTED);
throw DL_ABORT_EX(EX_FLOODING_DETECTED);
} else {
floodingStat.reset();
}
@ -386,7 +386,7 @@ void DefaultBtInteractive::checkActiveInteraction()
if(!peer->amInterested() && !peer->peerInterested() &&
inactiveCheckPoint.elapsed(interval)) {
// TODO change the message
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Disconnect peer because we are not interested each other"
" after %u second(s).", interval).str());
}
@ -397,7 +397,7 @@ void DefaultBtInteractive::checkActiveInteraction()
{
time_t interval = 2*60;
if(inactiveCheckPoint.elapsed(interval)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_DROP_INACTIVE_CONNECTION, interval).str());
}
}

4
src/DefaultBtMessageFactory.cc
View File

@ -204,12 +204,12 @@ DefaultBtMessageFactory::createBtMessage(const unsigned char* data, size_t dataL
msg = BtExtendedMessage::create(_extensionMessageFactory,
peer, data, dataLength);
} else {
throw DlAbortEx("Received extended message from peer during a session with extended messaging disabled.");
throw DL_ABORT_EX("Received extended message from peer during a session with extended messaging disabled.");
}
break;
}
default:
throw DlAbortEx(StringFormat("Invalid message ID. id=%u", id).str());
throw DL_ABORT_EX(StringFormat("Invalid message ID. id=%u", id).str());
}
}
setCommonProperty(msg);

24
src/DefaultBtProgressInfoFile.cc
View File

@ -183,11 +183,11 @@ void DefaultBtProgressInfoFile::save() {
_logger->info(MSG_SAVED_SEGMENT_FILE);
} catch(std::ios::failure const& exception) {
// TODO std::ios::failure doesn't give us the reasons of failure...
throw DlAbortEx(StringFormat(EX_SEGMENT_FILE_WRITE,
throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_WRITE,
_filename.c_str(), strerror(errno)).str());
}
if(!File(filenameTemp).renameTo(_filename)) {
throw DlAbortEx(StringFormat(EX_SEGMENT_FILE_WRITE,
throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_WRITE,
_filename.c_str(), strerror(errno)).str());
}
}
@ -212,7 +212,7 @@ void DefaultBtProgressInfoFile::load()
} else if(DefaultBtProgressInfoFile::V0001 == versionHex) {
version = 1;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Unsupported ctrl file version: %s",
versionHex.c_str()).str());
}
@ -232,7 +232,7 @@ void DefaultBtProgressInfoFile::load()
}
if((infoHashLength < 0) ||
((infoHashLength == 0) && infoHashCheckEnabled)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Invalid info hash length: %d", infoHashLength).str());
}
if(infoHashLength > 0) {
@ -242,7 +242,7 @@ void DefaultBtProgressInfoFile::load()
if(infoHashCheckEnabled &&
Util::toHex(savedInfoHash, infoHashLength) !=
btContext->getInfoHashAsString()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("info hash mismatch. expected: %s, actual: %s",
btContext->getInfoHashAsString().c_str(),
Util::toHex(savedInfoHash,
@ -264,7 +264,7 @@ void DefaultBtProgressInfoFile::load()
totalLength = ntoh64(totalLength);
}
if(totalLength != _dctx->getTotalLength()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("total length mismatch. expected: %s, actual: %s",
Util::itos(_dctx->getTotalLength()).c_str(),
Util::itos(totalLength).c_str()).str());
@ -288,7 +288,7 @@ void DefaultBtProgressInfoFile::load()
uint32_t expectedBitfieldLength =
((totalLength+pieceLength-1)/pieceLength+7)/8;
if(expectedBitfieldLength != bitfieldLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("bitfield length mismatch. expected: %d, actual: %d",
expectedBitfieldLength,
bitfieldLength).str());
@ -316,7 +316,7 @@ void DefaultBtProgressInfoFile::load()
index = ntohl(index);
}
if(!(index < _dctx->getNumPieces())) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("piece index out of range: %u", index).str());
}
uint32_t length;
@ -325,7 +325,7 @@ void DefaultBtProgressInfoFile::load()
length = ntohl(length);
}
if(!(length <=_dctx->getPieceLength())) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("piece length out of range: %u", length).str());
}
PieceHandle piece(new Piece(index, length));
@ -336,7 +336,7 @@ void DefaultBtProgressInfoFile::load()
bitfieldLength = ntohl(bitfieldLength);
}
if(piece->getBitfieldLength() != bitfieldLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("piece bitfield length mismatch."
" expected: %u actual: %u",
piece->getBitfieldLength(), bitfieldLength).str());
@ -368,7 +368,7 @@ void DefaultBtProgressInfoFile::load()
src.setBitfield(savedBitfield, bitfieldLength);
if((src.getCompletedLength() || numInFlightPiece) &&
!_option->getAsBool(PREF_ALLOW_PIECE_LENGTH_CHANGE)) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
("WARNING: Detected a change in piece length. You can proceed with"
" --allow-piece-length-change=true, but you may lose some download"
" progress.");
@ -384,7 +384,7 @@ void DefaultBtProgressInfoFile::load()
delete [] savedBitfield;
delete [] savedInfoHash;
// TODO std::ios::failure doesn't give us the reasons of failure...
throw DlAbortEx(StringFormat(EX_SEGMENT_FILE_READ,
throw DL_ABORT_EX(StringFormat(EX_SEGMENT_FILE_READ,
_filename.c_str(), strerror(errno)).str());
}
}

4
src/DefaultExtensionMessageFactory.cc
View File

@ -73,7 +73,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
} else {
std::string extensionName = _registry->getExtensionName(extensionMessageID);
if(extensionName.empty()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("No extension registered for extended message ID %u",
extensionMessageID).str());
}
@ -84,7 +84,7 @@ DefaultExtensionMessageFactory::createMessage(const unsigned char* data, size_t
m->setPeerStorage(_peerStorage);
return m;
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Unsupported extension message received. extensionMessageID=%u, extensionName=%s",
extensionMessageID, extensionName.c_str()).str());
}

19
src/DlAbortEx.h
View File

@ -46,14 +46,21 @@ protected:
return e;
}
public:
DlAbortEx(const std::string& msg):RecoverableException(msg) {}
DlAbortEx(const std::string& msg,
const Exception& cause):RecoverableException(msg, cause) {}
DlAbortEx(const RecoverableException& e):RecoverableException(e) {}
DlAbortEx(const std::string& msg, DownloadResult::RESULT code):
RecoverableException(msg, code) {}
DlAbortEx(const char* file, int line, const std::string& msg):
RecoverableException(file, line, msg) {}
DlAbortEx(const char* file, int line, const std::string& msg,
const Exception& cause):
RecoverableException(file, line, msg, cause) {}
DlAbortEx(const char* file, int line, const RecoverableException& e):
RecoverableException(file, line, e) {}
DlAbortEx(const char* file, int line, const std::string& msg,
DownloadResult::RESULT code):
RecoverableException(file, line, msg, code) {}
};
#define DL_ABORT_EX(arg) DlAbortEx(__FILE__, __LINE__, arg)
#define DL_ABORT_EX2(arg1, arg2) DlAbortEx(__FILE__, __LINE__, arg1, arg2)
} // namespace aria2
#endif // _D_DL_ABORT_EX_H_

19
src/DlRetryEx.h
View File

@ -46,14 +46,21 @@ protected:
return e;
}
public:
DlRetryEx(const std::string& msg):RecoverableException(msg) {}
DlRetryEx(const std::string& msg,
const Exception& cause):RecoverableException(msg, cause) {}
DlRetryEx(const DlRetryEx& e):RecoverableException(e) {}
DlRetryEx(const std::string& msg, DownloadResult::RESULT code):
RecoverableException(msg, code) {}
DlRetryEx(const char* file, int line, const std::string& msg):
RecoverableException(file, line, msg) {}
DlRetryEx(const char* file, int line, const std::string& msg,
const Exception& cause):
RecoverableException(file, line, msg, cause) {}
DlRetryEx(const char* file, int line, const DlRetryEx& e):
RecoverableException(file, line, e) {}
DlRetryEx(const char* file, int line, const std::string& msg,
DownloadResult::RESULT code):
RecoverableException(file, line, msg, code) {}
};
#define DL_RETRY_EX(arg) DlRetryEx(__FILE__, __LINE__, arg)
#define DL_RETRY_EX2(arg1, arg2) DlRetryEx(__FILE__, __LINE__, arg1, arg2)
} // namespace aria2
#endif // _D_DL_RETRY_EX_H_

13
src/DownloadCommand.cc
View File

@ -184,7 +184,7 @@ bool DownloadCommand::executeInternal() {
if(!segmentComplete && bufSize == 0 &&
!socket->wantRead() && !socket->wantWrite()) {
throw DlRetryEx(EX_GOT_EOF);
throw DL_RETRY_EX(EX_GOT_EOF);
}
if(segmentComplete) {
@ -236,10 +236,11 @@ void DownloadCommand::checkLowestDownloadSpeed() const
if(peerStat->getDownloadStartTime().elapsed(startupIdleTime)) {
unsigned int nowSpeed = peerStat->calculateDownloadSpeed();
if(lowestDownloadSpeedLimit > 0 && nowSpeed <= lowestDownloadSpeedLimit) {
throw DlAbortEx(StringFormat(EX_TOO_SLOW_DOWNLOAD_SPEED,
nowSpeed,
lowestDownloadSpeedLimit,
req->getHost().c_str()).str(), DownloadResult::TOO_SLOW_DOWNLOAD_SPEED);
throw DL_ABORT_EX2(StringFormat(EX_TOO_SLOW_DOWNLOAD_SPEED,
nowSpeed,
lowestDownloadSpeedLimit,
req->getHost().c_str()).str(),
DownloadResult::TOO_SLOW_DOWNLOAD_SPEED);
}
}
}
@ -294,7 +295,7 @@ void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment,
actualPieceHash.c_str());
segment->clear();
_requestGroup->getSegmentMan()->cancelSegment(cuid);
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat("Invalid checksum index=%d", segment->getIndex()).str());
}
}

2
src/DownloadEngineFactory.cc
View File

@ -98,7 +98,7 @@ DownloadEngineFactory::newDownloadEngine(Option* op,
if(ep->good()) {
eventPoll = ep;
} else {
throw DlAbortEx("Initializing EpollEventPoll failed."
throw DL_ABORT_EX("Initializing EpollEventPoll failed."
" Try --event-poll=select");
}
} else

22
src/DownloadFailureException.h
View File

@ -50,16 +50,24 @@ protected:
return e;
}
public:
DownloadFailureException(const std::string& msg):RecoverableException(msg) {}
DownloadFailureException(const std::string& msg,
DownloadFailureException(const char* file, int line, const std::string& msg):
RecoverableException(file, line, msg) {}
DownloadFailureException(const char* file, int line, const std::string& msg,
const Exception& cause):
RecoverableException(msg, cause) {}
DownloadFailureException(const DownloadFailureException& e):
RecoverableException(e) {}
DownloadFailureException(const std::string& msg, DownloadResult::RESULT code):
RecoverableException(msg, code) {}
RecoverableException(file, line, msg, cause) {}
DownloadFailureException(const char* file, int line,
const DownloadFailureException& e):
RecoverableException(file, line, e) {}
DownloadFailureException(const char* file, int line,
const std::string& msg, DownloadResult::RESULT code):
RecoverableException(file, line, msg, code) {}
};
#define DOWNLOAD_FAILURE_EXCEPTION(arg)\
DownloadFailureException(__FILE__, __LINE__, arg)
#define DOWNLOAD_FAILURE_EXCEPTION2(arg1, arg2)\
DownloadFailureException(__FILE__, __LINE__, arg1, arg2)
} // namespace aria2
#endif // _D_DOWNLOAD_FAILURE_EXCEPTION_H_

24
src/Exception.cc
View File

@ -34,15 +34,19 @@
/* copyright --> */
#include "Exception.h"
#include <sstream>
namespace aria2 {
Exception::Exception(const std::string& msg):exception(), _msg(msg) {}
Exception::Exception(const char* file, int line, const std::string& msg):
_file(file), _line(line), _msg(msg) {}
Exception::Exception(const std::string& msg,
Exception::Exception(const char* file, int line, const std::string& msg,
const Exception& cause):
exception(), _msg(msg), _cause(cause.copy()) {}
_file(file), _line(line), _msg(msg), _cause(cause.copy()) {}
Exception::Exception(const Exception& e):_msg(e._msg), _cause(e._cause)
Exception::Exception(const char* file, int line, const Exception& e):
_file(file), _line(line), _msg(e._msg), _cause(e._cause)
{}
Exception::~Exception() throw() {}
@ -54,17 +58,15 @@ const char* Exception::what() const throw()
std::string Exception::stackTrace() const throw()
{
std::string stackTrace = "Exception: ";
stackTrace += what();
stackTrace += "\n";
std::stringstream s;
s << "Exception: " << "[" << _file << ":" << _line << "] " << what() << "\n";
SharedHandle<Exception> e = _cause;
while(!e.isNull()) {
stackTrace += " -> ";
stackTrace += e->what();
stackTrace += "\n";
s << " -> " << "[" << e->_file << ":" << e->_line << "] "
<< e->what() << "\n";
e = e->_cause;
}
return stackTrace;
return s.str();
}
} // namespace aria2

11
src/Exception.h
View File

@ -43,6 +43,10 @@ namespace aria2 {
class Exception:public std::exception {
private:
const char* _file;
int _line;
std::string _msg;
SharedHandle<Exception> _cause;
@ -51,11 +55,12 @@ protected:
virtual SharedHandle<Exception> copy() const = 0;
public:
explicit Exception(const std::string& msg);
explicit Exception(const char* file, int line, const std::string& msg);
Exception(const std::string& msg, const Exception& cause);
Exception(const char* file, int line, const std::string& msg,
const Exception& cause);
Exception(const Exception& e);
Exception(const char* file, int line, const Exception& e);
virtual ~Exception() throw();

6
src/ExpatMetalinkProcessor.cc
View File

@ -123,12 +123,12 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar
break;
}
if(XML_Parse(parser, (const char*)buf, res, 0) == XML_STATUS_ERROR) {
throw DlAbortEx(MSG_CANNOT_PARSE_METALINK);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK);
}
readOffset += res;
}
if(XML_Parse(parser, 0, 0, 1) == XML_STATUS_ERROR) {
throw DlAbortEx(MSG_CANNOT_PARSE_METALINK);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK);
}
} catch(Exception& e) {
XML_ParserFree(parser);
@ -136,7 +136,7 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar
}
XML_ParserFree(parser);
if(!_stm->finished()) {
throw DlAbortEx(MSG_CANNOT_PARSE_METALINK);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK);
}
return _stm->getResult();
}

2
src/ExpatXmlRpcRequestProcessor.cc
View File

@ -112,7 +112,7 @@ XmlRpcRequestProcessor::parseMemory(const std::string& xml)
XML_ParserFree(parser);
if(r == XML_STATUS_ERROR) {
throw DlAbortEx(MSG_CANNOT_PARSE_XML_RPC_REQUEST);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_XML_RPC_REQUEST);
}
return XmlRpcRequest(_stm->getMethodName(), _stm->getCurrentFrameValue());
}

2
src/FallocFileAllocationIterator.cc
View File

@ -44,7 +44,7 @@ FallocFileAllocationIterator::FallocFileAllocationIterator
void FallocFileAllocationIterator::allocateChunk()
{
if(static_cast<uint64_t>(_offset) > _totalLength) {
throw DlAbortEx("FallocFileAllocationIterator: offset is larger than"
throw DL_ABORT_EX("FallocFileAllocationIterator: offset is larger than"
" totalLength");
}
_stream->allocate(_offset, _totalLength-_offset);

13
src/FatalException.h
View File

@ -46,12 +46,19 @@ protected:
return e;
}
public:
FatalException(const std::string& msg):Exception(msg) {}
FatalException(const std::string& msg,
const Exception& cause):Exception(msg, cause) {}
FatalException(const char* file, int line, const std::string& msg):
Exception(file, line, msg) {}
FatalException(const char* file, int line, const std::string& msg,
const Exception& cause):
Exception(file, line, msg, cause) {}
FatalException(const FatalException& e):Exception(e) {}
};
#define FATAL_EXCEPTION(arg)\
FatalException(__FILE__, __LINE__, arg)
#define FATAL_EXCEPTION2(arg1, arg2)\
FatalException(__FILE__, __LINE__, arg1, arg2)
} // namespace aria2
#endif // _D_FATAL_EXCEPTION_EX_H_

10
src/FtpConnection.cc
View File

@ -291,10 +291,10 @@ bool FtpConnection::bulkReceiveResponse(std::pair<unsigned int, std::string>& re
if(socket->wantRead() || socket->wantWrite()) {
return false;
}
throw DlRetryEx(EX_GOT_EOF);
throw DL_RETRY_EX(EX_GOT_EOF);
}
if(strbuf.size()+size > MAX_RECV_BUFFER) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat("Max FTP recv buffer reached. length=%lu",
static_cast<unsigned long>(strbuf.size()+size)).str());
}
@ -304,7 +304,7 @@ bool FtpConnection::bulkReceiveResponse(std::pair<unsigned int, std::string>& re
if(strbuf.size() >= 4) {
status = getStatus(strbuf);
if(status == 0) {
throw DlAbortEx(EX_INVALID_RESPONSE);
throw DL_ABORT_EX(EX_INVALID_RESPONSE);
}
} else {
return false;
@ -411,7 +411,7 @@ unsigned int FtpConnection::receivePasvResponse(std::pair<std::string, uint16_t>
// port number
dest.second = 256*p1+p2;
} else {
throw DlRetryEx(EX_INVALID_RESPONSE);
throw DL_RETRY_EX(EX_INVALID_RESPONSE);
}
}
return response.first;
@ -432,7 +432,7 @@ unsigned int FtpConnection::receivePwdResponse(std::string& pwd)
(last = response.second.find("\"", ++first)) != std::string::npos) {
pwd = response.second.substr(first, last-first);
} else {
throw DlAbortEx(EX_INVALID_RESPONSE);
throw DL_ABORT_EX(EX_INVALID_RESPONSE);
}
}
return response.first;

2
src/FtpFinishDownloadCommand.cc
View File

@ -82,7 +82,7 @@ bool FtpFinishDownloadCommand::execute()
return false;
}
if(status != 226) {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
if(getOption()->getAsBool(PREF_FTP_REUSE_CONNECTION)) {
std::map<std::string, std::string> options;

4
src/FtpInitiateConnectionCommand.cc
View File

@ -94,7 +94,7 @@ Command* FtpInitiateConnectionCommand::createNextCommand
proxyRequest, socket);
} else {
// TODO
throw DlAbortEx("ERROR");
throw DL_ABORT_EX("ERROR");
}
} else {
if(proxyMethod == V_TUNNEL) {
@ -114,7 +114,7 @@ Command* FtpInitiateConnectionCommand::createNextCommand
command = c;
} else {
// TODO
throw DlAbortEx("ERROR");
throw DL_ABORT_EX("ERROR");
}
}
} else {

28
src/FtpNegotiationCommand.cc
View File

@ -135,7 +135,7 @@ bool FtpNegotiationCommand::recvGreeting() {
return false;
}
if(status != 220) {
throw DlAbortEx(EX_CONNECTION_FAILED);
throw DL_ABORT_EX(EX_CONNECTION_FAILED);
}
sequence = SEQ_SEND_USER;
@ -164,7 +164,7 @@ bool FtpNegotiationCommand::recvUser() {
sequence = SEQ_SEND_PASS;
break;
default:
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
return true;
}
@ -185,7 +185,7 @@ bool FtpNegotiationCommand::recvPass() {
return false;
}
if(status != 230) {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
sequence = SEQ_SEND_TYPE;
return true;
@ -207,7 +207,7 @@ bool FtpNegotiationCommand::recvType() {
return false;
}
if(status != 200) {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
sequence = SEQ_SEND_PWD;
return true;
@ -232,7 +232,7 @@ bool FtpNegotiationCommand::recvPwd()
return false;
}
if(status != 257) {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
ftp->setBaseWorkingDir(pwd);
logger->info("CUID#%d - base working directory is '%s'", cuid, pwd.c_str());
@ -261,9 +261,9 @@ bool FtpNegotiationCommand::recvCwd() {
poolConnection();
_requestGroup->increaseAndValidateFileNotFoundCount();
if (status == 550)
throw DlAbortEx(MSG_RESOURCE_NOT_FOUND, DownloadResult::RESOURCE_NOT_FOUND);
throw DL_ABORT_EX2(MSG_RESOURCE_NOT_FOUND, DownloadResult::RESOURCE_NOT_FOUND);
else
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
if(getOption()->getAsBool(PREF_REMOTE_TIME)) {
sequence = SEQ_SEND_MDTM;
@ -330,7 +330,7 @@ bool FtpNegotiationCommand::onFileSizeDetermined(uint64_t totalLength)
dctx->setFilename(dctx->getDir()+"/"+Util::urldecode(req->getFile()));
_requestGroup->preDownloadProcessing();
if(e->_requestGroupMan->isSameFileBeingDownloaded(_requestGroup)) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat(EX_DUPLICATE_FILE_DOWNLOAD,
_requestGroup->getFilePath().c_str()).str());
}
@ -418,7 +418,7 @@ bool FtpNegotiationCommand::recvSize() {
if(status == 213) {
if(size > INT64_MAX) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_TOO_LARGE_FILE, Util::uitos(size, true).c_str()).str());
}
if(_requestGroup->getPieceStorage().isNull()) {
@ -485,7 +485,7 @@ bool FtpNegotiationCommand::recvPort() {
return false;
}
if(status != 200) {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
sequence = SEQ_SEND_REST;
return true;
@ -509,7 +509,7 @@ bool FtpNegotiationCommand::recvPasv() {
return false;
}
if(status != 227) {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
// make a data connection to the server.
logger->info(MSG_CONNECTING_TO_SERVER, cuid,
@ -551,7 +551,7 @@ bool FtpNegotiationCommand::recvRest(const SharedHandle<Segment>& segment) {
// then throw exception here.
if(status != 350) {
if(!segment.isNull() && segment->getPositionToWrite() != 0) {
throw DlAbortEx("FTP server doesn't support resuming.");
throw DL_ABORT_EX("FTP server doesn't support resuming.");
}
}
sequence = SEQ_SEND_RETR;
@ -576,9 +576,9 @@ bool FtpNegotiationCommand::recvRetr() {
if(status != 150 && status != 125) {
_requestGroup->increaseAndValidateFileNotFoundCount();
if (status == 550)
throw DlAbortEx(MSG_RESOURCE_NOT_FOUND, DownloadResult::RESOURCE_NOT_FOUND);
throw DL_ABORT_EX2(MSG_RESOURCE_NOT_FOUND, DownloadResult::RESOURCE_NOT_FOUND);
else
throw DlAbortEx(StringFormat(EX_BAD_STATUS, status).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, status).str());
}
if(getOption()->getAsBool(PREF_FTP_PASV)) {
sequence = SEQ_NEGOTIATION_COMPLETED;

4
src/GZipDecoder.cc
View File

@ -60,7 +60,7 @@ void GZipDecoder::init()
// initalize z_stream with gzip/zlib format auto detection enabled.
if(Z_OK != inflateInit2(_strm, 47)) {
throw DlAbortEx("Initializing z_stream failed.");
throw DL_ABORT_EX("Initializing z_stream failed.");
}
}
@ -94,7 +94,7 @@ std::string GZipDecoder::decode(const unsigned char* in, size_t length)
if(ret == Z_STREAM_END) {
_finished = true;
} else if(ret != Z_OK) {
throw DlAbortEx(StringFormat("libz::inflate() failed. cause:%s",
throw DL_ABORT_EX(StringFormat("libz::inflate() failed. cause:%s",
_strm->msg).str());
}

4
src/HandshakeExtensionMessage.cc
View File

@ -126,7 +126,7 @@ HandshakeExtensionMessageHandle
HandshakeExtensionMessage::create(const unsigned char* data, size_t length)
{
if(length < 1) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_TOO_SMALL_PAYLOAD_SIZE,
EXTENSION_NAME.c_str(), length).str());
}
@ -135,7 +135,7 @@ HandshakeExtensionMessage::create(const unsigned char* data, size_t length)
Util::urlencode(data, length).c_str());
const BDE dict = bencode::decode(data+1, length-1);
if(!dict.isDict()) {
throw DlAbortEx("Unexpected payload format for extended message handshake");
throw DL_ABORT_EX("Unexpected payload format for extended message handshake");
}
const BDE& port = dict["p"];
if(port.isInteger() && 0 < port.i() && port.i() < 65536) {

4
src/HttpConnection.cc
View File

@ -121,7 +121,7 @@ void HttpConnection::sendProxyRequest(const HttpRequestHandle& httpRequest)
HttpResponseHandle HttpConnection::receiveResponse()
{
if(outstandingHttpRequests.empty()) {
throw DlAbortEx(EX_NO_HTTP_REQUEST_ENTRY_FOUND);
throw DL_ABORT_EX(EX_NO_HTTP_REQUEST_ENTRY_FOUND);
}
HttpRequestEntryHandle entry = outstandingHttpRequests.front();
HttpHeaderProcessorHandle proc = entry->getHttpHeaderProcessor();
@ -133,7 +133,7 @@ HttpResponseHandle HttpConnection::receiveResponse()
if(socket->wantRead() || socket->wantWrite()) {
return SharedHandle<HttpResponse>();
} else {
throw DlRetryEx(EX_INVALID_RESPONSE);
throw DL_RETRY_EX(EX_INVALID_RESPONSE);
}
}
proc->update(buf, size);

8
src/HttpHeaderProcessor.cc
View File

@ -62,7 +62,7 @@ void HttpHeaderProcessor::update(const std::string& data)
void HttpHeaderProcessor::checkHeaderLimit(size_t incomingLength)
{
if(_buf.size()+incomingLength > _limit) {
throw DlAbortEx("Too large http header");
throw DL_ABORT_EX("Too large http header");
}
}
@ -99,7 +99,7 @@ SharedHandle<HttpHeader> HttpHeaderProcessor::getHttpResponseHeader()
if(((delimpos = _buf.find("\r\n")) == std::string::npos &&
(delimpos = _buf.find("\n")) == std::string::npos) ||
delimpos < 12) {
throw DlRetryEx(EX_NO_STATUS_HEADER);
throw DL_RETRY_EX(EX_NO_STATUS_HEADER);
}
HttpHeaderHandle httpHeader(new HttpHeader());
httpHeader->setVersion(_buf.substr(0, 8));
@ -120,12 +120,12 @@ SharedHandle<HttpHeader> HttpHeaderProcessor::getHttpRequestHeader()
if(((delimpos = _buf.find("\r\n")) == std::string::npos &&
(delimpos = _buf.find("\n")) == std::string::npos) ||
delimpos < 14) {
throw DlRetryEx(EX_NO_STATUS_HEADER);
throw DL_RETRY_EX(EX_NO_STATUS_HEADER);
}
std::deque<std::string> firstLine;
Util::slice(firstLine, _buf.substr(0, delimpos), ' ', true);
if(firstLine.size() != 3) {
throw DlAbortEx("Malformed HTTP request header.");
throw DL_ABORT_EX("Malformed HTTP request header.");
}
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->setMethod(firstLine[0]);

2
src/HttpInitiateConnectionCommand.cc
View File

@ -88,7 +88,7 @@ Command* HttpInitiateConnectionCommand::createNextCommand
command = c;
} else {
// TODO
throw DlAbortEx("ERROR");
throw DL_ABORT_EX("ERROR");
}
} else {
SharedHandle<HttpConnection> httpConnection

6
src/HttpResponse.cc
View File

@ -74,7 +74,7 @@ void HttpResponse::validateResponse() const
}
if(status >= HttpHeader::S300) {
if(!httpHeader->defined(HttpHeader::LOCATION)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_LOCATION_HEADER_REQUIRED,
Util::parseUInt(status)).str());
}
@ -82,7 +82,7 @@ void HttpResponse::validateResponse() const
// compare the received range against the requested range
RangeHandle responseRange = httpHeader->getRange();
if(!httpRequest->isRangeSatisfied(responseRange)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat
(EX_INVALID_RANGE_HEADER,
Util::itos(httpRequest->getStartByte(), true).c_str(),
@ -139,7 +139,7 @@ void HttpResponse::processRedirect()
logger->info(MSG_REDIRECT, cuid,
httpRequest->getRequest()->getCurrentUrl().c_str());
} else {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat("CUID#%d - Redirect to %s failed. It may not be a valid"
" URI.", cuid,
httpRequest->getRequest()->getCurrentUrl().c_str()).str());

4
src/HttpResponseCommand.cc
View File

@ -139,7 +139,7 @@ bool HttpResponseCommand::executeInternal()
dctx->setContentType(httpResponse->getContentType());
_requestGroup->preDownloadProcessing();
if(e->_requestGroupMan->isSameFileBeingDownloaded(_requestGroup)) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat(EX_DUPLICATE_FILE_DOWNLOAD,
_requestGroup->getFilePath().c_str()).str());
}
@ -276,7 +276,7 @@ static SharedHandle<Decoder> getTransferEncodingDecoder
if(httpResponse->isTransferEncodingSpecified()) {
decoder = httpResponse->getTransferEncodingDecoder();
if(decoder.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_TRANSFER_ENCODING_NOT_SUPPORTED,
httpResponse->getTransferEncoding().c_str()).str());
}

4
src/HttpServer.cc
View File

@ -66,7 +66,7 @@ SharedHandle<HttpHeader> HttpServer::receiveRequest()
unsigned char buf[size];
_socket->peekData(buf, size);
if(size == 0 && !(_socket->wantRead() || _socket->wantWrite())) {
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
_headerProcessor->update(buf, size);
if(!_headerProcessor->eoh()) {
@ -104,7 +104,7 @@ bool HttpServer::receiveBody()
(_lastContentLength-_lastBody.tellg()));
_socket->readData(buf, length);
if(length == 0 && !(_socket->wantRead() || _socket->wantWrite())) {
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
_lastBody.write(buf, length);
return _lastContentLength == static_cast<uint64_t>(_lastBody.tellp());

12
src/HttpSkipResponseCommand.cc
View File

@ -109,7 +109,7 @@ bool HttpSkipResponseCommand::executeInternal()
}
if(_totalLength != 0 && bufSize == 0 &&
!socket->wantRead() && !socket->wantWrite()) {
throw DlRetryEx(EX_GOT_EOF);
throw DL_RETRY_EX(EX_GOT_EOF);
}
} catch(RecoverableException& e) {
logger->debug(EX_EXCEPTION_CAUGHT, e);
@ -151,7 +151,7 @@ bool HttpSkipResponseCommand::processResponse()
unsigned int rnum =
_httpResponse->getHttpRequest()->getRequest()->getRedirectCount();
if(rnum >= Request::MAX_REDIRECT) {
throw DlAbortEx(StringFormat("Too many redirects: count=%u", rnum).str());
throw DL_ABORT_EX(StringFormat("Too many redirects: count=%u", rnum).str());
}
_httpResponse->processRedirect();
return prepareForRetry(0);
@ -165,13 +165,13 @@ bool HttpSkipResponseCommand::processResponse()
(req->getHost(), req->getDir())) {
return prepareForRetry(0);
} else {
throw DlAbortEx(EX_AUTH_FAILED);
throw DL_ABORT_EX(EX_AUTH_FAILED);
}
}else if(_httpResponse->getResponseStatus() == HttpHeader::S404) {
throw DlAbortEx(MSG_RESOURCE_NOT_FOUND,
DownloadResult::RESOURCE_NOT_FOUND);
throw DL_ABORT_EX2(MSG_RESOURCE_NOT_FOUND,
DownloadResult::RESOURCE_NOT_FOUND);
} else {
throw DlAbortEx(StringFormat(EX_BAD_STATUS, Util::parseUInt(_httpResponse->getResponseStatus())).str());
throw DL_ABORT_EX(StringFormat(EX_BAD_STATUS, Util::parseUInt(_httpResponse->getResponseStatus())).str());
}
} else {
return prepareForRetry(0);

2
src/InitiateConnectionCommandFactory.cc
View File

@ -67,7 +67,7 @@ InitiateConnectionCommandFactory::createInitiateConnectionCommand(int32_t cuid,
return new FtpInitiateConnectionCommand(cuid, req, requestGroup, e);
} else {
// these protocols are not supported yet
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("%s is not supported yet.",
req->getProtocol().c_str()).str());
}

2
src/IteratableChunkChecksumValidator.cc
View File

@ -152,7 +152,7 @@ std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length
size_t r = _pieceStorage->getDiskAdaptor()->readData(_buffer, BUFSIZE,
curoffset);
if(r == 0 || r < static_cast<size_t>(woffset)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_READ, _dctx->getActualBasePath().c_str(),
strerror(errno)).str());
}

6
src/LibgcryptARC4Context.h
View File

@ -36,9 +36,11 @@
#define _D_LIBGCRYPT_ARC4_CONTEXT_H_
#include "common.h"
#include <gcrypt.h>
#include "DlAbortEx.h"
#include "StringFormat.h"
#include <gcrypt.h>
namespace aria2 {
@ -48,7 +50,7 @@ private:
void handleError(gcry_error_t err) const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libgcrypt routine(ARC4Context class): %s",
gcry_strerror(err)).str());
}

6
src/LibgcryptARC4Decryptor.h
View File

@ -36,10 +36,12 @@
#define _D_LIBGCRYPT_ARC4_DECRYPTOR_H_
#include "common.h"
#include <gcrypt.h>
#include "DlAbortEx.h"
#include "LibgcryptARC4Context.h"
#include "StringFormat.h"
#include <gcrypt.h>
namespace aria2 {
@ -49,7 +51,7 @@ private:
void handleError(gcry_error_t err) const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libgcrypt routine(ARC4Decryptor class): %s",
gcry_strerror(err)).str());
}

6
src/LibgcryptARC4Encryptor.h
View File

@ -36,10 +36,12 @@
#define _D_LIBGCRYPT_ARC4_ENCRYPTOR_H_
#include "common.h"
#include <gcrypt.h>
#include "DlAbortEx.h"
#include "LibgcryptARC4Context.h"
#include "StringFormat.h"
#include <gcrypt.h>
namespace aria2 {
@ -49,7 +51,7 @@ private:
void handleError(gcry_error_t err) const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libgcrypt routine(ARC4Encryptor class): %s",
gcry_strerror(err)).str());
}

6
src/LibgcryptDHKeyExchange.h
View File

@ -56,7 +56,7 @@ private:
void handleError(gcry_error_t err) const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libgcrypt routine(DHKeyExchange class): %s",
gcry_strerror(err)).str());
}
@ -112,7 +112,7 @@ public:
size_t getPublicKey(unsigned char* out, size_t outLength) const
{
if(outLength < _keyLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Insufficient buffer for public key. expect:%u, actual:%u",
_keyLength, outLength).str());
}
@ -138,7 +138,7 @@ public:
size_t peerPublicKeyLength) const
{
if(outLength < _keyLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Insufficient buffer for secret. expect:%u, actual:%u",
_keyLength, outLength).str());
}

4
src/LibgnutlsTLSContext.cc
View File

@ -87,7 +87,7 @@ void TLSContext::addClientKeyFile(const std::string& certfile,
keyfile.c_str(),
GNUTLS_X509_FMT_PEM);
if(ret != GNUTLS_E_SUCCESS) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Failed to load client certificate from %s and"
" private key from %s. Cause: %s",
certfile.c_str(), keyfile.c_str(),
@ -102,7 +102,7 @@ void TLSContext::addTrustedCACertFile(const std::string& certfile)
certfile.c_str(),
GNUTLS_X509_FMT_PEM);
if(ret < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat
(MSG_LOADING_TRUSTED_CA_CERT_FAILED,
certfile.c_str(), gnutls_strerror(ret)).str());

8
src/LibsslARC4Context.h
View File

@ -36,11 +36,13 @@
#define _D_LIBSSL_ARC4_CONTEXT_H_
#include "common.h"
#include "DlAbortEx.h"
#include "StringFormat.h"
#include <openssl/evp.h>
#include <openssl/err.h>
#include "DlAbortEx.h"
#include "StringFormat.h"
namespace aria2 {
class LibsslARC4Context {
@ -49,7 +51,7 @@ private:
void handleError() const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libssl routine(ARC4Context class): %s",
ERR_error_string(ERR_get_error(), 0)).str());
}

8
src/LibsslARC4Decryptor.h
View File

@ -36,11 +36,13 @@
#define _D_LIBSSL_ARC4_DECRYPTOR_H_
#include "common.h"
#include <openssl/evp.h>
#include <openssl/err.h>
#include "DlAbortEx.h"
#include "LibsslARC4Context.h"
#include "StringFormat.h"
#include <openssl/evp.h>
#include <openssl/err.h>
namespace aria2 {
@ -50,7 +52,7 @@ private:
void handleError() const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libssl routine(ARC4Decryptor class): %s",
ERR_error_string(ERR_get_error(), 0)).str());
}

8
src/LibsslARC4Encryptor.h
View File

@ -36,11 +36,13 @@
#define _D_LIBSSL_ARC4_ENCRYPTOR_H_
#include "common.h"
#include <openssl/evp.h>
#include <openssl/err.h>
#include "DlAbortEx.h"
#include "LibsslARC4Context.h"
#include "StringFormat.h"
#include <openssl/evp.h>
#include <openssl/err.h>
namespace aria2 {
@ -50,7 +52,7 @@ private:
void handleError() const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libssl routine(ARC4Encryptor class): %s",
ERR_error_string(ERR_get_error(), 0)).str());
}

10
src/LibsslDHKeyExchange.h
View File

@ -62,7 +62,7 @@ private:
void handleError(const std::string& funName) const
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Exception in libssl routine %s(DHKeyExchange class): %s",
funName.c_str(), ERR_error_string(ERR_get_error(), 0)).str());
}
@ -123,7 +123,7 @@ public:
size_t getPublicKey(unsigned char* out, size_t outLength) const
{
if(outLength < _keyLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Insufficient buffer for public key. expect:%u, actual:%u",
_keyLength, outLength).str());
}
@ -132,7 +132,7 @@ public:
size_t offset = _keyLength-publicKeyBytes;
size_t nwritten = BN_bn2bin(_publicKey, out+offset);
if(nwritten != publicKeyBytes) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("BN_bn2bin in DHKeyExchange::getPublicKey, %u bytes written, but %u bytes expected.", nwritten, publicKeyBytes).str());
}
return nwritten;
@ -150,7 +150,7 @@ public:
size_t peerPublicKeyLength) const
{
if(outLength < _keyLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Insufficient buffer for secret. expect:%u, actual:%u",
_keyLength, outLength).str());
}
@ -171,7 +171,7 @@ public:
size_t nwritten = BN_bn2bin(secret, out+offset);
BN_free(secret);
if(nwritten != secretBytes) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("BN_bn2bin in DHKeyExchange::getPublicKey, %u bytes written, but %u bytes expected.", nwritten, secretBytes).str());
}
return nwritten;

6
src/LibsslTLSContext.cc
View File

@ -79,13 +79,13 @@ void TLSContext::addClientKeyFile(const std::string& certfile,
{
if(SSL_CTX_use_PrivateKey_file(_sslCtx, keyfile.c_str(),
SSL_FILETYPE_PEM) != 1) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat
("Failed to load client private key from %s. Cause: %s",
keyfile.c_str(), ERR_error_string(ERR_get_error(), 0)).str());
}
if(SSL_CTX_use_certificate_chain_file(_sslCtx, certfile.c_str()) != 1) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat
("Failed to load client certificate from %s. Cause: %s",
certfile.c_str(), ERR_error_string(ERR_get_error(), 0)).str());
@ -96,7 +96,7 @@ void TLSContext::addTrustedCACertFile(const std::string& certfile)
throw(DlAbortEx)
{
if(SSL_CTX_load_verify_locations(_sslCtx, certfile.c_str(), 0) != 1) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat
(MSG_LOADING_TRUSTED_CA_CERT_FAILED,
certfile.c_str(), ERR_error_string(ERR_get_error(), 0)).str());

24
src/MSEHandshake.cc
View File

@ -95,7 +95,7 @@ MSEHandshake::HANDSHAKE_TYPE MSEHandshake::identifyHandshakeType()
size_t r = 20-_rbufLength;
_socket->readData(_rbuf+_rbufLength, r);
if(r == 0 && !_socket->wantRead() && !_socket->wantWrite()) {
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
_rbufLength += r;
if(_rbufLength < 20) {
@ -305,7 +305,7 @@ bool MSEHandshake::findInitiatorVCMarker()
if(_socket->wantRead() || _socket->wantWrite()) {
return false;
}
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
// find vc
{
@ -313,7 +313,7 @@ bool MSEHandshake::findInitiatorVCMarker()
std::string vc(&_initiatorVCMarker[0], &_initiatorVCMarker[VC_LENGTH]);
if((_markerIndex = buf.find(vc)) == std::string::npos) {
if(616-KEY_LENGTH <= _rbufLength+r) {
throw DlAbortEx("Failed to find VC marker.");
throw DL_ABORT_EX("Failed to find VC marker.");
} else {
_socket->readData(_rbuf+_rbufLength, r);
_rbufLength += r;
@ -355,7 +355,7 @@ bool MSEHandshake::receiveInitiatorCryptoSelectAndPadDLength()
_negotiatedCryptoType = CRYPTO_ARC4;
}
if(_negotiatedCryptoType == CRYPTO_NONE) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("CUID#%d - No supported crypto type selected.", _cuid).str());
}
}
@ -395,7 +395,7 @@ bool MSEHandshake::findReceiverHashMarker()
if(_socket->wantRead() || _socket->wantWrite()) {
return false;
}
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
// find hash('req1', S), S is _secret.
{
@ -405,7 +405,7 @@ bool MSEHandshake::findReceiverHashMarker()
std::string req1(&md[0], &md[sizeof(md)]);
if((_markerIndex = buf.find(req1)) == std::string::npos) {
if(628-KEY_LENGTH <= _rbufLength+r) {
throw DlAbortEx("Failed to find hash marker.");
throw DL_ABORT_EX("Failed to find hash marker.");
} else {
_socket->readData(_rbuf+_rbufLength, r);
_rbufLength += r;
@ -447,7 +447,7 @@ bool MSEHandshake::receiveReceiverHashAndPadCLength
}
}
if(btContext.isNull()) {
throw DlAbortEx("Unknown info hash.");
throw DL_ABORT_EX("Unknown info hash.");
}
initCipher(btContext->getInfoHash());
@ -471,7 +471,7 @@ bool MSEHandshake::receiveReceiverHashAndPadCLength
_negotiatedCryptoType = CRYPTO_ARC4;
}
if(_negotiatedCryptoType == CRYPTO_NONE) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("CUID#%d - No supported crypto type provided.", _cuid).str());
}
}
@ -547,7 +547,7 @@ uint16_t MSEHandshake::verifyPadLength(const unsigned char* padlenbuf, const cha
uint16_t padLength = decodeLength16(padlenbuf);
_logger->debug("CUID#%d - len(%s)=%u", _cuid, padName, padLength);
if(padLength > 512) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Too large %s length: %u", padName, padLength).str());
}
return padLength;
@ -559,7 +559,7 @@ void MSEHandshake::verifyVC(const unsigned char* vcbuf)
unsigned char vc[VC_LENGTH];
_decryptor->decrypt(vc, sizeof(vc), vcbuf, sizeof(vc));
if(memcmp(VC, vc, sizeof(VC)) != 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Invalid VC: %s", Util::toHex(vc, VC_LENGTH).c_str()).str());
}
}
@ -570,7 +570,7 @@ void MSEHandshake::verifyReq1Hash(const unsigned char* req1buf)
unsigned char md[20];
createReq1Hash(md);
if(memcmp(md, req1buf, sizeof(md)) != 0) {
throw DlAbortEx("Invalid req1 hash found.");
throw DL_ABORT_EX("Invalid req1 hash found.");
}
}
@ -583,7 +583,7 @@ size_t MSEHandshake::receiveNBytes(size_t bytes)
}
_socket->readData(_rbuf+_rbufLength, r);
if(r == 0 && !_socket->wantRead() && !_socket->wantWrite()) {
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
_rbufLength += r;
}

6
src/MessageDigestHelper.cc
View File

@ -91,7 +91,7 @@ std::string MessageDigestHelper::digest(MessageDigestContext* ctx,
for(uint64_t i = 0; i < iteration; ++i) {
ssize_t readLength = bs->readData(BUF, BUFSIZE, offset);
if((size_t)readLength != BUFSIZE) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_READ, "n/a", strerror(errno)).str());
}
ctx->digestUpdate(BUF, readLength);
@ -100,7 +100,7 @@ std::string MessageDigestHelper::digest(MessageDigestContext* ctx,
if(tail) {
ssize_t readLength = bs->readData(BUF, tail, offset);
if((size_t)readLength != tail) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_READ, "n/a", strerror(errno)).str());
}
ctx->digestUpdate(BUF, readLength);
@ -130,7 +130,7 @@ void MessageDigestHelper::digest(unsigned char* md, size_t mdLength,
const std::string& algo, const void* data, size_t length)
{
if(mdLength < MessageDigestContext::digestLength(algo)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Insufficient space for storing message digest: %d required, but only %d is allocated",
MessageDigestContext::digestLength(algo), mdLength).str());
}

2
src/MetalinkHelper.cc
View File

@ -71,7 +71,7 @@ void MetalinkHelper::query
const SharedHandle<Metalinker>& metalinker, const Option* option)
{
if(metalinker->entries.empty()) {
throw DlAbortEx("No file entry found. Probably, the metalink file is not configured properly or broken.");
throw DL_ABORT_EX("No file entry found. Probably, the metalink file is not configured properly or broken.");
}
metalinker->queryEntry(result,
option->get(PREF_METALINK_VERSION),

4
src/MultiDiskAdaptor.cc
View File

@ -398,7 +398,7 @@ findFirstDiskWriterEntry(const DiskWriterEntries& diskWriterEntries, off_t offse
// In case when offset is out-of-range
if(!isInRange(*first, offset)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_OFFSET_OUT_OF_RANGE,
Util::itos(offset, true).c_str()).str());
}
@ -408,7 +408,7 @@ findFirstDiskWriterEntry(const DiskWriterEntries& diskWriterEntries, off_t offse
static void throwOnDiskWriterNotOpened(const SharedHandle<DiskWriterEntry>& e,
off_t offset)
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("DiskWriter for offset=%s, filename=%s is not opened.",
Util::itos(offset).c_str(),
e->getFilePath().c_str()).str());

2
src/NameMatchOptionHandler.h
View File

@ -99,7 +99,7 @@ public:
try {
parseArg(option, arg);
} catch(Exception& e) {
throw OptionHandlerException(_optName, e);
throw OPTION_HANDLER_EXCEPTION2(_optName, e);
}
}

2
src/NameResolver.cc
View File

@ -56,7 +56,7 @@ void NameResolver::resolve(std::deque<std::string>& resolvedAddresses,
int s;
s = getaddrinfo(hostname.c_str(), 0, &hints, &res);
if(s) {
throw DlAbortEx(StringFormat(EX_RESOLVE_HOSTNAME,
throw DL_ABORT_EX(StringFormat(EX_RESOLVE_HOSTNAME,
hostname.c_str(), gai_strerror(s)).str());
}
struct addrinfo* rp;

14
src/Netrc.cc
View File

@ -33,12 +33,14 @@
*/
/* copyright --> */
#include "Netrc.h"
#include "RecoverableException.h"
#include "StringFormat.h"
#include "A2STR.h"
#include <fstream>
#include <algorithm>
#include "DlAbortEx.h"
#include "StringFormat.h"
#include "A2STR.h"
namespace aria2 {
const std::string Netrc::MACHINE("machine");
@ -59,7 +61,7 @@ std::string Netrc::getRequiredNextToken(std::ifstream& f) const
if(f >> token) {
return token;
} else {
throw RecoverableException
throw DL_ABORT_EX
("Netrc:parse error. EOF reached where a token expected.");
}
}
@ -81,7 +83,7 @@ void Netrc::parse(const std::string& path)
std::ifstream f(path.c_str(), std::ios::binary);
if(!f) {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("File not found: %s", path.c_str()).str());
}
@ -97,7 +99,7 @@ void Netrc::parse(const std::string& path)
authenticator.reset(new DefaultAuthenticator());
} else {
if(authenticator.isNull()) {
throw RecoverableException
throw DL_ABORT_EX
("Netrc:parse error. %s encounterd where 'machine' or 'default' expected.");
}
if(token == Netrc::LOGIN) {

8
src/NsCookieParser.cc
View File

@ -33,11 +33,13 @@
*/
/* copyright --> */
#include "NsCookieParser.h"
#include <fstream>
#include "Util.h"
#include "A2STR.h"
#include "RecoverableException.h"
#include "DlAbortEx.h"
#include "StringFormat.h"
#include <fstream>
namespace aria2 {
@ -75,7 +77,7 @@ std::deque<Cookie> NsCookieParser::parse(const std::string& filename)
{
std::ifstream s(filename.c_str(), std::ios::binary);
if(!s) {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Failed to open file %s", filename.c_str()).str());
}
std::string line;

22
src/OptionHandlerException.cc
View File

@ -40,18 +40,22 @@ namespace aria2 {
const std::string OptionHandlerException::MESSAGE
("Exception occurred while processing option %s:");
OptionHandlerException::OptionHandlerException(const std::string& optName):
OptionHandlerException::OptionHandlerException(const char* file, int line,
const std::string& optName):
RecoverableException
(StringFormat(MESSAGE.c_str(), optName.c_str()).str()), _optName(optName) {}
OptionHandlerException::OptionHandlerException(const std::string& optName,
const Exception& cause):
RecoverableException
(StringFormat(MESSAGE.c_str(), optName.c_str()).str(), cause),
(file, line, StringFormat(MESSAGE.c_str(), optName.c_str()).str()),
_optName(optName) {}
OptionHandlerException::OptionHandlerException(const OptionHandlerException& e):
RecoverableException(e), _optName(e._optName) {}
OptionHandlerException::OptionHandlerException(const char* file, int line,
const std::string& optName,
const Exception& cause):
RecoverableException
(file, line, StringFormat(MESSAGE.c_str(), optName.c_str()).str(), cause),
_optName(optName) {}
OptionHandlerException::OptionHandlerException(const char* file, int line,
const OptionHandlerException& e):
RecoverableException(file, line, e), _optName(e._optName) {}
OptionHandlerException::~OptionHandlerException() throw() {}

14
src/OptionHandlerException.h
View File

@ -46,17 +46,25 @@ private:
protected:
virtual SharedHandle<Exception> copy() const;
public:
OptionHandlerException(const std::string& optName);
OptionHandlerException(const char* file, int line,
const std::string& optName);
OptionHandlerException(const std::string& optName, const Exception& cause);
OptionHandlerException(const char* file, int line, const std::string& optName,
const Exception& cause);
OptionHandlerException(const OptionHandlerException& e);
OptionHandlerException(const char* file, int line,
const OptionHandlerException& e);
virtual ~OptionHandlerException() throw();
const std::string& getOptionName() const throw();
};
#define OPTION_HANDLER_EXCEPTION(arg)\
OptionHandlerException(__FILE__, __LINE__, arg)
#define OPTION_HANDLER_EXCEPTION2(arg1, arg2)\
OptionHandlerException(__FILE__, __LINE__, arg1, arg2)
} // namespace aria2
#endif // _D_OPTION_HANDLER_EXCEPTION_EX_H_

14
src/OptionHandlerImpl.h
View File

@ -127,7 +127,7 @@ public:
option.put(_optName, V_FALSE);
} else {
std::string msg = _optName+" "+_("must be either 'true' or 'false'.");
throw DlAbortEx(msg);
throw DL_ABORT_EX(msg);
}
}
@ -160,7 +160,7 @@ public:
int32_t v = seq.next();
if(v < _min || _max < v) {
std::string msg = _optName+" "+_("must be between %s and %s.");
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(msg.c_str(), Util::itos(_min).c_str(),
Util::itos(_max).c_str()).str());
}
@ -215,7 +215,7 @@ public:
} else {
msg += _("must be a number.");
}
throw DlAbortEx(msg);
throw DL_ABORT_EX(msg);
}
}
@ -281,7 +281,7 @@ public:
} else {
msg += _("must be a number.");
}
throw DlAbortEx(msg);
throw DL_ABORT_EX(msg);
}
}
@ -462,7 +462,7 @@ public:
msg += "'"+*itr+"' ";
}
}
throw DlAbortEx(msg);
throw DL_ABORT_EX(msg);
} else {
option.put(_optName, optarg);
}
@ -502,7 +502,7 @@ public:
int32_t port = Util::parseInt(proxy.second);
if(proxy.first.empty() || proxy.second.empty() ||
port <= 0 || 65535 < port) {
throw DlAbortEx(_("unrecognized proxy format"));
throw DL_ABORT_EX(_("unrecognized proxy format"));
}
option.put(_optName, optarg);
setHostAndPort(option, proxy.first, port);
@ -545,7 +545,7 @@ public:
if(req.setUrl(url)) {
option.put(_optName, url);
} else {
throw DlAbortEx(_("unrecognized proxy format"));
throw DL_ABORT_EX(_("unrecognized proxy format"));
}
}

2
src/OptionParser.cc
View File

@ -142,7 +142,7 @@ void OptionParser::parseArg
op = findByShortName(c);
}
if(op.isNull()) {
throw DlAbortEx("Failed to parse command-line options.");
throw DL_ABORT_EX("Failed to parse command-line options.");
}
out << op->getName() << "=";
if(optarg) {

12
src/ParameterizedStringParser.cc
View File

@ -88,12 +88,12 @@ PStringDatumHandle ParameterizedStringParser::createSelect(const std::string& sr
++offset;
std::string::size_type rightParenIndex = src.find("}", offset);
if(rightParenIndex == std::string::npos) {
throw DlAbortEx("Missing '}' in the parameterized string.");
throw DL_ABORT_EX("Missing '}' in the parameterized string.");
}
std::deque<std::string> values;
Util::slice(values, src.substr(offset, rightParenIndex-offset), ',', true);
if(values.empty()) {
throw DlAbortEx("Empty {} is not allowed.");
throw DL_ABORT_EX("Empty {} is not allowed.");
}
offset = rightParenIndex+1;
PStringDatumHandle next = diggPString(src, offset);
@ -106,7 +106,7 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
++offset;
std::string::size_type rightParenIndex = src.find("]", offset);
if(rightParenIndex == std::string::npos) {
throw DlAbortEx("Missing ']' in the parameterized string.");
throw DL_ABORT_EX("Missing ']' in the parameterized string.");
}
std::string loopStr = src.substr(offset, rightParenIndex-offset);
offset = rightParenIndex+1;
@ -118,13 +118,13 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
if(Util::isNumber(stepStr)) {
step = Util::parseUInt(stepStr);
} else {
throw DlAbortEx("A step count must be a positive number.");
throw DL_ABORT_EX("A step count must be a positive number.");
}
loopStr.erase(colonIndex);
}
std::pair<std::string, std::string> range = Util::split(loopStr, "-");
if(range.first.empty() || range.second.empty()) {
throw DlAbortEx("Loop range missing.");
throw DL_ABORT_EX("Loop range missing.");
}
NumberDecoratorHandle nd;
unsigned int start;
@ -142,7 +142,7 @@ PStringDatumHandle ParameterizedStringParser::createLoop(const std::string& src,
start = Util::alphaToNum(range.first);
end = Util::alphaToNum(range.second);
} else {
throw DlAbortEx("Invalid loop range.");
throw DL_ABORT_EX("Invalid loop range.");
}
PStringDatumHandle next(diggPString(src, offset));

4
src/PeerAbstractCommand.cc
View File

@ -87,12 +87,12 @@ bool PeerAbstractCommand::execute()
_hupEvent) {
checkPoint.reset();
} else if(_errorEvent) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_NETWORK_PROBLEM,
socket->getSocketError().c_str()).str());
}
if(checkPoint.elapsed(timeout)) {
throw DlAbortEx(EX_TIME_OUT);
throw DL_ABORT_EX(EX_TIME_OUT);
}
return executeInternal();
} catch(DownloadFailureException& err) {

8
src/PeerConnection.cc
View File

@ -90,7 +90,7 @@ bool PeerConnection::receiveMessage(unsigned char* data, size_t& dataLength) {
// we got EOF
logger->debug("CUID#%d - In PeerConnection::receiveMessage(), remain=%lu",
cuid, static_cast<unsigned long>(temp));
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
lenbufLength += remaining;
if(4 > lenbufLength) {
@ -99,7 +99,7 @@ bool PeerConnection::receiveMessage(unsigned char* data, size_t& dataLength) {
}
uint32_t payloadLength = ntohl(*(reinterpret_cast<uint32_t*>(lenbuf)));
if(payloadLength > MAX_PAYLOAD_LEN) {
throw DlAbortEx(StringFormat(EX_TOO_LONG_PAYLOAD, payloadLength).str());
throw DL_ABORT_EX(StringFormat(EX_TOO_LONG_PAYLOAD, payloadLength).str());
}
currentPayloadLength = payloadLength;
}
@ -121,7 +121,7 @@ bool PeerConnection::receiveMessage(unsigned char* data, size_t& dataLength) {
cuid,
static_cast<unsigned long>(currentPayloadLength),
static_cast<unsigned long>(temp));
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
resbufLength += remaining;
if(currentPayloadLength > resbufLength) {
@ -168,7 +168,7 @@ bool PeerConnection::receiveHandshake(unsigned char* data, size_t& dataLength,
logger->debug
("CUID#%d - In PeerConnection::receiveHandshake(), remain=%lu",
cuid, static_cast<unsigned long>(temp));
throw DlAbortEx(EX_EOF_FROM_PEER);
throw DL_ABORT_EX(EX_EOF_FROM_PEER);
}
resbufLength += remaining;
if(BtHandshakeMessage::MESSAGE_LENGTH > resbufLength) {

22
src/PeerMessageUtil.cc
View File

@ -65,38 +65,38 @@ uint16_t PeerMessageUtil::getShortIntParam(const unsigned char* msg, size_t pos)
void PeerMessageUtil::checkIndex(size_t index, size_t pieces) {
if(!(index < pieces)) {
throw DlAbortEx(StringFormat("Invalid index: %lu",
throw DL_ABORT_EX(StringFormat("Invalid index: %lu",
static_cast<unsigned long>(index)).str());
}
}
void PeerMessageUtil::checkBegin(uint32_t begin, size_t pieceLength) {
if(!(begin < pieceLength)) {
throw DlAbortEx(StringFormat("Invalid begin: %u", begin).str());
throw DL_ABORT_EX(StringFormat("Invalid begin: %u", begin).str());
}
}
void PeerMessageUtil::checkLength(size_t length) {
if(length > MAX_BLOCK_LENGTH) {
throw DlAbortEx(StringFormat("Length too long: %lu > %uKB",
throw DL_ABORT_EX(StringFormat("Length too long: %lu > %uKB",
static_cast<unsigned long>(length),
MAX_BLOCK_LENGTH/1024).str());
}
if(length == 0) {
throw DlAbortEx(StringFormat("Invalid length: %lu",
throw DL_ABORT_EX(StringFormat("Invalid length: %lu",
static_cast<unsigned long>(length)).str());
}
}
void PeerMessageUtil::checkRange(uint32_t begin, size_t length, size_t pieceLength) {
if(!(0 < length)) {
throw DlAbortEx(StringFormat("Invalid range: begin=%u, length=%lu",
throw DL_ABORT_EX(StringFormat("Invalid range: begin=%u, length=%lu",
begin,
static_cast<unsigned long>(length)).str());
}
uint32_t end = begin+length;
if(!(end <= pieceLength)) {
throw DlAbortEx(StringFormat("Invalid range: begin=%u, length=%lu",
throw DL_ABORT_EX(StringFormat("Invalid range: begin=%u, length=%lu",
begin,
static_cast<unsigned long>(length)).str());
}
@ -106,14 +106,14 @@ void PeerMessageUtil::checkBitfield(const unsigned char* bitfield,
size_t bitfieldLength,
size_t pieces) {
if(!(bitfieldLength == (pieces+7)/8)) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Invalid bitfield length: %lu",
static_cast<unsigned long>(bitfieldLength)).str());
}
char lastbyte = bitfield[bitfieldLength-1];
for(size_t i = 0; i < 8-pieces%8 && pieces%8 != 0; ++i) {
if(!(((lastbyte >> i) & 1) == 0)) {
throw DlAbortEx("Invalid bitfield");
throw DL_ABORT_EX("Invalid bitfield");
}
}
}
@ -187,7 +187,7 @@ void PeerMessageUtil::assertPayloadLengthGreater
(size_t threshold, size_t actual, const std::string& msgName)
{
if(actual <= threshold) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_TOO_SMALL_PAYLOAD_SIZE, msgName.c_str(), actual).str());
}
}
@ -196,7 +196,7 @@ void PeerMessageUtil::assertPayloadLengthEqual
(size_t expected, size_t actual, const std::string& msgName)
{
if(expected != actual) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_INVALID_PAYLOAD_SIZE, msgName.c_str(),
actual, expected).str());
}
@ -207,7 +207,7 @@ void PeerMessageUtil::assertID
{
uint8_t id = getId(data);
if(expected != id) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_INVALID_BT_MESSAGE_ID, id, msgName.c_str(),
expected).str());
}

2
src/PeerReceiveHandshakeCommand.cc
View File

@ -102,7 +102,7 @@ bool PeerReceiveHandshakeCommand::executeInternal()
btRegistry->getPeerStorage(infoHash);
if(btContext.isNull() || !btRuntime->ready()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Unknown info hash %s", infoHash.c_str()).str());
}
TransferStat tstat = btContext->getOwnerRequestGroup()->calculateStat();

2
src/Platform.cc
View File

@ -102,7 +102,7 @@ bool Platform::setUp()
WSADATA wsaData;
memset((char*)&wsaData, 0, sizeof(wsaData));
if (WSAStartup(MAKEWORD(1, 1), &wsaData)) {
throw DlAbortEx(MSG_WINSOCK_INIT_FAILD);
throw DL_ABORT_EX(MSG_WINSOCK_INIT_FAILD);
}
#endif // HAVE_WINSOCK2_H

4
src/ReceiverMSEHandshakeCommand.cc
View File

@ -95,7 +95,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
break;
case MSEHandshake::HANDSHAKE_LEGACY: {
if(e->option->getAsBool(PREF_BT_REQUIRE_CRYPTO)) {
throw DlAbortEx("The legacy BitTorrent handshake is not acceptable by the preference.");
throw DL_ABORT_EX("The legacy BitTorrent handshake is not acceptable by the preference.");
}
SharedHandle<PeerConnection> peerConnection
(new PeerConnection(cuid, socket));
@ -107,7 +107,7 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
return true;
}
default:
throw DlAbortEx("Not supported handshake type.");
throw DL_ABORT_EX("Not supported handshake type.");
}
break;
}

19
src/RecoverableException.h
View File

@ -50,20 +50,23 @@ protected:
return e;
}
public:
RecoverableException(const std::string& msg):
Exception(msg),
RecoverableException(const char* file, int line, const std::string& msg):
Exception(file, line, msg),
_code(DownloadResult::UNKNOWN_ERROR) {}
RecoverableException(const std::string& msg, const Exception& cause):
Exception(msg, cause),
RecoverableException(const char* file, int line, const std::string& msg,
const Exception& cause):
Exception(file, line, msg, cause),
_code(DownloadResult::UNKNOWN_ERROR) {}
RecoverableException(const RecoverableException& e):
Exception(e),
RecoverableException(const char* file, int line,
const RecoverableException& e):
Exception(file, line, e),
_code(DownloadResult::UNKNOWN_ERROR) {}
RecoverableException(const std::string& msg, DownloadResult::RESULT result):
Exception(msg), _code(result) {}
RecoverableException(const char* file, int line, const std::string& msg,
DownloadResult::RESULT result):
Exception(file, line, msg), _code(result) {}
DownloadResult::RESULT getCode() const { return _code; }
};

22
src/RequestGroup.cc
View File

@ -207,18 +207,18 @@ void RequestGroup::createInitialCommand(std::deque<Command*>& commands,
BtContextHandle btContext = dynamic_pointer_cast<BtContext>(_downloadContext);
if(!btContext.isNull()) {
if(_option->getAsBool(PREF_DRY_RUN)) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
("Cancel BitTorrent download in dry-run context.");
}
SharedHandle<BtRegistry> btRegistry = e->getBtRegistry();
if(!btRegistry->getBtContext(btContext->getInfoHashAsString()).isNull()) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat("InfoHash %s is already registered.",
btContext->getInfoHashAsString().c_str()).str());
}
if(e->_requestGroupMan->isSameFileBeingDownloaded(this)) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat(EX_DUPLICATE_FILE_DOWNLOAD,
getFilePath().c_str()).str());
}
@ -313,7 +313,7 @@ void RequestGroup::createInitialCommand(std::deque<Command*>& commands,
!_option->getAsBool(PREF_ALLOW_OVERWRITE) &&
!_option->getAsBool(PREF_BT_SEED_UNVERIFIED)) {
// TODO we need this->haltRequested = true?
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat
(MSG_FILE_ALREADY_EXISTS,
getFilePath().c_str()).str());
@ -364,7 +364,7 @@ void RequestGroup::createInitialCommand(std::deque<Command*>& commands,
createNextCommand(commands, e, 1, method);
}else {
if(e->_requestGroupMan->isSameFileBeingDownloaded(this)) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat(EX_DUPLICATE_FILE_DOWNLOAD,
getFilePath().c_str()).str());
}
@ -529,7 +529,7 @@ void RequestGroup::loadAndOpenFile(const BtProgressInfoFileHandle& progressInfoF
}
setProgressInfoFile(progressInfoFile);
} catch(RecoverableException& e) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION2
(StringFormat(EX_DOWNLOAD_ABORTED).str(), e);
}
}
@ -546,12 +546,12 @@ void RequestGroup::shouldCancelDownloadForSafety()
if(tryAutoFileRenaming()) {
_logger->notice(MSG_FILE_RENAMED, getFilePath().c_str());
} else {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat("File renaming failed: %s",
getFilePath().c_str()).str());
}
} else {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION
(StringFormat(MSG_FILE_ALREADY_EXISTS,
getFilePath().c_str()).str());
}
@ -722,7 +722,7 @@ void RequestGroup::validateFilename(const std::string& expectedFilename,
return;
}
if(expectedFilename != actualFilename) {
throw DlAbortEx(StringFormat(EX_FILENAME_MISMATCH,
throw DL_ABORT_EX(StringFormat(EX_FILENAME_MISMATCH,
expectedFilename.c_str(),
actualFilename.c_str()).str());
}
@ -735,7 +735,7 @@ void RequestGroup::validateTotalLength(uint64_t expectedTotalLength,
return;
}
if(expectedTotalLength != actualTotalLength) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_SIZE_MISMATCH,
Util::itos(expectedTotalLength, true).c_str(),
Util::itos(actualTotalLength, true).c_str()).str());
@ -1200,7 +1200,7 @@ void RequestGroup::increaseAndValidateFileNotFoundCount()
const unsigned int maxCount = _option->getAsInt(PREF_MAX_FILE_NOT_FOUND);
if(maxCount > 0 && _fileNotFoundCount >= maxCount &&
_segmentMan->calculateSessionDownloadLength() == 0) {
throw DownloadFailureException
throw DOWNLOAD_FAILURE_EXCEPTION2
(StringFormat("Reached max-file-not-found count=%u", maxCount).str(),
DownloadResult::MAX_FILE_NOT_FOUND);
}

2
src/SimpleLogger.cc
View File

@ -94,7 +94,7 @@ SimpleLogger::~SimpleLogger() {
void SimpleLogger::openFile(const std::string& filename) {
file.open(filename.c_str(), std::ios::app|std::ios::binary);
if(!file) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_OPEN, filename.c_str(), strerror(errno)).str());
}
}

110
src/SocketCore.cc
View File

@ -173,7 +173,7 @@ void SocketCore::bind(uint16_t port)
int s;
s = getaddrinfo(0, uitos(port).c_str(), &hints, &res);
if(s) {
throw DlAbortEx(StringFormat(EX_SOCKET_BIND, gai_strerror(s)).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, gai_strerror(s)).str());
}
struct addrinfo* rp;
for(rp = res; rp; rp = rp->ai_next) {
@ -195,14 +195,14 @@ void SocketCore::bind(uint16_t port)
}
freeaddrinfo(res);
if(sockfd == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_BIND, "all addresses failed").str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, "all addresses failed").str());
}
}
void SocketCore::beginListen()
{
if(listen(sockfd, 1) == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_LISTEN, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_LISTEN, errorMsg()).str());
}
}
@ -213,7 +213,7 @@ SocketCore* SocketCore::acceptConnection() const
sock_t fd;
while((fd = accept(sockfd, reinterpret_cast<struct sockaddr*>(&sockaddr), &len)) == -1 && SOCKET_ERRNO == EINTR);
if(fd == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_ACCEPT, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_ACCEPT, errorMsg()).str());
}
return new SocketCore(fd, _sockType);
}
@ -224,7 +224,7 @@ void SocketCore::getAddrInfo(std::pair<std::string, uint16_t>& addrinfo) const
socklen_t len = sizeof(sockaddr);
struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr);
if(getsockname(sockfd, addrp, &len) == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str());
}
addrinfo = Util::getNumericNameInfo(addrp, len);
}
@ -235,7 +235,7 @@ void SocketCore::getPeerInfo(std::pair<std::string, uint16_t>& peerinfo) const
socklen_t len = sizeof(sockaddr);
struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr);
if(getpeername(sockfd, addrp, &len) == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str());
}
peerinfo = Util::getNumericNameInfo(addrp, len);
}
@ -254,7 +254,7 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port)
int s;
s = getaddrinfo(host.c_str(), uitos(port).c_str(), &hints, &res);
if(s) {
throw DlAbortEx(StringFormat(EX_RESOLVE_HOSTNAME,
throw DL_ABORT_EX(StringFormat(EX_RESOLVE_HOSTNAME,
host.c_str(), gai_strerror(s)).str());
}
struct addrinfo* rp;
@ -283,7 +283,7 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port)
}
freeaddrinfo(res);
if(sockfd == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_CONNECT, host.c_str(),
throw DL_ABORT_EX(StringFormat(EX_SOCKET_CONNECT, host.c_str(),
"all addresses failed").str());
}
}
@ -293,7 +293,7 @@ void SocketCore::setNonBlockingMode()
#ifdef __MINGW32__
static u_long flag = 1;
if (::ioctlsocket(sockfd, FIONBIO, &flag) == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_NONBLOCKING, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_NONBLOCKING, errorMsg()).str());
}
#else
int flags;
@ -309,7 +309,7 @@ void SocketCore::setBlockingMode()
#ifdef __MINGW32__
static u_long flag = 0;
if (::ioctlsocket(sockfd, FIONBIO, &flag) == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_BLOCKING, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BLOCKING, errorMsg()).str());
}
#else
int flags;
@ -355,7 +355,7 @@ void SocketCore::closeConnection()
void SocketCore::initEPOLL()
{
if((_epfd = epoll_create(1)) == -1) {
throw DlRetryEx(StringFormat("epoll_create failed:%s", errorMsg()).str());
throw DL_RETRY_EX(StringFormat("epoll_create failed:%s", errorMsg()).str());
}
memset(&_epEvent, 0, sizeof(struct epoll_event));
@ -363,7 +363,7 @@ void SocketCore::initEPOLL()
_epEvent.data.fd = sockfd;
if(epoll_ctl(_epfd, EPOLL_CTL_ADD, sockfd, &_epEvent) == -1) {
throw DlRetryEx(StringFormat("epoll_ctl failed:%s", errorMsg()).str());
throw DL_RETRY_EX(StringFormat("epoll_ctl failed:%s", errorMsg()).str());
}
}
@ -384,7 +384,7 @@ bool SocketCore::isWritable(time_t timeout)
} else if(r == 0) {
return false;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_CHECK_WRITABLE, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_CHECK_WRITABLE, errorMsg()).str());
}
} else
#endif // HAVE_EPOLL
@ -407,7 +407,7 @@ bool SocketCore::isWritable(time_t timeout)
if(SOCKET_ERRNO == A2_EINPROGRESS || SOCKET_ERRNO == EINTR) {
return false;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_CHECK_WRITABLE, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_CHECK_WRITABLE, errorMsg()).str());
}
}
} else {
@ -437,7 +437,7 @@ bool SocketCore::isReadable(time_t timeout)
} else if(r == 0) {
return false;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_CHECK_READABLE, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_CHECK_READABLE, errorMsg()).str());
}
} else
#endif // HAVE_EPOLL
@ -460,7 +460,7 @@ bool SocketCore::isReadable(time_t timeout)
if(SOCKET_ERRNO == A2_EINPROGRESS || SOCKET_ERRNO == EINTR) {
return false;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_CHECK_READABLE, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_CHECK_READABLE, errorMsg()).str());
}
}
} else {
@ -509,14 +509,14 @@ ssize_t SocketCore::writeData(const char* data, size_t len)
_wantWrite = true;
ret = 0;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_SEND, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_SEND, errorMsg()).str());
}
}
} else {
#ifdef HAVE_LIBSSL
ret = SSL_write(ssl, data, len);
if(ret == 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat
(EX_SOCKET_SEND, ERR_error_string(SSL_get_error(ssl, ret), 0)).str());
}
@ -524,7 +524,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len)
ret = sslHandleEAGAIN(ret);
}
if(ret < 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat
(EX_SOCKET_SEND, ERR_error_string(SSL_get_error(ssl, ret), 0)).str());
}
@ -536,7 +536,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len)
gnutlsRecordCheckDirection();
ret = 0;
} else if(ret < 0) {
throw DlRetryEx(StringFormat(EX_SOCKET_SEND, gnutls_strerror(ret)).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_SEND, gnutls_strerror(ret)).str());
}
#endif // HAVE_LIBGNUTLS
}
@ -558,7 +558,7 @@ void SocketCore::readData(char* data, size_t& len)
_wantRead = true;
ret = 0;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_RECV, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_RECV, errorMsg()).str());
}
}
} else {
@ -567,7 +567,7 @@ void SocketCore::readData(char* data, size_t& len)
// TODO handling len == 0 case required
ret = SSL_read(ssl, data, len);
if(ret == 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat
(EX_SOCKET_RECV, ERR_error_string(SSL_get_error(ssl, ret), 0)).str());
}
@ -575,7 +575,7 @@ void SocketCore::readData(char* data, size_t& len)
ret = sslHandleEAGAIN(ret);
}
if(ret < 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat
(EX_SOCKET_RECV, ERR_error_string(SSL_get_error(ssl, ret), 0)).str());
}
@ -586,7 +586,7 @@ void SocketCore::readData(char* data, size_t& len)
gnutlsRecordCheckDirection();
ret = 0;
} else if(ret < 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat(EX_SOCKET_RECV, gnutls_strerror(ret)).str());
}
#endif // HAVE_LIBGNUTLS
@ -608,7 +608,7 @@ void SocketCore::peekData(char* data, size_t& len)
_wantRead = true;
ret = 0;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_PEEK, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_PEEK, errorMsg()).str());
}
}
} else {
@ -617,7 +617,7 @@ void SocketCore::peekData(char* data, size_t& len)
// TODO handling len == 0 case required
ret = SSL_peek(ssl, data, len);
if(ret == 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat(EX_SOCKET_PEEK,
ERR_error_string(SSL_get_error(ssl, ret), 0)).str());
}
@ -625,7 +625,7 @@ void SocketCore::peekData(char* data, size_t& len)
ret = sslHandleEAGAIN(ret);
}
if(ret < 0) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat(EX_SOCKET_PEEK,
ERR_error_string(SSL_get_error(ssl, ret), 0)).str());
}
@ -636,7 +636,7 @@ void SocketCore::peekData(char* data, size_t& len)
gnutlsRecordCheckDirection();
ret = 0;
} else if(ret < 0) {
throw DlRetryEx(StringFormat(EX_SOCKET_PEEK,
throw DL_RETRY_EX(StringFormat(EX_SOCKET_PEEK,
gnutls_strerror(ret)).str());
}
#endif // HAVE_LIBGNUTLS
@ -685,7 +685,7 @@ static ssize_t GNUTLS_RECORD_RECV_NO_INTERRUPT
while((ret = gnutls_record_recv(sslSession, data, len)) ==
GNUTLS_E_INTERRUPTED);
if(ret < 0 && ret != GNUTLS_E_AGAIN) {
throw DlRetryEx
throw DL_RETRY_EX
(StringFormat(EX_SOCKET_RECV, gnutls_strerror(ret)).str());
}
return ret;
@ -731,12 +731,12 @@ void SocketCore::prepareSecureConnection()
// for SSL
ssl = SSL_new(_tlsContext->getSSLCtx());
if(!ssl) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_SSL_INIT_FAILURE,
ERR_error_string(ERR_get_error(), 0)).str());
}
if(SSL_set_fd(ssl, sockfd) == 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_SSL_INIT_FAILURE,
ERR_error_string(ERR_get_error(), 0)).str());
}
@ -782,19 +782,19 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
case SSL_ERROR_WANT_X509_LOOKUP:
case SSL_ERROR_ZERO_RETURN:
if (blocking) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_SSL_CONNECT_ERROR, ssl_error).str());
}
break;
case SSL_ERROR_SYSCALL:
throw DlAbortEx(EX_SSL_IO_ERROR);
throw DL_ABORT_EX(EX_SSL_IO_ERROR);
case SSL_ERROR_SSL:
throw DlAbortEx(EX_SSL_PROTOCOL_ERROR);
throw DL_ABORT_EX(EX_SSL_PROTOCOL_ERROR);
default:
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_SSL_UNKNOWN_ERROR, ssl_error).str());
}
}
@ -802,19 +802,19 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
// verify peer
X509* peerCert = SSL_get_peer_certificate(ssl);
if(!peerCert) {
throw DlAbortEx(MSG_NO_CERT_FOUND);
throw DL_ABORT_EX(MSG_NO_CERT_FOUND);
}
auto_delete<X509*> certDeleter(peerCert, X509_free);
long verifyResult = SSL_get_verify_result(ssl);
if(verifyResult != X509_V_OK) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_CERT_VERIFICATION_FAILED,
X509_verify_cert_error_string(verifyResult)).str());
}
X509_NAME* name = X509_get_subject_name(peerCert);
if(!name) {
throw DlAbortEx("Could not get X509 name object from the certificate.");
throw DL_ABORT_EX("Could not get X509 name object from the certificate.");
}
bool hostnameOK = false;
@ -838,7 +838,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
}
}
if(!hostnameOK) {
throw DlAbortEx(MSG_HOSTNAME_NOT_MATCH);
throw DL_ABORT_EX(MSG_HOSTNAME_NOT_MATCH);
}
}
#endif // HAVE_LIBSSL
@ -848,7 +848,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
gnutlsRecordCheckDirection();
return false;
} else if(ret < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_SSL_INIT_FAILURE, gnutls_strerror(ret)).str());
}
@ -857,7 +857,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
unsigned int status;
ret = gnutls_certificate_verify_peers2(sslSession, &status);
if(ret < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("gnutls_certificate_verify_peer2() failed. Cause: %s",
gnutls_strerror(ret)).str());
}
@ -873,27 +873,27 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
errors += " `issuer is not known'";
}
if(!errors.empty()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_CERT_VERIFICATION_FAILED, errors.c_str()).str());
}
}
// certificate type: only X509 is allowed.
if(gnutls_certificate_type_get(sslSession) != GNUTLS_CRT_X509) {
throw DlAbortEx("Certificate type is not X509.");
throw DL_ABORT_EX("Certificate type is not X509.");
}
unsigned int peerCertsLength;
const gnutls_datum_t* peerCerts = gnutls_certificate_get_peers
(sslSession, &peerCertsLength);
if(!peerCerts) {
throw DlAbortEx(MSG_NO_CERT_FOUND);
throw DL_ABORT_EX(MSG_NO_CERT_FOUND);
}
Time now;
for(unsigned int i = 0; i < peerCertsLength; ++i) {
gnutls_x509_crt_t cert;
ret = gnutls_x509_crt_init(&cert);
if(ret < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("gnutls_x509_crt_init() failed. Cause: %s",
gnutls_strerror(ret)).str());
}
@ -901,28 +901,28 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
(cert, gnutls_x509_crt_deinit);
ret = gnutls_x509_crt_import(cert, &peerCerts[i], GNUTLS_X509_FMT_DER);
if(ret < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("gnutls_x509_crt_import() failed. Cause: %s",
gnutls_strerror(ret)).str());
}
if(i == 0) {
if(!gnutls_x509_crt_check_hostname(cert, hostname.c_str())) {
throw DlAbortEx(MSG_HOSTNAME_NOT_MATCH);
throw DL_ABORT_EX(MSG_HOSTNAME_NOT_MATCH);
}
}
time_t activationTime = gnutls_x509_crt_get_activation_time(cert);
if(activationTime == -1) {
throw DlAbortEx("Could not get activation time from certificate.");
throw DL_ABORT_EX("Could not get activation time from certificate.");
}
if(now.getTime() < activationTime) {
throw DlAbortEx("Certificate is not activated yet.");
throw DL_ABORT_EX("Certificate is not activated yet.");
}
time_t expirationTime = gnutls_x509_crt_get_expiration_time(cert);
if(expirationTime == -1) {
throw DlAbortEx("Could not get expiration time from certificate.");
throw DL_ABORT_EX("Could not get expiration time from certificate.");
}
if(expirationTime < now.getTime()) {
throw DlAbortEx("Certificate has expired.");
throw DL_ABORT_EX("Certificate has expired.");
}
}
}
@ -983,7 +983,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len,
int s;
s = getaddrinfo(host.c_str(), uitos(port).c_str(), &hints, &res);
if(s) {
throw DlAbortEx(StringFormat(EX_SOCKET_SEND, gai_strerror(s)).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_SEND, gai_strerror(s)).str());
}
struct addrinfo* rp;
ssize_t r = -1;
@ -1000,7 +1000,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len,
}
freeaddrinfo(res);
if(r == -1) {
throw DlAbortEx(StringFormat(EX_SOCKET_SEND, errorMsg()).str());
throw DL_ABORT_EX(StringFormat(EX_SOCKET_SEND, errorMsg()).str());
}
return r;
}
@ -1022,7 +1022,7 @@ ssize_t SocketCore::readDataFrom(char* data, size_t len,
_wantRead = true;
r = 0;
} else {
throw DlRetryEx(StringFormat(EX_SOCKET_RECV, errorMsg()).str());
throw DL_RETRY_EX(StringFormat(EX_SOCKET_RECV, errorMsg()).str());
}
} else {
sender = Util::getNumericNameInfo(addrp, sockaddrlen);
@ -1037,7 +1037,7 @@ std::string SocketCore::getSocketError() const
socklen_t optlen = sizeof(error);
if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (a2_sockopt_t) &error, &optlen) == -1) {
throw DlAbortEx(StringFormat("Failed to get socket error: %s",
throw DL_ABORT_EX(StringFormat("Failed to get socket error: %s",
errorMsg()).str());
}
if(error != 0) {

8
src/Sqlite3MozCookieParser.cc
View File

@ -38,7 +38,7 @@
#include <sqlite3.h>
#include "RecoverableException.h"
#include "DlAbortEx.h"
#include "Util.h"
#include "StringFormat.h"
#include "A2STR.h"
@ -98,7 +98,7 @@ Sqlite3MozCookieParser::parse(const std::string& filename) const
ret = sqlite3_open_v2(filename.c_str(), &db, SQLITE_OPEN_READONLY, 0);
#else // !HAVE_SQLITE3_OPEN_V2
if(!File(filename).isFile()) {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Failed to open SQLite3 database: %s",
filename.c_str()).str());
}
@ -107,7 +107,7 @@ Sqlite3MozCookieParser::parse(const std::string& filename) const
if(SQLITE_OK != ret) {
std::string errMsg = sqlite3_errmsg(db);
sqlite3_close(db);
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Failed to open SQLite3 database: %s",
errMsg.c_str()).str());
}
@ -123,7 +123,7 @@ Sqlite3MozCookieParser::parse(const std::string& filename) const
}
if(SQLITE_OK != ret) {
sqlite3_close(db);
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Failed to read SQLite3 database: %s",
errMsg.c_str()).str());
}

2
src/UTPexExtensionMessage.cc
View File

@ -167,7 +167,7 @@ UTPexExtensionMessageHandle
UTPexExtensionMessage::create(const unsigned char* data, size_t len)
{
if(len < 1) {
throw DlAbortEx(StringFormat(MSG_TOO_SMALL_PAYLOAD_SIZE,
throw DL_ABORT_EX(StringFormat(MSG_TOO_SMALL_PAYLOAD_SIZE,
EXTENSION_NAME.c_str(), len).str());
}
UTPexExtensionMessageHandle msg(new UTPexExtensionMessage(*data));

44
src/Util.cc
View File

@ -427,19 +427,19 @@ int32_t Util::parseInt(const std::string& s, int32_t base)
{
std::string trimed = Util::trim(s);
if(trimed.empty()) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
"empty string").str());
}
char* stop;
errno = 0;
long int v = strtol(trimed.c_str(), &stop, base);
if(*stop != '\0') {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
} else if((((v == LONG_MIN) || (v == LONG_MAX)) && (errno == ERANGE)) ||
(v > INT32_MAX) ||
(v < INT32_MIN)) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
}
return v;
@ -449,22 +449,22 @@ uint32_t Util::parseUInt(const std::string& s, int base)
{
std::string trimed = Util::trim(s);
if(trimed.empty()) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
"empty string").str());
}
// We don't allow negative number.
if(trimed[0] == '-') {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
}
char* stop;
errno = 0;
unsigned long int v = strtoul(trimed.c_str(), &stop, base);
if(*stop != '\0') {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
} else if(((v == ULONG_MAX) && (errno == ERANGE)) || (v > UINT32_MAX)) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
}
return v;
@ -474,17 +474,17 @@ int64_t Util::parseLLInt(const std::string& s, int32_t base)
{
std::string trimed = Util::trim(s);
if(trimed.empty()) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
"empty string").str());
}
char* stop;
errno = 0;
int64_t v = strtoll(trimed.c_str(), &stop, base);
if(*stop != '\0') {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
} else if(((v == INT64_MIN) || (v == INT64_MAX)) && (errno == ERANGE)) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
}
return v;
@ -494,22 +494,22 @@ uint64_t Util::parseULLInt(const std::string& s, int base)
{
std::string trimed = Util::trim(s);
if(trimed.empty()) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
"empty string").str());
}
// We don't allow negative number.
if(trimed[0] == '-') {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
}
char* stop;
errno = 0;
uint64_t v = strtoull(trimed.c_str(), &stop, base);
if(*stop != '\0') {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
} else if((v == ULLONG_MAX) && (errno == ERANGE)) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
trimed.c_str()).str());
}
return v;
@ -531,7 +531,7 @@ IntSequence Util::parseIntRange(const std::string& src)
} else {
std::pair<std::string, std::string> vp = Util::split(p.first.c_str(), "-");
if(vp.first.empty() || vp.second.empty()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(MSG_INCOMPLETE_RANGE, p.first.c_str()).str());
}
int32_t v1 = Util::parseInt(vp.first.c_str());
@ -656,10 +656,10 @@ int64_t Util::getRealSize(const std::string& sizeWithUnit)
int64_t v = Util::parseLLInt(size);
if(v < 0) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Negative value detected: %s", sizeWithUnit.c_str()).str());
} else if(INT64_MAX/mult < v) {
throw DlAbortEx(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
throw DL_ABORT_EX(StringFormat(MSG_STRING_INTEGER_CONVERSION_FAILURE,
"overflow/underflow").str());
}
return v*mult;
@ -827,11 +827,11 @@ void Util::mkdirs(const std::string& dirpath)
if(dir.isDir()) {
// do nothing
} else if(dir.exists()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_MAKE_DIR, dir.getPath().c_str(),
"File already exists.").str());
} else if(!dir.mkdirs()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_MAKE_DIR, dir.getPath().c_str(),
strerror(errno)).str());
}
@ -871,7 +871,7 @@ void* Util::allocateAlignedMemory(size_t alignment, size_t size)
void* buffer;
int res;
if((res = posix_memalign(&buffer, alignment, size)) != 0) {
throw FatalException
throw FATAL_EXCEPTION
(StringFormat("Error in posix_memalign: %s", strerror(res)).str());
}
return buffer;
@ -886,7 +886,7 @@ Util::getNumericNameInfo(const struct sockaddr* sockaddr, socklen_t len)
int s = getnameinfo(sockaddr, len, host, NI_MAXHOST, service, NI_MAXSERV,
NI_NUMERICHOST|NI_NUMERICSERV);
if(s != 0) {
throw DlAbortEx(StringFormat("Failed to get hostname and port. cause: %s",
throw DL_ABORT_EX(StringFormat("Failed to get hostname and port. cause: %s",
gai_strerror(s)).str());
}
return std::pair<std::string, uint16_t>(host, atoi(service)); // TODO
@ -920,7 +920,7 @@ Util::parseIndexPath(const std::string& line)
std::pair<std::string, std::string> p = Util::split(line, "=");
size_t index = parseUInt(p.first);
if(p.second.empty()) {
throw DlAbortEx(StringFormat("Path with index=%u is empty.",
throw DL_ABORT_EX(StringFormat("Path with index=%u is empty.",
static_cast<unsigned int>(index)).str());
}
return std::map<size_t, std::string>::value_type(index, p.second);

8
src/XML2SAXMetalinkProcessor.cc
View File

@ -136,7 +136,7 @@ MetalinkProcessor::parseFile(const std::string& filename)
int retval = xmlSAXUserParseFile(&mySAXHandler, sessionData.get(),
filename.c_str());
if(retval != 0) {
throw DlAbortEx(MSG_CANNOT_PARSE_METALINK);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK);
}
return _stm->getResult();
}
@ -150,7 +150,7 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar
ssize_t res = binaryStream->readData(buf, 4, 0);
if(res != 4) {
throw DlAbortEx("Too small data for parsing XML.");
throw DL_ABORT_EX("Too small data for parsing XML.");
}
SharedHandle<SessionData> sessionData(new SessionData(_stm));
@ -163,7 +163,7 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar
break;
}
if(xmlParseChunk(ctx, (const char*)buf, res, 0) != 0) {
throw DlAbortEx(MSG_CANNOT_PARSE_METALINK);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK);
}
readOffset += res;
}
@ -175,7 +175,7 @@ MetalinkProcessor::parseFromBinaryStream(const SharedHandle<BinaryStream>& binar
xmlFreeParserCtxt(ctx);
if(!_stm->finished()) {
throw DlAbortEx(MSG_CANNOT_PARSE_METALINK);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_METALINK);
}
return _stm->getResult();
}

2
src/Xml2XmlRpcRequestProcessor.cc
View File

@ -141,7 +141,7 @@ XmlRpcRequestProcessor::parseMemory(const std::string& xml)
int r = xmlSAXUserParseMemory(&mySAXHandler, sessionData.get(),
xml.data(), xml.size());
if(r != 0) {
throw DlAbortEx(MSG_CANNOT_PARSE_XML_RPC_REQUEST);
throw DL_ABORT_EX(MSG_CANNOT_PARSE_XML_RPC_REQUEST);
}
return XmlRpcRequest(_stm->getMethodName(), _stm->getCurrentFrameValue());
}

40
src/XmlRpcMethodImpl.cc
View File

@ -86,7 +86,7 @@ BDE AddUriXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
const BDE& params = req._params;
assert(params.isList());
if(params.empty() || !params[0].isList() || params[0].empty()) {
throw DlAbortEx("URI is not provided.");
throw DL_ABORT_EX("URI is not provided.");
}
std::deque<std::string> uris;
for(BDE::List::const_iterator i = params[0].listBegin();
@ -109,7 +109,7 @@ BDE AddUriXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
e->_requestGroupMan->addReservedGroup(result.front());
return createGIDResponse(result.front()->getGID());
} else {
throw DlAbortEx("No URI to download.");
throw DL_ABORT_EX("No URI to download.");
}
}
@ -119,7 +119,7 @@ BDE AddTorrentXmlRpcMethod::process
const BDE& params = req._params;
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx("Torrent data is not provided.");
throw DL_ABORT_EX("Torrent data is not provided.");
}
std::deque<std::string> uris;
@ -145,7 +145,7 @@ BDE AddTorrentXmlRpcMethod::process
e->_requestGroupMan->addReservedGroup(result.front());
return createGIDResponse(result.front()->getGID());
} else {
throw DlAbortEx("No Torrent to download.");
throw DL_ABORT_EX("No Torrent to download.");
}
}
@ -155,7 +155,7 @@ BDE AddMetalinkXmlRpcMethod::process
const BDE& params = req._params;
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx("Metalink data is not provided.");
throw DL_ABORT_EX("Metalink data is not provided.");
}
SharedHandle<Option> requestOption(new Option(*e->option));
@ -173,7 +173,7 @@ BDE AddMetalinkXmlRpcMethod::process
}
return gids;
} else {
throw DlAbortEx("No files to download.");
throw DL_ABORT_EX("No files to download.");
}
}
@ -184,7 +184,7 @@ BDE RemoveXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx(MSG_GID_NOT_PROVIDED);
throw DL_ABORT_EX(MSG_GID_NOT_PROVIDED);
}
int32_t gid = Util::parseInt(params[0].s());
@ -194,13 +194,13 @@ BDE RemoveXmlRpcMethod::process(const XmlRpcRequest& req, DownloadEngine* e)
if(group.isNull()) {
group = e->_requestGroupMan->findReservedGroup(gid);
if(group.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Active Download not found for GID#%d", gid).str());
}
if(group->isDependencyResolved()) {
e->_requestGroupMan->removeReservedGroup(gid);
} else {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("GID#%d cannot be removed now", gid).str());
}
} else {
@ -320,7 +320,7 @@ BDE GetFilesXmlRpcMethod::process
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx(MSG_GID_NOT_PROVIDED);
throw DL_ABORT_EX(MSG_GID_NOT_PROVIDED);
}
int32_t gid = Util::parseInt(params[0].s());
@ -331,7 +331,7 @@ BDE GetFilesXmlRpcMethod::process
SharedHandle<DownloadResult> dr =
e->_requestGroupMan->findDownloadResult(gid);
if(dr.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("No file data is available for GID#%d", gid).str());
} else {
createFileEntry(files, dr->fileEntries.begin(), dr->fileEntries.end());
@ -351,14 +351,14 @@ BDE GetUrisXmlRpcMethod::process
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx(MSG_GID_NOT_PROVIDED);
throw DL_ABORT_EX(MSG_GID_NOT_PROVIDED);
}
int32_t gid = Util::parseInt(params[0].s());
SharedHandle<RequestGroup> group = findRequestGroup(e->_requestGroupMan, gid);
if(group.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("No URI data is available for GID#%d", gid).str());
}
BDE uriList = BDE::list();
@ -380,14 +380,14 @@ BDE GetPeersXmlRpcMethod::process
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx(MSG_GID_NOT_PROVIDED);
throw DL_ABORT_EX(MSG_GID_NOT_PROVIDED);
}
int32_t gid = Util::parseInt(params[0].s());
SharedHandle<RequestGroup> group = findRequestGroup(e->_requestGroupMan, gid);
if(group.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("No peer data is available for GID#%d", gid).str());
}
BDE peers = BDE::list();
@ -412,7 +412,7 @@ BDE TellStatusXmlRpcMethod::process
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx(MSG_GID_NOT_PROVIDED);
throw DL_ABORT_EX(MSG_GID_NOT_PROVIDED);
}
int32_t gid = Util::parseInt(params[0].s());
@ -426,7 +426,7 @@ BDE TellStatusXmlRpcMethod::process
SharedHandle<DownloadResult> ds =
e->_requestGroupMan->findDownloadResult(gid);
if(ds.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("No such download for GID#%d", gid).str());
}
gatherStoppedDownload(entryDict, ds);
@ -503,13 +503,13 @@ BDE ChangeOptionXmlRpcMethod::process
const BDE& params = req._params;
assert(params.isList());
if(params.empty() || !params[0].isString()) {
throw DlAbortEx(MSG_GID_NOT_PROVIDED);
throw DL_ABORT_EX(MSG_GID_NOT_PROVIDED);
}
int32_t gid = Util::parseInt(params[0].s());
SharedHandle<RequestGroup> group = findRequestGroup(e->_requestGroupMan, gid);
if(group.isNull()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Cannot change option for GID#%d", gid).str());
}
SharedHandle<Option> option(new Option(*group->getOption().get()));
@ -549,7 +549,7 @@ BDE ChangeGlobalOptionXmlRpcMethod::process
BDE NoSuchMethodXmlRpcMethod::process
(const XmlRpcRequest& req, DownloadEngine* e)
{
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("No such method: %s", req._methodName.c_str()).str());
}

18
src/bencode.cc
View File

@ -38,7 +38,7 @@
#include <sstream>
#include "StringFormat.h"
#include "RecoverableException.h"
#include "DlAbortEx.h"
namespace aria2 {
@ -50,7 +50,7 @@ static void checkdelim(std::istream& ss, const char delim = ':')
{
char d;
if(!(ss.get(d) && d == delim)) {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Delimiter '%c' not found.", delim).str());
}
}
@ -60,7 +60,7 @@ static std::string decoderawstring(std::istream& ss)
int length;
ss >> length;
if(!ss || length < 0) {
throw RecoverableException("A positive integer expected but none found.");
throw DL_ABORT_EX("A positive integer expected but none found.");
}
// TODO check length, it must be less than or equal to INT_MAX
checkdelim(ss);
@ -69,7 +69,7 @@ static std::string decoderawstring(std::istream& ss)
std::string str(&buf[0], &buf[length]);
delete [] buf;
if(ss.gcount() != static_cast<int>(length)) {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Expected %lu bytes of data, but only %d read.",
static_cast<unsigned long>(length), ss.gcount()).str());
}
@ -86,7 +86,7 @@ static BDE decodeinteger(std::istream& ss)
BDE::Integer integer;
ss >> integer;
if(!ss) {
throw RecoverableException("Integer expected but none found");
throw DL_ABORT_EX("Integer expected but none found");
}
checkdelim(ss, 'e');
return BDE(integer);
@ -105,7 +105,7 @@ static BDE decodedict(std::istream& ss)
dict[key] = decodeiter(ss);
}
}
throw RecoverableException("Unexpected EOF in dict context. 'e' expected.");
throw DL_ABORT_EX("Unexpected EOF in dict context. 'e' expected.");
}
static BDE decodelist(std::istream& ss)
@ -120,14 +120,14 @@ static BDE decodelist(std::istream& ss)
list << decodeiter(ss);
}
}
throw RecoverableException("Unexpected EOF in list context. 'e' expected.");
throw DL_ABORT_EX("Unexpected EOF in list context. 'e' expected.");
}
static BDE decodeiter(std::istream& ss)
{
char c;
if(!ss.get(c)) {
throw RecoverableException("Unexpected EOF in term context."
throw DL_ABORT_EX("Unexpected EOF in term context."
" 'd', 'l', 'i' or digit is expected.");
}
if(c == 'd') {
@ -168,7 +168,7 @@ BDE decodeFromFile(const std::string& filename)
if(f) {
return decode(f);
} else {
throw RecoverableException
throw DL_ABORT_EX
(StringFormat("Cannot open file '%s'.", filename.c_str()).str());
}
}

4
src/download_helper.cc
View File

@ -266,7 +266,7 @@ void createRequestGroupForMetalink
Metalink2RequestGroup().generate(result, dw, option);
}
if(result.empty()) {
throw DlAbortEx(MSG_NO_FILES_TO_DOWNLOAD);
throw DL_ABORT_EX(MSG_NO_FILES_TO_DOWNLOAD);
}
}
#endif // ENABLE_METALINK
@ -405,7 +405,7 @@ void createRequestGroupForUriList
createRequestGroupForUriList(result, option, std::cin);
} else {
if(!File(option->get(PREF_INPUT_FILE)).isFile()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat(EX_FILE_OPEN, option->get(PREF_INPUT_FILE).c_str(),
"No such file").str());
}

2
src/messageDigest.h
View File

@ -104,7 +104,7 @@ public:
{
DigestAlgoMap::const_iterator itr = digestAlgos.find(algostring);
if(itr == digestAlgos.end()) {
throw DlAbortEx
throw DL_ABORT_EX
(StringFormat("Digest algorithm %s is not supported.",
algostring.c_str()).str());
}

21
test/ExceptionTest.cc
View File

@ -1,9 +1,10 @@
#include "Exception.h"
#include "DownloadFailureException.h"
#include "Util.h"
#include <iostream>
#include <cppunit/extensions/HelperMacros.h>
#include "DownloadFailureException.h"
namespace aria2 {
class ExceptionTest:public CppUnit::TestFixture {
@ -24,14 +25,16 @@ CPPUNIT_TEST_SUITE_REGISTRATION(ExceptionTest);
void ExceptionTest::testStackTrace()
{
DownloadFailureException c1("cause1");
DownloadFailureException c2("cause2", c1);
DownloadFailureException e("exception thrown", c2);
DownloadFailureException c1 = DOWNLOAD_FAILURE_EXCEPTION("cause1");
DownloadFailureException c2 = DOWNLOAD_FAILURE_EXCEPTION2("cause2", c1);
DownloadFailureException e = DOWNLOAD_FAILURE_EXCEPTION2("exception thrown",
c2);
CPPUNIT_ASSERT_EQUAL(std::string("Exception: exception thrown\n"
" -> cause2\n"
" -> cause1\n"),
e.stackTrace());
CPPUNIT_ASSERT_EQUAL
(std::string("Exception: [ExceptionTest.cc:31] exception thrown\n"
" -> [ExceptionTest.cc:29] cause2\n"
" -> [ExceptionTest.cc:28] cause1\n"),
e.stackTrace());
}
} // namespace aria2

8
test/TestUtil.cc
View File

@ -20,12 +20,12 @@ void createFile(const std::string& path, size_t length)
File(File(path).getDirname()).mkdirs();
int fd = creat(path.c_str(), OPEN_MODE);
if(fd == -1) {
throw FatalException(StringFormat("Could not create file=%s. cause:%s",
path.c_str(), strerror(errno)).str());
throw FATAL_EXCEPTION(StringFormat("Could not create file=%s. cause:%s",
path.c_str(), strerror(errno)).str());
}
if(-1 == ftruncate(fd, length)) {
throw FatalException(StringFormat("ftruncate failed. cause:%s",
strerror(errno)).str());
throw FATAL_EXCEPTION(StringFormat("ftruncate failed. cause:%s",
strerror(errno)).str());
}
close(fd);
}