src/walletdb.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 "walletdb.h"
   7 #include "wallet.h"
   8
   9 #include <iostream>
  10 #include <fstream>
  11
  12 #include <boost/version.hpp>
  13 #include <boost/filesystem.hpp>
  14 #include <boost/algorithm/string.hpp>
  15
  16 #include <boost/date_time/posix_time/posix_time.hpp>
  17 #include <boost/lexical_cast.hpp>
  18 #include <boost/variant/get.hpp>
  19 #include <boost/algorithm/string.hpp>
  20
  21 using namespace std;
  22 using namespace boost;
  23
  24
  25 static uint64_t nAccountingEntryNumber = 0;
  26 extern bool fWalletUnlockMintOnly;
  27
  28 //
  29 // CWalletDB
  30 //
  31
  32 bool CWalletDB::WriteName(const string& strAddress, const string& strName)
  33 {
  34     nWalletDBUpdated++;
  35     return Write(make_pair(string("name"), strAddress), strName);
  36 }
  37
  38 bool CWalletDB::EraseName(const string& strAddress)
  39 {
  40     // This should only be used for sending addresses, never for receiving addresses,
  41     // receiving addresses must always have an address book entry if they're not change return.
  42     nWalletDBUpdated++;
  43     return Erase(make_pair(string("name"), strAddress));
  44 }
  45
  46 bool CWalletDB::ReadAccount(const string& strAccount, CAccount& account)
  47 {
  48     account.SetNull();
  49     return Read(make_pair(string("acc"), strAccount), account);
  50 }
  51
  52 bool CWalletDB::WriteAccount(const string& strAccount, const CAccount& account)
  53 {
  54     return Write(make_pair(string("acc"), strAccount), account);
  55 }
  56
  57 bool CWalletDB::WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry)
  58 {
  59     return Write(boost::make_tuple(string("acentry"), acentry.strAccount, nAccEntryNum), acentry);
  60 }
  61
  62 bool CWalletDB::WriteAccountingEntry(const CAccountingEntry& acentry)
  63 {
  64     return WriteAccountingEntry(++nAccountingEntryNumber, acentry);
  65 }
  66
  67 int64_t CWalletDB::GetAccountCreditDebit(const string& strAccount)
  68 {
  69     list<CAccountingEntry> entries;
  70     ListAccountCreditDebit(strAccount, entries);
  71
  72     int64_t nCreditDebit = 0;
  73     BOOST_FOREACH (const CAccountingEntry& entry, entries)
  74         nCreditDebit += entry.nCreditDebit;
  75
  76     return nCreditDebit;
  77 }
  78
  79 void CWalletDB::ListAccountCreditDebit(const string& strAccount, list<CAccountingEntry>& entries)
  80 {
  81     bool fAllAccounts = (strAccount == "*");
  82
  83     Dbc* pcursor = GetCursor();
  84     if (!pcursor)
  85         throw runtime_error("CWalletDB::ListAccountCreditDebit() : cannot create DB cursor");
  86     unsigned int fFlags = DB_SET_RANGE;
  87     while (true)
  88     {
  89         // Read next record
  90         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
  91         if (fFlags == DB_SET_RANGE)
  92             ssKey << boost::make_tuple(string("acentry"), (fAllAccounts? string("") : strAccount), uint64_t(0));
  93         CDataStream ssValue(SER_DISK, CLIENT_VERSION);
  94         int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
  95         fFlags = DB_NEXT;
  96         if (ret == DB_NOTFOUND)
  97             break;
  98         else if (ret != 0)
  99         {
 100             pcursor->close();
 101             throw runtime_error("CWalletDB::ListAccountCreditDebit() : error scanning DB");
 102         }
 103
 104         // Unserialize
 105         string strType;
 106         ssKey >> strType;
 107         if (strType != "acentry")
 108             break;
 109         CAccountingEntry acentry;
 110         ssKey >> acentry.strAccount;
 111         if (!fAllAccounts && acentry.strAccount != strAccount)
 112             break;
 113
 114         ssValue >> acentry;
 115         ssKey >> acentry.nEntryNo;
 116         entries.push_back(acentry);
 117     }
 118
 119     pcursor->close();
 120 }
 121
 122
 123 DBErrors
 124 CWalletDB::ReorderTransactions(CWallet* pwallet)
 125 {
 126     LOCK(pwallet->cs_wallet);
 127     // Old wallets didn't have any defined order for transactions
 128     // Probably a bad idea to change the output of this
 129
 130     // First: get all CWalletTx and CAccountingEntry into a sorted-by-time multimap.
 131     typedef pair<CWalletTx*, CAccountingEntry*> TxPair;
 132     typedef multimap<int64_t, TxPair > TxItems;
 133     TxItems txByTime;
 134
 135     for (map<uint256, CWalletTx>::iterator it = pwallet->mapWallet.begin(); it != pwallet->mapWallet.end(); ++it)
 136     {
 137         CWalletTx* wtx = &((*it).second);
 138         txByTime.insert(make_pair(wtx->nTimeReceived, TxPair(wtx, (CAccountingEntry*)0)));
 139     }
 140     list<CAccountingEntry> acentries;
 141     ListAccountCreditDebit("", acentries);
 142     BOOST_FOREACH(CAccountingEntry& entry, acentries)
 143     {
 144         txByTime.insert(make_pair(entry.nTime, TxPair((CWalletTx*)0, &entry)));
 145     }
 146
 147     int64_t& nOrderPosNext = pwallet->nOrderPosNext;
 148     nOrderPosNext = 0;
 149     std::vector<int64_t> nOrderPosOffsets;
 150     for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
 151     {
 152         CWalletTx *const pwtx = (*it).second.first;
 153         CAccountingEntry *const pacentry = (*it).second.second;
 154         int64_t& nOrderPos = (pwtx != 0) ? pwtx->nOrderPos : pacentry->nOrderPos;
 155
 156         if (nOrderPos == -1)
 157         {
 158             nOrderPos = nOrderPosNext++;
 159             nOrderPosOffsets.push_back(nOrderPos);
 160
 161             if (pacentry)
 162                 // Have to write accounting regardless, since we don't keep it in memory
 163                 if (!WriteAccountingEntry(pacentry->nEntryNo, *pacentry))
 164                     return DB_LOAD_FAIL;
 165         }
 166         else
 167         {
 168             int64_t nOrderPosOff = 0;
 169             BOOST_FOREACH(const int64_t& nOffsetStart, nOrderPosOffsets)
 170             {
 171                 if (nOrderPos >= nOffsetStart)
 172                     ++nOrderPosOff;
 173             }
 174             nOrderPos += nOrderPosOff;
 175             nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
 176
 177             if (!nOrderPosOff)
 178                 continue;
 179
 180             // Since we're changing the order, write it back
 181             if (pwtx)
 182             {
 183                 if (!WriteTx(pwtx->GetHash(), *pwtx))
 184                     return DB_LOAD_FAIL;
 185             }
 186             else
 187                 if (!WriteAccountingEntry(pacentry->nEntryNo, *pacentry))
 188                     return DB_LOAD_FAIL;
 189         }
 190     }
 191
 192     return DB_LOAD_OK;
 193 }
 194
 195 class CWalletScanState {
 196 public:
 197     unsigned int nKeys;
 198     unsigned int nCKeys;
 199     unsigned int nKeyMeta;
 200     bool fIsEncrypted;
 201     bool fAnyUnordered;
 202     int nFileVersion;
 203     vector<uint256> vWalletUpgrade;
 204
 205     CWalletScanState() {
 206         nKeys = nCKeys = nKeyMeta = 0;
 207         fIsEncrypted = false;
 208         fAnyUnordered = false;
 209         nFileVersion = 0;
 210     }
 211 };
 212
 213 bool
 214 ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
 215              CWalletScanState &wss, string& strType, string& strErr)
 216 {
 217     try {
 218         // Unserialize
 219         // Taking advantage of the fact that pair serialization
 220         // is just the two items serialized one after the other
 221         ssKey >> strType;
 222         if (strType == "name")
 223         {
 224             string strAddress;
 225             ssKey >> strAddress;
 226             ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()];
 227         }
 228         else if (strType == "tx")
 229         {
 230             uint256 hash;
 231             ssKey >> hash;
 232             CWalletTx& wtx = pwallet->mapWallet[hash];
 233             ssValue >> wtx;
 234             if (wtx.CheckTransaction() && (wtx.GetHash() == hash))
 235                 wtx.BindWallet(pwallet);
 236             else
 237             {
 238                 pwallet->mapWallet.erase(hash);
 239                 return false;
 240             }
 241
 242             // Undo serialize changes in 31600
 243             if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703)
 244             {
 245                 if (!ssValue.empty())
 246                 {
 247                     char fTmp;
 248                     char fUnused;
 249                     ssValue >> fTmp >> fUnused >> wtx.strFromAccount;
 250                     strErr = strprintf("LoadWallet() upgrading tx ver=%d %d '%s' %s",
 251                                        wtx.fTimeReceivedIsTxTime, fTmp, wtx.strFromAccount.c_str(), hash.ToString().c_str());
 252                     wtx.fTimeReceivedIsTxTime = fTmp;
 253                 }
 254                 else
 255                 {
 256                     strErr = strprintf("LoadWallet() repairing tx ver=%d %s", wtx.fTimeReceivedIsTxTime, hash.ToString().c_str());
 257                     wtx.fTimeReceivedIsTxTime = 0;
 258                 }
 259                 wss.vWalletUpgrade.push_back(hash);
 260             }
 261
 262             if (wtx.nOrderPos == -1)
 263                 wss.fAnyUnordered = true;
 264
 265             //// debug print
 266             //printf("LoadWallet  %s\n", wtx.GetHash().ToString().c_str());
 267             //printf(" %12"PRId64"  %s  %s  %s\n",
 268             //    wtx.vout[0].nValue,
 269             //    DateTimeStrFormat("%x %H:%M:%S", wtx.GetBlockTime()).c_str(),
 270             //    wtx.hashBlock.ToString().substr(0,20).c_str(),
 271             //    wtx.mapValue["message"].c_str());
 272         }
 273         else if (strType == "acentry")
 274         {
 275             string strAccount;
 276             ssKey >> strAccount;
 277             uint64_t nNumber;
 278             ssKey >> nNumber;
 279             if (nNumber > nAccountingEntryNumber)
 280                 nAccountingEntryNumber = nNumber;
 281
 282             if (!wss.fAnyUnordered)
 283             {
 284                 CAccountingEntry acentry;
 285                 ssValue >> acentry;
 286                 if (acentry.nOrderPos == -1)
 287                     wss.fAnyUnordered = true;
 288             }
 289         }
 290         else if (strType == "watchs")
 291         {
 292             CScript script;
 293             ssKey >> script;
 294             char fYes;
 295             ssValue >> fYes;
 296             if (fYes == '1')
 297                 pwallet->LoadWatchOnly(script);
 298
 299             // Watch-only addresses have no birthday information for now,
 300             // so set the wallet birthday to the beginning of time.
 301             pwallet->nTimeFirstKey = 1;
 302         }
 303         else if (strType == "key" || strType == "wkey")
 304         {
 305             vector<unsigned char> vchPubKey;
 306             ssKey >> vchPubKey;
 307             CKey key;
 308             if (strType == "key")
 309             {
 310                 wss.nKeys++;
 311                 CPrivKey pkey;
 312                 ssValue >> pkey;
 313                 key.SetPubKey(vchPubKey);
 314                 if (!key.SetPrivKey(pkey))
 315                 {
 316                     strErr = "Error reading wallet database: CPrivKey corrupt";
 317                     return false;
 318                 }
 319                 if (key.GetPubKey() != vchPubKey)
 320                 {
 321                     strErr = "Error reading wallet database: CPrivKey pubkey inconsistency";
 322                     return false;
 323                 }
 324                 if (!key.IsValid())
 325                 {
 326                     strErr = "Error reading wallet database: invalid CPrivKey";
 327                     return false;
 328                 }
 329             }
 330             else
 331             {
 332                 CWalletKey wkey;
 333                 ssValue >> wkey;
 334                 key.SetPubKey(vchPubKey);
 335                 if (!key.SetPrivKey(wkey.vchPrivKey))
 336                 {
 337                     strErr = "Error reading wallet database: CPrivKey corrupt";
 338                     return false;
 339                 }
 340                 if (key.GetPubKey() != vchPubKey)
 341                 {
 342                     strErr = "Error reading wallet database: CWalletKey pubkey inconsistency";
 343                     return false;
 344                 }
 345                 if (!key.IsValid())
 346                 {
 347                     strErr = "Error reading wallet database: invalid CWalletKey";
 348                     return false;
 349                 }
 350             }
 351             if (!pwallet->LoadKey(key))
 352             {
 353                 strErr = "Error reading wallet database: LoadKey failed";
 354                 return false;
 355             }
 356         }
 357         else if (strType == "mkey")
 358         {
 359             unsigned int nID;
 360             ssKey >> nID;
 361             CMasterKey kMasterKey;
 362             ssValue >> kMasterKey;
 363
 364             if(pwallet->mapMasterKeys.count(nID) != 0)
 365             {
 366                 strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
 367                 return false;
 368             }
 369             pwallet->mapMasterKeys[nID] = kMasterKey;
 370             if (pwallet->nMasterKeyMaxID < nID)
 371                 pwallet->nMasterKeyMaxID = nID;
 372         }
 373         else if (strType == "ckey")
 374         {
 375             wss.nCKeys++;
 376             vector<unsigned char> vchPubKey;
 377             ssKey >> vchPubKey;
 378             vector<unsigned char> vchPrivKey;
 379             ssValue >> vchPrivKey;
 380             if (!pwallet->LoadCryptedKey(vchPubKey, vchPrivKey))
 381             {
 382                 strErr = "Error reading wallet database: LoadCryptedKey failed";
 383                 return false;
 384             }
 385             wss.fIsEncrypted = true;
 386         }
 387         else if (strType == "keymeta")
 388         {
 389             CPubKey vchPubKey;
 390             ssKey >> vchPubKey;
 391             CKeyMetadata keyMeta;
 392             ssValue >> keyMeta;
 393             wss.nKeyMeta++;
 394
 395             pwallet->LoadKeyMetadata(vchPubKey, keyMeta);
 396
 397             // find earliest key creation time, as wallet birthday
 398             if (!pwallet->nTimeFirstKey ||
 399                 (keyMeta.nCreateTime < pwallet->nTimeFirstKey))
 400                 pwallet->nTimeFirstKey = keyMeta.nCreateTime;
 401         }
 402         else if (strType == "defaultkey")
 403         {
 404             ssValue >> pwallet->vchDefaultKey;
 405         }
 406         else if (strType == "pool")
 407         {
 408             int64_t nIndex;
 409             ssKey >> nIndex;
 410             CKeyPool keypool;
 411             ssValue >> keypool;
 412             pwallet->setKeyPool.insert(nIndex);
 413
 414             // If no metadata exists yet, create a default with the pool key's
 415             // creation time. Note that this may be overwritten by actually
 416             // stored metadata for that key later, which is fine.
 417             CKeyID keyid = keypool.vchPubKey.GetID();
 418             if (pwallet->mapKeyMetadata.count(keyid) == 0)
 419                 pwallet->mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
 420
 421         }
 422         else if (strType == "version")
 423         {
 424             ssValue >> wss.nFileVersion;
 425             if (wss.nFileVersion == 10300)
 426                 wss.nFileVersion = 300;
 427         }
 428         else if (strType == "cscript")
 429         {
 430             uint160 hash;
 431             ssKey >> hash;
 432             CScript script;
 433             ssValue >> script;
 434             if (!pwallet->LoadCScript(script))
 435             {
 436                 strErr = "Error reading wallet database: LoadCScript failed";
 437                 return false;
 438             }
 439         }
 440         else if (strType == "orderposnext")
 441         {
 442             ssValue >> pwallet->nOrderPosNext;
 443         }
 444     } catch (...)
 445     {
 446         return false;
 447     }
 448     return true;
 449 }
 450
 451 static bool IsKeyType(string strType)
 452 {
 453     return (strType== "key" || strType == "wkey" ||
 454             strType == "mkey" || strType == "ckey");
 455 }
 456
 457 DBErrors CWalletDB::LoadWallet(CWallet* pwallet)
 458 {
 459     pwallet->vchDefaultKey = CPubKey();
 460     CWalletScanState wss;
 461     bool fNoncriticalErrors = false;
 462     DBErrors result = DB_LOAD_OK;
 463
 464     try {
 465         LOCK(pwallet->cs_wallet);
 466         int nMinVersion = 0;
 467         if (Read((string)"minversion", nMinVersion))
 468         {
 469             if (nMinVersion > CLIENT_VERSION)
 470                 return DB_TOO_NEW;
 471             pwallet->LoadMinVersion(nMinVersion);
 472         }
 473
 474         // Get cursor
 475         Dbc* pcursor = GetCursor();
 476         if (!pcursor)
 477         {
 478             printf("Error getting wallet database cursor\n");
 479             return DB_CORRUPT;
 480         }
 481
 482         while (true)
 483         {
 484             // Read next record
 485             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 486             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
 487             int ret = ReadAtCursor(pcursor, ssKey, ssValue);
 488             if (ret == DB_NOTFOUND)
 489                 break;
 490             else if (ret != 0)
 491             {
 492                 printf("Error reading next record from wallet database\n");
 493                 return DB_CORRUPT;
 494             }
 495
 496             // Try to be tolerant of single corrupt records:
 497             string strType, strErr;
 498             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr))
 499             {
 500                 // losing keys is considered a catastrophic error, anything else
 501                 // we assume the user can live with:
 502                 if (IsKeyType(strType))
 503                     result = DB_CORRUPT;
 504                 else
 505                 {
 506                     // Leave other errors alone, if we try to fix them we might make things worse.
 507                     fNoncriticalErrors = true; // ... but do warn the user there is something wrong.
 508                     if (strType == "tx")
 509                         // Rescan if there is a bad transaction record:
 510                         SoftSetBoolArg("-rescan", true);
 511                 }
 512             }
 513             if (!strErr.empty())
 514                 printf("%s\n", strErr.c_str());
 515         }
 516         pcursor->close();
 517     }
 518     catch (...)
 519     {
 520         result = DB_CORRUPT;
 521     }
 522
 523     if (fNoncriticalErrors && result == DB_LOAD_OK)
 524         result = DB_NONCRITICAL_ERROR;
 525
 526     // Any wallet corruption at all: skip any rewriting or
 527     // upgrading, we don't want to make it worse.
 528     if (result != DB_LOAD_OK)
 529         return result;
 530
 531     printf("nFileVersion = %d\n", wss.nFileVersion);
 532
 533     printf("Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total\n",
 534            wss.nKeys, wss.nCKeys, wss.nKeyMeta, wss.nKeys + wss.nCKeys);
 535
 536     // nTimeFirstKey is only reliable if all keys have metadata
 537     if ((wss.nKeys + wss.nCKeys) != wss.nKeyMeta)
 538         pwallet->nTimeFirstKey = 1; // 0 would be considered 'no value'
 539
 540
 541     BOOST_FOREACH(uint256 hash, wss.vWalletUpgrade)
 542         WriteTx(hash, pwallet->mapWallet[hash]);
 543
 544     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
 545     if (wss.fIsEncrypted && (wss.nFileVersion == 40000 || wss.nFileVersion == 50000))
 546         return DB_NEED_REWRITE;
 547
 548     if (wss.nFileVersion < CLIENT_VERSION) // Update
 549         WriteVersion(CLIENT_VERSION);
 550
 551     if (wss.fAnyUnordered)
 552         result = ReorderTransactions(pwallet);
 553
 554     return result;
 555 }
 556
 557 void ThreadFlushWalletDB(void* parg)
 558 {
 559     // Make this thread recognisable as the wallet flushing thread
 560     RenameThread("novacoin-wallet");
 561
 562     const string& strFile = ((const string*)parg)[0];
 563     static bool fOneThread;
 564     if (fOneThread)
 565         return;
 566     fOneThread = true;
 567     if (!GetBoolArg("-flushwallet", true))
 568         return;
 569
 570     unsigned int nLastSeen = nWalletDBUpdated;
 571     unsigned int nLastFlushed = nWalletDBUpdated;
 572     int64_t nLastWalletUpdate = GetTime();
 573     while (!fShutdown)
 574     {
 575         Sleep(500);
 576
 577         if (nLastSeen != nWalletDBUpdated)
 578         {
 579             nLastSeen = nWalletDBUpdated;
 580             nLastWalletUpdate = GetTime();
 581         }
 582
 583         if (nLastFlushed != nWalletDBUpdated && GetTime() - nLastWalletUpdate >= 2)
 584         {
 585             TRY_LOCK(bitdb.cs_db,lockDb);
 586             if (lockDb)
 587             {
 588                 // Don't do this if any databases are in use
 589                 int nRefCount = 0;
 590                 map<string, int>::iterator mi = bitdb.mapFileUseCount.begin();
 591                 while (mi != bitdb.mapFileUseCount.end())
 592                 {
 593                     nRefCount += (*mi).second;
 594                     mi++;
 595                 }
 596
 597                 if (nRefCount == 0 && !fShutdown)
 598                 {
 599                     map<string, int>::iterator mi = bitdb.mapFileUseCount.find(strFile);
 600                     if (mi != bitdb.mapFileUseCount.end())
 601                     {
 602                         printf("Flushing wallet.dat\n");
 603                         nLastFlushed = nWalletDBUpdated;
 604                         int64_t nStart = GetTimeMillis();
 605
 606                         // Flush wallet.dat so it's self contained
 607                         bitdb.CloseDb(strFile);
 608                         bitdb.CheckpointLSN(strFile);
 609
 610                         bitdb.mapFileUseCount.erase(mi++);
 611                         printf("Flushed wallet.dat %" PRId64 "ms\n", GetTimeMillis() - nStart);
 612                     }
 613                 }
 614             }
 615         }
 616     }
 617 }
 618
 619 bool BackupWallet(const CWallet& wallet, const string& strDest)
 620 {
 621     if (!wallet.fFileBacked)
 622         return false;
 623     while (!fShutdown)
 624     {
 625         {
 626             LOCK(bitdb.cs_db);
 627             if (!bitdb.mapFileUseCount.count(wallet.strWalletFile) || bitdb.mapFileUseCount[wallet.strWalletFile] == 0)
 628             {
 629                 // Flush log data to the dat file
 630                 bitdb.CloseDb(wallet.strWalletFile);
 631                 bitdb.CheckpointLSN(wallet.strWalletFile);
 632                 bitdb.mapFileUseCount.erase(wallet.strWalletFile);
 633
 634                 // Copy wallet.dat
 635                 filesystem::path pathSrc = GetDataDir() / wallet.strWalletFile;
 636                 filesystem::path pathDest(strDest);
 637                 if (filesystem::is_directory(pathDest))
 638                     pathDest /= wallet.strWalletFile;
 639
 640                 try {
 641 #if BOOST_VERSION >= 104000
 642                     filesystem::copy_file(pathSrc, pathDest, filesystem::copy_option::overwrite_if_exists);
 643 #else
 644                     filesystem::copy_file(pathSrc, pathDest);
 645 #endif
 646                     printf("copied wallet.dat to %s\n", pathDest.string().c_str());
 647                     return true;
 648                 } catch(const filesystem::filesystem_error &e) {
 649                     printf("error copying wallet.dat to %s - %s\n", pathDest.string().c_str(), e.what());
 650                     return false;
 651                 }
 652             }
 653         }
 654         Sleep(100);
 655     }
 656     return false;
 657 }
 658
 659 bool DumpWallet(CWallet* pwallet, const string& strDest)
 660 {
 661
 662   if (!pwallet->fFileBacked)
 663       return false;
 664   while (!fShutdown)
 665   {
 666       // Populate maps
 667       std::map<CKeyID, int64_t> mapKeyBirth;
 668       std::set<CKeyID> setKeyPool;
 669       pwallet->GetKeyBirthTimes(mapKeyBirth);
 670       pwallet->GetAllReserveKeys(setKeyPool);
 671
 672       // sort time/key pairs
 673       std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
 674       for (std::map<CKeyID, int64_t>::const_iterator it = mapKeyBirth.begin(); it != mapKeyBirth.end(); it++) {
 675           vKeyBirth.push_back(std::make_pair(it->second, it->first));
 676       }
 677       mapKeyBirth.clear();
 678       std::sort(vKeyBirth.begin(), vKeyBirth.end());
 679
 680       // open outputfile as a stream
 681       ofstream file;
 682       file.open(strDest.c_str());
 683       if (!file.is_open())
 684          return false;
 685
 686       // produce output
 687       file << strprintf("# Wallet dump created by NovaCoin %s (%s)\n", CLIENT_BUILD.c_str(), CLIENT_DATE.c_str());
 688       file << strprintf("# * Created on %s\n", EncodeDumpTime(GetTime()).c_str());
 689       file << strprintf("# * Best block at time of backup was %i (%s),\n", nBestHeight, hashBestChain.ToString().c_str());
 690       file << strprintf("#   mined on %s\n", EncodeDumpTime(pindexBest->nTime).c_str());
 691       file << "\n";
 692       for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
 693           const CKeyID &keyid = it->second;
 694           std::string strTime = EncodeDumpTime(it->first);
 695           std::string strAddr = CBitcoinAddress(keyid).ToString();
 696           bool IsCompressed;
 697
 698           CKey key;
 699           if (pwallet->GetKey(keyid, key)) {
 700               if (pwallet->mapAddressBook.count(keyid)) {
 701                   CSecret secret = key.GetSecret(IsCompressed);
 702                   file << strprintf("%s %s label=%s # addr=%s\n",
 703                                     CBitcoinSecret(secret, IsCompressed).ToString().c_str(),
 704                                     strTime.c_str(),
 705                                     EncodeDumpString(pwallet->mapAddressBook[keyid]).c_str(),
 706                                     strAddr.c_str());
 707               } else if (setKeyPool.count(keyid)) {
 708                   CSecret secret = key.GetSecret(IsCompressed);
 709                   file << strprintf("%s %s reserve=1 # addr=%s\n",
 710                                     CBitcoinSecret(secret, IsCompressed).ToString().c_str(),
 711                                     strTime.c_str(),
 712                                     strAddr.c_str());
 713               } else {
 714                   CSecret secret = key.GetSecret(IsCompressed);
 715                   file << strprintf("%s %s change=1 # addr=%s\n",
 716                                     CBitcoinSecret(secret, IsCompressed).ToString().c_str(),
 717                                     strTime.c_str(),
 718                                     strAddr.c_str());
 719               }
 720           }
 721       }
 722       file << "\n";
 723       file << "# End of dump\n";
 724       file.close();
 725       return true;
 726      }
 727    return false;
 728 }
 729
 730
 731 bool ImportWallet(CWallet *pwallet, const string& strLocation)
 732 {
 733
 734    if (!pwallet->fFileBacked)
 735        return false;
 736    while (!fShutdown)
 737    {
 738       // open inputfile as stream
 739       ifstream file;
 740       file.open(strLocation.c_str());
 741       if (!file.is_open())
 742           return false;
 743
 744       int64_t nTimeBegin = pindexBest->nTime;
 745
 746       bool fGood = true;
 747
 748       // read through input file checking and importing keys into wallet.
 749       while (file.good()) {
 750           std::string line;
 751           std::getline(file, line);
 752           if (line.empty() || line[0] == '#')
 753               continue;
 754
 755           std::vector<std::string> vstr;
 756           boost::split(vstr, line, boost::is_any_of(" "));
 757           if (vstr.size() < 2)
 758               continue;
 759           CBitcoinSecret vchSecret;
 760           if (!vchSecret.SetString(vstr[0]))
 761               continue;
 762
 763           bool fCompressed;
 764           CKey key;
 765           CSecret secret = vchSecret.GetSecret(fCompressed);
 766           key.SetSecret(secret, fCompressed);
 767           CKeyID keyid = key.GetPubKey().GetID();
 768
 769           if (pwallet->HaveKey(keyid)) {
 770               printf("Skipping import of %s (key already present)\n", CBitcoinAddress(keyid).ToString().c_str());
 771              continue;
 772           }
 773           int64_t nTime = DecodeDumpTime(vstr[1]);
 774           std::string strLabel;
 775           bool fLabel = true;
 776           for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
 777               if (boost::algorithm::starts_with(vstr[nStr], "#"))
 778                   break;
 779               if (vstr[nStr] == "change=1")
 780                   fLabel = false;
 781               if (vstr[nStr] == "reserve=1")
 782                   fLabel = false;
 783               if (boost::algorithm::starts_with(vstr[nStr], "label=")) {
 784                   strLabel = DecodeDumpString(vstr[nStr].substr(6));
 785                   fLabel = true;
 786               }
 787           }
 788           printf("Importing %s...\n", CBitcoinAddress(keyid).ToString().c_str());
 789           if (!pwallet->AddKey(key)) {
 790               fGood = false;
 791               continue;
 792           }
 793           pwallet->mapKeyMetadata[keyid].nCreateTime = nTime;
 794           if (fLabel)
 795               pwallet->SetAddressBookName(keyid, strLabel);
 796           nTimeBegin = std::min(nTimeBegin, nTime);
 797       }
 798       file.close();
 799
 800       // rescan block chain looking for coins from new keys
 801       CBlockIndex *pindex = pindexBest;
 802       while (pindex && pindex->pprev && pindex->nTime > nTimeBegin - 7200)
 803           pindex = pindex->pprev;
 804
 805       printf("Rescanning last %i blocks\n", pindexBest->nHeight - pindex->nHeight + 1);
 806       pwallet->ScanForWalletTransactions(pindex);
 807       pwallet->ReacceptWalletTransactions();
 808       pwallet->MarkDirty();
 809
 810       return fGood;
 811
 812   }
 813
 814   return false;
 815
 816 }
 817
 818
 819 //
 820 // Try to (very carefully!) recover wallet.dat if there is a problem.
 821 //
 822 bool CWalletDB::Recover(CDBEnv& dbenv, std::string filename, bool fOnlyKeys)
 823 {
 824     // Recovery procedure:
 825     // move wallet.dat to wallet.timestamp.bak
 826     // Call Salvage with fAggressive=true to
 827     // get as much data as possible.
 828     // Rewrite salvaged data to wallet.dat
 829     // Set -rescan so any missing transactions will be
 830     // found.
 831     int64_t now = GetTime();
 832     std::string newFilename = strprintf("wallet.%" PRId64 ".bak", now);
 833
 834     int result = dbenv.dbenv.dbrename(NULL, filename.c_str(), NULL,
 835                                       newFilename.c_str(), DB_AUTO_COMMIT);
 836     if (result == 0)
 837         printf("Renamed %s to %s\n", filename.c_str(), newFilename.c_str());
 838     else
 839     {
 840         printf("Failed to rename %s to %s\n", filename.c_str(), newFilename.c_str());
 841         return false;
 842     }
 843
 844     std::vector<CDBEnv::KeyValPair> salvagedData;
 845     bool allOK = dbenv.Salvage(newFilename, true, salvagedData);
 846     if (salvagedData.empty())
 847     {
 848         printf("Salvage(aggressive) found no records in %s.\n", newFilename.c_str());
 849         return false;
 850     }
 851     printf("Salvage(aggressive) found %" PRIszu " records\n", salvagedData.size());
 852
 853     bool fSuccess = allOK;
 854     Db* pdbCopy = new Db(&dbenv.dbenv, 0);
 855     int ret = pdbCopy->open(NULL,                 // Txn pointer
 856                             filename.c_str(),   // Filename
 857                             "main",    // Logical db name
 858                             DB_BTREE,  // Database type
 859                             DB_CREATE,    // Flags
 860                             0);
 861     if (ret > 0)
 862     {
 863         printf("Cannot create database file %s\n", filename.c_str());
 864         return false;
 865     }
 866     CWallet dummyWallet;
 867     CWalletScanState wss;
 868
 869     DbTxn* ptxn = dbenv.TxnBegin();
 870     BOOST_FOREACH(CDBEnv::KeyValPair& row, salvagedData)
 871     {
 872         if (fOnlyKeys)
 873         {
 874             CDataStream ssKey(row.first, SER_DISK, CLIENT_VERSION);
 875             CDataStream ssValue(row.second, SER_DISK, CLIENT_VERSION);
 876             string strType, strErr;
 877             bool fReadOK = ReadKeyValue(&dummyWallet, ssKey, ssValue,
 878                                         wss, strType, strErr);
 879             if (!IsKeyType(strType))
 880                 continue;
 881             if (!fReadOK)
 882             {
 883                 printf("WARNING: CWalletDB::Recover skipping %s: %s\n", strType.c_str(), strErr.c_str());
 884                 continue;
 885             }
 886         }
 887         Dbt datKey(&row.first[0], row.first.size());
 888         Dbt datValue(&row.second[0], row.second.size());
 889         int ret2 = pdbCopy->put(ptxn, &datKey, &datValue, DB_NOOVERWRITE);
 890         if (ret2 > 0)
 891             fSuccess = false;
 892     }
 893     ptxn->commit(0);
 894     pdbCopy->close(0);
 895     delete pdbCopy;
 896
 897     return fSuccess;
 898 }
 899
 900 bool CWalletDB::Recover(CDBEnv& dbenv, std::string filename)
 901 {
 902     return CWalletDB::Recover(dbenv, filename, false);
 903 }