[linux-block.git] / tools / testing / selftests / net / tls.c

// SPDX-License-Identifier: GPL-2.0

#define _GNU_SOURCE

#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <linux/tls.h>
#include <linux/tcp.h>
#include <linux/socket.h>

#include <sys/types.h>
#include <sys/sendfile.h>
#include <sys/socket.h>
#include <sys/stat.h>

#include "../kselftest_harness.h"

#define TLS_PAYLOAD_MAX_LEN 16384
#define SOL_TLS 282

FIXTURE(tls)
{
	int fd, cfd;
	bool notls;
};

FIXTURE_SETUP(tls)
{
	struct tls12_crypto_info_aes_gcm_128 tls12;
	struct sockaddr_in addr;
	socklen_t len;
	int sfd, ret;

	self->notls = false;
	len = sizeof(addr);

	memset(&tls12, 0, sizeof(tls12));
	tls12.info.version = TLS_1_2_VERSION;
	tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;

	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	addr.sin_port = 0;

	self->fd = socket(AF_INET, SOCK_STREAM, 0);
	sfd = socket(AF_INET, SOCK_STREAM, 0);

	ret = bind(sfd, &addr, sizeof(addr));
	ASSERT_EQ(ret, 0);
	ret = listen(sfd, 10);
	ASSERT_EQ(ret, 0);

	ret = getsockname(sfd, &addr, &len);
	ASSERT_EQ(ret, 0);

	ret = connect(self->fd, &addr, sizeof(addr));
	ASSERT_EQ(ret, 0);

	ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	if (ret != 0) {
		self->notls = true;
		printf("Failure setting TCP_ULP, testing without tls\n");
	}

	if (!self->notls) {
		ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12,
				 sizeof(tls12));
		ASSERT_EQ(ret, 0);
	}

	self->cfd = accept(sfd, &addr, &len);
	ASSERT_GE(self->cfd, 0);

	if (!self->notls) {
		ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls",
				 sizeof("tls"));
		ASSERT_EQ(ret, 0);

		ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12,
				 sizeof(tls12));
		ASSERT_EQ(ret, 0);
	}

	close(sfd);
}

FIXTURE_TEARDOWN(tls)
{
	close(self->fd);
	close(self->cfd);
}

TEST_F(tls, sendfile)
{
	int filefd = open("/proc/self/exe", O_RDONLY);
	struct stat st;

	EXPECT_GE(filefd, 0);
	fstat(filefd, &st);
	EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
}

TEST_F(tls, send_then_sendfile)
{
	int filefd = open("/proc/self/exe", O_RDONLY);
	char const *test_str = "test_send";
	int to_send = strlen(test_str) + 1;
	char recv_buf[10];
	struct stat st;
	char *buf;

	EXPECT_GE(filefd, 0);
	fstat(filefd, &st);
	buf = (char *)malloc(st.st_size);

	EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
	EXPECT_EQ(recv(self->cfd, recv_buf, to_send, 0), to_send);
	EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);

	EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
	EXPECT_EQ(recv(self->cfd, buf, st.st_size, 0), st.st_size);
}

TEST_F(tls, recv_max)
{
	unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
	char recv_mem[TLS_PAYLOAD_MAX_LEN];
	char buf[TLS_PAYLOAD_MAX_LEN];

	EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
	EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
	EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
}

TEST_F(tls, recv_small)
{
	char const *test_str = "test_read";
	int send_len = 10;
	char buf[10];

	send_len = strlen(test_str) + 1;
	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
}

TEST_F(tls, msg_more)
{
	char const *test_str = "test_read";
	int send_len = 10;
	char buf[10 * 2];

	EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
	EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_DONTWAIT),
		  send_len * 2);
	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
}

TEST_F(tls, sendmsg_single)
{
	struct msghdr msg;

	char const *test_str = "test_sendmsg";
	size_t send_len = 13;
	struct iovec vec;
	char buf[13];

	vec.iov_base = (char *)test_str;
	vec.iov_len = send_len;
	memset(&msg, 0, sizeof(struct msghdr));
	msg.msg_iov = &vec;
	msg.msg_iovlen = 1;
	EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
}

TEST_F(tls, sendmsg_large)
{
	void *mem = malloc(16384);
	size_t send_len = 16384;
	size_t sends = 128;
	struct msghdr msg;
	size_t recvs = 0;
	size_t sent = 0;

	memset(&msg, 0, sizeof(struct msghdr));
	while (sent++ < sends) {
		struct iovec vec = { (void *)mem, send_len };

		msg.msg_iov = &vec;
		msg.msg_iovlen = 1;
		EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
	}

	while (recvs++ < sends)
		EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);

	free(mem);
}

