// Copyright (c) 2009 Satoshi Nakamoto // Distributed under the MIT/X11 software license, see the accompanying // file license.txt or http://www.opensource.org/licenses/mit-license.php. #include "headers.h" #ifdef _WIN32 #include #endif #include #include "btfaddr.h" #include "btftunnel.h" void ThreadMessageHandler2(void* parg); void ThreadSocketHandler2(void* parg); // // Global state variables // bool fClient = false; uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK); CAddress addrLocalHost(0, DEFAULT_PORT, nLocalServices); unsigned short nListenPort = DEFAULT_PORT; // local P2P port (tunable via /port) CNode nodeLocalHost(INVALID_SOCKET, CAddress("127.0.0.1", nLocalServices)); CNode* pnodeLocalHost = &nodeLocalHost; bool fShutdown = false; array vfThreadRunning; vector vNodes; CCriticalSection cs_vNodes; map mapRelay; deque > vRelayExpiration; CCriticalSection cs_mapRelay; map mapAlreadyAskedFor; string strBtfConnect; // .btf peer to keep connected to (from /connectbtf) bool GetMyExternalIP(unsigned int& ipRet) { // Try several plain-text IP echo services in order. // Each returns just the IPv4 address as the first line of the HTTP body. struct { const char* host; const char* path; } services[] = { { "api4.ipify.org", "/" }, { "icanhazip.com", "/" }, { "ipecho.net", "/plain" }, { "checkip.amazonaws.com", "/" }, }; for (auto& svc : services) { struct addrinfo hints, *res = NULL; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; if (getaddrinfo(svc.host, "80", &hints, &res) != 0 || !res) continue; SOCKET hSocket = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (hSocket == INVALID_SOCKET) { freeaddrinfo(res); continue; } // 5-second timeout so a dead service doesn't stall startup #ifdef _WIN32 DWORD tv = 5000; setsockopt(hSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)); setsockopt(hSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&tv, sizeof(tv)); #else struct timeval tv; tv.tv_sec = 5; tv.tv_usec = 0; setsockopt(hSocket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); setsockopt(hSocket, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); #endif if (connect(hSocket, res->ai_addr, (int)res->ai_addrlen) != 0) { freeaddrinfo(res); closesocket(hSocket); continue; } freeaddrinfo(res); string req = string("GET ") + svc.path + " HTTP/1.0\r\nHost: " + svc.host + "\r\nConnection: close\r\n\r\n"; send(hSocket, req.c_str(), (int)req.size(), 0); // Read response, skip HTTP headers, grab first line of body string response; char buf[256]; int n; while ((n = recv(hSocket, buf, sizeof(buf)-1, 0)) > 0) { buf[n] = 0; response += buf; if (response.size() > 4096) break; } closesocket(hSocket); // Find blank line separating headers from body size_t bodyPos = response.find("\r\n\r\n"); if (bodyPos == string::npos) bodyPos = response.find("\n\n"); if (bodyPos == string::npos) continue; string body = response.substr(bodyPos + (response[bodyPos+2]=='\r' ? 4 : 2)); // Trim whitespace while (!body.empty() && (body.back() == '\n' || body.back() == '\r' || body.back() == ' ')) body.pop_back(); // Parse as IP CAddress addr(body.c_str()); if (addr.ip == 0) continue; printf("GetMyExternalIP() via %s: %s\n", svc.host, body.c_str()); ipRet = addr.ip; return true; } return error("GetMyExternalIP() : all services failed\n"); } void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1) { // If the dialog might get closed before the reply comes back, // call this in the destructor so it doesn't get called after it's deleted. CRITICAL_BLOCK(cs_vNodes) { foreach(CNode* pnode, vNodes) { CRITICAL_BLOCK(pnode->cs_mapRequests) { for (map::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();) { CRequestTracker& tracker = (*mi).second; if (tracker.fn == fn && tracker.param1 == param1) pnode->mapRequests.erase(mi++); else mi++; } } } } } // // Subscription methods for the broadcast and subscription system. // Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT. // // The subscription system uses a meet-in-the-middle strategy. // With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers // subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through. // bool AnySubscribed(unsigned int nChannel) { if (pnodeLocalHost->IsSubscribed(nChannel)) return true; CRITICAL_BLOCK(cs_vNodes) foreach(CNode* pnode, vNodes) if (pnode->IsSubscribed(nChannel)) return true; return false; } bool CNode::IsSubscribed(unsigned int nChannel) { if (nChannel >= vfSubscribe.size()) return false; return vfSubscribe[nChannel]; } void CNode::Subscribe(unsigned int nChannel, unsigned int nHops) { if (nChannel >= vfSubscribe.size()) return; if (!AnySubscribed(nChannel)) { // Relay subscribe CRITICAL_BLOCK(cs_vNodes) foreach(CNode* pnode, vNodes) if (pnode != this) pnode->PushMessage("subscribe", nChannel, nHops); } vfSubscribe[nChannel] = true; } void CNode::CancelSubscribe(unsigned int nChannel) { if (nChannel >= vfSubscribe.size()) return; // Prevent from relaying cancel if wasn't subscribed if (!vfSubscribe[nChannel]) return; vfSubscribe[nChannel] = false; if (!AnySubscribed(nChannel)) { // Relay subscription cancel CRITICAL_BLOCK(cs_vNodes) foreach(CNode* pnode, vNodes) if (pnode != this) pnode->PushMessage("sub-cancel", nChannel); // Clear memory, no longer subscribed if (nChannel == MSG_PRODUCT) CRITICAL_BLOCK(cs_mapProducts) mapProducts.clear(); } } CNode* FindNode(unsigned int ip) { CRITICAL_BLOCK(cs_vNodes) { foreach(CNode* pnode, vNodes) if (pnode->addr.ip == ip) return (pnode); } return NULL; } // Synthetic marker address for a tunneled `.btf` peer. The real endpoint is // unknown by design (the tunnel hides it), so tag the CNode with a non-routable // 10.x.x.x address (fails IsRoutable, so it is never gossiped as a real peer) // that is stable per identity, keeping FindNode and the duplicate check working. static CAddress BtfMarkerAddr(const unsigned char b5[5]) { unsigned int ip; unsigned char b[4] = { 10, b5[0], b5[1], b5[2] }; memcpy(&ip, b, 4); unsigned short port = htons((unsigned short)((b5[3] << 8) | b5[4])); return CAddress(ip, port, nLocalServices); } // Shared tail: given a peer's pubkey and already-resolved rendezvous // coordinates, open the tunnel and register the CNode. Used by both // ConnectNodeBtf (which resolves the descriptor itself) and // ConnectNodeBtfResolved (which takes an already-resolved descriptor, so it // makes no Nostr relay calls at all -- see nostr.cpp's BtfResolveMany for why // that matters when dialing many candidates in parallel). static CNode* ConnectNodeBtfTail(const string& strBtfAddr, const unsigned char pk[32], const string& strMeeting, const unsigned char enc_pub[32]) { CAddress addr = BtfMarkerAddr(pk); CNode* pnode = FindNode(addr.ip); if (pnode) { pnode->AddRef(); return pnode; } size_t colon = strMeeting.rfind(':'); if (colon == string::npos) return NULL; string strHost = strMeeting.substr(0, colon); int nPort = atoi(strMeeting.substr(colon + 1).c_str()); if (nPort <= 0 || nPort > 65535) return NULL; btf_socket_t hSocket = btf::BtfClientTunnel(strHost.c_str(), (unsigned short)nPort, pk, enc_pub); if (hSocket == INVALID_SOCKET) { if (fDebug) LogPrint("net", "ConnectNodeBtf: tunnel to %s via %s failed\n", strBtfAddr.c_str(), strMeeting.c_str()); return NULL; } if (fDebug) LogPrint("net", "connected %s via rendezvous %s\n", strBtfAddr.c_str(), strMeeting.c_str()); // Add node pnode = new CNode(hSocket, addr, false); pnode->AddRef(); CRITICAL_BLOCK(cs_vNodes) vNodes.push_back(pnode); return pnode; } // Connect to a peer by its `.btf` address: resolve the self-certified // descriptor over Nostr, then tunnel through its meeting node with the // end-to-end channel. Neither side ever learns the other's IP. CNode* ConnectNodeBtf(const string& strBtfAddr) { unsigned char pk[32]; if (!btf::ParseAddress(strBtfAddr, pk)) { LogPrint("net", "ConnectNodeBtf: invalid address %s\n", strBtfAddr.c_str()); return NULL; } if (BtfLocalAddress() == strBtfAddr) return NULL; // ourselves if (fDebug) LogPrint("net", "trying %s\n", strBtfAddr.c_str()); string strMeeting; unsigned char enc_pub[32]; if (!BtfResolve(strBtfAddr, strMeeting, enc_pub)) { if (fDebug) LogPrint("net", "ConnectNodeBtf: could not resolve a descriptor for %s\n", strBtfAddr.c_str()); return NULL; } return ConnectNodeBtfTail(strBtfAddr, pk, strMeeting, enc_pub); } // Same as ConnectNodeBtf, but skips the Nostr resolve step because the caller // already resolved the descriptor (e.g. via BtfResolveMany, batching many // addresses into one relay round-trip instead of one relay round-trip per // address). Makes zero relay connections -- only talks to the peer's // rendezvous meeting node. CNode* ConnectNodeBtfResolved(const string& strBtfAddr, const string& strMeeting, const unsigned char enc_pub[32]) { unsigned char pk[32]; if (!btf::ParseAddress(strBtfAddr, pk)) { LogPrint("net", "ConnectNodeBtf: invalid address %s\n", strBtfAddr.c_str()); return NULL; } if (BtfLocalAddress() == strBtfAddr) return NULL; // ourselves return ConnectNodeBtfTail(strBtfAddr, pk, strMeeting, enc_pub); } // Anonymous inbound listener (this node's `.btf` hidden service). Registers at // the meeting relay and blocks until a client dials our address; each pairing // becomes a normal inbound CNode riding the end-to-end channel, then we // register again for the next caller. void ThreadBtfAccept(void* parg) { printf("ThreadBtfAccept started\n"); unsigned char pk[32]; unsigned char sk[32]; while (!BtfGetIdentity(pk, sk)) { if (fShutdown) return; Sleep(5000); } size_t iRelay = 0; bool fPicked = false; loop { if (fShutdown) return; // Curated seeds + relays discovered from Nostr announcements. vector relays = BtfAllRelays(); if (relays.empty()) { Sleep(10000); // no meeting relay configured continue; } // Random start spreads nodes across all relays (incl. volunteer ones). if (!fPicked) { iRelay = (size_t)GetRand(relays.size()); fPicked = true; } // Stick to the current relay while it works; on failure, fail over to // the next one so a DDoS'd/blocked relay IP can't keep us offline. string strMeeting = relays[iRelay % relays.size()]; size_t colon = strMeeting.rfind(':'); if (colon == string::npos) { iRelay++; Sleep(2000); continue; } string strHost = strMeeting.substr(0, colon); int nPort = atoi(strMeeting.substr(colon + 1).c_str()); // Blocks until a client is paired to us (or the relay drops us) btf::RvSocket rv = btf::RvServiceRegister(strHost.c_str(), (unsigned short)nPort, pk); if (fShutdown) { if (rv != btf::RV_INVALID) btf::RvClose(rv); return; } if (rv == btf::RV_INVALID) { iRelay++; // this relay is down/attacked -> try the next one Sleep(3000); continue; } // Registered OK: advertise THIS relay in our descriptor so clients dial // us here, and keep using it (iRelay unchanged) until it fails. BtfSetActiveRelay(strMeeting); btf_socket_t hSocket = btf::BtfServiceWrap(rv, sk); if (hSocket == INVALID_SOCKET) continue; // The dialer is anonymous (its pubkey never reaches us), so tag the // connection with a random marker address. unsigned char rnd[5]; RAND_bytes(rnd, sizeof(rnd)); CAddress addr = BtfMarkerAddr(rnd); LogPrint("net", "accepted .btf connection via rendezvous %s\n", strMeeting.c_str()); CNode* pnode = new CNode(hSocket, addr, true); pnode->AddRef(); CRITICAL_BLOCK(cs_vNodes) vNodes.push_back(pnode); } } // Keep an outbound connection to a specific `.btf` peer (from /connectbtf) -- // the rendezvous analogue of addnode. Retries until connected, reconnects if // the tunnel drops. void ThreadBtfConnect(void* parg) { printf("ThreadBtfConnect started\n"); string strAddr = *(string*)parg; delete (string*)parg; loop { if (fShutdown) return; try { CNode* pnode = ConnectNodeBtf(strAddr); if (pnode) { if (!pnode->fNetworkNode) pnode->fNetworkNode = true; // keep the ref from ConnectNodeBtf else pnode->Release(); // already pinned; drop the extra ref } } CATCH_PRINT_EXCEPTION("ThreadBtfConnect") for (int i = 0; i < 30 && !fShutdown; i++) Sleep(1000); } } void CNode::Disconnect() { LogPrint("net", "disconnecting node %s\n", addr.ToString().c_str()); closesocket(hSocket); // All of a nodes broadcasts and subscriptions are automatically torn down // when it goes down, so a node has to stay up to keep its broadcast going. CRITICAL_BLOCK(cs_mapProducts) for (map::iterator mi = mapProducts.begin(); mi != mapProducts.end();) AdvertRemoveSource(this, MSG_PRODUCT, 0, (*(mi++)).second); // Cancel subscriptions for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++) if (vfSubscribe[nChannel]) CancelSubscribe(nChannel); } void ThreadSocketHandler(void* parg) { IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg)); loop { vfThreadRunning[0] = true; CheckForShutdown(0); try { ThreadSocketHandler2(parg); } CATCH_PRINT_EXCEPTION("ThreadSocketHandler()") vfThreadRunning[0] = false; Sleep(5000); } } void ThreadSocketHandler2(void* parg) { printf("ThreadSocketHandler started\n"); SOCKET hListenSocket = *(SOCKET*)parg; list vNodesDisconnected; int nPrevNodeCount = 0; loop { // // Disconnect nodes // CRITICAL_BLOCK(cs_vNodes) { // Disconnect duplicate connections map mapFirst; foreach(CNode* pnode, vNodes) { if (pnode->fDisconnect) continue; unsigned int ip = pnode->addr.ip; if (mapFirst.count(ip) && addrLocalHost.ip < ip) { // In case two nodes connect to each other at once, // the lower ip disconnects its outbound connection CNode* pnodeExtra = mapFirst[ip]; if (pnodeExtra->GetRefCount() > (pnodeExtra->fNetworkNode ? 1 : 0)) swap(pnodeExtra, pnode); if (pnodeExtra->GetRefCount() <= (pnodeExtra->fNetworkNode ? 1 : 0)) { LogPrint("net", "(%d nodes) disconnecting duplicate: %s\n", vNodes.size(), pnodeExtra->addr.ToString().c_str()); if (pnodeExtra->fNetworkNode && !pnode->fNetworkNode) { pnode->AddRef(); swap(pnodeExtra->fNetworkNode, pnode->fNetworkNode); pnodeExtra->Release(); } pnodeExtra->fDisconnect = true; } } mapFirst[ip] = pnode; } // Disconnect unused nodes vector vNodesCopy = vNodes; foreach(CNode* pnode, vNodesCopy) { if (pnode->ReadyToDisconnect() && pnode->vRecv.empty() && pnode->vSend.empty()) { // remove from vNodes vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end()); pnode->Disconnect(); // hold in disconnected pool until all refs are released pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 5 * 60); if (pnode->fNetworkNode) pnode->Release(); vNodesDisconnected.push_back(pnode); } } // Delete disconnected nodes list vNodesDisconnectedCopy = vNodesDisconnected; foreach(CNode* pnode, vNodesDisconnectedCopy) { // wait until threads are done using it if (pnode->GetRefCount() <= 0) { bool fDelete = false; TRY_CRITICAL_BLOCK(pnode->cs_vSend) TRY_CRITICAL_BLOCK(pnode->cs_vRecv) TRY_CRITICAL_BLOCK(pnode->cs_mapRequests) TRY_CRITICAL_BLOCK(pnode->cs_inventory) fDelete = true; if (fDelete) { vNodesDisconnected.remove(pnode); delete pnode; } } } } if (vNodes.size() != nPrevNodeCount) { nPrevNodeCount = vNodes.size(); MainFrameRepaint(); } // // Find which sockets have data to receive // struct timeval timeout; timeout.tv_sec = 0; timeout.tv_usec = 50000; // frequency to poll pnode->vSend fd_set fdsetRecv; fd_set fdsetSend; FD_ZERO(&fdsetRecv); FD_ZERO(&fdsetSend); SOCKET hSocketMax = 0; FD_SET(hListenSocket, &fdsetRecv); hSocketMax = max(hSocketMax, hListenSocket); CRITICAL_BLOCK(cs_vNodes) { foreach(CNode* pnode, vNodes) { FD_SET(pnode->hSocket, &fdsetRecv); hSocketMax = max(hSocketMax, pnode->hSocket); TRY_CRITICAL_BLOCK(pnode->cs_vSend) if (!pnode->vSend.empty()) FD_SET(pnode->hSocket, &fdsetSend); } } vfThreadRunning[0] = false; int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, NULL, &timeout); vfThreadRunning[0] = true; CheckForShutdown(0); if (nSelect == SOCKET_ERROR) { int nErr = WSAGetLastError(); LogPrint("net", "select failed: %d\n", nErr); for (int i = 0; i <= hSocketMax; i++) { FD_SET(i, &fdsetRecv); FD_SET(i, &fdsetSend); } Sleep(timeout.tv_usec/1000); } RandAddSeed(); //// debug print //foreach(CNode* pnode, vNodes) //{ // printf("vRecv = %-5d ", pnode->vRecv.size()); // printf("vSend = %-5d ", pnode->vSend.size()); //} //printf("\n"); // // Accept new connections // if (FD_ISSET(hListenSocket, &fdsetRecv)) { struct sockaddr_in sockaddr; #ifdef _WIN32 int len = sizeof(sockaddr); #else socklen_t len = sizeof(sockaddr); #endif SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len); CAddress addr(sockaddr); if (hSocket == INVALID_SOCKET) { if (WSAGetLastError() != WSAEWOULDBLOCK) printf("ERROR ThreadSocketHandler accept failed: %d\n", WSAGetLastError()); } else { LogPrint("net", "accepted connection from %s\n", addr.ToString().c_str()); CNode* pnode = new CNode(hSocket, addr, true); pnode->AddRef(); CRITICAL_BLOCK(cs_vNodes) vNodes.push_back(pnode); } } // // Service each socket // vector vNodesCopy; CRITICAL_BLOCK(cs_vNodes) vNodesCopy = vNodes; foreach(CNode* pnode, vNodesCopy) { CheckForShutdown(0); SOCKET hSocket = pnode->hSocket; // // Receive // if (FD_ISSET(hSocket, &fdsetRecv)) { TRY_CRITICAL_BLOCK(pnode->cs_vRecv) { CDataStream& vRecv = pnode->vRecv; unsigned int nPos = vRecv.size(); // typical socket buffer is 8K-64K const unsigned int nBufSize = 0x10000; vRecv.resize(nPos + nBufSize); int nBytes = recv(hSocket, &vRecv[nPos], nBufSize, 0); vRecv.resize(nPos + max(nBytes, 0)); if (nBytes == 0) { // socket closed gracefully if (!pnode->fDisconnect) LogPrint("net", "recv: socket closed\n"); pnode->fDisconnect = true; } else if (nBytes < 0) { // socket error int nErr = WSAGetLastError(); if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) { if (!pnode->fDisconnect) LogPrint("net", "recv failed: %d\n", nErr); pnode->fDisconnect = true; } } } } // // Send // if (FD_ISSET(hSocket, &fdsetSend)) { TRY_CRITICAL_BLOCK(pnode->cs_vSend) { CDataStream& vSend = pnode->vSend; if (!vSend.empty()) { int nBytes = send(hSocket, &vSend[0], vSend.size(), 0); if (nBytes > 0) { vSend.erase(vSend.begin(), vSend.begin() + nBytes); } else if (nBytes == 0) { if (pnode->ReadyToDisconnect()) pnode->vSend.clear(); } else { LogPrint("net", "send error %d\n", nBytes); if (pnode->ReadyToDisconnect()) pnode->vSend.clear(); } } } } } Sleep(10); } } void ThreadMessageHandler(void* parg) { IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg)); loop { vfThreadRunning[2] = true; CheckForShutdown(2); try { ThreadMessageHandler2(parg); } CATCH_PRINT_EXCEPTION("ThreadMessageHandler()") vfThreadRunning[2] = false; Sleep(5000); } } void ThreadMessageHandler2(void* parg) { printf("ThreadMessageHandler started\n"); SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL); loop { // Poll the connected nodes for messages vector vNodesCopy; CRITICAL_BLOCK(cs_vNodes) vNodesCopy = vNodes; foreach(CNode* pnode, vNodesCopy) { pnode->AddRef(); // Receive messages TRY_CRITICAL_BLOCK(pnode->cs_vRecv) ProcessMessages(pnode); // Send messages TRY_CRITICAL_BLOCK(pnode->cs_vSend) SendMessages(pnode); pnode->Release(); } // Wait and allow messages to bunch up vfThreadRunning[2] = false; Sleep(100); vfThreadRunning[2] = true; CheckForShutdown(2); } } //// todo: start one thread per processor, use getenv("NUMBER_OF_PROCESSORS") void ThreadBitcoinMiner(void* parg) { vfThreadRunning[3] = true; CheckForShutdown(3); try { bool fRet = BitcoinMiner(); printf("BitcoinMiner returned %s\n\n\n", fRet ? "true" : "false"); } CATCH_PRINT_EXCEPTION("BitcoinMiner()") vfThreadRunning[3] = false; } bool StartNode(string& strError) { strError = ""; // Sockets startup WSADATA wsadata; int ret = WSAStartup(MAKEWORD(2,2), &wsadata); if (ret != NO_ERROR) { strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret); printf("%s\n", strError.c_str()); return false; } // Get local host ip char pszHostName[255]; if (gethostname(pszHostName, 255) == SOCKET_ERROR) { strError = strprintf("Error: Unable to get IP address of this computer (gethostname returned error %d)", WSAGetLastError()); printf("%s\n", strError.c_str()); return false; } struct hostent* pHostEnt = gethostbyname(pszHostName); if (!pHostEnt) { strError = strprintf("Error: Unable to get IP address of this computer (gethostbyname returned error %d)", WSAGetLastError()); printf("%s\n", strError.c_str()); return false; } addrLocalHost = CAddress(*(long*)(pHostEnt->h_addr_list[0]), nListenPort, nLocalServices); printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str()); // Create socket for listening for incoming connections SOCKET hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (hListenSocket == INVALID_SOCKET) { strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError()); printf("%s\n", strError.c_str()); return false; } // Set to nonblocking, incoming connections will also inherit this u_long nOne = 1; if (ioctlsocket(hListenSocket, FIONBIO, &nOne) == SOCKET_ERROR) { strError = strprintf("Error: Couldn't set properties on socket for incoming connections (ioctlsocket returned error %d)", WSAGetLastError()); printf("%s\n", strError.c_str()); return false; } // The sockaddr_in structure specifies the address family, // IP address, and port for the socket that is being bound int nRetryLimit = 15; struct sockaddr_in sockaddr = addrLocalHost.GetSockAddr(); if (bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR) { int nErr = WSAGetLastError(); if (nErr == WSAEADDRINUSE) strError = strprintf("Error: Unable to bind to port %s on this computer. The program is probably already running.", addrLocalHost.ToString().c_str()); else strError = strprintf("Error: Unable to bind to port %s on this computer (bind returned error %d)", addrLocalHost.ToString().c_str(), nErr); printf("%s\n", strError.c_str()); return false; } printf("bound to addrLocalHost = %s\n\n", addrLocalHost.ToString().c_str()); // Listen for incoming connections if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR) { strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError()); printf("%s\n", strError.c_str()); return false; } // Get our external IP in a background thread -- up to 4 HTTP requests with // 5s timeouts each could otherwise delay startup by 20s on first run. // addrIncoming from a previous session is used immediately as a fallback. if (addrIncoming.ip) addrLocalHost.ip = addrIncoming.ip; _beginthread([](void*) { unsigned int ip = addrLocalHost.ip; if (GetMyExternalIP(ip)) { addrLocalHost.ip = ip; addrIncoming = addrLocalHost; CWalletDB().WriteSetting("addrIncoming", addrIncoming); printf("External IP updated: %s\n", addrLocalHost.ToStringIP().c_str()); } }, 0, NULL); // Peer discovery over Nostr relays (replaces the old IRC seed) if (_beginthread(ThreadNostrSeed, 0, NULL) == -1) printf("Error: _beginthread(ThreadNostrSeed) failed\n"); // Anonymous inbound: this node's .btf hidden service, reachable through the // meeting relay without exposing our IP or needing a public port. if (!vBtfMeetingRelays.empty()) if (_beginthread(ThreadBtfAccept, 0, NULL) == -1) printf("Error: _beginthread(ThreadBtfAccept) failed\n"); // Anonymous outbound: keep a connection to a specific .btf peer, if asked. if (!strBtfConnect.empty()) if (_beginthread(ThreadBtfConnect, 0, new string(strBtfConnect)) == -1) printf("Error: _beginthread(ThreadBtfConnect) failed\n"); // // Start threads // if (_beginthread(ThreadSocketHandler, 0, new SOCKET(hListenSocket)) == -1) { strError = "Error: _beginthread(ThreadSocketHandler) failed"; printf("%s\n", strError.c_str()); return false; } if (_beginthread(ThreadMessageHandler, 0, NULL) == -1) { strError = "Error: _beginthread(ThreadMessageHandler) failed"; printf("%s\n", strError.c_str()); return false; } return true; } bool StopNode() { printf("StopNode()\n"); fShutdown = true; nTransactionsUpdated++; while (count(vfThreadRunning.begin(), vfThreadRunning.end(), true)) Sleep(10); Sleep(50); // Sockets shutdown WSACleanup(); return true; } void CheckForShutdown(int n) { if (fShutdown) { if (n != -1) vfThreadRunning[n] = false; _endthread(); } }