net: implement poll #14336

1517 | +    if (interruptNet)
1518 | +        return;
1519 | +
1520 | +    std::vector<struct pollfd> pollfds;
1521 | +    struct pollfd pollfd;
1522 | +    memset(&pollfd, 0, sizeof(struct pollfd));

---

1605 | -            for (CNode* pnode : vNodesCopy)
1606 | -                pnode->AddRef();
1607 | +            LOCK(pnode->cs_hSocket);
1608 | +            if (pnode->hSocket == INVALID_SOCKET)
1609 | +                continue;
1610 | +            recvSet = recv_set.count(pnode->hSocket);

---

1507 | +void CConnman::SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set)
1508 | +{
1509 | +    std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
1510 | +    GenerateSelectSet(recv_select_set, send_select_set, error_select_set);
1511 | +
1512 | +    if (recv_select_set.empty() && send_select_set.empty() and error_select_set.empty()) {

---

1540 | +    }
1541 | +
1542 | +    if(poll(&pollfds[0], pollfds.size(), 50) < 0)
1543 | +        LogPrint(BCLog::NET, "poll failure %d %s\n", errno, strerror(errno));
1544 | +
1545 | +    for (struct pollfd pollfd : pollfds) {

---

1346 | @@ -1347,8 +1347,6 @@ void CConnman::SocketHandler()
1347 |  
1348 |      int nSelect = select(have_fds ? hSocketMax + 1 : 0,
1349 |                           &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
1350 | -    if (interruptNet)

---

1380 | +void CConnman::SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set)
1381 | +{
1382 | +    std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
1383 | +    GenerateSelectSet(recv_select_set, send_select_set, error_select_set);
1384 | +
1385 | +    std::vector<struct pollfd> pollfds;

---

1402 | +        pollfd.fd = hSocket;
1403 | +        pollfd.events = POLLERR|POLLHUP;
1404 | +        pollfds.push_back(pollfd);
1405 | +    }
1406 | +
1407 | +    if(poll(&pollfds[0], pollfds.size(), 50) < 0)

---

1327 |  
1328 |      std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
1329 |      GenerateSelectSet(recv_select_set, send_select_set, error_select_set);
1330 |  
1331 | +    if (recv_select_set.empty() && send_select_set.empty() && error_select_set.empty()) {
1332 | +        interruptNet.sleep_for(std::chrono::milliseconds(50));

---

1365 | -                FD_SET(i, &fdsetRecv);
1366 | -        }
1367 | +        int nErr = WSAGetLastError();
1368 | +        LogPrintf("socket select error %s\n", NetworkErrorString(nErr));
1369 | +        for (unsigned int i = 0; i <= hSocketMax; i++)
1370 | +            FD_SET(i, &fdsetRecv);

---

1377 | @@ -1377,6 +1378,58 @@ void CConnman::SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_s
1378 |          if(FD_ISSET(hSocket, &fdsetError))
1379 |              error_set.insert(hSocket);
1380 |  }
1381 | +#else
1382 | +void CConnman::SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set)
1383 | +{
1384 | +    std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
1385 | +    GenerateSelectSet(recv_select_set, send_select_set, error_select_set);

---

1407 | +            pollfds.push_back(pollfd);
1408 | +        }
1409 | +
1410 | +        for (SOCKET hSocket : error_select_set) {
1411 | +            pollfd.fd = hSocket;
1412 | +            pollfd.events = POLLERR|POLLHUP;

---

1412 | +            pollfd.events = POLLERR|POLLHUP;
1413 | +            pollfds.push_back(pollfd);
1414 | +        }
1415 | +    }
1416 | +
1417 | +    if(poll(pollfds.data(), pollfds.size(), 50) < 0)

---

1307 | @@ -1308,6 +1308,7 @@ void CConnman::GenerateSelectSet(std::set<SOCKET> &recv_set, std::set<SOCKET> &s
1308 |      }
1309 |  }
1310 |  
1311 | +#ifdef WIN32

---

1312 |              }
1313 |          }
1314 |      }
1315 | +}
1316 | +
1317 | +#ifndef HAVE_POLL

---

1379 | +    //
1380 | +    // Find which sockets have data to receive
1381 | +    //
1382 | +    struct timeval timeout;
1383 | +    timeout.tv_sec  = 0;
1384 | +    timeout.tv_usec = SELECT_TIMEOUT_MILLISECONDS * 1000; // frequency to poll pnode->vSend

---

1263 | @@ -1262,28 +1264,10 @@ void CConnman::InactivityCheck(CNode *pnode)
1264 |      }
1265 |  }
1266 |  
1267 | -void CConnman::SocketHandler()
1268 | +bool CConnman::GenerateSelectSet(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set)

---

 101 | @@ -102,12 +102,12 @@ typedef void* sockopt_arg_type;
 102 |  typedef char* sockopt_arg_type;
 103 |  #endif
 104 |  
 105 | +#if not defined WIN32

---

1344 | +        pollfds[hSocket].fd = hSocket;
1345 | +        // These flags are ignored, but we set them for clarity
1346 | +        pollfds[hSocket].events |= POLLERR|POLLHUP;
1347 | +    }
1348 | +
1349 | +    std::vector<struct pollfd> vpollfds;

---