TEST_F(tls, sendmsg_multiple)
{
	char const *test_str = "test_sendmsg_multiple";
	struct iovec vec[5];
	char *test_strs[5];
	struct msghdr msg;
	int total_len = 0;
	int len_cmp = 0;
	int iov_len = 5;
	char *buf;
	int i;

	memset(&msg, 0, sizeof(struct msghdr));
	for (i = 0; i < iov_len; i++) {
		test_strs[i] = (char *)malloc(strlen(test_str) + 1);
		snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
		vec[i].iov_base = (void *)test_strs[i];
		vec[i].iov_len = strlen(test_strs[i]) + 1;
		total_len += vec[i].iov_len;
	}
	msg.msg_iov = vec;
	msg.msg_iovlen = iov_len;

	EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
	buf = malloc(total_len);
	EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
	for (i = 0; i < iov_len; i++) {
		EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
				 strlen(test_strs[i])),
			  0);
		len_cmp += strlen(buf + len_cmp) + 1;
	}
	for (i = 0; i < iov_len; i++)
		free(test_strs[i]);
	free(buf);
}

TEST_F(tls, sendmsg_multiple_stress)
{
	char const *test_str = "abcdefghijklmno";
	struct iovec vec[1024];
	char *test_strs[1024];
	int iov_len = 1024;
	int total_len = 0;
	char buf[1 << 14];
	struct msghdr msg;
	int len_cmp = 0;
	int i;

	memset(&msg, 0, sizeof(struct msghdr));
	for (i = 0; i < iov_len; i++) {
		test_strs[i] = (char *)malloc(strlen(test_str) + 1);
		snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
		vec[i].iov_base = (void *)test_strs[i];
		vec[i].iov_len = strlen(test_strs[i]) + 1;
		total_len += vec[i].iov_len;
	}
	msg.msg_iov = vec;
	msg.msg_iovlen = iov_len;

	EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
	EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);

	for (i = 0; i < iov_len; i++)
		len_cmp += strlen(buf + len_cmp) + 1;

	for (i = 0; i < iov_len; i++)
		free(test_strs[i]);
}

TEST_F(tls, splice_from_pipe)
{
	int send_len = TLS_PAYLOAD_MAX_LEN;
	char mem_send[TLS_PAYLOAD_MAX_LEN];
	char mem_recv[TLS_PAYLOAD_MAX_LEN];
	int p[2];

	ASSERT_GE(pipe(p), 0);
	EXPECT_GE(write(p[1], mem_send, send_len), 0);
	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
}

TEST_F(tls, splice_from_pipe2)
{
	int send_len = 16000;
	char mem_send[16000];
	char mem_recv[16000];
	int p2[2];
	int p[2];

	ASSERT_GE(pipe(p), 0);
	ASSERT_GE(pipe(p2), 0);
	EXPECT_GE(write(p[1], mem_send, 8000), 0);
	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
	EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
	EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
}

TEST_F(tls, send_and_splice)
{
	int send_len = TLS_PAYLOAD_MAX_LEN;
	char mem_send[TLS_PAYLOAD_MAX_LEN];
	char mem_recv[TLS_PAYLOAD_MAX_LEN];
	char const *test_str = "test_read";
	int send_len2 = 10;
	char buf[10];
	int p[2];

	ASSERT_GE(pipe(p), 0);
	EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
	EXPECT_NE(recv(self->cfd, buf, send_len2, 0), -1);
	EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);

	EXPECT_GE(write(p[1], mem_send, send_len), send_len);
	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);

	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
}

TEST_F(tls, splice_to_pipe)
{
	int send_len = TLS_PAYLOAD_MAX_LEN;
	char mem_send[TLS_PAYLOAD_MAX_LEN];
	char mem_recv[TLS_PAYLOAD_MAX_LEN];
	int p[2];

	ASSERT_GE(pipe(p), 0);
	EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
	EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
	EXPECT_GE(read(p[0], mem_recv, send_len), 0);
	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
}

TEST_F(tls, recvmsg_single)
{
	char const *test_str = "test_recvmsg_single";
	int send_len = strlen(test_str) + 1;
	char buf[20];
	struct msghdr hdr;
	struct iovec vec;

	memset(&hdr, 0, sizeof(hdr));
	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	vec.iov_base = (char *)buf;
	vec.iov_len = send_len;
	hdr.msg_iovlen = 1;
	hdr.msg_iov = &vec;
	EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
}

