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 extern bool fCommandLine;\r
 125 \r
 126 void RandAddSeed();\r
 127 void RandAddSeedPerfmon();\r
 128 int OutputDebugStringF(const char* pszFormat, ...);\r
 129 int my_snprintf(char* buffer, size_t limit, const char* format, ...);\r
 130 string strprintf(const char* format, ...);\r
 131 bool error(const char* format, ...);\r
 132 void PrintException(std::exception* pex, const char* pszThread);\r
 133 void LogException(std::exception* pex, const char* pszThread);\r
 134 void ParseString(const string& str, char c, vector<string>& v);\r
 135 string FormatMoney(int64 n, bool fPlus=false);\r
 136 bool ParseMoney(const string& str, int64& nRet);\r
 137 bool ParseMoney(const char* pszIn, int64& nRet);\r
 138 vector<unsigned char> ParseHex(const char* psz);\r
 139 vector<unsigned char> ParseHex(const std::string& str);\r
 140 void ParseParameters(int argc, char* argv[]);\r
 141 const char* wxGetTranslation(const char* psz);\r
 142 int GetFilesize(FILE* file);\r
 143 void GetDataDir(char* pszDirRet);\r
 144 string GetDataDir();\r
 145 void ShrinkDebugFile();\r
 146 uint64 GetRand(uint64 nMax);\r
 147 int64 GetTime();\r
 148 int64 GetAdjustedTime();\r
 149 void AddTimeData(unsigned int ip, int64 nTime);\r
 150 \r
 151 \r
 152 \r
 153 \r
 154 \r
 155 \r
 156 \r
 157 \r
 158 \r
 159 \r
 160 \r
 161 \r
 162 \r
 163 // Wrapper to automatically initialize critical sections\r
 164 class CCriticalSection\r
 165 {\r
 166 #ifdef __WXMSW__\r
 167 protected:\r
 168     CRITICAL_SECTION cs;\r
 169 public:\r
 170     explicit CCriticalSection() { InitializeCriticalSection(&cs); }\r
 171     ~CCriticalSection() { DeleteCriticalSection(&cs); }\r
 172     void Enter() { EnterCriticalSection(&cs); }\r
 173     void Leave() { LeaveCriticalSection(&cs); }\r
 174     bool TryEnter() { return TryEnterCriticalSection(&cs); }\r
 175 #else\r
 176 protected:\r
 177     wxMutex mutex;\r
 178 public:\r
 179     explicit CCriticalSection() : mutex(wxMUTEX_RECURSIVE) { }\r
 180     ~CCriticalSection() { }\r
 181     void Enter() { mutex.Lock(); }\r
 182     void Leave() { mutex.Unlock(); }\r
 183     bool TryEnter() { return mutex.TryLock() == wxMUTEX_NO_ERROR; }\r
 184 #endif\r
 185 public:\r
 186     const char* pszFile;\r
 187     int nLine;\r
 188 };\r
 189 \r
 190 // Automatically leave critical section when leaving block, needed for exception safety\r
 191 class CCriticalBlock\r
 192 {\r
 193 protected:\r
 194     CCriticalSection* pcs;\r
 195 public:\r
 196     CCriticalBlock(CCriticalSection& csIn) { pcs = &csIn; pcs->Enter(); }\r
 197     ~CCriticalBlock() { pcs->Leave(); }\r
 198 };\r
 199 \r
 200 // WARNING: This will catch continue and break!\r
 201 // break is caught with an assertion, but there's no way to detect continue.\r
 202 // I'd rather be careful than suffer the other more error prone syntax.\r
 203 // The compiler will optimise away all this loop junk.\r
 204 #define CRITICAL_BLOCK(cs)     \\r
 205     for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by CRITICAL_BLOCK!", !fcriticalblockonce)), fcriticalblockonce=false)  \\r
 206     for (CCriticalBlock criticalblock(cs); fcriticalblockonce && (cs.pszFile=__FILE__, cs.nLine=__LINE__, true); fcriticalblockonce=false, cs.pszFile=NULL, cs.nLine=0)\r
 207 \r
 208 class CTryCriticalBlock\r
 209 {\r
 210 protected:\r
 211     CCriticalSection* pcs;\r
 212 public:\r
 213     CTryCriticalBlock(CCriticalSection& csIn) { pcs = (csIn.TryEnter() ? &csIn : NULL); }\r
 214     ~CTryCriticalBlock() { if (pcs) pcs->Leave(); }\r
 215     bool Entered() { return pcs != NULL; }\r
 216 };\r
 217 \r
 218 #define TRY_CRITICAL_BLOCK(cs)     \\r
 219     for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by TRY_CRITICAL_BLOCK!", !fcriticalblockonce)), fcriticalblockonce=false)  \\r
 220     for (CTryCriticalBlock criticalblock(cs); fcriticalblockonce && (fcriticalblockonce = criticalblock.Entered()) && (cs.pszFile=__FILE__, cs.nLine=__LINE__, true); fcriticalblockonce=false, cs.pszFile=NULL, cs.nLine=0)\r
 221 \r
 222 \r
 223 \r
 224 \r
 225 \r
 226 \r
 227 \r
 228 \r
 229 \r
 230 \r
 231 inline string i64tostr(int64 n)\r
 232 {\r
 233     return strprintf("%"PRI64d, n);\r
 234 }\r
 235 \r
 236 inline string itostr(int n)\r
 237 {\r
 238     return strprintf("%d", n);\r
 239 }\r
 240 \r
 241 inline int64 atoi64(const char* psz)\r
 242 {\r
 243 #ifdef _MSC_VER\r
 244     return _atoi64(psz);\r
 245 #else\r
 246     return strtoll(psz, NULL, 10);\r
 247 #endif\r
 248 }\r
 249 \r
 250 inline int64 atoi64(const string& str)\r
 251 {\r
 252 #ifdef _MSC_VER\r
 253     return _atoi64(str.c_str());\r
 254 #else\r
 255     return strtoll(str.c_str(), NULL, 10);\r
 256 #endif\r
 257 }\r
 258 \r
 259 inline int atoi(const string& str)\r
 260 {\r
 261     return atoi(str.c_str());\r
 262 }\r
 263 \r
 264 inline int roundint(double d)\r
 265 {\r
 266     return (int)(d > 0 ? d + 0.5 : d - 0.5);\r
 267 }\r
 268 \r
 269 inline int64 roundint64(double d)\r
 270 {\r
 271     return (int64)(d > 0 ? d + 0.5 : d - 0.5);\r
 272 }\r
 273 \r
 274 template<typename T>\r
 275 string HexStr(const T itbegin, const T itend, bool fSpaces=true)\r
 276 {\r
 277     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];\r
 278     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);\r
 279     string str;\r
 280     for (const unsigned char* p = pbegin; p != pend; p++)\r
 281         str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);\r
 282     return str;\r
 283 }\r
 284 \r
 285 inline string HexStr(vector<unsigned char> vch, bool fSpaces=true)\r
 286 {\r
 287     return HexStr(vch.begin(), vch.end(), fSpaces);\r
 288 }\r
 289 \r
 290 template<typename T>\r
 291 string HexNumStr(const T itbegin, const T itend, bool f0x=true)\r
 292 {\r
 293     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];\r
 294     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);\r
 295     string str = (f0x ? "0x" : "");\r
 296     for (const unsigned char* p = pend-1; p >= pbegin; p--)\r
 297         str += strprintf("%02X", *p);\r
 298     return str;\r
 299 }\r
 300 \r
 301 template<typename T>\r
 302 void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)\r
 303 {\r
 304     printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());\r
 305 }\r
 306 \r
 307 inline void PrintHex(vector<unsigned char> vch, const char* pszFormat="%s", bool fSpaces=true)\r
 308 {\r
 309     printf(pszFormat, HexStr(vch, fSpaces).c_str());\r
 310 }\r
 311 \r
 312 inline int64 PerformanceCounter()\r
 313 {\r
 314     int64 nCounter = 0;\r
 315 #ifdef __WXMSW__\r
 316     QueryPerformanceCounter((LARGE_INTEGER*)&nCounter);\r
 317 #else\r
 318     timeval t;\r
 319     gettimeofday(&t, NULL);\r
 320     nCounter = t.tv_sec * 1000000 + t.tv_usec;\r
 321 #endif\r
 322     return nCounter;\r
 323 }\r
 324 \r
 325 inline int64 GetTimeMillis()\r
 326 {\r
 327     return wxGetLocalTimeMillis().GetValue();\r
 328 }\r
 329 \r
 330 inline string DateTimeStrFormat(const char* pszFormat, int64 nTime)\r
 331 {\r
 332     time_t n = nTime;\r
 333     struct tm* ptmTime = gmtime(&n);\r
 334     char pszTime[200];\r
 335     strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);\r
 336     return pszTime;\r
 337 }\r
 338 \r
 339 template<typename T>\r
 340 void skipspaces(T& it)\r
 341 {\r
 342     while (isspace(*it))\r
 343         ++it;\r
 344 }\r
 345 \r
 346 \r
 347 \r
 348 \r
 349 \r
 350 \r
 351 \r
 352 \r
 353 \r
 354 \r
 355 \r
 356 \r
 357 inline void heapchk()\r
 358 {\r
 359 #ifdef __WXMSW__\r
 360     /// for debugging\r
 361     //if (_heapchk() != _HEAPOK)\r
 362     //    DebugBreak();\r
 363 #endif\r
 364 }\r
 365 \r
 366 // Randomize the stack to help protect against buffer overrun exploits\r
 367 #define IMPLEMENT_RANDOMIZE_STACK(ThreadFn)                         \\r
 368     {                                                               \\r
 369         static char nLoops;                                         \\r
 370         if (nLoops <= 0)                                            \\r
 371             nLoops = GetRand(20) + 1;                               \\r
 372         if (nLoops-- > 1)                                           \\r
 373         {                                                           \\r
 374             ThreadFn;                                               \\r
 375             return;                                                 \\r
 376         }                                                           \\r
 377     }\r
 378 \r
 379 #define CATCH_PRINT_EXCEPTION(pszFn)     \\r
 380     catch (std::exception& e) {          \\r
 381         PrintException(&e, (pszFn));     \\r
 382     } catch (...) {                      \\r
 383         PrintException(NULL, (pszFn));   \\r
 384     }\r
 385 \r
 386 \r
 387 \r
 388 \r
 389 \r
 390 \r
 391 \r
 392 \r
 393 \r
 394 \r
 395 template<typename T1>\r
 396 inline uint256 Hash(const T1 pbegin, const T1 pend)\r
 397 {\r
 398     uint256 hash1;\r
 399     SHA256((unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);\r
 400     uint256 hash2;\r
 401     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 402     return hash2;\r
 403 }\r
 404 \r
 405 template<typename T1, typename T2>\r
 406 inline uint256 Hash(const T1 p1begin, const T1 p1end,\r
 407                     const T2 p2begin, const T2 p2end)\r
 408 {\r
 409     uint256 hash1;\r
 410     SHA256_CTX ctx;\r
 411     SHA256_Init(&ctx);\r
 412     SHA256_Update(&ctx, (unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]));\r
 413     SHA256_Update(&ctx, (unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]));\r
 414     SHA256_Final((unsigned char*)&hash1, &ctx);\r
 415     uint256 hash2;\r
 416     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 417     return hash2;\r
 418 }\r
 419 \r
 420 template<typename T1, typename T2, typename T3>\r
 421 inline uint256 Hash(const T1 p1begin, const T1 p1end,\r
 422                     const T2 p2begin, const T2 p2end,\r
 423                     const T3 p3begin, const T3 p3end)\r
 424 {\r
 425     uint256 hash1;\r
 426     SHA256_CTX ctx;\r
 427     SHA256_Init(&ctx);\r
 428     SHA256_Update(&ctx, (unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]));\r
 429     SHA256_Update(&ctx, (unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]));\r
 430     SHA256_Update(&ctx, (unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0]));\r
 431     SHA256_Final((unsigned char*)&hash1, &ctx);\r
 432     uint256 hash2;\r
 433     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 434     return hash2;\r
 435 }\r
 436 \r
 437 template<typename T>\r
 438 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)\r
 439 {\r
 440     // Most of the time is spent allocating and deallocating CDataStream's\r
 441     // buffer.  If this ever needs to be optimized further, make a CStaticStream\r
 442     // class with its buffer on the stack.\r
 443     CDataStream ss(nType, nVersion);\r
 444     ss.reserve(10000);\r
 445     ss << obj;\r
 446     return Hash(ss.begin(), ss.end());\r
 447 }\r
 448 \r
 449 inline uint160 Hash160(const vector<unsigned char>& vch)\r
 450 {\r
 451     uint256 hash1;\r
 452     SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);\r
 453     uint160 hash2;\r
 454     RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);\r
 455     return hash2;\r
 456 }\r
 457 \r
 458 \r
 459 \r
 460 \r
 461 \r
 462 \r
 463 \r
 464 \r
 465 \r
 466 \r
 467 \r
 468 // Note: It turns out we might have been able to use boost::thread\r
 469 // by using TerminateThread(boost::thread.native_handle(), 0);\r
 470 #ifdef __WXMSW__\r
 471 typedef HANDLE pthread_t;\r
 472 \r
 473 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)\r
 474 {\r
 475     DWORD nUnused = 0;\r
 476     HANDLE hthread =\r
 477         CreateThread(\r
 478             NULL,                        // default security\r
 479             0,                           // inherit stack size from parent\r
 480             (LPTHREAD_START_ROUTINE)pfn, // function pointer\r
 481             parg,                        // argument\r
 482             0,                           // creation option, start immediately\r
 483             &nUnused);                   // thread identifier\r
 484     if (hthread == NULL)\r
 485     {\r
 486         printf("Error: CreateThread() returned %d\n", GetLastError());\r
 487         return (pthread_t)0;\r
 488     }\r
 489     if (!fWantHandle)\r
 490     {\r
 491         CloseHandle(hthread);\r
 492         return (pthread_t)-1;\r
 493     }\r
 494     return hthread;\r
 495 }\r
 496 \r
 497 inline void SetThreadPriority(int nPriority)\r
 498 {\r
 499     SetThreadPriority(GetCurrentThread(), nPriority);\r
 500 }\r
 501 #else\r
 502 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)\r
 503 {\r
 504     pthread_t hthread = 0;\r
 505     int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg);\r
 506     if (ret != 0)\r
 507     {\r
 508         printf("Error: pthread_create() returned %d\n", ret);\r
 509         return (pthread_t)0;\r
 510     }\r
 511     if (!fWantHandle)\r
 512         return (pthread_t)-1;\r
 513     return hthread;\r
 514 }\r
 515 \r
 516 #define THREAD_PRIORITY_LOWEST          PRIO_MIN\r
 517 #define THREAD_PRIORITY_BELOW_NORMAL    2\r
 518 #define THREAD_PRIORITY_NORMAL          0\r
 519 #define THREAD_PRIORITY_ABOVE_NORMAL    0\r
 520 \r
 521 inline void SetThreadPriority(int nPriority)\r
 522 {\r
 523     // It's unclear if it's even possible to change thread priorities on Linux,\r
 524     // but we really and truly need it for the generation threads.\r
 525 #ifdef PRIO_THREAD\r
 526     setpriority(PRIO_THREAD, 0, nPriority);\r
 527 #else\r
 528     setpriority(PRIO_PROCESS, 0, nPriority);\r
 529 #endif\r
 530 }\r
 531 \r
 532 inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)\r
 533 {\r
 534     return (pthread_cancel(hthread) == 0);\r
 535 }\r
 536 \r
 537 inline void ExitThread(unsigned int nExitCode)\r
 538 {\r
 539     pthread_exit((void*)nExitCode);\r
 540 }\r
 541 #endif\r