// 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" #include void ThreadMessageHandler2(void* parg); void ThreadSocketHandler2(void* parg); void ThreadOpenConnections2(void* parg); // // Global state variables // bool fClient = false; uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK); CAddress addrLocalHost(0, DEFAULT_PORT, nLocalServices); CNode nodeLocalHost(INVALID_SOCKET, CAddress("127.0.0.1", nLocalServices)); CNode* pnodeLocalHost = &nodeLocalHost; bool fShutdown = false; array vnThreadsRunning; vector vNodes; CCriticalSection cs_vNodes; map, CAddress> mapAddresses; CCriticalSection cs_mapAddresses; map mapRelay; deque > vRelayExpiration; CCriticalSection cs_mapRelay; map mapAlreadyAskedFor; CAddress addrProxy; bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet) { hSocketRet = INVALID_SOCKET; SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (hSocket == INVALID_SOCKET) return false; bool fRoutable = !(addrConnect.GetByte(3) == 10 || (addrConnect.GetByte(3) == 192 && addrConnect.GetByte(2) == 168)); bool fProxy = (addrProxy.ip && fRoutable); struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr()); if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR) { closesocket(hSocket); return false; } if (fProxy) { printf("Proxy connecting %s\n", addrConnect.ToStringLog().c_str()); char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user"; memcpy(pszSocks4IP + 2, &addrConnect.port, 2); memcpy(pszSocks4IP + 4, &addrConnect.ip, 4); char* pszSocks4 = pszSocks4IP; int nSize = sizeof(pszSocks4IP); int ret = send(hSocket, pszSocks4, nSize, 0); if (ret != nSize) { closesocket(hSocket); return error("Error sending to proxy\n"); } char pchRet[8]; if (recv(hSocket, pchRet, 8, 0) != 8) { closesocket(hSocket); return error("Error reading proxy response\n"); } if (pchRet[1] != 0x5a) { closesocket(hSocket); return error("Proxy returned error %d\n", pchRet[1]); } printf("Proxy connection established %s\n", addrConnect.ToStringLog().c_str()); } hSocketRet = hSocket; return true; } bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet) { SOCKET hSocket; if (!ConnectSocket(addrConnect, hSocket)) return error("GetMyExternalIP() : connection to %s failed\n", addrConnect.ToString().c_str()); send(hSocket, pszGet, strlen(pszGet), 0); string strLine; while (RecvLine(hSocket, strLine)) { if (strLine.empty()) { loop { if (!RecvLine(hSocket, strLine)) { closesocket(hSocket); return false; } if (strLine.find(pszKeyword) != -1) { strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword)); break; } } closesocket(hSocket); if (strLine.find("<")) strLine = strLine.substr(0, strLine.find("<")); strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r")); strLine = wxString(strLine).Trim(); CAddress addr(strLine.c_str()); printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str()); if (addr.ip == 0 || !addr.IsRoutable()) return false; ipRet = addr.ip; return true; } } closesocket(hSocket); return error("GetMyExternalIP() : connection closed\n"); } bool GetMyExternalIP(unsigned int& ipRet) { CAddress addrConnect; char* pszGet; char* pszKeyword; for (int nLookup = 0; nLookup <= 1; nLookup++) for (int nHost = 1; nHost <= 2; nHost++) { if (nHost == 1) { addrConnect = CAddress("70.86.96.218:80"); // www.ipaddressworld.com if (nLookup == 1) { struct hostent* phostent = gethostbyname("www.ipaddressworld.com"); if (phostent && phostent->h_addr_list && phostent->h_addr_list[0]) addrConnect = CAddress(*(u_long*)phostent->h_addr_list[0], htons(80)); } pszGet = "GET /ip.php HTTP/1.1\r\n" "Host: www.ipaddressworld.com\r\n" "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n" "Connection: close\r\n" "\r\n"; pszKeyword = "IP:"; } else if (nHost == 2) { addrConnect = CAddress("208.78.68.70:80"); // checkip.dyndns.org if (nLookup == 1) { struct hostent* phostent = gethostbyname("checkip.dyndns.org"); if (phostent && phostent->h_addr_list && phostent->h_addr_list[0]) addrConnect = CAddress(*(u_long*)phostent->h_addr_list[0], htons(80)); } pszGet = "GET / HTTP/1.1\r\n" "Host: checkip.dyndns.org\r\n" "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n" "Connection: close\r\n" "\r\n"; pszKeyword = "Address:"; } if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet)) return true; } return false; } bool AddAddress(CAddrDB& addrdb, const CAddress& addr) { if (!addr.IsRoutable()) return false; if (addr.ip == addrLocalHost.ip) return false; CRITICAL_BLOCK(cs_mapAddresses) { map, CAddress>::iterator it = mapAddresses.find(addr.GetKey()); if (it == mapAddresses.end()) { // New address mapAddresses.insert(make_pair(addr.GetKey(), addr)); addrdb.WriteAddress(addr); return true; } else { CAddress& addrFound = (*it).second; if ((addrFound.nServices | addr.nServices) != addrFound.nServices) { // Services have been added addrFound.nServices |= addr.nServices; addrdb.WriteAddress(addrFound); return true; } else if (addrFound.nTime < GetAdjustedTime() - 24 * 60 * 60) { // Periodically update most recently seen time addrFound.nTime = GetAdjustedTime(); addrdb.WriteAddress(addrFound); return false; } } } return false; } 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; } CNode* FindNode(CAddress addr) { CRITICAL_BLOCK(cs_vNodes) { foreach(CNode* pnode, vNodes) if (pnode->addr == addr) return (pnode); } return NULL; } CNode* ConnectNode(CAddress addrConnect, int64 nTimeout) { if (addrConnect.ip == addrLocalHost.ip) return NULL; // Look for an existing connection CNode* pnode = FindNode(addrConnect.ip); if (pnode) { if (nTimeout != 0) pnode->AddRef(nTimeout); else pnode->AddRef(); return pnode; } /// debug print printf("trying connection %s\n", addrConnect.ToStringLog().c_str()); // Connect SOCKET hSocket; if (ConnectSocket(addrConnect, hSocket)) { /// debug print printf("connected %s\n", addrConnect.ToStringLog().c_str()); // Set to nonblocking u_long nOne = 1; if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR) printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError()); // Add node CNode* pnode = new CNode(hSocket, addrConnect, false); if (nTimeout != 0) pnode->AddRef(nTimeout); else pnode->AddRef(); CRITICAL_BLOCK(cs_vNodes) vNodes.push_back(pnode); CRITICAL_BLOCK(cs_mapAddresses) mapAddresses[addrConnect.GetKey()].nLastFailed = 0; return pnode; } else { CRITICAL_BLOCK(cs_mapAddresses) mapAddresses[addrConnect.GetKey()].nLastFailed = GetTime(); return NULL; } } void CNode::Disconnect() { printf("disconnecting node %s\n", addr.ToStringLog().c_str()); closesocket(hSocket); // If outbound and never got version message, mark address as failed if (!fInbound && nVersion == 0) CRITICAL_BLOCK(cs_mapAddresses) mapAddresses[addr.GetKey()].nLastFailed = GetTime(); // 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 { vnThreadsRunning[0] = true; CheckForShutdown(0); try { ThreadSocketHandler2(parg); vnThreadsRunning[0] = false; } catch (std::exception& e) { vnThreadsRunning[0] = false; PrintException(&e, "ThreadSocketHandler()"); } catch (...) { vnThreadsRunning[0] = false; PrintException(NULL, "ThreadSocketHandler()"); } 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 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 struct fd_set fdsetRecv; struct 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); } } vnThreadsRunning[0] = false; int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, NULL, &timeout); vnThreadsRunning[0] = true; CheckForShutdown(0); if (nSelect == SOCKET_ERROR) { int nErr = WSAGetLastError(); printf("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; int len = sizeof(sockaddr); 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 { printf("accepted connection %s\n", addr.ToStringLog().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) printf("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) printf("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 { printf("send error %d\n", nBytes); if (pnode->ReadyToDisconnect()) pnode->vSend.clear(); } } } } } Sleep(10); } } void ThreadOpenConnections(void* parg) { IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg)); loop { vnThreadsRunning[1] = true; CheckForShutdown(1); try { ThreadOpenConnections2(parg); vnThreadsRunning[1] = false; } catch (std::exception& e) { vnThreadsRunning[1] = false; PrintException(&e, "ThreadOpenConnections()"); } catch (...) { vnThreadsRunning[1] = false; PrintException(NULL, "ThreadOpenConnections()"); } Sleep(5000); } } void ThreadOpenConnections2(void* parg) { printf("ThreadOpenConnections started\n"); // Initiate network connections int nTry = 0; bool fIRCOnly = false; const int nMaxConnections = 15; loop { // Wait vnThreadsRunning[1] = false; Sleep(500); while (vNodes.size() >= nMaxConnections || vNodes.size() >= mapAddresses.size()) { CheckForShutdown(1); Sleep(2000); } vnThreadsRunning[1] = true; CheckForShutdown(1); // // The IP selection process is designed to limit vulnerability to address flooding. // Any class C (a.b.c.?) has an equal chance of being chosen, then an IP is // chosen within the class C. An attacker may be able to allocate many IPs, but // they would normally be concentrated in blocks of class C's. They can hog the // attention within their class C, but not the whole IP address space overall. // A lone node in a class C will get as much attention as someone holding all 255 // IPs in another class C. // // Every other try is with IRC addresses only fIRCOnly = !fIRCOnly; if (mapIRCAddresses.empty()) fIRCOnly = false; else if (nTry++ < 30 && vNodes.size() < nMaxConnections/2) fIRCOnly = true; // Make a list of unique class C's unsigned char pchIPCMask[4] = { 0xff, 0xff, 0xff, 0x00 }; unsigned int nIPCMask = *(unsigned int*)pchIPCMask; vector vIPC; CRITICAL_BLOCK(cs_mapIRCAddresses) CRITICAL_BLOCK(cs_mapAddresses) { vIPC.reserve(mapAddresses.size()); unsigned int nPrev = 0; foreach(const PAIRTYPE(vector, CAddress)& item, mapAddresses) { const CAddress& addr = item.second; if (!addr.IsIPv4()) continue; if (fIRCOnly && !mapIRCAddresses.count(item.first)) continue; // Taking advantage of mapAddresses being in sorted order, // with IPs of the same class C grouped together. unsigned int ipC = addr.ip & nIPCMask; if (ipC != nPrev) vIPC.push_back(nPrev = ipC); } } if (vIPC.empty()) continue; // Choose a random class C unsigned int ipC = vIPC[GetRand(vIPC.size())]; // Organize all addresses in the class C by IP map > mapIP; CRITICAL_BLOCK(cs_mapIRCAddresses) CRITICAL_BLOCK(cs_mapAddresses) { int64 nDelay = ((30 * 60) << vNodes.size()); if (!fIRCOnly) { nDelay *= 2; if (vNodes.size() >= 3) nDelay *= 4; if (!mapIRCAddresses.empty()) nDelay *= 100; } for (map, CAddress>::iterator mi = mapAddresses.lower_bound(CAddress(ipC, 0).GetKey()); mi != mapAddresses.upper_bound(CAddress(ipC | ~nIPCMask, 0xffff).GetKey()); ++mi) { const CAddress& addr = (*mi).second; if (fIRCOnly && !mapIRCAddresses.count((*mi).first)) continue; int64 nRandomizer = (addr.nLastFailed * addr.ip * 7777U) % 20000; if (GetTime() - addr.nLastFailed > nDelay * nRandomizer / 10000) mapIP[addr.ip].push_back(addr); } } if (mapIP.empty()) continue; // Choose a random IP in the class C map >::iterator mi = mapIP.begin(); advance(mi, GetRand(mapIP.size())); // Once we've chosen an IP, we'll try every given port before moving on foreach(const CAddress& addrConnect, (*mi).second) { // // Initiate outbound network connection // CheckForShutdown(1); if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() || FindNode(addrConnect.ip)) continue; vnThreadsRunning[1] = false; CNode* pnode = ConnectNode(addrConnect); vnThreadsRunning[1] = true; CheckForShutdown(1); if (!pnode) continue; pnode->fNetworkNode = true; if (addrLocalHost.IsRoutable()) { // Advertise our address vector vAddrToSend; vAddrToSend.push_back(addrLocalHost); pnode->PushMessage("addr", vAddrToSend); } // Get as many addresses as we can pnode->PushMessage("getaddr"); ////// should the one on the receiving end do this too? // Subscribe our local subscription list const unsigned int nHops = 0; for (unsigned int nChannel = 0; nChannel < pnodeLocalHost->vfSubscribe.size(); nChannel++) if (pnodeLocalHost->vfSubscribe[nChannel]) pnode->PushMessage("subscribe", nChannel, nHops); break; } } } void ThreadMessageHandler(void* parg) { IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg)); loop { vnThreadsRunning[2] = true; CheckForShutdown(2); try { ThreadMessageHandler2(parg); vnThreadsRunning[2] = false; } catch (std::exception& e) { vnThreadsRunning[2] = false; PrintException(&e, "ThreadMessageHandler()"); } catch (...) { vnThreadsRunning[2] = false; PrintException(NULL, "ThreadMessageHandler()"); } 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 vnThreadsRunning[2] = false; Sleep(100); vnThreadsRunning[2] = true; CheckForShutdown(2); } } 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]), DEFAULT_PORT, 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 address for incoming connections if (addrIncoming.ip) addrLocalHost.ip = addrIncoming.ip; if (GetMyExternalIP(addrLocalHost.ip)) { addrIncoming = addrLocalHost; CWalletDB().WriteSetting("addrIncoming", addrIncoming); } // Get addresses from IRC and advertise ours if (_beginthread(ThreadIRCSeed, 0, NULL) == -1) printf("Error: _beginthread(ThreadIRCSeed) 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(ThreadOpenConnections, 0, NULL) == -1) { strError = "Error: _beginthread(ThreadOpenConnections) 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++; int64 nStart = GetTime(); while (vnThreadsRunning[0] || vnThreadsRunning[2] || vnThreadsRunning[3]) { if (GetTime() - nStart > 15) break; Sleep(20); } if (vnThreadsRunning[0]) printf("ThreadSocketHandler still running\n"); if (vnThreadsRunning[1]) printf("ThreadOpenConnections still running\n"); if (vnThreadsRunning[2]) printf("ThreadMessageHandler still running\n"); if (vnThreadsRunning[3]) printf("ThreadBitcoinMiner still running\n"); while (vnThreadsRunning[2]) Sleep(20); Sleep(50); // Sockets shutdown WSACleanup(); return true; } void CheckForShutdown(int n) { if (fShutdown) { if (n != -1) vnThreadsRunning[n] = false; if (n == 0) foreach(CNode* pnode, vNodes) closesocket(pnode->hSocket); _endthread(); } }