#include "net.h"
#include "init.h"
#include "util.h"
-#include "ui_interface.h"
+#include "ipcollector.h"
+#include "interface.h"
#include "checkpoints.h"
#include <boost/format.hpp>
#include <boost/filesystem.hpp>
std::string strWalletFileName;
bool fConfChange;
unsigned int nNodeLifespan;
-unsigned int nMinerSleep;
bool fUseFastIndex;
-bool fUseFastStakeMiner;
bool fUseMemoryLog;
enum Checkpoints::CPMode CheckpointsMode;
// Ping and address broadcast intervals
extern int64_t nPingInterval;
-extern int64_t nBroadcastInterval;
+extern int64_t nReserveBalance;
//////////////////////////////////////////////////////////////////////////////
//
nTransactionsUpdated++;
// CTxDB().Close();
bitdb.Flush(false);
+ StopRPCServer();
StopNode();
bitdb.Flush(true);
boost::filesystem::remove(GetPidFile());
extern void noui_connect();
int main(int argc, char* argv[])
{
- bool fRet = false;
// Connect bitcoind signal handlers
noui_connect();
- fRet = AppInit(argc, argv);
+ bool fRet = AppInit(argc, argv);
if (fRet && fDaemon)
return 0;
" -connect=<ip> " + _("Connect only to the specified node(s)") + "\n" +
" -seednode=<ip> " + _("Connect to a node to retrieve peer addresses, and disconnect") + "\n" +
" -externalip=<ip> " + _("Specify your own public address") + "\n" +
- " -onlynet=<net> " + _("Only connect to nodes in network <net> (IPv4, IPv6 or Tor)") + "\n" +
+ " -onlynet=<net> " + _("Only connect to nodes in network <net> (IPv4, IPv6 or Onion)") + "\n" +
" -discover " + _("Discover own IP address (default: 1 when listening and no -externalip)") + "\n" +
" -irc " + _("Find peers using internet relay chat (default: 1)") + "\n" +
" -listen " + _("Accept connections from outside (default: 1 if no -proxy or -connect)") + "\n" +
" -bantime=<n> " + _("Number of seconds to keep misbehaving peers from reconnecting (default: 86400)") + "\n" +
" -maxreceivebuffer=<n> " + _("Maximum per-connection receive buffer, <n>*1000 bytes (default: 5000)") + "\n" +
" -maxsendbuffer=<n> " + _("Maximum per-connection send buffer, <n>*1000 bytes (default: 1000)") + "\n" +
-#ifdef USE_UPNP
-#if USE_UPNP
- " -upnp " + _("Use UPnP to map the listening port (default: 1 when listening)") + "\n" +
-#else
- " -upnp " + _("Use UPnP to map the listening port (default: 0)") + "\n" +
-#endif
-#endif
" -detachdb " + _("Detach block and address databases. Increases shutdown time (default: 0)") + "\n" +
#ifdef DB_LOG_IN_MEMORY
" -rpcconnect=<ip> " + _("Send commands to node running on <ip> (default: 127.0.0.1)") + "\n" +
" -blocknotify=<cmd> " + _("Execute command when the best block changes (%s in cmd is replaced by block hash)") + "\n" +
" -walletnotify=<cmd> " + _("Execute command when a wallet transaction changes (%s in cmd is replaced by TxID)") + "\n" +
+ " -peercollector=<cmd> " + _("Execute command to collect peer addresses") + "\n" +
" -confchange " + _("Require a confirmations for change (default: 0)") + "\n" +
" -upgradewallet " + _("Upgrade wallet to latest format") + "\n" +
" -keypool=<n> " + _("Set key pool size to <n> (default: 100)") + "\n" +
"\n" + _("Block creation options:") + "\n" +
" -blockminsize=<n> " + _("Set minimum block size in bytes (default: 0)") + "\n" +
" -blockmaxsize=<n> " + _("Set maximum block size in bytes (default: 250000)") + "\n" +
- " -blockprioritysize=<n> " + _("Set maximum size of high-priority/low-fee transactions in bytes (default: 27000)") + "\n" +
-
- "\n" + _("SSL options: (see the Bitcoin Wiki for SSL setup instructions)") + "\n" +
- " -rpcssl " + _("Use OpenSSL (https) for JSON-RPC connections") + "\n" +
- " -rpcsslcertificatechainfile=<file.cert> " + _("Server certificate file (default: server.cert)") + "\n" +
- " -rpcsslprivatekeyfile=<file.pem> " + _("Server private key (default: server.pem)") + "\n" +
- " -rpcsslciphers=<ciphers> " + _("Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)") + "\n";
+ " -blockprioritysize=<n> " + _("Set maximum size of high-priority/low-fee transactions in bytes (default: 27000)") + "\n";
return strUsage;
}
typedef BOOL (WINAPI *PSETPROCDEPPOL)(DWORD);
PSETPROCDEPPOL setProcDEPPol = (PSETPROCDEPPOL)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "SetProcessDEPPolicy");
if (setProcDEPPol != NULL) setProcDEPPol(PROCESS_DEP_ENABLE);
+
+ // Initialize Windows Sockets
+ WSADATA wsadata;
+ int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
+ if (ret != NO_ERROR)
+ {
+ return InitError(strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret));
+ }
#endif
#ifndef WIN32
umask(077);
// ********************************************************* Step 2: parameter interactions
- nNodeLifespan = (unsigned int)(GetArg("-addrlifespan", 7));
+ nNodeLifespan = GetArgUInt("-addrlifespan", 7);
fUseFastIndex = GetBoolArg("-fastindex", true);
fUseMemoryLog = GetBoolArg("-memorylog", true);
- nMinerSleep = (unsigned int)(GetArg("-minersleep", 500));
// Ping and address broadcast intervals
nPingInterval = max<int64_t>(10 * 60, GetArg("-keepalive", 30 * 60));
- nBroadcastInterval = max<int64_t>(6 * 60 * 60, GetArg("-addrsetlifetime", 24 * 60 * 60));
-
CheckpointsMode = Checkpoints::STRICT;
std::string strCpMode = GetArg("-cppolicy", "strict");
if (!GetBoolArg("-listen", true)) {
// do not map ports or try to retrieve public IP when not listening (pointless)
- SoftSetBoolArg("-upnp", false);
SoftSetBoolArg("-discover", false);
}
// ********************************************************* Step 3: parameter-to-internal-flags
// -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency
- nScriptCheckThreads = (int)(GetArg("-par", 0));
+ nScriptCheckThreads = GetArgInt("-par", 0);
if (nScriptCheckThreads == 0)
nScriptCheckThreads = boost::thread::hardware_concurrency();
if (nScriptCheckThreads <= 1)
if (mapArgs.count("-timeout"))
{
- int nNewTimeout = (int)(GetArg("-timeout", 5000));
+ int nNewTimeout = GetArgInt("-timeout", 5000);
if (nNewTimeout > 0 && nNewTimeout < 600000)
nConnectTimeout = nNewTimeout;
}
- // Continue to put "/P2SH/" in the coinbase to monitor
- // BIP16 support.
- // This can be removed eventually...
- const char* pszP2SH = "/P2SH/";
- COINBASE_FLAGS << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
-
+ // Put client version data into coinbase flags.
+ COINBASE_FLAGS << PROTOCOL_VERSION << DISPLAY_VERSION_MAJOR << DISPLAY_VERSION_MINOR << DISPLAY_VERSION_REVISION;
if (mapArgs.count("-paytxfee"))
{
int64_t nStart;
-#ifdef USE_SSE2
- scrypt_detect_sse2();
-#endif
// ********************************************************* Step 5: verify database integrity
uiInterface.InitMessage(_("Verifying database integrity..."));
return false;
}
- if (filesystem::exists(GetDataDir() / strWalletFileName))
+ if (boost::filesystem::exists(GetDataDir() / strWalletFileName))
{
CDBEnv::VerifyResult r = bitdb.Verify(strWalletFileName, CWalletDB::Recover);
if (r == CDBEnv::RECOVER_OK)
// ********************************************************* Step 6: network initialization
- int nSocksVersion = (int)(GetArg("-socks", 5));
+ int nSocksVersion = GetArgInt("-socks", 5);
if (nSocksVersion != 4 && nSocksVersion != 5)
return InitError(strprintf(_("Unknown -socks proxy version requested: %i"), nSocksVersion));
CService addrProxy;
bool fProxy = false;
if (mapArgs.count("-proxy")) {
- addrProxy = CService(mapArgs["-proxy"], 9050);
+ addrProxy = CService(mapArgs["-proxy"], nSocksDefault);
if (!addrProxy.IsValid())
return InitError(strprintf(_("Invalid -proxy address: '%s'"), mapArgs["-proxy"].c_str()));
if (!mapArgs.count("-tor"))
addrOnion = addrProxy;
else
- addrOnion = CService(mapArgs["-tor"], 9050);
+ addrOnion = CService(mapArgs["-tor"], nSocksDefault);
if (!addrOnion.IsValid())
return InitError(strprintf(_("Invalid -tor address: '%s'"), mapArgs["-tor"].c_str()));
SetProxy(NET_TOR, addrOnion, 5);
fNoListen = !GetBoolArg("-listen", true);
fDiscover = GetBoolArg("-discover", true);
fNameLookup = GetBoolArg("-dns", true);
-#ifdef USE_UPNP
- fUseUPnP = GetBoolArg("-upnp", USE_UPNP);
-#endif
} else {
// Don't listen, discover addresses or search for nodes if IPv4 and IPv6 networking is disabled.
fNoListen = true;
- fDiscover = fNameLookup = fUseUPnP = false;
+ fDiscover = fNameLookup = false;
SoftSetBoolArg("-irc", false);
SoftSetBoolArg("-dnsseed", false);
}
if (mapArgs.count("-reservebalance")) // ppcoin: reserve balance amount
{
- int64_t nReserveBalance = 0;
if (!ParseMoney(mapArgs["-reservebalance"], nReserveBalance))
{
InitError(_("Invalid amount for -reservebalance=<amount>"));
strLoadError = _("Error loading block database");
break;
}
- } catch(std::exception &e) {
- (void)e;
+ } catch(const std::exception&) {
strLoadError = _("Error opening block database");
break;
}
if (GetBoolArg("-upgradewallet", fFirstRun))
{
- int nMaxVersion = (int)(GetArg("-upgradewallet", 0));
+ int nMaxVersion = GetArgInt("-upgradewallet", 0);
if (nMaxVersion == 0) // the -upgradewallet without argument case
{
printf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
pwalletMain->SetDefaultKey(newDefaultKey);
if (!pwalletMain->SetAddressBookName(pwalletMain->vchDefaultKey.GetID(), ""))
strErrors << _("Cannot write default address") << "\n";
+
+ CMalleableKeyView keyView = pwalletMain->GenerateNewMalleableKey();
+ CMalleableKey mKey;
+ if (!pwalletMain->GetMalleableKey(keyView, mKey))
+ strErrors << _("Unable to generate new malleable key");
+ if (!pwalletMain->SetAddressBookName(CBitcoinAddress(keyView.GetMalleablePubKey()), ""))
+ strErrors << _("Cannot write default address") << "\n";
}
printf("%s", strErrors.str().c_str());
StartShutdown();
}
- filesystem::path pathBootstrap = GetDataDir() / "bootstrap.dat";
- if (filesystem::exists(pathBootstrap)) {
+ boost::filesystem::path pathBootstrap = GetDataDir() / "bootstrap.dat";
+ if (boost::filesystem::exists(pathBootstrap)) {
uiInterface.InitMessage(_("Importing bootstrap blockchain data file."));
FILE *file = fopen(pathBootstrap.string().c_str(), "rb");
if (file) {
- filesystem::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
+ boost::filesystem::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
LoadExternalBlockFile(file);
RenameOver(pathBootstrap, pathBootstrapOld);
}
InitError(_("Error: could not start node"));
if (fServer)
- NewThread(ThreadRPCServer, NULL);
+ StartRPCServer();
- // ********************************************************* Step 12: finished
+ // ********************************************************* Step 13: IP collection thread
+ strCollectorCommand = GetArg("-peercollector", "");
+ if (!fTestNet && strCollectorCommand != "")
+ NewThread(ThreadIPCollector, NULL);
+ // ********************************************************* Step 14: finished
uiInterface.InitMessage(_("Done loading"));
printf("Done loading\n");
#if !defined(QT_GUI)
// Loop until process is exit()ed from shutdown() function,
// called from ThreadRPCServer thread when a "stop" command is received.
- while (1)
+ for ( ; ; )
Sleep(5000);
#endif