Add -walletdir parameter to specify custom wallet dir

meshcollider · meshcollider · commit 0530ba0eae14 · 2017-11-18T00:50:58.000+13:00
diff --git a/src/Makefile.am b/src/Makefile.am
@@ -168,6 +168,7 @@ BITCOIN_CORE_H = \
   wallet/rpcwallet.h \
   wallet/wallet.h \
   wallet/walletdb.h \
+  wallet/walletutil.h \
   warnings.h \
   zmq/zmqabstractnotifier.h \
   zmq/zmqconfig.h\
@@ -249,6 +250,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/rpcwallet.cpp \
   wallet/wallet.cpp \
   wallet/walletdb.cpp \
+  wallet/walletutil.cpp \
   $(BITCOIN_CORE_H)
 
 # crypto primitives library
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
@@ -101,6 +101,10 @@ bool AppInit(int argc, char* argv[])
             fprintf(stderr, "Error: Specified data directory \"%s\" does not exist.\n", gArgs.GetArg("-datadir", "").c_str());
             return false;
         }
+        if (gArgs.IsArgSet("-walletdir") && !fs::is_directory(GetWalletDir())) {
+            fprintf(stderr, "Error: Specified wallet directory \"%s\" does not exist.\n", gArgs.GetArg("-walletdir", "").c_str());
+            return false;
+        }
         try
         {
             gArgs.ReadConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
diff --git a/src/init.cpp b/src/init.cpp
@@ -1220,6 +1220,7 @@ bool AppInitMain(boost::thread_group& threadGroup, CScheduler& scheduler)
         LogPrintf("Startup time: %s\n", DateTimeStrFormat("%Y-%m-%d %H:%M:%S", GetTime()));
     LogPrintf("Default data directory %s\n", GetDefaultDataDir().string());
     LogPrintf("Using data directory %s\n", GetDataDir().string());
+    LogPrintf("Using wallet directory %s\n", GetWalletDir().string());
     LogPrintf("Using config file %s\n", GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME)).string());
     LogPrintf("Using at most %i automatic connections (%i file descriptors available)\n", nMaxConnections, nFD);
 
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
@@ -626,6 +626,11 @@ int main(int argc, char *argv[])
                               QObject::tr("Error: Specified data directory \"%1\" does not exist.").arg(QString::fromStdString(gArgs.GetArg("-datadir", ""))));
         return EXIT_FAILURE;
     }
+    if (gArgs.IsArgSet("-walletdir") && !fs::is_directory(GetWalletDir())) {
+        QMessageBox::critical(0, QObject::tr(PACKAGE_NAME),
+                              QObject::tr("Error: Specified wallet directory \"%1\" does not exist.").arg(QString::fromStdString(gArgs.GetArg("-walletdir", ""))));
+        return EXIT_FAILURE;
+    }
     try {
         gArgs.ReadConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
     } catch (const std::exception& e) {
diff --git a/src/wallet/db.cpp b/src/wallet/db.cpp
@@ -11,6 +11,7 @@
 #include <protocol.h>
 #include <util.h>
 #include <utilstrencodings.h>
+#include <wallet/walletutil.h>
 
 #include <stdint.h>
 
@@ -257,23 +258,23 @@ bool CDB::Recover(const std::string& filename, void *callbackDataIn, bool (*reco
     return fSuccess;
 }
 
-bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr)
+bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr)
 {
     LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0));
     LogPrintf("Using wallet %s\n", walletFile);
 
     // Wallet file must be a plain filename without a directory
     if (walletFile != fs::basename(walletFile) + fs::extension(walletFile))
     {
-        errorStr = strprintf(_("Wallet %s resides outside data directory %s"), walletFile, dataDir.string());
+        errorStr = strprintf(_("Wallet %s resides outside wallet directory %s"), walletFile, walletDir.string());
         return false;
     }
 
-    if (!bitdb.Open(dataDir))
+    if (!bitdb.Open(walletDir))
     {
         // try moving the database env out of the way
-        fs::path pathDatabase = dataDir / "database";
-        fs::path pathDatabaseBak = dataDir / strprintf("database.%d.bak", GetTime());
+        fs::path pathDatabase = walletDir / "database";
+        fs::path pathDatabaseBak = walletDir / strprintf("database.%d.bak", GetTime());
         try {
             fs::rename(pathDatabase, pathDatabaseBak);
             LogPrintf("Moved old %s to %s. Retrying.\n", pathDatabase.string(), pathDatabaseBak.string());
@@ -282,18 +283,18 @@ bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataD
         }
 
         // try again
-        if (!bitdb.Open(dataDir)) {
+        if (!bitdb.Open(walletDir)) {
             // if it still fails, it probably means we can't even create the database env
-            errorStr = strprintf(_("Error initializing wallet database environment %s!"), GetDataDir());
+            errorStr = strprintf(_("Error initializing wallet database environment %s!"), walletDir);
             return false;
         }
     }
     return true;
 }
 
-bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc)
+bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc)
 {
-    if (fs::exists(dataDir / walletFile))
+    if (fs::exists(walletDir / walletFile))
     {
         std::string backup_filename;
         CDBEnv::VerifyResult r = bitdb.Verify(walletFile, recoverFunc, backup_filename);
@@ -303,7 +304,7 @@ bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& data
                                      " Original %s saved as %s in %s; if"
                                      " your balance or transactions are incorrect you should"
                                      " restore from a backup."),
-                                   walletFile, backup_filename, dataDir);
+                                   walletFile, backup_filename, walletDir);
         }
         if (r == CDBEnv::RECOVER_FAIL)
         {
@@ -407,7 +408,7 @@ CDB::CDB(CWalletDBWrapper& dbw, const char* pszMode, bool fFlushOnCloseIn) : pdb
 
     {
         LOCK(env->cs_db);
-        if (!env->Open(GetDataDir()))
+        if (!env->Open(GetWalletDir()))
             throw std::runtime_error("CDB: Failed to open database environment.");
 
         pdb = env->mapDb[strFilename];
@@ -695,7 +696,7 @@ bool CWalletDBWrapper::Backup(const std::string& strDest)
                 env->mapFileUseCount.erase(strFile);
 
                 // Copy wallet file
-                fs::path pathSrc = GetDataDir() / strFile;
+                fs::path pathSrc = GetWalletDir() / strFile;
                 fs::path pathDest(strDest);
                 if (fs::is_directory(pathDest))
                     pathDest /= strFile;
diff --git a/src/wallet/db.h b/src/wallet/db.h
@@ -167,9 +167,9 @@ class CDB
        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);
+    static bool VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr);
     /* verifies the database file */
-    static bool VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc);
+    static bool VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc);
 
 public:
     template <typename K, typename T>
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
@@ -9,8 +9,9 @@
 #include <util.h>
 #include <utilmoneystr.h>
 #include <validation.h>
-#include <wallet/wallet.h>
 #include <wallet/rpcwallet.h>
+#include <wallet/wallet.h>
+#include <wallet/walletutil.h>
 
 std::string GetWalletHelpString(bool showDebug)
 {
@@ -34,6 +35,7 @@ std::string GetWalletHelpString(bool showDebug)
     strUsage += HelpMessageOpt("-upgradewallet", _("Upgrade wallet to latest format on startup"));
     strUsage += HelpMessageOpt("-wallet=<file>", _("Specify wallet file (within data directory)") + " " + strprintf(_("(default: %s)"), DEFAULT_WALLET_DAT));
     strUsage += HelpMessageOpt("-walletbroadcast", _("Make the wallet broadcast transactions") + " " + strprintf(_("(default: %u)"), DEFAULT_WALLETBROADCAST));
+    strUsage += HelpMessageOpt("-walletdir=<dir>", _("Specify directory to hold wallets (default: <datadir>/wallets if it exists, otherwise <datadir>)"));
     strUsage += HelpMessageOpt("-walletnotify=<cmd>", _("Execute command when a wallet transaction changes (%s in cmd is replaced by TxID)"));
     strUsage += HelpMessageOpt("-zapwallettxes=<mode>", _("Delete all wallet transactions and only recover those parts of the blockchain through -rescan on startup") +
                                " " + _("(1 = keep tx meta data e.g. account owner and payment request information, 2 = drop tx meta data)"));
@@ -205,7 +207,7 @@ bool VerifyWallets()
             return InitError(strprintf(_("Error loading wallet %s. Invalid characters in -wallet filename."), walletFile));
         }
 
-        fs::path wallet_path = fs::absolute(walletFile, GetDataDir());
+        fs::path wallet_path = fs::absolute(walletFile, GetWalletDir());
 
         if (fs::exists(wallet_path) && (!fs::is_regular_file(wallet_path) || fs::is_symlink(wallet_path))) {
             return InitError(strprintf(_("Error loading wallet %s. -wallet filename must be a regular file."), walletFile));
@@ -216,7 +218,7 @@ bool VerifyWallets()
         }
 
         std::string strError;
-        if (!CWalletDB::VerifyEnvironment(walletFile, GetDataDir().string(), strError)) {
+        if (!CWalletDB::VerifyEnvironment(walletFile, GetWalletDir().string(), strError)) {
             return InitError(strError);
         }
 
@@ -230,7 +232,7 @@ bool VerifyWallets()
         }
 
         std::string strWarning;
-        bool dbV = CWalletDB::VerifyDatabaseFile(walletFile, GetDataDir().string(), strWarning, strError);
+        bool dbV = CWalletDB::VerifyDatabaseFile(walletFile, GetWalletDir().string(), strWarning, strError);
         if (!strWarning.empty()) {
             InitWarning(strWarning);
         }
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
@@ -26,6 +26,7 @@
 #include <wallet/feebumper.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
