sslexample

common.h (5503B)

---

 #define _GNU_SOURCE 1
 #define _XOPEN_SOURCE 700
 
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <sys/socket.h>
 #include <netinet/ip.h>
 #include <netdb.h>
 
 #include <fcntl.h>
 
 #include <liburing.h>
 
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 
 #ifndef NDEBUG
 # define DBGLOG(...) fprintf(stderr, __VA_ARGS__)
 #else
 # define DBGLOG(...)
 #endif
 
 #define TO_PARENT_PTR(ptr, T, member) \
 	((T *) (((uintptr_t) (ptr)) - offsetof(T, member)))
 
 // ioreq : a helper to make multiplexing operations on an io_uring easier
 // ===========================================================================
 //
 
 enum ioreq_type {
 	IOREQ_ACCEPT, IOREQ_CONNECT, IOREQ_RECV, IOREQ_SEND, IOREQ_CLOSE,
 };
 
 struct ioreq_accept {
 	int fd;
 	struct sockaddr *addr;
 	socklen_t *addrlen;
 	int flags;
 };
 
 struct ioreq_connect {
 	int fd;
 	struct sockaddr *addr;
 	socklen_t addrlen;
 };
 
 struct ioreq_recv {
 	int fd;
 	void *buf;
 	size_t len;
 	int flags;
 };
 
 struct ioreq_send {
 	int fd;
 	void *buf;
 	size_t len;
 	int flags;
 };
 
 struct ioreq_close {
 	int fd;
 };
 
 union ioreq_tag {
 	struct ioreq_accept accept;
 	struct ioreq_connect connect;
 	struct ioreq_recv recv;
 	struct ioreq_send send;
 	struct ioreq_close close;
 };
 
 struct ioreq {
 	enum ioreq_type type;
 	union ioreq_tag tag;
 };
 
 static int
 queue_ioreqs(struct io_uring *uring, struct ioreq *reqs, size_t len)
 {
 	for (size_t i = 0; i < len; i++) {
 		struct ioreq *req = &reqs[i];
 
 		struct io_uring_sqe *sqe = io_uring_get_sqe(uring);
 		if (!sqe) { /* out of sqes, submit and try again */
 			io_uring_submit(uring);
 			sqe = io_uring_get_sqe(uring);
 		}
 
 		assert(sqe);
 
 		io_uring_sqe_set_data(sqe, req);
 
 		switch (req->type) {
 		case IOREQ_ACCEPT:
 			io_uring_prep_accept(sqe,
 					     req->tag.accept.fd,
 					     req->tag.accept.addr,
 					     req->tag.accept.addrlen,
 					     req->tag.accept.flags);
 			break;
 
 		case IOREQ_CONNECT:
 			io_uring_prep_connect(sqe,
 					      req->tag.connect.fd,
 					      req->tag.connect.addr,
 					      req->tag.connect.addrlen);
 			break;
 
 		case IOREQ_RECV:
 			io_uring_prep_recv(sqe,
 					   req->tag.recv.fd,
 					   req->tag.recv.buf,
 					   req->tag.recv.len,
 					   req->tag.recv.flags);
 			break;
 
 		case IOREQ_SEND:
 			io_uring_prep_send(sqe,
 					   req->tag.send.fd,
 					   req->tag.send.buf,
 					   req->tag.send.len,
 					   req->tag.send.flags);
 			break;
 
 
 		case IOREQ_CLOSE:
 			io_uring_prep_close(sqe,
 					    req->tag.close.fd);
 			break;
 		}
 	}
 
 	return 0;
 }
 
 // connection : an abstraction over a socket and an ssl stream
 // ===========================================================================
 //
 
 struct connection {
 	int socket;
 
 	struct ioreq ioreq;
 
 	SSL *ssl;
 	BIO *ssl_bio, *net_bio;
 
 	size_t cur, len, cap;
 	unsigned char *buf;
 };
 
 static void
 conn_init(struct connection *conn, int fd, SSL *ssl, void *buf, size_t cap)
 {
 	conn->socket = fd;
 	conn->ssl = ssl;
 
 	BIO_new_bio_pair(&conn->ssl_bio, 0, &conn->net_bio, 0);
 	SSL_set_bio(conn->ssl, conn->ssl_bio, conn->ssl_bio);
 
 	conn->buf = buf;
 	conn->cap = cap;
 	conn->cur = conn->len = 0;
 }
 
 static void
 conn_free(struct connection *conn)
 {
 	SSL_free(conn->ssl);
 	BIO_free(conn->net_bio);
 }
 
 static int
 conn_prep_recv(struct connection *conn, struct io_uring *uring)
 {
 	char *buf;
 	int len = BIO_nwrite0(conn->net_bio, &buf);
 
 	DBGLOG("[conn:%d] receiving %d bytes\n", conn->socket, len);
 
 	conn->ioreq.type = IOREQ_RECV;
 	conn->ioreq.tag.recv.fd = conn->socket;
 	conn->ioreq.tag.recv.buf = buf;
 	conn->ioreq.tag.recv.len = len;
 	conn->ioreq.tag.recv.flags = 0;
 
 	return queue_ioreqs(uring, &conn->ioreq, 1);
 }
 
 static void
 conn_finish_recv(struct connection *conn, int res)
 {
 	DBGLOG("[conn:%d] recieved %d bytes\n", conn->socket, res);
 	BIO_nwrite(conn->net_bio, NULL, res);
 }
 
 static int
 conn_prep_send(struct connection *conn, struct io_uring *uring)
 {
 	char *buf;
 	int len = BIO_nread0(conn->net_bio, &buf);
 
 	DBGLOG("[conn:%d] sending %d bytes\n", conn->socket, len);
 
 	conn->ioreq.type = IOREQ_SEND;
 	conn->ioreq.tag.send.fd = conn->socket;
 	conn->ioreq.tag.send.buf = buf;
 	conn->ioreq.tag.send.len = len;
 	conn->ioreq.tag.send.flags = 0;
 
 	return queue_ioreqs(uring, &conn->ioreq, 1);
 }
 
 static void
 conn_finish_send(struct connection *conn, int res)
 {
 	DBGLOG("[conn:%d] sent %d bytes\n", conn->socket, res);
 	BIO_nread(conn->net_bio, NULL, res);
 }
 
 static int
 conn_prep_close(struct connection *conn, struct io_uring *uring)
 {
 	DBGLOG("[conn:%d] closing connection\n", conn->socket);
 
 	conn->ioreq.type = IOREQ_CLOSE;
 	conn->ioreq.tag.close.fd = conn->socket;
 
 	return queue_ioreqs(uring, &conn->ioreq, 1);
 }
 
 extern int
 do_tls_connect(struct io_uring *uring, struct connection *conn, int res);
 
 static int
 conn_do_tls_handshake(struct connection *conn, struct io_uring *uring,
 		      int transferred)
 {
 	int res = SSL_do_handshake(conn->ssl);
 	if (res == 1) /* completed handshake */
 		return do_tls_connect(uring, conn, transferred);
 
 	if (res == 0) /* disconnected */
 		return -1;
 
 	int err = SSL_get_error(conn->ssl, res);
 	if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE) {
 		fprintf(stderr, "unexpected ssl error: %d\n", err);
 		ERR_print_errors_fp(stderr);
 		return -1;
 	}
 
 	int pending = BIO_ctrl_pending(conn->net_bio);
 	if (pending)
 		return conn_prep_send(conn, uring);
 
 	int expecting = BIO_ctrl_get_read_request(conn->net_bio);
 	if (expecting)
 		return conn_prep_recv(conn, uring);
 
 	return -1;
 }