epoll support

examples/src/linux/Makefile

@@ -33,6 +33,7 @@ TARGETS =					\
  	x8664_hello_cpp			\
 	x8664_hello_cpp_static	\
 	x8664_cloexec_test		\
+	x8664_linux_onestraw	\
 	patch_test.bin
 
 .PHONY: all clean
@@ -124,7 +125,10 @@ libpatch_test.so: patch_test.so.h patch_test.so.c
 	$(CC) $(CPPFLAGS) -Wall -s -O0 -shared -fpic -o $@ patch_test.so.c
 
 patch_test.bin: patch_test.bin.c libpatch_test.so
+
 	$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $^
+x8664_onestraw_server: x8664_linux_onestraw.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -m64 -o $@ $<
 
 $(OBJS):%.o:%.c
 	$(CC) $(CFLAGS) -c $< -o $@

examples/src/linux/x8664_linux_epoll.c

@@ -0,0 +1,54 @@
+#define MAX_EVENTS 5
+#define READ_SIZE 10
+#include <stdio.h>     // for fprintf()
+#include <unistd.h>    // for close(), read()
+#include <sys/epoll.h> // for epoll_create1(), epoll_ctl(), struct epoll_event
+#include <string.h>    // for strncmp
+
+int main()
+{
+	//setvbuf(stdin, NULL, _IONBF, 0);
+	int running = 1, event_count, i;
+	size_t bytes_read;
+	char read_buffer[READ_SIZE + 1];
+	struct epoll_event event, events[MAX_EVENTS];
+	int epoll_fd = epoll_create1(0);
+
+	if (epoll_fd == -1) {
+		fprintf(stderr, "Failed to create epoll file descriptor\n");
+		return 1;
+	}
+
+	event.events = EPOLLIN;
+	event.data.fd = 0;
+
+	if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, 0, &event))
+	{
+		fprintf(stderr, "Failed to add file descriptor to epoll\n");
+		close(epoll_fd);
+		return 1;
+	}
+
+	while (running) {
+		printf("\nPolling for input...\n");
+		event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, 30000);
+		printf("%d ready events\n", event_count);
+		for (i = 0; i < event_count; i++) {
+			printf("Reading file descriptor '%d' -- ", events[i].data.fd);
+			bytes_read = read(events[i].data.fd, read_buffer, READ_SIZE);
+			printf("%zd bytes read.\n", bytes_read);
+			read_buffer[bytes_read] = '\0';
+			printf("Read '%s'\n", read_buffer);
+
+			if(!strncmp(read_buffer, "stop\n", 5))
+			running = 0;
+		}
+	}
+
+	if (close(epoll_fd)) {
+		fprintf(stderr, "Failed to close epoll file descriptor\n");
+		return 1;
+	}
+
+	return 0;
+}

examples/src/linux/x8664_linux_onestraw.c

