|
|
|
// Copyright (c) 2016-2024 The Hush developers
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
|
|
// Distributed under the GPLv3 software license, see the accompanying
|
|
|
|
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
|
|
|
|
#include "util/strencodings.h"
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
|
|
|
|
#include "tinyformat.h"
|
|
|
|
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <cstring>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <iomanip>
|
|
|
|
#include <limits>
|
|
|
|
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
static const string CHARS_ALPHA_NUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
|
|
|
|
|
|
static const string SAFE_CHARS[] =
|
|
|
|
{
|
|
|
|
CHARS_ALPHA_NUM + " .,;_/:?@()", // SAFE_CHARS_DEFAULT
|
|
|
|
CHARS_ALPHA_NUM + " .,;_?@", // SAFE_CHARS_UA_COMMENT
|
|
|
|
CHARS_ALPHA_NUM + "!*'();:@&=+$,/?#[]-_.~%" // SAFE_CHARS_URI
|
|
|
|
};
|
|
|
|
|
|
|
|
string SanitizeString(const string& str, int rule)
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
{
|
|
|
|
string strResult;
|
|
|
|
for (std::string::size_type i = 0; i < str.size(); i++)
|
|
|
|
{
|
|
|
|
if (SAFE_CHARS[rule].find(str[i]) != std::string::npos)
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
strResult.push_back(str[i]);
|
|
|
|
}
|
|
|
|
return strResult;
|
|
|
|
}
|
|
|
|
|
|
|
|
string SanitizeFilename(const string& str)
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* safeChars chosen to restrict filename, keeping it simple to avoid cross-platform issues.
|
|
|
|
* http://stackoverflow.com/a/2306003
|
|
|
|
*/
|
|
|
|
static string safeChars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890");
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string HexInt(uint32_t val)
|
|
|
|
{
|
|
|
|
std::stringstream ss;
|
|
|
|
ss << std::setfill('0') << std::setw(sizeof(uint32_t) * 2) << std::hex << val;
|
|
|
|
return ss.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t ParseHexToUInt32(const std::string& str) {
|
|
|
|
std::istringstream converter(str);
|
|
|
|
uint32_t value;
|
|
|
|
converter >> std::hex >> value;
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
const signed char p_util_hexdigit[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,
|
|
|
|
0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
|
|
|
|
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };
|
|
|
|
|
|
|
|
signed char HexDigit(char c)
|
|
|
|
{
|
|
|
|
return p_util_hexdigit[(unsigned char)c];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsHex(const string& str)
|
|
|
|
{
|
|
|
|
for(std::string::const_iterator it(str.begin()); it != str.end(); ++it)
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
{
|
|
|
|
if (HexDigit(*it) < 0)
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return (str.size() > 0) && (str.size()%2 == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
vector<unsigned char> ParseHex(const char* psz)
|
|
|
|
{
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
vector<unsigned char> ParseHex(const string& str)
|
|
|
|
{
|
|
|
|
return ParseHex(str.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
string EncodeBase64(const unsigned char* pch, size_t len)
|
|
|
|
{
|
|
|
|
static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
|
|
|
|
std::string str;
|
|
|
|
str.reserve(((len + 2) / 3) * 4);
|
|
|
|
ConvertBits<8, 6, true>([&](int v) { str += pbase64[v]; }, pch, pch + len);
|
|
|
|
while (str.size() % 4) str += '=';
|
|
|
|
return str;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
string EncodeBase64(const string& str)
|
|
|
|
{
|
|
|
|
return EncodeBase64((const unsigned char*)str.c_str(), str.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
const char* e = p;
|
|
|
|
std::vector<uint8_t> val;
|
|
|
|
val.reserve(strlen(p));
|
|
|
|
while (*p != 0) {
|
|
|
|
int x = decode64_table[(unsigned char)*p];
|
|
|
|
if (x == -1) break;
|
|
|
|
val.push_back(x);
|
|
|
|
++p;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<unsigned char> ret;
|
|
|
|
ret.reserve((val.size() * 3) / 4);
|
|
|
|
bool valid = ConvertBits<6, 8, false>([&](unsigned char c) { ret.push_back(c); }, val.begin(), val.end());
|
|
|
|
|
|
|
|
const char* q = p;
|
|
|
|
while (valid && *p != 0) {
|
|
|
|
if (*p != '=') {
|
|
|
|
valid = false;
|
|
|
|
break;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
valid = valid && (p - e) % 4 == 0 && p - q < 4;
|
|
|
|
if (pfInvalid) *pfInvalid = !valid;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
|
|
|
|
return ret;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
string DecodeBase64(const string& str)
|
|
|
|
{
|
|
|
|
vector<unsigned char> vchRet = DecodeBase64(str.c_str());
|
|
|
|
return (vchRet.size() == 0) ? string() : string((const char*)&vchRet[0], vchRet.size());
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
string EncodeBase32(const unsigned char* pch, size_t len)
|
|
|
|
{
|
|
|
|
static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
|
|
|
|
|
|
|
|
std::string str;
|
|
|
|
str.reserve(((len + 4) / 5) * 8);
|
|
|
|
ConvertBits<8, 5, true>([&](int v) { str += pbase32[v]; }, pch, pch + len);
|
|
|
|
while (str.size() % 8) str += '=';
|
|
|
|
return str;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
string EncodeBase32(const string& str)
|
|
|
|
{
|
|
|
|
return EncodeBase32((const unsigned char*)str.c_str(), str.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
const char* e = p;
|
|
|
|
std::vector<uint8_t> val;
|
|
|
|
val.reserve(strlen(p));
|
|
|
|
while (*p != 0) {
|
|
|
|
int x = decode32_table[(unsigned char)*p];
|
|
|
|
if (x == -1) break;
|
|
|
|
val.push_back(x);
|
|
|
|
++p;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<unsigned char> ret;
|
|
|
|
ret.reserve((val.size() * 5) / 8);
|
|
|
|
bool valid = ConvertBits<5, 8, false>([&](unsigned char c) { ret.push_back(c); }, val.begin(), val.end());
|
|
|
|
|
|
|
|
const char* q = p;
|
|
|
|
while (valid && *p != 0) {
|
|
|
|
if (*p != '=') {
|
|
|
|
valid = false;
|
|
|
|
break;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
valid = valid && (p - e) % 8 == 0 && p - q < 8;
|
|
|
|
if (pfInvalid) *pfInvalid = !valid;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
|
|
|
|
return ret;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
string DecodeBase32(const string& str)
|
|
|
|
{
|
|
|
|
vector<unsigned char> vchRet = DecodeBase32(str.c_str());
|
|
|
|
return (vchRet.size() == 0) ? string() : string((const char*)&vchRet[0], vchRet.size());
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
}
|
|
|
|
|
|
|
|
static bool ParsePrechecks(const std::string& str)
|
|
|
|
{
|
|
|
|
if (str.empty()) // No empty string allowed
|
|
|
|
return false;
|
|
|
|
if (str.size() >= 1 && (isspace(str[0]) || isspace(str[str.size()-1]))) // No padding allowed
|
|
|
|
return false;
|
|
|
|
if (str.size() != strlen(str.c_str())) // No embedded NUL characters allowed
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
bool ParseInt32(const std::string& str, int32_t *out)
|
|
|
|
{
|
|
|
|
if (!ParsePrechecks(str))
|
|
|
|
return false;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
char *endp = NULL;
|
|
|
|
errno = 0; // strtol will not set errno if valid
|
|
|
|
long int n = strtol(str.c_str(), &endp, 10);
|
|
|
|
if(out) *out = (int32_t)n;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
// Note that strtol returns a *long int*, so even if strtol doesn't report a over/underflow
|
|
|
|
// we still have to check that the returned value is within the range of an *int32_t*. On 64-bit
|
|
|
|
// platforms the size of these types may be different.
|
|
|
|
return endp && *endp == 0 && !errno &&
|
|
|
|
n >= std::numeric_limits<int32_t>::min() &&
|
|
|
|
n <= std::numeric_limits<int32_t>::max();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ParseInt64(const std::string& str, int64_t *out)
|
|
|
|
{
|
|
|
|
if (!ParsePrechecks(str))
|
|
|
|
return false;
|
|
|
|
char *endp = NULL;
|
|
|
|
errno = 0; // strtoll will not set errno if valid
|
|
|
|
long long int n = strtoll(str.c_str(), &endp, 10);
|
|
|
|
if(out) *out = (int64_t)n;
|
|
|
|
// Note that strtoll returns a *long long int*, so even if strtol doesn't report a over/underflow
|
|
|
|
// we still have to check that the returned value is within the range of an *int64_t*.
|
|
|
|
return endp && *endp == 0 && !errno &&
|
|
|
|
n >= std::numeric_limits<int64_t>::min() &&
|
|
|
|
n <= std::numeric_limits<int64_t>::max();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ParseDouble(const std::string& str, double *out)
|
|
|
|
{
|
|
|
|
if (!ParsePrechecks(str))
|
|
|
|
return false;
|
|
|
|
if (str.size() >= 2 && str[0] == '0' && str[1] == 'x') // No hexadecimal floats allowed
|
|
|
|
return false;
|
|
|
|
std::istringstream text(str);
|
|
|
|
text.imbue(std::locale::classic());
|
|
|
|
double result;
|
|
|
|
text >> result;
|
|
|
|
if(out) *out = result;
|
|
|
|
return text.eof() && !text.fail();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string FormatParagraph(const std::string& in, size_t width, size_t indent)
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
{
|
|
|
|
std::stringstream out;
|
|
|
|
size_t col = 0;
|
|
|
|
size_t ptr = 0;
|
|
|
|
while(ptr < in.size())
|
|
|
|
{
|
|
|
|
// Find beginning of next word
|
|
|
|
ptr = in.find_first_not_of(' ', ptr);
|
|
|
|
if (ptr == std::string::npos)
|
|
|
|
break;
|
|
|
|
// Find end of next word
|
|
|
|
size_t endword = in.find_first_of(' ', ptr);
|
|
|
|
if (endword == std::string::npos)
|
|
|
|
endword = in.size();
|
|
|
|
// Add newline and indentation if this wraps over the allowed width
|
|
|
|
if (col > 0)
|
|
|
|
{
|
|
|
|
if ((col + endword - ptr) > width)
|
|
|
|
{
|
|
|
|
out << '\n';
|
|
|
|
for(size_t i=0; i<indent; ++i)
|
|
|
|
out << ' ';
|
|
|
|
col = 0;
|
|
|
|
} else
|
|
|
|
out << ' ';
|
|
|
|
}
|
|
|
|
// Append word
|
|
|
|
out << in.substr(ptr, endword - ptr);
|
|
|
|
col += endword - ptr + 1;
|
Split up util.cpp/h
Split up util.cpp/h into:
- string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach)
- money utilities (parsesmoney, formatmoney)
- time utilities (gettime*, sleep, format date):
- and the rest (logging, argument parsing, config file parsing)
The latter is basically the environment and OS handling,
and is stripped of all utility functions, so we may want to
rename it to something else than util.cpp/h for clarity (Matt suggested
osinterface).
Breaks dependency of sha256.cpp on all the things pulled in by util.
10 years ago
|
|
|
ptr = endword;
|
|
|
|
}
|
|
|
|
return out.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string i64tostr(int64_t n)
|
|
|
|
{
|
|
|
|
return strprintf("%d", n);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string itostr(int n)
|
|
|
|
{
|
|
|
|
return strprintf("%d", n);
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t atoi64(const char* psz)
|
|
|
|
{
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
return _atoi64(psz);
|
|
|
|
#else
|
|
|
|
return strtoll(psz, NULL, 10);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t atoi64(const std::string& str)
|
|
|
|
{
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
return _atoi64(str.c_str());
|
|
|
|
#else
|
|
|
|
return strtoll(str.c_str(), NULL, 10);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
int atoi(const std::string& str)
|
|
|
|
{
|
|
|
|
return atoi(str.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Upper bound for mantissa.
|
|
|
|
* 10^18-1 is the largest arbitrary decimal that will fit in a signed 64-bit integer.
|
|
|
|
* Larger integers cannot consist of arbitrary combinations of 0-9:
|
|
|
|
*
|
|
|
|
* 999999999999999999 1^18-1
|
|
|
|
* 9223372036854775807 (1<<63)-1 (max int64_t)
|
|
|
|
* 9999999999999999999 1^19-1 (would overflow)
|
|
|
|
*/
|
|
|
|
static const int64_t UPPER_BOUND = 1000000000000000000LL - 1LL;
|
|
|
|
|
|
|
|
/** Helper function for ParseFixedPoint */
|
|
|
|
static inline bool ProcessMantissaDigit(char ch, int64_t &mantissa, int &mantissa_tzeros)
|
|
|
|
{
|
|
|
|
if(ch == '0')
|
|
|
|
++mantissa_tzeros;
|
|
|
|
else {
|
|
|
|
for (int i=0; i<=mantissa_tzeros; ++i) {
|
|
|
|
if (mantissa > (UPPER_BOUND / 10LL))
|
|
|
|
return false; /* overflow */
|
|
|
|
mantissa *= 10;
|
|
|
|
}
|
|
|
|
mantissa += ch - '0';
|
|
|
|
mantissa_tzeros = 0;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amount_out)
|
|
|
|
{
|
|
|
|
int64_t mantissa = 0;
|
|
|
|
int64_t exponent = 0;
|
|
|
|
int mantissa_tzeros = 0;
|
|
|
|
bool mantissa_sign = false;
|
|
|
|
bool exponent_sign = false;
|
|
|
|
int i,n,ptr = 0; char *str = (char *)val.c_str();
|
|
|
|
int end = val.size();
|
|
|
|
int point_ofs = 0;
|
|
|
|
n = val.size();
|
|
|
|
if ( n == 11 && (val[0] < '9' || val[1] < '3') )
|
|
|
|
{
|
|
|
|
uint64_t val64 = 0;
|
|
|
|
for (i=0; i<n; i++)
|
|
|
|
{
|
|
|
|
if ( val[i] < '0' || val[i] > '9' )
|
|
|
|
break;
|
|
|
|
val64 = (val64 * 10) + (val[i] - '0');
|
|
|
|
}
|
|
|
|
if ( i == n ) // 90000000000
|
|
|
|
{
|
|
|
|
*amount_out = val64 * 100000000;
|
|
|
|
//fprintf(stderr,"special case: %s -> %.8f\n",val.c_str(),(double)*amount_out/100000000);
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ptr < end && val[ptr] == '-') {
|
|
|
|
mantissa_sign = true;
|
|
|
|
++ptr;
|
|
|
|
}
|
|
|
|
if (ptr < end)
|
|
|
|
{
|
|
|
|
if (val[ptr] == '0') {
|
|
|
|
/* pass single 0 */
|
|
|
|
++ptr;
|
|
|
|
} else if (val[ptr] >= '1' && val[ptr] <= '9') {
|
|
|
|
while (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
|
|
|
|
if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
|
|
|
|
return false; /* overflow */
|
|
|
|
++ptr;
|
|
|
|
}
|
|
|
|
} else return false; /* missing expected digit */
|
|
|
|
} else return false; /* empty string or loose '-' */
|
|
|
|
if (ptr < end && val[ptr] == '.')
|
|
|
|
{
|
|
|
|
++ptr;
|
|
|
|
if (ptr < end && val[ptr] >= '0' && val[ptr] <= '9')
|
|
|
|
{
|
|
|
|
while (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
|
|
|
|
if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
|
|
|
|
return false; /* overflow */
|
|
|
|
++ptr;
|
|
|
|
++point_ofs;
|
|
|
|
}
|
|
|
|
} else return false; /* missing expected digit */
|
|
|
|
}
|
|
|
|
if (ptr < end && (val[ptr] == 'e' || val[ptr] == 'E'))
|
|
|
|
{
|
|
|
|
++ptr;
|
|
|
|
if (ptr < end && val[ptr] == '+')
|
|
|
|
++ptr;
|
|
|
|
else if (ptr < end && val[ptr] == '-') {
|
|
|
|
exponent_sign = true;
|
|
|
|
++ptr;
|
|
|
|
}
|
|
|
|
if (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
|
|
|
|
while (ptr < end && val[ptr] >= '0' && val[ptr] <= '9') {
|
|
|
|
if (exponent > (UPPER_BOUND / 10LL))
|
|
|
|
return false; /* overflow */
|
|
|
|
exponent = exponent * 10 + val[ptr] - '0';
|
|
|
|
++ptr;
|
|
|
|
}
|
|
|
|
} else return false; /* missing expected digit */
|
|
|
|
}
|
|
|
|
if (ptr != end)
|
|
|
|
return false; /* trailing garbage */
|
|
|
|
|
|
|
|
/* finalize exponent */
|
|
|
|
if (exponent_sign)
|
|
|
|
exponent = -exponent;
|
|
|
|
exponent = exponent - point_ofs + mantissa_tzeros;
|
|
|
|
|
|
|
|
/* finalize mantissa */
|
|
|
|
if (mantissa_sign)
|
|
|
|
mantissa = -mantissa;
|
|
|
|
|
|
|
|
/* convert to one 64-bit fixed-point value */
|
|
|
|
exponent += decimals;
|
|
|
|
if (exponent < 0)
|
|
|
|
return false; /* cannot represent values smaller than 10^-decimals */
|
|
|
|
if (exponent >= 18)
|
|
|
|
return false; /* cannot represent values larger than or equal to 10^(18-decimals) */
|
|
|
|
|
|
|
|
for (int i=0; i < exponent; ++i) {
|
|
|
|
if (mantissa > (UPPER_BOUND / 10LL) || mantissa < -(UPPER_BOUND / 10LL))
|
|
|
|
return false; /* overflow */
|
|
|
|
mantissa *= 10;
|
|
|
|
}
|
|
|
|
if (mantissa > UPPER_BOUND || mantissa < -UPPER_BOUND)
|
|
|
|
return false; /* overflow */
|
|
|
|
|
|
|
|
if (amount_out)
|
|
|
|
*amount_out = mantissa;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|