serve

main.c (6802B)

---

 #include "website.h"
 
 struct opts opts = {
 	.verbose = 0,
 	.host = "localhost",
 	.port = "8080",
 };
 
 #define OPTSTR "hva:p:"
 static void
 usage(char *prog)
 {
 	fprintf(stderr, "Usage: %s [-hv] [-a <addr>] [-p <port>] <webroot>\n", prog);
 	fprintf(stderr, "\t-h : display this help information\n");
 	fprintf(stderr, "\t-v : enable verbose logging\n");
 	fprintf(stderr, "\t-a : set the server socket bind address (default: localhost)\n");
 	fprintf(stderr, "\t-p : set the server socket bind port (default: 8080)\n");
 	fprintf(stderr, "\twebroot : directory out of which to serve files\n");
 }
 
 static int
 parse_opts(int argc, char **argv)
 {
 	int opt;
 	while ((opt = getopt(argc, argv, OPTSTR)) > 0) {
 		switch (opt) {
 		case 'v':
 			opts.verbose = 1;
 			break;
 
 		case 'a':
 			opts.host = optarg;
 			break;
 
 		case 'p':
 			opts.port = optarg;
 			break;
 
 		default:
 			return -1;
 		}
 	}
 
 	if (optind >= argc) {
 		fprintf(stderr, "Missing webroot\n");
 		return -1;
 	}
 
 	opts.webroot = argv[optind];
 
 	return 0;
 }
 
 sig_atomic_t quit;
 
 static void
 close_handler(int sig, siginfo_t *info, void *uctx)
 {
 	(void) info;
 	(void) uctx;
 
 	fprintf(stderr, "Signal %d caught. Quitting\n", sig);
 
 	quit = 1;
 }
 
 sig_atomic_t reload_tree;
 
 static void
 reload_handler(int sig, siginfo_t *info, void *uctx)
 {
 	(void) info;
 	(void) uctx;
 
 	fprintf(stderr, "Signal %d caught. Reloading file tree\n", sig);
 
 	reload_tree = 1;
 }
 
 int
 serve(struct io_uring *ioring, int webroot, int sock, struct connection_pool *pool)
 {
 	listen(sock, SERVER_LISTEN_BACKLOG);
 
 	struct sockaddr_storage client_addr;
 	socklen_t client_addrlen = sizeof client_addr;
 
 	struct ioreq accept_req = {
 		.type = IOREQ_ACCEPT,
 		.fd = sock,
 		.accept.addr = (struct sockaddr *) &client_addr,
 		.accept.addrlen = &client_addrlen,
 		.accept.flags = 0,
 	};
 
 	enqueue_ioreq(ioring, &accept_req);
 	submit_ioreqs(ioring);
 
 	quit = 0;
 	while (!quit) {
 		struct io_uring_cqe *cqe;
 		if (io_uring_wait_cqe(ioring, &cqe) < 0) {
 			fprintf(stderr, "io_uring_wait_cqe() failed\n");
 			return EXIT_FAILURE;
 		}
 
 		unsigned head, seen = 0;
 		io_uring_for_each_cqe(ioring, head, cqe) {
 			struct ioreq *ioreq = io_uring_cqe_get_data(cqe);
 			if (!ioreq) { /* overloaded client error messages */
 				// TODO: do something?
 			}
 
 			int res = cqe->res;
 			switch (ioreq->type) {
 			case IOREQ_ACCEPT: {
 				if (res < 0) { /* multishot failed, restart? */
 					fprintf(stderr, "multishot accept failed\n");
 					return EXIT_FAILURE;
 				}
 
 				struct connection *conn = connection_pool_alloc(pool);
 				if (!conn) { /* overloaded server */
 					close(res);
 					goto next_cqe;
 				}
 
 				if (opts.verbose) {
 				char host[NI_MAXHOST];
 				char port[NI_MAXSERV];
 				getnameinfo((struct sockaddr *) &client_addr,
 					    client_addrlen,
 					    host, sizeof host,
 					    port, sizeof port,
 					    NI_NUMERICHOST | NI_NUMERICSERV);
 
 				fprintf(stderr, "[%d] Client connection from %s:%s\n",
 						res, host, port);
 				}
 
 				handle_accept(ioring, conn, res);
 			} break;
 
 			case IOREQ_RECV: {
 				struct connection *conn = TO_PARENT(ioreq, struct connection, ioreq);
 				assert(conn);
 
 				if (res <= 0) {
 					if (opts.verbose)
 					fprintf(stderr, "recv(): %d (%s), closing connection\n", res, strerror(-res));
 					close_connection(ioring, conn);
 					break;
 				}
 
 				if (opts.verbose)
 				fprintf(stderr, "[%d] Client recv: %d bytes\n",
 						conn->socket, res);
 
 				handle_request_chunk(ioring, conn, webroot, res);
 			} break;
 
 			case IOREQ_SEND: {
 				struct connection *conn = TO_PARENT(ioreq, struct connection, ioreq);
 				assert(conn);
 
 				if (res <= 0) {
 					if (opts.verbose)
 					fprintf(stderr, "send(): %d (%s), closing connection\n", res, strerror(-res));
 					close_connection(ioring, conn);
 					break;
 				}
 
 				if (opts.verbose)
 				fprintf(stderr, "[%d] Client send(): %d bytes\n",
 						conn->socket, res);
 
 				handle_response_chunk(ioring, conn, res);
 			} break;
 
 			case IOREQ_READ: {
 				struct connection *conn = TO_PARENT(ioreq, struct connection, ioreq);
 				assert(conn);
 
 				if (res <= 0) {
 					if (opts.verbose)
 					fprintf(stderr, "read(): %d (%s), closing connection\n", res, strerror(-res));
 					close_connection(ioring, conn);
 					break;
 				}
 
 				if (opts.verbose)
 				fprintf(stderr, "[%d] Client read: %d bytes\n",
 						conn->socket, res);
 
 				handle_fileread_chunk(ioring, conn, res);
 			} break;
 
 			case IOREQ_CLOSE: {
 				struct connection *conn = TO_PARENT(ioreq, struct connection, ioreq);
 				assert(conn);
 
 				if (opts.verbose)
 				fprintf(stderr, "[%d] Client closed connection\n",
 						conn->socket);
 
 				connection_pool_free(pool, conn);
 			} break;
 			}
 
 next_cqe:
 			seen++;
 		}
 
 		io_uring_cq_advance(ioring, seen);
 
 		submit_ioreqs(ioring);
 	}
 
 	return EXIT_SUCCESS;
 }
 
 int
 main(int argc, char **argv)
 {
 	if (parse_opts(argc, argv) < 0) {
 		usage(argv[0]);
 		exit(EXIT_FAILURE);
 	}
 
 	struct sigaction on_close = {
 		.sa_sigaction = close_handler, .sa_flags = SA_SIGINFO,
 	};
 
 	sigaction(SIGINT, &on_close, NULL);
 	sigaction(SIGKILL, &on_close, NULL);
 
 	/* we want to cache the webroot tree in memory, and we need to know
 	 * when tree has changed. we could use inotify for this, but that has
 	 * the possibility of failure (overflow) and is more complicated than
 	 * the program updating our tree sending us a signal to reload
 	 */
 	struct sigaction on_reload = {
 		.sa_sigaction = reload_handler, .sa_flags = SA_SIGINFO,
 	};
 
 	sigaction(SIGHUP, &on_reload, NULL);
 
 	struct connection_pool pool;
 	if (connection_pool_init(&pool, CONNECTION_POOL_CAPACITY) < 0) {
 		fprintf(stderr, "Failed to initialise connection pool\n");
 		exit(EXIT_FAILURE);
 	}
 
 	struct io_uring ioring;
 	if (ioring_init(&ioring)) {
 		fprintf(stderr, "Failed to initialise io_uring\n");
 		exit(EXIT_FAILURE);
 	}
 
 	int webroot = open(opts.webroot, O_DIRECTORY | O_PATH | O_CLOEXEC);
 	if (webroot < 0) {
 		fprintf(stderr, "Failed to open webroot %s\n", opts.webroot);
 		exit(EXIT_FAILURE);
 	}
 
 	int sock = create_server_socket(opts.host, opts.port);
 	if (sock < 0) {
 		fprintf(stderr, "Failed to create and bind server socket to %s:%s\n",
 				opts.host, opts.port);
 		exit(EXIT_FAILURE);
 	}
 
 	struct sockaddr_storage addr;
 	socklen_t addrlen = sizeof addr;
 	if (getsockname(sock, (struct sockaddr *) &addr, &addrlen) < 0) {
 		fprintf(stderr, "Failed to get bound socket addr\n");
 		exit(EXIT_FAILURE);
 	}
 
 	char bound_host[NI_MAXHOST], bound_port[NI_MAXSERV];
 	getnameinfo((struct sockaddr *) &addr, addrlen,
 		    bound_host, sizeof bound_host,
 		    bound_port, sizeof bound_port,
 		    NI_NUMERICHOST | NI_NUMERICSERV);
 
 	fprintf(stderr, "Server socket bound to %s:%s\n", bound_host, bound_port);
 
 	exit(serve(&ioring, webroot, sock, &pool));
 }
 
 #include "utils.c"
 #include "net.c"
 #include "uri.c"
 #include "connection.c"