{

LOCK(cs_vOneShots);

vOneShots.push_back(strDest);

{

if (fNoListen)

return false;

int nBestScore = -1;

int nBestReachability = -1;

{

LOCK(cs_mapLocalHost);

for (map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)

{

int nScore = (*it).second.nScore;

int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);

if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))

{

addr = CService((*it).first, (*it).second.nPort);

nBestReachability = nReachability;

nBestScore = nScore;

}

}

}

return nBestScore >= 0;

{

CAddress ret(CService("0.0.0.0",0),0);

CService addr;

if (GetLocal(addr, paddrPeer))

{

ret = CAddress(addr);

ret.nServices = nLocalServices;

ret.nTime = GetAdjustedTime();

}

return ret;

{

strLine = "";

while (true)

{

char c;

int nBytes = recv(hSocket, &c, 1, 0);

if (nBytes > 0)

{

if (c == '\n')

continue;

if (c == '\r')

return true;

strLine += c;

if (strLine.size() >= 9000)

return true;

}

else if (nBytes <= 0)

{

boost::this_thread::interruption_point();

if (nBytes < 0)

{

int nErr = WSAGetLastError();

if (nErr == WSAEMSGSIZE)

continue;

if (nErr == WSAEWOULDBLOCK || nErr == WSAEINTR || nErr == WSAEINPROGRESS)

{

MilliSleep(10);

continue;

}

}

if (!strLine.empty())

return true;

if (nBytes == 0)

{

// socket closed

LogPrint("net", "socket closed\n");

return false;

}

else

{

// socket error

int nErr = WSAGetLastError();

LogPrint("net", "recv failed: %d\n", nErr);

return false;

}

}

}

{

LOCK(cs_vNodes);

BOOST_FOREACH(CNode* pnode, vNodes)

{

if (pnode->fSuccessfullyConnected)

{

CAddress addrLocal = GetLocalAddress(&pnode->addr);

if (addrLocal.IsRoutable() && (CService)addrLocal != (CService)pnode->addrLocal)

{

pnode->PushAddress(addrLocal);

pnode->addrLocal = addrLocal;

}

}

}

{

LOCK(cs_mapLocalHost);

vfReachable[net] = fFlag;

if (net == NET_IPV6 && fFlag)

vfReachable[NET_IPV4] = true;

{

if (!addr.IsRoutable())

return false;

if (!fDiscover && nScore < LOCAL_MANUAL)

return false;

if (IsLimited(addr))

return false;

LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore);

{

LOCK(cs_mapLocalHost);

bool fAlready = mapLocalHost.count(addr) > 0;

LocalServiceInfo &info = mapLocalHost[addr];

if (!fAlready || nScore >= info.nScore) {

info.nScore = nScore + (fAlready ? 1 : 0);

info.nPort = addr.GetPort();

}

SetReachable(addr.GetNetwork());

}

AdvertizeLocal();

return true;

{

if (net == NET_UNROUTABLE)

return;

LOCK(cs_mapLocalHost);

vfLimited[net] = fLimited;

{

LOCK(cs_mapLocalHost);

return vfLimited[net];

{

{

LOCK(cs_mapLocalHost);

if (mapLocalHost.count(addr) == 0)

return false;

mapLocalHost[addr].nScore++;

}

AdvertizeLocal();

return true;

{

LOCK(cs_mapLocalHost);

return mapLocalHost.count(addr) > 0;

{

LOCK(cs_mapLocalHost);

enum Network net = addr.GetNetwork();

return vfReachable[net] && !vfLimited[net];

{

SOCKET hSocket;

if (!ConnectSocket(addrConnect, hSocket))

return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString());

send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);

string strLine;

while (RecvLine(hSocket, strLine))

{

if (strLine.empty()) // HTTP response is separated from headers by blank line

{

while (true)

{

if (!RecvLine(hSocket, strLine))

{

closesocket(hSocket);

return false;

}

if (pszKeyword == NULL)

break;

if (strLine.find(pszKeyword) != string::npos)

{

strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));

break;

}

}

closesocket(hSocket);

if (strLine.find("<") != string::npos)

strLine = strLine.substr(0, strLine.find("<"));

strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));

while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))

strLine.resize(strLine.size()-1);

CService addr(strLine,0,true);

LogPrintf("GetMyExternalIP() received [%s] %s\n", strLine, addr.ToString());

if (!addr.IsValid() || !addr.IsRoutable())

return false;

ipRet.SetIP(addr);

return true;

}

}

closesocket(hSocket);

return error("GetMyExternalIP() : connection closed");

{

CService addrConnect;

const char* pszGet;

const char* pszKeyword;

for (int nLookup = 0; nLookup <= 1; nLookup++)

for (int nHost = 1; nHost <= 2; nHost++)

{

// We should be phasing out our use of sites like these. If we need

// replacements, we should ask for volunteers to put this simple

// php file on their web server that prints the client IP:

// <?php echo $_SERVER["REMOTE_ADDR"]; ?>

if (nHost == 1)

{

addrConnect = CService("91.198.22.70", 80); // checkip.dyndns.org

if (nLookup == 1)

{

CService addrIP("checkip.dyndns.org", 80, true);

if (addrIP.IsValid())

addrConnect = addrIP;

}

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:";

}

else if (nHost == 2)

{

addrConnect = CService("74.208.43.192", 80); // www.showmyip.com

if (nLookup == 1)

{

CService addrIP("www.showmyip.com", 80, true);

if (addrIP.IsValid())

addrConnect = addrIP;

}

pszGet = "GET /simple/ HTTP/1.1\r\n"

"Host: www.showmyip.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 = NULL; // Returns just IP address

}

if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))

return true;

}

return false;

{

CNetAddr addrLocalHost;

if (GetMyExternalIP(addrLocalHost))

{

LogPrintf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP());

AddLocal(addrLocalHost, LOCAL_HTTP);

}

{

fDisconnect = true;

if (hSocket != INVALID_SOCKET)

{

LogPrint("net", "disconnecting node %s\n", addrName);

closesocket(hSocket);

hSocket = INVALID_SOCKET;

}

// in case this fails, we'll empty the recv buffer when the CNode is deleted

TRY_LOCK(cs_vRecvMsg, lockRecv);

if (lockRecv)

vRecvMsg.clear();

// if this was the sync node, we'll need a new one

if (this == pnodeSync)

pnodeSync = NULL;

{

int nBestHeight = g_signals.GetHeight().get_value_or(0);

/// when NTP implemented, change to just nTime = GetAdjustedTime()

int64_t nTime = (fInbound ? GetAdjustedTime() : GetTime());

CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0",0)));

CAddress addrMe = GetLocalAddress(&addr);

RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));

LogPrint("net", "send version message: version %d, blocks=%d, us=%s, them=%s, peer=%s\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString(), addrYou.ToString(), addr.ToString());

PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,

nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight, true);

{

bool fResult = false;

{

LOCK(cs_setBanned);

std::map<CNetAddr, int64_t>::iterator i = setBanned.find(ip);

if (i != setBanned.end())

{

int64_t t = (*i).second;

if (GetTime() < t)

fResult = true;

}

}

return fResult;

int64_t banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban

{

LOCK(cs_setBanned);

if (setBanned[addr] < banTime)

setBanned[addr] = banTime;

}

return true;

{

stats.nodeid = this->GetId();

X(nServices);

X(nLastSend);

X(nLastRecv);

X(nTimeConnected);

X(addrName);

X(nVersion);

X(cleanSubVer);

X(fInbound);

X(nStartingHeight);

X(nSendBytes);

X(nRecvBytes);

stats.fSyncNode = (this == pnodeSync);

// It is common for nodes with good ping times to suddenly become lagged,

// due to a new block arriving or other large transfer.

// Merely reporting pingtime might fool the caller into thinking the node was still responsive,

// since pingtime does not update until the ping is complete, which might take a while.

// So, if a ping is taking an unusually long time in flight,

// the caller can immediately detect that this is happening.

int64_t nPingUsecWait = 0;

if ((0 != nPingNonceSent) && (0 != nPingUsecStart)) {

nPingUsecWait = GetTimeMicros() - nPingUsecStart;

}

// Raw ping time is in microseconds, but show it to user as whole seconds (Sidecoin users should be well used to small numbers with many decimal places by now :)

stats.dPingTime = (((double)nPingUsecTime) / 1e6);

stats.dPingWait = (((double)nPingUsecWait) / 1e6);

// Leave string empty if addrLocal invalid (not filled in yet)

stats.addrLocal = addrLocal.IsValid() ? addrLocal.ToString() : "";

{

while (nBytes > 0) {

// get current incomplete message, or create a new one

if (vRecvMsg.empty() ||

vRecvMsg.back().complete())

vRecvMsg.push_back(CNetMessage(SER_NETWORK, nRecvVersion));

CNetMessage& msg = vRecvMsg.back();

// absorb network data

int handled;

if (!msg.in_data)

handled = msg.readHeader(pch, nBytes);

else

handled = msg.readData(pch, nBytes);

if (handled < 0)

return false;

pch += handled;

nBytes -= handled;

}

return true;

{

// copy data to temporary parsing buffer

unsigned int nRemaining = 24 - nHdrPos;

unsigned int nCopy = std::min(nRemaining, nBytes);

memcpy(&hdrbuf[nHdrPos], pch, nCopy);

nHdrPos += nCopy;

// if header incomplete, exit

if (nHdrPos < 24)

return nCopy;

// deserialize to CMessageHeader

try {

hdrbuf >> hdr;

}

catch (std::exception &e) {

return -1;

}

// reject messages larger than MAX_SIZE

if (hdr.nMessageSize > MAX_SIZE)

return -1;

// switch state to reading message data

in_data = true;

vRecv.resize(hdr.nMessageSize);

return nCopy;

{

unsigned int nRemaining = hdr.nMessageSize - nDataPos;

unsigned int nCopy = std::min(nRemaining, nBytes);

memcpy(&vRecv[nDataPos], pch, nCopy);

nDataPos += nCopy;

return nCopy;

{

std::deque<CSerializeData>::iterator it = pnode->vSendMsg.begin();

while (it != pnode->vSendMsg.end()) {

const CSerializeData &data = *it;

assert(data.size() > pnode->nSendOffset);

int nBytes = send(pnode->hSocket, &data[pnode->nSendOffset], data.size() - pnode->nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);

if (nBytes > 0) {

pnode->nLastSend = GetTime();

pnode->nSendBytes += nBytes;

pnode->nSendOffset += nBytes;

pnode->RecordBytesSent(nBytes);

if (pnode->nSendOffset == data.size()) {

pnode->nSendOffset = 0;

pnode->nSendSize -= data.size();

it++;

} else {

// could not send full message; stop sending more

break;

}

} else {

if (nBytes < 0) {

// error

int nErr = WSAGetLastError();

if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)

{

LogPrintf("socket send error %d\n", nErr);

pnode->CloseSocketDisconnect();

}

}

// couldn't send anything at all

break;

}

}

if (it == pnode->vSendMsg.end()) {

assert(pnode->nSendOffset == 0);

assert(pnode->nSendSize == 0);

}

pnode->vSendMsg.erase(pnode->vSendMsg.begin(), it);

{

unsigned int nPrevNodeCount = 0;

while (true)

{

//

// Disconnect nodes

//

{

LOCK(cs_vNodes);

// Disconnect unused nodes

vector<CNode*> vNodesCopy = vNodes;

BOOST_FOREACH(CNode* pnode, vNodesCopy)

{

if (pnode->fDisconnect ||

(pnode->GetRefCount() <= 0 && pnode->vRecvMsg.empty() && pnode->nSendSize == 0 && pnode->ssSend.empty()))

{

// remove from vNodes

vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());

// release outbound grant (if any)

pnode->grantOutbound.Release();

// close socket and cleanup

pnode->CloseSocketDisconnect();

pnode->Cleanup();

// hold in disconnected pool until all refs are released

if (pnode->fNetworkNode || pnode->fInbound)

pnode->Release();

vNodesDisconnected.push_back(pnode);

}

}

}

{

// Delete disconnected nodes

list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;

BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)

{

// wait until threads are done using it

if (pnode->GetRefCount() <= 0)

{

bool fDelete = false;

{

TRY_LOCK(pnode->cs_vSend, lockSend);

if (lockSend)

{

TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);

if (lockRecv)

{

TRY_LOCK(pnode->cs_inventory, lockInv);

if (lockInv)

fDelete = true;

}

}

}

if (fDelete)

{

vNodesDisconnected.remove(pnode);

delete pnode;

}

}

}

}

if(vNodes.size() != nPrevNodeCount) {

nPrevNodeCount = vNodes.size();

uiInterface.NotifyNumConnectionsChanged(nPrevNodeCount);

}

//

// 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_set fdsetError;

FD_ZERO(&fdsetRecv);

FD_ZERO(&fdsetSend);

FD_ZERO(&fdsetError);

SOCKET hSocketMax = 0;

bool have_fds = false;

BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket) {

FD_SET(hListenSocket, &fdsetRecv);

hSocketMax = max(hSocketMax, hListenSocket);

have_fds = true;

}

{

LOCK(cs_vNodes);

BOOST_FOREACH(CNode* pnode, vNodes)

{

if (pnode->hSocket == INVALID_SOCKET)

continue;

FD_SET(pnode->hSocket, &fdsetError);

hSocketMax = max(hSocketMax, pnode->hSocket);

have_fds = true;

// Implement the following logic:

// * If there is data to send, select() for sending data. As this only

// happens when optimistic write failed, we choose to first drain the

// write buffer in this case before receiving more. This avoids

// needlessly queueing received data, if the remote peer is not themselves

// receiving data. This means properly utilizing TCP flow control signalling.

// * Otherwise, if there is no (complete) message in the receive buffer,

// or there is space left in the buffer, select() for receiving data.

// * (if neither of the above applies, there is certainly one message

// in the receiver buffer ready to be processed).

// Together, that means that at least one of the following is always possible,

// so we don't deadlock:

// * We send some data.

// * We wait for data to be received (and disconnect after timeout).

// * We process a message in the buffer (message handler thread).

{

TRY_LOCK(pnode->cs_vSend, lockSend);

if (lockSend && !pnode->vSendMsg.empty()) {

FD_SET(pnode->hSocket, &fdsetSend);

continue;

}

}

{

TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);

if (lockRecv && (

pnode->vRecvMsg.empty() || !pnode->vRecvMsg.front().complete() ||

pnode->GetTotalRecvSize() <= ReceiveFloodSize()))

FD_SET(pnode->hSocket, &fdsetRecv);

}

}

}

int nSelect = select(have_fds ? hSocketMax + 1 : 0,

&fdsetRecv, &fdsetSend, &fdsetError, &timeout);

boost::this_thread::interruption_point();

if (nSelect == SOCKET_ERROR)

{

if (have_fds)

{

int nErr = WSAGetLastError();

LogPrintf("socket select error %d\n", nErr);

for (unsigned int i = 0; i <= hSocketMax; i++)

FD_SET(i, &fdsetRecv);

}

FD_ZERO(&fdsetSend);

FD_ZERO(&fdsetError);

MilliSleep(timeout.tv_usec/1000);

}

//

// Accept new connections

//

BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket)

if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))

