Replace select() with poll()

select() can monitor only file descriptors numbers that are less than
FD_SETSIZE, poll() does not have this limitation. Using a file
descriptor greater than or equal to FD_SETSIZE results in buffer
overflow.

Change-Id: I803f8dae37303598c64dbb5d50483d287175c08d
(cherry picked from commit e5b2c929da88469ea651757d8a19fc871f1d57a9)

Author: Paweł Andruszkiewicz

modules/util/json_importer.cc

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2022, Oracle and/or its affiliates.
+ * Copyright (c) 2018, 2023, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0,
@@ -25,7 +25,7 @@
 #ifdef _WIN32
 #include <Winsock2.h>
 #else
-#include <sys/select.h>
+#include <poll.h>
 #endif
 #include <deque>
 #include <istream>
@@ -317,19 +317,28 @@ void Json_importer::update_statistics(xcl::XQuery_result *xquery_result) {
 
 void Json_importer::recv_response(bool block) {
   if (m_pending_response > 0) {
-    my_socket fd = m_session->get_driver_obj()
-                       ->get_protocol()
-                       .get_connection()
-                       .get_socket_fd();
-    fd_set rfds;
-    FD_ZERO(&rfds);
-    FD_SET(fd, &rfds);
-    timeval timeout;
-    timeout.tv_sec = 0;
-    timeout.tv_usec = 0;
-    auto ready = select(fd + 1, &rfds, nullptr, nullptr, &timeout);
-    bool fd_ready = FD_ISSET(fd, &rfds);
-    if (block || (ready > 0 && fd_ready)) {
+    bool should_receive = false;
+
+    if (block) {
+      should_receive = true;
+    } else {
+      pollfd rfds;
+      rfds.fd = m_session->get_driver_obj()
+                    ->get_protocol()
+                    .get_connection()
+                    .get_socket_fd();
+      rfds.events = POLLIN;
+      rfds.revents = 0;
+
+#ifdef _WIN32
+      const auto poll = WSAPoll;
+#endif  // _WIN32
+
+      const auto ready = poll(&rfds, 1, 0);  // return immediately
+      should_receive = (ready > 0) && (rfds.revents & POLLIN);
+    }
+
+    if (should_receive) {
       xcl::XError error;
       auto result =
           m_session->get_driver_obj()->get_protocol().recv_resultset(&error);

mysqlshdk/libs/utils/process_launcher.cc

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2022, Oracle and/or its affiliates.
+ * Copyright (c) 2014, 2023, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0,
@@ -773,42 +773,44 @@ std::string Process::read_from_terminal() {
 
   return output;
 #else   // ! __APPLE__
-  fd_set input;
   char buffer[512];
-  struct timeval timeout;
   int64_t retry_count = 0;
 
-  do {
-    timeout.tv_sec = 0;
-    timeout.tv_usec = 500 * 1000;  // 500ms
+  pollfd input;
+  input.fd = m_master_device;
+  input.events = POLLIN;
 
-    FD_ZERO(&input);
-    FD_SET(m_master_device, &input);
+  do {
+    input.revents = 0;
 
-    int ret = ::select(m_master_device + 1, &input, nullptr, nullptr, &timeout);
+    int ret = ::poll(&input, 1, 500);  // 500ms
 
     if (ret == -1) {
       report_error(nullptr);
     } else if (ret == 0) {
-      report_error("Timeout on select()");
-    } else {
+      report_error("Timeout on poll()");
+    } else if (input.revents & POLLIN) {
       int n = ::read(m_master_device, buffer, sizeof(buffer));
 
       if (n >= 0) {
         return std::string(buffer, n);
-      } else if (errno == EIO) {
-        // This error means that the other side of pseudo terminal is closed.
-        // Since child does not duplicate it to stdin/stdout/stderr, it will
-        // remain closed until the child process opens the controlling terminal
-        // (i.e. writes the password prompt and waits for user input).
-        if (++retry_count > 1000000) {
-          report_error("Controlling terminal seems to be closed");
-        } else {
-          continue;
-        }
       } else {
         report_error(nullptr);
       }
+    } else if (input.revents & POLLHUP) {
+      // This event means that the other side of pseudo terminal is closed.
+      // Since child does not duplicate it to stdin/stdout/stderr, it will
+      // remain closed until the child process opens the controlling terminal
+      // (i.e. writes the password prompt and waits for user input).
+      if (++retry_count > 1000000) {
+        report_error("Controlling terminal seems to be closed");
+      } else {
+        continue;
+      }
+    } else {
+      const auto msg = "No data to read, poll() returned an error event: " +
+                       std::to_string(input.revents);
+      report_error(msg.c_str());
     }
   } while (true);
 

mysqlshdk/libs/utils/utils_net.cc

@@ -38,6 +38,7 @@
 #include <ifaddrs.h>
 #include <net/if.h>
 #include <netdb.h>
+#include <poll.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -602,32 +603,30 @@ bool Net::is_port_listening_impl(const std::string &address, int port) const {
   }
 
 #ifdef _WIN32
+  const auto poll = WSAPoll;
   auto last_error = []() { return WSAGetLastError(); };
   const int connection_refused = WSAECONNREFUSED;
-  auto would_block = [](int err) {
+  const auto would_block = [](int err) {
     return err == WSAEWOULDBLOCK || err == WSAEINPROGRESS;
   };
 #else
   auto last_error = []() { return errno; };
   const int connection_refused = ECONNREFUSED;
-  auto would_block = [](int err) {
+  const auto would_block = [](int err) {
     return err == EWOULDBLOCK || err == EINPROGRESS;
   };
 #endif
   int err;
 
-  struct timeval timeout;
-  timeout.tv_sec = k_port_check_timeout;
-  timeout.tv_usec = 0;
+  pollfd fds;
+  fds.fd = sock;
+  fds.events = POLLIN | POLLOUT;
 
   while (would_block((err = last_error()))) {
-    fd_set wfds, efds;
-    FD_ZERO(&wfds);
-    FD_SET(sock, &wfds);
-    FD_ZERO(&efds);
-    FD_SET(sock, &efds);
+    fds.revents = 0;
+
+    err = poll(&fds, 1, k_port_check_timeout * 1000);  // milliseconds
 
-    err = select(sock + 1, nullptr, &wfds, &efds, &timeout);
     if (err == 0) {
       // timeout
       closesocket(sock);
@@ -636,6 +635,7 @@ bool Net::is_port_listening_impl(const std::string &address, int port) const {
 
     if (err > 0) {
       socklen_t len = sizeof(err);
+
       if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&err, &len) < 0) {
         err = last_error();
       } else {
@@ -644,6 +644,7 @@ bool Net::is_port_listening_impl(const std::string &address, int port) const {
           return true;
         }
       }
+
       break;
     }
   }