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/btfrv.cpp | 250 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 src/btfrv.cpp (limited to 'src/btfrv.cpp') diff --git a/src/btfrv.cpp b/src/btfrv.cpp new file mode 100644 index 0000000..ffda08c --- /dev/null +++ b/src/btfrv.cpp @@ -0,0 +1,250 @@ +// Copyright (c) 2026 Bitflash developers +// Distributed under the MIT/X11 software license. +// +// Bitflash rendezvous transport. See btfrv.h. +// Windows/Winsock implementation (Layer 6 will #ifdef this for Linux/BSD sockets). + +#include "btfrv.h" + +// Portable sockets: Winsock on Windows, BSD sockets on Linux/POSIX (for the +// headless relay `bitflashd` that runs on the VPS). +#ifdef _WIN32 +#include +#include +#define CLOSESOCK closesocket +#else +#include +#include +#include +#include +#include +#include +typedef int SOCKET; +#define INVALID_SOCKET (-1) +#define SOCKET_ERROR (-1) +#define CLOSESOCK ::close +#ifndef SD_BOTH +#define SD_BOTH SHUT_RDWR +#endif +#endif + +#include +#include +#include +#include +#include +#include +#include + +namespace btf +{ + +static std::atomic g_stop(false); +static SOCKET g_listen = INVALID_SOCKET; + +// Services that have registered and are waiting for a client, keyed by pubkey. +static std::map g_waiting; +static std::mutex g_mtx; + +bool RvInit() +{ + static bool done = false; + if (done) return true; +#ifdef _WIN32 + WSADATA wsa; + if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) return false; +#else + signal(SIGPIPE, SIG_IGN); // don't die when writing to a closed peer +#endif + done = true; + return true; +} + +// ---- low-level helpers ---- + +static bool ReadN(SOCKET s, void* buf, int n) +{ + char* p = (char*)buf; + int off = 0; + while (off < n) + { + int r = recv(s, p + off, n - off, 0); + if (r <= 0) return false; + off += r; + } + return true; +} + +static bool WriteN(SOCKET s, const void* buf, int n) +{ + const char* p = (const char*)buf; + int off = 0; + while (off < n) + { + int r = send(s, p + off, n - off, 0); + if (r <= 0) return false; + off += r; + } + return true; +} + +static SOCKET ConnectTo(const char* host, unsigned short port) +{ + struct addrinfo hints, *res = NULL; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_STREAM; + char portstr[16]; sprintf(portstr, "%u", (unsigned)port); + if (getaddrinfo(host, portstr, &hints, &res) != 0 || !res) return INVALID_SOCKET; + SOCKET s = socket(res->ai_family, res->ai_socktype, res->ai_protocol); + if (s == INVALID_SOCKET) { freeaddrinfo(res); return INVALID_SOCKET; } + if (connect(s, res->ai_addr, (int)res->ai_addrlen) != 0) + { + CLOSESOCK(s); freeaddrinfo(res); return INVALID_SOCKET; + } + freeaddrinfo(res); + return s; +} + +// ---- relay side ---- + +// Pump bytes from `from` to `to`. Owns closing `from`; shuts down `to` on exit +// so the peer-direction thread unblocks and closes its own socket exactly once. +static void Forward(SOCKET from, SOCKET to) +{ + char buf[32 * 1024]; + for (;;) + { + int r = recv(from, buf, sizeof(buf), 0); + if (r <= 0) break; + if (!WriteN(to, buf, r)) break; + } + shutdown(to, SD_BOTH); + CLOSESOCK(from); +} + +static void HandleIncoming(SOCKET s) +{ + unsigned char hdr[33]; + if (!ReadN(s, hdr, 33)) { CLOSESOCK(s); return; } + char role = (char)hdr[0]; + std::string pubkey((char*)hdr + 1, 32); + + if (role == 'S') + { + // Register and wait; a future client will pair us. + std::lock_guard lk(g_mtx); + // If a stale service for this key exists, drop it. + std::map::iterator it = g_waiting.find(pubkey); + if (it != g_waiting.end()) CLOSESOCK(it->second); + g_waiting[pubkey] = s; + // leave the socket open in the map; do not close here. + } + else if (role == 'C') + { + SOCKET svc = INVALID_SOCKET; + { + std::lock_guard lk(g_mtx); + std::map::iterator it = g_waiting.find(pubkey); + if (it != g_waiting.end()) { svc = it->second; g_waiting.erase(it); } + } + if (svc == INVALID_SOCKET) + { + unsigned char no = 0x00; + WriteN(s, &no, 1); + CLOSESOCK(s); + return; + } + // Pair: tell both sides, then forward raw bytes bidirectionally. + unsigned char ok = 0x01; + bool a = WriteN(svc, &ok, 1); + bool b = WriteN(s, &ok, 1); + if (!a || !b) { CLOSESOCK(svc); CLOSESOCK(s); return; } + std::thread(Forward, s, svc).detach(); + std::thread(Forward, svc, s).detach(); + } + else + { + CLOSESOCK(s); + } +} + +bool RvRelayRun(unsigned short port) +{ + if (!RvInit()) return false; + g_stop = false; + + g_listen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (g_listen == INVALID_SOCKET) return false; + int yes = 1; + setsockopt(g_listen, SOL_SOCKET, SO_REUSEADDR, (char*)&yes, sizeof(yes)); + + struct sockaddr_in addr; + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = INADDR_ANY; + addr.sin_port = htons(port); + if (bind(g_listen, (struct sockaddr*)&addr, sizeof(addr)) != 0) { CLOSESOCK(g_listen); return false; } + if (listen(g_listen, 16) != 0) { CLOSESOCK(g_listen); return false; } + + while (!g_stop) + { + struct sockaddr_in cli; + socklen_t len = sizeof(cli); + SOCKET s = accept(g_listen, (struct sockaddr*)&cli, &len); + if (s == INVALID_SOCKET) + { + if (g_stop) break; + continue; + } + std::thread(HandleIncoming, s).detach(); + } + CLOSESOCK(g_listen); + g_listen = INVALID_SOCKET; + return true; +} + +void RvRelayStop() +{ + g_stop = true; + if (g_listen != INVALID_SOCKET) + CLOSESOCK(g_listen); // unblock accept() +} + +// ---- service / client helpers ---- + +RvSocket RvServiceRegister(const char* relay_host, unsigned short port, + const unsigned char my_pubkey[32]) +{ + if (!RvInit()) return RV_INVALID; + SOCKET s = ConnectTo(relay_host, port); + if (s == INVALID_SOCKET) return RV_INVALID; + unsigned char hdr[33]; + hdr[0] = (unsigned char)'S'; + memcpy(hdr + 1, my_pubkey, 32); + if (!WriteN(s, hdr, 33)) { CLOSESOCK(s); return RV_INVALID; } + unsigned char paired = 0; + if (!ReadN(s, &paired, 1) || paired != 0x01) { CLOSESOCK(s); return RV_INVALID; } + return (RvSocket)s; +} + +RvSocket RvClientConnect(const char* relay_host, unsigned short port, + const unsigned char target_pubkey[32]) +{ + if (!RvInit()) return RV_INVALID; + SOCKET s = ConnectTo(relay_host, port); + if (s == INVALID_SOCKET) return RV_INVALID; + unsigned char hdr[33]; + hdr[0] = (unsigned char)'C'; + memcpy(hdr + 1, target_pubkey, 32); + if (!WriteN(s, hdr, 33)) { CLOSESOCK(s); return RV_INVALID; } + unsigned char paired = 0; + if (!ReadN(s, &paired, 1) || paired != 0x01) { CLOSESOCK(s); return RV_INVALID; } + return (RvSocket)s; +} + +bool RvReadN(RvSocket s, void* buf, int n) { return ReadN((SOCKET)s, buf, n); } +bool RvWriteN(RvSocket s, const void* buf, int n) { return WriteN((SOCKET)s, buf, n); } +void RvClose(RvSocket s) { if (s != RV_INVALID) CLOSESOCK((SOCKET)s); } + +} // namespace btf -- cgit v1.2.3