{

#ifdef USE_IPV6

struct sockaddr_storage sockaddr;

#else

struct sockaddr sockaddr;

#endif

socklen_t len = sizeof(sockaddr);

SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);

CAddress addr;

int nInbound = 0;

if (hSocket != INVALID_SOCKET)

if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr))

LogPrintf("Warning: Unknown socket family\n");

{

LOCK(cs_vNodes);

BOOST_FOREACH(CNode* pnode, vNodes)

if (pnode->fInbound)

nInbound++;

}

if (hSocket == INVALID_SOCKET)

{

int nErr = WSAGetLastError();

if (nErr != WSAEWOULDBLOCK)

LogPrintf("socket error accept failed: %d\n", nErr);

}

else if (nInbound >= nMaxConnections - MAX_OUTBOUND_CONNECTIONS)

{

{

LOCK(cs_setservAddNodeAddresses);

if (!setservAddNodeAddresses.count(addr))

closesocket(hSocket);

}

}

else if (CNode::IsBanned(addr))

{

LogPrintf("connection from %s dropped (banned)\n", addr.ToString());

closesocket(hSocket);

}

else

{

LogPrint("net", "accepted connection %s\n", addr.ToString());

CNode* pnode = new CNode(hSocket, addr, "", true);

pnode->AddRef();

{

LOCK(cs_vNodes);

vNodes.push_back(pnode);

}

}

}

//

// Service each socket

//

vector<CNode*> vNodesCopy;

{

LOCK(cs_vNodes);

vNodesCopy = vNodes;

BOOST_FOREACH(CNode* pnode, vNodesCopy)

pnode->AddRef();

}

BOOST_FOREACH(CNode* pnode, vNodesCopy)

{

boost::this_thread::interruption_point();

//

// Receive

//

if (pnode->hSocket == INVALID_SOCKET)

continue;

if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))

{

TRY_LOCK(pnode->cs_vRecvMsg, lockRecv);

if (lockRecv)

{

{

// typical socket buffer is 8K-64K

char pchBuf[0x10000];

int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);

if (nBytes > 0)