lldpad eloop select change to poll

In an environment with 576 virtual NICs, when the function eloop_sock_table_dispatch calls FD_ISSET,
the value of file descriptor table->table[i].sock exceeds 1024 (the kernel fds structure has only 1024 bits).
As a result, the glibc determines that a buffer overflow occurs and aborts the process.

To solve this problem, we change select to poll because poll has no restriction on the fd size.
Poll allows file descriptors to listen to different events, such as POLLIN and POLLOUT.
Therefore, no need to create different queues for different events, we delete writers and exceptions
and rename readers to sock_table.

Author: huyizhen

eloop.c

@@ -20,6 +20,7 @@
 #include <sys/time.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <poll.h>
 #include "eloop.h"
 #include "include/messages.h"
 
@@ -67,9 +68,11 @@ int os_get_time(struct os_time *t)
 	} \
 } while (0)
 
+#define os_time_to_ms(a) \
+	((a)->sec * 1000 + (a)->usec / 1000)
 
 struct eloop_sock {
-	int sock;
+	struct pollfd sock;
 	void *eloop_data;
 	void *user_data;
 	eloop_sock_handler handler;
@@ -99,11 +102,9 @@ struct eloop_sock_table {
 struct eloop_data {
 	void *user_data;
 
-	int max_sock;
+	int max_sockfd;
 
-	struct eloop_sock_table readers;
-	struct eloop_sock_table writers;
-	struct eloop_sock_table exceptions;
+	struct eloop_sock_table sock_table;
 
 	struct eloop_timeout *timeout;
 
@@ -127,167 +128,122 @@ int eloop_init(void *user_data)
 }
 
 
-static int eloop_sock_table_add_sock(struct eloop_sock_table *table,
-                                     int sock, eloop_sock_handler handler,
+int eloop_register_sock(struct pollfd sock, eloop_sock_handler handler,
                                      void *eloop_data, void *user_data)
 {
 	struct eloop_sock *tmp;
 
-	if (table == NULL)
-		return -EINVAL;
-
 	tmp = (struct eloop_sock *)
-		realloc(table->table,
-			   (table->count + 1) * sizeof(struct eloop_sock));
+		realloc(eloop.sock_table.table,
+			   (eloop.sock_table.count + 1) * sizeof(struct eloop_sock));
 	if (tmp == NULL)
 		return -ENOMEM;
 
-	tmp[table->count].sock = sock;
-	tmp[table->count].eloop_data = eloop_data;
-	tmp[table->count].user_data = user_data;
-	tmp[table->count].handler = handler;
-	table->count++;
-	table->table = tmp;
-	if (sock > eloop.max_sock)
-		eloop.max_sock = sock;
-	table->changed = 1;
+	tmp[eloop.sock_table.count].sock = sock;
+	tmp[eloop.sock_table.count].eloop_data = eloop_data;
+	tmp[eloop.sock_table.count].user_data = user_data;
+	tmp[eloop.sock_table.count].handler = handler;
+	eloop.sock_table.count++;
+	eloop.sock_table.table = tmp;
+	if (sock.fd > eloop.max_sockfd)
+		eloop.max_sockfd = sock.fd;
+	eloop.sock_table.changed = 1;
 
 	return 0;
 }
 
 
-static void eloop_sock_table_remove_sock(struct eloop_sock_table *table,
-                                         int sock)
+void eloop_unregister_sock(int sockfd)
 {
 	int i;
 
-	if (table == NULL || table->table == NULL || table->count == 0)
+	if (eloop.sock_table.table == NULL || eloop.sock_table.count == 0)
 		return;
 
-	for (i = 0; i < table->count; i++) {
-		if (table->table[i].sock == sock)
+	for (i = 0; i < eloop.sock_table.count; i++) {
+		if (eloop.sock_table.table[i].sock.fd == sockfd)
 			break;
 	}
-	if (i == table->count)
+	if (i == eloop.sock_table.count)
 		return;
-	if (i != table->count - 1) {
-		memmove(&table->table[i], &table->table[i + 1],
-			   (table->count - i - 1) *
+	if (i != eloop.sock_table.count - 1) {
+		memmove(&eloop.sock_table.table[i], &eloop.sock_table.table[i + 1],
+			   (eloop.sock_table.count - i - 1) *
 			   sizeof(struct eloop_sock));
 	}
-	table->count--;
-	table->changed = 1;
+	eloop.sock_table.count--;
+	eloop.sock_table.changed = 1;
 }
 
 
-static void eloop_sock_table_set_fds(struct eloop_sock_table *table,
-				     fd_set *fds)
+static void eloop_sock_table_set_fds(struct pollfd *fds)
 {
 	int i;
-
-	FD_ZERO(fds);
-
-	if (table->table == NULL)
+	if (eloop.sock_table.table == NULL)
 		return;
 
-	for (i = 0; i < table->count; i++)
-		FD_SET(table->table[i].sock, fds);
+	for (i = 0; i < eloop.sock_table.count; i++) {
+		fds[eloop.sock_table.table[i].sock.fd] = eloop.sock_table.table[i].sock;
+	}
 }
 
 
-static void eloop_sock_table_dispatch(struct eloop_sock_table *table,
-				      fd_set *fds)
+static void eloop_sock_table_dispatch(struct pollfd *fds)
 {
 	int i;
 
-	if (table == NULL || table->table == NULL)
+	if (eloop.sock_table.table == NULL)
 		return;
 
-	table->changed = 0;
-	for (i = 0; i < table->count; i++) {
-		if (FD_ISSET(table->table[i].sock, fds)) {
-			table->table[i].handler(table->table[i].sock,
-						table->table[i].eloop_data,
-						table->table[i].user_data);
-			if (table->changed)
+	eloop.sock_table.changed = 0;
+	for (i = 0; i < eloop.sock_table.count; i++) {
+		if (fds[eloop.sock_table.table[i].sock.fd].revents & POLL_IN) {
+			eloop.sock_table.table[i].handler(eloop.sock_table.table[i].sock.fd,
+						eloop.sock_table.table[i].eloop_data,
+						eloop.sock_table.table[i].user_data);
+			if (eloop.sock_table.changed)
 				break;
 		}
 	}
 }
 
 
-static void eloop_sock_table_destroy(struct eloop_sock_table *table)
+static void eloop_sock_table_destroy()
 {
-	int rc, tc, sock;
-
-	if (table) {
-		tc = table->count;
+	int rc, tc, sockfd;
+	if (eloop.sock_table.table) {
+		tc = eloop.sock_table.count;
 		while (tc > 0) {
-			sock = table->table[tc].sock;
-			rc = fcntl(sock, F_GETFD);
+			sockfd = eloop.sock_table.table[tc].sock.fd;
+			rc = fcntl(sockfd, F_GETFD);
 			if (rc != -1) {
-				rc = close(sock);
+				rc = close(sockfd);
 				if (rc)
 					LLDPAD_ERR("Failed to close fd - %s\n",
 							strerror(errno));
 			}
 			tc--;
 		}
-		free(table->table);
+		free(eloop.sock_table.table);
 	}
 }
 
 
-int eloop_register_read_sock(int sock, eloop_sock_handler handler,
+int eloop_register_read_sock(int sockfd, eloop_sock_handler handler,
 			     void *eloop_data, void *user_data)
 {
-	return eloop_register_sock(sock, EVENT_TYPE_READ, handler,
-				   eloop_data, user_data);
-}
-
-
-void eloop_unregister_read_sock(int sock)
-{
-	eloop_unregister_sock(sock, EVENT_TYPE_READ);
-}
-
-
-static struct eloop_sock_table *eloop_get_sock_table(eloop_event_type type)
-{
-	switch (type) {
-	case EVENT_TYPE_READ:
-		return &eloop.readers;
-	case EVENT_TYPE_WRITE:
-		return &eloop.writers;
-	case EVENT_TYPE_EXCEPTION:
-		return &eloop.exceptions;
-	}
-
-	return NULL;
-}
-
-
-int eloop_register_sock(int sock, eloop_event_type type,
-			eloop_sock_handler handler,
-			void *eloop_data, void *user_data)
-{
-	struct eloop_sock_table *table;
-
-	table = eloop_get_sock_table(type);
-	return eloop_sock_table_add_sock(table, sock, handler,
-					 eloop_data, user_data);
+	struct pollfd sock = {0};
+	sock.fd = sockfd;
+	sock.events = POLLIN;
+	return eloop_register_sock(sock, handler, eloop_data, user_data);
 }
 
 
-void eloop_unregister_sock(int sock, eloop_event_type type)
+void eloop_unregister_read_sock(int sockfd)
 {
-	struct eloop_sock_table *table;
-
-	table = eloop_get_sock_table(type);
-	eloop_sock_table_remove_sock(table, sock);
+	eloop_unregister_sock(sockfd);
 }
 
-
 int eloop_register_timeout(unsigned int secs, unsigned int usecs,
 			   eloop_timeout_handler handler,
 			   void *eloop_data, void *user_data)
@@ -468,37 +424,31 @@ int eloop_register_signal_reconfig(eloop_signal_handler handler,
 
 void eloop_run(void)
 {
-	fd_set *rfds, *wfds, *efds;
-	int res;
-	struct timeval _tv;
+	int res, timeout;
 	struct os_time tv, now;
-
-	rfds = malloc(sizeof(*rfds));
-	wfds = malloc(sizeof(*wfds));
-	efds = malloc(sizeof(*efds));
-	if (rfds == NULL || wfds == NULL || efds == NULL) {
-		printf("eloop_run - malloc failed\n");
-		goto out;
-	}
+	struct pollfd *fds = NULL;
 
 	while (!eloop.terminate &&
-	       (eloop.timeout || eloop.readers.count > 0 ||
-		eloop.writers.count > 0 || eloop.exceptions.count > 0)) {
+	       (eloop.timeout || eloop.sock_table.count > 0)) {
 		if (eloop.timeout) {
 			os_get_time(&now);
 			if (os_time_before(&now, &eloop.timeout->time))
 				os_time_sub(&eloop.timeout->time, &now, &tv);
 			else
 				tv.sec = tv.usec = 0;
-			_tv.tv_sec = tv.sec;
-			_tv.tv_usec = tv.usec;
+			timeout = os_time_to_ms(&tv);
 		}
 
-		eloop_sock_table_set_fds(&eloop.readers, rfds);
-		eloop_sock_table_set_fds(&eloop.writers, wfds);
-		eloop_sock_table_set_fds(&eloop.exceptions, efds);
-		res = select(eloop.max_sock + 1, rfds, wfds, efds,
-			     eloop.timeout ? &_tv : NULL);
+		fds = (struct pollfd *)
+			realloc(fds, (eloop.max_sockfd + 1) * sizeof(struct eloop_sock));
+		if (fds == NULL) {
+			perror("realloc");
+			goto out;
+		}
+		memset(fds, 0, (eloop.max_sockfd + 1) * sizeof(struct eloop_sock));
+
+		eloop_sock_table_set_fds(fds);
+		res = poll(fds, eloop.max_sockfd + 1, eloop.timeout ? timeout : -1);
 		if (res < 0 && errno != EINTR && errno != 0) {
 			perror("select");
 			goto out;
@@ -522,16 +472,11 @@ void eloop_run(void)
 
 		if (res <= 0)
 			continue;
-
-		eloop_sock_table_dispatch(&eloop.readers, rfds);
-		eloop_sock_table_dispatch(&eloop.writers, wfds);
-		eloop_sock_table_dispatch(&eloop.exceptions, efds);
+		eloop_sock_table_dispatch(fds);
 	}
-
 out:
-	free(rfds);
-	free(wfds);
-	free(efds);
+	if (fds)
+		free(fds);
 }
 
 
@@ -551,9 +496,7 @@ void eloop_destroy(void)
 		timeout = timeout->next;
 		free(prev);
 	}
-	eloop_sock_table_destroy(&eloop.readers);
-	eloop_sock_table_destroy(&eloop.writers);
-	eloop_sock_table_destroy(&eloop.exceptions);
+	eloop_sock_table_destroy();
 	free(eloop.signals);
 }
 
@@ -564,16 +507,16 @@ int eloop_terminated(void)
 }
 
 
-void eloop_wait_for_read_sock(int sock)
+void eloop_wait_for_read_sock(int sockfd)
 {
-	fd_set rfds;
+	struct pollfd fds;
 
-	if (sock < 0)
+	if (sockfd < 0)
 		return;
 
-	FD_ZERO(&rfds);
-	FD_SET(sock, &rfds);
-	select(sock + 1, &rfds, NULL, NULL, NULL);
+	fds.fd = sockfd;
+	fds.events = POLLIN;
+	poll(&fds, 1, -1);
 }