READ THE CODE

Inside Bitcoin

The code behind the network, with room to understand it.

Stable release v32.1bitcoin/bitcoin · f0de87f04062 ↗3,020 source files · 47.5 MB stored on the server340 file guides

Release published 2026-10-28 · Snapshot fetched 2026-11-01. Latest stable release at fetch time; development branches and Git history are excluded. Only the selected code window and visible folders load here.

11,334 bytes · SHA-256 0f41ff2302d7d4a5… · View upstream ↗

1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present 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 <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <util/fs_helpers.h>
9#include <random.h>
10#include <sync.h>
11#include <tinyformat.h>
12#include <util/byte_units.h>
13#include <util/check.h>
14#include <util/fs.h>
15#include <util/log.h>
16#include <util/syserror.h>
17
18#include <cerrno>
19#include <fstream>
20#include <limits>
21#include <map>
22#include <memory>
23#include <optional>
24#include <stdexcept>
25#include <string>
26#include <system_error>
27#include <utility>
28
29#ifndef WIN32
30#include <fcntl.h>
31#include <sys/resource.h>
32#include <sys/types.h>
33#include <unistd.h>
34#else
35#include <io.h>
36#include <shlobj.h>
37#endif // WIN32
38
39#ifdef __APPLE__
40#include <sys/mount.h>
41#include <sys/param.h>
42#endif
43
44/** Mutex to protect dir_locks. */
45static GlobalMutex cs_dir_locks;
46/** A map that contains all the currently held directory locks. After
47 * successful locking, these will be held here until the global destructor
48 * cleans them up and thus automatically unlocks them, or ReleaseDirectoryLocks
49 * is called.
50 */
51static std::map<std::string, std::unique_ptr<fsbridge::FileLock>> dir_locks GUARDED_BY(cs_dir_locks);
52namespace util {
53LockResult LockDirectory(const fs::path& directory, const fs::path& lockfile_name, bool probe_only)
54{
55    LOCK(cs_dir_locks);
56    fs::path pathLockFile = directory / lockfile_name;
57
58    // If a lock for this directory already exists in the map, don't try to re-lock it
59    if (dir_locks.contains(fs::PathToString(pathLockFile))) {
60        return LockResult::Success;
61    }
62
63    // Create empty lock file if it doesn't exist.
64    if (auto created{fsbridge::fopen(pathLockFile, "a")}) {
65        std::fclose(created);
66    } else {
67        return LockResult::ErrorWrite;
68    }
69    auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
70    if (!lock->TryLock()) {
71        LogError("Error while attempting to lock directory %s: %s\n", fs::PathToString(directory), lock->GetReason());
72        return LockResult::ErrorLock;
73    }
74    if (!probe_only) {
75        // Lock successful and we're not just probing, put it into the map
76        dir_locks.emplace(fs::PathToString(pathLockFile), std::move(lock));
77    }
78    return LockResult::Success;
79}
80} // namespace util
81void UnlockDirectory(const fs::path& directory, const fs::path& lockfile_name)
82{
83    LOCK(cs_dir_locks);
84    dir_locks.erase(fs::PathToString(directory / lockfile_name));
85}
86
87void ReleaseDirectoryLocks()
88{
89    LOCK(cs_dir_locks);
90    dir_locks.clear();
91}
92
93bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes)
94{
95    constexpr uint64_t min_disk_space{50_MiB};
96
97    uint64_t free_bytes_available = fs::space(dir).available;
98    return free_bytes_available >= min_disk_space + additional_bytes;
99}
100
101std::streampos GetFileSize(const char* path, std::streamsize max)
102{
103    std::ifstream file{path, std::ios::binary};
104    file.ignore(max);
105    return file.gcount();
106}
107
108bool FileCommit(FILE* file)
109{
110    if (fflush(file) != 0) { // harmless if redundantly called
111        LogError("fflush failed: %s", SysErrorString(errno));
112        return false;
113    }
114#ifdef WIN32
115    HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
116    if (FlushFileBuffers(hFile) == 0) {
117        LogError("FlushFileBuffers failed: %s", Win32ErrorString(GetLastError()));
118        return false;
119    }
120#elif defined(__APPLE__) && defined(F_FULLFSYNC)
121    if (fcntl(fileno(file), F_FULLFSYNC, 0) == -1) { // Manpage says "value other than -1" is returned on success
122        LogError("fcntl F_FULLFSYNC failed: %s", SysErrorString(errno));
123        return false;
124    }
125#elif HAVE_FDATASYNC
126    if (fdatasync(fileno(file)) != 0 && errno != EINVAL) { // Ignore EINVAL for filesystems that don't support sync
127        LogError("fdatasync failed: %s", SysErrorString(errno));
128        return false;
129    }
130#else
131    if (fsync(fileno(file)) != 0 && errno != EINVAL) {
132        LogError("fsync failed: %s", SysErrorString(errno));
133        return false;
134    }
135#endif
136    return true;
137}
138
139void DirectoryCommit(const fs::path& dirname)
140{
141#ifndef WIN32
142    FILE* file = fsbridge::fopen(dirname, "r");
143    if (file) {
144        fsync(fileno(file));
145        fclose(file);
146    }
147#endif
148}
149
150bool TruncateFile(FILE* file, uint64_t length)
151{
152#if defined(WIN32)
153    return _chsize_s(_fileno(file), length) == 0;
154#else
155    return ftruncate(fileno(file), length) == 0;
156#endif
157}
158
159int RaiseFileDescriptorLimit(int min_fd)
160{
161    Assert(min_fd >= 0);
162#if defined(WIN32)
163    return 2048;
164#else
165    struct rlimit limitFD;
166    if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
167        // If the current soft limit is already higher, don't raise it
168        if (limitFD.rlim_cur != RLIM_INFINITY && std::cmp_less(limitFD.rlim_cur, min_fd)) {
169            const auto current_limit{limitFD.rlim_cur};
170            static_assert(std::in_range<rlim_t>(std::numeric_limits<int>::max()));
171            limitFD.rlim_cur = static_cast<rlim_t>(min_fd);
172            // Don't raise soft limit beyond hard limit
173            if ((limitFD.rlim_max != RLIM_INFINITY) && (limitFD.rlim_cur > limitFD.rlim_max)) {
174                limitFD.rlim_cur = limitFD.rlim_max;
175            }
176            if (current_limit != limitFD.rlim_cur) {
177                setrlimit(RLIMIT_NOFILE, &limitFD);
178                getrlimit(RLIMIT_NOFILE, &limitFD);
179            }
180        }
181        // Check the (possibly raised) current soft limit against the special
182        // value of RLIM_INFINITY. Some platforms implement this as the maximum
183        // uint64, others as int64 (-1). Avoid casting even if the return type
184        // is changed to uint64_t. We also cap unlikely but possible values
185        // that would overflow int.
186        if (limitFD.rlim_cur == RLIM_INFINITY ||
187            std::cmp_greater_equal(limitFD.rlim_cur, std::numeric_limits<int>::max())) {
188            return std::numeric_limits<int>::max();
189        }
190        return static_cast<int>(limitFD.rlim_cur);
191    }
192    return min_fd; // getrlimit failed, assume it's fine
193#endif
194}
195
196/**
197 * this function tries to make a particular range of a file allocated (corresponding to disk space)
198 * it is advisory, and the range specified in the arguments will never contain live data
199 */
200void AllocateFileRange(FILE* file, uint64_t offset, unsigned int length)
201{
202#if defined(WIN32)
203    // Windows-specific version
204    HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
205    LARGE_INTEGER nFileSize;
206    int64_t nEndPos = (int64_t)offset + length;
207    nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
208    nFileSize.u.HighPart = nEndPos >> 32;
209    SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
210    SetEndOfFile(hFile);
211#elif defined(__APPLE__)
212    // OSX specific version
213    // NOTE: Contrary to other OS versions, the OSX version assumes that
214    // NOTE: offset is the size of the file.
215    fstore_t fst;
216    fst.fst_flags = F_ALLOCATECONTIG;
217    fst.fst_posmode = F_PEOFPOSMODE;
218    fst.fst_offset = 0;
219    fst.fst_length = length; // mac os fst_length takes the # of free bytes to allocate, not desired file size
220    fst.fst_bytesalloc = 0;
221    if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
222        fst.fst_flags = F_ALLOCATEALL;
223        fcntl(fileno(file), F_PREALLOCATE, &fst);
224    }
225    ftruncate(fileno(file), static_cast<off_t>(offset) + length);
226#else
227#if defined(HAVE_POSIX_FALLOCATE)
228    // Version using posix_fallocate
229    off_t nEndPos = (off_t)offset + length;
230    if (0 == posix_fallocate(fileno(file), 0, nEndPos)) return;
231#endif
232    // Fallback version
233    // TODO: just write one byte per block
234    static const char buf[65536] = {};
235    if (FileSeek64(file, offset, SEEK_SET)) {
236        return;
237    }
238    while (length > 0) {
239        unsigned int now = 65536;
240        if (length < now)
241            now = length;
242        fwrite(buf, 1, now, file); // allowed to fail; this function is advisory anyway
243        length -= now;
244    }
245#endif
246}
247
248#ifdef WIN32
249fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
250{

src/wallet/receive.cpp

src/wallet/coinselection.cpp

src/consensus/validation.h

src/primitives/transaction.cpp

src/script/descriptor.cpp

src/bitcoin-cli.cpp

src/rpc/blockchain.cpp

src/rpc/rawtransaction.cpp

src/init.cpp

src/crypto/sha256.cpp

src/consensus/merkle.h

src/consensus/tx_check.h

src/consensus/tx_verify.h

src/policy/feerate.h

src/policy/feerate.cpp

src/primitives/transaction_identifier.h

src/chainparamsbase.h

src/chainparamsbase.cpp

src/util/moneystr.cpp

src/crypto/ripemd160.h

src/crypto/sha1.h

src/crypto/sha512.h

src/crypto/hmac_sha256.h

src/crypto/hmac_sha512.h

src/crypto/hmac_sha256.cpp

src/crypto/hmac_sha512.cpp

src/crypto/hkdf_sha256_32.h

src/crypto/hkdf_sha256_32.cpp

src/support/cleanse.h

src/support/cleanse.cpp

src/crypto/siphash.cpp

src/crypto/muhash.h

src/crypto/chacha20.h

src/crypto/poly1305.h

src/crypto/chacha20poly1305.h

src/crypto/chacha20poly1305.cpp

src/util/chaintype.cpp

src/util/obfuscation.h

src/util/byte_units.h

src/util/overflow.h

src/blockencodings.cpp

src/net_permissions.cpp

src/policy/packages.cpp

src/policy/rbf.cpp

src/policy/truc_policy.cpp

src/policy/ephemeral_policy.cpp

src/policy/settings.cpp

src/policy/policy.cpp

src/node/transaction.cpp

src/node/coin.cpp

src/rpc/client.cpp

src/rpc/external_signer.cpp

src/rpc/request.cpp

src/rpc/server_util.cpp

src/rpc/fees.cpp

src/rpc/output_script.cpp

src/rpc/rawtransaction_util.cpp

src/rpc/rawtransaction_util.h

src/rpc/register.h

src/rpc/request.h

src/rpc/server_util.h

src/rpc/protocol.h

src/rpc/server.h

src/rpc/signmessage.cpp

src/rpc/txoutproof.cpp

src/rpc/util.cpp

src/rpc/util.h

src/wallet/rpc/addresses.cpp

src/wallet/rpc/backup.cpp

src/wallet/rpc/coins.cpp

src/wallet/rpc/encrypt.cpp

src/wallet/rpc/signmessage.cpp

src/wallet/rpc/util.cpp

src/wallet/rpc/util.h

src/wallet/coincontrol.cpp

src/wallet/coincontrol.h

src/wallet/context.cpp

src/wallet/context.h

src/wallet/crypter.cpp

src/wallet/crypter.h

src/wallet/db.cpp

src/wallet/export.cpp

src/wallet/external_signer_scriptpubkeyman.cpp

src/wallet/rpc/spend.cpp

src/wallet/rpc/transactions.cpp

src/wallet/rpc/wallet.cpp

src/wallet/feebumper.cpp

src/wallet/feebumper.h

src/index/base.h

src/index/base.cpp

src/index/txindex.h

src/index/txindex.cpp

src/index/txindex_key.h

src/index/txospenderindex.h

src/index/txospenderindex.cpp

src/index/blockfilterindex.h

src/index/blockfilterindex.cpp

src/index/coinstatsindex.h

src/index/coinstatsindex.cpp

src/index/db_key.h

src/index/disktxpos.h

src/kernel/chain.cpp

src/kernel/chain.h

src/kernel/checks.cpp

src/kernel/checks.h

src/kernel/context.cpp

src/kernel/context.h

src/kernel/cs_main.cpp

src/kernel/cs_main.h

src/kernel/disconnected_transactions.cpp

src/kernel/disconnected_transactions.h

src/kernel/mempool_removal_reason.cpp

src/kernel/mempool_removal_reason.h

src/kernel/coinstats.cpp

src/kernel/coinstats.h

src/kernel/chainparams.cpp

src/kernel/chainparams.h

src/wallet/sqlite.cpp

src/wallet/sqlite.h

src/wallet/transaction.cpp

src/wallet/transaction.h

src/wallet/dump.cpp

src/wallet/dump.h

src/wallet/init.cpp

src/wallet/walletutil.cpp

src/wallet/walletutil.h

src/wallet/wallettool.cpp

src/wallet/wallettool.h

src/wallet/export.h

src/wallet/migrate.cpp

src/wallet/migrate.h

src/wallet/db.h

src/wallet/walletdb.cpp

src/wallet/interfaces.cpp

src/wallet/scriptpubkeyman.cpp

src/wallet/scriptpubkeyman.h

src/kernel/bitcoinkernel.cpp

src/kernel/bitcoinkernel.h

src/kernel/bitcoinkernel_wrapper.h

src/node/chainstate.cpp

src/node/chainstate.h

src/node/blockstorage.cpp

src/node/blockstorage.h

src/node/mempool_persist.cpp

src/node/mempool_persist.h

src/node/utxo_snapshot.cpp

src/node/utxo_snapshot.h

src/node/kernel_notifications.cpp

src/node/kernel_notifications.h

src/node/blockmanager_args.cpp

src/kernel/blockmanager_opts.h

src/util/expected.cpp

src/policy/settings.h

src/util/types.h

src/kernel/messagestartchars.h

src/kernel/warning.h

src/util/exception.h

src/common/license_info.h

src/node/coins_view_args.h

src/node/database_args.h

src/util/batchpriority.h

src/util/ui_change_type.h

src/node/coins_view_args.cpp

src/node/peerman_args.h

src/util/serfloat.h

src/node/blockmanager_args.h

src/node/database_args.cpp

src/util/overloaded.h

src/interfaces/types.h

src/node/chainstatemanager_args.h

src/node/minisketchwrapper.h

src/util/macros.h

src/util/syserror.h

src/common/run_command.h

src/util/bytevectorhash.cpp

src/node/mempool_persist_args.cpp

src/util/exec.h

src/util/rbf.h

src/crypto/hex_base.h

src/node/mempool_persist_args.h

src/interfaces/echo.h

src/util/any.h

src/util/batchpriority.cpp

src/util/threadnames.h

src/node/coin.h

src/node/mempool_args.h

src/util/asmap.h

src/util/bytevectorhash.h

src/node/context.cpp

src/util/insert.h

src/util/readwritefile.h

src/node/peerman_args.cpp

src/node/interface_ui.cpp

src/interfaces/handler.h

src/node/mining_args.h

src/util/hasher.cpp

src/common/init.h

src/kernel/mempool_limits.h

src/common/system.h

src/crypto/sha3.h

src/util/threadinterrupt.cpp

src/node/protocol_version.h

src/util/exception.cpp

src/common/messages.h

src/node/connection_types.cpp

src/util/bip32.h

src/common/license_info.cpp

src/util/stdmutex.h

src/common/run_command.cpp

src/util/check.cpp

src/util/golombrice.h

src/node/types.h

src/node/timeoffsets.h

src/util/readwritefile.cpp

src/util/fastrange.h

src/util/signalinterrupt.h

src/util/task_runner.h

src/util/syserror.cpp

src/common/interfaces.cpp

src/common/types.h

src/util/threadinterrupt.h

src/kernel/chainstatemanager_opts.h

src/node/psbt.h

src/policy/ephemeral_policy.h

src/util/trace.h

src/common/url.cpp

src/kernel/mempool_options.h

src/util/serfloat.cpp

src/kernel/notifications_interface.h

src/node/timeoffsets.cpp

src/node/warnings.cpp

src/util/hash_type.h

src/crypto/hex_base.cpp

src/node/eviction.h

src/util/tokenbucket.h

src/crypto/aes.h

src/common/pcp.h

src/util/feefrac.cpp

src/node/transaction.h

src/util/threadnames.cpp

src/common/signmessage.h

src/util/exec.cpp

src/util/signalinterrupt.cpp

Independent explanations by MyBitcoinExplorer. Not affiliated with or endorsed by Bitcoin Core. Guides are educational and do not replace the source or its tests.

Bitcoin Core source © its contributors, distributed under the MIT license. Original notices and bundled third-party licenses are retained in the source tree.