TEST_F(tls, recvmsg_single_max)
{
	int send_len = TLS_PAYLOAD_MAX_LEN;
	char send_mem[TLS_PAYLOAD_MAX_LEN];
	char recv_mem[TLS_PAYLOAD_MAX_LEN];
	struct iovec vec;
	struct msghdr hdr;

	EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
	vec.iov_base = (char *)recv_mem;
	vec.iov_len = TLS_PAYLOAD_MAX_LEN;

	hdr.msg_iovlen = 1;
	hdr.msg_iov = &vec;
	EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
	EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
}

TEST_F(tls, recvmsg_multiple)
{
	unsigned int msg_iovlen = 1024;
	unsigned int len_compared = 0;
	struct iovec vec[1024];
	char *iov_base[1024];
	unsigned int iov_len = 16;
	int send_len = 1 << 14;
	char buf[1 << 14];
	struct msghdr hdr;
	int i;

	EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
	for (i = 0; i < msg_iovlen; i++) {
		iov_base[i] = (char *)malloc(iov_len);
		vec[i].iov_base = iov_base[i];
		vec[i].iov_len = iov_len;
	}

	hdr.msg_iovlen = msg_iovlen;
	hdr.msg_iov = vec;
	EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
	for (i = 0; i < msg_iovlen; i++)
		len_compared += iov_len;

	for (i = 0; i < msg_iovlen; i++)
		free(iov_base[i]);
}

TEST_F(tls, single_send_multiple_recv)
{
	unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
	unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
	char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
	char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];

	EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
	memset(recv_mem, 0, total_len);

	EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
	EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
	EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
}

TEST_F(tls, multiple_send_single_recv)
{
	unsigned int total_len = 2 * 10;
	unsigned int send_len = 10;
	char recv_mem[2 * 10];
	char send_mem[10];

	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
	memset(recv_mem, 0, total_len);
	EXPECT_EQ(recv(self->cfd, recv_mem, total_len, 0), total_len);

	EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
	EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
}

TEST_F(tls, recv_partial)
{
	char const *test_str = "test_read_partial";
	char const *test_str_first = "test_read";
	char const *test_str_second = "_partial";
	int send_len = strlen(test_str) + 1;
	char recv_mem[18];

	memset(recv_mem, 0, sizeof(recv_mem));
	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first), 0), -1);
	EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
	memset(recv_mem, 0, sizeof(recv_mem));
	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
	EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
		  0);
}

TEST_F(tls, recv_nonblock)
{
	char buf[4096];
	bool err;

	EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
	err = (errno == EAGAIN || errno == EWOULDBLOCK);
	EXPECT_EQ(err, true);
}

TEST_F(tls, recv_peek)
{
	char const *test_str = "test_read_peek";
	int send_len = strlen(test_str) + 1;
	char buf[15];

	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
	memset(buf, 0, sizeof(buf));
	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
}

TEST_F(tls, recv_peek_multiple)
{
	char const *test_str = "test_read_peek";
	int send_len = strlen(test_str) + 1;
	unsigned int num_peeks = 100;
	char buf[15];
	int i;

	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	for (i = 0; i < num_peeks; i++) {
		EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
		EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
		memset(buf, 0, sizeof(buf));
	}
	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
}

TEST_F(tls, pollin)
{
	char const *test_str = "test_poll";
	struct pollfd fd = { 0, 0, 0 };
	char buf[10];
	int send_len = 10;

	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	fd.fd = self->cfd;
	fd.events = POLLIN;

	EXPECT_EQ(poll(&fd, 1, 20), 1);
	EXPECT_EQ(fd.revents & POLLIN, 1);
	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
	/* Test timing out */
	EXPECT_EQ(poll(&fd, 1, 20), 0);
}

TEST_F(tls, poll_wait)
{
	char const *test_str = "test_poll_wait";
	int send_len = strlen(test_str) + 1;
	struct pollfd fd = { 0, 0, 0 };
	char recv_mem[15];

	fd.fd = self->cfd;
	fd.events = POLLIN;
	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	/* Set timeout to inf. secs */
	EXPECT_EQ(poll(&fd, 1, -1), 1);
	EXPECT_EQ(fd.revents & POLLIN, 1);
	EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len);
}

TEST_F(tls, blocking)
{
	size_t data = 100000;
	int res = fork();

	EXPECT_NE(res, -1);

	if (res) {
		/* parent */
		size_t left = data;
		char buf[16384];
		int status;
		int pid2;

		while (left) {
			int res = send(self->fd, buf,
				       left > 16384 ? 16384 : left, 0);

			EXPECT_GE(res, 0);
			left -= res;
		}

		pid2 = wait(&status);
		EXPECT_EQ(status, 0);
		EXPECT_EQ(res, pid2);
	} else {
		/* child */
		size_t left = data;
		char buf[16384];

		while (left) {
			int res = recv(self->cfd, buf,
				       left > 16384 ? 16384 : left, 0);

			EXPECT_GE(res, 0);
			left -= res;
		}
	}
}

