From 51d617e70f90a972185917ea0096c1ecef2bfa8b Mon Sep 17 00:00:00 2001 From: Bitflash-sh Date: Fri, 24 Jul 2026 11:18:11 -0300 Subject: Bitflash: fair-launch release Satoshi's bitcoin-0.1.0 reborn with RandomX CPU proof of work, anonymous .btf addressing over Nostr with CGNAT rendezvous, automatic peer discovery, a headless Linux node, and Windows GUI wallet. Fair launch, no premine, 21M cap. --- src/compat.h | 193 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 src/compat.h (limited to 'src/compat.h') diff --git a/src/compat.h b/src/compat.h new file mode 100644 index 0000000..e3f76a1 --- /dev/null +++ b/src/compat.h @@ -0,0 +1,193 @@ +// Copyright (c) 2026 Bitflash developers +// Distributed under the MIT/X11 software license. +// +// POSIX/Linux compatibility shim. Lets the Windows-flavored core (Winsock, +// _beginthread, CRITICAL_SECTION, Sleep, ...) compile largely unchanged on +// Linux for the headless node/miner `bitflash-node`. Included by headers.h on +// non-Windows platforms only; the Windows build never sees this file. + +#ifndef BITFLASH_COMPAT_H +#define BITFLASH_COMPAT_H +#ifndef _WIN32 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// ---- Windows integer/type aliases used across the core ---- +typedef unsigned int DWORD; +typedef void* HANDLE; +typedef int64_t LARGE_INTEGER; +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif +#ifndef _I64_MAX +#define _I64_MAX 0x7fffffffffffffffLL +#define _I64_MIN (-0x7fffffffffffffffLL - 1) +#endif +#ifndef _UI64_MAX +#define _UI64_MAX 0xffffffffffffffffULL +#endif + +// High-resolution counter (used only for optional timing in the core). +inline void QueryPerformanceCounter(LARGE_INTEGER* p) +{ + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + *p = (int64_t)ts.tv_sec * 1000000000LL + ts.tv_nsec; +} + +// ---- socket layer (Winsock -> BSD sockets) ---- +typedef int SOCKET; +#ifndef INVALID_SOCKET +#define INVALID_SOCKET (-1) +#endif +#ifndef SOCKET_ERROR +#define SOCKET_ERROR (-1) +#endif +#ifndef NO_ERROR +#define NO_ERROR 0 +#endif +#define closesocket(s) ::close(s) +inline int WSAGetLastError() { return errno; } + +// Winsock error codes mapped to POSIX errno values +#define WSAEWOULDBLOCK EWOULDBLOCK +#define WSAEMSGSIZE EMSGSIZE +#define WSAEINTR EINTR +#define WSAEINPROGRESS EINPROGRESS +#define WSAEADDRINUSE EADDRINUSE +#define WSAEALREADY EALREADY +#define WSAECONNREFUSED ECONNREFUSED +#define WSAENOTSOCK EBADF + +// Only FIONBIO (non-blocking toggle) is used; implement it robustly via fcntl. +inline int ioctlsocket(SOCKET s, long cmd, u_long* argp) +{ + if (cmd == (long)FIONBIO) + { + int flags = fcntl(s, F_GETFL, 0); + if (flags < 0) return -1; + if (*argp) flags |= O_NONBLOCK; else flags &= ~O_NONBLOCK; + return fcntl(s, F_SETFL, flags); + } + return ioctl(s, cmd, argp); +} + +// WSAStartup/WSACleanup are no-ops outside Windows. +typedef int WSADATA; +inline int WSAStartup(unsigned short, WSADATA*) { return 0; } +inline int WSACleanup() { return 0; } +#ifndef MAKEWORD +#define MAKEWORD(a, b) 0 +#endif + +// ---- Sleep(ms) ---- +inline void Sleep(unsigned int ms) +{ + struct timespec ts; + ts.tv_sec = ms / 1000; + ts.tv_nsec = (long)(ms % 1000) * 1000000L; + nanosleep(&ts, NULL); +} + +// ---- threads: _beginthread / _endthread over pthreads ---- +struct _bf_thread_ctx { void (*fn)(void*); void* arg; }; +inline void* _bf_thread_trampoline(void* p) +{ + _bf_thread_ctx* c = (_bf_thread_ctx*)p; + void (*fn)(void*) = c->fn; + void* arg = c->arg; + delete c; + fn(arg); + return NULL; +} +inline uintptr_t _beginthread(void (*start)(void*), unsigned, void* arg) +{ + _bf_thread_ctx* c = new _bf_thread_ctx; + c->fn = start; c->arg = arg; + pthread_t th; + if (pthread_create(&th, NULL, _bf_thread_trampoline, c) != 0) + { + delete c; + return (uintptr_t)-1; + } + pthread_detach(th); + return (uintptr_t)th; +} +inline void _endthread() { pthread_exit(NULL); } + +// ---- CRITICAL_SECTION over a recursive mutex (util.h's CCriticalSection +// compiles unchanged on top of these) ---- +typedef pthread_mutex_t CRITICAL_SECTION; +inline void InitializeCriticalSection(CRITICAL_SECTION* cs) +{ + pthread_mutexattr_t a; + pthread_mutexattr_init(&a); + pthread_mutexattr_settype(&a, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(cs, &a); + pthread_mutexattr_destroy(&a); +} +inline void DeleteCriticalSection(CRITICAL_SECTION* cs) { pthread_mutex_destroy(cs); } +inline void EnterCriticalSection(CRITICAL_SECTION* cs) { pthread_mutex_lock(cs); } +inline void LeaveCriticalSection(CRITICAL_SECTION* cs) { pthread_mutex_unlock(cs); } +inline bool TryEnterCriticalSection(CRITICAL_SECTION* cs) { return pthread_mutex_trylock(cs) == 0; } + +// ---- misc Windows CRT/debug helpers ---- +inline void OutputDebugStringA(const char*) {} +inline void DebugBreak() {} +#ifndef _HEAPOK +#define _HEAPOK 0 +#endif +inline int _heapchk() { return _HEAPOK; } +#define _vsnprintf vsnprintf +inline char* strlwr(char* s) { for (char* p = s; *p; ++p) *p = (char)tolower((unsigned char)*p); return s; } +#define _strlwr strlwr +inline int _mkdir(const char* p) { return ::mkdir(p, 0755); } + +// Thread priority is a Windows nicety; on Linux the message-handler thread just +// runs at normal priority (harmless no-op). +inline void* GetCurrentThread() { return (void*)0; } +inline void SetThreadPriority(void*, int) {} +#ifndef THREAD_PRIORITY_BELOW_NORMAL +#define THREAD_PRIORITY_BELOW_NORMAL 0 +#define THREAD_PRIORITY_LOWEST 0 +#define THREAD_PRIORITY_NORMAL 0 +#endif + +// ---- wxWidgets shims (the headless build has no GUI; the few core call sites +// degrade to console/no-op) ---- +#define wxTheApp ((void*)0) +#ifndef wxOK +#define wxOK 0 +#define wxICON_ERROR 0 +#define wxICON_EXCLAMATION 0 +#define wxICON_INFORMATION 0 +#endif +inline void wxMessageBox(const std::string& msg, const std::string& caption = "", long = 0) +{ + fprintf(stderr, "%s%s%s\n", caption.c_str(), caption.empty() ? "" : ": ", msg.c_str()); +} + +#endif // !_WIN32 +#endif // BITFLASH_COMPAT_H -- cgit v1.2.3