LCOV - code coverage report
Current view: top level - src/wallet - db.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 0 71 0.0 %
Date: 2024-01-03 14:57:27 Functions: 0 6 0.0 %
Branches: 0 228 0.0 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2021 The Bitcoin Core developers
       3                 :            : // Distributed under the MIT software license, see the accompanying
       4                 :            : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :            : 
       6                 :            : #include <chainparams.h>
       7                 :            : #include <common/args.h>
       8                 :            : #include <logging.h>
       9                 :            : #include <util/fs.h>
      10                 :            : #include <wallet/db.h>
      11                 :            : 
      12                 :            : #include <exception>
      13                 :            : #include <fstream>
      14                 :            : #include <string>
      15                 :            : #include <system_error>
      16                 :            : #include <vector>
      17                 :            : 
      18                 :            : namespace wallet {
      19                 :          0 : std::vector<fs::path> ListDatabases(const fs::path& wallet_dir)
      20                 :            : {
      21                 :          0 :     std::vector<fs::path> paths;
      22                 :          0 :     std::error_code ec;
      23                 :            : 
      24 [ #  # ][ #  # ]:          0 :     for (auto it = fs::recursive_directory_iterator(wallet_dir, ec); it != fs::recursive_directory_iterator(); it.increment(ec)) {
                 [ #  # ]
      25         [ #  # ]:          0 :         if (ec) {
      26 [ #  # ][ #  # ]:          0 :             if (fs::is_directory(*it)) {
      27                 :          0 :                 it.disable_recursion_pending();
      28 [ #  # ][ #  # ]:          0 :                 LogPrintf("%s: %s %s -- skipping.\n", __func__, ec.message(), fs::PathToString(it->path()));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
      29                 :          0 :             } else {
      30 [ #  # ][ #  # ]:          0 :                 LogPrintf("%s: %s %s\n", __func__, ec.message(), fs::PathToString(it->path()));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
      31                 :            :             }
      32                 :          0 :             continue;
      33                 :            :         }
      34                 :            : 
      35                 :            :         try {
      36 [ #  # ][ #  # ]:          0 :             const fs::path path{it->path().lexically_relative(wallet_dir)};
      37                 :            : 
      38 [ #  # ][ #  # ]:          0 :             if (it->status().type() == fs::file_type::directory &&
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
      39 [ #  # ][ #  # ]:          0 :                 (IsBDBFile(BDBDataFile(it->path())) || IsSQLiteFile(SQLiteDataFile(it->path())))) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
      40                 :            :                 // Found a directory which contains wallet.dat btree file, add it as a wallet.
      41         [ #  # ]:          0 :                 paths.emplace_back(path);
      42 [ #  # ][ #  # ]:          0 :             } else if (it.depth() == 0 && it->symlink_status().type() == fs::file_type::regular && IsBDBFile(it->path())) {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
      43 [ #  # ][ #  # ]:          0 :                 if (it->path().filename() == "wallet.dat") {
                 [ #  # ]
      44                 :            :                     // Found top-level wallet.dat btree file, add top level directory ""
      45                 :            :                     // as a wallet.
      46         [ #  # ]:          0 :                     paths.emplace_back();
      47                 :          0 :                 } else {
      48                 :            :                     // Found top-level btree file not called wallet.dat. Current bitcoin
      49                 :            :                     // software will never create these files but will allow them to be
      50                 :            :                     // opened in a shared database environment for backwards compatibility.
      51                 :            :                     // Add it to the list of available wallets.
      52         [ #  # ]:          0 :                     paths.emplace_back(path);
      53                 :            :                 }
      54                 :          0 :             }
      55         [ #  # ]:          0 :         } catch (const std::exception& e) {
      56 [ #  # ][ #  # ]:          0 :             LogPrintf("%s: Error scanning %s: %s\n", __func__, fs::PathToString(it->path()), e.what());
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
      57                 :          0 :             it.disable_recursion_pending();
      58 [ #  # ][ #  # ]:          0 :         }
      59                 :          0 :     }
      60                 :            : 
      61                 :          0 :     return paths;
      62         [ #  # ]:          0 : }
      63                 :            : 
      64                 :          0 : fs::path BDBDataFile(const fs::path& wallet_path)
      65                 :            : {
      66         [ #  # ]:          0 :     if (fs::is_regular_file(wallet_path)) {
      67                 :            :         // Special case for backwards compatibility: if wallet path points to an
      68                 :            :         // existing file, treat it as the path to a BDB data file in a parent
      69                 :            :         // directory that also contains BDB log files.
      70                 :          0 :         return wallet_path;
      71                 :            :     } else {
      72                 :            :         // Normal case: Interpret wallet path as a directory path containing
      73                 :            :         // data and log files.
      74         [ #  # ]:          0 :         return wallet_path / "wallet.dat";
      75                 :            :     }
      76                 :          0 : }
      77                 :            : 
      78                 :          0 : fs::path SQLiteDataFile(const fs::path& path)
      79                 :            : {
      80         [ #  # ]:          0 :     return path / "wallet.dat";
      81                 :          0 : }
      82                 :            : 
      83                 :          0 : bool IsBDBFile(const fs::path& path)
      84                 :            : {
      85         [ #  # ]:          0 :     if (!fs::exists(path)) return false;
      86                 :            : 
      87                 :            :     // A Berkeley DB Btree file has at least 4K.
      88                 :            :     // This check also prevents opening lock files.
      89                 :          0 :     std::error_code ec;
      90                 :          0 :     auto size = fs::file_size(path, ec);
      91 [ #  # ][ #  # ]:          0 :     if (ec) LogPrintf("%s: %s %s\n", __func__, ec.message(), fs::PathToString(path));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
      92         [ #  # ]:          0 :     if (size < 4096) return false;
      93                 :            : 
      94                 :          0 :     std::ifstream file{path, std::ios::binary};
      95 [ #  # ][ #  # ]:          0 :     if (!file.is_open()) return false;
      96                 :            : 
      97         [ #  # ]:          0 :     file.seekg(12, std::ios::beg); // Magic bytes start at offset 12
      98                 :          0 :     uint32_t data = 0;
      99         [ #  # ]:          0 :     file.read((char*) &data, sizeof(data)); // Read 4 bytes of file to compare against magic
     100                 :            : 
     101                 :            :     // Berkeley DB Btree magic bytes, from:
     102                 :            :     //  https://github.com/file/file/blob/5824af38469ec1ca9ac3ffd251e7afe9dc11e227/magic/Magdir/database#L74-L75
     103                 :            :     //  - big endian systems - 00 05 31 62
     104                 :            :     //  - little endian systems - 62 31 05 00
     105         [ #  # ]:          0 :     return data == 0x00053162 || data == 0x62310500;
     106                 :          0 : }
     107                 :            : 
     108                 :          0 : bool IsSQLiteFile(const fs::path& path)
     109                 :            : {
     110         [ #  # ]:          0 :     if (!fs::exists(path)) return false;
     111                 :            : 
     112                 :            :     // A SQLite Database file is at least 512 bytes.
     113                 :          0 :     std::error_code ec;
     114                 :          0 :     auto size = fs::file_size(path, ec);
     115 [ #  # ][ #  # ]:          0 :     if (ec) LogPrintf("%s: %s %s\n", __func__, ec.message(), fs::PathToString(path));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     116         [ #  # ]:          0 :     if (size < 512) return false;
     117                 :            : 
     118                 :          0 :     std::ifstream file{path, std::ios::binary};
     119 [ #  # ][ #  # ]:          0 :     if (!file.is_open()) return false;
     120                 :            : 
     121                 :            :     // Magic is at beginning and is 16 bytes long
     122                 :            :     char magic[16];
     123         [ #  # ]:          0 :     file.read(magic, 16);
     124                 :            : 
     125                 :            :     // Application id is at offset 68 and 4 bytes long
     126         [ #  # ]:          0 :     file.seekg(68, std::ios::beg);
     127                 :            :     char app_id[4];
     128         [ #  # ]:          0 :     file.read(app_id, 4);
     129                 :            : 
     130         [ #  # ]:          0 :     file.close();
     131                 :            : 
     132                 :            :     // Check the magic, see https://sqlite.org/fileformat.html
     133         [ #  # ]:          0 :     std::string magic_str(magic, 16);
     134 [ #  # ][ #  # ]:          0 :     if (magic_str != std::string{"SQLite format 3\000", 16}) {
     135                 :          0 :         return false;
     136                 :            :     }
     137                 :            : 
     138                 :            :     // Check the application id matches our network magic
     139 [ #  # ][ #  # ]:          0 :     return memcmp(Params().MessageStart().data(), app_id, 4) == 0;
     140                 :          0 : }
     141                 :            : 
     142                 :          0 : void ReadDatabaseArgs(const ArgsManager& args, DatabaseOptions& options)
     143                 :            : {
     144                 :            :     // Override current options with args values, if any were specified
     145 [ #  # ][ #  # ]:          0 :     options.use_unsafe_sync = args.GetBoolArg("-unsafesqlitesync", options.use_unsafe_sync);
     146 [ #  # ][ #  # ]:          0 :     options.use_shared_memory = !args.GetBoolArg("-privdb", !options.use_shared_memory);
     147 [ #  # ][ #  # ]:          0 :     options.max_log_mb = args.GetIntArg("-dblogsize", options.max_log_mb);
     148                 :          0 : }
     149                 :            : 
     150                 :            : } // namespace wallet

Generated by: LCOV version 1.14