X-Git-Url: https://git.novaco.in/?p=novacoin.git;a=blobdiff_plain;f=src%2Futil.h;h=6cf2070a86700bccab4f820f0d58aa73de455899;hp=45b14420f1930525bc9000d4d38cfb266f7708d8;hb=c95d66bd55a225326e81dce15d347f04b1d71d67;hpb=d05c03ab4ed23389b1326f9b7c77a8d7b8d6588d diff --git a/src/util.h b/src/util.h index 45b1442..6cf2070 100644 --- a/src/util.h +++ b/src/util.h @@ -1,10 +1,11 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2012 The Bitcoin developers // Distributed under the MIT/X11 software license, see the accompanying -// file license.txt or http://www.opensource.org/licenses/mit-license.php. +// file COPYING or http://www.opensource.org/licenses/mit-license.php. #ifndef BITCOIN_UTIL_H #define BITCOIN_UTIL_H + #include "uint256.h" #ifndef WIN32 @@ -12,56 +13,86 @@ #include #include #endif + #include #include #include +#ifndef Q_MOC_RUN #include -#include +#include +#include #include #include +#endif -#include -#include - +#include -#if defined(_MSC_VER) || defined(__BORLANDC__) -typedef __int64 int64; -typedef unsigned __int64 uint64; -#else -typedef long long int64; -typedef unsigned long long uint64; -#endif -#if defined(_MSC_VER) && _MSC_VER < 1300 -#define for if (false) ; else for -#endif -#ifndef _MSC_VER -#define __forceinline inline +#if defined(__USE_MINGW_ANSI_STDIO) +#undef __USE_MINGW_ANSI_STDIO // This constant forces MinGW to conduct stupid behavior #endif +#include + +#include "netbase.h" // for AddTimeData + +static const int32_t nOneHour = 60 * 60; +static const int32_t nOneDay = 24 * 60 * 60; +static const int64_t nOneWeek = 7 * 24 * 60 * 60; + +static const int64_t COIN = 1000000; +static const int64_t CENT = 10000; -#define loop for (;;) #define BEGIN(a) ((char*)&(a)) #define END(a) ((char*)&((&(a))[1])) #define UBEGIN(a) ((unsigned char*)&(a)) #define UEND(a) ((unsigned char*)&((&(a))[1])) #define ARRAYLEN(array) (sizeof(array)/sizeof((array)[0])) -#define printf OutputDebugStringF -#ifdef snprintf -#undef snprintf +#define UVOIDBEGIN(a) ((void*)&(a)) +#define CVOIDBEGIN(a) ((const void*)&(a)) +#define UINTBEGIN(a) ((uint32_t*)&(a)) +#define CUINTBEGIN(a) ((const uint32_t*)&(a)) + +#ifndef THROW_WITH_STACKTRACE +#define THROW_WITH_STACKTRACE(exception) \ +{ \ + LogStackTrace(); \ + throw (exception); \ +} +void LogStackTrace(); #endif -#define snprintf my_snprintf -#ifndef PRI64d -#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MSVCRT__) -#define PRI64d "I64d" -#define PRI64u "I64u" -#define PRI64x "I64x" -#else -#define PRI64d "lld" -#define PRI64u "llu" -#define PRI64x "llx" +#if defined(_MSC_VER) || defined(__MSVCRT__) + /* Silence compiler warnings on Windows + related to MinGWs inttypes.h */ + #undef PRIu64 + #undef PRId64 + #undef PRIx64 + + #define PRIu64 "I64u" + #define PRId64 "I64d" + #define PRIx64 "I64x" + #endif + +/* Format characters for (s)size_t and ptrdiff_t */ +#if defined(_MSC_VER) || defined(__MSVCRT__) + /* (s)size_t and ptrdiff_t have the same size specifier in MSVC: + http://msdn.microsoft.com/en-us/library/tcxf1dw6%28v=vs.100%29.aspx + */ + #define PRIszx "Ix" + #define PRIszu "Iu" + #define PRIszd "Id" + #define PRIpdx "Ix" + #define PRIpdu "Iu" + #define PRIpdd "Id" +#else /* C99 standard */ + #define PRIszx "zx" + #define PRIszu "zu" + #define PRIszd "zd" + #define PRIpdx "tx" + #define PRIpdu "tu" + #define PRIpdd "td" #endif // This is needed because the foreach macro can't get over the comma in pair @@ -84,36 +115,14 @@ T* alignup(T* p) #ifdef WIN32 #define MSG_NOSIGNAL 0 #define MSG_DONTWAIT 0 -#ifndef UINT64_MAX -#define UINT64_MAX _UI64_MAX -#define INT64_MAX _I64_MAX -#define INT64_MIN _I64_MIN -#endif + #ifndef S_IRUSR #define S_IRUSR 0400 #define S_IWUSR 0200 #endif -#define unlink _unlink -typedef int socklen_t; #else -#define WSAGetLastError() errno -#define WSAEINVAL EINVAL -#define WSAEALREADY EALREADY -#define WSAEWOULDBLOCK EWOULDBLOCK -#define WSAEMSGSIZE EMSGSIZE -#define WSAEINTR EINTR -#define WSAEINPROGRESS EINPROGRESS -#define WSAEADDRINUSE EADDRINUSE -#define WSAENOTSOCK EBADF -#define INVALID_SOCKET (SOCKET)(~0) -#define SOCKET_ERROR -1 -typedef u_int SOCKET; -#define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d) -#define strlwr(psz) to_lower(psz) -#define _strlwr(psz) to_lower(psz) #define MAX_PATH 1024 -#define Beep(n1,n2) (0) -inline void Sleep(int64 n) +inline void Sleep(int64_t n) { /*Boost has a year 2038 problem— if the request sleep time is past epoch+2^31 seconds the sleep returns instantly. So we clamp our sleeps here to 10 years and hope that boost is fixed by 2028.*/ @@ -121,24 +130,14 @@ inline void Sleep(int64 n) } #endif -inline int myclosesocket(SOCKET& hSocket) -{ - if (hSocket == INVALID_SOCKET) - return WSAENOTSOCK; -#ifdef WIN32 - int ret = closesocket(hSocket); +/* This GNU C extension enables the compiler to check the format string against the parameters provided. + * X is the number of the "format string" parameter, and Y is the number of the first variadic parameter. + * Parameters count from 1. + */ +#ifdef __GNUC__ +#define ATTR_WARN_PRINTF(X,Y) __attribute__((format(printf,X,Y))) #else - int ret = close(hSocket); -#endif - hSocket = INVALID_SOCKET; - return ret; -} -#define closesocket(s) myclosesocket(s) -#if !defined(QT_GUI) -inline const char* _(const char* psz) -{ - return psz; -} +#define ATTR_WARN_PRINTF(X,Y) #endif @@ -148,13 +147,12 @@ inline const char* _(const char* psz) - extern std::map mapArgs; extern std::map > mapMultiArgs; extern bool fDebug; +extern bool fDebugNet; extern bool fPrintToConsole; extern bool fPrintToDebugger; -extern char pszSetDataDir[MAX_PATH]; extern bool fRequestShutdown; extern bool fShutdown; extern bool fDaemon; @@ -164,49 +162,92 @@ extern std::string strMiscWarning; extern bool fTestNet; extern bool fNoListen; extern bool fLogTimestamps; +extern bool fReopenDebugLog; void RandAddSeed(); void RandAddSeedPerfmon(); -int OutputDebugStringF(const char* pszFormat, ...); -int my_snprintf(char* buffer, size_t limit, const char* format, ...); -std::string strprintf(const std::string &format, ...); -bool error(const std::string &format, ...); +int ATTR_WARN_PRINTF(1,2) OutputDebugStringF(const char* pszFormat, ...); + +/* + Rationale for the real_strprintf / strprintf construction: + It is not allowed to use va_start with a pass-by-reference argument. + (C++ standard, 18.7, paragraph 3). Use a dummy argument to work around this, and use a + macro to keep similar semantics. +*/ + +/** Overload strprintf for char*, so that GCC format type warnings can be given */ +std::string ATTR_WARN_PRINTF(1,3) real_strprintf(const char *format, int dummy, ...); +/** Overload strprintf for std::string, to be able to use it with _ (translation). + * This will not support GCC format type warnings (-Wformat) so be careful. + */ +std::string real_strprintf(const std::string &format, int dummy, ...); +#define strprintf(format, ...) real_strprintf(format, 0, __VA_ARGS__) +std::string vstrprintf(const char *format, va_list ap); + +bool ATTR_WARN_PRINTF(1,2) error(const char *format, ...); + +/* Redefine printf so that it directs output to debug.log + * + * Do this *after* defining the other printf-like functions, because otherwise the + * __attribute__((format(printf,X,Y))) gets expanded to __attribute__((format(OutputDebugStringF,X,Y))) + * which confuses gcc. + */ +#define printf OutputDebugStringF + void LogException(std::exception* pex, const char* pszThread); void PrintException(std::exception* pex, const char* pszThread); void PrintExceptionContinue(std::exception* pex, const char* pszThread); void ParseString(const std::string& str, char c, std::vector& v); -std::string FormatMoney(int64 n, bool fPlus=false); -bool ParseMoney(const std::string& str, int64& nRet); -bool ParseMoney(const char* pszIn, int64& nRet); +std::string FormatMoney(int64_t n, bool fPlus=false); +bool ParseMoney(const std::string& str, int64_t& nRet); +bool ParseMoney(const char* pszIn, int64_t& nRet); std::vector ParseHex(const char* psz); std::vector ParseHex(const std::string& str); +bool IsHex(const std::string& str); std::vector DecodeBase64(const char* p, bool* pfInvalid = NULL); std::string DecodeBase64(const std::string& str); std::string EncodeBase64(const unsigned char* pch, size_t len); std::string EncodeBase64(const std::string& str); -void ParseParameters(int argc, char* argv[]); -const char* wxGetTranslation(const char* psz); +std::vector DecodeBase32(const char* p, bool* pfInvalid = NULL); +std::string DecodeBase32(const std::string& str); +std::string EncodeBase32(const unsigned char* pch, size_t len); +std::string EncodeBase32(const std::string& str); +std::string EncodeDumpTime(int64_t nTime); +int64_t DecodeDumpTime(const std::string& s); +std::string EncodeDumpString(const std::string &str); +std::string DecodeDumpString(const std::string &str); +void ParseParameters(int argc, const char*const argv[]); bool WildcardMatch(const char* psz, const char* mask); bool WildcardMatch(const std::string& str, const std::string& mask); +void FileCommit(FILE *fileout); int GetFilesize(FILE* file); -void GetDataDir(char* pszDirRet); -std::string GetConfigFile(); -std::string GetPidFile(); -void CreatePidFile(std::string pidFile, pid_t pid); +bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest); +boost::filesystem::path GetDefaultDataDir(); +const boost::filesystem::path &GetDataDir(bool fNetSpecific = true); +boost::filesystem::path GetConfigFile(); +boost::filesystem::path GetPidFile(); +#ifndef WIN32 +void CreatePidFile(const boost::filesystem::path &path, pid_t pid); +#endif void ReadConfigFile(std::map& mapSettingsRet, std::map >& mapMultiSettingsRet); #ifdef WIN32 -std::string MyGetSpecialFolderPath(int nFolder, bool fCreate); +boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate = true); #endif -std::string GetDefaultDataDir(); -std::string GetDataDir(); void ShrinkDebugFile(); int GetRandInt(int nMax); -uint64 GetRand(uint64 nMax); -int64 GetTime(); -void SetMockTime(int64 nMockTimeIn); -int64 GetAdjustedTime(); -void AddTimeData(unsigned int ip, int64 nTime); +uint64_t GetRand(uint64_t nMax); +uint256 GetRandHash(); +int64_t GetTime(); +int64_t GetTimeMillis(); +int64_t GetTimeMicros(); + +int64_t GetAdjustedTime(); +int64_t GetTimeOffset(); +int64_t GetNodesOffset(); std::string FormatFullVersion(); +std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector& comments); +void AddTimeData(const CNetAddr& ip, int64_t nTime); +void runCommand(std::string strCommand); @@ -216,105 +257,9 @@ std::string FormatFullVersion(); - - - - -// Wrapper to automatically initialize mutex -class CCriticalSection -{ -protected: - boost::interprocess::interprocess_recursive_mutex mutex; -public: - explicit CCriticalSection() { } - ~CCriticalSection() { } - void Enter(const char* pszName, const char* pszFile, int nLine); - void Leave(); - bool TryEnter(const char* pszName, const char* pszFile, int nLine); -}; - -// Automatically leave critical section when leaving block, needed for exception safety -class CCriticalBlock +inline std::string i64tostr(int64_t n) { -protected: - CCriticalSection* pcs; - -public: - CCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine) - { - pcs = &csIn; - pcs->Enter(pszName, pszFile, nLine); - } - - operator bool() const - { - return true; - } - - ~CCriticalBlock() - { - pcs->Leave(); - } -}; - -#define CRITICAL_BLOCK(cs) \ - if (CCriticalBlock criticalblock = CCriticalBlock(cs, #cs, __FILE__, __LINE__)) - -#define ENTER_CRITICAL_SECTION(cs) \ - (cs).Enter(#cs, __FILE__, __LINE__) - -#define LEAVE_CRITICAL_SECTION(cs) \ - (cs).Leave() - -class CTryCriticalBlock -{ -protected: - CCriticalSection* pcs; - -public: - CTryCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine) - { - pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL); - } - - operator bool() const - { - return Entered(); - } - - ~CTryCriticalBlock() - { - if (pcs) - { - pcs->Leave(); - } - } - bool Entered() const { return pcs != NULL; } -}; - -#define TRY_CRITICAL_BLOCK(cs) \ - if (CTryCriticalBlock criticalblock = CTryCriticalBlock(cs, #cs, __FILE__, __LINE__)) - - - - - - -// This is exactly like std::string, but with a custom allocator. -// (secure_allocator<> is defined in serialize.h) -typedef std::basic_string, secure_allocator > SecureString; - -// This is exactly like std::string, but with a custom allocator. -// (secure_allocator<> is defined in serialize.h) -typedef std::basic_string, secure_allocator > SecureString; - - - - - -inline std::string i64tostr(int64 n) -{ - return strprintf("%"PRI64d, n); + return strprintf("%" PRId64, n); } inline std::string itostr(int n) @@ -322,7 +267,7 @@ inline std::string itostr(int n) return strprintf("%d", n); } -inline int64 atoi64(const char* psz) +inline int64_t atoi64(const char* psz) { #ifdef _MSC_VER return _atoi64(psz); @@ -331,7 +276,7 @@ inline int64 atoi64(const char* psz) #endif } -inline int64 atoi64(const std::string& str) +inline int64_t atoi64(const std::string& str) { #ifdef _MSC_VER return _atoi64(str.c_str()); @@ -340,6 +285,26 @@ inline int64 atoi64(const std::string& str) #endif } +inline int32_t strtol(const char* psz) +{ + return strtol(psz, NULL, 10); +} + +inline int32_t strtol(const std::string& str) +{ + return strtol(str.c_str(), NULL, 10); +} + +inline uint32_t strtoul(const char* psz) +{ + return strtoul(psz, NULL, 10); +} + +inline uint32_t strtoul(const std::string& str) +{ + return strtoul(str.c_str(), NULL, 10); +} + inline int atoi(const std::string& str) { return atoi(str.c_str()); @@ -350,52 +315,48 @@ inline int roundint(double d) return (int)(d > 0 ? d + 0.5 : d - 0.5); } -inline int64 roundint64(double d) +inline int64_t roundint64(double d) { - return (int64)(d > 0 ? d + 0.5 : d - 0.5); + return (int64_t)(d > 0 ? d + 0.5 : d - 0.5); } -inline int64 abs64(int64 n) +inline int64_t abs64(int64_t n) { return (n >= 0 ? n : -n); } -template -std::string HexStr(const T itbegin, const T itend, bool fSpaces=false) +inline std::string leftTrim(std::string src, char chr) { - if (itbegin == itend) - return ""; - const unsigned char* pbegin = (const unsigned char*)&itbegin[0]; - const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]); - std::string str; - str.reserve((pend-pbegin) * (fSpaces ? 3 : 2)); - for (const unsigned char* p = pbegin; p != pend; p++) - str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p); - return str; -} + std::string::size_type pos = src.find_first_not_of(chr, 0); -inline std::string HexStr(const std::vector& vch, bool fSpaces=false) -{ - return HexStr(vch.begin(), vch.end(), fSpaces); + if(pos > 0) + src.erase(0, pos); + + return src; } template -std::string HexNumStr(const T itbegin, const T itend, bool f0x=true) +std::string HexStr(const T itbegin, const T itend, bool fSpaces=false) { - if (itbegin == itend) - return ""; - const unsigned char* pbegin = (const unsigned char*)&itbegin[0]; - const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]); - std::string str = (f0x ? "0x" : ""); - str.reserve(str.size() + (pend-pbegin) * 2); - for (const unsigned char* p = pend-1; p >= pbegin; p--) - str += strprintf("%02x", *p); - return str; + std::string rv; + static const char hexmap[16] = { '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + rv.reserve((itend-itbegin)*3); + for(T it = itbegin; it < itend; ++it) + { + unsigned char val = (unsigned char)(*it); + if(fSpaces && it != itbegin) + rv.push_back(' '); + rv.push_back(hexmap[val>>4]); + rv.push_back(hexmap[val&15]); + } + + return rv; } -inline std::string HexNumStr(const std::vector& vch, bool f0x=true) +inline std::string HexStr(const std::vector& vch, bool fSpaces=false) { - return HexNumStr(vch.begin(), vch.end(), f0x); + return HexStr(vch.begin(), vch.end(), fSpaces); } template @@ -409,34 +370,40 @@ inline void PrintHex(const std::vector& vch, const char* pszForma printf(pszFormat, HexStr(vch, fSpaces).c_str()); } -inline int64 GetPerformanceCounter() +inline int64_t GetPerformanceCounter() { - int64 nCounter = 0; + int64_t nCounter = 0; #ifdef WIN32 QueryPerformanceCounter((LARGE_INTEGER*)&nCounter); #else timeval t; gettimeofday(&t, NULL); - nCounter = t.tv_sec * 1000000 + t.tv_usec; + nCounter = (int64_t) t.tv_sec * 1000000 + t.tv_usec; #endif return nCounter; } -inline int64 GetTimeMillis() +inline int64_t GetTimeMillis() { - return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) - + return (boost::posix_time::microsec_clock::universal_time() - boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds(); } -inline std::string DateTimeStrFormat(const char* pszFormat, int64 nTime) +inline int64_t GetTimeMicros() +{ + return (boost::posix_time::microsec_clock::universal_time() - + boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_microseconds(); +} + +std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime); + +static const std::string strTimestampFormat = "%Y-%m-%d %H:%M:%S UTC"; +inline std::string DateTimeStrFormat(int64_t nTime) { - time_t n = nTime; - struct tm* ptmTime = gmtime(&n); - char pszTime[200]; - strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime); - return pszTime; + return DateTimeStrFormat(strTimestampFormat.c_str(), nTime); } + template void skipspaces(T& it) { @@ -453,30 +420,50 @@ inline bool IsSwitchChar(char c) #endif } -inline std::string GetArg(const std::string& strArg, const std::string& strDefault) -{ - if (mapArgs.count(strArg)) - return mapArgs[strArg]; - return strDefault; -} +/** + * Return string argument or default value + * + * @param strArg Argument to get (e.g. "-foo") + * @param default (e.g. "1") + * @return command-line argument or default value + */ +std::string GetArg(const std::string& strArg, const std::string& strDefault); -inline int64 GetArg(const std::string& strArg, int64 nDefault) -{ - if (mapArgs.count(strArg)) - return atoi64(mapArgs[strArg]); - return nDefault; -} +/** + * Return 64-bit integer argument or default value + * + * @param strArg Argument to get (e.g. "-foo") + * @param default (e.g. 1) + * @return command-line argument (0 if invalid number) or default value + */ +int64_t GetArg(const std::string& strArg, int64_t nDefault); -inline bool GetBoolArg(const std::string& strArg, bool fDefault=false) -{ - if (mapArgs.count(strArg)) - { - if (mapArgs[strArg].empty()) - return true; - return (atoi(mapArgs[strArg]) != 0); - } - return fDefault; -} +/** + * Return 32-bit integer argument or default value + * + * @param strArg Argument to get (e.g. "-foo") + * @param default (e.g. 1) + * @return command-line argument (0 if invalid number) or default value + */ +int32_t GetArgInt(const std::string& strArg, int32_t nDefault); + +/** + * Return 32-bit unsigned integer argument or default value + * + * @param strArg Argument to get (e.g. "-foo") + * @param default (e.g. 1) + * @return command-line argument (0 if invalid number) or default value + */ +uint32_t GetArgUInt(const std::string& strArg, uint32_t nDefault); + +/** + * Return boolean argument or default value + * + * @param strArg Argument to get (e.g. "-foo") + * @param default (true or false) + * @return command-line argument or default value + */ +bool GetBoolArg(const std::string& strArg, bool fDefault=false); /** * Set an argument if it doesn't already have a value @@ -494,138 +481,41 @@ bool SoftSetArg(const std::string& strArg, const std::string& strValue); * @param fValue Value (e.g. false) * @return true if argument gets set, false if it already had a value */ -bool SoftSetArg(const std::string& strArg, bool fValue); - - - - - - - - - -inline void heapchk() -{ -#ifdef WIN32 - /// for debugging - //if (_heapchk() != _HEAPOK) - // DebugBreak(); -#endif -} +bool SoftSetBoolArg(const std::string& strArg, bool fValue); -// Randomize the stack to help protect against buffer overrun exploits -#define IMPLEMENT_RANDOMIZE_STACK(ThreadFn) \ - { \ - static char nLoops; \ - if (nLoops <= 0) \ - nLoops = GetRand(20) + 1; \ - if (nLoops-- > 1) \ - { \ - ThreadFn; \ - return; \ - } \ - } - -#define CATCH_PRINT_EXCEPTION(pszFn) \ - catch (std::exception& e) { \ - PrintException(&e, (pszFn)); \ - } catch (...) { \ - PrintException(NULL, (pszFn)); \ - } - - - - - - - - - - -template -inline uint256 Hash(const T1 pbegin, const T1 pend) -{ - static unsigned char pblank[1]; - uint256 hash1; - SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1); - uint256 hash2; - SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2); - return hash2; -} - -template -inline uint256 Hash(const T1 p1begin, const T1 p1end, - const T2 p2begin, const T2 p2end) -{ - static unsigned char pblank[1]; - uint256 hash1; - SHA256_CTX ctx; - SHA256_Init(&ctx); - SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0])); - SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0])); - SHA256_Final((unsigned char*)&hash1, &ctx); - uint256 hash2; - SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2); - return hash2; -} - -template -inline uint256 Hash(const T1 p1begin, const T1 p1end, - const T2 p2begin, const T2 p2end, - const T3 p3begin, const T3 p3end) -{ - static unsigned char pblank[1]; - uint256 hash1; - SHA256_CTX ctx; - SHA256_Init(&ctx); - SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0])); - SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0])); - SHA256_Update(&ctx, (p3begin == p3end ? pblank : (unsigned char*)&p3begin[0]), (p3end - p3begin) * sizeof(p3begin[0])); - SHA256_Final((unsigned char*)&hash1, &ctx); - uint256 hash2; - SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2); - return hash2; -} - -template -uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION) -{ - // Most of the time is spent allocating and deallocating CDataStream's - // buffer. If this ever needs to be optimized further, make a CStaticStream - // class with its buffer on the stack. - CDataStream ss(nType, nVersion); - ss.reserve(10000); - ss << obj; - return Hash(ss.begin(), ss.end()); -} - -inline uint160 Hash160(const std::vector& vch) +/** + * Timing-attack-resistant comparison. + * Takes time proportional to length + * of first argument. + */ +template +bool TimingResistantEqual(const T& a, const T& b) { - uint256 hash1; - SHA256(&vch[0], vch.size(), (unsigned char*)&hash1); - uint160 hash2; - RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2); - return hash2; + if (b.size() == 0) return a.size() == 0; + size_t accumulator = a.size() ^ b.size(); + for (size_t i = 0; i < a.size(); i++) + accumulator |= a[i] ^ b[i%b.size()]; + return accumulator == 0; } - -// Median filter over a stream of values -// Returns the median of the last N numbers +/** Median filter over a stream of values. + * Returns the median of the last N numbers + */ template class CMedianFilter { private: std::vector vValues; std::vector vSorted; - int nSize; + unsigned int nSize; public: - CMedianFilter(int size, T initial_value): + CMedianFilter(unsigned int size, T initial_value): nSize(size) { vValues.reserve(size); vValues.push_back(initial_value); vSorted = vValues; } - + void input(T value) { if(vValues.size() == nSize) @@ -641,7 +531,7 @@ public: T median() const { - int size = vSorted.size(); + size_t size = vSorted.size(); assert(size>0); if(size & 1) // Odd number of elements { @@ -652,67 +542,26 @@ public: return (vSorted[size/2-1] + vSorted[size/2]) / 2; } } -}; - - - - - - - - - -// Note: It turns out we might have been able to use boost::thread -// by using TerminateThread(boost::thread.native_handle(), 0); -#ifdef WIN32 -typedef HANDLE pthread_t; - -inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false) -{ - DWORD nUnused = 0; - HANDLE hthread = - CreateThread( - NULL, // default security - 0, // inherit stack size from parent - (LPTHREAD_START_ROUTINE)pfn, // function pointer - parg, // argument - 0, // creation option, start immediately - &nUnused); // thread identifier - if (hthread == NULL) + int size() const { - printf("Error: CreateThread() returned %d\n", GetLastError()); - return (pthread_t)0; + return static_cast(vValues.size()); } - if (!fWantHandle) + + std::vector sorted () const { - CloseHandle(hthread); - return (pthread_t)-1; + return vSorted; } - return hthread; -} +}; + +bool NewThread(void(*pfn)(void*), void* parg); +#ifdef WIN32 inline void SetThreadPriority(int nPriority) { SetThreadPriority(GetCurrentThread(), nPriority); } #else -inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false) -{ - pthread_t hthread = 0; - int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg); - if (ret != 0) - { - printf("Error: pthread_create() returned %d\n", ret); - return (pthread_t)0; - } - if (!fWantHandle) - { - pthread_detach(hthread); - return (pthread_t)-1; - } - return hthread; -} #define THREAD_PRIORITY_LOWEST PRIO_MAX #define THREAD_PRIORITY_BELOW_NORMAL 2 @@ -730,40 +579,13 @@ inline void SetThreadPriority(int nPriority) #endif } -inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode) -{ - return (pthread_cancel(hthread) == 0); -} - inline void ExitThread(size_t nExitCode) { pthread_exit((void*)nExitCode); } #endif - - - - -inline bool AffinityBugWorkaround(void(*pfn)(void*)) -{ -#ifdef WIN32 - // Sometimes after a few hours affinity gets stuck on one processor - DWORD_PTR dwProcessAffinityMask = -1; - DWORD_PTR dwSystemAffinityMask = -1; - GetProcessAffinityMask(GetCurrentProcess(), &dwProcessAffinityMask, &dwSystemAffinityMask); - DWORD dwPrev1 = SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinityMask); - DWORD dwPrev2 = SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinityMask); - if (dwPrev2 != dwProcessAffinityMask) - { - printf("AffinityBugWorkaround() : SetThreadAffinityMask=%d, ProcessAffinityMask=%d, restarting thread\n", dwPrev2, dwProcessAffinityMask); - if (!CreateThread(pfn, NULL)) - printf("Error: CreateThread() failed\n"); - return true; - } -#endif - return false; -} +void RenameThread(const char* name); inline uint32_t ByteReverse(uint32_t value) { @@ -772,3 +594,4 @@ inline uint32_t ByteReverse(uint32_t value) } #endif +