src/util.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5 #ifndef BITCOIN_UTIL_H
   6 #define BITCOIN_UTIL_H
   7
   8
   9 #ifndef WIN32
  10 #include <sys/types.h>
  11 #include <sys/time.h>
  12 #include <sys/resource.h>
  13 #endif
  14
  15 #include <map>
  16 #include <vector>
  17 #include <string>
  18
  19 #ifndef Q_MOC_RUN
  20 #include <boost/thread.hpp>
  21 #include <boost/filesystem.hpp>
  22 #include <boost/filesystem/path.hpp>
  23 #include <boost/date_time/gregorian/gregorian_types.hpp>
  24 #include <boost/date_time/posix_time/posix_time_types.hpp>
  25 #endif
  26
  27 #include <stdarg.h>
  28
  29 #if defined(__USE_MINGW_ANSI_STDIO)
  30 #undef __USE_MINGW_ANSI_STDIO // This constant forces MinGW to conduct stupid behavior
  31 #endif
  32 #include <inttypes.h>
  33
  34
  35 static const int32_t nOneHour = 60 * 60;
  36 static const int32_t nOneDay = 24 * 60 * 60;
  37 static const int64_t nOneWeek = 7 * 24 * 60 * 60;
  38
  39 static const int64_t COIN = 1000000;
  40 static const int64_t CENT = 10000;
  41
  42 #define BEGIN(a)            ((char*)&(a))
  43 #define END(a)              ((char*)&((&(a))[1]))
  44 #define UBEGIN(a)           ((unsigned char*)&(a))
  45 #define UEND(a)             ((unsigned char*)&((&(a))[1]))
  46 #define ARRAYLEN(array)     (sizeof(array)/sizeof((array)[0]))
  47
  48 #define UVOIDBEGIN(a)        ((void*)&(a))
  49 #define CVOIDBEGIN(a)        ((const void*)&(a))
  50 #define UINTBEGIN(a)        ((uint32_t*)&(a))
  51 #define CUINTBEGIN(a)        ((const uint32_t*)&(a))
  52
  53 #ifndef THROW_WITH_STACKTRACE
  54 #define THROW_WITH_STACKTRACE(exception)  \
  55 {                                         \
  56     LogStackTrace();                      \
  57     throw (exception);                    \
  58 }
  59 void LogStackTrace();
  60 #endif
  61
  62 #if defined(_MSC_VER) || defined(__MSVCRT__)
  63  /* Silence compiler warnings on Windows
  64      related to MinGWs inttypes.h */
  65  #undef PRIu64
  66  #undef PRId64
  67  #undef PRIx64
  68
  69  #define PRIu64 "I64u"
  70  #define PRId64 "I64d"
  71  #define PRIx64 "I64x"
  72
  73 #endif
  74
  75 /* Format characters for (s)size_t and ptrdiff_t */
  76 #if defined(_MSC_VER) || defined(__MSVCRT__)
  77   /* (s)size_t and ptrdiff_t have the same size specifier in MSVC:
  78      http://msdn.microsoft.com/en-us/library/tcxf1dw6%28v=vs.100%29.aspx
  79    */
  80   #define PRIszx    "Ix"
  81   #define PRIszu    "Iu"
  82   #define PRIszd    "Id"
  83   #define PRIpdx    "Ix"
  84   #define PRIpdu    "Iu"
  85   #define PRIpdd    "Id"
  86 #else /* C99 standard */
  87   #define PRIszx    "zx"
  88   #define PRIszu    "zu"
  89   #define PRIszd    "zd"
  90   #define PRIpdx    "tx"
  91   #define PRIpdu    "tu"
  92   #define PRIpdd    "td"
  93 #endif
  94
  95 // This is needed because the foreach macro can't get over the comma in pair<t1, t2>
  96 #define PAIRTYPE(t1, t2)    std::pair<t1, t2>
  97
  98 // Align by increasing pointer, must have extra space at end of buffer
  99 template <size_t nBytes, typename T>
 100 T* alignup(T* p)
 101 {
 102     union
 103     {
 104         T* ptr;
 105         size_t n;
 106     } u;
 107     u.ptr = p;
 108     u.n = (u.n + (nBytes-1)) & ~(nBytes-1);
 109     return u.ptr;
 110 }
 111
 112 #ifdef WIN32
 113 #define MSG_NOSIGNAL        0
 114 #define MSG_DONTWAIT        0
 115
 116 #ifndef S_IRUSR
 117 #define S_IRUSR             0400
 118 #define S_IWUSR             0200
 119 #endif
 120 #else
 121 #define MAX_PATH            1024
 122 inline void Sleep(int64_t n)
 123 {
 124     /*Boost has a year 2038 problem— if the request sleep time is past epoch+2^31 seconds the sleep returns instantly.
 125       So we clamp our sleeps here to 10 years and hope that boost is fixed by 2028.*/
 126     boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(n>315576000000LL?315576000000LL:n));
 127 }
 128 #endif
 129
 130 /* This GNU C extension enables the compiler to check the format string against the parameters provided.
 131  * X is the number of the "format string" parameter, and Y is the number of the first variadic parameter.
 132  * Parameters count from 1.
 133  */
 134 #ifdef __GNUC__
 135 #define ATTR_WARN_PRINTF(X,Y) __attribute__((format(printf,X,Y)))
 136 #else
 137 #define ATTR_WARN_PRINTF(X,Y)
 138 #endif
 139
 140
 141
 142
 143
 144
 145
 146
 147 extern std::map<std::string, std::string> mapArgs;
 148 extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
 149 extern bool fDebug;
 150 extern bool fDebugNet;
 151 extern bool fPrintToConsole;
 152 extern bool fPrintToDebugger;
 153 extern bool fRequestShutdown;
 154 extern bool fShutdown;
 155 extern bool fDaemon;
 156 extern bool fServer;
 157 extern bool fCommandLine;
 158 extern std::string strMiscWarning;
 159 extern bool fTestNet;
 160 extern bool fNoListen;
 161 extern bool fLogTimestamps;
 162 extern bool fReopenDebugLog;
 163
 164 void RandAddSeed();
 165 void RandAddSeedPerfmon();
 166 int ATTR_WARN_PRINTF(1,2) OutputDebugStringF(const char* pszFormat, ...);
 167
 168 /*
 169   Rationale for the real_strprintf / strprintf construction:
 170     It is not allowed to use va_start with a pass-by-reference argument.
 171     (C++ standard, 18.7, paragraph 3). Use a dummy argument to work around this, and use a
 172     macro to keep similar semantics.
 173 */
 174
 175 /** Overload strprintf for char*, so that GCC format type warnings can be given */
 176 std::string ATTR_WARN_PRINTF(1,3) real_strprintf(const char *format, int dummy, ...);
 177 /** Overload strprintf for std::string, to be able to use it with _ (translation).
 178  * This will not support GCC format type warnings (-Wformat) so be careful.
 179  */
 180 std::string real_strprintf(const std::string &format, int dummy, ...);
 181 #define strprintf(format, ...) real_strprintf(format, 0, __VA_ARGS__)
 182 std::string vstrprintf(const char *format, va_list ap);
 183
 184 bool ATTR_WARN_PRINTF(1,2) error(const char *format, ...);
 185
 186 /* Redefine printf so that it directs output to debug.log
 187  *
 188  * Do this *after* defining the other printf-like functions, because otherwise the
 189  * __attribute__((format(printf,X,Y))) gets expanded to __attribute__((format(OutputDebugStringF,X,Y)))
 190  * which confuses gcc.
 191  */
 192 #define printf OutputDebugStringF
 193
 194 void LogException(std::exception* pex, const char* pszThread);
 195 void PrintException(std::exception* pex, const char* pszThread);
 196 void PrintExceptionContinue(std::exception* pex, const char* pszThread);
 197 void ParseString(const std::string& str, char c, std::vector<std::string>& v);
 198 std::string FormatMoney(int64_t n, bool fPlus=false);
 199 bool ParseMoney(const std::string& str, int64_t& nRet);
 200 bool ParseMoney(const char* pszIn, int64_t& nRet);
 201 std::vector<unsigned char> ParseHex(const char* psz);
 202 std::vector<unsigned char> ParseHex(const std::string& str);
 203 bool IsHex(const std::string& str);
 204 std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL);
 205 std::string DecodeBase64(const std::string& str);
 206 std::string EncodeBase64(const unsigned char* pch, size_t len);
 207 std::string EncodeBase64(const std::string& str);
 208 std::vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid = NULL);
 209 std::string DecodeBase32(const std::string& str);
 210 std::string EncodeBase32(const unsigned char* pch, size_t len);
 211 std::string EncodeBase32(const std::string& str);
 212 std::string EncodeDumpTime(int64_t nTime);
 213 int64_t DecodeDumpTime(const std::string& s);
 214 std::string EncodeDumpString(const std::string &str);
 215 std::string DecodeDumpString(const std::string &str);
 216 void ParseParameters(int argc, const char*const argv[]);
 217 bool WildcardMatch(const char* psz, const char* mask);
 218 bool WildcardMatch(const std::string& str, const std::string& mask);
 219 void FileCommit(FILE *fileout);
 220 int GetFilesize(FILE* file);
 221 bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest);
 222 boost::filesystem::path GetDefaultDataDir();
 223 const boost::filesystem::path &GetDataDir(bool fNetSpecific = true);
 224 boost::filesystem::path GetConfigFile();
 225 boost::filesystem::path GetPidFile();
 226 #ifndef WIN32
 227 void CreatePidFile(const boost::filesystem::path &path, pid_t pid);
 228 #endif
 229 void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
 230 #ifdef WIN32
 231 boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate = true);
 232 #endif
 233 void ShrinkDebugFile();
 234 int GetRandInt(int nMax);
 235 uint64_t GetRand(uint64_t nMax);
 236 int64_t GetTime();
 237 int64_t GetTimeMillis();
 238 int64_t GetTimeMicros();
 239 std::string FormatFullVersion();
 240 std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector<std::string>& comments);
 241 void runCommand(std::string strCommand);
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251 inline std::string i64tostr(int64_t n)
 252 {
 253     return strprintf("%" PRId64, n);
 254 }
 255
 256 inline std::string itostr(int n)
 257 {
 258     return strprintf("%d", n);
 259 }
 260
 261 inline int64_t atoi64(const char* psz)
 262 {
 263 #ifdef _MSC_VER
 264     return _atoi64(psz);
 265 #else
 266     return strtoll(psz, NULL, 10);
 267 #endif
 268 }
 269
 270 inline int64_t atoi64(const std::string& str)
 271 {
 272 #ifdef _MSC_VER
 273     return _atoi64(str.c_str());
 274 #else
 275     return strtoll(str.c_str(), NULL, 10);
 276 #endif
 277 }
 278
 279 inline int32_t strtol(const char* psz)
 280 {
 281     return strtol(psz, NULL, 10);
 282 }
 283
 284 inline int32_t strtol(const std::string& str)
 285 {
 286     return strtol(str.c_str(), NULL, 10);
 287 }
 288
 289 inline uint32_t strtoul(const char* psz)
 290 {
 291     return strtoul(psz, NULL, 10);
 292 }
 293
 294 inline uint32_t strtoul(const std::string& str)
 295 {
 296     return strtoul(str.c_str(), NULL, 10);
 297 }
 298
 299 inline int atoi(const std::string& str)
 300 {
 301     return atoi(str.c_str());
 302 }
 303
 304 inline int roundint(double d)
 305 {
 306     return (int)(d > 0 ? d + 0.5 : d - 0.5);
 307 }
 308
 309 inline int64_t roundint64(double d)
 310 {
 311     return (int64_t)(d > 0 ? d + 0.5 : d - 0.5);
 312 }
 313
 314 inline int64_t abs64(int64_t n)
 315 {
 316     return (n >= 0 ? n : -n);
 317 }
 318
 319 inline std::string leftTrim(std::string src, char chr)
 320 {
 321     std::string::size_type pos = src.find_first_not_of(chr, 0);
 322
 323     if(pos > 0)
 324         src.erase(0, pos);
 325
 326     return src;
 327 }
 328
 329 template<typename T>
 330 std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
 331 {
 332     std::string rv;
 333     static const char hexmap[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
 334                                      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 335     rv.reserve((itend-itbegin)*3);
 336     for(T it = itbegin; it < itend; ++it)
 337     {
 338         unsigned char val = (unsigned char)(*it);
 339         if(fSpaces && it != itbegin)
 340             rv.push_back(' ');
 341         rv.push_back(hexmap[val>>4]);
 342         rv.push_back(hexmap[val&15]);
 343     }
 344
 345     return rv;
 346 }
 347
 348 inline std::string HexStr(const std::vector<unsigned char>& vch, bool fSpaces=false)
 349 {
 350     return HexStr(vch.begin(), vch.end(), fSpaces);
 351 }
 352
 353 template<typename T>
 354 void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)
 355 {
 356     printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());
 357 }
 358
 359 inline void PrintHex(const std::vector<unsigned char>& vch, const char* pszFormat="%s", bool fSpaces=true)
 360 {
 361     printf(pszFormat, HexStr(vch, fSpaces).c_str());
 362 }
 363
 364 inline int64_t GetPerformanceCounter()
 365 {
 366     int64_t nCounter = 0;
 367 #ifdef WIN32
 368     QueryPerformanceCounter((LARGE_INTEGER*)&nCounter);
 369 #else
 370     timeval t;
 371     gettimeofday(&t, NULL);
 372     nCounter = (int64_t) t.tv_sec * 1000000 + t.tv_usec;
 373 #endif
 374     return nCounter;
 375 }
 376
 377 inline int64_t GetTimeMillis()
 378 {
 379     return (boost::posix_time::microsec_clock::universal_time() -
 380             boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds();
 381 }
 382
 383 inline int64_t GetTimeMicros()
 384 {
 385     return (boost::posix_time::microsec_clock::universal_time() -
 386                    boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_microseconds();
 387 }
 388
 389 std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime);
 390
 391 static const std::string strTimestampFormat = "%Y-%m-%d %H:%M:%S UTC";
 392 inline std::string DateTimeStrFormat(int64_t nTime)
 393 {
 394     return DateTimeStrFormat(strTimestampFormat.c_str(), nTime);
 395 }
 396
 397
 398 template<typename T>
 399 void skipspaces(T& it)
 400 {
 401     while (isspace(*it))
 402         ++it;
 403 }
 404
 405 inline bool IsSwitchChar(char c)
 406 {
 407 #ifdef WIN32
 408     return c == '-' || c == '/';
 409 #else
 410     return c == '-';
 411 #endif
 412 }
 413
 414 /**
 415  * Return string argument or default value
 416  *
 417  * @param strArg Argument to get (e.g. "-foo")
 418  * @param default (e.g. "1")
 419  * @return command-line argument or default value
 420  */
 421 std::string GetArg(const std::string& strArg, const std::string& strDefault);
 422
 423 /**
 424  * Return 64-bit integer argument or default value
 425  *
 426  * @param strArg Argument to get (e.g. "-foo")
 427  * @param default (e.g. 1)
 428  * @return command-line argument (0 if invalid number) or default value
 429  */
 430 int64_t GetArg(const std::string& strArg, int64_t nDefault);
 431
 432 /**
 433  * Return 32-bit integer argument or default value
 434  *
 435  * @param strArg Argument to get (e.g. "-foo")
 436  * @param default (e.g. 1)
 437  * @return command-line argument (0 if invalid number) or default value
 438  */
 439 int32_t GetArgInt(const std::string& strArg, int32_t nDefault);
 440
 441 /**
 442  * Return 32-bit unsigned integer argument or default value
 443  *
 444  * @param strArg Argument to get (e.g. "-foo")
 445  * @param default (e.g. 1)
 446  * @return command-line argument (0 if invalid number) or default value
 447  */
 448 uint32_t GetArgUInt(const std::string& strArg, uint32_t nDefault);
 449
 450 /**
 451  * Return boolean argument or default value
 452  *
 453  * @param strArg Argument to get (e.g. "-foo")
 454  * @param default (true or false)
 455  * @return command-line argument or default value
 456  */
 457 bool GetBoolArg(const std::string& strArg, bool fDefault=false);
 458
 459 /**
 460  * Set an argument if it doesn't already have a value
 461  *
 462  * @param strArg Argument to set (e.g. "-foo")
 463  * @param strValue Value (e.g. "1")
 464  * @return true if argument gets set, false if it already had a value
 465  */
 466 bool SoftSetArg(const std::string& strArg, const std::string& strValue);
 467
 468 /**
 469  * Set a boolean argument if it doesn't already have a value
 470  *
 471  * @param strArg Argument to set (e.g. "-foo")
 472  * @param fValue Value (e.g. false)
 473  * @return true if argument gets set, false if it already had a value
 474  */
 475 bool SoftSetBoolArg(const std::string& strArg, bool fValue);
 476
 477 /**
 478  * Timing-attack-resistant comparison.
 479  * Takes time proportional to length
 480  * of first argument.
 481  */
 482 template <typename T>
 483 bool TimingResistantEqual(const T& a, const T& b)
 484 {
 485     if (b.size() == 0) return a.size() == 0;
 486     size_t accumulator = a.size() ^ b.size();
 487     for (size_t i = 0; i < a.size(); i++)
 488         accumulator |= a[i] ^ b[i%b.size()];
 489     return accumulator == 0;
 490 }
 491
 492 bool NewThread(void(*pfn)(void*), void* parg);
 493
 494 #ifdef WIN32
 495 inline void SetThreadPriority(int nPriority)
 496 {
 497     SetThreadPriority(GetCurrentThread(), nPriority);
 498 }
 499 #else
 500
 501 #define THREAD_PRIORITY_LOWEST          PRIO_MAX
 502 #define THREAD_PRIORITY_BELOW_NORMAL    2
 503 #define THREAD_PRIORITY_NORMAL          0
 504 #define THREAD_PRIORITY_ABOVE_NORMAL    0
 505
 506 inline void SetThreadPriority(int nPriority)
 507 {
 508     // It's unclear if it's even possible to change thread priorities on Linux,
 509     // but we really and truly need it for the generation threads.
 510 #ifdef PRIO_THREAD
 511     setpriority(PRIO_THREAD, 0, nPriority);
 512 #else
 513     setpriority(PRIO_PROCESS, 0, nPriority);
 514 #endif
 515 }
 516
 517 inline void ExitThread(size_t nExitCode)
 518 {
 519     pthread_exit((void*)nExitCode);
 520 }
 521 #endif
 522
 523 void RenameThread(const char* name);
 524
 525 inline uint32_t ByteReverse(uint32_t value)
 526 {
 527     value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
 528     return (value<<16) | (value>>16);
 529 }
 530
 531 #endif