sslexample

sslclient.c (5567B)

---

 #include "common.h"
 
 struct ssl_client {
 	struct connection conn;
 };
 
 int
 do_tls_connect(struct io_uring *uring, struct connection *conn, int res)
 {
 	DBGLOG("completed tls handshake!\n");
 
 #ifndef NDEBUG
 	conn->len = snprintf((char *) conn->buf, conn->cap, "Hello, World!\n");	
 #else
 	conn->len = conn->cap;
 #endif
 
 	printf("sending and expecting to receive %zu byte chunks\n", conn->len);
 
 	conn->cur = SSL_write(conn->ssl, conn->buf, conn->len);
 
 	return conn_prep_send(conn, uring);
 }
 
 int
 do_recv(struct io_uring *uring, struct connection *conn, int res)
 {
 	if (conn->cur < conn->len) { /* have not received entire message */
 		conn->cur += SSL_read(conn->ssl, conn->buf + conn->cur, conn->len - conn->cur);
 		return conn_prep_recv(conn, uring);
 	} else { /* received entire message */
 #ifndef NDEBUG
 		printf("received %zu plaintext bytes\n", conn->cur);
 
 		uint64_t nsec_per_msec = 1000000;
 		struct timespec timeout = { .tv_nsec = nsec_per_msec, };
 		while (nanosleep(&timeout, &timeout) < 0);
 #endif
 
 		conn->cur = SSL_write(conn->ssl, conn->buf, conn->len);
 
 		return conn_prep_send(conn, uring);
 	}
 }
 
 int
 do_send(struct io_uring *uring, struct connection *conn, int res)
 {
 	if (conn->cur < conn->len) { /* have not sent entire message */
 		conn->cur += SSL_write(conn->ssl, conn->buf + conn->cur, conn->len - conn->cur);
 		return conn_prep_send(conn, uring);
 	} else { /* sent entire message */
 #ifndef NDEBUG
 		printf("sent %zu plaintext bytes\n", conn->cur);
 #endif
 
 		conn->cur = SSL_read(conn->ssl, conn->buf, conn->len);
 
 		return conn_prep_recv(conn, uring);
 	}
 }
 
 struct ssl_app {
 	char const *host, *port;
 
 	struct io_uring io_uring;
 
 	SSL_CTX *ssl_ctx;
 };
 
 int
 start_client(struct ssl_app *app)
 {
 	struct addrinfo hints = {
 		.ai_family = AF_UNSPEC,
 		.ai_socktype = SOCK_STREAM,
 		.ai_protocol = IPPROTO_TCP,
 		.ai_flags = AI_NUMERICSERV,
 	}, *addrinfo, *ptr;
 
 	int res;
 	if ((res = getaddrinfo(app->host, app->port, &hints, &addrinfo))) {
 		fprintf(stderr, "Failed to get address info: %s\n",
 				gai_strerror(res));
 		exit(EXIT_FAILURE);
 	}
 
 	int sock;
 	for (ptr = addrinfo; ptr; ptr = ptr->ai_next) {
 		sock = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
 		if (sock < 0)
 			continue;
 
 		if (connect(sock, ptr->ai_addr, ptr->ai_addrlen) < 0) {
 			close(sock);
 			continue;
 		}
 
 		break;
 	}
 
 	if (ptr) {
 		char host[NI_MAXHOST], serv[NI_MAXSERV];
 		getnameinfo(ptr->ai_addr, ptr->ai_addrlen,
 			    host, sizeof host, serv, sizeof serv,
 			    NI_NUMERICSERV);
 		printf("Connected to %s:%s\n", host, serv);
 	}
 
 	freeaddrinfo(addrinfo);
 
 	if (!ptr) {
 		fprintf(stderr, "Failed to connect to %s:%s\n",
 				app->host, app->port);
 		exit(EXIT_FAILURE);
 	}
 
 	struct ssl_client *client = malloc(sizeof *client);
 	assert(client);
 
 	SSL *ssl = SSL_new(app->ssl_ctx);
 	assert(ssl);
 
 	SSL_set_connect_state(ssl);
 	SSL_set_tlsext_host_name(ssl, app->host);
 	SSL_set1_host(ssl, app->host);
 
 	size_t cap = 4096;
 	void *buf = malloc(cap);
 	assert(buf);
 
 	conn_init(&client->conn, sock, ssl, buf, cap);
 
 	return conn_do_tls_handshake(&client->conn, &app->io_uring, 0);
 }
 
 void
 stop_client(struct ssl_app *app, struct connection *conn)
 {
 	conn_free(conn);
 
 	struct ssl_client *client = TO_PARENT_PTR(conn, struct ssl_client, conn);
 
 	free(client->conn.buf);
 	free(client);
 }
 
 int
 handle(struct ssl_app *app)
 {
 	start_client(app);
 
 	int quit = 0;
 	while (!quit) {
 		io_uring_submit_and_wait(&app->io_uring, 1);
 
 		struct io_uring_cqe *cqe;
 		unsigned head, seen_cqes = 0;
 		io_uring_for_each_cqe(&app->io_uring, head, cqe) {
 			struct ioreq *ioreq = io_uring_cqe_get_data(cqe);
 			assert(ioreq);
 
 			struct connection *conn =
 				TO_PARENT_PTR(ioreq, struct connection, ioreq);
 
 			switch (ioreq->type) {
 			case IOREQ_RECV: {
 				if (cqe->res <= 0) {
 					conn_prep_close(conn, &app->io_uring);
 					goto next_cqe;
 				}
 
 				conn_finish_recv(conn, cqe->res);
 
 				if (!SSL_is_init_finished(conn->ssl)) {
 					conn_do_tls_handshake(conn, &app->io_uring, cqe->res);
 				} else {
 					do_recv(&app->io_uring, conn, cqe->res);
 				}
 			} break;
 
 			case IOREQ_SEND: {
 				if (cqe->res <= 0) {
 					conn_prep_close(conn, &app->io_uring);
 					goto next_cqe;
 				}
 
 				conn_finish_send(conn, cqe->res);
 
 				if (!SSL_is_init_finished(conn->ssl)) {
 					conn_do_tls_handshake(conn, &app->io_uring, cqe->res);
 				} else {
 					do_send(&app->io_uring, conn, cqe->res);
 				}
 			} break;
 
 			case IOREQ_CLOSE: {
 				stop_client(app, conn);
 				quit = 1;
 			} break;
 
 			default:
 				break;
 			}
 
 next_cqe:
 			seen_cqes++;
 		}
 
 		io_uring_cq_advance(&app->io_uring, seen_cqes);
 	}
 
 	return EXIT_SUCCESS;
 }
 
 int
 main(int argc, char **argv)
 {
 	if (argc < 4) {
 		fprintf(stderr, "Usage: %s <host> <port> <cert>\n", argv[0]);
 		exit(EXIT_FAILURE);
 	}
 
 	char *host = argv[1], *port = argv[2], *cert = argv[3];
 
 	struct ssl_app app;
 	memset(&app, 0, sizeof app);
 
 	app.host = host;
 	app.port = port;
 
 	// create uring
 	// ===================================================================
 	//
 
 	unsigned entries = 32, flags = 0;
 	io_uring_queue_init(entries, &app.io_uring, flags);
 
 	// setup global ssl context and client ssl context
 	// ===================================================================
 	//
 
 	app.ssl_ctx = SSL_CTX_new(TLS_method());
 	assert(app.ssl_ctx);
 
 	SSL_CTX_set_min_proto_version(app.ssl_ctx, TLS1_2_VERSION);
 	SSL_CTX_set_verify(app.ssl_ctx, SSL_VERIFY_PEER, NULL);
 	SSL_CTX_load_verify_file(app.ssl_ctx, cert);
 
 	// start client
 	// ===================================================================
 	//
 
 	exit(handle(&app));
 }