1346 | +        pollfds[hSocket].events |= POLLERR|POLLHUP;
1347 | +    }
1348 | +
1349 | +    std::vector<struct pollfd> vpollfds;
1350 | +    for(auto it : pollfds)
1351 | +        vpollfds.push_back(it.second);

---

1345 | +        // These flags are ignored, but we set them for clarity
1346 | +        pollfds[hSocket].events |= POLLERR|POLLHUP;
1347 | +    }
1348 | +
1349 | +    std::vector<struct pollfd> vpollfds;
1350 | +    for(auto it : pollfds)

---

1328 | +        interruptNet.sleep_for(std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS));
1329 | +        return;
1330 | +    }
1331 | +
1332 | +    std::map<SOCKET, struct pollfd> pollfds;
1333 | +    for (SOCKET hSocket : recv_select_set) {

---

1346 | +        pollfds[hSocket].events |= POLLERR|POLLHUP;
1347 | +    }
1348 | +
1349 | +    std::vector<struct pollfd> vpollfds;
1350 | +    vpollfds.reserve(pollfds.size());
1351 | +    for(auto it : pollfds)

---

1356 | +
1357 | +    if (interruptNet)
1358 | +        return;
1359 | +
1360 | +    for (struct pollfd pollfd : vpollfds) {
1361 | +        if (pollfd.revents & POLLIN)

---

1428 | -        if (!interruptNet.sleep_for(std::chrono::milliseconds(timeout.tv_usec/1000)))
1429 | +        if (!interruptNet.sleep_for(std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS)))
1430 |              return;
1431 |      }
1432 |  
1433 | +    for (SOCKET hSocket : recv_select_set)

---

  16 | @@ -17,6 +17,10 @@
  17 |  #include <string>
  18 |  #include <vector>
  19 |  
  20 | +#ifndef WIN32

---

  30 | @@ -31,6 +31,7 @@
  31 |  
  32 |  #ifndef WIN32
  33 |  #include <arpa/inet.h>
  34 | +#include <poll.h>

---

 101 | @@ -102,8 +102,12 @@ typedef void* sockopt_arg_type;
 102 |  typedef char* sockopt_arg_type;
 103 |  #endif
 104 |  
 105 | +#if defined(__linux__)

---

1346 | +
1347 | +    if (poll(vpollfds.data(), vpollfds.size(), SELECT_TIMEOUT_MILLISECONDS) < 0) return;
1348 | +
1349 | +    if (interruptNet) return;
1350 | +
1351 | +    for (struct pollfd pollfd : vpollfds) {

---

  31 | @@ -32,6 +32,7 @@
  32 |  
  33 |  #ifndef WIN32
  34 |  #include <arpa/inet.h>
  35 | +#include <poll.h>

---

 948 |      nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS + MAX_ADDNODE_CONNECTIONS);
 949 | +#ifdef USE_POLL
 950 | +    nMaxConnections = std::max(std::min<int>(nMaxConnections, nFD - nBind - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS), 0);
 951 | +#else
 952 | +    nMaxConnections = std::max(std::min<int>(nMaxConnections, FD_SETSIZE - nBind - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS), 0);
 953 | +#endif

---

1325 | +void CConnman::BuildPollfds(std::vector<struct pollfd> &vpollfds) {
1326 | +    std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
1327 | +    if (!GenerateSelectSet(recv_select_set, send_select_set, error_select_set)) {
1328 | +        interruptNet.sleep_for(std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS));
1329 | +        return;
1330 | +    }

---

1320 | -                         &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
1321 | +    return !recv_set.empty() || !send_set.empty() || !error_set.empty();
1322 | +}
1323 | +
1324 | +#ifdef USE_POLL
1325 | +void CConnman::BuildPollfds(std::vector<struct pollfd> &vpollfds) {

---

1429 | +        if (!interruptNet.sleep_for(std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS)))
1430 |              return;
1431 |      }
1432 |  
1433 | +    for (SOCKET hSocket : recv_select_set) {
1434 | +        if(FD_ISSET(hSocket, &fdsetRecv)) {

---

1350 | +    vpollfds.reserve(pollfds.size());
1351 | +    for (auto it : pollfds) {
1352 | +        vpollfds.push_back(std::move(it.second));
1353 | +    }
1354 | +
1355 | +    if (poll(vpollfds.data(), vpollfds.size(), SELECT_TIMEOUT_MILLISECONDS) < 0) return;

---

1361 | +        if (pollfd_entry.revents & POLLOUT)           send_set.insert(pollfd_entry.fd);
1362 | +        if (pollfd_entry.revents & (POLLERR|POLLHUP)) error_set.insert(pollfd_entry.fd);
1363 | +    }
1364 | +}
1365 | +#else
1366 | +void CConnman::SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set)

---

 272 | +                struct pollfd pollfd = {};
 273 | +                pollfd.fd = hSocket;
 274 | +                pollfd.events = POLLIN | POLLOUT;
 275 | +                int nRet = poll(&pollfd, 1, std::min(endTime - curTime, maxWait));
 276 | +#else
 277 |                  struct timeval tval = MillisToTimeval(std::min(endTime - curTime, maxWait));

---

 278 |                  fd_set fdset;
 279 |                  FD_ZERO(&fdset);
 280 |                  FD_SET(hSocket, &fdset);
 281 |                  int nRet = select(hSocket + 1, &fdset, nullptr, nullptr, &tval);
 282 | +#endif
 283 |                  if (nRet == SOCKET_ERROR) {

---