{

if (mode & CRYPTO_LOCK) {

ENTER_CRITICAL_SECTION(*ppmutexOpenSSL[i]);

} else {

LEAVE_CRITICAL_SECTION(*ppmutexOpenSSL[i]);

}

{

CInit()

{

// Init OpenSSL library multithreading support

ppmutexOpenSSL = (CCriticalSection**)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(CCriticalSection*));

for (int i = 0; i < CRYPTO_num_locks(); i++)

ppmutexOpenSSL[i] = new CCriticalSection();

CRYPTO_set_locking_callback(locking_callback);

#ifdef WIN32

// Seed random number generator with screen scrape and other hardware sources

RAND_screen();

#endif

// Seed random number generator with performance counter

RandAddSeed();

}

~CInit()

{

// Shutdown OpenSSL library multithreading support

CRYPTO_set_locking_callback(NULL);

for (int i = 0; i < CRYPTO_num_locks(); i++)

delete ppmutexOpenSSL[i];

OPENSSL_free(ppmutexOpenSSL);

}

{

// Seed with CPU performance counter

int64_t nCounter = GetPerformanceCounter();

RAND_add(&nCounter, sizeof(nCounter), 1.5);

memset(&nCounter, 0, sizeof(nCounter));

{

RandAddSeed();

// This can take up to 2 seconds, so only do it every 10 minutes

static int64_t nLastPerfmon;

if (GetTime() < nLastPerfmon + 10 * 60)

return;

nLastPerfmon = GetTime();

#ifdef WIN32

// Don't need this on Linux, OpenSSL automatically uses /dev/urandom

// Seed with the entire set of perfmon data

unsigned char pdata[250000];

memset(pdata, 0, sizeof(pdata));

unsigned long nSize = sizeof(pdata);

long ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, pdata, &nSize);

RegCloseKey(HKEY_PERFORMANCE_DATA);

if (ret == ERROR_SUCCESS)

{

RAND_add(pdata, nSize, nSize/100.0);

OPENSSL_cleanse(pdata, nSize);

LogPrint("rand", "RandAddSeed() %lu bytes\n", nSize);

}

#endif

{

if (nMax == 0)

return 0;

// The range of the random source must be a multiple of the modulus

// to give every possible output value an equal possibility

uint64_t nRange = (std::numeric_limits<uint64_t>::max() / nMax) * nMax;

uint64_t nRand = 0;

do

RAND_bytes((unsigned char*)&nRand, sizeof(nRand));

while (nRand >= nRange);

return (nRand % nMax);

{

uint256 hash;

RAND_bytes((unsigned char*)&hash, sizeof(hash));

return hash;

{

assert(fileout == NULL);

assert(mutexDebugLog == NULL);

boost::filesystem::path pathDebug = GetDataDir() / "debug.log";

fileout = fopen(pathDebug.string().c_str(), "a");

if (fileout) setbuf(fileout, NULL); // unbuffered

mutexDebugLog = new boost::mutex();

{

if (category != NULL)

{

if (!fDebug)

return 0;

// Give each thread quick access to -debug settings.

// This helps prevent issues debugging global destructors,

// where mapMultiArgs might be deleted before another

// global destructor calls LogPrint()

static boost::thread_specific_ptr<set<string> > ptrCategory;

if (ptrCategory.get() == NULL)

{

const vector<string>& categories = mapMultiArgs["-debug"];

ptrCategory.reset(new set<string>(categories.begin(), categories.end()));

// thread_specific_ptr automatically deletes the set when the thread ends.

}

const set<string>& setCategories = *ptrCategory.get();

// if not debugging everything and not debugging specific category, LogPrint does nothing.

if (setCategories.count(string("")) == 0 &&

setCategories.count(string(category)) == 0)

return 0;

}

int ret = 0; // Returns total number of characters written

if (fPrintToConsole)

{

// print to console

va_list arg_ptr;

va_start(arg_ptr, pszFormat);

ret += vprintf(pszFormat, arg_ptr);

va_end(arg_ptr);

}

else if (fPrintToDebugLog)

{

static bool fStartedNewLine = true;

boost::call_once(&DebugPrintInit, debugPrintInitFlag);

if (fileout == NULL)

return ret;

boost::mutex::scoped_lock scoped_lock(*mutexDebugLog);

// reopen the log file, if requested

if (fReopenDebugLog) {

fReopenDebugLog = false;

boost::filesystem::path pathDebug = GetDataDir() / "debug.log";

if (freopen(pathDebug.string().c_str(),"a",fileout) != NULL)

setbuf(fileout, NULL); // unbuffered

}

// Debug print useful for profiling

if (fLogTimestamps && fStartedNewLine)

ret += fprintf(fileout, "%s ", DateTimeStrFormat("%Y-%m-%d %H:%M:%S", GetTime()).c_str());

if (pszFormat[strlen(pszFormat) - 1] == '\n')

fStartedNewLine = true;

else

fStartedNewLine = false;

va_list arg_ptr;

va_start(arg_ptr, pszFormat);

ret += vfprintf(fileout, pszFormat, arg_ptr);

va_end(arg_ptr);

}

return ret;

{

char buffer[50000];

char* p = buffer;

int limit = sizeof(buffer);

int ret;

while (true)

{

va_list arg_ptr;

va_copy(arg_ptr, ap);

ret = vsnprintf(p, limit, format, arg_ptr);

va_end(arg_ptr);

if (ret >= 0 && ret < limit)

break;

if (p != buffer)

delete[] p;

limit *= 2;

p = new char[limit];

if (p == NULL)

throw std::bad_alloc();

}

string str(p, p+ret);

if (p != buffer)

delete[] p;

return str;

{

va_list arg_ptr;

va_start(arg_ptr, dummy);

string str = vstrprintf(format, arg_ptr);

va_end(arg_ptr);

return str;

{

va_list arg_ptr;

va_start(arg_ptr, dummy);

string str = vstrprintf(format.c_str(), arg_ptr);

va_end(arg_ptr);

return str;

{

va_list arg_ptr;

va_start(arg_ptr, format);

std::string str = vstrprintf(format, arg_ptr);

va_end(arg_ptr);

LogPrintf("ERROR: %s\n", str.c_str());

return false;

{

if (str.empty())

return;

string::size_type i1 = 0;

string::size_type i2;

while (true)

{

i2 = str.find(c, i1);

if (i2 == str.npos)

{

v.push_back(str.substr(i1));

return;

}

v.push_back(str.substr(i1, i2-i1));

i1 = i2+1;

}

{

// Note: not using straight sprintf here because we do NOT want

// localized number formatting.

int64_t n_abs = (n > 0 ? n : -n);

int64_t quotient = n_abs/COIN;

int64_t remainder = n_abs%COIN;

string str = strprintf("%"PRId64".%08"PRId64, quotient, remainder);

// Right-trim excess zeros before the decimal point:

int nTrim = 0;

for (int i = str.size()-1; (str[i] == '0' && isdigit(str[i-2])); --i)

++nTrim;

if (nTrim)

str.erase(str.size()-nTrim, nTrim);

if (n < 0)

str.insert((unsigned int)0, 1, '-');

else if (fPlus && n > 0)

str.insert((unsigned int)0, 1, '+');

return str;

{

string strWhole;

int64_t nUnits = 0;

const char* p = pszIn;

while (isspace(*p))

p++;

for (; *p; p++)

{

if (*p == '.')

{

p++;

int64_t nMult = CENT*10;

while (isdigit(*p) && (nMult > 0))

{

nUnits += nMult * (*p++ - '0');

nMult /= 10;

}

break;

}

if (isspace(*p))

break;

if (!isdigit(*p))

return false;

strWhole.insert(strWhole.end(), *p);

}

for (; *p; p++)

if (!isspace(*p))

return false;

if (strWhole.size() > 10) // guard against 63 bit overflow

return false;

if (nUnits < 0 || nUnits > COIN)

return false;

int64_t nWhole = atoi64(strWhole);

int64_t nValue = nWhole*COIN + nUnits;

nRet = nValue;

return true;

{

string strResult;

for (std::string::size_type i = 0; i < str.size(); i++)

{

if (safeChars.find(str[i]) != std::string::npos)

strResult.push_back(str[i]);

}

return strResult;

{

BOOST_FOREACH(char c, str)

{

if (HexDigit(c) < 0)

return false;

}

return (str.size() > 0) && (str.size()%2 == 0);

{

// convert hex dump to vector

vector<unsigned char> vch;

while (true)

{

while (isspace(*psz))

psz++;

signed char c = HexDigit(*psz++);

if (c == (signed char)-1)

break;

unsigned char n = (c << 4);

c = HexDigit(*psz++);

if (c == (signed char)-1)

break;

n |= c;

vch.push_back(n);

}

return vch;

{

// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set

if (name.find("-no") == 0)

{

std::string positive("-");

positive.append(name.begin()+3, name.end());

if (mapSettingsRet.count(positive) == 0)

{

bool value = !GetBoolArg(name, false);

mapSettingsRet[positive] = (value ? "1" : "0");

}

}

{

mapArgs.clear();

mapMultiArgs.clear();

for (int i = 1; i < argc; i++)

{

std::string str(argv[i]);

std::string strValue;

size_t is_index = str.find('=');

if (is_index != std::string::npos)

{

strValue = str.substr(is_index+1);

str = str.substr(0, is_index);

}

#ifdef WIN32

boost::to_lower(str);

if (boost::algorithm::starts_with(str, "/"))

str = "-" + str.substr(1);

#endif

if (str[0] != '-')

break;

mapArgs[str] = strValue;

mapMultiArgs[str].push_back(strValue);

}

// New 0.6 features:

BOOST_FOREACH(const PAIRTYPE(string,string)& entry, mapArgs)

{

string name = entry.first;

// interpret --foo as -foo (as long as both are not set)

if (name.find("--") == 0)

{

std::string singleDash(name.begin()+1, name.end());

if (mapArgs.count(singleDash) == 0)

mapArgs[singleDash] = entry.second;

name = singleDash;

}

// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set

InterpretNegativeSetting(name, mapArgs);

}

{

if (mapArgs.count(strArg))

return mapArgs[strArg];

return strDefault;

{

if (mapArgs.count(strArg))

return atoi64(mapArgs[strArg]);

return nDefault;

{

if (mapArgs.count(strArg))

{

if (mapArgs[strArg].empty())

return true;

return (atoi(mapArgs[strArg]) != 0);

}

return fDefault;

{

if (mapArgs.count(strArg))

return false;

mapArgs[strArg] = strValue;

return true;

{

if (fValue)

return SoftSetArg(strArg, std::string("1"));

else

return SoftSetArg(strArg, std::string("0"));

{

static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

string strRet="";

strRet.reserve((len+2)/3*4);

int mode=0, left=0;

const unsigned char *pchEnd = pch+len;

while (pch<pchEnd)

{

int enc = *(pch++);

switch (mode)

{

case 0: // we have no bits

strRet += pbase64[enc >> 2];

left = (enc & 3) << 4;

mode = 1;

break;

case 1: // we have two bits

strRet += pbase64[left | (enc >> 4)];

left = (enc & 15) << 2;

mode = 2;

break;

case 2: // we have four bits

strRet += pbase64[left | (enc >> 6)];

strRet += pbase64[enc & 63];

mode = 0;

break;

}

}

if (mode)

{

strRet += pbase64[left];

strRet += '=';

if (mode == 1)

strRet += '=';

}

return strRet;

{

static const int decode64_table[256] =

{

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,

-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,

29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,

49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1

};

if (pfInvalid)

*pfInvalid = false;

vector<unsigned char> vchRet;

vchRet.reserve(strlen(p)*3/4);

int mode = 0;

int left = 0;

while (1)

{

int dec = decode64_table[(unsigned char)*p];

if (dec == -1) break;

p++;

switch (mode)

{

case 0: // we have no bits and get 6

left = dec;

mode = 1;

break;

case 1: // we have 6 bits and keep 4

vchRet.push_back((left<<2) | (dec>>4));

left = dec & 15;

mode = 2;

break;

case 2: // we have 4 bits and get 6, we keep 2

vchRet.push_back((left<<4) | (dec>>2));

left = dec & 3;

mode = 3;

break;

case 3: // we have 2 bits and get 6

vchRet.push_back((left<<6) | dec);

mode = 0;

break;

}

}

if (pfInvalid)

switch (mode)

{

case 0: // 4n base64 characters processed: ok

break;

case 1: // 4n+1 base64 character processed: impossible

*pfInvalid = true;

break;

case 2: // 4n+2 base64 characters processed: require '=='

if (left || p[0] != '=' || p[1] != '=' || decode64_table[(unsigned char)p[2]] != -1)

*pfInvalid = true;

break;

case 3: // 4n+3 base64 characters processed: require '='

if (left || p[0] != '=' || decode64_table[(unsigned char)p[1]] != -1)

*pfInvalid = true;

break;

}

return vchRet;

{

vector<unsigned char> vchRet = DecodeBase64(str.c_str());

return string((const char*)&vchRet[0], vchRet.size());

{

static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";

string strRet="";

strRet.reserve((len+4)/5*8);

int mode=0, left=0;

const unsigned char *pchEnd = pch+len;

while (pch<pchEnd)

{

int enc = *(pch++);

switch (mode)

{

case 0: // we have no bits

strRet += pbase32[enc >> 3];

left = (enc & 7) << 2;

mode = 1;

break;

case 1: // we have three bits

strRet += pbase32[left | (enc >> 6)];

strRet += pbase32[(enc >> 1) & 31];

left = (enc & 1) << 4;

mode = 2;

break;

case 2: // we have one bit

strRet += pbase32[left | (enc >> 4)];

left = (enc & 15) << 1;

mode = 3;

break;

case 3: // we have four bits

strRet += pbase32[left | (enc >> 7)];

strRet += pbase32[(enc >> 2) & 31];

left = (enc & 3) << 3;

mode = 4;

break;

case 4: // we have two bits

strRet += pbase32[left | (enc >> 5)];

strRet += pbase32[enc & 31];

mode = 0;

}

}

static const int nPadding[5] = {0, 6, 4, 3, 1};

if (mode)

{

strRet += pbase32[left];

for (int n=0; n<nPadding[mode]; n++)

strRet += '=';

}

return strRet;

{

static const int decode32_table[256] =

{

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,

-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 0, 1, 2,

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,

23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1

};

if (pfInvalid)

*pfInvalid = false;

vector<unsigned char> vchRet;

vchRet.reserve((strlen(p))*5/8);

int mode = 0;

int left = 0;

while (1)

{

int dec = decode32_table[(unsigned char)*p];

if (dec == -1) break;

p++;

switch (mode)

{

case 0: // we have no bits and get 5

left = dec;

mode = 1;

break;

case 1: // we have 5 bits and keep 2

vchRet.push_back((left<<3) | (dec>>2));

left = dec & 3;

mode = 2;

break;

case 2: // we have 2 bits and keep 7

left = left << 5 | dec;

mode = 3;

break;

case 3: // we have 7 bits and keep 4

vchRet.push_back((left<<1) | (dec>>4));

left = dec & 15;

mode = 4;

break;

case 4: // we have 4 bits, and keep 1

vchRet.push_back((left<<4) | (dec>>1));

left = dec & 1;

mode = 5;

break;

case 5: // we have 1 bit, and keep 6

left = left << 5 | dec;

mode = 6;

break;

case 6: // we have 6 bits, and keep 3

vchRet.push_back((left<<2) | (dec>>3));

left = dec & 7;

mode = 7;

break;

case 7: // we have 3 bits, and keep 0

vchRet.push_back((left<<5) | dec);

mode = 0;

break;

}

}

if (pfInvalid)

switch (mode)

{

case 0: // 8n base32 characters processed: ok

break;

case 1: // 8n+1 base32 characters processed: impossible

case 3: // +3

case 6: // +6

*pfInvalid = true;

break;

case 2: // 8n+2 base32 characters processed: require '======'

if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || p[4] != '=' || p[5] != '=' || decode32_table[(unsigned char)p[6]] != -1)

*pfInvalid = true;

break;

case 4: // 8n+4 base32 characters processed: require '===='

if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || decode32_table[(unsigned char)p[4]] != -1)

*pfInvalid = true;

break;

case 5: // 8n+5 base32 characters processed: require '==='

if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || decode32_table[(unsigned char)p[3]] != -1)

*pfInvalid = true;

break;

case 7: // 8n+7 base32 characters processed: require '='

if (left || p[0] != '=' || decode32_table[(unsigned char)p[1]] != -1)

*pfInvalid = true;

break;

}

return vchRet;

{

vector<unsigned char> vchRet = DecodeBase32(str.c_str());

return string((const char*)&vchRet[0], vchRet.size());

{

while (true)

{

switch (*mask)

{

case '\0':

return (*psz == '\0');

case '*':

return WildcardMatch(psz, mask+1) || (*psz && WildcardMatch(psz+1, mask));

case '?':

if (*psz == '\0')

return false;

break;

default:

if (*psz != *mask)

return false;

break;

}

psz++;

mask++;

}

{

#ifdef WIN32

char pszModule[MAX_PATH] = "";

GetModuleFileNameA(NULL, pszModule, sizeof(pszModule));

#else

const char* pszModule = "bitcoin";

#endif

if (pex)

return strprintf(

"EXCEPTION: %s \n%s \n%s in %s \n", typeid(*pex).name(), pex->what(), pszModule, pszThread);

else

return strprintf(

"UNKNOWN EXCEPTION \n%s in %s \n", pszModule, pszThread);