+#include <wallet/walletutil.h>
 
 #include <init.h>  // For StartShutdown
 
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
@@ -814,14 +814,14 @@ bool CWalletDB::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDa
     return true;
 }
 
-bool CWalletDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr)
+bool CWalletDB::VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr)
 {
-    return CDB::VerifyEnvironment(walletFile, dataDir, errorStr);
+    return CDB::VerifyEnvironment(walletFile, walletDir, errorStr);
 }
 
-bool CWalletDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr)
+bool CWalletDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr)
 {
-    return CDB::VerifyDatabaseFile(walletFile, dataDir, warningStr, errorStr, CWalletDB::Recover);
+    return CDB::VerifyDatabaseFile(walletFile, walletDir, warningStr, errorStr, CWalletDB::Recover);
 }
 
 bool CWalletDB::WriteDestData(const std::string &address, const std::string &key, const std::string &value)
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
@@ -226,9 +226,9 @@ class CWalletDB
     /* Function to determine if a certain KV/key-type is a key (cryptographical key) type */
     static bool IsKeyType(const std::string& strType);
     /* verifies the database environment */
-    static bool VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr);
+    static bool VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr);
     /* verifies the database file */
-    static bool VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr);
+    static bool VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr);
 
     //! write the hdchain model (external chain child index counter)
     bool WriteHDChain(const CHDChain& chain);
diff --git a/src/wallet/walletutil.cpp b/src/wallet/walletutil.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) 2017 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "wallet/walletutil.h"
+
+fs::path GetWalletDir()
+{
+    fs::path path;
+
+    if (gArgs.IsArgSet("-walletdir")) {
+        path = fs::system_complete(gArgs.GetArg("-walletdir", ""));
+        if (!fs::is_directory(path)) {
+            // If the path specified doesn't exist, we return the deliberately
+            // invalid empty string.
+            path = "";
+        }
+    } else {
+        path = GetDataDir();
+    }
+
+    return path;
+}
diff --git a/src/wallet/walletutil.h b/src/wallet/walletutil.h
@@ -0,0 +1,13 @@
+// Copyright (c) 2017 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_WALLET_UTIL_H
+#define BITCOIN_WALLET_UTIL_H
+
+#include "util.h"
+
+//! Get the path of the wallet directory.
+fs::path GetWalletDir();
+
+#endif // BITCOIN_WALLET_UTIL_H

Original file line number	Diff line number	Diff line change
`@@ -101,6 +101,10 @@ bool AppInit(int argc, char* argv[])`
`101`	`101`	`fprintf(stderr, "Error: Specified data directory \"%s\" does not exist.\n", gArgs.GetArg("-datadir", "").c_str());`
`102`	`102`	`return false;`
`103`	`103`	`}`
	`104`	`+ if (gArgs.IsArgSet("-walletdir") && !fs::is_directory(GetWalletDir())) {`
	`105`	`+ fprintf(stderr, "Error: Specified wallet directory \"%s\" does not exist.\n", gArgs.GetArg("-walletdir", "").c_str());`
	`106`	`+ return false;`
	`107`	`+ }`
`104`	`108`	`try`
`105`	`109`	`{`
`106`	`110`	`gArgs.ReadConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`#include <protocol.h>`
`12`	`12`	`#include <util.h>`
`13`	`13`	`#include <utilstrencodings.h>`
	`14`	`+#include <wallet/walletutil.h>`
`14`	`15`
`15`	`16`	`#include <stdint.h>`
`16`	`17`
`@@ -257,23 +258,23 @@ bool CDB::Recover(const std::string& filename, void callbackDataIn, bool (reco`
`257`	`258`	`return fSuccess;`
`258`	`259`	`}`
`259`	`260`
`260`		`-bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr)`
	`261`	`+bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr)`
`261`	`262`	`{`
`262`	`263`	`LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0));`
`263`	`264`	`LogPrintf("Using wallet %s\n", walletFile);`
`264`	`265`
`265`	`266`	`// Wallet file must be a plain filename without a directory`
`266`	`267`	`if (walletFile != fs::basename(walletFile) + fs::extension(walletFile))`
`267`	`268`	`{`
`268`		`- errorStr = strprintf(_("Wallet %s resides outside data directory %s"), walletFile, dataDir.string());`
	`269`	`+ errorStr = strprintf(_("Wallet %s resides outside wallet directory %s"), walletFile, walletDir.string());`
`269`	`270`	`return false;`
`270`	`271`	`}`
`271`	`272`
`272`		`- if (!bitdb.Open(dataDir))`
	`273`	`+ if (!bitdb.Open(walletDir))`
