/*

This file is part of cpp-ethereum.

cpp-ethereum is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

cpp-ethereum is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.

*/

/** @file Common.cpp

* @author Gav Wood <i@gavwood.com>

* @date 2014

*/

#include "CommonData.h"

#include <random>

#include "Exceptions.h"

#include <libdevcore/Log.h>

using namespace std;

using namespace dev;

std::string dev::escaped(std::string const& _s, bool _all)

{

static const map<char, char> prettyEscapes{{'\r', 'r'}, {'\n', 'n'}, {'\t', 't'}, {'\v', 'v'}};

std::string ret;

ret.reserve(_s.size() + 2);

ret.push_back('"');

for (auto i: _s)

if (i == '"' && !_all)

ret += "\\\"";

else if (i == '\\' && !_all)

ret += "\\\\";

else if (prettyEscapes.count(i))

{

ret += '\\';

ret += prettyEscapes.find(i)->second;

}

else if (i < ' ' || _all)

{

ret += "\\x";

ret.push_back("0123456789abcdef"[(uint8_t)i / 16]);

ret.push_back("0123456789abcdef"[(uint8_t)i % 16]);

}

else

ret.push_back(i);

ret.push_back('"');

return ret;

}

std::string dev::randomWord()

{

static std::mt19937_64 s_eng(0);

std::string ret(std::uniform_int_distribution<int>(1, 5)(s_eng), ' ');

char const n[] = "qwertyuiop";//asdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";

std::uniform_int_distribution<int> d(0, sizeof(n) - 2);

for (char& c: ret)

c = n[d(s_eng)];

return ret;

}

int dev::fromHex(char _i)

{

if (_i >= '0' && _i <= '9')

return _i - '0';

if (_i >= 'a' && _i <= 'f')

return _i - 'a' + 10;

if (_i >= 'A' && _i <= 'F')

return _i - 'A' + 10;

BOOST_THROW_EXCEPTION(BadHexCharacter() << errinfo_invalidSymbol(_i));

}

bytes dev::fromHex(std::string const& _s)

{

unsigned s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0;

std::vector<uint8_t> ret;

ret.reserve((_s.size() - s + 1) / 2);

if (_s.size() % 2)

try

{

ret.push_back(fromHex(_s[s++]));

}

catch (...){ ret.push_back(0); cwarn << boost::current_exception_diagnostic_information(); }

for (unsigned i = s; i < _s.size(); i += 2)

try

{

ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1])));

}

catch (...){ ret.push_back(0); cwarn << boost::current_exception_diagnostic_information(); }

return ret;

}

bytes dev::asNibbles(std::string const& _s)

{

std::vector<uint8_t> ret;

ret.reserve(_s.size() * 2);

for (auto i: _s)

{

ret.push_back(i / 16);

ret.push_back(i % 16);

}

return ret;

}

#if 0

/* Following code is copyright 2012-2014 Luke Dashjr

*

* This program is free software; you can redistribute it and/or modify it

* under the terms of the standard MIT license. See COPYING for more details.

*/

#include <cstdbool>

#include <cstddef>

#include <cstdint>

#include <cstring>

static const int8_t b58digits_map[] = {

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

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

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

-1, 0, 1, 2, 3, 4, 5, 6, 7, 8,-1,-1,-1,-1,-1,-1,

-1, 9,10,11,12,13,14,15, 16,-1,17,18,19,20,21,-1,

22,23,24,25,26,27,28,29, 30,31,32,-1,-1,-1,-1,-1,

-1,33,34,35,36,37,38,39, 40,41,42,43,-1,44,45,46,

47,48,49,50,51,52,53,54, 55,56,57,-1,-1,-1,-1,-1,

};

bool b58tobin(void *bin, size_t *binszp, const char *b58, size_t b58sz)

