twisterarmy/twister-core
1
0
Fork 0
mirror of https://github.com/twisterarmy/twister-core.git synced 2025-01-08 22:08:00 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #7 from twisterarmy/master

Browse Source 
Master updates
This commit is contained in:
d47081 2022-07-10 02:23:07 +03:00 committed by GitHub
commit bfd7a06862
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 81 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libtorrent/include/libtorrent/alert.hpp
View File

@ -113,7 +113,7 @@ namespace libtorrent {
severity_t severity() const TORRENT_DEPRECATED { return warning; } severity_t severity() const TORRENT_DEPRECATED { return warning; }
#endif #endif
virtual std::auto_ptr<alert> clone() const = 0; virtual std::unique_ptr<alert> clone() const = 0;
private: private:
ptime m_timestamp; ptime m_timestamp;
@ -133,7 +133,7 @@ namespace libtorrent {
template<class Handler template<class Handler
, BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, class T)> , BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, class T)>
void handle_alert_dispatch( void handle_alert_dispatch(
const std::auto_ptr<alert>& alert_, const Handler& handler const std::unique_ptr<alert>& alert_, const Handler& handler
, const std::type_info& typeid_ , const std::type_info& typeid_
, T0*, BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(TORRENT_MAX_ALERT_TYPES, T, *p)) , T0*, BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(TORRENT_MAX_ALERT_TYPES, T, *p))
{ {
@ -147,7 +147,7 @@ namespace libtorrent {
template<class Handler> template<class Handler>
void handle_alert_dispatch( void handle_alert_dispatch(
const std::auto_ptr<alert>& const std::unique_ptr<alert>&
, const Handler& , const Handler&
, const std::type_info& , const std::type_info&
, BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, void_* BOOST_PP_INTERCEPT)) , BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, void_* BOOST_PP_INTERCEPT))
@ -162,7 +162,7 @@ namespace libtorrent {
struct TORRENT_EXPORT handle_alert struct TORRENT_EXPORT handle_alert
{ {
template<class Handler> template<class Handler>
handle_alert(const std::auto_ptr<alert>& alert_ handle_alert(const std::unique_ptr<alert>& alert_
, const Handler& handler) , const Handler& handler)
{ {
#define ALERT_POINTER_TYPE(z, n, text) (BOOST_PP_CAT(T, n)*)0 #define ALERT_POINTER_TYPE(z, n, text) (BOOST_PP_CAT(T, n)*)0

8
libtorrent/include/libtorrent/alert_manager.hpp
View File

@ -57,7 +57,7 @@ namespace libtorrent {
void post_alert(const alert& alert_); void post_alert(const alert& alert_);
void post_alert_ptr(alert* alert_); void post_alert_ptr(alert* alert_);
bool pending() const; bool pending() const;
std::auto_ptr<alert> get(); std::unique_ptr<alert> get();
void get_all(std::deque<alert*>* alerts); void get_all(std::deque<alert*>* alerts);
template <class T> template <class T>
@ -86,21 +86,21 @@ namespace libtorrent {
size_t alert_queue_size_limit() const { return m_queue_size_limit; } size_t alert_queue_size_limit() const { return m_queue_size_limit; }
size_t set_alert_queue_size_limit(size_t queue_size_limit_); size_t set_alert_queue_size_limit(size_t queue_size_limit_);
void set_dispatch_function(boost::function<void(std::auto_ptr<alert>)> const&); void set_dispatch_function(std::function<void(std::unique_ptr<alert>&&)> const&);
#ifndef TORRENT_DISABLE_EXTENSIONS #ifndef TORRENT_DISABLE_EXTENSIONS
void add_extension(boost::shared_ptr<plugin> ext); void add_extension(boost::shared_ptr<plugin> ext);
#endif #endif
private: private:
void post_impl(std::auto_ptr<alert>& alert_, mutex::scoped_lock& l); void post_impl(std::unique_ptr<alert>&& alert_, mutex::scoped_lock& l);
std::deque<alert*> m_alerts; std::deque<alert*> m_alerts;
mutable mutex m_mutex; mutable mutex m_mutex;
condition_variable m_condition; condition_variable m_condition;
boost::uint32_t m_alert_mask; boost::uint32_t m_alert_mask;
size_t m_queue_size_limit; size_t m_queue_size_limit;
boost::function<void(std::auto_ptr<alert>)> m_dispatch; std::function<void(std::unique_ptr<alert>&&)> m_dispatch;
#ifndef TORRENT_DISABLE_EXTENSIONS #ifndef TORRENT_DISABLE_EXTENSIONS
typedef std::list<boost::shared_ptr<plugin> > ses_extension_list_t; typedef std::list<boost::shared_ptr<plugin> > ses_extension_list_t;

4
libtorrent/include/libtorrent/alert_types.hpp
View File

@ -106,8 +106,8 @@ namespace libtorrent
#define TORRENT_DEFINE_ALERT(name) \ #define TORRENT_DEFINE_ALERT(name) \
const static int alert_type = __LINE__; \ const static int alert_type = __LINE__; \
virtual int type() const { return alert_type; } \ virtual int type() const { return alert_type; } \
virtual std::auto_ptr<alert> clone() const \ virtual std::unique_ptr<alert> clone() const \
{ return std::auto_ptr<alert>(new name(*this)); } \ { return std::unique_ptr<alert>(new name(*this)); } \
virtual int category() const { return static_category; } \ virtual int category() const { return static_category; } \
virtual char const* what() const { return #name; } virtual char const* what() const { return #name; }

4
libtorrent/include/libtorrent/aux_/session_impl.hpp
View File

@ -380,9 +380,9 @@ namespace libtorrent
void set_alert_mask(boost::uint32_t m); void set_alert_mask(boost::uint32_t m);
size_t set_alert_queue_size_limit(size_t queue_size_limit_); size_t set_alert_queue_size_limit(size_t queue_size_limit_);
std::auto_ptr<alert> pop_alert(); std::unique_ptr<alert> pop_alert();
void pop_alerts(std::deque<alert*>* alerts); void pop_alerts(std::deque<alert*>* alerts);
void set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const&); void set_alert_dispatch(boost::function<void(std::unique_ptr<alert>)> const&);
void post_alert(const alert& alert_); void post_alert(const alert& alert_);
alert const* wait_for_alert(time_duration max_wait); alert const* wait_for_alert(time_duration max_wait);

4
libtorrent/include/libtorrent/session.hpp
View File

@ -796,7 +796,7 @@ namespace libtorrent
// //
// ``save_resume_data_alert`` and ``save_resume_data_failed_alert`` are always posted, regardelss // ``save_resume_data_alert`` and ``save_resume_data_failed_alert`` are always posted, regardelss
// of the alert mask. // of the alert mask.
std::auto_ptr<alert> pop_alert(); std::unique_ptr<alert> pop_alert();
void pop_alerts(std::deque<alert*>* alerts); void pop_alerts(std::deque<alert*>* alerts);
alert const* wait_for_alert(time_duration max_wait); alert const* wait_for_alert(time_duration max_wait);
@ -821,7 +821,7 @@ namespace libtorrent
// The main intention with this function is to support integration with platform-dependent message // The main intention with this function is to support integration with platform-dependent message
// queues or signalling systems. For instance, on windows, one could post a message to an HNWD or // queues or signalling systems. For instance, on windows, one could post a message to an HNWD or
// on linux, write to a pipe or an eventfd. // on linux, write to a pipe or an eventfd.
void set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const& fun); void set_alert_dispatch(boost::function<void(std::unique_ptr<alert>)> const& fun);
connection_queue& get_connection_queue(); connection_queue& get_connection_queue();

24
libtorrent/src/alert_manager.cpp
View File

@ -72,7 +72,7 @@ namespace libtorrent
return NULL; return NULL;
} }
void alert_manager::set_dispatch_function(boost::function<void(std::auto_ptr<alert>)> const& fun) void alert_manager::set_dispatch_function(std::function<void(std::unique_ptr<alert>&&)> const& fun)
{ {
mutex::scoped_lock lock(m_mutex); mutex::scoped_lock lock(m_mutex);
@ -85,7 +85,7 @@ namespace libtorrent
while (!alerts.empty()) while (!alerts.empty())
{ {
TORRENT_TRY { TORRENT_TRY {
m_dispatch(std::auto_ptr<alert>(alerts.front())); m_dispatch(std::unique_ptr<alert>(alerts.front()));
} TORRENT_CATCH(std::exception&) {} } TORRENT_CATCH(std::exception&) {}
alerts.pop_front(); alerts.pop_front();
} }
@ -94,13 +94,13 @@ namespace libtorrent
void dispatch_alert(boost::function<void(alert const&)> dispatcher void dispatch_alert(boost::function<void(alert const&)> dispatcher
, alert* alert_) , alert* alert_)
{ {
std::auto_ptr<alert> holder(alert_); std::unique_ptr<alert> holder(alert_);
dispatcher(*alert_); dispatcher(*alert_);
} }
void alert_manager::post_alert_ptr(alert* alert_) void alert_manager::post_alert_ptr(alert* alert_)
{ {
std::auto_ptr<alert> a(alert_); std::unique_ptr<alert> a(alert_);
#ifndef TORRENT_DISABLE_EXTENSIONS #ifndef TORRENT_DISABLE_EXTENSIONS
for (ses_extension_list_t::iterator i = m_ses_extensions.begin() for (ses_extension_list_t::iterator i = m_ses_extensions.begin()
@ -113,12 +113,12 @@ namespace libtorrent
#endif #endif
mutex::scoped_lock lock(m_mutex); mutex::scoped_lock lock(m_mutex);
post_impl(a, lock); post_impl(std::move(a), lock);
} }
void alert_manager::post_alert(const alert& alert_) void alert_manager::post_alert(const alert& alert_)
{ {
std::auto_ptr<alert> a(alert_.clone()); std::unique_ptr<alert> a(alert_.clone());
#ifndef TORRENT_DISABLE_EXTENSIONS #ifndef TORRENT_DISABLE_EXTENSIONS
for (ses_extension_list_t::iterator i = m_ses_extensions.begin() for (ses_extension_list_t::iterator i = m_ses_extensions.begin()
@ -131,16 +131,16 @@ namespace libtorrent
#endif #endif
mutex::scoped_lock lock(m_mutex); mutex::scoped_lock lock(m_mutex);
post_impl(a, lock); post_impl(std::move(a), lock);
} }
void alert_manager::post_impl(std::auto_ptr<alert>& alert_, mutex::scoped_lock& l) void alert_manager::post_impl(std::unique_ptr<alert>&& alert_, mutex::scoped_lock& l)
{ {
if (m_dispatch) if (m_dispatch)
{ {
TORRENT_ASSERT(m_alerts.empty()); TORRENT_ASSERT(m_alerts.empty());
TORRENT_TRY { TORRENT_TRY {
m_dispatch(alert_); m_dispatch(std::move(alert_));
} TORRENT_CATCH(std::exception&) {} } TORRENT_CATCH(std::exception&) {}
} }
else if (m_alerts.size() < m_queue_size_limit || !alert_->discardable()) else if (m_alerts.size() < m_queue_size_limit || !alert_->discardable())
@ -158,16 +158,16 @@ namespace libtorrent
} }
#endif #endif
std::auto_ptr<alert> alert_manager::get() std::unique_ptr<alert> alert_manager::get()
{ {
mutex::scoped_lock lock(m_mutex); mutex::scoped_lock lock(m_mutex);
if (m_alerts.empty()) if (m_alerts.empty())
return std::auto_ptr<alert>(0); return std::unique_ptr<alert>(nullptr);
alert* result = m_alerts.front(); alert* result = m_alerts.front();
m_alerts.pop_front(); m_alerts.pop_front();
return std::auto_ptr<alert>(result); return std::unique_ptr<alert>(result);
} }
void alert_manager::get_all(std::deque<alert*>* alerts) void alert_manager::get_all(std::deque<alert*>* alerts)

4
libtorrent/src/session.cpp
View File

@ -1096,12 +1096,12 @@ namespace libtorrent
} }
#endif // TORRENT_NO_DEPRECATE #endif // TORRENT_NO_DEPRECATE
void session::set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const& fun) void session::set_alert_dispatch(boost::function<void(std::unique_ptr<alert>)> const& fun)
{ {
TORRENT_ASYNC_CALL1(set_alert_dispatch, fun); TORRENT_ASYNC_CALL1(set_alert_dispatch, fun);
} }
std::auto_ptr<alert> session::pop_alert() std::unique_ptr<alert> session::pop_alert()
{ {
return m_impl->pop_alert(); return m_impl->pop_alert();
} }

6
libtorrent/src/session_impl.cpp
View File

@ -5037,7 +5037,7 @@ retry:
TORRENT_ASSERT(is_network_thread()); TORRENT_ASSERT(is_network_thread());
std::auto_ptr<state_update_alert> alert(new state_update_alert()); std::unique_ptr<state_update_alert> alert(new state_update_alert());
alert->status.reserve(m_state_updates.size()); alert->status.reserve(m_state_updates.size());
#if defined TORRENT_DEBUG || TORRENT_RELEASE_ASSERTS #if defined TORRENT_DEBUG || TORRENT_RELEASE_ASSERTS
@ -6157,12 +6157,12 @@ retry:
} }
} }
void session_impl::set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const& fun) void session_impl::set_alert_dispatch(boost::function<void(std::unique_ptr<alert>)> const& fun)
{ {
m_alerts.set_dispatch_function(fun); m_alerts.set_dispatch_function(fun);
} }
std::auto_ptr<alert> session_impl::pop_alert() std::unique_ptr<alert> session_impl::pop_alert()
{ {
return m_alerts.get(); return m_alerts.get();
} }

2
libtorrent/src/torrent_info.cpp
View File

@ -357,7 +357,7 @@ namespace libtorrent
struct string_less_no_case struct string_less_no_case
{ {
bool operator()(std::string const& lhs, std::string const& rhs) bool operator()(std::string const& lhs, std::string const& rhs) const
{ {
char c1, c2; char c1, c2;
char const* s1 = lhs.c_str(); char const* s1 = lhs.c_str();

6
libtorrent/test/setup_transfer.cpp
View File

@ -73,9 +73,9 @@ void report_failure(char const* err, char const* file, int line)
tests_failure = true; tests_failure = true;
} }
std::auto_ptr<alert> wait_for_alert(session& ses, int type) std::unique_ptr<alert> wait_for_alert(session& ses, int type)
{ {
std::auto_ptr<alert> ret; std::unique_ptr<alert> ret;
while (!ret.get()) while (!ret.get())
{ {
ses.wait_for_alert(milliseconds(5000)); ses.wait_for_alert(milliseconds(5000));
@ -86,7 +86,7 @@ std::auto_ptr<alert> wait_for_alert(session& ses, int type)
{ {
if (!ret.get() && (*i)->type() == type) if (!ret.get() && (*i)->type() == type)
{ {
ret = std::auto_ptr<alert>(*i); ret = std::unique_ptr<alert>(*i);
} }
else else
delete *i; delete *i;

2
libtorrent/test/setup_transfer.hpp
View File

@ -50,7 +50,7 @@ int EXPORT load_file(std::string const& filename, std::vector<char>& v, libtorre
void EXPORT report_failure(char const* err, char const* file, int line); void EXPORT report_failure(char const* err, char const* file, int line);
std::auto_ptr<libtorrent::alert> EXPORT wait_for_alert(libtorrent::session& ses, int type); std::unique_ptr<libtorrent::alert> EXPORT wait_for_alert(libtorrent::session& ses, int type);
void EXPORT print_ses_rate(float time void EXPORT print_ses_rate(float time
, libtorrent::torrent_status const* st1 , libtorrent::torrent_status const* st1

14
src/bitcoinrpc.cpp
View File

@ -954,14 +954,14 @@ void StartRPCThreads()
{ {
rpc_ssl_context->set_options(ssl::context::no_sslv2); rpc_ssl_context->set_options(ssl::context::no_sslv2);
filesystem::path pathCertFile(GetArg("-rpcsslcertificatechainfile", "server.cert")); boost::filesystem::path pathCertFile(GetArg("-rpcsslcertificatechainfile", "server.cert"));
if (!pathCertFile.is_complete()) pathCertFile = filesystem::path(GetDataDir()) / pathCertFile; if (!pathCertFile.is_complete()) pathCertFile = boost::filesystem::path(GetDataDir()) / pathCertFile;
if (filesystem::exists(pathCertFile)) rpc_ssl_context->use_certificate_chain_file(pathCertFile.string()); if (boost::filesystem::exists(pathCertFile)) rpc_ssl_context->use_certificate_chain_file(pathCertFile.string());
else printf("ThreadRPCServer ERROR: missing server certificate file %s\n", pathCertFile.string().c_str()); else printf("ThreadRPCServer ERROR: missing server certificate file %s\n", pathCertFile.string().c_str());
filesystem::path pathPKFile(GetArg("-rpcsslprivatekeyfile", "server.pem")); boost::filesystem::path pathPKFile(GetArg("-rpcsslprivatekeyfile", "server.pem"));
if (!pathPKFile.is_complete()) pathPKFile = filesystem::path(GetDataDir()) / pathPKFile; if (!pathPKFile.is_complete()) pathPKFile = boost::filesystem::path(GetDataDir()) / pathPKFile;
if (filesystem::exists(pathPKFile)) rpc_ssl_context->use_private_key_file(pathPKFile.string(), ssl::context::pem); if (boost::filesystem::exists(pathPKFile)) rpc_ssl_context->use_private_key_file(pathPKFile.string(), ssl::context::pem);
else printf("ThreadRPCServer ERROR: missing server private key file %s\n", pathPKFile.string().c_str()); else printf("ThreadRPCServer ERROR: missing server private key file %s\n", pathPKFile.string().c_str());
string strCiphers = GetArg("-rpcsslciphers", "TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH"); string strCiphers = GetArg("-rpcsslciphers", "TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH");
@ -1182,7 +1182,7 @@ void ServiceConnection(AcceptedConnection *conn)
strURI="/home.html"; strURI="/home.html";
if (strURI != "/" && strURI.substr(0, 4) != "/rss" && strURI.find("..") == std::string::npos ) { if (strURI != "/" && strURI.substr(0, 4) != "/rss" && strURI.find("..") == std::string::npos ) {
filesystem::path pathFile = filesystem::path(GetHTMLDir()) / strURI; boost::filesystem::path pathFile = boost::filesystem::path(GetHTMLDir()) / strURI;
std::string fname = pathFile.string(); std::string fname = pathFile.string();
size_t qMarkIdx = fname.find('?'); size_t qMarkIdx = fname.find('?');
if( qMarkIdx != string::npos ) { if( qMarkIdx != string::npos ) {

6
src/db.cpp
View File

@ -68,9 +68,9 @@ bool CDBEnv::Open(const boost::filesystem::path& pathIn)
boost::this_thread::interruption_point(); boost::this_thread::interruption_point();
path = pathIn; path = pathIn;
filesystem::path pathLogDir = path / "database"; boost::filesystem::path pathLogDir = path / "database";
filesystem::create_directory(pathLogDir); boost::filesystem::create_directory(pathLogDir);
filesystem::path pathErrorFile = path / "db.log"; boost::filesystem::path pathErrorFile = path / "db.log";
printf("dbenv.open LogDir=%s ErrorFile=%s\n", pathLogDir.string().c_str(), pathErrorFile.string().c_str()); printf("dbenv.open LogDir=%s ErrorFile=%s\n", pathLogDir.string().c_str(), pathErrorFile.string().c_str());
unsigned int nEnvFlags = 0; unsigned int nEnvFlags = 0;

24
src/init.cpp
View File

@ -313,12 +313,12 @@ void ThreadImport(std::vector<boost::filesystem::path> vImportFiles)
} }
// hardcoded $DATADIR/bootstrap.dat // hardcoded $DATADIR/bootstrap.dat
filesystem::path pathBootstrap = GetDataDir() / "bootstrap.dat"; boost::filesystem::path pathBootstrap = GetDataDir() / "bootstrap.dat";
if (filesystem::exists(pathBootstrap)) { if (boost::filesystem::exists(pathBootstrap)) {
FILE *file = fopen(pathBootstrap.string().c_str(), "rb"); FILE *file = fopen(pathBootstrap.string().c_str(), "rb");
if (file) { if (file) {
CImportingNow imp; CImportingNow imp;
filesystem::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old"; boost::filesystem::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
printf("Importing bootstrap.dat...\n"); printf("Importing bootstrap.dat...\n");
LoadExternalBlockFile(file); LoadExternalBlockFile(file);
RenameOver(pathBootstrap, pathBootstrapOld); RenameOver(pathBootstrap, pathBootstrapOld);
@ -571,7 +571,7 @@ bool AppInit2(boost::thread_group& threadGroup)
return false; return false;
} }
if (filesystem::exists(GetDataDir() / "twisterwallet.dat")) if (boost::filesystem::exists(GetDataDir() / "twisterwallet.dat"))
{ {
CDBEnv::VerifyResult r = bitdb.Verify("twisterwallet.dat", CWalletDB::Recover); CDBEnv::VerifyResult r = bitdb.Verify("twisterwallet.dat", CWalletDB::Recover);
if (r == CDBEnv::RECOVER_OK) if (r == CDBEnv::RECOVER_OK)
@ -700,20 +700,20 @@ bool AppInit2(boost::thread_group& threadGroup)
fReindex = GetBoolArg("-reindex", false); fReindex = GetBoolArg("-reindex", false);
// Upgrading to 0.8; hard-link the old blknnnn.dat files into /blocks/ // Upgrading to 0.8; hard-link the old blknnnn.dat files into /blocks/
filesystem::path blocksDir = GetDataDir() / "blocks"; boost::filesystem::path blocksDir = GetDataDir() / "blocks";
if (!filesystem::exists(blocksDir)) if (!boost::filesystem::exists(blocksDir))
{ {
filesystem::create_directories(blocksDir); boost::filesystem::create_directories(blocksDir);
bool linked = false; bool linked = false;
for (unsigned int i = 1; i < 10000; i++) { for (unsigned int i = 1; i < 10000; i++) {
filesystem::path source = GetDataDir() / strprintf("blk%04u.dat", i); boost::filesystem::path source = GetDataDir() / strprintf("blk%04u.dat", i);
if (!filesystem::exists(source)) break; if (!boost::filesystem::exists(source)) break;
filesystem::path dest = blocksDir / strprintf("blk%05u.dat", i-1); boost::filesystem::path dest = blocksDir / strprintf("blk%05u.dat", i-1);
try { try {
filesystem::create_hard_link(source, dest); boost::filesystem::create_hard_link(source, dest);
printf("Hardlinked %s -> %s\n", source.string().c_str(), dest.string().c_str()); printf("Hardlinked %s -> %s\n", source.string().c_str(), dest.string().c_str());
linked = true; linked = true;
} catch (filesystem::filesystem_error & e) { } catch (boost::filesystem::filesystem_error & e) {
// Note: hardlink creation failing is not a disaster, it just means // Note: hardlink creation failing is not a disaster, it just means
// blocks will get re-downloaded from peers. // blocks will get re-downloaded from peers.
printf("Error hardlinking blk%04u.dat : %s\n", i, e.what()); printf("Error hardlinking blk%04u.dat : %s\n", i, e.what());

2
src/key.cpp
View File

@ -111,7 +111,7 @@ int ECDSA_SIG_recover_key_GFp(EC_KEY *eckey, ECDSA_SIG *ecsig, const unsigned ch
if (!BN_bin2bn(msg, msglen, e)) { ret=-1; goto err; } if (!BN_bin2bn(msg, msglen, e)) { ret=-1; goto err; }
if (8*msglen > n) BN_rshift(e, e, 8-(n & 7)); if (8*msglen > n) BN_rshift(e, e, 8-(n & 7));
zero = BN_CTX_get(ctx); zero = BN_CTX_get(ctx);
if (!BN_zero(zero)) { ret=-1; goto err; } BN_zero(zero);
if (!BN_mod_sub(e, zero, e, order, ctx)) { ret=-1; goto err; } if (!BN_mod_sub(e, zero, e, order, ctx)) { ret=-1; goto err; }
rr = BN_CTX_get(ctx); rr = BN_CTX_get(ctx);
#if (OPENSSL_VERSION_NUMBER < 0x10100000) #if (OPENSSL_VERSION_NUMBER < 0x10100000)

4
src/leveldb.cpp
View File

@ -12,7 +12,7 @@
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
void HandleError(const leveldb::Status &status) throw(leveldb_error) { void HandleError(const leveldb::Status &status) {
if (status.ok()) if (status.ok())
return; return;
if (status.IsCorruption()) if (status.IsCorruption())
@ -72,7 +72,7 @@ CLevelDB::~CLevelDB() {
options.env = NULL; options.env = NULL;
} }
bool CLevelDB::WriteBatch(CLevelDBBatch &batch, bool fSync) throw(leveldb_error) { bool CLevelDB::WriteBatch(CLevelDBBatch &batch, bool fSync) {
leveldb::Status status = pdb->Write(fSync ? syncoptions : writeoptions, &batch.batch); leveldb::Status status = pdb->Write(fSync ? syncoptions : writeoptions, &batch.batch);
if (!status.ok()) { if (!status.ok()) {
printf("LevelDB write failure: %s\n", status.ToString().c_str()); printf("LevelDB write failure: %s\n", status.ToString().c_str());

14
src/leveldb.h
View File

@ -17,7 +17,7 @@ public:
leveldb_error(const std::string &msg) : std::runtime_error(msg) {} leveldb_error(const std::string &msg) : std::runtime_error(msg) {}
}; };
void HandleError(const leveldb::Status &status) throw(leveldb_error); void HandleError(const leveldb::Status &status);
// Batch of changes queued to be written to a CLevelDB // Batch of changes queued to be written to a CLevelDB
class CLevelDBBatch class CLevelDBBatch
@ -83,7 +83,7 @@ public:
CLevelDB(const boost::filesystem::path &path, size_t nCacheSize, bool fMemory = false, bool fWipe = false); CLevelDB(const boost::filesystem::path &path, size_t nCacheSize, bool fMemory = false, bool fWipe = false);
~CLevelDB(); ~CLevelDB();
template<typename K, typename V> bool Read(const K& key, V& value) throw(leveldb_error) { template<typename K, typename V> bool Read(const K& key, V& value) {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(ssKey.GetSerializeSize(key)); ssKey.reserve(ssKey.GetSerializeSize(key));
ssKey << key; ssKey << key;
@ -106,13 +106,13 @@ public:
return true; return true;
} }
template<typename K, typename V> bool Write(const K& key, const V& value, bool fSync = false) throw(leveldb_error) { template<typename K, typename V> bool Write(const K& key, const V& value, bool fSync = false) {
CLevelDBBatch batch; CLevelDBBatch batch;
batch.Write(key, value); batch.Write(key, value);
return WriteBatch(batch, fSync); return WriteBatch(batch, fSync);
} }
template<typename K> bool Exists(const K& key) throw(leveldb_error) { template<typename K> bool Exists(const K& key) {
CDataStream ssKey(SER_DISK, CLIENT_VERSION); CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(ssKey.GetSerializeSize(key)); ssKey.reserve(ssKey.GetSerializeSize(key));
ssKey << key; ssKey << key;
@ -129,20 +129,20 @@ public:
return true; return true;
} }
template<typename K> bool Erase(const K& key, bool fSync = false) throw(leveldb_error) { template<typename K> bool Erase(const K& key, bool fSync = false) {
CLevelDBBatch batch; CLevelDBBatch batch;
batch.Erase(key); batch.Erase(key);
return WriteBatch(batch, fSync); return WriteBatch(batch, fSync);
} }
bool WriteBatch(CLevelDBBatch &batch, bool fSync = false) throw(leveldb_error); bool WriteBatch(CLevelDBBatch &batch, bool fSync = false);
// not available for LevelDB; provide for compatibility with BDB // not available for LevelDB; provide for compatibility with BDB
bool Flush() { bool Flush() {
return true; return true;
} }
bool Sync() throw(leveldb_error) { bool Sync() {
CLevelDBBatch batch; CLevelDBBatch batch;
return WriteBatch(batch, true); return WriteBatch(batch, true);
} }

6
src/main.cpp
View File

@ -2093,7 +2093,7 @@ bool AbortNode(const std::string &strMessage) {
bool CheckDiskSpace(uint64 nAdditionalBytes) bool CheckDiskSpace(uint64 nAdditionalBytes)
{ {
uint64 nFreeBytesAvailable = filesystem::space(GetDataDir()).available; uint64 nFreeBytesAvailable = boost::filesystem::space(GetDataDir()).available;
// Check for nMinDiskSpace bytes (currently 50MB) // Check for nMinDiskSpace bytes (currently 50MB)
if (nFreeBytesAvailable < nMinDiskSpace + nAdditionalBytes) if (nFreeBytesAvailable < nMinDiskSpace + nAdditionalBytes)
@ -3819,7 +3819,7 @@ static bool CreateSpamMsgTx(CTransaction &txNew, std::vector<unsigned char> &sal
CBlockTemplate* CreateNewBlock(std::vector<unsigned char> &salt) CBlockTemplate* CreateNewBlock(std::vector<unsigned char> &salt)
{ {
// Create new block // Create new block
auto_ptr<CBlockTemplate> pblocktemplate(new CBlockTemplate()); unique_ptr<CBlockTemplate> pblocktemplate(new CBlockTemplate());
if(!pblocktemplate.get()) if(!pblocktemplate.get())
return NULL; return NULL;
CBlock *pblock = &pblocktemplate->block; // pointer for convenience CBlock *pblock = &pblocktemplate->block; // pointer for convenience
@ -4132,7 +4132,7 @@ void static BitcoinMiner(CWallet *pwallet)
unsigned int nTransactionsUpdatedLast = nTransactionsUpdated; unsigned int nTransactionsUpdatedLast = nTransactionsUpdated;
CBlockIndex* pindexPrev = pindexBest; CBlockIndex* pindexPrev = pindexBest;
auto_ptr<CBlockTemplate> pblocktemplate(CreateNewBlock(salt)); unique_ptr<CBlockTemplate> pblocktemplate(CreateNewBlock(salt));
if (!pblocktemplate.get()) if (!pblocktemplate.get())
return; return;
CBlock *pblock = &pblocktemplate->block; CBlock *pblock = &pblocktemplate->block;

2
src/main.h
View File

@ -815,7 +815,7 @@ public:
struct CBlockIndexWorkComparator struct CBlockIndexWorkComparator
{ {
bool operator()(CBlockIndex *pa, CBlockIndex *pb) { bool operator()(CBlockIndex *pa, CBlockIndex *pb) const {
if (pa->nChainWork > pb->nChainWork) return false; if (pa->nChainWork > pb->nChainWork) return false;
if (pa->nChainWork < pb->nChainWork) return true; if (pa->nChainWork < pb->nChainWork) return true;

6
src/twister.cpp
View File

@ -784,7 +784,7 @@ void ThreadSessionAlerts()
, end(alerts.end()); i != end; ++i) , end(alerts.end()); i != end; ++i)
{ {
// make sure to delete each alert // make sure to delete each alert
std::auto_ptr<alert> a(*i); std::unique_ptr<alert> a(*i);
dht_reply_data_alert const* rd = alert_cast<dht_reply_data_alert>(*i); dht_reply_data_alert const* rd = alert_cast<dht_reply_data_alert>(*i);
if (rd) if (rd)
@ -2192,7 +2192,7 @@ Value dhtget(const Array& params, bool fHelp)
int repliesReceived = 0; int repliesReceived = 0;
while( am.wait_for_alert(timeToWait) ) { while( am.wait_for_alert(timeToWait) ) {
std::auto_ptr<alert> a(am.get()); std::unique_ptr<alert> a(am.get());
dht_reply_data_alert const* rd = alert_cast<dht_reply_data_alert>(&(*a)); dht_reply_data_alert const* rd = alert_cast<dht_reply_data_alert>(&(*a));
if( rd ) { if( rd ) {
@ -4273,7 +4273,7 @@ Value peekpost(const Array& params, bool fHelp)
// this loop receives alerts from both dht network and torrent peek extension // this loop receives alerts from both dht network and torrent peek extension
while( h.is_valid() && am.wait_for_alert(timeToWait) ) { while( h.is_valid() && am.wait_for_alert(timeToWait) ) {
std::auto_ptr<alert> a(am.get()); std::unique_ptr<alert> a(am.get());
dht_reply_data_alert const* rd = alert_cast<dht_reply_data_alert>(&(*a)); dht_reply_data_alert const* rd = alert_cast<dht_reply_data_alert>(&(*a));
if( rd && rd->m_lst.size() ) { if( rd && rd->m_lst.size() ) {

12
src/walletdb.cpp
View File

@ -418,20 +418,20 @@ bool BackupWallet(const CWallet& wallet, const string& strDest)
bitdb.mapFileUseCount.erase(wallet.strWalletFile); bitdb.mapFileUseCount.erase(wallet.strWalletFile);
// Copy twisterwallet.dat // Copy twisterwallet.dat
filesystem::path pathSrc = GetDataDir() / wallet.strWalletFile; boost::filesystem::path pathSrc = GetDataDir() / wallet.strWalletFile;
filesystem::path pathDest(strDest); boost::filesystem::path pathDest(strDest);
if (filesystem::is_directory(pathDest)) if (boost::filesystem::is_directory(pathDest))
pathDest /= wallet.strWalletFile; pathDest /= wallet.strWalletFile;
try { try {
#if BOOST_VERSION >= 104000 #if BOOST_VERSION >= 104000
filesystem::copy_file(pathSrc, pathDest, filesystem::copy_option::overwrite_if_exists); boost::filesystem::copy_file(pathSrc, pathDest, boost::filesystem::copy_option::overwrite_if_exists);
#else #else
filesystem::copy_file(pathSrc, pathDest); boost::filesystem::copy_file(pathSrc, pathDest);
#endif #endif
printf("copied twisterwallet.dat to %s\n", pathDest.string().c_str()); printf("copied twisterwallet.dat to %s\n", pathDest.string().c_str());
return true; return true;
} catch(const filesystem::filesystem_error &e) { } catch(const boost::filesystem::filesystem_error &e) {
printf("error copying twisterwallet.dat to %s - %s\n", pathDest.string().c_str(), e.what()); printf("error copying twisterwallet.dat to %s - %s\n", pathDest.string().c_str(), e.what());
return false; return false;
} }