wallet: Include actual backup filename in recovery warning message

luke-jr · luke-jr · commit b823a4c9f683 · 2017-06-06T21:17:09.000Z
diff --git a/src/wallet/db.cpp b/src/wallet/db.cpp
@@ -143,7 +143,7 @@ void CDBEnv::MakeMock()
     fMockDb = true;
 }
 
-CDBEnv::VerifyResult CDBEnv::Verify(const std::string& strFile, bool (*recoverFunc)(const std::string& strFile))
+CDBEnv::VerifyResult CDBEnv::Verify(const std::string& strFile, recoverFunc_type recoverFunc, std::string& out_backup_filename)
 {
     LOCK(cs_db);
     assert(mapFileUseCount.count(strFile) == 0);
@@ -156,11 +156,11 @@ CDBEnv::VerifyResult CDBEnv::Verify(const std::string& strFile, bool (*recoverFu
         return RECOVER_FAIL;
 
     // Try to recover:
-    bool fRecovered = (*recoverFunc)(strFile);
+    bool fRecovered = (*recoverFunc)(strFile, out_backup_filename);
     return (fRecovered ? RECOVER_OK : RECOVER_FAIL);
 }
 
-bool CDB::Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue))
+bool CDB::Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& newFilename)
 {
     // Recovery procedure:
     // move wallet file to wallet.timestamp.bak
@@ -170,7 +170,7 @@ bool CDB::Recover(const std::string& filename, void *callbackDataIn, bool (*reco
     // Set -rescan so any missing transactions will be
     // found.
     int64_t now = GetTime();
-    std::string newFilename = strprintf("wallet.%d.bak", now);
+    newFilename = strprintf("wallet.%d.bak", now);
 
     int result = bitdb.dbenv->dbrename(NULL, filename.c_str(), NULL,
                                        newFilename.c_str(), DB_AUTO_COMMIT);
@@ -261,18 +261,19 @@ bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataD
     return true;
 }
 
-bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, bool (*recoverFunc)(const std::string& strFile))
+bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc)
 {
     if (fs::exists(dataDir / walletFile))
     {
-        CDBEnv::VerifyResult r = bitdb.Verify(walletFile, recoverFunc);
+        std::string backup_filename;
+        CDBEnv::VerifyResult r = bitdb.Verify(walletFile, recoverFunc, backup_filename);
         if (r == CDBEnv::RECOVER_OK)
         {
             warningStr = strprintf(_("Warning: Wallet file corrupt, data salvaged!"
                                      " Original %s saved as %s in %s; if"
                                      " your balance or transactions are incorrect you should"
                                      " restore from a backup."),
-                                   walletFile, "wallet.{timestamp}.bak", dataDir);
+                                   walletFile, backup_filename, dataDir);
         }
         if (r == CDBEnv::RECOVER_FAIL)
         {
diff --git a/src/wallet/db.h b/src/wallet/db.h
@@ -55,7 +55,8 @@ class CDBEnv
     enum VerifyResult { VERIFY_OK,
                         RECOVER_OK,
                         RECOVER_FAIL };
-    VerifyResult Verify(const std::string& strFile, bool (*recoverFunc)(const std::string& strFile));
+    typedef bool (*recoverFunc_type)(const std::string& strFile, std::string& out_backup_filename);
+    VerifyResult Verify(const std::string& strFile, recoverFunc_type recoverFunc, std::string& out_backup_filename);
     /**
      * Salvage data from a file that Verify says is bad.
      * fAggressive sets the DB_AGGRESSIVE flag (see berkeley DB->verify() method documentation).
@@ -156,15 +157,15 @@ class CDB
 
     void Flush();
     void Close();
-    static bool Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue));
+    static bool Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename);
 
     /* flush the wallet passively (TRY_LOCK)
        ideal to be called periodically */
     static bool PeriodicFlush(CWalletDBWrapper& dbw);
     /* verifies the database environment */
     static bool VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr);
     /* verifies the database file */
-    static bool VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, bool (*recoverFunc)(const std::string& strFile));
+    static bool VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc);
 
 private:
     CDB(const CDB&);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -459,7 +459,8 @@ bool CWallet::Verify()
         {
             // Recover readable keypairs:
             CWallet dummyWallet;
-            if (!CWalletDB::Recover(walletFile, (void *)&dummyWallet, CWalletDB::RecoverKeysOnlyFilter))
+            std::string backup_filename;
+            if (!CWalletDB::Recover(walletFile, (void *)&dummyWallet, CWalletDB::RecoverKeysOnlyFilter, backup_filename))
                 return false;
         }
 
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
@@ -783,16 +783,16 @@ void MaybeCompactWalletDB()
 //
 // Try to (very carefully!) recover wallet file if there is a problem.
 //
