src/main.cpp

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