src/main.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2011 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   5 #include "headers.h"
   6 #include "checkpoints.h"
   7 #include "db.h"
   8 #include "net.h"
   9 #include "init.h"
  10 #include <boost/algorithm/string/replace.hpp>
  11 #include <boost/filesystem.hpp>
  12 #include <boost/filesystem/fstream.hpp>
  13
  14 using namespace std;
  15 using namespace boost;
  16
  17 //
  18 // Global state
  19 //
  20
  21 // Name of client reported in the 'version' message. Report the same name
  22 // for both bitcoind and bitcoin-qt, to make it harder for attackers to
  23 // target servers or GUI users specifically.
  24 const std::string CLIENT_NAME("bitcoin-qt");
  25
  26 CCriticalSection cs_setpwalletRegistered;
  27 set<CWallet*> setpwalletRegistered;
  28
  29 CCriticalSection cs_main;
  30
  31 static map<uint256, CTransaction> mapTransactions;
  32 CCriticalSection cs_mapTransactions;
  33 unsigned int nTransactionsUpdated = 0;
  34 map<COutPoint, CInPoint> mapNextTx;
  35
  36 map<uint256, CBlockIndex*> mapBlockIndex;
  37 uint256 hashGenesisBlock("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
  38 static CBigNum bnProofOfWorkLimit(~uint256(0) >> 32);
  39 CBlockIndex* pindexGenesisBlock = NULL;
  40 int nBestHeight = -1;
  41 CBigNum bnBestChainWork = 0;
  42 CBigNum bnBestInvalidWork = 0;
  43 uint256 hashBestChain = 0;
  44 CBlockIndex* pindexBest = NULL;
  45 int64 nTimeBestReceived = 0;
  46
  47 CMedianFilter<int> cPeerBlockCounts(5, 0); // Amount of blocks that other nodes claim to have
  48
  49 map<uint256, CBlock*> mapOrphanBlocks;
  50 multimap<uint256, CBlock*> mapOrphanBlocksByPrev;
  51
  52 map<uint256, CDataStream*> mapOrphanTransactions;
  53 multimap<uint256, CDataStream*> mapOrphanTransactionsByPrev;
  54
  55
  56 double dHashesPerSec;
  57 int64 nHPSTimerStart;
  58
  59 // Settings
  60 int fGenerateBitcoins = false;
  61 int64 nTransactionFee = 0;
  62 int fLimitProcessors = false;
  63 int nLimitProcessors = 1;
  64 int fMinimizeToTray = true;
  65 int fMinimizeOnClose = true;
  66 #if USE_UPNP
  67 int fUseUPnP = true;
  68 #else
  69 int fUseUPnP = false;
  70 #endif
  71
  72
  73 //////////////////////////////////////////////////////////////////////////////
  74 //
  75 // dispatching functions
  76 //
  77
  78 // These functions dispatch to one or all registered wallets
  79
  80
  81 void RegisterWallet(CWallet* pwalletIn)
  82 {
  83     CRITICAL_BLOCK(cs_setpwalletRegistered)
  84     {
  85         setpwalletRegistered.insert(pwalletIn);
  86     }
  87 }
  88
  89 void UnregisterWallet(CWallet* pwalletIn)
  90 {
  91     CRITICAL_BLOCK(cs_setpwalletRegistered)
  92     {
  93         setpwalletRegistered.erase(pwalletIn);
  94     }
  95 }
  96
  97 // check whether the passed transaction is from us
  98 bool static IsFromMe(CTransaction& tx)
  99 {
 100     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 101         if (pwallet->IsFromMe(tx))
 102             return true;
 103     return false;
 104 }
 105
 106 // get the wallet transaction with the given hash (if it exists)
 107 bool static GetTransaction(const uint256& hashTx, CWalletTx& wtx)
 108 {
 109     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 110         if (pwallet->GetTransaction(hashTx,wtx))
 111             return true;
 112     return false;
 113 }
 114
 115 // erases transaction with the given hash from all wallets
 116 void static EraseFromWallets(uint256 hash)
 117 {
 118     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 119         pwallet->EraseFromWallet(hash);
 120 }
 121
 122 // make sure all wallets know about the given transaction, in the given block
 123 void static SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false)
 124 {
 125     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 126         pwallet->AddToWalletIfInvolvingMe(tx, pblock, fUpdate);
 127 }
 128
 129 // notify wallets about a new best chain
 130 void static SetBestChain(const CBlockLocator& loc)
 131 {
 132     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 133         pwallet->SetBestChain(loc);
 134 }
 135
 136 // notify wallets about an updated transaction
 137 void static UpdatedTransaction(const uint256& hashTx)
 138 {
 139     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 140         pwallet->UpdatedTransaction(hashTx);
 141 }
 142
 143 // dump all wallets
 144 void static PrintWallets(const CBlock& block)
 145 {
 146     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 147         pwallet->PrintWallet(block);
 148 }
 149
 150 // notify wallets about an incoming inventory (for request counts)
 151 void static Inventory(const uint256& hash)
 152 {
 153     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 154         pwallet->Inventory(hash);
 155 }
 156
 157 // ask wallets to resend their transactions
 158 void static ResendWalletTransactions()
 159 {
 160     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
 161         pwallet->ResendWalletTransactions();
 162 }
 163
 164
 165
 166
 167
 168
 169
 170 //////////////////////////////////////////////////////////////////////////////
 171 //
 172 // mapOrphanTransactions
 173 //
 174
 175 void static AddOrphanTx(const CDataStream& vMsg)
 176 {
 177     CTransaction tx;
 178     CDataStream(vMsg) >> tx;
 179     uint256 hash = tx.GetHash();
 180     if (mapOrphanTransactions.count(hash))
 181         return;
 182     CDataStream* pvMsg = mapOrphanTransactions[hash] = new CDataStream(vMsg);
 183     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 184         mapOrphanTransactionsByPrev.insert(make_pair(txin.prevout.hash, pvMsg));
 185 }
 186
 187 void static EraseOrphanTx(uint256 hash)
 188 {
 189     if (!mapOrphanTransactions.count(hash))
 190         return;
 191     const CDataStream* pvMsg = mapOrphanTransactions[hash];
 192     CTransaction tx;
 193     CDataStream(*pvMsg) >> tx;
 194     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 195     {
 196         for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(txin.prevout.hash);
 197              mi != mapOrphanTransactionsByPrev.upper_bound(txin.prevout.hash);)
 198         {
 199             if ((*mi).second == pvMsg)
 200                 mapOrphanTransactionsByPrev.erase(mi++);
 201             else
 202                 mi++;
 203         }
 204     }
 205     delete pvMsg;
 206     mapOrphanTransactions.erase(hash);
 207 }
 208
 209
 210
 211
 212
 213
 214
 215
 216 //////////////////////////////////////////////////////////////////////////////
 217 //
 218 // CTransaction and CTxIndex
 219 //
 220
 221 bool CTransaction::ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet)
 222 {
 223     SetNull();
 224     if (!txdb.ReadTxIndex(prevout.hash, txindexRet))
 225         return false;
 226     if (!ReadFromDisk(txindexRet.pos))
 227         return false;
 228     if (prevout.n >= vout.size())
 229     {
 230         SetNull();
 231         return false;
 232     }
 233     return true;
 234 }
 235
 236 bool CTransaction::ReadFromDisk(CTxDB& txdb, COutPoint prevout)
 237 {
 238     CTxIndex txindex;
 239     return ReadFromDisk(txdb, prevout, txindex);
 240 }
 241
 242 bool CTransaction::ReadFromDisk(COutPoint prevout)
 243 {
 244     CTxDB txdb("r");
 245     CTxIndex txindex;
 246     return ReadFromDisk(txdb, prevout, txindex);
 247 }
 248
 249 bool CTransaction::IsStandard() const
 250 {
 251     BOOST_FOREACH(const CTxIn& txin, vin)
 252     {
 253         // Biggest 'standard' txin is a 3-signature 3-of-3 CHECKMULTISIG
 254         // pay-to-script-hash, which is 3 ~80-byte signatures, 3
 255         // ~65-byte public keys, plus a few script ops.
 256         if (txin.scriptSig.size() > 500)
 257             return false;
 258         if (!txin.scriptSig.IsPushOnly())
 259             return false;
 260     }
 261     BOOST_FOREACH(const CTxOut& txout, vout)
 262         if (!::IsStandard(txout.scriptPubKey))
 263             return false;
 264     return true;
 265 }
 266
 267 //
 268 // Check transaction inputs, and make sure any
 269 // pay-to-script-hash transactions are evaluating IsStandard scripts
 270 //
 271 // Why bother? To avoid denial-of-service attacks; an attacker
 272 // can submit a standard HASH... OP_EQUAL transaction,
 273 // which will get accepted into blocks. The redemption
 274 // script can be anything; an attacker could use a very
 275 // expensive-to-check-upon-redemption script like:
 276 //   DUP CHECKSIG DROP ... repeated 100 times... OP_1
 277 //
 278 bool CTransaction::AreInputsStandard(const std::map<uint256, std::pair<CTxIndex, CTransaction> >& mapInputs) const
 279 {
 280     if (fTestNet)
 281         return true; // Allow non-standard on testnet
 282
 283     for (int i = 0; i < vin.size(); i++)
 284     {
 285         COutPoint prevout = vin[i].prevout;
 286
 287         std::map<uint256, std::pair<CTxIndex, CTransaction> >::const_iterator mi = mapInputs.find(prevout.hash);
 288         if (mi == mapInputs.end())
 289             return false;
 290
 291         const CTransaction& txPrev = (mi->second).second;
 292         assert(prevout.n < txPrev.vout.size());
 293
 294         vector<vector<unsigned char> > vSolutions;
 295         txnouttype whichType;
 296         // get the scriptPubKey corresponding to this input:
 297         const CScript& prevScript = txPrev.vout[prevout.n].scriptPubKey;
 298         if (!Solver(prevScript, whichType, vSolutions))
 299             return false;
 300         if (whichType == TX_SCRIPTHASH)
 301         {
 302             vector<vector<unsigned char> > stack;
 303
 304             if (!EvalScript(stack, vin[i].scriptSig, *this, i, 0))
 305                 return false;
 306             if (stack.empty())
 307                 return false;
 308             CScript subscript(stack.back().begin(), stack.back().end());
 309             if (!::IsStandard(subscript))
 310                 return false;
 311         }
 312     }
 313
 314     return true;
 315 }
 316
 317 int
 318 CTransaction::GetLegacySigOpCount() const
 319 {
 320     int nSigOps = 0;
 321     BOOST_FOREACH(const CTxIn& txin, vin)
 322     {
 323         nSigOps += txin.scriptSig.GetSigOpCount(false);
 324     }
 325     BOOST_FOREACH(const CTxOut& txout, vout)
 326     {
 327         nSigOps += txout.scriptPubKey.GetSigOpCount(false);
 328     }
 329     return nSigOps;
 330 }
 331
 332
 333 int CMerkleTx::SetMerkleBranch(const CBlock* pblock)
 334 {
 335     if (fClient)
 336     {
 337         if (hashBlock == 0)
 338             return 0;
 339     }
 340     else
 341     {
 342         CBlock blockTmp;
 343         if (pblock == NULL)
 344         {
 345             // Load the block this tx is in
 346             CTxIndex txindex;
 347             if (!CTxDB("r").ReadTxIndex(GetHash(), txindex))
 348                 return 0;
 349             if (!blockTmp.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos))
 350                 return 0;
 351             pblock = &blockTmp;
 352         }
 353
 354         // Update the tx's hashBlock
 355         hashBlock = pblock->GetHash();
 356
 357         // Locate the transaction
 358         for (nIndex = 0; nIndex < pblock->vtx.size(); nIndex++)
 359             if (pblock->vtx[nIndex] == *(CTransaction*)this)
 360                 break;
 361         if (nIndex == pblock->vtx.size())
 362         {
 363             vMerkleBranch.clear();
 364             nIndex = -1;
 365             printf("ERROR: SetMerkleBranch() : couldn't find tx in block\n");
 366             return 0;
 367         }
 368
 369         // Fill in merkle branch
 370         vMerkleBranch = pblock->GetMerkleBranch(nIndex);
 371     }
 372
 373     // Is the tx in a block that's in the main chain
 374     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
 375     if (mi == mapBlockIndex.end())
 376         return 0;
 377     CBlockIndex* pindex = (*mi).second;
 378     if (!pindex || !pindex->IsInMainChain())
 379         return 0;
 380
 381     return pindexBest->nHeight - pindex->nHeight + 1;
 382 }
 383
 384
 385
 386
 387
 388
 389
 390 bool CTransaction::CheckTransaction() const
 391 {
 392     // Basic checks that don't depend on any context
 393     if (vin.empty())
 394         return DoS(10, error("CTransaction::CheckTransaction() : vin empty"));
 395     if (vout.empty())
 396         return DoS(10, error("CTransaction::CheckTransaction() : vout empty"));
 397     // Size limits
 398     if (::GetSerializeSize(*this, SER_NETWORK) > MAX_BLOCK_SIZE)
 399         return DoS(100, error("CTransaction::CheckTransaction() : size limits failed"));
 400
 401     // Check for negative or overflow output values
 402     int64 nValueOut = 0;
 403     BOOST_FOREACH(const CTxOut& txout, vout)
 404     {
 405         if (txout.nValue < 0)
 406             return DoS(100, error("CTransaction::CheckTransaction() : txout.nValue negative"));
 407         if (txout.nValue > MAX_MONEY)
 408             return DoS(100, error("CTransaction::CheckTransaction() : txout.nValue too high"));
 409         nValueOut += txout.nValue;
 410         if (!MoneyRange(nValueOut))
 411             return DoS(100, error("CTransaction::CheckTransaction() : txout total out of range"));
 412     }
 413
 414     // Check for duplicate inputs
 415     set<COutPoint> vInOutPoints;
 416     BOOST_FOREACH(const CTxIn& txin, vin)
 417     {
 418         if (vInOutPoints.count(txin.prevout))
 419             return false;
 420         vInOutPoints.insert(txin.prevout);
 421     }
 422
 423     if (IsCoinBase())
 424     {
 425         if (vin[0].scriptSig.size() < 2 || vin[0].scriptSig.size() > 100)
 426             return DoS(100, error("CTransaction::CheckTransaction() : coinbase script size"));
 427     }
 428     else
 429     {
 430         BOOST_FOREACH(const CTxIn& txin, vin)
 431             if (txin.prevout.IsNull())
 432                 return DoS(10, error("CTransaction::CheckTransaction() : prevout is null"));
 433     }
 434
 435     return true;
 436 }
 437
 438 bool CTransaction::AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs, bool* pfMissingInputs)
 439 {
 440     if (pfMissingInputs)
 441         *pfMissingInputs = false;
 442
 443     if (!CheckTransaction())
 444         return error("AcceptToMemoryPool() : CheckTransaction failed");
 445
 446     // Coinbase is only valid in a block, not as a loose transaction
 447     if (IsCoinBase())
 448         return DoS(100, error("AcceptToMemoryPool() : coinbase as individual tx"));
 449
 450     // To help v0.1.5 clients who would see it as a negative number
 451     if ((int64)nLockTime > std::numeric_limits<int>::max())
 452         return error("AcceptToMemoryPool() : not accepting nLockTime beyond 2038 yet");
 453
 454     // Rather not work on nonstandard transactions (unless -testnet)
 455     if (!fTestNet && !IsStandard())
 456         return error("AcceptToMemoryPool() : nonstandard transaction type");
 457
 458     // Do we already have it?
 459     uint256 hash = GetHash();
 460     CRITICAL_BLOCK(cs_mapTransactions)
 461         if (mapTransactions.count(hash))
 462             return false;
 463     if (fCheckInputs)
 464         if (txdb.ContainsTx(hash))
 465             return false;
 466
 467     // Check for conflicts with in-memory transactions
 468     CTransaction* ptxOld = NULL;
 469     for (int i = 0; i < vin.size(); i++)
 470     {
 471         COutPoint outpoint = vin[i].prevout;
 472         if (mapNextTx.count(outpoint))
 473         {
 474             // Disable replacement feature for now
 475             return false;
 476
 477             // Allow replacing with a newer version of the same transaction
 478             if (i != 0)
 479                 return false;
 480             ptxOld = mapNextTx[outpoint].ptx;
 481             if (ptxOld->IsFinal())
 482                 return false;
 483             if (!IsNewerThan(*ptxOld))
 484                 return false;
 485             for (int i = 0; i < vin.size(); i++)
 486             {
 487                 COutPoint outpoint = vin[i].prevout;
 488                 if (!mapNextTx.count(outpoint) || mapNextTx[outpoint].ptx != ptxOld)
 489                     return false;
 490             }
 491             break;
 492         }
 493     }
 494
 495     if (fCheckInputs)
 496     {
 497         map<uint256, pair<CTxIndex, CTransaction> > mapInputs;
 498         map<uint256, CTxIndex> mapUnused;
 499         if (!FetchInputs(txdb, mapUnused, false, false, mapInputs))
 500         {
 501             if (pfMissingInputs)
 502                 *pfMissingInputs = true;
 503             return error("AcceptToMemoryPool() : FetchInputs failed %s", hash.ToString().substr(0,10).c_str());
 504         }
 505
 506         // Check for non-standard pay-to-script-hash in inputs
 507         if (!AreInputsStandard(mapInputs))
 508             return error("AcceptToMemoryPool() : nonstandard transaction input");
 509
 510         // Check against previous transactions
 511         int64 nFees = 0;
 512         int nSigOps = 0;
 513         if (!ConnectInputs(mapInputs, mapUnused, CDiskTxPos(1,1,1), pindexBest, nFees, false, false, nSigOps))
 514         {
 515             if (pfMissingInputs)
 516                 *pfMissingInputs = true;
 517             return error("AcceptToMemoryPool() : ConnectInputs failed %s", hash.ToString().substr(0,10).c_str());
 518         }
 519
 520         // Checking ECDSA signatures is a CPU bottleneck, so to avoid denial-of-service
 521         // attacks disallow transactions with more than one SigOp per 65 bytes.
 522         // 65 bytes because that is the minimum size of an ECDSA signature
 523         unsigned int nSize = ::GetSerializeSize(*this, SER_NETWORK);
 524         if (nSigOps > nSize / 65 || nSize < 100)
 525             return error("AcceptToMemoryPool() : transaction with out-of-bounds SigOpCount");
 526
 527         // Don't accept it if it can't get into a block
 528         if (nFees < GetMinFee(1000, true, GMF_RELAY))
 529             return error("AcceptToMemoryPool() : not enough fees");
 530
 531         // Continuously rate-limit free transactions
 532         // This mitigates 'penny-flooding' -- sending thousands of free transactions just to
 533         // be annoying or make other's transactions take longer to confirm.
 534         if (nFees < MIN_RELAY_TX_FEE)
 535         {
 536             static CCriticalSection cs;
 537             static double dFreeCount;
 538             static int64 nLastTime;
 539             int64 nNow = GetTime();
 540
 541             CRITICAL_BLOCK(cs)
 542             {
 543                 // Use an exponentially decaying ~10-minute window:
 544                 dFreeCount *= pow(1.0 - 1.0/600.0, (double)(nNow - nLastTime));
 545                 nLastTime = nNow;
 546                 // -limitfreerelay unit is thousand-bytes-per-minute
 547                 // At default rate it would take over a month to fill 1GB
 548                 if (dFreeCount > GetArg("-limitfreerelay", 15)*10*1000 && !IsFromMe(*this))
 549                     return error("AcceptToMemoryPool() : free transaction rejected by rate limiter");
 550                 if (fDebug)
 551                     printf("Rate limit dFreeCount: %g => %g\n", dFreeCount, dFreeCount+nSize);
 552                 dFreeCount += nSize;
 553             }
 554         }
 555     }
 556
 557     // Store transaction in memory
 558     CRITICAL_BLOCK(cs_mapTransactions)
 559     {
 560         if (ptxOld)
 561         {
 562             printf("AcceptToMemoryPool() : replacing tx %s with new version\n", ptxOld->GetHash().ToString().c_str());
 563             ptxOld->RemoveFromMemoryPool();
 564         }
 565         AddToMemoryPoolUnchecked();
 566     }
 567
 568     ///// are we sure this is ok when loading transactions or restoring block txes
 569     // If updated, erase old tx from wallet
 570     if (ptxOld)
 571         EraseFromWallets(ptxOld->GetHash());
 572
 573     printf("AcceptToMemoryPool(): accepted %s\n", hash.ToString().substr(0,10).c_str());
 574     return true;
 575 }
 576
 577 bool CTransaction::AcceptToMemoryPool(bool fCheckInputs, bool* pfMissingInputs)
 578 {
 579     CTxDB txdb("r");
 580     return AcceptToMemoryPool(txdb, fCheckInputs, pfMissingInputs);
 581 }
 582
 583 uint64 nPooledTx = 0;
 584
 585 bool CTransaction::AddToMemoryPoolUnchecked()
 586 {
 587     printf("AcceptToMemoryPoolUnchecked(): size %lu\n",  mapTransactions.size());
 588     // Add to memory pool without checking anything.  Don't call this directly,
 589     // call AcceptToMemoryPool to properly check the transaction first.
 590     CRITICAL_BLOCK(cs_mapTransactions)
 591     {
 592         uint256 hash = GetHash();
 593         mapTransactions[hash] = *this;
 594         for (int i = 0; i < vin.size(); i++)
 595             mapNextTx[vin[i].prevout] = CInPoint(&mapTransactions[hash], i);
 596         nTransactionsUpdated++;
 597         ++nPooledTx;
 598     }
 599     return true;
 600 }
 601
 602
 603 bool CTransaction::RemoveFromMemoryPool()
 604 {
 605     // Remove transaction from memory pool
 606     CRITICAL_BLOCK(cs_mapTransactions)
 607     {
 608         BOOST_FOREACH(const CTxIn& txin, vin)
 609             mapNextTx.erase(txin.prevout);
 610         mapTransactions.erase(GetHash());
 611         nTransactionsUpdated++;
 612         --nPooledTx;
 613     }
 614     return true;
 615 }
 616
 617
 618
 619
 620
 621
 622 int CMerkleTx::GetDepthInMainChain(CBlockIndex* &pindexRet) const
 623 {
 624     if (hashBlock == 0 || nIndex == -1)
 625         return 0;
 626
 627     // Find the block it claims to be in
 628     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
 629     if (mi == mapBlockIndex.end())
 630         return 0;
 631     CBlockIndex* pindex = (*mi).second;
 632     if (!pindex || !pindex->IsInMainChain())
 633         return 0;
 634
 635     // Make sure the merkle branch connects to this block
 636     if (!fMerkleVerified)
 637     {
 638         if (CBlock::CheckMerkleBranch(GetHash(), vMerkleBranch, nIndex) != pindex->hashMerkleRoot)
 639             return 0;
 640         fMerkleVerified = true;
 641     }
 642
 643     pindexRet = pindex;
 644     return pindexBest->nHeight - pindex->nHeight + 1;
 645 }
 646
 647
 648 int CMerkleTx::GetBlocksToMaturity() const
 649 {
 650     if (!IsCoinBase())
 651         return 0;
 652     return max(0, (COINBASE_MATURITY+20) - GetDepthInMainChain());
 653 }
 654
 655
 656 bool CMerkleTx::AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs)
 657 {
 658     if (fClient)
 659     {
 660         if (!IsInMainChain() && !ClientConnectInputs())
 661             return false;
 662         return CTransaction::AcceptToMemoryPool(txdb, false);
 663     }
 664     else
 665     {
 666         return CTransaction::AcceptToMemoryPool(txdb, fCheckInputs);
 667     }
 668 }
 669
 670 bool CMerkleTx::AcceptToMemoryPool()
 671 {
 672     CTxDB txdb("r");
 673     return AcceptToMemoryPool(txdb);
 674 }
 675
 676
 677
 678 bool CWalletTx::AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs)
 679 {
 680     CRITICAL_BLOCK(cs_mapTransactions)
 681     {
 682         // Add previous supporting transactions first
 683         BOOST_FOREACH(CMerkleTx& tx, vtxPrev)
 684         {
 685             if (!tx.IsCoinBase())
 686             {
 687                 uint256 hash = tx.GetHash();
 688                 if (!mapTransactions.count(hash) && !txdb.ContainsTx(hash))
 689                     tx.AcceptToMemoryPool(txdb, fCheckInputs);
 690             }
 691         }
 692         return AcceptToMemoryPool(txdb, fCheckInputs);
 693     }
 694     return false;
 695 }
 696
 697 bool CWalletTx::AcceptWalletTransaction()
 698 {
 699     CTxDB txdb("r");
 700     return AcceptWalletTransaction(txdb);
 701 }
 702
 703 int CTxIndex::GetDepthInMainChain() const
 704 {
 705     // Read block header
 706     CBlock block;
 707     if (!block.ReadFromDisk(pos.nFile, pos.nBlockPos, false))
 708         return 0;
 709     // Find the block in the index
 710     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(block.GetHash());
 711     if (mi == mapBlockIndex.end())
 712         return 0;
 713     CBlockIndex* pindex = (*mi).second;
 714     if (!pindex || !pindex->IsInMainChain())
 715         return 0;
 716     return 1 + nBestHeight - pindex->nHeight;
 717 }
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728 //////////////////////////////////////////////////////////////////////////////
 729 //
 730 // CBlock and CBlockIndex
 731 //
 732
 733 bool CBlock::ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions)
 734 {
 735     if (!fReadTransactions)
 736     {
 737         *this = pindex->GetBlockHeader();
 738         return true;
 739     }
 740     if (!ReadFromDisk(pindex->nFile, pindex->nBlockPos, fReadTransactions))
 741         return false;
 742     if (GetHash() != pindex->GetBlockHash())
 743         return error("CBlock::ReadFromDisk() : GetHash() doesn't match index");
 744     return true;
 745 }
 746
 747 uint256 static GetOrphanRoot(const CBlock* pblock)
 748 {
 749     // Work back to the first block in the orphan chain
 750     while (mapOrphanBlocks.count(pblock->hashPrevBlock))
 751         pblock = mapOrphanBlocks[pblock->hashPrevBlock];
 752     return pblock->GetHash();
 753 }
 754
 755 int64 static GetBlockValue(int nHeight, int64 nFees)
 756 {
 757     int64 nSubsidy = 50 * COIN;
 758
 759     // Subsidy is cut in half every 4 years
 760     nSubsidy >>= (nHeight / 210000);
 761
 762     return nSubsidy + nFees;
 763 }
 764
 765 static const int64 nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
 766 static const int64 nTargetSpacing = 10 * 60;
 767 static const int64 nInterval = nTargetTimespan / nTargetSpacing;
 768
 769 //
 770 // minimum amount of work that could possibly be required nTime after
 771 // minimum work required was nBase
 772 //
 773 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime)
 774 {
 775     CBigNum bnResult;
 776     bnResult.SetCompact(nBase);
 777     while (nTime > 0 && bnResult < bnProofOfWorkLimit)
 778     {
 779         // Maximum 400% adjustment...
 780         bnResult *= 4;
 781         // ... in best-case exactly 4-times-normal target time
 782         nTime -= nTargetTimespan*4;
 783     }
 784     if (bnResult > bnProofOfWorkLimit)
 785         bnResult = bnProofOfWorkLimit;
 786     return bnResult.GetCompact();
 787 }
 788
 789 unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast)
 790 {
 791
 792     // Genesis block
 793     if (pindexLast == NULL)
 794         return bnProofOfWorkLimit.GetCompact();
 795
 796     // Only change once per interval
 797     if ((pindexLast->nHeight+1) % nInterval != 0)
 798         return pindexLast->nBits;
 799
 800     // Go back by what we want to be 14 days worth of blocks
 801     const CBlockIndex* pindexFirst = pindexLast;
 802     for (int i = 0; pindexFirst && i < nInterval-1; i++)
 803         pindexFirst = pindexFirst->pprev;
 804     assert(pindexFirst);
 805
 806     // Limit adjustment step
 807     int64 nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
 808     printf("  nActualTimespan = %"PRI64d"  before bounds\n", nActualTimespan);
 809     if (nActualTimespan < nTargetTimespan/4)
 810         nActualTimespan = nTargetTimespan/4;
 811     if (nActualTimespan > nTargetTimespan*4)
 812         nActualTimespan = nTargetTimespan*4;
 813
 814     // Retarget
 815     CBigNum bnNew;
 816     bnNew.SetCompact(pindexLast->nBits);
 817     bnNew *= nActualTimespan;
 818     bnNew /= nTargetTimespan;
 819
 820     if (bnNew > bnProofOfWorkLimit)
 821         bnNew = bnProofOfWorkLimit;
 822
 823     /// debug print
 824     printf("GetNextWorkRequired RETARGET\n");
 825     printf("nTargetTimespan = %"PRI64d"    nActualTimespan = %"PRI64d"\n", nTargetTimespan, nActualTimespan);
 826     printf("Before: %08x  %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
 827     printf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());
 828
 829     return bnNew.GetCompact();
 830 }
 831
 832 bool CheckProofOfWork(uint256 hash, unsigned int nBits)
 833 {
 834     CBigNum bnTarget;
 835     bnTarget.SetCompact(nBits);
 836
 837     // Check range
 838     if (bnTarget <= 0 || bnTarget > bnProofOfWorkLimit)
 839         return error("CheckProofOfWork() : nBits below minimum work");
 840
 841     // Check proof of work matches claimed amount
 842     if (hash > bnTarget.getuint256())
 843         return error("CheckProofOfWork() : hash doesn't match nBits");
 844
 845     return true;
 846 }
 847
 848 // Return maximum amount of blocks that other nodes claim to have
 849 int GetNumBlocksOfPeers()
 850 {
 851     return std::max(cPeerBlockCounts.median(), Checkpoints::GetTotalBlocksEstimate());
 852 }
 853
 854 bool IsInitialBlockDownload()
 855 {
 856     if (pindexBest == NULL || nBestHeight < Checkpoints::GetTotalBlocksEstimate())
 857         return true;
 858     static int64 nLastUpdate;
 859     static CBlockIndex* pindexLastBest;
 860     if (pindexBest != pindexLastBest)
 861     {
 862         pindexLastBest = pindexBest;
 863         nLastUpdate = GetTime();
 864     }
 865     return (GetTime() - nLastUpdate < 10 &&
 866             pindexBest->GetBlockTime() < GetTime() - 24 * 60 * 60);
 867 }
 868
 869 void static InvalidChainFound(CBlockIndex* pindexNew)
 870 {
 871     if (pindexNew->bnChainWork > bnBestInvalidWork)
 872     {
 873         bnBestInvalidWork = pindexNew->bnChainWork;
 874         CTxDB().WriteBestInvalidWork(bnBestInvalidWork);
 875         MainFrameRepaint();
 876     }
 877     printf("InvalidChainFound: invalid block=%s  height=%d  work=%s\n", pindexNew->GetBlockHash().ToString().substr(0,20).c_str(), pindexNew->nHeight, pindexNew->bnChainWork.ToString().c_str());
 878     printf("InvalidChainFound:  current best=%s  height=%d  work=%s\n", hashBestChain.ToString().substr(0,20).c_str(), nBestHeight, bnBestChainWork.ToString().c_str());
 879     if (pindexBest && bnBestInvalidWork > bnBestChainWork + pindexBest->GetBlockWork() * 6)
 880         printf("InvalidChainFound: WARNING: Displayed transactions may not be correct!  You may need to upgrade, or other nodes may need to upgrade.\n");
 881 }
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893 bool CTransaction::DisconnectInputs(CTxDB& txdb)
 894 {
 895     // Relinquish previous transactions' spent pointers
 896     if (!IsCoinBase())
 897     {
 898         BOOST_FOREACH(const CTxIn& txin, vin)
 899         {
 900             COutPoint prevout = txin.prevout;
 901
 902             // Get prev txindex from disk
 903             CTxIndex txindex;
 904             if (!txdb.ReadTxIndex(prevout.hash, txindex))
 905                 return error("DisconnectInputs() : ReadTxIndex failed");
 906
 907             if (prevout.n >= txindex.vSpent.size())
 908                 return error("DisconnectInputs() : prevout.n out of range");
 909
 910             // Mark outpoint as not spent
 911             txindex.vSpent[prevout.n].SetNull();
 912
 913             // Write back
 914             if (!txdb.UpdateTxIndex(prevout.hash, txindex))
 915                 return error("DisconnectInputs() : UpdateTxIndex failed");
 916         }
 917     }
 918
 919     // Remove transaction from index
 920     if (!txdb.EraseTxIndex(*this))
 921         return error("DisconnectInputs() : EraseTxPos failed");
 922
 923     return true;
 924 }
 925
 926
 927 bool CTransaction::FetchInputs(CTxDB& txdb, const map<uint256, CTxIndex>& mapTestPool,
 928                                bool fBlock, bool fMiner, map<uint256, pair<CTxIndex, CTransaction> >& inputsRet)
 929 {
 930     if (IsCoinBase())
 931         return true; // Coinbase transactions have no inputs to fetch.
 932
 933     for (int i = 0; i < vin.size(); i++)
 934     {
 935         COutPoint prevout = vin[i].prevout;
 936         if (inputsRet.count(prevout.hash))
 937             continue; // Got it already
 938
 939         // Read txindex
 940         CTxIndex& txindex = inputsRet[prevout.hash].first;
 941         bool fFound = true;
 942         if ((fBlock || fMiner) && mapTestPool.count(prevout.hash))
 943         {
 944             // Get txindex from current proposed changes
 945             txindex = mapTestPool.find(prevout.hash)->second;
 946         }
 947         else
 948         {
 949             // Read txindex from txdb
 950             fFound = txdb.ReadTxIndex(prevout.hash, txindex);
 951         }
 952         if (!fFound && (fBlock || fMiner))
 953             return fMiner ? false : error("FetchInputs() : %s prev tx %s index entry not found", GetHash().ToString().substr(0,10).c_str(),  prevout.hash.ToString().substr(0,10).c_str());
 954
 955         // Read txPrev
 956         CTransaction& txPrev = inputsRet[prevout.hash].second;
 957         if (!fFound || txindex.pos == CDiskTxPos(1,1,1))
 958         {
 959             // Get prev tx from single transactions in memory
 960             CRITICAL_BLOCK(cs_mapTransactions)
 961             {
 962                 if (!mapTransactions.count(prevout.hash))
 963                     return error("FetchInputs() : %s mapTransactions prev not found %s", GetHash().ToString().substr(0,10).c_str(),  prevout.hash.ToString().substr(0,10).c_str());
 964                 txPrev = mapTransactions[prevout.hash];
 965             }
 966             if (!fFound)
 967                 txindex.vSpent.resize(txPrev.vout.size());
 968         }
 969         else
 970         {
 971             // Get prev tx from disk
 972             if (!txPrev.ReadFromDisk(txindex.pos))
 973                 return error("FetchInputs() : %s ReadFromDisk prev tx %s failed", GetHash().ToString().substr(0,10).c_str(),  prevout.hash.ToString().substr(0,10).c_str());
 974         }
 975     }
 976
 977     // Make sure all prevout.n's are valid:
 978     for (int i = 0; i < vin.size(); i++)
 979     {
 980         const COutPoint prevout = vin[i].prevout;
 981         const CTxIndex& txindex = inputsRet[prevout.hash].first;
 982         const CTransaction& txPrev = inputsRet[prevout.hash].second;
 983         if (prevout.n >= txPrev.vout.size() || prevout.n >= txindex.vSpent.size())
 984             return DoS(100, error("FetchInputs() : %s prevout.n out of range %d %d %d prev tx %s\n%s", GetHash().ToString().substr(0,10).c_str(), prevout.n, txPrev.vout.size(), txindex.vSpent.size(), prevout.hash.ToString().substr(0,10).c_str(), txPrev.ToString().c_str()));
 985     }
 986
 987     return true;
 988 }
 989
 990 bool CTransaction::ConnectInputs(map<uint256, pair<CTxIndex, CTransaction> > inputs,
 991                                  map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
 992                                  const CBlockIndex* pindexBlock, int64& nFees, bool fBlock, bool fMiner, int& nSigOpsRet, int64 nMinFee)
 993 {
 994     // Take over previous transactions' spent pointers
 995     // fBlock is true when this is called from AcceptBlock when a new best-block is added to the blockchain
 996     // fMiner is true when called from the internal bitcoin miner
 997     // ... both are false when called from CTransaction::AcceptToMemoryPool
 998     if (!IsCoinBase())
 999     {
1000         int64 nValueIn = 0;
1001         for (int i = 0; i < vin.size(); i++)
1002         {
1003             COutPoint prevout = vin[i].prevout;
1004             assert(inputs.count(prevout.hash) > 0);
1005             CTxIndex& txindex = inputs[prevout.hash].first;
1006             CTransaction& txPrev = inputs[prevout.hash].second;
1007
1008             if (prevout.n >= txPrev.vout.size() || prevout.n >= txindex.vSpent.size())
1009                 return DoS(100, error("ConnectInputs() : %s prevout.n out of range %d %d %d prev tx %s\n%s", GetHash().ToString().substr(0,10).c_str(), prevout.n, txPrev.vout.size(), txindex.vSpent.size(), prevout.hash.ToString().substr(0,10).c_str(), txPrev.ToString().c_str()));
1010
1011             // If prev is coinbase, check that it's matured
1012             if (txPrev.IsCoinBase())
1013                 for (const CBlockIndex* pindex = pindexBlock; pindex && pindexBlock->nHeight - pindex->nHeight < COINBASE_MATURITY; pindex = pindex->pprev)
1014                     if (pindex->nBlockPos == txindex.pos.nBlockPos && pindex->nFile == txindex.pos.nFile)
1015                         return error("ConnectInputs() : tried to spend coinbase at depth %d", pindexBlock->nHeight - pindex->nHeight);
1016
1017             bool fStrictPayToScriptHash = true;
1018             if (fBlock)
1019             {
1020                 // To avoid being on the short end of a block-chain split,
1021                 // don't do secondary validation of pay-to-script-hash transactions
1022                 // until blocks with timestamps after paytoscripthashtime:
1023                 int64 nEvalSwitchTime = GetArg("paytoscripthashtime", 1329264000); // Feb 15, 2012
1024                 fStrictPayToScriptHash = (pindexBlock->nTime >= nEvalSwitchTime);
1025             }
1026             // if !fBlock, then always be strict-- don't accept
1027             // invalid-under-new-rules pay-to-script-hash transactions into
1028             // our memory pool (don't relay them, don't include them
1029             // in blocks we mine).
1030
1031             // Skip ECDSA signature verification when connecting blocks (fBlock=true)
1032             // before the last blockchain checkpoint. This is safe because block merkle hashes are
1033             // still computed and checked, and any change will be caught at the next checkpoint.
1034             if (!(fBlock && (nBestHeight < Checkpoints::GetTotalBlocksEstimate())))
1035             {
1036                 // Verify signature
1037                 if (!VerifySignature(txPrev, *this, i, fStrictPayToScriptHash, 0))
1038                     return DoS(100,error("ConnectInputs() : %s VerifySignature failed", GetHash().ToString().substr(0,10).c_str()));
1039             }
1040
1041             // Check for conflicts (double-spend)
1042             // This doesn't trigger the DoS code on purpose; if it did, it would make it easier
1043             // for an attacker to attempt to split the network.
1044             if (!txindex.vSpent[prevout.n].IsNull())
1045                 return fMiner ? false : error("ConnectInputs() : %s prev tx already used at %s", GetHash().ToString().substr(0,10).c_str(), txindex.vSpent[prevout.n].ToString().c_str());
1046
1047             // Check for negative or overflow input values
1048             nValueIn += txPrev.vout[prevout.n].nValue;
1049             if (!MoneyRange(txPrev.vout[prevout.n].nValue) || !MoneyRange(nValueIn))
1050                 return DoS(100, error("ConnectInputs() : txin values out of range"));
1051
1052             // Calculate sigOps accurately:
1053             nSigOpsRet += txPrev.vout[prevout.n].scriptPubKey.GetSigOpCount(vin[i].scriptSig);
1054
1055             // Mark outpoints as spent
1056             txindex.vSpent[prevout.n] = posThisTx;
1057
1058             // Write back
1059             if (fBlock || fMiner)
1060             {
1061                 mapTestPool[prevout.hash] = txindex;
1062             }
1063         }
1064
1065         if (nValueIn < GetValueOut())
1066             return DoS(100, error("ConnectInputs() : %s value in < value out", GetHash().ToString().substr(0,10).c_str()));
1067
1068         // Tally transaction fees
1069         int64 nTxFee = nValueIn - GetValueOut();
1070         if (nTxFee < 0)
1071             return DoS(100, error("ConnectInputs() : %s nTxFee < 0", GetHash().ToString().substr(0,10).c_str()));
1072         if (nTxFee < nMinFee)
1073             return false;
1074         nFees += nTxFee;
1075         if (!MoneyRange(nFees))
1076             return DoS(100, error("ConnectInputs() : nFees out of range"));
1077     }
1078
1079     if (fBlock)
1080     {
1081         // Add transaction to changes
1082         mapTestPool[GetHash()] = CTxIndex(posThisTx, vout.size());
1083     }
1084     else if (fMiner)
1085     {
1086         // Add transaction to test pool
1087         mapTestPool[GetHash()] = CTxIndex(CDiskTxPos(1,1,1), vout.size());
1088     }
1089
1090     return true;
1091 }
1092
1093
1094 bool CTransaction::ClientConnectInputs()
1095 {
1096     if (IsCoinBase())
1097         return false;
1098
1099     // Take over previous transactions' spent pointers
1100     CRITICAL_BLOCK(cs_mapTransactions)
1101     {
1102         int64 nValueIn = 0;
1103         for (int i = 0; i < vin.size(); i++)
1104         {
1105             // Get prev tx from single transactions in memory
1106             COutPoint prevout = vin[i].prevout;
1107             if (!mapTransactions.count(prevout.hash))
1108                 return false;
1109             CTransaction& txPrev = mapTransactions[prevout.hash];
1110
1111             if (prevout.n >= txPrev.vout.size())
1112                 return false;
1113
1114             // Verify signature
1115             if (!VerifySignature(txPrev, *this, i, true, 0))
1116                 return error("ConnectInputs() : VerifySignature failed");
1117
1118             ///// this is redundant with the mapNextTx stuff, not sure which I want to get rid of
1119             ///// this has to go away now that posNext is gone
1120             // // Check for conflicts
1121             // if (!txPrev.vout[prevout.n].posNext.IsNull())
1122             //     return error("ConnectInputs() : prev tx already used");
1123             //
1124             // // Flag outpoints as used
1125             // txPrev.vout[prevout.n].posNext = posThisTx;
1126
1127             nValueIn += txPrev.vout[prevout.n].nValue;
1128
1129             if (!MoneyRange(txPrev.vout[prevout.n].nValue) || !MoneyRange(nValueIn))
1130                 return error("ClientConnectInputs() : txin values out of range");
1131         }
1132         if (GetValueOut() > nValueIn)
1133             return false;
1134     }
1135
1136     return true;
1137 }
1138
1139
1140
1141
1142 bool CBlock::DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex)
1143 {
1144     // Disconnect in reverse order
1145     for (int i = vtx.size()-1; i >= 0; i--)
1146         if (!vtx[i].DisconnectInputs(txdb))
1147             return false;
1148
1149     // Update block index on disk without changing it in memory.
1150     // The memory index structure will be changed after the db commits.
1151     if (pindex->pprev)
1152     {
1153         CDiskBlockIndex blockindexPrev(pindex->pprev);
1154         blockindexPrev.hashNext = 0;
1155         if (!txdb.WriteBlockIndex(blockindexPrev))
1156             return error("DisconnectBlock() : WriteBlockIndex failed");
1157     }
1158
1159     return true;
1160 }
1161
1162 bool CBlock::ConnectBlock(CTxDB& txdb, CBlockIndex* pindex)
1163 {
1164     // Check it again in case a previous version let a bad block in
1165     if (!CheckBlock())
1166         return false;
1167
1168     //// issue here: it doesn't know the version
1169     unsigned int nTxPos = pindex->nBlockPos + ::GetSerializeSize(CBlock(), SER_DISK) - 1 + GetSizeOfCompactSize(vtx.size());
1170
1171     map<uint256, CTxIndex> mapQueuedChanges;
1172     int64 nFees = 0;
1173     int nSigOps = 0;
1174     BOOST_FOREACH(CTransaction& tx, vtx)
1175     {
1176         CDiskTxPos posThisTx(pindex->nFile, pindex->nBlockPos, nTxPos);
1177         nTxPos += ::GetSerializeSize(tx, SER_DISK);
1178
1179         map<uint256, pair<CTxIndex, CTransaction> > mapInputs;
1180         if (!tx.FetchInputs(txdb, mapQueuedChanges, true, false, mapInputs))
1181             return false;
1182
1183         int nTxOps = 0;
1184         if (!tx.ConnectInputs(mapInputs, mapQueuedChanges, posThisTx, pindex, nFees, true, false, nTxOps))
1185             return false;
1186
1187         nSigOps += nTxOps;
1188         if (nSigOps > MAX_BLOCK_SIGOPS)
1189             return DoS(100, error("ConnectBlock() : too many sigops"));
1190         // There is a different MAX_BLOCK_SIGOPS check in AcceptBlock();
1191         // a block must satisfy both to make it into the best-chain
1192         // (AcceptBlock() is always called before ConnectBlock())
1193     }
1194
1195     // Write queued txindex changes
1196     for (map<uint256, CTxIndex>::iterator mi = mapQueuedChanges.begin(); mi != mapQueuedChanges.end(); ++mi)
1197     {
1198         if (!txdb.UpdateTxIndex((*mi).first, (*mi).second))
1199             return error("ConnectBlock() : UpdateTxIndex failed");
1200     }
1201
1202     if (vtx[0].GetValueOut() > GetBlockValue(pindex->nHeight, nFees))
1203         return false;
1204
1205     // Update block index on disk without changing it in memory.
1206     // The memory index structure will be changed after the db commits.
1207     if (pindex->pprev)
1208     {
1209         CDiskBlockIndex blockindexPrev(pindex->pprev);
1210         blockindexPrev.hashNext = pindex->GetBlockHash();
1211         if (!txdb.WriteBlockIndex(blockindexPrev))
1212             return error("ConnectBlock() : WriteBlockIndex failed");
1213     }
1214
1215     // Watch for transactions paying to me
1216     BOOST_FOREACH(CTransaction& tx, vtx)
1217         SyncWithWallets(tx, this, true);
1218
1219     return true;
1220 }
1221
1222 bool static Reorganize(CTxDB& txdb, CBlockIndex* pindexNew)
1223 {
1224     printf("REORGANIZE\n");
1225
1226     // Find the fork
1227     CBlockIndex* pfork = pindexBest;
1228     CBlockIndex* plonger = pindexNew;
1229     while (pfork != plonger)
1230     {
1231         while (plonger->nHeight > pfork->nHeight)
1232             if (!(plonger = plonger->pprev))
1233                 return error("Reorganize() : plonger->pprev is null");
1234         if (pfork == plonger)
1235             break;
1236         if (!(pfork = pfork->pprev))
1237             return error("Reorganize() : pfork->pprev is null");
1238     }
1239
1240     // List of what to disconnect
1241     vector<CBlockIndex*> vDisconnect;
1242     for (CBlockIndex* pindex = pindexBest; pindex != pfork; pindex = pindex->pprev)
1243         vDisconnect.push_back(pindex);
1244
1245     // List of what to connect
1246     vector<CBlockIndex*> vConnect;
1247     for (CBlockIndex* pindex = pindexNew; pindex != pfork; pindex = pindex->pprev)
1248         vConnect.push_back(pindex);
1249     reverse(vConnect.begin(), vConnect.end());
1250
1251     // Disconnect shorter branch
1252     vector<CTransaction> vResurrect;
1253     BOOST_FOREACH(CBlockIndex* pindex, vDisconnect)
1254     {
1255         CBlock block;
1256         if (!block.ReadFromDisk(pindex))
1257             return error("Reorganize() : ReadFromDisk for disconnect failed");
1258         if (!block.DisconnectBlock(txdb, pindex))
1259             return error("Reorganize() : DisconnectBlock failed");
1260
1261         // Queue memory transactions to resurrect
1262         BOOST_FOREACH(const CTransaction& tx, block.vtx)
1263             if (!tx.IsCoinBase())
1264                 vResurrect.push_back(tx);
1265     }
1266
1267     // Connect longer branch
1268     vector<CTransaction> vDelete;
1269     for (int i = 0; i < vConnect.size(); i++)
1270     {
1271         CBlockIndex* pindex = vConnect[i];
1272         CBlock block;
1273         if (!block.ReadFromDisk(pindex))
1274             return error("Reorganize() : ReadFromDisk for connect failed");
1275         if (!block.ConnectBlock(txdb, pindex))
1276         {
1277             // Invalid block
1278             txdb.TxnAbort();
1279             return error("Reorganize() : ConnectBlock failed");
1280         }
1281
1282         // Queue memory transactions to delete
1283         BOOST_FOREACH(const CTransaction& tx, block.vtx)
1284             vDelete.push_back(tx);
1285     }
1286     if (!txdb.WriteHashBestChain(pindexNew->GetBlockHash()))
1287         return error("Reorganize() : WriteHashBestChain failed");
1288
1289     // Make sure it's successfully written to disk before changing memory structure
1290     if (!txdb.TxnCommit())
1291         return error("Reorganize() : TxnCommit failed");
1292
1293     // Disconnect shorter branch
1294     BOOST_FOREACH(CBlockIndex* pindex, vDisconnect)
1295         if (pindex->pprev)
1296             pindex->pprev->pnext = NULL;
1297
1298     // Connect longer branch
1299     BOOST_FOREACH(CBlockIndex* pindex, vConnect)
1300         if (pindex->pprev)
1301             pindex->pprev->pnext = pindex;
1302
1303     // Resurrect memory transactions that were in the disconnected branch
1304     BOOST_FOREACH(CTransaction& tx, vResurrect)
1305         tx.AcceptToMemoryPool(txdb, false);
1306
1307     // Delete redundant memory transactions that are in the connected branch
1308     BOOST_FOREACH(CTransaction& tx, vDelete)
1309         tx.RemoveFromMemoryPool();
1310
1311     return true;
1312 }
1313
1314
1315 static void
1316 runCommand(std::string strCommand)
1317 {
1318     int nErr = ::system(strCommand.c_str());
1319     if (nErr)
1320         printf("runCommand error: system(%s) returned %d\n", strCommand.c_str(), nErr);
1321 }
1322
1323 bool CBlock::SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew)
1324 {
1325     uint256 hash = GetHash();
1326
1327     txdb.TxnBegin();
1328     if (pindexGenesisBlock == NULL && hash == hashGenesisBlock)
1329     {
1330         txdb.WriteHashBestChain(hash);
1331         if (!txdb.TxnCommit())
1332             return error("SetBestChain() : TxnCommit failed");
1333         pindexGenesisBlock = pindexNew;
1334     }
1335     else if (hashPrevBlock == hashBestChain)
1336     {
1337         // Adding to current best branch
1338         if (!ConnectBlock(txdb, pindexNew) || !txdb.WriteHashBestChain(hash))
1339         {
1340             txdb.TxnAbort();
1341             InvalidChainFound(pindexNew);
1342             return error("SetBestChain() : ConnectBlock failed");
1343         }
1344         if (!txdb.TxnCommit())
1345             return error("SetBestChain() : TxnCommit failed");
1346
1347         // Add to current best branch
1348         pindexNew->pprev->pnext = pindexNew;
1349
1350         // Delete redundant memory transactions
1351         BOOST_FOREACH(CTransaction& tx, vtx)
1352             tx.RemoveFromMemoryPool();
1353     }
1354     else
1355     {
1356         // New best branch
1357         if (!Reorganize(txdb, pindexNew))
1358         {
1359             txdb.TxnAbort();
1360             InvalidChainFound(pindexNew);
1361             return error("SetBestChain() : Reorganize failed");
1362         }
1363     }
1364
1365     // Update best block in wallet (so we can detect restored wallets)
1366     bool fIsInitialDownload = IsInitialBlockDownload();
1367     if (!fIsInitialDownload)
1368     {
1369         const CBlockLocator locator(pindexNew);
1370         ::SetBestChain(locator);
1371     }
1372
1373     // New best block
1374     hashBestChain = hash;
1375     pindexBest = pindexNew;
1376     nBestHeight = pindexBest->nHeight;
1377     bnBestChainWork = pindexNew->bnChainWork;
1378     nTimeBestReceived = GetTime();
1379     nTransactionsUpdated++;
1380     printf("SetBestChain: new best=%s  height=%d  work=%s\n", hashBestChain.ToString().substr(0,20).c_str(), nBestHeight, bnBestChainWork.ToString().c_str());
1381
1382     std::string strCmd = GetArg("-blocknotify", "");
1383
1384     if (!fIsInitialDownload && !strCmd.empty())
1385     {
1386         boost::replace_all(strCmd, "%s", hashBestChain.GetHex());
1387         boost::thread t(runCommand, strCmd); // thread runs free
1388     }
1389
1390     return true;
1391 }
1392
1393
1394 bool CBlock::AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos)
1395 {
1396     // Check for duplicate
1397     uint256 hash = GetHash();
1398     if (mapBlockIndex.count(hash))
1399         return error("AddToBlockIndex() : %s already exists", hash.ToString().substr(0,20).c_str());
1400
1401     // Construct new block index object
1402     CBlockIndex* pindexNew = new CBlockIndex(nFile, nBlockPos, *this);
1403     if (!pindexNew)
1404         return error("AddToBlockIndex() : new CBlockIndex failed");
1405     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
1406     pindexNew->phashBlock = &((*mi).first);
1407     map<uint256, CBlockIndex*>::iterator miPrev = mapBlockIndex.find(hashPrevBlock);
1408     if (miPrev != mapBlockIndex.end())
1409     {
1410         pindexNew->pprev = (*miPrev).second;
1411         pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
1412     }
1413     pindexNew->bnChainWork = (pindexNew->pprev ? pindexNew->pprev->bnChainWork : 0) + pindexNew->GetBlockWork();
1414
1415     CTxDB txdb;
1416     txdb.TxnBegin();
1417     txdb.WriteBlockIndex(CDiskBlockIndex(pindexNew));
1418     if (!txdb.TxnCommit())
1419         return false;
1420
1421     // New best
1422     if (pindexNew->bnChainWork > bnBestChainWork)
1423         if (!SetBestChain(txdb, pindexNew))
1424             return false;
1425
1426     txdb.Close();
1427
1428     if (pindexNew == pindexBest)
1429     {
1430         // Notify UI to display prev block's coinbase if it was ours
1431         static uint256 hashPrevBestCoinBase;
1432         UpdatedTransaction(hashPrevBestCoinBase);
1433         hashPrevBestCoinBase = vtx[0].GetHash();
1434     }
1435
1436     MainFrameRepaint();
1437     return true;
1438 }
1439
1440
1441
1442
1443 bool CBlock::CheckBlock() const
1444 {
1445     // These are checks that are independent of context
1446     // that can be verified before saving an orphan block.
1447
1448     // Size limits
1449     if (vtx.empty() || vtx.size() > MAX_BLOCK_SIZE || ::GetSerializeSize(*this, SER_NETWORK) > MAX_BLOCK_SIZE)
1450         return DoS(100, error("CheckBlock() : size limits failed"));
1451
1452     // Check proof of work matches claimed amount
1453     if (!CheckProofOfWork(GetHash(), nBits))
1454         return DoS(50, error("CheckBlock() : proof of work failed"));
1455
1456     // Check timestamp
1457     if (GetBlockTime() > GetAdjustedTime() + 2 * 60 * 60)
1458         return error("CheckBlock() : block timestamp too far in the future");
1459
1460     // First transaction must be coinbase, the rest must not be
1461     if (vtx.empty() || !vtx[0].IsCoinBase())
1462         return DoS(100, error("CheckBlock() : first tx is not coinbase"));
1463     for (int i = 1; i < vtx.size(); i++)
1464         if (vtx[i].IsCoinBase())
1465             return DoS(100, error("CheckBlock() : more than one coinbase"));
1466
1467     // Check transactions
1468     BOOST_FOREACH(const CTransaction& tx, vtx)
1469         if (!tx.CheckTransaction())
1470             return DoS(tx.nDoS, error("CheckBlock() : CheckTransaction failed"));
1471
1472     // Pre-pay-to-script-hash (before version 0.6), this is how sigops
1473     // were counted; there is another check in ConnectBlock when
1474     // transaction inputs are fetched to count pay-to-script-hash sigops:
1475     int nSigOps = 0;
1476     BOOST_FOREACH(const CTransaction& tx, vtx)
1477     {
1478         nSigOps += tx.GetLegacySigOpCount();
1479     }
1480     if (nSigOps > MAX_BLOCK_SIGOPS)
1481         return DoS(100, error("CheckBlock() : out-of-bounds SigOpCount"));
1482
1483     // Check merkleroot
1484     if (hashMerkleRoot != BuildMerkleTree())
1485         return DoS(100, error("CheckBlock() : hashMerkleRoot mismatch"));
1486
1487     return true;
1488 }
1489
1490 bool CBlock::AcceptBlock()
1491 {
1492     // Check for duplicate
1493     uint256 hash = GetHash();
1494     if (mapBlockIndex.count(hash))
1495         return error("AcceptBlock() : block already in mapBlockIndex");
1496
1497     // Get prev block index
1498     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashPrevBlock);
1499     if (mi == mapBlockIndex.end())
1500         return DoS(10, error("AcceptBlock() : prev block not found"));
1501     CBlockIndex* pindexPrev = (*mi).second;
1502     int nHeight = pindexPrev->nHeight+1;
1503
1504     // Check proof of work
1505     if (nBits != GetNextWorkRequired(pindexPrev))
1506         return DoS(100, error("AcceptBlock() : incorrect proof of work"));
1507
1508     // Check timestamp against prev
1509     if (GetBlockTime() <= pindexPrev->GetMedianTimePast())
1510         return error("AcceptBlock() : block's timestamp is too early");
1511
1512     // Check that all transactions are finalized
1513     BOOST_FOREACH(const CTransaction& tx, vtx)
1514         if (!tx.IsFinal(nHeight, GetBlockTime()))
1515             return DoS(10, error("AcceptBlock() : contains a non-final transaction"));
1516
1517     // Check that the block chain matches the known block chain up to a checkpoint
1518     if (!Checkpoints::CheckBlock(nHeight, hash))
1519         return DoS(100, error("AcceptBlock() : rejected by checkpoint lockin at %d", nHeight));
1520
1521     // Write block to history file
1522     if (!CheckDiskSpace(::GetSerializeSize(*this, SER_DISK)))
1523         return error("AcceptBlock() : out of disk space");
1524     unsigned int nFile = -1;
1525     unsigned int nBlockPos = 0;
1526     if (!WriteToDisk(nFile, nBlockPos))
1527         return error("AcceptBlock() : WriteToDisk failed");
1528     if (!AddToBlockIndex(nFile, nBlockPos))
1529         return error("AcceptBlock() : AddToBlockIndex failed");
1530
1531     // Relay inventory, but don't relay old inventory during initial block download
1532     if (hashBestChain == hash)
1533         CRITICAL_BLOCK(cs_vNodes)
1534             BOOST_FOREACH(CNode* pnode, vNodes)
1535                 if (nBestHeight > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : 140700))
1536                     pnode->PushInventory(CInv(MSG_BLOCK, hash));
1537
1538     return true;
1539 }
1540
1541 bool ProcessBlock(CNode* pfrom, CBlock* pblock)
1542 {
1543     // Check for duplicate
1544     uint256 hash = pblock->GetHash();
1545     if (mapBlockIndex.count(hash))
1546         return error("ProcessBlock() : already have block %d %s", mapBlockIndex[hash]->nHeight, hash.ToString().substr(0,20).c_str());
1547     if (mapOrphanBlocks.count(hash))
1548         return error("ProcessBlock() : already have block (orphan) %s", hash.ToString().substr(0,20).c_str());
1549
1550     // Preliminary checks
1551     if (!pblock->CheckBlock())
1552         return error("ProcessBlock() : CheckBlock FAILED");
1553
1554     CBlockIndex* pcheckpoint = Checkpoints::GetLastCheckpoint(mapBlockIndex);
1555     if (pcheckpoint && pblock->hashPrevBlock != hashBestChain)
1556     {
1557         // Extra checks to prevent "fill up memory by spamming with bogus blocks"
1558         int64 deltaTime = pblock->GetBlockTime() - pcheckpoint->nTime;
1559         if (deltaTime < 0)
1560         {
1561             pfrom->Misbehaving(100);
1562             return error("ProcessBlock() : block with timestamp before last checkpoint");
1563         }
1564         CBigNum bnNewBlock;
1565         bnNewBlock.SetCompact(pblock->nBits);
1566         CBigNum bnRequired;
1567         bnRequired.SetCompact(ComputeMinWork(pcheckpoint->nBits, deltaTime));
1568         if (bnNewBlock > bnRequired)
1569         {
1570             pfrom->Misbehaving(100);
1571             return error("ProcessBlock() : block with too little proof-of-work");
1572         }
1573     }
1574
1575
1576     // If don't already have its previous block, shunt it off to holding area until we get it
1577     if (!mapBlockIndex.count(pblock->hashPrevBlock))
1578     {
1579         printf("ProcessBlock: ORPHAN BLOCK, prev=%s\n", pblock->hashPrevBlock.ToString().substr(0,20).c_str());
1580         CBlock* pblock2 = new CBlock(*pblock);
1581         mapOrphanBlocks.insert(make_pair(hash, pblock2));
1582         mapOrphanBlocksByPrev.insert(make_pair(pblock2->hashPrevBlock, pblock2));
1583
1584         // Ask this guy to fill in what we're missing
1585         if (pfrom)
1586             pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(pblock2));
1587         return true;
1588     }
1589
1590     // Store to disk
1591     if (!pblock->AcceptBlock())
1592         return error("ProcessBlock() : AcceptBlock FAILED");
1593
1594     // Recursively process any orphan blocks that depended on this one
1595     vector<uint256> vWorkQueue;
1596     vWorkQueue.push_back(hash);
1597     for (int i = 0; i < vWorkQueue.size(); i++)
1598     {
1599         uint256 hashPrev = vWorkQueue[i];
1600         for (multimap<uint256, CBlock*>::iterator mi = mapOrphanBlocksByPrev.lower_bound(hashPrev);
1601              mi != mapOrphanBlocksByPrev.upper_bound(hashPrev);
1602              ++mi)
1603         {
1604             CBlock* pblockOrphan = (*mi).second;
1605             if (pblockOrphan->AcceptBlock())
1606                 vWorkQueue.push_back(pblockOrphan->GetHash());
1607             mapOrphanBlocks.erase(pblockOrphan->GetHash());
1608             delete pblockOrphan;
1609         }
1610         mapOrphanBlocksByPrev.erase(hashPrev);
1611     }
1612
1613     printf("ProcessBlock: ACCEPTED\n");
1614     return true;
1615 }
1616
1617
1618
1619
1620
1621
1622
1623
1624 bool CheckDiskSpace(uint64 nAdditionalBytes)
1625 {
1626     uint64 nFreeBytesAvailable = filesystem::space(GetDataDir()).available;
1627
1628     // Check for 15MB because database could create another 10MB log file at any time
1629     if (nFreeBytesAvailable < (uint64)15000000 + nAdditionalBytes)
1630     {
1631         fShutdown = true;
1632         string strMessage = _("Warning: Disk space is low  ");
1633         strMiscWarning = strMessage;
1634         printf("*** %s\n", strMessage.c_str());
1635         ThreadSafeMessageBox(strMessage, "Bitcoin", wxOK | wxICON_EXCLAMATION);
1636         CreateThread(Shutdown, NULL);
1637         return false;
1638     }
1639     return true;
1640 }
1641
1642 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode)
1643 {
1644     if (nFile == -1)
1645         return NULL;
1646     FILE* file = fopen(strprintf("%s/blk%04d.dat", GetDataDir().c_str(), nFile).c_str(), pszMode);
1647     if (!file)
1648         return NULL;
1649     if (nBlockPos != 0 && !strchr(pszMode, 'a') && !strchr(pszMode, 'w'))
1650     {
1651         if (fseek(file, nBlockPos, SEEK_SET) != 0)
1652         {
1653             fclose(file);
1654             return NULL;
1655         }
1656     }
1657     return file;
1658 }
1659
1660 static unsigned int nCurrentBlockFile = 1;
1661
1662 FILE* AppendBlockFile(unsigned int& nFileRet)
1663 {
1664     nFileRet = 0;
1665     loop
1666     {
1667         FILE* file = OpenBlockFile(nCurrentBlockFile, 0, "ab");
1668         if (!file)
1669             return NULL;
1670         if (fseek(file, 0, SEEK_END) != 0)
1671             return NULL;
1672         // FAT32 filesize max 4GB, fseek and ftell max 2GB, so we must stay under 2GB
1673         if (ftell(file) < 0x7F000000 - MAX_SIZE)
1674         {
1675             nFileRet = nCurrentBlockFile;
1676             return file;
1677         }
1678         fclose(file);
1679         nCurrentBlockFile++;
1680     }
1681 }
1682
1683 bool LoadBlockIndex(bool fAllowNew)
1684 {
1685     if (fTestNet)
1686     {
1687         hashGenesisBlock = uint256("0x00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008");
1688         bnProofOfWorkLimit = CBigNum(~uint256(0) >> 28);
1689         pchMessageStart[0] = 0xfa;
1690         pchMessageStart[1] = 0xbf;
1691         pchMessageStart[2] = 0xb5;
1692         pchMessageStart[3] = 0xda;
1693     }
1694
1695     //
1696     // Load block index
1697     //
1698     CTxDB txdb("cr");
1699     if (!txdb.LoadBlockIndex())
1700         return false;
1701     txdb.Close();
1702
1703     //
1704     // Init with genesis block
1705     //
1706     if (mapBlockIndex.empty())
1707     {
1708         if (!fAllowNew)
1709             return false;
1710
1711         // Genesis Block:
1712         // CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
1713         //   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
1714         //     CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
1715         //     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
1716         //   vMerkleTree: 4a5e1e
1717
1718         // Genesis block
1719         const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
1720         CTransaction txNew;
1721         txNew.vin.resize(1);
1722         txNew.vout.resize(1);
1723         txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
1724         txNew.vout[0].nValue = 50 * COIN;
1725         txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
1726         CBlock block;
1727         block.vtx.push_back(txNew);
1728         block.hashPrevBlock = 0;
1729         block.hashMerkleRoot = block.BuildMerkleTree();
1730         block.nVersion = 1;
1731         block.nTime    = 1231006505;
1732         block.nBits    = 0x1d00ffff;
1733         block.nNonce   = 2083236893;
1734
1735         if (fTestNet)
1736         {
1737             block.nTime    = 1296688602;
1738             block.nBits    = 0x1d07fff8;
1739             block.nNonce   = 384568319;
1740         }
1741
1742         //// debug print
1743         printf("%s\n", block.GetHash().ToString().c_str());
1744         printf("%s\n", hashGenesisBlock.ToString().c_str());
1745         printf("%s\n", block.hashMerkleRoot.ToString().c_str());
1746         assert(block.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
1747         block.print();
1748         assert(block.GetHash() == hashGenesisBlock);
1749
1750         // Start new block file
1751         unsigned int nFile;
1752         unsigned int nBlockPos;
1753         if (!block.WriteToDisk(nFile, nBlockPos))
1754             return error("LoadBlockIndex() : writing genesis block to disk failed");
1755         if (!block.AddToBlockIndex(nFile, nBlockPos))
1756             return error("LoadBlockIndex() : genesis block not accepted");
1757     }
1758
1759     return true;
1760 }
1761
1762
1763
1764 void PrintBlockTree()
1765 {
1766     // precompute tree structure
1767     map<CBlockIndex*, vector<CBlockIndex*> > mapNext;
1768     for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
1769     {
1770         CBlockIndex* pindex = (*mi).second;
1771         mapNext[pindex->pprev].push_back(pindex);
1772         // test
1773         //while (rand() % 3 == 0)
1774         //    mapNext[pindex->pprev].push_back(pindex);
1775     }
1776
1777     vector<pair<int, CBlockIndex*> > vStack;
1778     vStack.push_back(make_pair(0, pindexGenesisBlock));
1779
1780     int nPrevCol = 0;
1781     while (!vStack.empty())
1782     {
1783         int nCol = vStack.back().first;
1784         CBlockIndex* pindex = vStack.back().second;
1785         vStack.pop_back();
1786
1787         // print split or gap
1788         if (nCol > nPrevCol)
1789         {
1790             for (int i = 0; i < nCol-1; i++)
1791                 printf("| ");
1792             printf("|\\\n");
1793         }
1794         else if (nCol < nPrevCol)
1795         {
1796             for (int i = 0; i < nCol; i++)
1797                 printf("| ");
1798             printf("|\n");
1799        }
1800         nPrevCol = nCol;
1801
1802         // print columns
1803         for (int i = 0; i < nCol; i++)
1804             printf("| ");
1805
1806         // print item
1807         CBlock block;
1808         block.ReadFromDisk(pindex);
1809         printf("%d (%u,%u) %s  %s  tx %d",
1810             pindex->nHeight,
1811             pindex->nFile,
1812             pindex->nBlockPos,
1813             block.GetHash().ToString().substr(0,20).c_str(),
1814             DateTimeStrFormat("%x %H:%M:%S", block.GetBlockTime()).c_str(),
1815             block.vtx.size());
1816
1817         PrintWallets(block);
1818
1819         // put the main timechain first
1820         vector<CBlockIndex*>& vNext = mapNext[pindex];
1821         for (int i = 0; i < vNext.size(); i++)
1822         {
1823             if (vNext[i]->pnext)
1824             {
1825                 swap(vNext[0], vNext[i]);
1826                 break;
1827             }
1828         }
1829
1830         // iterate children
1831         for (int i = 0; i < vNext.size(); i++)
1832             vStack.push_back(make_pair(nCol+i, vNext[i]));
1833     }
1834 }
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845 //////////////////////////////////////////////////////////////////////////////
1846 //
1847 // CAlert
1848 //
1849
1850 map<uint256, CAlert> mapAlerts;
1851 CCriticalSection cs_mapAlerts;
1852
1853 string GetWarnings(string strFor)
1854 {
1855     int nPriority = 0;
1856     string strStatusBar;
1857     string strRPC;
1858     if (GetBoolArg("-testsafemode"))
1859         strRPC = "test";
1860
1861     // Misc warnings like out of disk space and clock is wrong
1862     if (strMiscWarning != "")
1863     {
1864         nPriority = 1000;
1865         strStatusBar = strMiscWarning;
1866     }
1867
1868     // Longer invalid proof-of-work chain
1869     if (pindexBest && bnBestInvalidWork > bnBestChainWork + pindexBest->GetBlockWork() * 6)
1870     {
1871         nPriority = 2000;
1872         strStatusBar = strRPC = "WARNING: Displayed transactions may not be correct!  You may need to upgrade, or other nodes may need to upgrade.";
1873     }
1874
1875     // Alerts
1876     CRITICAL_BLOCK(cs_mapAlerts)
1877     {
1878         BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
1879         {
1880             const CAlert& alert = item.second;
1881             if (alert.AppliesToMe() && alert.nPriority > nPriority)
1882             {
1883                 nPriority = alert.nPriority;
1884                 strStatusBar = alert.strStatusBar;
1885             }
1886         }
1887     }
1888
1889     if (strFor == "statusbar")
1890         return strStatusBar;
1891     else if (strFor == "rpc")
1892         return strRPC;
1893     assert(!"GetWarnings() : invalid parameter");
1894     return "error";
1895 }
1896
1897 bool CAlert::ProcessAlert()
1898 {
1899     if (!CheckSignature())
1900         return false;
1901     if (!IsInEffect())
1902         return false;
1903
1904     CRITICAL_BLOCK(cs_mapAlerts)
1905     {
1906         // Cancel previous alerts
1907         for (map<uint256, CAlert>::iterator mi = mapAlerts.begin(); mi != mapAlerts.end();)
1908         {
1909             const CAlert& alert = (*mi).second;
1910             if (Cancels(alert))
1911             {
1912                 printf("cancelling alert %d\n", alert.nID);
1913                 mapAlerts.erase(mi++);
1914             }
1915             else if (!alert.IsInEffect())
1916             {
1917                 printf("expiring alert %d\n", alert.nID);
1918                 mapAlerts.erase(mi++);
1919             }
1920             else
1921                 mi++;
1922         }
1923
1924         // Check if this alert has been cancelled
1925         BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
1926         {
1927             const CAlert& alert = item.second;
1928             if (alert.Cancels(*this))
1929             {
1930                 printf("alert already cancelled by %d\n", alert.nID);
1931                 return false;
1932             }
1933         }
1934
1935         // Add to mapAlerts
1936         mapAlerts.insert(make_pair(GetHash(), *this));
1937     }
1938
1939     printf("accepted alert %d, AppliesToMe()=%d\n", nID, AppliesToMe());
1940     MainFrameRepaint();
1941     return true;
1942 }
1943
1944
1945
1946
1947
1948
1949
1950
1951 //////////////////////////////////////////////////////////////////////////////
1952 //
1953 // Messages
1954 //
1955
1956
1957 bool static AlreadyHave(CTxDB& txdb, const CInv& inv)
1958 {
1959     switch (inv.type)
1960     {
1961     case MSG_TX:    return mapTransactions.count(inv.hash) || mapOrphanTransactions.count(inv.hash) || txdb.ContainsTx(inv.hash);
1962     case MSG_BLOCK: return mapBlockIndex.count(inv.hash) || mapOrphanBlocks.count(inv.hash);
1963     }
1964     // Don't know what it is, just say we already got one
1965     return true;
1966 }
1967
1968
1969
1970
1971 // The message start string is designed to be unlikely to occur in normal data.
1972 // The characters are rarely used upper ascii, not valid as UTF-8, and produce
1973 // a large 4-byte int at any alignment.
1974 unsigned char pchMessageStart[4] = { 0xf9, 0xbe, 0xb4, 0xd9 };
1975
1976
1977 bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
1978 {
1979     static map<CService, vector<unsigned char> > mapReuseKey;
1980     RandAddSeedPerfmon();
1981     if (fDebug) {
1982         printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
1983         printf("received: %s (%d bytes)\n", strCommand.c_str(), vRecv.size());
1984     }
1985     if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
1986     {
1987         printf("dropmessagestest DROPPING RECV MESSAGE\n");
1988         return true;
1989     }
1990
1991
1992
1993
1994
1995     if (strCommand == "version")
1996     {
1997         // Each connection can only send one version message
1998         if (pfrom->nVersion != 0)
1999         {
2000             pfrom->Misbehaving(1);
2001             return false;
2002         }
2003
2004         int64 nTime;
2005         CAddress addrMe;
2006         CAddress addrFrom;
2007         uint64 nNonce = 1;
2008         vRecv >> pfrom->nVersion >> pfrom->nServices >> nTime >> addrMe;
2009         if (pfrom->nVersion == 10300)
2010             pfrom->nVersion = 300;
2011         if (pfrom->nVersion >= 106 && !vRecv.empty())
2012             vRecv >> addrFrom >> nNonce;
2013         if (pfrom->nVersion >= 106 && !vRecv.empty())
2014             vRecv >> pfrom->strSubVer;
2015         if (pfrom->nVersion >= 209 && !vRecv.empty())
2016             vRecv >> pfrom->nStartingHeight;
2017
2018         if (pfrom->nVersion == 0)
2019             return false;
2020
2021         // Disconnect if we connected to ourself
2022         if (nNonce == nLocalHostNonce && nNonce > 1)
2023         {
2024             printf("connected to self at %s, disconnecting\n", pfrom->addr.ToString().c_str());
2025             pfrom->fDisconnect = true;
2026             return true;
2027         }
2028
2029         // Be shy and don't send version until we hear
2030         if (pfrom->fInbound)
2031             pfrom->PushVersion();
2032
2033         pfrom->fClient = !(pfrom->nServices & NODE_NETWORK);
2034
2035         AddTimeData(pfrom->addr, nTime);
2036
2037         // Change version
2038         if (pfrom->nVersion >= 209)
2039             pfrom->PushMessage("verack");
2040         pfrom->vSend.SetVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
2041         if (pfrom->nVersion < 209)
2042             pfrom->vRecv.SetVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
2043
2044         if (!pfrom->fInbound)
2045         {
2046             // Advertise our address
2047             if (addrLocalHost.IsRoutable() && !fUseProxy)
2048             {
2049                 CAddress addr(addrLocalHost);
2050                 addr.nTime = GetAdjustedTime();
2051                 pfrom->PushAddress(addr);
2052             }
2053
2054             // Get recent addresses
2055             if (pfrom->nVersion >= 31402 || mapAddresses.size() < 1000)
2056             {
2057                 pfrom->PushMessage("getaddr");
2058                 pfrom->fGetAddr = true;
2059             }
2060         }
2061
2062         // Ask the first connected node for block updates
2063         static int nAskedForBlocks = 0;
2064         if (!pfrom->fClient &&
2065             (pfrom->nVersion < 32000 || pfrom->nVersion >= 32400) &&
2066              (nAskedForBlocks < 1 || vNodes.size() <= 1))
2067         {
2068             nAskedForBlocks++;
2069             pfrom->PushGetBlocks(pindexBest, uint256(0));
2070         }
2071
2072         // Relay alerts
2073         CRITICAL_BLOCK(cs_mapAlerts)
2074             BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
2075                 item.second.RelayTo(pfrom);
2076
2077         pfrom->fSuccessfullyConnected = true;
2078
2079         printf("version message: version %d, blocks=%d\n", pfrom->nVersion, pfrom->nStartingHeight);
2080
2081         cPeerBlockCounts.input(pfrom->nStartingHeight);
2082     }
2083
2084
2085     else if (pfrom->nVersion == 0)
2086     {
2087         // Must have a version message before anything else
2088         pfrom->Misbehaving(1);
2089         return false;
2090     }
2091
2092
2093     else if (strCommand == "verack")
2094     {
2095         pfrom->vRecv.SetVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
2096     }
2097
2098
2099     else if (strCommand == "addr")
2100     {
2101         vector<CAddress> vAddr;
2102         vRecv >> vAddr;
2103
2104         // Don't want addr from older versions unless seeding
2105         if (pfrom->nVersion < 209)
2106             return true;
2107         if (pfrom->nVersion < 31402 && mapAddresses.size() > 1000)
2108             return true;
2109         if (vAddr.size() > 1000)
2110         {
2111             pfrom->Misbehaving(20);
2112             return error("message addr size() = %d", vAddr.size());
2113         }
2114
2115         // Store the new addresses
2116         CAddrDB addrDB;
2117         addrDB.TxnBegin();
2118         int64 nNow = GetAdjustedTime();
2119         int64 nSince = nNow - 10 * 60;
2120         BOOST_FOREACH(CAddress& addr, vAddr)
2121         {
2122             if (fShutdown)
2123                 return true;
2124             // ignore IPv6 for now, since it isn't implemented anyway
2125             if (!addr.IsIPv4())
2126                 continue;
2127             if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60)
2128                 addr.nTime = nNow - 5 * 24 * 60 * 60;
2129             AddAddress(addr, 2 * 60 * 60, &addrDB);
2130             pfrom->AddAddressKnown(addr);
2131             if (addr.nTime > nSince && !pfrom->fGetAddr && vAddr.size() <= 10 && addr.IsRoutable())
2132             {
2133                 // Relay to a limited number of other nodes
2134                 CRITICAL_BLOCK(cs_vNodes)
2135                 {
2136                     // Use deterministic randomness to send to the same nodes for 24 hours
2137                     // at a time so the setAddrKnowns of the chosen nodes prevent repeats
2138                     static uint256 hashSalt;
2139                     if (hashSalt == 0)
2140                         RAND_bytes((unsigned char*)&hashSalt, sizeof(hashSalt));
2141                     int64 hashAddr = addr.GetHash();
2142                     uint256 hashRand = hashSalt ^ (hashAddr<<32) ^ ((GetTime()+hashAddr)/(24*60*60));
2143                     hashRand = Hash(BEGIN(hashRand), END(hashRand));
2144                     multimap<uint256, CNode*> mapMix;
2145                     BOOST_FOREACH(CNode* pnode, vNodes)
2146                     {
2147                         if (pnode->nVersion < 31402)
2148                             continue;
2149                         unsigned int nPointer;
2150                         memcpy(&nPointer, &pnode, sizeof(nPointer));
2151                         uint256 hashKey = hashRand ^ nPointer;
2152                         hashKey = Hash(BEGIN(hashKey), END(hashKey));
2153                         mapMix.insert(make_pair(hashKey, pnode));
2154                     }
2155                     int nRelayNodes = 2;
2156                     for (multimap<uint256, CNode*>::iterator mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)
2157                         ((*mi).second)->PushAddress(addr);
2158                 }
2159             }
2160         }
2161         addrDB.TxnCommit();  // Save addresses (it's ok if this fails)
2162         if (vAddr.size() < 1000)
2163             pfrom->fGetAddr = false;
2164     }
2165
2166
2167     else if (strCommand == "inv")
2168     {
2169         vector<CInv> vInv;
2170         vRecv >> vInv;
2171         if (vInv.size() > 50000)
2172         {
2173             pfrom->Misbehaving(20);
2174             return error("message inv size() = %d", vInv.size());
2175         }
2176
2177         CTxDB txdb("r");
2178         BOOST_FOREACH(const CInv& inv, vInv)
2179         {
2180             if (fShutdown)
2181                 return true;
2182             pfrom->AddInventoryKnown(inv);
2183
2184             bool fAlreadyHave = AlreadyHave(txdb, inv);
2185             if (fDebug)
2186                 printf("  got inventory: %s  %s\n", inv.ToString().c_str(), fAlreadyHave ? "have" : "new");
2187
2188             if (!fAlreadyHave)
2189                 pfrom->AskFor(inv);
2190             else if (inv.type == MSG_BLOCK && mapOrphanBlocks.count(inv.hash))
2191                 pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(mapOrphanBlocks[inv.hash]));
2192
2193             // Track requests for our stuff
2194             Inventory(inv.hash);
2195         }
2196     }
2197
2198
2199     else if (strCommand == "getdata")
2200     {
2201         vector<CInv> vInv;
2202         vRecv >> vInv;
2203         if (vInv.size() > 50000)
2204         {
2205             pfrom->Misbehaving(20);
2206             return error("message getdata size() = %d", vInv.size());
2207         }
2208
2209         BOOST_FOREACH(const CInv& inv, vInv)
2210         {
2211             if (fShutdown)
2212                 return true;
2213             printf("received getdata for: %s\n", inv.ToString().c_str());
2214
2215             if (inv.type == MSG_BLOCK)
2216             {
2217                 // Send block from disk
2218                 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(inv.hash);
2219                 if (mi != mapBlockIndex.end())
2220                 {
2221                     CBlock block;
2222                     block.ReadFromDisk((*mi).second);
2223                     pfrom->PushMessage("block", block);
2224
2225                     // Trigger them to send a getblocks request for the next batch of inventory
2226                     if (inv.hash == pfrom->hashContinue)
2227                     {
2228                         // Bypass PushInventory, this must send even if redundant,
2229                         // and we want it right after the last block so they don't
2230                         // wait for other stuff first.
2231                         vector<CInv> vInv;
2232                         vInv.push_back(CInv(MSG_BLOCK, hashBestChain));
2233                         pfrom->PushMessage("inv", vInv);
2234                         pfrom->hashContinue = 0;
2235                     }
2236                 }
2237             }
2238             else if (inv.IsKnownType())
2239             {
2240                 // Send stream from relay memory
2241                 CRITICAL_BLOCK(cs_mapRelay)
2242                 {
2243                     map<CInv, CDataStream>::iterator mi = mapRelay.find(inv);
2244                     if (mi != mapRelay.end())
2245                         pfrom->PushMessage(inv.GetCommand(), (*mi).second);
2246                 }
2247             }
2248
2249             // Track requests for our stuff
2250             Inventory(inv.hash);
2251         }
2252     }
2253
2254
2255     else if (strCommand == "getblocks")
2256     {
2257         CBlockLocator locator;
2258         uint256 hashStop;
2259         vRecv >> locator >> hashStop;
2260
2261         // Find the last block the caller has in the main chain
2262         CBlockIndex* pindex = locator.GetBlockIndex();
2263
2264         // Send the rest of the chain
2265         if (pindex)
2266             pindex = pindex->pnext;
2267         int nLimit = 500 + locator.GetDistanceBack();
2268         unsigned int nBytes = 0;
2269         printf("getblocks %d to %s limit %d\n", (pindex ? pindex->nHeight : -1), hashStop.ToString().substr(0,20).c_str(), nLimit);
2270         for (; pindex; pindex = pindex->pnext)
2271         {
2272             if (pindex->GetBlockHash() == hashStop)
2273             {
2274                 printf("  getblocks stopping at %d %s (%u bytes)\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,20).c_str(), nBytes);
2275                 break;
2276             }
2277             pfrom->PushInventory(CInv(MSG_BLOCK, pindex->GetBlockHash()));
2278             CBlock block;
2279             block.ReadFromDisk(pindex, true);
2280             nBytes += block.GetSerializeSize(SER_NETWORK);
2281             if (--nLimit <= 0 || nBytes >= SendBufferSize()/2)
2282             {
2283                 // When this block is requested, we'll send an inv that'll make them
2284                 // getblocks the next batch of inventory.
2285                 printf("  getblocks stopping at limit %d %s (%u bytes)\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,20).c_str(), nBytes);
2286                 pfrom->hashContinue = pindex->GetBlockHash();
2287                 break;
2288             }
2289         }
2290     }
2291
2292
2293     else if (strCommand == "getheaders")
2294     {
2295         CBlockLocator locator;
2296         uint256 hashStop;
2297         vRecv >> locator >> hashStop;
2298
2299         CBlockIndex* pindex = NULL;
2300         if (locator.IsNull())
2301         {
2302             // If locator is null, return the hashStop block
2303             map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashStop);
2304             if (mi == mapBlockIndex.end())
2305                 return true;
2306             pindex = (*mi).second;
2307         }
2308         else
2309         {
2310             // Find the last block the caller has in the main chain
2311             pindex = locator.GetBlockIndex();
2312             if (pindex)
2313                 pindex = pindex->pnext;
2314         }
2315
2316         vector<CBlock> vHeaders;
2317         int nLimit = 2000 + locator.GetDistanceBack();
2318         printf("getheaders %d to %s limit %d\n", (pindex ? pindex->nHeight : -1), hashStop.ToString().substr(0,20).c_str(), nLimit);
2319         for (; pindex; pindex = pindex->pnext)
2320         {
2321             vHeaders.push_back(pindex->GetBlockHeader());
2322             if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
2323                 break;
2324         }
2325         pfrom->PushMessage("headers", vHeaders);
2326     }
2327
2328
2329     else if (strCommand == "tx")
2330     {
2331         vector<uint256> vWorkQueue;
2332         CDataStream vMsg(vRecv);
2333         CTransaction tx;
2334         vRecv >> tx;
2335
2336         CInv inv(MSG_TX, tx.GetHash());
2337         pfrom->AddInventoryKnown(inv);
2338
2339         bool fMissingInputs = false;
2340         if (tx.AcceptToMemoryPool(true, &fMissingInputs))
2341         {
2342             SyncWithWallets(tx, NULL, true);
2343             RelayMessage(inv, vMsg);
2344             mapAlreadyAskedFor.erase(inv);
2345             vWorkQueue.push_back(inv.hash);
2346
2347             // Recursively process any orphan transactions that depended on this one
2348             for (int i = 0; i < vWorkQueue.size(); i++)
2349             {
2350                 uint256 hashPrev = vWorkQueue[i];
2351                 for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(hashPrev);
2352                      mi != mapOrphanTransactionsByPrev.upper_bound(hashPrev);
2353                      ++mi)
2354                 {
2355                     const CDataStream& vMsg = *((*mi).second);
2356                     CTransaction tx;
2357                     CDataStream(vMsg) >> tx;
2358                     CInv inv(MSG_TX, tx.GetHash());
2359
2360                     if (tx.AcceptToMemoryPool(true))
2361                     {
2362                         printf("   accepted orphan tx %s\n", inv.hash.ToString().substr(0,10).c_str());
2363                         SyncWithWallets(tx, NULL, true);
2364                         RelayMessage(inv, vMsg);
2365                         mapAlreadyAskedFor.erase(inv);
2366                         vWorkQueue.push_back(inv.hash);
2367                     }
2368                 }
2369             }
2370
2371             BOOST_FOREACH(uint256 hash, vWorkQueue)
2372                 EraseOrphanTx(hash);
2373         }
2374         else if (fMissingInputs)
2375         {
2376             printf("storing orphan tx %s\n", inv.hash.ToString().substr(0,10).c_str());
2377             AddOrphanTx(vMsg);
2378         }
2379         if (tx.nDoS) pfrom->Misbehaving(tx.nDoS);
2380     }
2381
2382
2383     else if (strCommand == "block")
2384     {
2385         CBlock block;
2386         vRecv >> block;
2387
2388         printf("received block %s\n", block.GetHash().ToString().substr(0,20).c_str());
2389         // block.print();
2390
2391         CInv inv(MSG_BLOCK, block.GetHash());
2392         pfrom->AddInventoryKnown(inv);
2393
2394         if (ProcessBlock(pfrom, &block))
2395             mapAlreadyAskedFor.erase(inv);
2396         if (block.nDoS) pfrom->Misbehaving(block.nDoS);
2397     }
2398
2399
2400     else if (strCommand == "getaddr")
2401     {
2402         // Nodes rebroadcast an addr every 24 hours
2403         pfrom->vAddrToSend.clear();
2404         int64 nSince = GetAdjustedTime() - 3 * 60 * 60; // in the last 3 hours
2405         CRITICAL_BLOCK(cs_mapAddresses)
2406         {
2407             unsigned int nCount = 0;
2408             BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
2409             {
2410                 const CAddress& addr = item.second;
2411                 if (addr.nTime > nSince)
2412                     nCount++;
2413             }
2414             BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
2415             {
2416                 const CAddress& addr = item.second;
2417                 if (addr.nTime > nSince && GetRand(nCount) < 2500)
2418                     pfrom->PushAddress(addr);
2419             }
2420         }
2421     }
2422
2423
2424     else if (strCommand == "checkorder")
2425     {
2426         uint256 hashReply;
2427         vRecv >> hashReply;
2428
2429         if (!GetBoolArg("-allowreceivebyip"))
2430         {
2431             pfrom->PushMessage("reply", hashReply, (int)2, string(""));
2432             return true;
2433         }
2434
2435         CWalletTx order;
2436         vRecv >> order;
2437
2438         /// we have a chance to check the order here
2439
2440         // Keep giving the same key to the same ip until they use it
2441         if (!mapReuseKey.count(pfrom->addr))
2442             pwalletMain->GetKeyFromPool(mapReuseKey[pfrom->addr], true);
2443
2444         // Send back approval of order and pubkey to use
2445         CScript scriptPubKey;
2446         scriptPubKey << mapReuseKey[pfrom->addr] << OP_CHECKSIG;
2447         pfrom->PushMessage("reply", hashReply, (int)0, scriptPubKey);
2448     }
2449
2450
2451     else if (strCommand == "reply")
2452     {
2453         uint256 hashReply;
2454         vRecv >> hashReply;
2455
2456         CRequestTracker tracker;
2457         CRITICAL_BLOCK(pfrom->cs_mapRequests)
2458         {
2459             map<uint256, CRequestTracker>::iterator mi = pfrom->mapRequests.find(hashReply);
2460             if (mi != pfrom->mapRequests.end())
2461             {
2462                 tracker = (*mi).second;
2463                 pfrom->mapRequests.erase(mi);
2464             }
2465         }
2466         if (!tracker.IsNull())
2467             tracker.fn(tracker.param1, vRecv);
2468     }
2469
2470
2471     else if (strCommand == "ping")
2472     {
2473     }
2474
2475
2476     else if (strCommand == "alert")
2477     {
2478         CAlert alert;
2479         vRecv >> alert;
2480
2481         if (alert.ProcessAlert())
2482         {
2483             // Relay
2484             pfrom->setKnown.insert(alert.GetHash());
2485             CRITICAL_BLOCK(cs_vNodes)
2486                 BOOST_FOREACH(CNode* pnode, vNodes)
2487                     alert.RelayTo(pnode);
2488         }
2489     }
2490
2491
2492     else
2493     {
2494         // Ignore unknown commands for extensibility
2495     }
2496
2497
2498     // Update the last seen time for this node's address
2499     if (pfrom->fNetworkNode)
2500         if (strCommand == "version" || strCommand == "addr" || strCommand == "inv" || strCommand == "getdata" || strCommand == "ping")
2501             AddressCurrentlyConnected(pfrom->addr);
2502
2503
2504     return true;
2505 }
2506
2507 bool ProcessMessages(CNode* pfrom)
2508 {
2509     CDataStream& vRecv = pfrom->vRecv;
2510     if (vRecv.empty())
2511         return true;
2512     //if (fDebug)
2513     //    printf("ProcessMessages(%u bytes)\n", vRecv.size());
2514
2515     //
2516     // Message format
2517     //  (4) message start
2518     //  (12) command
2519     //  (4) size
2520     //  (4) checksum
2521     //  (x) data
2522     //
2523
2524     loop
2525     {
2526         // Scan for message start
2527         CDataStream::iterator pstart = search(vRecv.begin(), vRecv.end(), BEGIN(pchMessageStart), END(pchMessageStart));
2528         int nHeaderSize = vRecv.GetSerializeSize(CMessageHeader());
2529         if (vRecv.end() - pstart < nHeaderSize)
2530         {
2531             if (vRecv.size() > nHeaderSize)
2532             {
2533                 printf("\n\nPROCESSMESSAGE MESSAGESTART NOT FOUND\n\n");
2534                 vRecv.erase(vRecv.begin(), vRecv.end() - nHeaderSize);
2535             }
2536             break;
2537         }
2538         if (pstart - vRecv.begin() > 0)
2539             printf("\n\nPROCESSMESSAGE SKIPPED %d BYTES\n\n", pstart - vRecv.begin());
2540         vRecv.erase(vRecv.begin(), pstart);
2541
2542         // Read header
2543         vector<char> vHeaderSave(vRecv.begin(), vRecv.begin() + nHeaderSize);
2544         CMessageHeader hdr;
2545         vRecv >> hdr;
2546         if (!hdr.IsValid())
2547         {
2548             printf("\n\nPROCESSMESSAGE: ERRORS IN HEADER %s\n\n\n", hdr.GetCommand().c_str());
2549             continue;
2550         }
2551         string strCommand = hdr.GetCommand();
2552
2553         // Message size
2554         unsigned int nMessageSize = hdr.nMessageSize;
2555         if (nMessageSize > MAX_SIZE)
2556         {
2557             printf("ProcessMessage(%s, %u bytes) : nMessageSize > MAX_SIZE\n", strCommand.c_str(), nMessageSize);
2558             continue;
2559         }
2560         if (nMessageSize > vRecv.size())
2561         {
2562             // Rewind and wait for rest of message
2563             vRecv.insert(vRecv.begin(), vHeaderSave.begin(), vHeaderSave.end());
2564             break;
2565         }
2566
2567         // Checksum
2568         if (vRecv.GetVersion() >= 209)
2569         {
2570             uint256 hash = Hash(vRecv.begin(), vRecv.begin() + nMessageSize);
2571             unsigned int nChecksum = 0;
2572             memcpy(&nChecksum, &hash, sizeof(nChecksum));
2573             if (nChecksum != hdr.nChecksum)
2574             {
2575                 printf("ProcessMessage(%s, %u bytes) : CHECKSUM ERROR nChecksum=%08x hdr.nChecksum=%08x\n",
2576                        strCommand.c_str(), nMessageSize, nChecksum, hdr.nChecksum);
2577                 continue;
2578             }
2579         }
2580
2581         // Copy message to its own buffer
2582         CDataStream vMsg(vRecv.begin(), vRecv.begin() + nMessageSize, vRecv.nType, vRecv.nVersion);
2583         vRecv.ignore(nMessageSize);
2584
2585         // Process message
2586         bool fRet = false;
2587         try
2588         {
2589             CRITICAL_BLOCK(cs_main)
2590                 fRet = ProcessMessage(pfrom, strCommand, vMsg);
2591             if (fShutdown)
2592                 return true;
2593         }
2594         catch (std::ios_base::failure& e)
2595         {
2596             if (strstr(e.what(), "end of data"))
2597             {
2598                 // Allow exceptions from underlength message on vRecv
2599                 printf("ProcessMessage(%s, %u bytes) : Exception '%s' caught, normally caused by a message being shorter than its stated length\n", strCommand.c_str(), nMessageSize, e.what());
2600             }
2601             else if (strstr(e.what(), "size too large"))
2602             {
2603                 // Allow exceptions from overlong size
2604                 printf("ProcessMessage(%s, %u bytes) : Exception '%s' caught\n", strCommand.c_str(), nMessageSize, e.what());
2605             }
2606             else
2607             {
2608                 PrintExceptionContinue(&e, "ProcessMessage()");
2609             }
2610         }
2611         catch (std::exception& e) {
2612             PrintExceptionContinue(&e, "ProcessMessage()");
2613         } catch (...) {
2614             PrintExceptionContinue(NULL, "ProcessMessage()");
2615         }
2616
2617         if (!fRet)
2618             printf("ProcessMessage(%s, %u bytes) FAILED\n", strCommand.c_str(), nMessageSize);
2619     }
2620
2621     vRecv.Compact();
2622     return true;
2623 }
2624
2625
2626 bool SendMessages(CNode* pto, bool fSendTrickle)
2627 {
2628     CRITICAL_BLOCK(cs_main)
2629     {
2630         // Don't send anything until we get their version message
2631         if (pto->nVersion == 0)
2632             return true;
2633
2634         // Keep-alive ping
2635         if (pto->nLastSend && GetTime() - pto->nLastSend > 30 * 60 && pto->vSend.empty())
2636             pto->PushMessage("ping");
2637
2638         // Resend wallet transactions that haven't gotten in a block yet
2639         ResendWalletTransactions();
2640
2641         // Address refresh broadcast
2642         static int64 nLastRebroadcast;
2643         if (GetTime() - nLastRebroadcast > 24 * 60 * 60)
2644         {
2645             nLastRebroadcast = GetTime();
2646             CRITICAL_BLOCK(cs_vNodes)
2647             {
2648                 BOOST_FOREACH(CNode* pnode, vNodes)
2649                 {
2650                     // Periodically clear setAddrKnown to allow refresh broadcasts
2651                     pnode->setAddrKnown.clear();
2652
2653                     // Rebroadcast our address
2654                     if (addrLocalHost.IsRoutable() && !fUseProxy)
2655                     {
2656                         CAddress addr(addrLocalHost);
2657                         addr.nTime = GetAdjustedTime();
2658                         pnode->PushAddress(addr);
2659                     }
2660                 }
2661             }
2662         }
2663
2664         // Clear out old addresses periodically so it's not too much work at once
2665         static int64 nLastClear;
2666         if (nLastClear == 0)
2667             nLastClear = GetTime();
2668         if (GetTime() - nLastClear > 10 * 60 && vNodes.size() >= 3)
2669         {
2670             nLastClear = GetTime();
2671             CRITICAL_BLOCK(cs_mapAddresses)
2672             {
2673                 CAddrDB addrdb;
2674                 int64 nSince = GetAdjustedTime() - 14 * 24 * 60 * 60;
2675                 for (map<vector<unsigned char>, CAddress>::iterator mi = mapAddresses.begin();
2676                      mi != mapAddresses.end();)
2677                 {
2678                     const CAddress& addr = (*mi).second;
2679                     if (addr.nTime < nSince)
2680                     {
2681                         if (mapAddresses.size() < 1000 || GetTime() > nLastClear + 20)
2682                             break;
2683                         addrdb.EraseAddress(addr);
2684                         mapAddresses.erase(mi++);
2685                     }
2686                     else
2687                         mi++;
2688                 }
2689             }
2690         }
2691
2692
2693         //
2694         // Message: addr
2695         //
2696         if (fSendTrickle)
2697         {
2698             vector<CAddress> vAddr;
2699             vAddr.reserve(pto->vAddrToSend.size());
2700             BOOST_FOREACH(const CAddress& addr, pto->vAddrToSend)
2701             {
2702                 // returns true if wasn't already contained in the set
2703                 if (pto->setAddrKnown.insert(addr).second)
2704                 {
2705                     vAddr.push_back(addr);
2706                     // receiver rejects addr messages larger than 1000
2707                     if (vAddr.size() >= 1000)
2708                     {
2709                         pto->PushMessage("addr", vAddr);
2710                         vAddr.clear();
2711                     }
2712                 }
2713             }
2714             pto->vAddrToSend.clear();
2715             if (!vAddr.empty())
2716                 pto->PushMessage("addr", vAddr);
2717         }
2718
2719
2720         //
2721         // Message: inventory
2722         //
2723         vector<CInv> vInv;
2724         vector<CInv> vInvWait;
2725         CRITICAL_BLOCK(pto->cs_inventory)
2726         {
2727             vInv.reserve(pto->vInventoryToSend.size());
2728             vInvWait.reserve(pto->vInventoryToSend.size());
2729             BOOST_FOREACH(const CInv& inv, pto->vInventoryToSend)
2730             {
2731                 if (pto->setInventoryKnown.count(inv))
2732                     continue;
2733
2734                 // trickle out tx inv to protect privacy
2735                 if (inv.type == MSG_TX && !fSendTrickle)
2736                 {
2737                     // 1/4 of tx invs blast to all immediately
2738                     static uint256 hashSalt;
2739                     if (hashSalt == 0)
2740                         RAND_bytes((unsigned char*)&hashSalt, sizeof(hashSalt));
2741                     uint256 hashRand = inv.hash ^ hashSalt;
2742                     hashRand = Hash(BEGIN(hashRand), END(hashRand));
2743                     bool fTrickleWait = ((hashRand & 3) != 0);
2744
2745                     // always trickle our own transactions
2746                     if (!fTrickleWait)
2747                     {
2748                         CWalletTx wtx;
2749                         if (GetTransaction(inv.hash, wtx))
2750                             if (wtx.fFromMe)
2751                                 fTrickleWait = true;
2752                     }
2753
2754                     if (fTrickleWait)
2755                     {
2756                         vInvWait.push_back(inv);
2757                         continue;
2758                     }
2759                 }
2760
2761                 // returns true if wasn't already contained in the set
2762                 if (pto->setInventoryKnown.insert(inv).second)
2763                 {
2764                     vInv.push_back(inv);
2765                     if (vInv.size() >= 1000)
2766                     {
2767                         pto->PushMessage("inv", vInv);
2768                         vInv.clear();
2769                     }
2770                 }
2771             }
2772             pto->vInventoryToSend = vInvWait;
2773         }
2774         if (!vInv.empty())
2775             pto->PushMessage("inv", vInv);
2776
2777
2778         //
2779         // Message: getdata
2780         //
2781         vector<CInv> vGetData;
2782         int64 nNow = GetTime() * 1000000;
2783         CTxDB txdb("r");
2784         while (!pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
2785         {
2786             const CInv& inv = (*pto->mapAskFor.begin()).second;
2787             if (!AlreadyHave(txdb, inv))
2788             {
2789                 printf("sending getdata: %s\n", inv.ToString().c_str());
2790                 vGetData.push_back(inv);
2791                 if (vGetData.size() >= 1000)
2792                 {
2793                     pto->PushMessage("getdata", vGetData);
2794                     vGetData.clear();
2795                 }
2796             }
2797             mapAlreadyAskedFor[inv] = nNow;
2798             pto->mapAskFor.erase(pto->mapAskFor.begin());
2799         }
2800         if (!vGetData.empty())
2801             pto->PushMessage("getdata", vGetData);
2802
2803     }
2804     return true;
2805 }
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820 //////////////////////////////////////////////////////////////////////////////
2821 //
2822 // BitcoinMiner
2823 //
2824
2825 int static FormatHashBlocks(void* pbuffer, unsigned int len)
2826 {
2827     unsigned char* pdata = (unsigned char*)pbuffer;
2828     unsigned int blocks = 1 + ((len + 8) / 64);
2829     unsigned char* pend = pdata + 64 * blocks;
2830     memset(pdata + len, 0, 64 * blocks - len);
2831     pdata[len] = 0x80;
2832     unsigned int bits = len * 8;
2833     pend[-1] = (bits >> 0) & 0xff;
2834     pend[-2] = (bits >> 8) & 0xff;
2835     pend[-3] = (bits >> 16) & 0xff;
2836     pend[-4] = (bits >> 24) & 0xff;
2837     return blocks;
2838 }
2839
2840 static const unsigned int pSHA256InitState[8] =
2841 {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
2842
2843 void SHA256Transform(void* pstate, void* pinput, const void* pinit)
2844 {
2845     SHA256_CTX ctx;
2846     unsigned char data[64];
2847
2848     SHA256_Init(&ctx);
2849
2850     for (int i = 0; i < 16; i++)
2851         ((uint32_t*)data)[i] = ByteReverse(((uint32_t*)pinput)[i]);
2852
2853     for (int i = 0; i < 8; i++)
2854         ctx.h[i] = ((uint32_t*)pinit)[i];
2855
2856     SHA256_Update(&ctx, data, sizeof(data));
2857     for (int i = 0; i < 8; i++)
2858         ((uint32_t*)pstate)[i] = ctx.h[i];
2859 }
2860
2861 //
2862 // ScanHash scans nonces looking for a hash with at least some zero bits.
2863 // It operates on big endian data.  Caller does the byte reversing.
2864 // All input buffers are 16-byte aligned.  nNonce is usually preserved
2865 // between calls, but periodically or if nNonce is 0xffff0000 or above,
2866 // the block is rebuilt and nNonce starts over at zero.
2867 //
2868 unsigned int static ScanHash_CryptoPP(char* pmidstate, char* pdata, char* phash1, char* phash, unsigned int& nHashesDone)
2869 {
2870     unsigned int& nNonce = *(unsigned int*)(pdata + 12);
2871     for (;;)
2872     {
2873         // Crypto++ SHA-256
2874         // Hash pdata using pmidstate as the starting state into
2875         // preformatted buffer phash1, then hash phash1 into phash
2876         nNonce++;
2877         SHA256Transform(phash1, pdata, pmidstate);
2878         SHA256Transform(phash, phash1, pSHA256InitState);
2879
2880         // Return the nonce if the hash has at least some zero bits,
2881         // caller will check if it has enough to reach the target
2882         if (((unsigned short*)phash)[14] == 0)
2883             return nNonce;
2884
2885         // If nothing found after trying for a while, return -1
2886         if ((nNonce & 0xffff) == 0)
2887         {
2888             nHashesDone = 0xffff+1;
2889             return -1;
2890         }
2891     }
2892 }
2893
2894 // Some explaining would be appreciated
2895 class COrphan
2896 {
2897 public:
2898     CTransaction* ptx;
2899     set<uint256> setDependsOn;
2900     double dPriority;
2901
2902     COrphan(CTransaction* ptxIn)
2903     {
2904         ptx = ptxIn;
2905         dPriority = 0;
2906     }
2907
2908     void print() const
2909     {
2910         printf("COrphan(hash=%s, dPriority=%.1f)\n", ptx->GetHash().ToString().substr(0,10).c_str(), dPriority);
2911         BOOST_FOREACH(uint256 hash, setDependsOn)
2912             printf("   setDependsOn %s\n", hash.ToString().substr(0,10).c_str());
2913     }
2914 };
2915
2916
2917 uint64 nLastBlockTx = 0;
2918 uint64 nLastBlockSize = 0;
2919
2920 CBlock* CreateNewBlock(CReserveKey& reservekey)
2921 {
2922     CBlockIndex* pindexPrev = pindexBest;
2923
2924     // Create new block
2925     auto_ptr<CBlock> pblock(new CBlock());
2926     if (!pblock.get())
2927         return NULL;
2928
2929     // Create coinbase tx
2930     CTransaction txNew;
2931     txNew.vin.resize(1);
2932     txNew.vin[0].prevout.SetNull();
2933     txNew.vout.resize(1);
2934     txNew.vout[0].scriptPubKey << reservekey.GetReservedKey() << OP_CHECKSIG;
2935
2936     // Add our coinbase tx as first transaction
2937     pblock->vtx.push_back(txNew);
2938
2939     // Collect memory pool transactions into the block
2940     int64 nFees = 0;
2941     CRITICAL_BLOCK(cs_main)
2942     CRITICAL_BLOCK(cs_mapTransactions)
2943     {
2944         CTxDB txdb("r");
2945
2946         // Priority order to process transactions
2947         list<COrphan> vOrphan; // list memory doesn't move
2948         map<uint256, vector<COrphan*> > mapDependers;
2949         multimap<double, CTransaction*> mapPriority;
2950         for (map<uint256, CTransaction>::iterator mi = mapTransactions.begin(); mi != mapTransactions.end(); ++mi)
2951         {
2952             CTransaction& tx = (*mi).second;
2953             if (tx.IsCoinBase() || !tx.IsFinal())
2954                 continue;
2955
2956             COrphan* porphan = NULL;
2957             double dPriority = 0;
2958             BOOST_FOREACH(const CTxIn& txin, tx.vin)
2959             {
2960                 // Read prev transaction
2961                 CTransaction txPrev;
2962                 CTxIndex txindex;
2963                 if (!txPrev.ReadFromDisk(txdb, txin.prevout, txindex))
2964                 {
2965                     // Has to wait for dependencies
2966                     if (!porphan)
2967                     {
2968                         // Use list for automatic deletion
2969                         vOrphan.push_back(COrphan(&tx));
2970                         porphan = &vOrphan.back();
2971                     }
2972                     mapDependers[txin.prevout.hash].push_back(porphan);
2973                     porphan->setDependsOn.insert(txin.prevout.hash);
2974                     continue;
2975                 }
2976                 int64 nValueIn = txPrev.vout[txin.prevout.n].nValue;
2977
2978                 // Read block header
2979                 int nConf = txindex.GetDepthInMainChain();
2980
2981                 dPriority += (double)nValueIn * nConf;
2982
2983                 if (fDebug && GetBoolArg("-printpriority"))
2984                     printf("priority     nValueIn=%-12I64d nConf=%-5d dPriority=%-20.1f\n", nValueIn, nConf, dPriority);
2985             }
2986
2987             // Priority is sum(valuein * age) / txsize
2988             dPriority /= ::GetSerializeSize(tx, SER_NETWORK);
2989
2990             if (porphan)
2991                 porphan->dPriority = dPriority;
2992             else
2993                 mapPriority.insert(make_pair(-dPriority, &(*mi).second));
2994
2995             if (fDebug && GetBoolArg("-printpriority"))
2996             {
2997                 printf("priority %-20.1f %s\n%s", dPriority, tx.GetHash().ToString().substr(0,10).c_str(), tx.ToString().c_str());
2998                 if (porphan)
2999                     porphan->print();
3000                 printf("\n");
3001             }
3002         }
3003
3004         // Collect transactions into block
3005         map<uint256, CTxIndex> mapTestPool;
3006         uint64 nBlockSize = 1000;
3007         uint64 nBlockTx = 0;
3008         int nBlockSigOps1 = 100; // pre-0.6 count of sigOps
3009         int nBlockSigOps2 = 100; // post-0.6 count of sigOps
3010         while (!mapPriority.empty())
3011         {
3012             // Take highest priority transaction off priority queue
3013             double dPriority = -(*mapPriority.begin()).first;
3014             CTransaction& tx = *(*mapPriority.begin()).second;
3015             mapPriority.erase(mapPriority.begin());
3016
3017             // Size limits
3018             unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK);
3019             if (nBlockSize + nTxSize >= MAX_BLOCK_SIZE_GEN)
3020                 continue;
3021
3022             // Legacy limits on sigOps:
3023             int nTxSigOps1 = tx.GetLegacySigOpCount();
3024             if (nBlockSigOps1 + nTxSigOps1 >= MAX_BLOCK_SIGOPS)
3025                 continue;
3026
3027             // Transaction fee required depends on block size
3028             bool fAllowFree = (nBlockSize + nTxSize < 4000 || CTransaction::AllowFree(dPriority));
3029             int64 nMinFee = tx.GetMinFee(nBlockSize, fAllowFree, GMF_BLOCK);
3030
3031             // Connecting shouldn't fail due to dependency on other memory pool transactions
3032             // because we're already processing them in order of dependency
3033             map<uint256, CTxIndex> mapTestPoolTmp(mapTestPool);
3034             map<uint256, pair<CTxIndex, CTransaction> > mapInputs;
3035             if (!tx.FetchInputs(txdb, mapTestPoolTmp, false, true, mapInputs))
3036                 continue;
3037
3038             int nTxSigOps2 = 0;
3039             if (!tx.ConnectInputs(mapInputs, mapTestPoolTmp, CDiskTxPos(1,1,1), pindexPrev, nFees, false, true, nTxSigOps2, nMinFee))
3040                 continue;
3041             if (nBlockSigOps2 + nTxSigOps2 >= MAX_BLOCK_SIGOPS)
3042                 continue;
3043             swap(mapTestPool, mapTestPoolTmp);
3044
3045             // Added
3046             pblock->vtx.push_back(tx);
3047             nBlockSize += nTxSize;
3048             ++nBlockTx;
3049             nBlockSigOps1 += nTxSigOps1;
3050             nBlockSigOps2 += nTxSigOps2;
3051
3052             // Add transactions that depend on this one to the priority queue
3053             uint256 hash = tx.GetHash();
3054             if (mapDependers.count(hash))
3055             {
3056                 BOOST_FOREACH(COrphan* porphan, mapDependers[hash])
3057                 {
3058                     if (!porphan->setDependsOn.empty())
3059                     {
3060                         porphan->setDependsOn.erase(hash);
3061                         if (porphan->setDependsOn.empty())
3062                             mapPriority.insert(make_pair(-porphan->dPriority, porphan->ptx));
3063                     }
3064                 }
3065             }
3066         }
3067
3068         nLastBlockTx = nBlockTx;
3069         nLastBlockSize = nBlockSize;
3070         printf("CreateNewBlock(): total size %lu\n", nBlockSize);
3071
3072     }
3073     pblock->vtx[0].vout[0].nValue = GetBlockValue(pindexPrev->nHeight+1, nFees);
3074
3075     // Fill in header
3076     pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
3077     pblock->hashMerkleRoot = pblock->BuildMerkleTree();
3078     pblock->nTime          = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
3079     pblock->nBits          = GetNextWorkRequired(pindexPrev);
3080     pblock->nNonce         = 0;
3081
3082     return pblock.release();
3083 }
3084
3085
3086 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
3087 {
3088     // Update nExtraNonce
3089     static uint256 hashPrevBlock;
3090     if (hashPrevBlock != pblock->hashPrevBlock)
3091     {
3092         nExtraNonce = 0;
3093         hashPrevBlock = pblock->hashPrevBlock;
3094     }
3095     ++nExtraNonce;
3096     pblock->vtx[0].vin[0].scriptSig = CScript() << pblock->nTime << CBigNum(nExtraNonce);
3097
3098     // Put "/P2SH/" in the coinbase so everybody can tell when
3099     // a majority of miners support it
3100     const char* pszP2SH = "/P2SH/";
3101     pblock->vtx[0].vin[0].scriptSig += CScript() << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
3102     assert(pblock->vtx[0].vin[0].scriptSig.size() <= 100);
3103
3104     pblock->hashMerkleRoot = pblock->BuildMerkleTree();
3105 }
3106
3107
3108 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1)
3109 {
3110     //
3111     // Prebuild hash buffers
3112     //
3113     struct
3114     {
3115         struct unnamed2
3116         {
3117             int nVersion;
3118             uint256 hashPrevBlock;
3119             uint256 hashMerkleRoot;
3120             unsigned int nTime;
3121             unsigned int nBits;
3122             unsigned int nNonce;
3123         }
3124         block;
3125         unsigned char pchPadding0[64];
3126         uint256 hash1;
3127         unsigned char pchPadding1[64];
3128     }
3129     tmp;
3130     memset(&tmp, 0, sizeof(tmp));
3131
3132     tmp.block.nVersion       = pblock->nVersion;
3133     tmp.block.hashPrevBlock  = pblock->hashPrevBlock;
3134     tmp.block.hashMerkleRoot = pblock->hashMerkleRoot;
3135     tmp.block.nTime          = pblock->nTime;
3136     tmp.block.nBits          = pblock->nBits;
3137     tmp.block.nNonce         = pblock->nNonce;
3138
3139     FormatHashBlocks(&tmp.block, sizeof(tmp.block));
3140     FormatHashBlocks(&tmp.hash1, sizeof(tmp.hash1));
3141
3142     // Byte swap all the input buffer
3143     for (int i = 0; i < sizeof(tmp)/4; i++)
3144         ((unsigned int*)&tmp)[i] = ByteReverse(((unsigned int*)&tmp)[i]);
3145
3146     // Precalc the first half of the first hash, which stays constant
3147     SHA256Transform(pmidstate, &tmp.block, pSHA256InitState);
3148
3149     memcpy(pdata, &tmp.block, 128);
3150     memcpy(phash1, &tmp.hash1, 64);
3151 }
3152
3153
3154 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey)
3155 {
3156     uint256 hash = pblock->GetHash();
3157     uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
3158
3159     if (hash > hashTarget)
3160         return false;
3161
3162     //// debug print
3163     printf("BitcoinMiner:\n");
3164     printf("proof-of-work found  \n  hash: %s  \ntarget: %s\n", hash.GetHex().c_str(), hashTarget.GetHex().c_str());
3165     pblock->print();
3166     printf("%s ", DateTimeStrFormat("%x %H:%M", GetTime()).c_str());
3167     printf("generated %s\n", FormatMoney(pblock->vtx[0].vout[0].nValue).c_str());
3168
3169     // Found a solution
3170     CRITICAL_BLOCK(cs_main)
3171     {
3172         if (pblock->hashPrevBlock != hashBestChain)
3173             return error("BitcoinMiner : generated block is stale");
3174
3175         // Remove key from key pool
3176         reservekey.KeepKey();
3177
3178         // Track how many getdata requests this block gets
3179         CRITICAL_BLOCK(wallet.cs_wallet)
3180             wallet.mapRequestCount[pblock->GetHash()] = 0;
3181
3182         // Process this block the same as if we had received it from another node
3183         if (!ProcessBlock(NULL, pblock))
3184             return error("BitcoinMiner : ProcessBlock, block not accepted");
3185     }
3186
3187     return true;
3188 }
3189
3190 void static ThreadBitcoinMiner(void* parg);
3191
3192 void static BitcoinMiner(CWallet *pwallet)
3193 {
3194     printf("BitcoinMiner started\n");
3195     SetThreadPriority(THREAD_PRIORITY_LOWEST);
3196
3197     // Each thread has its own key and counter
3198     CReserveKey reservekey(pwallet);
3199     unsigned int nExtraNonce = 0;
3200
3201     while (fGenerateBitcoins)
3202     {
3203         if (AffinityBugWorkaround(ThreadBitcoinMiner))
3204             return;
3205         if (fShutdown)
3206             return;
3207         while (vNodes.empty() || IsInitialBlockDownload())
3208         {
3209             Sleep(1000);
3210             if (fShutdown)
3211                 return;
3212             if (!fGenerateBitcoins)
3213                 return;
3214         }
3215
3216
3217         //
3218         // Create new block
3219         //
3220         unsigned int nTransactionsUpdatedLast = nTransactionsUpdated;
3221         CBlockIndex* pindexPrev = pindexBest;
3222
3223         auto_ptr<CBlock> pblock(CreateNewBlock(reservekey));
3224         if (!pblock.get())
3225             return;
3226         IncrementExtraNonce(pblock.get(), pindexPrev, nExtraNonce);
3227
3228         printf("Running BitcoinMiner with %d transactions in block\n", pblock->vtx.size());
3229
3230
3231         //
3232         // Prebuild hash buffers
3233         //
3234         char pmidstatebuf[32+16]; char* pmidstate = alignup<16>(pmidstatebuf);
3235         char pdatabuf[128+16];    char* pdata     = alignup<16>(pdatabuf);
3236         char phash1buf[64+16];    char* phash1    = alignup<16>(phash1buf);
3237
3238         FormatHashBuffers(pblock.get(), pmidstate, pdata, phash1);
3239
3240         unsigned int& nBlockTime = *(unsigned int*)(pdata + 64 + 4);
3241         unsigned int& nBlockNonce = *(unsigned int*)(pdata + 64 + 12);
3242
3243
3244         //
3245         // Search
3246         //
3247         int64 nStart = GetTime();
3248         uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
3249         uint256 hashbuf[2];
3250         uint256& hash = *alignup<16>(hashbuf);
3251         loop
3252         {
3253             unsigned int nHashesDone = 0;
3254             unsigned int nNonceFound;
3255
3256             // Crypto++ SHA-256
3257             nNonceFound = ScanHash_CryptoPP(pmidstate, pdata + 64, phash1,
3258                                             (char*)&hash, nHashesDone);
3259
3260             // Check if something found
3261             if (nNonceFound != -1)
3262             {
3263                 for (int i = 0; i < sizeof(hash)/4; i++)
3264                     ((unsigned int*)&hash)[i] = ByteReverse(((unsigned int*)&hash)[i]);
3265
3266                 if (hash <= hashTarget)
3267                 {
3268                     // Found a solution
3269                     pblock->nNonce = ByteReverse(nNonceFound);
3270                     assert(hash == pblock->GetHash());
3271
3272                     SetThreadPriority(THREAD_PRIORITY_NORMAL);
3273                     CheckWork(pblock.get(), *pwalletMain, reservekey);
3274                     SetThreadPriority(THREAD_PRIORITY_LOWEST);
3275                     break;
3276                 }
3277             }
3278
3279             // Meter hashes/sec
3280             static int64 nHashCounter;
3281             if (nHPSTimerStart == 0)
3282             {
3283                 nHPSTimerStart = GetTimeMillis();
3284                 nHashCounter = 0;
3285             }
3286             else
3287                 nHashCounter += nHashesDone;
3288             if (GetTimeMillis() - nHPSTimerStart > 4000)
3289             {
3290                 static CCriticalSection cs;
3291                 CRITICAL_BLOCK(cs)
3292                 {
3293                     if (GetTimeMillis() - nHPSTimerStart > 4000)
3294                     {
3295                         dHashesPerSec = 1000.0 * nHashCounter / (GetTimeMillis() - nHPSTimerStart);
3296                         nHPSTimerStart = GetTimeMillis();
3297                         nHashCounter = 0;
3298                         string strStatus = strprintf("    %.0f khash/s", dHashesPerSec/1000.0);
3299                         UIThreadCall(boost::bind(CalledSetStatusBar, strStatus, 0));
3300                         static int64 nLogTime;
3301                         if (GetTime() - nLogTime > 30 * 60)
3302                         {
3303                             nLogTime = GetTime();
3304                             printf("%s ", DateTimeStrFormat("%x %H:%M", GetTime()).c_str());
3305                             printf("hashmeter %3d CPUs %6.0f khash/s\n", vnThreadsRunning[3], dHashesPerSec/1000.0);
3306                         }
3307                     }
3308                 }
3309             }
3310
3311             // Check for stop or if block needs to be rebuilt
3312             if (fShutdown)
3313                 return;
3314             if (!fGenerateBitcoins)
3315                 return;
3316             if (fLimitProcessors && vnThreadsRunning[3] > nLimitProcessors)
3317                 return;
3318             if (vNodes.empty())
3319                 break;
3320             if (nBlockNonce >= 0xffff0000)
3321                 break;
3322             if (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60)
3323                 break;
3324             if (pindexPrev != pindexBest)
3325                 break;
3326
3327             // Update nTime every few seconds
3328             pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
3329             nBlockTime = ByteReverse(pblock->nTime);
3330         }
3331     }
3332 }
3333
3334 void static ThreadBitcoinMiner(void* parg)
3335 {
3336     CWallet* pwallet = (CWallet*)parg;
3337     try
3338     {
3339         vnThreadsRunning[3]++;
3340         BitcoinMiner(pwallet);
3341         vnThreadsRunning[3]--;
3342     }
3343     catch (std::exception& e) {
3344         vnThreadsRunning[3]--;
3345         PrintException(&e, "ThreadBitcoinMiner()");
3346     } catch (...) {
3347         vnThreadsRunning[3]--;
3348         PrintException(NULL, "ThreadBitcoinMiner()");
3349     }
3350     UIThreadCall(boost::bind(CalledSetStatusBar, "", 0));
3351     nHPSTimerStart = 0;
3352     if (vnThreadsRunning[3] == 0)
3353         dHashesPerSec = 0;
3354     printf("ThreadBitcoinMiner exiting, %d threads remaining\n", vnThreadsRunning[3]);
3355 }
3356
3357
3358 void GenerateBitcoins(bool fGenerate, CWallet* pwallet)
3359 {
3360     if (fGenerateBitcoins != fGenerate)
3361     {
3362         fGenerateBitcoins = fGenerate;
3363         WriteSetting("fGenerateBitcoins", fGenerateBitcoins);
3364         MainFrameRepaint();
3365     }
3366     if (fGenerateBitcoins)
3367     {
3368         int nProcessors = boost::thread::hardware_concurrency();
3369         printf("%d processors\n", nProcessors);
3370         if (nProcessors < 1)
3371             nProcessors = 1;
3372         if (fLimitProcessors && nProcessors > nLimitProcessors)
3373             nProcessors = nLimitProcessors;
3374         int nAddThreads = nProcessors - vnThreadsRunning[3];
3375         printf("Starting %d BitcoinMiner threads\n", nAddThreads);
3376         for (int i = 0; i < nAddThreads; i++)
3377         {
3378             if (!CreateThread(ThreadBitcoinMiner, pwallet))
3379                 printf("Error: CreateThread(ThreadBitcoinMiner) failed\n");
3380             Sleep(10);
3381         }
3382     }
3383 }