-bool CWalletDB::Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue))
+bool CWalletDB::Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename)
 {
-    return CDB::Recover(filename, callbackDataIn, recoverKVcallback);
+    return CDB::Recover(filename, callbackDataIn, recoverKVcallback, out_backup_filename);
 }
 
-bool CWalletDB::Recover(const std::string& filename)
+bool CWalletDB::Recover(const std::string& filename, std::string& out_backup_filename)
 {
     // recover without a key filter callback
     // results in recovering all record types
-    return CWalletDB::Recover(filename, NULL, NULL);
+    return CWalletDB::Recover(filename, NULL, NULL, out_backup_filename);
 }
 
 bool CWalletDB::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDataStream ssValue)
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
@@ -218,9 +218,9 @@ class CWalletDB
     DBErrors ZapWalletTx(std::vector<CWalletTx>& vWtx);
     DBErrors ZapSelectTx(std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut);
     /* Try to (very carefully!) recover wallet database (with a possible key type filter) */
-    static bool Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue));
+    static bool Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename);
     /* Recover convenience-function to bypass the key filter callback, called when verify fails, recovers everything */
-    static bool Recover(const std::string& filename);
+    static bool Recover(const std::string& filename, std::string& out_backup_filename);
     /* Recover filter (used as callback), will only let keys (cryptographical keys) as KV/key-type pass through */
     static bool RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDataStream ssValue);
     /* Function to determine if a certain KV/key-type is a key (cryptographical key) type */

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ void CDBEnv::MakeMock()`
`143`	`143`	`fMockDb = true;`
`144`	`144`	`}`
`145`	`145`
`146`		`-CDBEnv::VerifyResult CDBEnv::Verify(const std::string& strFile, bool (*recoverFunc)(const std::string& strFile))`
	`146`	`+CDBEnv::VerifyResult CDBEnv::Verify(const std::string& strFile, recoverFunc_type recoverFunc, std::string& out_backup_filename)`
`147`	`147`	`{`
`148`	`148`	`LOCK(cs_db);`
`149`	`149`	`assert(mapFileUseCount.count(strFile) == 0);`
`@@ -156,11 +156,11 @@ CDBEnv::VerifyResult CDBEnv::Verify(const std::string& strFile, bool (*recoverFu`
`156`	`156`	`return RECOVER_FAIL;`
`157`	`157`
`158`	`158`	`// Try to recover:`
`159`		`- bool fRecovered = (*recoverFunc)(strFile);`
	`159`	`+ bool fRecovered = (*recoverFunc)(strFile, out_backup_filename);`
`160`	`160`	`return (fRecovered ? RECOVER_OK : RECOVER_FAIL);`
`161`	`161`	`}`
`162`	`162`
`163`		`-bool CDB::Recover(const std::string& filename, void callbackDataIn, bool (recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue))`
	`163`	`+bool CDB::Recover(const std::string& filename, void callbackDataIn, bool (recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& newFilename)`
`164`	`164`	`{`
`165`	`165`	`// Recovery procedure:`
`166`	`166`	`// move wallet file to wallet.timestamp.bak`
`@@ -170,7 +170,7 @@ bool CDB::Recover(const std::string& filename, void callbackDataIn, bool (reco`
`170`	`170`	`// Set -rescan so any missing transactions will be`
`171`	`171`	`// found.`
`172`	`172`	`int64_t now = GetTime();`
`173`		`- std::string newFilename = strprintf("wallet.%d.bak", now);`
	`173`	`+ newFilename = strprintf("wallet.%d.bak", now);`
`174`	`174`
`175`	`175`	`int result = bitdb.dbenv->dbrename(NULL, filename.c_str(), NULL,`
`176`	`176`	`newFilename.c_str(), DB_AUTO_COMMIT);`
`@@ -261,18 +261,19 @@ bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataD`
`261`	`261`	`return true;`
`262`	`262`	`}`
`263`	`263`
`264`		`-bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, bool (*recoverFunc)(const std::string& strFile))`
	`264`	`+bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc)`
`265`	`265`	`{`
`266`	`266`	`if (fs::exists(dataDir / walletFile))`
`267`	`267`	`{`
`268`		`- CDBEnv::VerifyResult r = bitdb.Verify(walletFile, recoverFunc);`
	`268`	`+ std::string backup_filename;`
	`269`	`+ CDBEnv::VerifyResult r = bitdb.Verify(walletFile, recoverFunc, backup_filename);`
`269`	`270`	`if (r == CDBEnv::RECOVER_OK)`
`270`	`271`	`{`
`271`	`272`	`warningStr = strprintf(_("Warning: Wallet file corrupt, data salvaged!"`
`272`	`273`	`" Original %s saved as %s in %s; if"`
`273`	`274`	`" your balance or transactions are incorrect you should"`
`274`	`275`	`" restore from a backup."),`
`275`		`- walletFile, "wallet.{timestamp}.bak", dataDir);`
	`276`	`+ walletFile, backup_filename, dataDir);`
`276`	`277`	`}`
`277`	`278`	`if (r == CDBEnv::RECOVER_FAIL)`
`278`	`279`	`{`
Original file line number	Diff line number	Diff line change
`@@ -459,7 +459,8 @@ bool CWallet::Verify()`
`459`	`459`	`{`
`460`	`460`	`// Recover readable keypairs:`
`461`	`461`	`CWallet dummyWallet;`
`462`		`- if (!CWalletDB::Recover(walletFile, (void *)&dummyWallet, CWalletDB::RecoverKeysOnlyFilter))`
	`462`	`+ std::string backup_filename;`
	`463`	`+ if (!CWalletDB::Recover(walletFile, (void *)&dummyWallet, CWalletDB::RecoverKeysOnlyFilter, backup_filename))`
`463`	`464`	`return false;`
`464`	`465`	`}`
`465`	`466`
Original file line number	Diff line number	Diff line change
`@@ -783,16 +783,16 @@ void MaybeCompactWalletDB()`
`783`	`783`	`//`
`784`	`784`	`// Try to (very carefully!) recover wallet file if there is a problem.`
`785`	`785`	`//`
`786`		`-bool CWalletDB::Recover(const std::string& filename, void callbackDataIn, bool (recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue))`
	`786`	`+bool CWalletDB::Recover(const std::string& filename, void callbackDataIn, bool (recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename)`
`787`	`787`	`{`
`788`		`- return CDB::Recover(filename, callbackDataIn, recoverKVcallback);`
	`788`	`+ return CDB::Recover(filename, callbackDataIn, recoverKVcallback, out_backup_filename);`
`789`	`789`	`}`
`790`	`790`
`791`		`-bool CWalletDB::Recover(const std::string& filename)`
	`791`	`+bool CWalletDB::Recover(const std::string& filename, std::string& out_backup_filename)`
`792`	`792`	`{`
`793`	`793`	`// recover without a key filter callback`
`794`	`794`	`// results in recovering all record types`
`795`		`- return CWalletDB::Recover(filename, NULL, NULL);`
	`795`	`+ return CWalletDB::Recover(filename, NULL, NULL, out_backup_filename);`
`796`	`796`	`}`
`797`	`797`
`798`	`798`	`bool CWalletDB::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDataStream ssValue)`