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