(18 . 8)(18 . 8)
void ThreadMessageHandler2(void* parg);
void ThreadSocketHandler2(void* parg);
void ThreadOpenConnections2(void* parg);
bool OpenNetworkConnection(const CAddress& addrConnect);

void ThreadOpenWires2(void* parg);
bool OpenNetworkConnection(const CAddress& addrConnect, bool fWireConnection=false);



(37 . 6)(37 . 7)

vector<CNode*> vNodes;
CCriticalSection cs_vNodes;
map<vector<unsigned char>, CAddress> mapWires;
map<vector<unsigned char>, CAddress> mapAddresses;
CCriticalSection cs_mapAddresses;
map<CInv, CDataStream> mapRelay;
(243 . 6)(244 . 20)
}


// 'Wires' don't get saved to the DB; they don't get shared with peers,
// including one another; they don't voluntarily get disconnected;
// if disconnected by other side, they will bang on the door forever;
// they carry no ban score. Think of them as 'leased lines.'
// They are also permitted to be ports on localhost! (tunnelers, e.g., 'g'.)
// Use with caution!!!
bool AddWire(CAddress addr)
{
  printf("AddWire(%s)\n", addr.ToString().c_str());
  mapWires.insert(make_pair(addr.GetKey(), addr)); // NO error checking!
  return true;
}


bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
{
    if (!addr.IsRoutable())
(452 . 31)(467 . 29)
    return NULL;
}

CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
CNode* ConnectNode(CAddress addrConnect, int64 nTimeout, bool fWireNode)
{
    if (addrConnect.ip == addrLocalHost.ip)
    if (!fWireNode && (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;
    
    if (fWireNode) {
      nTimeout = 0;
      printf("Connecting to wire node... %s\n",
             addrConnect.ToString().c_str());
    }

    
    /// debug print
    printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
        addrConnect.ToString().c_str(),
        (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
        (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);

    CRITICAL_BLOCK(cs_mapAddresses)
        mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();

    if (!fWireNode)
      {
        CRITICAL_BLOCK(cs_mapAddresses)
          mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
      }
    
    // Connect
    SOCKET hSocket;
    if (ConnectSocket(addrConnect, hSocket))
(490 . 6)(503 . 10)

        // Add node
        CNode* pnode = new CNode(hSocket, addrConnect, false);
        pnode->fWireNode = fWireNode;

        if (fWireNode) printf("Added wire node !\n");

        if (nTimeout != 0)
            pnode->AddRef(nTimeout);
        else
(508 . 6)(525 . 10)

void CNode::CloseSocketDisconnect()
{
    if (fWireNode) {
      printf("WARNING: disconnecting wire %s ! (will retry...)\n",
             addr.ToString().c_str());
    }
    fDisconnect = true;
    if (hSocket != INVALID_SOCKET)
    {
(557 . 6)(578 . 12)

bool CNode::Misbehaving(int howmuch)
{
    if (fWireNode)
    {
        printf("Warning: wire node %s misbehaving (no disconnect)\n", addr.ToString().c_str());
        return false;
    }

    if (addr.IsLocal())
    {
        printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
(873 . 8)(900 . 8)
            //
            if (pnode->vSend.empty())
                pnode->nLastSendEmpty = GetTime();
            if (GetTime() - pnode->nTimeConnected > 60)
            {
            if ((!pnode->fWireNode) && (GetTime() - pnode->nTimeConnected > 60))
            { // these conditions do not apply to wires !
                if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
                {
                    printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
(1061 . 19)(1088 . 23)
    }
}

bool OpenNetworkConnection(const CAddress& addrConnect)
bool OpenNetworkConnection(const CAddress& addrConnect, bool fWireConnection)
{
    //
    // Initiate outbound network connection
    //
    if (fShutdown)
        return false;
    if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
        FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))

    if (!fWireConnection && 
        (addrConnect.ip == addrLocalHost.ip || CNode::IsBanned(addrConnect.ip)))
        return false;

    if (!addrConnect.IsIPv4() || FindNode(addrConnect.ip))
        return false;

    vnThreadsRunning[1]--;
    CNode* pnode = ConnectNode(addrConnect);
    CNode* pnode = ConnectNode(addrConnect, 0, fWireConnection);
    vnThreadsRunning[1]++;
    if (fShutdown)
        return false;
(1085 . 10)(1116 . 42)
}


void ThreadOpenWires(void* parg)
{
    IMPLEMENT_RANDOMIZE_STACK(ThreadOpenWires(parg));
    try
    {
        vnThreadsRunning[5]++;
        ThreadOpenWires2(parg);
        vnThreadsRunning[5]--;
    }
    catch (std::exception& e) {
        vnThreadsRunning[5]--;
        PrintException(&e, "ThreadOpenWires()");
    } catch (...) {
        vnThreadsRunning[5]--;
        PrintException(NULL, "ThreadOpenWires()");
    }
    printf("ThreadOpenWires exiting\n");
}


void ThreadOpenWires2(void* parg)
{
    printf("ThreadOpenWires started\n");


    while (1)
      {
        BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapWires)
          {
            const CAddress& addr = item.second;
            OpenNetworkConnection(addr, true);
            if (fShutdown)
              return;
          }
        Sleep(wireRefresh);
      }
}


void ThreadMessageHandler(void* parg)
(1298 . 6)(1361 . 10)
    if (!CreateThread(ThreadOpenConnections, NULL))
        printf("Error: CreateThread(ThreadOpenConnections) failed\n");

    // Initiate outbound wires, if at least one was defined
    if (fWires && !CreateThread(ThreadOpenWires, NULL))
        printf("Error: CreateThread(ThreadOpenWires) failed\n");

    // Process messages
    if (!CreateThread(ThreadMessageHandler, NULL))
        printf("Error: CreateThread(ThreadMessageHandler) failed\n");
(1312 . 7)(1379 . 7)
    fShutdown = true;
    nTransactionsUpdated++;
    int64 nStart = GetTime();
    while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
    while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0 || vnThreadsRunning[5] > 0
    )
    {
        if (GetTime() - nStart > 20)
(1324 . 6)(1391 . 7)
    if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
    if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
    if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
    if (vnThreadsRunning[5] > 0) printf("ThreadOpenWires still running\n");
    while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
        Sleep(20);
    Sleep(50);