util.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto\r
   2 // Distributed under the MIT/X11 software license, see the accompanying\r
   3 // file license.txt or http://www.opensource.org/licenses/mit-license.php.\r
   4 \r
   5 \r
   6 #if defined(_MSC_VER) || defined(__BORLANDC__)\r
   7 typedef __int64  int64;\r
   8 typedef unsigned __int64  uint64;\r
   9 #else\r
  10 typedef long long  int64;\r
  11 typedef unsigned long long  uint64;\r
  12 #endif\r
  13 #if defined(_MSC_VER) && _MSC_VER < 1300\r
  14 #define for  if (false) ; else for\r
  15 #endif\r
  16 #ifndef _MSC_VER\r
  17 #define __forceinline  inline\r
  18 #endif\r
  19 \r
  20 #define foreach             BOOST_FOREACH\r
  21 #define loop                for (;;)\r
  22 #define BEGIN(a)            ((char*)&(a))\r
  23 #define END(a)              ((char*)&((&(a))[1]))\r
  24 #define UBEGIN(a)           ((unsigned char*)&(a))\r
  25 #define UEND(a)             ((unsigned char*)&((&(a))[1]))\r
  26 #define ARRAYLEN(array)     (sizeof(array)/sizeof((array)[0]))\r
  27 #define printf              OutputDebugStringF\r
  28 \r
  29 #ifdef snprintf\r
  30 #undef snprintf\r
  31 #endif\r
  32 #define snprintf my_snprintf\r
  33 \r
  34 #ifndef PRI64d\r
  35 #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MSVCRT__)\r
  36 #define PRI64d  "I64d"\r
  37 #define PRI64u  "I64u"\r
  38 #define PRI64x  "I64x"\r
  39 #else\r
  40 #define PRI64d  "lld"\r
  41 #define PRI64u  "llu"\r
  42 #define PRI64x  "llx"\r
  43 #endif\r
  44 #endif\r
  45 \r
  46 // This is needed because the foreach macro can't get over the comma in pair<t1, t2>\r
  47 #define PAIRTYPE(t1, t2)    pair<t1, t2>\r
  48 \r
  49 // Used to bypass the rule against non-const reference to temporary\r
  50 // where it makes sense with wrappers such as CFlatData or CTxDB\r
  51 template<typename T>\r
  52 inline T& REF(const T& val)\r
  53 {\r
  54     return (T&)val;\r
  55 }\r
  56 \r
  57 #ifdef __WXMSW__\r
  58 static const bool fWindows = true;\r
  59 #define MSG_NOSIGNAL        0\r
  60 #define MSG_DONTWAIT        0\r
  61 #ifndef UINT64_MAX\r
  62 #define UINT64_MAX          _UI64_MAX\r
  63 #define INT64_MAX           _I64_MAX\r
  64 #define INT64_MIN           _I64_MIN\r
  65 #endif\r
  66 #ifndef S_IRUSR\r
  67 #define S_IRUSR             0400\r
  68 #define S_IWUSR             0200\r
  69 #endif\r
  70 #define unlink              _unlink\r
  71 typedef int socklen_t;\r
  72 #else\r
  73 static const bool fWindows = false;\r
  74 #define WSAGetLastError()   errno\r
  75 #define WSAEWOULDBLOCK      EWOULDBLOCK\r
  76 #define WSAEMSGSIZE         EMSGSIZE\r
  77 #define WSAEINTR            EINTR\r
  78 #define WSAEINPROGRESS      EINPROGRESS\r
  79 #define WSAEADDRINUSE       EADDRINUSE\r
  80 #define WSAENOTSOCK         EBADF\r
  81 #define INVALID_SOCKET      (SOCKET)(~0)\r
  82 #define SOCKET_ERROR        -1\r
  83 typedef u_int SOCKET;\r
  84 #define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)\r
  85 #define strlwr(psz)         to_lower(psz)\r
  86 #define _strlwr(psz)        to_lower(psz)\r
  87 #define _mkdir(psz)         filesystem::create_directory(psz)\r
  88 #define MAX_PATH            1024\r
  89 #define Sleep(n)            wxMilliSleep(n)\r
  90 #define Beep(n1,n2)         (0)\r
  91 #endif\r
  92 \r
  93 inline int myclosesocket(SOCKET& hSocket)\r
  94 {\r
  95     if (hSocket == INVALID_SOCKET)\r
  96         return WSAENOTSOCK;\r
  97 #ifdef __WXMSW__\r
  98     int ret = closesocket(hSocket);\r
  99 #else\r
 100     int ret = close(hSocket);\r
 101 #endif\r
 102     hSocket = INVALID_SOCKET;\r
 103     return ret;\r
 104 }\r
 105 #define closesocket(s)      myclosesocket(s)\r
 106 \r
 107 \r
 108 \r
 109 \r
 110 \r
 111 \r
 112 \r
 113 \r
 114 \r
 115 \r
 116 extern map<string, string> mapArgs;\r
 117 extern map<string, vector<string> > mapMultiArgs;\r
 118 extern bool fDebug;\r
 119 extern bool fPrintToConsole;\r
 120 extern bool fPrintToDebugger;\r
 121 extern char pszSetDataDir[MAX_PATH];\r
 122 extern bool fShutdown;\r
 123 extern bool fDaemon;\r
 124 \r
 125 void RandAddSeed();\r
 126 void RandAddSeedPerfmon();\r
 127 int OutputDebugStringF(const char* pszFormat, ...);\r
 128 int my_snprintf(char* buffer, size_t limit, const char* format, ...);\r
 129 string strprintf(const char* format, ...);\r
 130 bool error(const char* format, ...);\r
 131 void PrintException(std::exception* pex, const char* pszThread);\r
 132 void LogException(std::exception* pex, const char* pszThread);\r
 133 void ParseString(const string& str, char c, vector<string>& v);\r
 134 string FormatMoney(int64 n, bool fPlus=false);\r
 135 bool ParseMoney(const char* pszIn, int64& nRet);\r
 136 vector<unsigned char> ParseHex(const char* psz);\r
 137 vector<unsigned char> ParseHex(const std::string& str);\r
 138 void ParseParameters(int argc, char* argv[]);\r
 139 int GetFilesize(FILE* file);\r
 140 void GetDataDir(char* pszDirRet);\r
 141 string GetDataDir();\r
 142 void ShrinkDebugFile();\r
 143 uint64 GetRand(uint64 nMax);\r
 144 int64 GetTime();\r
 145 int64 GetAdjustedTime();\r
 146 void AddTimeData(unsigned int ip, int64 nTime);\r
 147 \r
 148 \r
 149 \r
 150 \r
 151 \r
 152 \r
 153 \r
 154 \r
 155 \r
 156 \r
 157 \r
 158 \r
 159 \r
 160 // Wrapper to automatically initialize critical sections\r
 161 class CCriticalSection\r
 162 {\r
 163 #ifdef __WXMSW__\r
 164 protected:\r
 165     CRITICAL_SECTION cs;\r
 166 public:\r
 167     explicit CCriticalSection() { InitializeCriticalSection(&cs); }\r
 168     ~CCriticalSection() { DeleteCriticalSection(&cs); }\r
 169     void Enter() { EnterCriticalSection(&cs); }\r
 170     void Leave() { LeaveCriticalSection(&cs); }\r
 171     bool TryEnter() { return TryEnterCriticalSection(&cs); }\r
 172 #else\r
 173 protected:\r
 174     wxMutex mutex;\r
 175 public:\r
 176     explicit CCriticalSection() : mutex(wxMUTEX_RECURSIVE) { }\r
 177     ~CCriticalSection() { }\r
 178     void Enter() { mutex.Lock(); }\r
 179     void Leave() { mutex.Unlock(); }\r
 180     bool TryEnter() { return mutex.TryLock() == wxMUTEX_NO_ERROR; }\r
 181 #endif\r
 182 public:\r
 183     const char* pszFile;\r
 184     int nLine;\r
 185 };\r
 186 \r
 187 // Automatically leave critical section when leaving block, needed for exception safety\r
 188 class CCriticalBlock\r
 189 {\r
 190 protected:\r
 191     CCriticalSection* pcs;\r
 192 public:\r
 193     CCriticalBlock(CCriticalSection& csIn) { pcs = &csIn; pcs->Enter(); }\r
 194     ~CCriticalBlock() { pcs->Leave(); }\r
 195 };\r
 196 \r
 197 // WARNING: This will catch continue and break!\r
 198 // break is caught with an assertion, but there's no way to detect continue.\r
 199 // I'd rather be careful than suffer the other more error prone syntax.\r
 200 // The compiler will optimise away all this loop junk.\r
 201 #define CRITICAL_BLOCK(cs)     \\r
 202     for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by CRITICAL_BLOCK!", !fcriticalblockonce)), fcriticalblockonce=false)  \\r
 203     for (CCriticalBlock criticalblock(cs); fcriticalblockonce && (cs.pszFile=__FILE__, cs.nLine=__LINE__, true); fcriticalblockonce=false, cs.pszFile=NULL, cs.nLine=0)\r
 204 \r
 205 class CTryCriticalBlock\r
 206 {\r
 207 protected:\r
 208     CCriticalSection* pcs;\r
 209 public:\r
 210     CTryCriticalBlock(CCriticalSection& csIn) { pcs = (csIn.TryEnter() ? &csIn : NULL); }\r
 211     ~CTryCriticalBlock() { if (pcs) pcs->Leave(); }\r
 212     bool Entered() { return pcs != NULL; }\r
 213 };\r
 214 \r
 215 #define TRY_CRITICAL_BLOCK(cs)     \\r
 216     for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by TRY_CRITICAL_BLOCK!", !fcriticalblockonce)), fcriticalblockonce=false)  \\r
 217     for (CTryCriticalBlock criticalblock(cs); fcriticalblockonce && (fcriticalblockonce = criticalblock.Entered()) && (cs.pszFile=__FILE__, cs.nLine=__LINE__, true); fcriticalblockonce=false, cs.pszFile=NULL, cs.nLine=0)\r
 218 \r
 219 \r
 220 \r
 221 \r
 222 \r
 223 \r
 224 \r
 225 \r
 226 \r
 227 \r
 228 inline string i64tostr(int64 n)\r
 229 {\r
 230     return strprintf("%"PRI64d, n);\r
 231 }\r
 232 \r
 233 inline string itostr(int n)\r
 234 {\r
 235     return strprintf("%d", n);\r
 236 }\r
 237 \r
 238 inline int64 atoi64(const char* psz)\r
 239 {\r
 240 #ifdef _MSC_VER\r
 241     return _atoi64(psz);\r
 242 #else\r
 243     return strtoll(psz, NULL, 10);\r
 244 #endif\r
 245 }\r
 246 \r
 247 inline int64 atoi64(const string& str)\r
 248 {\r
 249 #ifdef _MSC_VER\r
 250     return _atoi64(str.c_str());\r
 251 #else\r
 252     return strtoll(str.c_str(), NULL, 10);\r
 253 #endif\r
 254 }\r
 255 \r
 256 inline int atoi(const string& str)\r
 257 {\r
 258     return atoi(str.c_str());\r
 259 }\r
 260 \r
 261 inline int roundint(double d)\r
 262 {\r
 263     return (int)(d > 0 ? d + 0.5 : d - 0.5);\r
 264 }\r
 265 \r
 266 inline int64 roundint64(double d)\r
 267 {\r
 268     return (int64)(d > 0 ? d + 0.5 : d - 0.5);\r
 269 }\r
 270 \r
 271 template<typename T>\r
 272 string HexStr(const T itbegin, const T itend, bool fSpaces=true)\r
 273 {\r
 274     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];\r
 275     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);\r
 276     string str;\r
 277     for (const unsigned char* p = pbegin; p != pend; p++)\r
 278         str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);\r
 279     return str;\r
 280 }\r
 281 \r
 282 inline string HexStr(vector<unsigned char> vch, bool fSpaces=true)\r
 283 {\r
 284     return HexStr(vch.begin(), vch.end(), fSpaces);\r
 285 }\r
 286 \r
 287 template<typename T>\r
 288 string HexNumStr(const T itbegin, const T itend, bool f0x=true)\r
 289 {\r
 290     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];\r
 291     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);\r
 292     string str = (f0x ? "0x" : "");\r
 293     for (const unsigned char* p = pend-1; p >= pbegin; p--)\r
 294         str += strprintf("%02X", *p);\r
 295     return str;\r
 296 }\r
 297 \r
 298 template<typename T>\r
 299 void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)\r
 300 {\r
 301     printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());\r
 302 }\r
 303 \r
 304 inline void PrintHex(vector<unsigned char> vch, const char* pszFormat="%s", bool fSpaces=true)\r
 305 {\r
 306     printf(pszFormat, HexStr(vch, fSpaces).c_str());\r
 307 }\r
 308 \r
 309 inline int64 PerformanceCounter()\r
 310 {\r
 311     int64 nCounter = 0;\r
 312 #ifdef __WXMSW__\r
 313     QueryPerformanceCounter((LARGE_INTEGER*)&nCounter);\r
 314 #else\r
 315     timeval t;\r
 316     gettimeofday(&t, NULL);\r
 317     nCounter = t.tv_sec * 1000000 + t.tv_usec;\r
 318 #endif\r
 319     return nCounter;\r
 320 }\r
 321 \r
 322 inline int64 GetTimeMillis()\r
 323 {\r
 324     return wxGetLocalTimeMillis().GetValue();\r
 325 }\r
 326 \r
 327 inline string DateTimeStrFormat(const char* pszFormat, int64 nTime)\r
 328 {\r
 329     time_t n = nTime;\r
 330     struct tm* ptmTime = gmtime(&n);\r
 331     char pszTime[200];\r
 332     strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);\r
 333     return pszTime;\r
 334 }\r
 335 \r
 336 template<typename T>\r
 337 void skipspaces(T& it)\r
 338 {\r
 339     while (isspace(*it))\r
 340         ++it;\r
 341 }\r
 342 \r
 343 \r
 344 \r
 345 \r
 346 \r
 347 \r
 348 \r
 349 \r
 350 \r
 351 \r
 352 \r
 353 \r
 354 \r
 355 inline void heapchk()\r
 356 {\r
 357 #ifdef __WXMSW__\r
 358     /// for debugging\r
 359     //if (_heapchk() != _HEAPOK)\r
 360     //    DebugBreak();\r
 361 #endif\r
 362 }\r
 363 \r
 364 // Randomize the stack to help protect against buffer overrun exploits\r
 365 #define IMPLEMENT_RANDOMIZE_STACK(ThreadFn)                         \\r
 366     {                                                               \\r
 367         static char nLoops;                                         \\r
 368         if (nLoops <= 0)                                            \\r
 369             nLoops = GetRand(20) + 1;                               \\r
 370         if (nLoops-- > 1)                                           \\r
 371         {                                                           \\r
 372             ThreadFn;                                               \\r
 373             return;                                                 \\r
 374         }                                                           \\r
 375     }\r
 376 \r
 377 #define CATCH_PRINT_EXCEPTION(pszFn)     \\r
 378     catch (std::exception& e) {          \\r
 379         PrintException(&e, (pszFn));     \\r
 380     } catch (...) {                      \\r
 381         PrintException(NULL, (pszFn));   \\r
 382     }\r
 383 \r
 384 \r
 385 \r
 386 \r
 387 \r
 388 \r
 389 \r
 390 \r
 391 \r
 392 \r
 393 template<typename T1>\r
 394 inline uint256 Hash(const T1 pbegin, const T1 pend)\r
 395 {\r
 396     uint256 hash1;\r
 397     SHA256((unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);\r
 398     uint256 hash2;\r
 399     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 400     return hash2;\r
 401 }\r
 402 \r
 403 template<typename T1, typename T2>\r
 404 inline uint256 Hash(const T1 p1begin, const T1 p1end,\r
 405                     const T2 p2begin, const T2 p2end)\r
 406 {\r
 407     uint256 hash1;\r
 408     SHA256_CTX ctx;\r
 409     SHA256_Init(&ctx);\r
 410     SHA256_Update(&ctx, (unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]));\r
 411     SHA256_Update(&ctx, (unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]));\r
 412     SHA256_Final((unsigned char*)&hash1, &ctx);\r
 413     uint256 hash2;\r
 414     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 415     return hash2;\r
 416 }\r
 417 \r
 418 template<typename T1, typename T2, typename T3>\r
 419 inline uint256 Hash(const T1 p1begin, const T1 p1end,\r
 420                     const T2 p2begin, const T2 p2end,\r
 421                     const T3 p3begin, const T3 p3end)\r
 422 {\r
 423     uint256 hash1;\r
 424     SHA256_CTX ctx;\r
 425     SHA256_Init(&ctx);\r
 426     SHA256_Update(&ctx, (unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]));\r
 427     SHA256_Update(&ctx, (unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]));\r
 428     SHA256_Update(&ctx, (unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]));\r
 429     SHA256_Final((unsigned char*)&hash1, &ctx);\r
 430     uint256 hash2;\r
 431     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 432     return hash2;\r
 433 }\r
 434 \r
 435 template<typename T>\r
 436 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)\r
 437 {\r
 438     // Most of the time is spent allocating and deallocating CDataStream's\r
 439     // buffer.  If this ever needs to be optimized further, make a CStaticStream\r
 440     // class with its buffer on the stack.\r
 441     CDataStream ss(nType, nVersion);\r
 442     ss.reserve(10000);\r
 443     ss << obj;\r
 444     return Hash(ss.begin(), ss.end());\r
 445 }\r
 446 \r
 447 inline uint160 Hash160(const vector<unsigned char>& vch)\r
 448 {\r
 449     uint256 hash1;\r
 450     SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);\r
 451     uint160 hash2;\r
 452     RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 453     return hash2;\r
 454 }\r
 455 \r
 456 \r
 457 \r
 458 \r
 459 \r
 460 \r
 461 \r
 462 \r
 463 \r
 464 \r
 465 \r
 466 // Note: It turns out we might have been able to use boost::thread\r
 467 // by using TerminateThread(boost::thread.native_handle(), 0);\r
 468 #ifdef __WXMSW__\r
 469 typedef HANDLE pthread_t;\r
 470 \r
 471 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)\r
 472 {\r
 473     DWORD nUnused = 0;\r
 474     HANDLE hthread =\r
 475         CreateThread(\r
 476             NULL,                        // default security\r
 477             0,                           // inherit stack size from parent\r
 478             (LPTHREAD_START_ROUTINE)pfn, // function pointer\r
 479             parg,                        // argument\r
 480             0,                           // creation option, start immediately\r
 481             &nUnused);                   // thread identifier\r
 482     if (hthread == NULL)\r
 483     {\r
 484         printf("Error: CreateThread() returned %d\n", GetLastError());\r
 485         return (pthread_t)0;\r
 486     }\r
 487     if (!fWantHandle)\r
 488     {\r
 489         CloseHandle(hthread);\r
 490         return (pthread_t)-1;\r
 491     }\r
 492     return hthread;\r
 493 }\r
 494 \r
 495 inline void SetThreadPriority(int nPriority)\r
 496 {\r
 497     SetThreadPriority(GetCurrentThread(), nPriority);\r
 498 }\r
 499 #else\r
 500 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)\r
 501 {\r
 502     pthread_t hthread = 0;\r
 503     int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg);\r
 504     if (ret != 0)\r
 505     {\r
 506         printf("Error: pthread_create() returned %d\n", ret);\r
 507         return (pthread_t)0;\r
 508     }\r
 509     if (!fWantHandle)\r
 510         return (pthread_t)-1;\r
 511     return hthread;\r
 512 }\r
 513 \r
 514 #define THREAD_PRIORITY_LOWEST          PRIO_MIN\r
 515 #define THREAD_PRIORITY_BELOW_NORMAL    2\r
 516 #define THREAD_PRIORITY_NORMAL          0\r
 517 #define THREAD_PRIORITY_ABOVE_NORMAL    0\r
 518 \r
 519 inline void SetThreadPriority(int nPriority)\r
 520 {\r
 521     // threads are processes on linux, so PRIO_PROCESS affects just the one thread\r
 522     setpriority(PRIO_PROCESS, getpid(), nPriority);\r
 523 }\r
 524 \r
 525 inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)\r
 526 {\r
 527     return (pthread_cancel(hthread) == 0);\r
 528 }\r
 529 \r
 530 inline void ExitThread(unsigned int nExitCode)\r
 531 {\r
 532     pthread_exit((void*)nExitCode);\r
 533 }\r
 534 #endif\r