TEST_F(tls, nonblocking)
{
	size_t data = 100000;
	int sendbuf = 100;
	int flags;
	int res;

	flags = fcntl(self->fd, F_GETFL, 0);
	fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
	fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);

	/* Ensure nonblocking behavior by imposing a small send
	 * buffer.
	 */
	EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
			     &sendbuf, sizeof(sendbuf)), 0);

	res = fork();
	EXPECT_NE(res, -1);

	if (res) {
		/* parent */
		bool eagain = false;
		size_t left = data;
		char buf[16384];
		int status;
		int pid2;

		while (left) {
			int res = send(self->fd, buf,
				       left > 16384 ? 16384 : left, 0);

			if (res == -1 && errno == EAGAIN) {
				eagain = true;
				usleep(10000);
				continue;
			}
			EXPECT_GE(res, 0);
			left -= res;
		}

		EXPECT_TRUE(eagain);
		pid2 = wait(&status);

		EXPECT_EQ(status, 0);
		EXPECT_EQ(res, pid2);
	} else {
		/* child */
		bool eagain = false;
		size_t left = data;
		char buf[16384];

		while (left) {
			int res = recv(self->cfd, buf,
				       left > 16384 ? 16384 : left, 0);

			if (res == -1 && errno == EAGAIN) {
				eagain = true;
				usleep(10000);
				continue;
			}
			EXPECT_GE(res, 0);
			left -= res;
		}
		EXPECT_TRUE(eagain);
	}
}

TEST_F(tls, control_msg)
{
	if (self->notls)
		return;

	char cbuf[CMSG_SPACE(sizeof(char))];
	char const *test_str = "test_read";
	int cmsg_len = sizeof(char);
	char record_type = 100;
	struct cmsghdr *cmsg;
	struct msghdr msg;
	int send_len = 10;
	struct iovec vec;
	char buf[10];

	vec.iov_base = (char *)test_str;
	vec.iov_len = 10;
	memset(&msg, 0, sizeof(struct msghdr));
	msg.msg_iov = &vec;
	msg.msg_iovlen = 1;
	msg.msg_control = cbuf;
	msg.msg_controllen = sizeof(cbuf);
	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_TLS;
	/* test sending non-record types. */
	cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
	cmsg->cmsg_len = CMSG_LEN(cmsg_len);
	*CMSG_DATA(cmsg) = record_type;
	msg.msg_controllen = cmsg->cmsg_len;

	EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
	/* Should fail because we didn't provide a control message */
	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);

	vec.iov_base = buf;
	EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len);
	cmsg = CMSG_FIRSTHDR(&msg);
	EXPECT_NE(cmsg, NULL);
	EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
	EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
	record_type = *((unsigned char *)CMSG_DATA(cmsg));
	EXPECT_EQ(record_type, 100);
	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
}