`273`	`274`	`{`
`274`	`275`	`// try moving the database env out of the way`
`275`		`- fs::path pathDatabase = dataDir / "database";`
`276`		`- fs::path pathDatabaseBak = dataDir / strprintf("database.%d.bak", GetTime());`
	`276`	`+ fs::path pathDatabase = walletDir / "database";`
	`277`	`+ fs::path pathDatabaseBak = walletDir / strprintf("database.%d.bak", GetTime());`
`277`	`278`	`try {`
`278`	`279`	`fs::rename(pathDatabase, pathDatabaseBak);`
`279`	`280`	`LogPrintf("Moved old %s to %s. Retrying.\n", pathDatabase.string(), pathDatabaseBak.string());`
`@@ -282,18 +283,18 @@ bool CDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataD`
`282`	`283`	`}`
`283`	`284`
`284`	`285`	`// try again`
`285`		`- if (!bitdb.Open(dataDir)) {`
	`286`	`+ if (!bitdb.Open(walletDir)) {`
`286`	`287`	`// if it still fails, it probably means we can't even create the database env`
`287`		`- errorStr = strprintf(_("Error initializing wallet database environment %s!"), GetDataDir());`
	`288`	`+ errorStr = strprintf(_("Error initializing wallet database environment %s!"), walletDir);`
`288`	`289`	`return false;`
`289`	`290`	`}`
`290`	`291`	`}`
`291`	`292`	`return true;`
`292`	`293`	`}`
`293`	`294`
`294`		`-bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc)`
	`295`	`+bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr, CDBEnv::recoverFunc_type recoverFunc)`
`295`	`296`	`{`
`296`		`- if (fs::exists(dataDir / walletFile))`
	`297`	`+ if (fs::exists(walletDir / walletFile))`
`297`	`298`	`{`
`298`	`299`	`std::string backup_filename;`
`299`	`300`	`CDBEnv::VerifyResult r = bitdb.Verify(walletFile, recoverFunc, backup_filename);`
`@@ -303,7 +304,7 @@ bool CDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& data`
`303`	`304`	`" Original %s saved as %s in %s; if"`
`304`	`305`	`" your balance or transactions are incorrect you should"`
`305`	`306`	`" restore from a backup."),`
`306`		`- walletFile, backup_filename, dataDir);`
	`307`	`+ walletFile, backup_filename, walletDir);`
`307`	`308`	`}`
`308`	`309`	`if (r == CDBEnv::RECOVER_FAIL)`
`309`	`310`	`{`
`@@ -407,7 +408,7 @@ CDB::CDB(CWalletDBWrapper& dbw, const char* pszMode, bool fFlushOnCloseIn) : pdb`
`407`	`408`
`408`	`409`	`{`
`409`	`410`	`LOCK(env->cs_db);`
`410`		`- if (!env->Open(GetDataDir()))`
	`411`	`+ if (!env->Open(GetWalletDir()))`
`411`	`412`	`throw std::runtime_error("CDB: Failed to open database environment.");`
`412`	`413`
`413`	`414`	`pdb = env->mapDb[strFilename];`
`@@ -695,7 +696,7 @@ bool CWalletDBWrapper::Backup(const std::string& strDest)`
`695`	`696`	`env->mapFileUseCount.erase(strFile);`
`696`	`697`
`697`	`698`	`// Copy wallet file`
`698`		`- fs::path pathSrc = GetDataDir() / strFile;`
	`699`	`+ fs::path pathSrc = GetWalletDir() / strFile;`
`699`	`700`	`fs::path pathDest(strDest);`
`700`	`701`	`if (fs::is_directory(pathDest))`
`701`	`702`	`pathDest /= strFile;`
Original file line number	Diff line number	Diff line change
`@@ -814,14 +814,14 @@ bool CWalletDB::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDa`
`814`	`814`	`return true;`
`815`	`815`	`}`
`816`	`816`
`817`		`-bool CWalletDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr)`
	`817`	`+bool CWalletDB::VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr)`
`818`	`818`	`{`
`819`		`- return CDB::VerifyEnvironment(walletFile, dataDir, errorStr);`
	`819`	`+ return CDB::VerifyEnvironment(walletFile, walletDir, errorStr);`
`820`	`820`	`}`
`821`	`821`
`822`		`-bool CWalletDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr)`
	`822`	`+bool CWalletDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr)`
`823`	`823`	`{`
`824`		`- return CDB::VerifyDatabaseFile(walletFile, dataDir, warningStr, errorStr, CWalletDB::Recover);`
	`824`	`+ return CDB::VerifyDatabaseFile(walletFile, walletDir, warningStr, errorStr, CWalletDB::Recover);`
`825`	`825`	`}`
`826`	`826`
`827`	`827`	`bool CWalletDB::WriteDestData(const std::string &address, const std::string &key, const std::string &value)`