#include "util.h"
#include "sync.h"
-#include "strlcpy.h"
#include "version.h"
#include "ui_interface.h"
#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/case_conv.hpp> // for to_lower()
+#include <boost/algorithm/string/predicate.hpp> // for startswith() and endswith()
// Work around clang compilation problem in Boost 1.46:
// /usr/include/boost/program_options/detail/config_file.hpp:163:17: error: call to function 'to_internal' that is neither visible in the template definition nor found by argument-dependent lookup
#include <boost/program_options/parsers.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
+
+#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/foreach.hpp>
#include <boost/thread.hpp>
#include <openssl/crypto.h>
#include <openssl/rand.h>
-#include <stdarg.h>
#ifdef WIN32
#ifdef _MSC_VER
# include <sys/prctl.h>
#endif
-#ifndef WIN32
+#if !defined(WIN32) && !defined(ANDROID)
#include <execinfo.h>
#endif
using namespace std;
+namespace bt = boost::posix_time;
map<string, string> mapArgs;
map<string, vector<string> > mapMultiArgs;
bool fTestNet = false;
bool fNoListen = false;
bool fLogTimestamps = false;
-CMedianFilter<int64> vTimeOffsets(200,0);
+CMedianFilter<int64_t> vTimeOffsets(200,0);
bool fReopenDebugLog = false;
+// Extended DecodeDumpTime implementation, see this page for details:
+// http://stackoverflow.com/questions/3786201/parsing-of-date-time-from-string-boost
+const std::locale formats[] = {
+ std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%dT%H:%M:%SZ")),
+ std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d %H:%M:%S")),
+ std::locale(std::locale::classic(),new bt::time_input_facet("%Y/%m/%d %H:%M:%S")),
+ std::locale(std::locale::classic(),new bt::time_input_facet("%d.%m.%Y %H:%M:%S")),
+ std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d"))
+};
+
+const size_t formats_n = sizeof(formats)/sizeof(formats[0]);
+
+std::time_t pt_to_time_t(const bt::ptime& pt)
+{
+ bt::ptime timet_start(boost::gregorian::date(1970,1,1));
+ bt::time_duration diff = pt - timet_start;
+ return diff.ticks()/bt::time_duration::rep_type::ticks_per_second;
+}
+
// Init OpenSSL library multithreading support
static CCriticalSection** ppmutexOpenSSL;
void locking_callback(int mode, int i, const char* file, int line)
void RandAddSeed()
{
// Seed with CPU performance counter
- int64 nCounter = GetPerformanceCounter();
+ 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 nLastPerfmon;
+ static int64_t nLastPerfmon;
if (GetTime() < nLastPerfmon + 10 * 60)
return;
nLastPerfmon = GetTime();
if (ret == ERROR_SUCCESS)
{
RAND_add(pdata, nSize, nSize/100.0);
- memset(pdata, 0, nSize);
+ OPENSSL_cleanse(pdata, nSize);
printf("RandAddSeed() %lu bytes\n", nSize);
}
#endif
}
-uint64 GetRand(uint64 nMax)
+uint64_t GetRand(uint64_t nMax)
{
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 nRange = (std::numeric_limits<uint64>::max() / nMax) * nMax;
- uint64 nRand = 0;
+ 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);
int GetRandInt(int nMax)
{
- return GetRand(nMax);
+ return static_cast<int>(GetRand(nMax));
}
uint256 GetRandHash()
int ret;
while (true)
{
+#ifndef _MSC_VER
va_list arg_ptr;
va_copy(arg_ptr, ap);
+#else
+ va_list arg_ptr = ap;
+#endif
#ifdef WIN32
ret = _vsnprintf(p, limit, format, arg_ptr);
#else
}
-string FormatMoney(int64 n, bool fPlus)
+string FormatMoney(int64_t n, bool fPlus)
{
// Note: not using straight sprintf here because we do NOT want
// localized number formatting.
- int64 n_abs = (n > 0 ? n : -n);
- int64 quotient = n_abs/COIN;
- int64 remainder = n_abs%COIN;
- string str = strprintf("%"PRI64d".%08"PRI64d, quotient, remainder);
+ int64_t n_abs = (n > 0 ? n : -n);
+ int64_t quotient = n_abs/COIN;
+ int64_t remainder = n_abs%COIN;
+ string str = strprintf("%" PRId64 ".%06" PRId64, quotient, remainder);
// Right-trim excess zeros before the decimal point:
int nTrim = 0;
}
-bool ParseMoney(const string& str, int64& nRet)
+bool ParseMoney(const string& str, int64_t& nRet)
{
return ParseMoney(str.c_str(), nRet);
}
-bool ParseMoney(const char* pszIn, int64& nRet)
+bool ParseMoney(const char* pszIn, int64_t& nRet)
{
string strWhole;
- int64 nUnits = 0;
+ int64_t nUnits = 0;
const char* p = pszIn;
while (isspace(*p))
p++;
if (*p == '.')
{
p++;
- int64 nMult = CENT*10;
+ int64_t nMult = CENT*10;
while (isdigit(*p) && (nMult > 0))
{
nUnits += nMult * (*p++ - '0');
return false;
if (nUnits < 0 || nUnits > COIN)
return false;
- int64 nWhole = atoi64(strWhole);
- int64 nValue = nWhole*COIN + nUnits;
+ int64_t nWhole = atoi64(strWhole);
+ int64_t nValue = nWhole*COIN + nUnits;
nRet = nValue;
return true;
mapMultiArgs.clear();
for (int i = 1; i < argc; i++)
{
- char psz[10000];
- strlcpy(psz, argv[i], sizeof(psz));
- char* pszValue = (char*)"";
- if (strchr(psz, '='))
+ std::string str(argv[i]);
+ std::string strValue;
+ size_t is_index = str.find('=');
+ if (is_index != std::string::npos)
{
- pszValue = strchr(psz, '=');
- *pszValue++ = '\0';
+ strValue = str.substr(is_index+1);
+ str = str.substr(0, is_index);
}
- #ifdef WIN32
- _strlwr(psz);
- if (psz[0] == '/')
- psz[0] = '-';
- #endif
- if (psz[0] != '-')
+#ifdef WIN32
+ boost::to_lower(str);
+ if (boost::algorithm::starts_with(str, "/"))
+ str = "-" + str.substr(1);
+#endif
+ if (str[0] != '-')
break;
- mapArgs[psz] = pszValue;
- mapMultiArgs[psz].push_back(pszValue);
+ mapArgs[str] = strValue;
+ mapMultiArgs[str].push_back(strValue);
}
// New 0.6 features:
return strDefault;
}
-int64 GetArg(const std::string& strArg, int64 nDefault)
+int64_t GetArg(const std::string& strArg, int64_t nDefault)
{
if (mapArgs.count(strArg))
return atoi64(mapArgs[strArg]);
bool SoftSetArg(const std::string& strArg, const std::string& strValue)
{
- if (mapArgs.count(strArg))
+ if (mapArgs.count(strArg) || mapMultiArgs.count(strArg))
return false;
mapArgs[strArg] = strValue;
+ mapMultiArgs[strArg].push_back(strValue);
+
return true;
}
}
+int64_t DecodeDumpTime(const std::string& s)
+{
+ bt::ptime pt;
+
+ for(size_t i=0; i<formats_n; ++i)
+ {
+ std::istringstream is(s);
+ is.imbue(formats[i]);
+ is >> pt;
+ if(pt != bt::ptime()) break;
+ }
+
+ return pt_to_time_t(pt);
+}
+
+std::string EncodeDumpTime(int64_t nTime) {
+ return DateTimeStrFormat("%Y-%m-%dT%H:%M:%SZ", nTime);
+}
+
+std::string EncodeDumpString(const std::string &str) {
+ std::stringstream ret;
+ BOOST_FOREACH(unsigned char c, str) {
+ if (c <= 32 || c >= 128 || c == '%') {
+ ret << '%' << HexStr(&c, &c + 1);
+ } else {
+ ret << c;
+ }
+ }
+ return ret.str();
+}
+
+std::string DecodeDumpString(const std::string &str) {
+ std::stringstream ret;
+ for (unsigned int pos = 0; pos < str.length(); pos++) {
+ unsigned char c = str[pos];
+ if (c == '%' && pos+2 < str.length()) {
+ c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
+ ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
+ pos += 2;
+ }
+ ret << c;
+ }
+ return ret.str();
+}
+
bool WildcardMatch(const char* psz, const char* mask)
{
while (true)
printf("\n\n******* exception encountered *******\n");
if (fileout)
{
-#ifndef WIN32
+#if !defined(WIN32) && !defined(ANDROID)
void* pszBuffer[32];
size_t size;
size = backtrace(pszBuffer, 32);
return path;
}
+string randomStrGen(int length) {
+ static string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+ string result;
+ result.resize(length);
+ for (int32_t i = 0; i < length; i++)
+ result[i] = charset[rand() % charset.length()];
+
+ return result;
+}
+
+void createConf()
+{
+ srand(time(NULL));
+
+ ofstream pConf;
+#if BOOST_FILESYSTEM_VERSION >= 3
+ pConf.open(GetConfigFile().generic_string().c_str());
+#else
+ pConf.open(GetConfigFile().string().c_str());
+#endif
+ pConf << "rpcuser=user\nrpcpassword="
+ + randomStrGen(15)
+ + "\nrpcport=8344"
+ + "\nport=7777"
+ + "\n#(0=off, 1=on) daemon - run in the background as a daemon and accept commands"
+ + "\ndaemon=0"
+ + "\n#(0=off, 1=on) server - accept command line and JSON-RPC commands"
+ + "\nserver=0"
+ + "\nrpcallowip=127.0.0.1"
+ + "\ntestnet=0";
+ pConf.close();
+}
+
boost::filesystem::path GetConfigFile()
{
boost::filesystem::path pathConfigFile(GetArg("-conf", "novacoin.conf"));
{
boost::filesystem::ifstream streamConfig(GetConfigFile());
if (!streamConfig.good())
- return; // No bitcoin.conf file is OK
+ {
+ createConf();
+ new(&streamConfig) boost::filesystem::ifstream(GetConfigFile());
+ if(!streamConfig.good())
+ return;
+ }
set<string> setOptions;
setOptions.insert("*");
{
// Restart the file with some of the end
char pch[200000];
- fseek(file, -sizeof(pch), SEEK_END);
+ fseek(file, -((long long)sizeof(pch)), SEEK_END);
int nBytes = fread(pch, 1, sizeof(pch), file);
fclose(file);
// - Median of other nodes clocks
// - The user (asking the user to fix the system clock if the first two disagree)
//
-static int64 nMockTime = 0; // For unit testing
+static int64_t nMockTime = 0; // For unit testing
-int64 GetTime()
+int64_t GetTime()
{
if (nMockTime) return nMockTime;
return time(NULL);
}
-void SetMockTime(int64 nMockTimeIn)
+void SetMockTime(int64_t nMockTimeIn)
{
nMockTime = nMockTimeIn;
}
-static int64 nTimeOffset = 0;
+static int64_t nTimeOffset = 0;
-int64 GetTimeOffset()
+int64_t GetTimeOffset()
{
return nTimeOffset;
}
-int64 GetAdjustedTime()
+int64_t GetAdjustedTime()
{
return GetTime() + GetTimeOffset();
}
-void AddTimeData(const CNetAddr& ip, int64 nTime)
+void AddTimeData(const CNetAddr& ip, int64_t nTime)
{
- int64 nOffsetSample = nTime - GetTime();
+ int64_t nOffsetSample = nTime - GetTime();
// Ignore duplicates
static set<CNetAddr> setKnown;
// Add data
vTimeOffsets.input(nOffsetSample);
- printf("Added time data, samples %d, offset %+"PRI64d" (%+"PRI64d" minutes)\n", vTimeOffsets.size(), nOffsetSample, nOffsetSample/60);
+ printf("Added time data, samples %d, offset %+" PRId64 " (%+" PRId64 " minutes)\n", vTimeOffsets.size(), nOffsetSample, nOffsetSample/60);
if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
{
- int64 nMedian = vTimeOffsets.median();
- std::vector<int64> vSorted = vTimeOffsets.sorted();
+ int64_t nMedian = vTimeOffsets.median();
+ std::vector<int64_t> vSorted = vTimeOffsets.sorted();
// Only let other nodes change our time by so much
if (abs64(nMedian) < 70 * 60)
{
{
// If nobody has a time different than ours but within 5 minutes of ours, give a warning
bool fMatch = false;
- BOOST_FOREACH(int64 nOffset, vSorted)
+ BOOST_FOREACH(int64_t nOffset, vSorted)
if (nOffset != 0 && abs64(nOffset) < 5 * 60)
fMatch = true;
}
}
if (fDebug) {
- BOOST_FOREACH(int64 n, vSorted)
- printf("%+"PRI64d" ", n);
+ BOOST_FOREACH(int64_t n, vSorted)
+ printf("%+" PRId64 " ", n);
printf("| ");
}
- printf("nTimeOffset = %+"PRI64d" (%+"PRI64d" minutes)\n", nTimeOffset, nTimeOffset/60);
+ printf("nTimeOffset = %+" PRId64 " (%+" PRId64 " minutes)\n", nTimeOffset, nTimeOffset/60);
}
}
}
return true;
}
+
+std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime)
+{
+ // std::locale takes ownership of the pointer
+ std::locale loc(std::locale::classic(), new boost::posix_time::time_facet(pszFormat));
+ std::stringstream ss;
+ ss.imbue(loc);
+ ss << boost::posix_time::from_time_t(nTime);
+ return ss.str();
+}
\ No newline at end of file