TEST_HARNESS_MAIN
Commit	Line	Data
7f657d5b DW	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#define _GNU_SOURCE
	4
	5	#include <arpa/inet.h>
	6	#include <errno.h>
	7	#include <error.h>
	8	#include <fcntl.h>
	9	#include <poll.h>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <unistd.h>
	13
	14	#include <linux/tls.h>
	15	#include <linux/tcp.h>
	16	#include <linux/socket.h>
	17
	18	#include <sys/types.h>
	19	#include <sys/sendfile.h>
	20	#include <sys/socket.h>
	21	#include <sys/stat.h>
	22
	23	#include "../kselftest_harness.h"
	24
	25	#define TLS_PAYLOAD_MAX_LEN 16384
	26	#define SOL_TLS 282
	27
	28	FIXTURE(tls)
	29	{
	30	int fd, cfd;
	31	bool notls;
	32	};
	33
	34	FIXTURE_SETUP(tls)
	35	{
	36	struct tls12_crypto_info_aes_gcm_128 tls12;
	37	struct sockaddr_in addr;
	38	socklen_t len;
	39	int sfd, ret;
	40
	41	self->notls = false;
	42	len = sizeof(addr);
	43
	44	memset(&tls12, 0, sizeof(tls12));
	45	tls12.info.version = TLS_1_2_VERSION;
	46	tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
	47
	48	addr.sin_family = AF_INET;
	49	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	50	addr.sin_port = 0;
	51
	52	self->fd = socket(AF_INET, SOCK_STREAM, 0);
	53	sfd = socket(AF_INET, SOCK_STREAM, 0);
	54
	55	ret = bind(sfd, &addr, sizeof(addr));
	56	ASSERT_EQ(ret, 0);
	57	ret = listen(sfd, 10);
	58	ASSERT_EQ(ret, 0);
	59
	60	ret = getsockname(sfd, &addr, &len);
	61	ASSERT_EQ(ret, 0);
	62
	63	ret = connect(self->fd, &addr, sizeof(addr));
	64	ASSERT_EQ(ret, 0);
65
66	ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
67	if (ret != 0) {
68	self->notls = true;
69	printf("Failure setting TCP_ULP, testing without tls\n");
70	}
71
72	if (!self->notls) {
73	ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12,
74	sizeof(tls12));
75	ASSERT_EQ(ret, 0);
76	}
77
78	self->cfd = accept(sfd, &addr, &len);
79	ASSERT_GE(self->cfd, 0);
80
81	if (!self->notls) {
82	ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls",
83	sizeof("tls"));
84	ASSERT_EQ(ret, 0);
85
86	ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12,
87	sizeof(tls12));
88	ASSERT_EQ(ret, 0);
89	}
90
91	close(sfd);
92	}
93
94	FIXTURE_TEARDOWN(tls)
95	{
96	close(self->fd);
97	close(self->cfd);
98	}
99
100	TEST_F(tls, sendfile)
101	{
102	int filefd = open("/proc/self/exe", O_RDONLY);
103	struct stat st;
104
105	EXPECT_GE(filefd, 0);
106	fstat(filefd, &st);
107	EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
108	}
109
110	TEST_F(tls, send_then_sendfile)
111	{
112	int filefd = open("/proc/self/exe", O_RDONLY);
113	char const *test_str = "test_send";
114	int to_send = strlen(test_str) + 1;
115	char recv_buf[10];
116	struct stat st;
117	char *buf;
118
119	EXPECT_GE(filefd, 0);
120	fstat(filefd, &st);
121	buf = (char *)malloc(st.st_size);
122
123	EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
124	EXPECT_EQ(recv(self->cfd, recv_buf, to_send, 0), to_send);
125	EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
126
127	EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
128	EXPECT_EQ(recv(self->cfd, buf, st.st_size, 0), st.st_size);
129	}
130
131	TEST_F(tls, recv_max)
132	{
133	unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
134	char recv_mem[TLS_PAYLOAD_MAX_LEN];
135	char buf[TLS_PAYLOAD_MAX_LEN];
136
137	EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
138	EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
139	EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
140	}
141
142	TEST_F(tls, recv_small)
143	{
144	char const *test_str = "test_read";
145	int send_len = 10;
146	char buf[10];
147
148	send_len = strlen(test_str) + 1;
149	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
150	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
151	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
152	}
153
154	TEST_F(tls, msg_more)
155	{
156	char const *test_str = "test_read";
157	int send_len = 10;
158	char buf[10 * 2];
159
160	EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
161	EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
162	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
163	EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_DONTWAIT),
164	send_len * 2);
165	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
166	}
167
168	TEST_F(tls, sendmsg_single)
169	{
170	struct msghdr msg;
171
172	char const *test_str = "test_sendmsg";
173	size_t send_len = 13;
174	struct iovec vec;
175	char buf[13];
176
177	vec.iov_base = (char *)test_str;
178	vec.iov_len = send_len;
179	memset(&msg, 0, sizeof(struct msghdr));
180	msg.msg_iov = &vec;
181	msg.msg_iovlen = 1;
182	EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
183	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
184	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
185	}
186
187	TEST_F(tls, sendmsg_large)
188	{
189	void *mem = malloc(16384);
190	size_t send_len = 16384;
191	size_t sends = 128;
192	struct msghdr msg;
193	size_t recvs = 0;
194	size_t sent = 0;
195
196	memset(&msg, 0, sizeof(struct msghdr));
197	while (sent++ < sends) {
198	struct iovec vec = { (void *)mem, send_len };
199
200	msg.msg_iov = &vec;
201	msg.msg_iovlen = 1;
202	EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
203	}
204
205	while (recvs++ < sends)
206	EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
207
208	free(mem);
209	}
210
211	TEST_F(tls, sendmsg_multiple)
212	{
213	char const *test_str = "test_sendmsg_multiple";
214	struct iovec vec[5];
215	char *test_strs[5];
216	struct msghdr msg;
217	int total_len = 0;
218	int len_cmp = 0;
219	int iov_len = 5;
220	char *buf;
221	int i;
222
223	memset(&msg, 0, sizeof(struct msghdr));
224	for (i = 0; i < iov_len; i++) {
225	test_strs[i] = (char *)malloc(strlen(test_str) + 1);
226	snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
227	vec[i].iov_base = (void *)test_strs[i];
228	vec[i].iov_len = strlen(test_strs[i]) + 1;
229	total_len += vec[i].iov_len;
230	}
231	msg.msg_iov = vec;
232	msg.msg_iovlen = iov_len;
233
234	EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
235	buf = malloc(total_len);
236	EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
237	for (i = 0; i < iov_len; i++) {
238	EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
239	strlen(test_strs[i])),
240	0);
241	len_cmp += strlen(buf + len_cmp) + 1;
242	}
243	for (i = 0; i < iov_len; i++)
244	free(test_strs[i]);
245	free(buf);
246	}
247
248	TEST_F(tls, sendmsg_multiple_stress)
249	{
250	char const *test_str = "abcdefghijklmno";
251	struct iovec vec[1024];
252	char *test_strs[1024];
253	int iov_len = 1024;
254	int total_len = 0;
255	char buf[1 << 14];
256	struct msghdr msg;
257	int len_cmp = 0;
258	int i;
259
260	memset(&msg, 0, sizeof(struct msghdr));
261	for (i = 0; i < iov_len; i++) {
262	test_strs[i] = (char *)malloc(strlen(test_str) + 1);
263	snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
264	vec[i].iov_base = (void *)test_strs[i];
265	vec[i].iov_len = strlen(test_strs[i]) + 1;
266	total_len += vec[i].iov_len;
267	}
268	msg.msg_iov = vec;
269	msg.msg_iovlen = iov_len;
270
271	EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
272	EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
273
274	for (i = 0; i < iov_len; i++)
275	len_cmp += strlen(buf + len_cmp) + 1;
276
277	for (i = 0; i < iov_len; i++)
278	free(test_strs[i]);
279	}
280
281	TEST_F(tls, splice_from_pipe)
282	{
283	int send_len = TLS_PAYLOAD_MAX_LEN;
284	char mem_send[TLS_PAYLOAD_MAX_LEN];
285	char mem_recv[TLS_PAYLOAD_MAX_LEN];
286	int p[2];
287
288	ASSERT_GE(pipe(p), 0);
289	EXPECT_GE(write(p[1], mem_send, send_len), 0);
290	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
291	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
292	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
293	}
294
295	TEST_F(tls, splice_from_pipe2)
296	{
297	int send_len = 16000;
298	char mem_send[16000];
299	char mem_recv[16000];
300	int p2[2];
301	int p[2];
302
303	ASSERT_GE(pipe(p), 0);
304	ASSERT_GE(pipe(p2), 0);
305	EXPECT_GE(write(p[1], mem_send, 8000), 0);
306	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
307	EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
308	EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
309	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
310	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
311	}
312
313	TEST_F(tls, send_and_splice)
314	{
315	int send_len = TLS_PAYLOAD_MAX_LEN;
316	char mem_send[TLS_PAYLOAD_MAX_LEN];
317	char mem_recv[TLS_PAYLOAD_MAX_LEN];
318	char const *test_str = "test_read";
319	int send_len2 = 10;
320	char buf[10];
321	int p[2];
322
323	ASSERT_GE(pipe(p), 0);
324	EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
325	EXPECT_NE(recv(self->cfd, buf, send_len2, 0), -1);
326	EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
327
328	EXPECT_GE(write(p[1], mem_send, send_len), send_len);
329	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
330
331	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
332	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
333	}
334
335	TEST_F(tls, splice_to_pipe)
336	{
337	int send_len = TLS_PAYLOAD_MAX_LEN;
338	char mem_send[TLS_PAYLOAD_MAX_LEN];
339	char mem_recv[TLS_PAYLOAD_MAX_LEN];
340	int p[2];
341
342	ASSERT_GE(pipe(p), 0);
343	EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
344	EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
345	EXPECT_GE(read(p[0], mem_recv, send_len), 0);
346	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
347	}
348
349	TEST_F(tls, recvmsg_single)
350	{
351	char const *test_str = "test_recvmsg_single";
352	int send_len = strlen(test_str) + 1;
353	char buf[20];
354	struct msghdr hdr;
355	struct iovec vec;
356
357	memset(&hdr, 0, sizeof(hdr));
358	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
359	vec.iov_base = (char *)buf;
360	vec.iov_len = send_len;
361	hdr.msg_iovlen = 1;
362	hdr.msg_iov = &vec;
363	EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
364	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
365	}
366
367	TEST_F(tls, recvmsg_single_max)
368	{
369	int send_len = TLS_PAYLOAD_MAX_LEN;
370	char send_mem[TLS_PAYLOAD_MAX_LEN];
371	char recv_mem[TLS_PAYLOAD_MAX_LEN];
372	struct iovec vec;
373	struct msghdr hdr;
374
375	EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
376	vec.iov_base = (char *)recv_mem;
377	vec.iov_len = TLS_PAYLOAD_MAX_LEN;
378
379	hdr.msg_iovlen = 1;
380	hdr.msg_iov = &vec;
381	EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
382	EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
383	}
384
385	TEST_F(tls, recvmsg_multiple)
386	{
387	unsigned int msg_iovlen = 1024;
388	unsigned int len_compared = 0;
389	struct iovec vec[1024];
390	char *iov_base[1024];
391	unsigned int iov_len = 16;
392	int send_len = 1 << 14;
393	char buf[1 << 14];
394	struct msghdr hdr;
395	int i;
396
397	EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
398	for (i = 0; i < msg_iovlen; i++) {
399	iov_base[i] = (char *)malloc(iov_len);
400	vec[i].iov_base = iov_base[i];
401	vec[i].iov_len = iov_len;
402	}
403
404	hdr.msg_iovlen = msg_iovlen;
405	hdr.msg_iov = vec;
406	EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
407	for (i = 0; i < msg_iovlen; i++)
408	len_compared += iov_len;
409
410	for (i = 0; i < msg_iovlen; i++)
411	free(iov_base[i]);
412	}
413
414	TEST_F(tls, single_send_multiple_recv)
415	{
416	unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
417	unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
418	char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
419	char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
420
421	EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
422	memset(recv_mem, 0, total_len);
423
424	EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
425	EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
426	EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
427	}
428
429	TEST_F(tls, multiple_send_single_recv)
430	{
431	unsigned int total_len = 2 * 10;
432	unsigned int send_len = 10;
433	char recv_mem[2 * 10];
434	char send_mem[10];
435
436	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
437	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
438	memset(recv_mem, 0, total_len);
439	EXPECT_EQ(recv(self->cfd, recv_mem, total_len, 0), total_len);
440
441	EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
442	EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
443	}
444
445	TEST_F(tls, recv_partial)
446	{
447	char const *test_str = "test_read_partial";
448	char const *test_str_first = "test_read";
449	char const *test_str_second = "_partial";
450	int send_len = strlen(test_str) + 1;
451	char recv_mem[18];
452
453	memset(recv_mem, 0, sizeof(recv_mem));
454	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
455	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first), 0), -1);
456	EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
457	memset(recv_mem, 0, sizeof(recv_mem));
458	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
459	EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
460	0);
461	}
462
463	TEST_F(tls, recv_nonblock)
464	{
465	char buf[4096];
466	bool err;
467
468	EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
469	err = (errno == EAGAIN \|\| errno == EWOULDBLOCK);
470	EXPECT_EQ(err, true);
471	}
472
473	TEST_F(tls, recv_peek)
474	{
475	char const *test_str = "test_read_peek";
476	int send_len = strlen(test_str) + 1;
477	char buf[15];
478
479	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
480	EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
481	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
482	memset(buf, 0, sizeof(buf));
483	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
484	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
485	}
486
487	TEST_F(tls, recv_peek_multiple)
488	{
489	char const *test_str = "test_read_peek";
490	int send_len = strlen(test_str) + 1;
491	unsigned int num_peeks = 100;
492	char buf[15];
493	int i;
494
495	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
496	for (i = 0; i < num_peeks; i++) {
497	EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
498	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
499	memset(buf, 0, sizeof(buf));
500	}
501	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
502	EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
503	}
504
505	TEST_F(tls, pollin)
506	{
507	char const *test_str = "test_poll";
508	struct pollfd fd = { 0, 0, 0 };
509	char buf[10];
510	int send_len = 10;
511
512	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
513	fd.fd = self->cfd;
514	fd.events = POLLIN;
515
516	EXPECT_EQ(poll(&fd, 1, 20), 1);
517	EXPECT_EQ(fd.revents & POLLIN, 1);
518	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
519	/* Test timing out */
520	EXPECT_EQ(poll(&fd, 1, 20), 0);
521	}
522
523	TEST_F(tls, poll_wait)
524	{
525	char const *test_str = "test_poll_wait";
526	int send_len = strlen(test_str) + 1;
527	struct pollfd fd = { 0, 0, 0 };
528	char recv_mem[15];
529
530	fd.fd = self->cfd;
531	fd.events = POLLIN;
532	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
533	/* Set timeout to inf. secs */
534	EXPECT_EQ(poll(&fd, 1, -1), 1);
535	EXPECT_EQ(fd.revents & POLLIN, 1);
536	EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len);
537	}
538
539	TEST_F(tls, blocking)
540	{
541	size_t data = 100000;
542	int res = fork();
543
544	EXPECT_NE(res, -1);
545
546	if (res) {
547	/* parent */
548	size_t left = data;
549	char buf[16384];
550	int status;
551	int pid2;
552
553	while (left) {
554	int res = send(self->fd, buf,
555	left > 16384 ? 16384 : left, 0);
556
557	EXPECT_GE(res, 0);
558	left -= res;
559	}
560
561	pid2 = wait(&status);
562	EXPECT_EQ(status, 0);
563	EXPECT_EQ(res, pid2);
564	} else {
565	/* child */
566	size_t left = data;
567	char buf[16384];
568
569	while (left) {
570	int res = recv(self->cfd, buf,
571	left > 16384 ? 16384 : left, 0);
572
573	EXPECT_GE(res, 0);
574	left -= res;
575	}
576	}
577	}
578
579	TEST_F(tls, nonblocking)
580	{
581	size_t data = 100000;
582	int sendbuf = 100;
583	int flags;
584	int res;
585
586	flags = fcntl(self->fd, F_GETFL, 0);
587	fcntl(self->fd, F_SETFL, flags \| O_NONBLOCK);
588	fcntl(self->cfd, F_SETFL, flags \| O_NONBLOCK);
589
590	/* Ensure nonblocking behavior by imposing a small send
591	* buffer.
592	*/
593	EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
594	&sendbuf, sizeof(sendbuf)), 0);
595
596	res = fork();
597	EXPECT_NE(res, -1);
598
599	if (res) {
600	/* parent */
601	bool eagain = false;
602	size_t left = data;
603	char buf[16384];
604	int status;
605	int pid2;
606
607	while (left) {
608	int res = send(self->fd, buf,
609	left > 16384 ? 16384 : left, 0);
610
611	if (res == -1 && errno == EAGAIN) {
612	eagain = true;
613	usleep(10000);
614	continue;
615	}
616	EXPECT_GE(res, 0);
617	left -= res;
618	}
619
620	EXPECT_TRUE(eagain);
621	pid2 = wait(&status);
622
623	EXPECT_EQ(status, 0);
624	EXPECT_EQ(res, pid2);
625	} else {
626	/* child */
627	bool eagain = false;
628	size_t left = data;
629	char buf[16384];
630
631	while (left) {
632	int res = recv(self->cfd, buf,
633	left > 16384 ? 16384 : left, 0);
634
635	if (res == -1 && errno == EAGAIN) {
636	eagain = true;
637	usleep(10000);
638	continue;
639	}
640	EXPECT_GE(res, 0);
641	left -= res;
642	}
643	EXPECT_TRUE(eagain);
644	}
645	}
646
647	TEST_F(tls, control_msg)
648	{
649	if (self->notls)
650	return;
651
652	char cbuf[CMSG_SPACE(sizeof(char))];
653	char const *test_str = "test_read";
654	int cmsg_len = sizeof(char);
655	char record_type = 100;
656	struct cmsghdr *cmsg;
657	struct msghdr msg;
658	int send_len = 10;
659	struct iovec vec;
660	char buf[10];
661
662	vec.iov_base = (char *)test_str;
663	vec.iov_len = 10;
664	memset(&msg, 0, sizeof(struct msghdr));
665	msg.msg_iov = &vec;
666	msg.msg_iovlen = 1;
667	msg.msg_control = cbuf;
668	msg.msg_controllen = sizeof(cbuf);
669	cmsg = CMSG_FIRSTHDR(&msg);
670	cmsg->cmsg_level = SOL_TLS;
671	/* test sending non-record types. */
672	cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
673	cmsg->cmsg_len = CMSG_LEN(cmsg_len);
674	*CMSG_DATA(cmsg) = record_type;
675	msg.msg_controllen = cmsg->cmsg_len;
676
677	EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
678	/* Should fail because we didn't provide a control message */
679	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
680
681	vec.iov_base = buf;
682	EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len);
683	cmsg = CMSG_FIRSTHDR(&msg);
684	EXPECT_NE(cmsg, NULL);
685	EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
686	EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
687	record_type = ((unsigned char )CMSG_DATA(cmsg));
688	EXPECT_EQ(record_type, 100);
689	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
690	}
691
692	TEST_HARNESS_MAIN