@@ -0,0 +1,199 @@
+/* 
+ * Attention:
+ * To keep things simple, do not handle socket/bind/listen/.../epoll_create/epoll_wait API error 
+ */
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/epoll.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define DEFAULT_PORT    8000
+#define MAX_CONN        16
+#define MAX_EVENTS      32
+#define BUF_SIZE        16
+#define MAX_LINE        256
+
+void server_run();
+void client_run();
+
+int main(int argc, char *argv[])
+{
+	int opt;
+	char role = 's';
+	while ((opt = getopt(argc, argv, "cs")) != -1) {
+		switch (opt) {
+		case 'c':
+			role = 'c';
+			break;
+		case 's':
+			break;
+		default:
+			printf("usage: %s [-cs]\n", argv[0]);
+			exit(1);
+		}
+	}
+	if (role == 's') {
+		server_run();
+	} else {
+		client_run();
+	}
+	return 0;
+}
+
+/*
+ * register events of fd to epfd
+ */
+static void epoll_ctl_add(int epfd, int fd, uint32_t events)
+{
+	struct epoll_event ev;
+	ev.events = events;
+	ev.data.fd = fd;
+	if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
+		perror("epoll_ctl()\n");
+		exit(1);
+	}
+}
+
+static void set_sockaddr(struct sockaddr_in *addr)
+{
+	bzero((char *)addr, sizeof(struct sockaddr_in));
+	addr->sin_family = AF_INET;
+	addr->sin_addr.s_addr = INADDR_ANY;
+	addr->sin_port = htons(DEFAULT_PORT);
+}
+
+static int setnonblocking(int sockfd)
+{
+	if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK) ==
+	    -1) {
+		return -1;
+	}
+	return 0;
+}
+
+/*
+ * epoll echo server
+ */
+void server_run()
+{
+	int i;
+	int n;
+	int epfd;
+	int nfds;
+	int listen_sock;
+	int conn_sock;
+	int socklen;
+	char buf[BUF_SIZE];
+	struct sockaddr_in srv_addr;
+	struct sockaddr_in cli_addr;
+	struct epoll_event events[MAX_EVENTS];
+
+	listen_sock = socket(AF_INET, SOCK_STREAM, 0);
+
+	set_sockaddr(&srv_addr);
+	bind(listen_sock, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
+
+	setnonblocking(listen_sock);
+	listen(listen_sock, MAX_CONN);
+
+	epfd = epoll_create(1);
+	epoll_ctl_add(epfd, listen_sock, EPOLLIN | EPOLLOUT | EPOLLET);
+
+	socklen = sizeof(cli_addr);
+	int a;
+	for (a = 0; a < 2; a++) {
+		nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
+		for (i = 0; i < nfds; i++) {
+			if (events[i].data.fd == listen_sock) {
+				/* handle new connection */
+				conn_sock =
+				    accept(listen_sock,
+					   (struct sockaddr *)&cli_addr,
+					   &socklen);
+
+				inet_ntop(AF_INET, (char *)&(cli_addr.sin_addr),
+					  buf, sizeof(cli_addr));
+				printf("[+] connected with %s:%d\n", buf,
+				       ntohs(cli_addr.sin_port));
+
+				setnonblocking(conn_sock);
+				epoll_ctl_add(epfd, conn_sock,
+					      EPOLLIN | EPOLLET | EPOLLRDHUP |
+					      EPOLLHUP);
+			} else if (events[i].events & EPOLLIN) {
+				/* handle EPOLLIN event */
+				for (;;) {
+					bzero(buf, sizeof(buf));
+					n = read(events[i].data.fd, buf,
+						 sizeof(buf));
+					if (n <= 0 /* || errno == EAGAIN */ ) {
+						break;
+					} else {
+						printf("[+] data: %s\n", buf);
+						write(events[i].data.fd, buf,
+						      strlen(buf));
+					}
+				}
+			} else {
+				printf("[+] unexpected\n");
+			}
+			/* check if the connection is closing */
+			if (events[i].events & (EPOLLRDHUP | EPOLLHUP)) {
+				printf("[+] connection closed\n");
+				epoll_ctl(epfd, EPOLL_CTL_DEL,
+					  events[i].data.fd, NULL);
+				close(events[i].data.fd);
+				continue;
+			}
+		}
+	}
+}
+
+/*
+ * test clinet 
+ */
+void client_run()
+{
+	int n;
+	int c;
+	int sockfd;
+	char buf[MAX_LINE];
+	struct sockaddr_in srv_addr;
+
+	sockfd = socket(AF_INET, SOCK_STREAM, 0);
+
+	set_sockaddr(&srv_addr);
+
+	if (connect(sockfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0) {
+		perror("connect()");
+		exit(1);
+	}
+
+	for (;;) {
+		printf("input: ");
+		fgets(buf, sizeof(buf), stdin);
+		c = strlen(buf) - 1;
+		buf[c] = '\0';
+		write(sockfd, buf, c + 1);
+
+		bzero(buf, sizeof(buf));
+		while (errno != EAGAIN
+		       && (n = read(sockfd, buf, sizeof(buf))) > 0) {
+			printf("echo: %s\n", buf);
+			bzero(buf, sizeof(buf));
+
+			c -= n;
+			if (c <= 0) {
+				break;
+			}
+		}
+	}
+	close(sockfd);
+}

qiling/os/posix/const.py

@@ -1064,3 +1064,29 @@ class qnx_mmap_prot_flags(QlPrettyFlag):
 SHMDT       = 22
 SHMGET      = 23
 SHMCTL      = 24
+
+# see: https://elixir.bootlin.com/linux/v5.19.17/source/include/uapi/linux/eventpoll.h
+EPOLL_CTL_ADD = 1
+EPOLL_CTL_DEL = 2
+EPOLL_CTL_MOD = 3
+
+EPOLLIN     = 0x00000001
+EPOLLPRI    = 0x00000002
+EPOLLOUT    = 0x00000004
+EPOLLERR    = 0x00000008
+EPOLLHUP    = 0x00000010
+EPOLLNVAL   = 0x00000020
+EPOLLRDNORM = 0x00000040
+EPOLLRDBAND = 0x00000080
+EPOLLWRNORM = 0x00000100
+EPOLLWRBAND = 0x00000200
+EPOLLMSG    = 0x00000400
+EPOLLRDHUP  = 0x00002000
+
+# TODO: should be aligned to emulated system's close-on-exec value
+EPOLL_CLOEXEC = 0o2000000
+
+EPOLLEXCLUSIVE = 0b1 << 28
+EPOLLWAKEUP    = 0b1 << 29
+EPOLLONESHOT   = 0b1 << 30
+EPOLLET        = 0b1 << 31

qiling/os/posix/syscall/__init__.py

@@ -30,3 +30,4 @@
 from .unistd import *
 from .utsname import *
 from .wait import *
+from .epoll import *