{

size_t binsz = *binszp;

const unsigned char *b58u = (void*)b58;

unsigned char *binu = bin;

size_t outisz = (binsz + 3) / 4;

uint32_t outi[outisz];

uint64_t t;

uint32_t c;

size_t i, j;

uint8_t bytesleft = binsz % 4;

uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;

unsigned zerocount = 0;

if (!b58sz)

b58sz = strlen(b58);

memset(outi, 0, outisz * sizeof(*outi));

// Leading zeros, just count

for (i = 0; i < b58sz && !b58digits_map[b58u[i]]; ++i)

++zerocount;

for ( ; i < b58sz; ++i)

{

if (b58u[i] & 0x80)

// High-bit set on invalid digit

return false;

if (b58digits_map[b58u[i]] == -1)

// Invalid base58 digit

return false;

c = (unsigned)b58digits_map[b58u[i]];

for (j = outisz; j--; )

{

t = ((uint64_t)outi[j]) * 58 + c;

c = (t & 0x3f00000000) >> 32;

outi[j] = t & 0xffffffff;

}

if (c)

// Output number too big (carry to the next int32)

return false;

if (outi[0] & zeromask)

// Output number too big (last int32 filled too far)

return false;

}

j = 0;

switch (bytesleft) {

case 3:

*(binu++) = (outi[0] & 0xff0000) >> 16;

case 2:

*(binu++) = (outi[0] & 0xff00) >> 8;

case 1:

*(binu++) = (outi[0] & 0xff);

++j;

default:

break;

}

for (; j < outisz; ++j)

{

*(binu++) = (outi[j] >> 0x18) & 0xff;

*(binu++) = (outi[j] >> 0x10) & 0xff;

*(binu++) = (outi[j] >> 8) & 0xff;

*(binu++) = (outi[j] >> 0) & 0xff;

}

// Count canonical base58 byte count

binu = bin;

for (i = 0; i < binsz; ++i)

{

if (binu[i])

break;

--*binszp;

}

*binszp += zerocount;

return true;

}

static

bool my_dblsha256(void *hash, const void *data, size_t datasz)

{

uint8_t buf[0x20];

return b58_sha256_impl(buf, data, datasz) && b58_sha256_impl(hash, buf, sizeof(buf));

}

int b58check(const void *bin, size_t binsz, const char *base58str, size_t b58sz)

{

unsigned char buf[32];

const uint8_t *binc = bin;

unsigned i;

if (binsz < 4)

return -4;

if (!my_dblsha256(buf, bin, binsz - 4))

return -2;

if (memcmp(&binc[binsz - 4], buf, 4))

return -1;

// Check number of zeros is correct AFTER verifying checksum (to avoid possibility of accessing base58str beyond the end)

for (i = 0; binc[i] == '\0' && base58str[i] == '1'; ++i)

{} // Just finding the end of zeros, nothing to do in loop

if (binc[i] == '\0' || base58str[i] == '1')

return -3;

return binc[0];

}

static const char b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

bool b58enc(char *b58, size_t *b58sz, const void *data, size_t binsz)

{

const uint8_t *bin = data;

int carry;

size_t i, j, high, zcount = 0;

size_t size;

while (zcount < binsz && !bin[zcount])

++zcount;

size = (binsz - zcount) * 138 / 100 + 1;

uint8_t buf[size];

memset(buf, 0, size);

for (i = zcount, high = size - 1; i < binsz; ++i, high = j)

{

for (carry = bin[i], j = size - 1; (j > high) || carry; --j)

{

carry += 256 * buf[j];

buf[j] = carry % 58;

carry /= 58;

}

}

for (j = 0; j < size && !buf[j]; ++j);

if (*b58sz <= zcount + size - j)

{

*b58sz = zcount + size - j + 1;

return false;

}

if (zcount)

memset(b58, '1', zcount);

for (i = zcount; j < size; ++i, ++j)

b58[i] = b58digits_ordered[buf[j]];

b58[i] = '\0';

*b58sz = i + 1;

return true;

}

#endif