~hc/RK356X_SDK_RELEASE.git

..	..	@@ -25,10 +25,95 @@
25	25	#define TLS_PAYLOAD_MAX_LEN 16384
26	26	#define SOL_TLS 282
27	27
	28	+FIXTURE(tls_basic)
	29	+{
	30	+ int fd, cfd;
	31	+ bool notls;
	32	+};
	33	+
	34	+FIXTURE_SETUP(tls_basic)
	35	+{
	36	+ struct sockaddr_in addr;
	37	+ socklen_t len;
	38	+ int sfd, ret;
	39	+
	40	+ self->notls = false;
	41	+ len = sizeof(addr);
	42	+
	43	+ addr.sin_family = AF_INET;
	44	+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
	45	+ addr.sin_port = 0;
	46	+
	47	+ self->fd = socket(AF_INET, SOCK_STREAM, 0);
	48	+ sfd = socket(AF_INET, SOCK_STREAM, 0);
	49	+
	50	+ ret = bind(sfd, &addr, sizeof(addr));
	51	+ ASSERT_EQ(ret, 0);
	52	+ ret = listen(sfd, 10);
	53	+ ASSERT_EQ(ret, 0);
	54	+
	55	+ ret = getsockname(sfd, &addr, &len);
	56	+ ASSERT_EQ(ret, 0);
	57	+
	58	+ ret = connect(self->fd, &addr, sizeof(addr));
	59	+ ASSERT_EQ(ret, 0);
	60	+
	61	+ self->cfd = accept(sfd, &addr, &len);
	62	+ ASSERT_GE(self->cfd, 0);
	63	+
	64	+ close(sfd);
	65	+
	66	+ ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	67	+ if (ret != 0) {
	68	+ ASSERT_EQ(errno, ENOENT);
	69	+ self->notls = true;
	70	+ printf("Failure setting TCP_ULP, testing without tls\n");
	71	+ return;
	72	+ }
	73	+
	74	+ ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	75	+ ASSERT_EQ(ret, 0);
	76	+}
	77	+
	78	+FIXTURE_TEARDOWN(tls_basic)
	79	+{
	80	+ close(self->fd);
	81	+ close(self->cfd);
	82	+}
	83	+
	84	+/* Send some data through with ULP but no keys */
	85	+TEST_F(tls_basic, base_base)
	86	+{
	87	+ char const *test_str = "test_read";
	88	+ int send_len = 10;
	89	+ char buf[10];
	90	+
	91	+ ASSERT_EQ(strlen(test_str) + 1, send_len);
	92	+
	93	+ EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	94	+ EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
	95	+ EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	96	+};
	97	+
28	98	FIXTURE(tls)
29	99	{
30	100	int fd, cfd;
31	101	bool notls;
	102	+};
	103	+
	104	+FIXTURE_VARIANT(tls)
	105	+{
	106	+ unsigned int tls_version;
	107	+};
	108	+
	109	+FIXTURE_VARIANT_ADD(tls, 12)
	110	+{
	111	+ .tls_version = TLS_1_2_VERSION,
	112	+};
	113	+
	114	+FIXTURE_VARIANT_ADD(tls, 13)
	115	+{
	116	+ .tls_version = TLS_1_3_VERSION,
32	117	};
33	118
34	119	FIXTURE_SETUP(tls)
..	..	@@ -42,7 +127,7 @@
42	127	len = sizeof(addr);
43	128
44	129	memset(&tls12, 0, sizeof(tls12));
45		- tls12.info.version = TLS_1_2_VERSION;
	130	+ tls12.info.version = variant->tls_version;
46	131	tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
47	132
48	133	addr.sin_family = AF_INET;
..	..	@@ -121,11 +206,69 @@
121	206	buf = (char *)malloc(st.st_size);
122	207
123	208	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);
	209	+ EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send);
125	210	EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
126	211
127	212	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);
	213	+ EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size);
	214	+}
	215	+
	216	+static void chunked_sendfile(struct __test_metadata *_metadata,
	217	+ struct _test_data_tls *self,
	218	+ uint16_t chunk_size,
	219	+ uint16_t extra_payload_size)
	220	+{
	221	+ char buf[TLS_PAYLOAD_MAX_LEN];
	222	+ uint16_t test_payload_size;
	223	+ int size = 0;
	224	+ int ret;
	225	+ char filename[] = "/tmp/mytemp.XXXXXX";
	226	+ int fd = mkstemp(filename);
	227	+ off_t offset = 0;
	228	+
	229	+ unlink(filename);
	230	+ ASSERT_GE(fd, 0);
	231	+ EXPECT_GE(chunk_size, 1);
	232	+ test_payload_size = chunk_size + extra_payload_size;
	233	+ ASSERT_GE(TLS_PAYLOAD_MAX_LEN, test_payload_size);
	234	+ memset(buf, 1, test_payload_size);
	235	+ size = write(fd, buf, test_payload_size);
	236	+ EXPECT_EQ(size, test_payload_size);
	237	+ fsync(fd);
	238	+
	239	+ while (size > 0) {
	240	+ ret = sendfile(self->fd, fd, &offset, chunk_size);
	241	+ EXPECT_GE(ret, 0);
	242	+ size -= ret;
	243	+ }
	244	+
	245	+ EXPECT_EQ(recv(self->cfd, buf, test_payload_size, MSG_WAITALL),
	246	+ test_payload_size);
	247	+
	248	+ close(fd);
	249	+}
	250	+
	251	+TEST_F(tls, multi_chunk_sendfile)
	252	+{
	253	+ chunked_sendfile(_metadata, self, 4096, 4096);
	254	+ chunked_sendfile(_metadata, self, 4096, 0);
	255	+ chunked_sendfile(_metadata, self, 4096, 1);
	256	+ chunked_sendfile(_metadata, self, 4096, 2048);
	257	+ chunked_sendfile(_metadata, self, 8192, 2048);
	258	+ chunked_sendfile(_metadata, self, 4096, 8192);
	259	+ chunked_sendfile(_metadata, self, 8192, 4096);
	260	+ chunked_sendfile(_metadata, self, 12288, 1024);
	261	+ chunked_sendfile(_metadata, self, 12288, 2000);
	262	+ chunked_sendfile(_metadata, self, 15360, 100);
	263	+ chunked_sendfile(_metadata, self, 15360, 300);
	264	+ chunked_sendfile(_metadata, self, 1, 4096);
	265	+ chunked_sendfile(_metadata, self, 2048, 4096);
	266	+ chunked_sendfile(_metadata, self, 2048, 8192);
	267	+ chunked_sendfile(_metadata, self, 4096, 8192);
	268	+ chunked_sendfile(_metadata, self, 1024, 12288);
	269	+ chunked_sendfile(_metadata, self, 2000, 12288);
	270	+ chunked_sendfile(_metadata, self, 100, 15360);
	271	+ chunked_sendfile(_metadata, self, 300, 15360);
129	272	}
130	273
131	274	TEST_F(tls, recv_max)
..	..	@@ -160,9 +303,19 @@
160	303	EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
161	304	EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
162	305	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
163		- EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_DONTWAIT),
	306	+ EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL),
164	307	send_len * 2);
165	308	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	309	+}
	310	+
	311	+TEST_F(tls, msg_more_unsent)
	312	+{
	313	+ char const *test_str = "test_read";
	314	+ int send_len = 10;
	315	+ char buf[10];
	316	+
	317	+ EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
	318	+ EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
166	319	}
167	320
168	321	TEST_F(tls, sendmsg_single)
..	..	@@ -180,9 +333,41 @@
180	333	msg.msg_iov = &vec;
181	334	msg.msg_iovlen = 1;
182	335	EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
183		- EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
	336	+ EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
184	337	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
185	338	}
	339	+
	340	+#define MAX_FRAGS 64
	341	+#define SEND_LEN 13
	342	+TEST_F(tls, sendmsg_fragmented)
	343	+{
	344	+ char const *test_str = "test_sendmsg";
	345	+ char buf[SEND_LEN * MAX_FRAGS];
	346	+ struct iovec vec[MAX_FRAGS];
	347	+ struct msghdr msg;
	348	+ int i, frags;
	349	+
	350	+ for (frags = 1; frags <= MAX_FRAGS; frags++) {
	351	+ for (i = 0; i < frags; i++) {
	352	+ vec[i].iov_base = (char *)test_str;
	353	+ vec[i].iov_len = SEND_LEN;
	354	+ }
	355	+
	356	+ memset(&msg, 0, sizeof(struct msghdr));
	357	+ msg.msg_iov = vec;
	358	+ msg.msg_iovlen = frags;
	359	+
	360	+ EXPECT_EQ(sendmsg(self->fd, &msg, 0), SEND_LEN * frags);
	361	+ EXPECT_EQ(recv(self->cfd, buf, SEND_LEN * frags, MSG_WAITALL),
	362	+ SEND_LEN * frags);
	363	+
	364	+ for (i = 0; i < frags; i++)
	365	+ EXPECT_EQ(memcmp(buf + SEND_LEN * i,
	366	+ test_str, SEND_LEN), 0);
	367	+ }
	368	+}
	369	+#undef MAX_FRAGS
	370	+#undef SEND_LEN
186	371
187	372	TEST_F(tls, sendmsg_large)
188	373	{
..	..	@@ -199,11 +384,12 @@
199	384
200	385	msg.msg_iov = &vec;
201	386	msg.msg_iovlen = 1;
202		- EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
	387	+ EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
203	388	}
204	389
205		- while (recvs++ < sends)
206		- EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
	390	+ while (recvs++ < sends) {
	391	+ EXPECT_NE(recv(self->cfd, mem, send_len, 0), -1);
	392	+ }
207	393
208	394	free(mem);
209	395	}
..	..	@@ -231,9 +417,9 @@
231	417	msg.msg_iov = vec;
232	418	msg.msg_iovlen = iov_len;
233	419
234		- EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
	420	+ EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
235	421	buf = malloc(total_len);
236		- EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
	422	+ EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
237	423	for (i = 0; i < iov_len; i++) {
238	424	EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
239	425	strlen(test_strs[i])),
..	..	@@ -306,7 +492,7 @@
306	492	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
307	493	EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
308	494	EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
309		- EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
	495	+ EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
310	496	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
311	497	}
312	498
..	..	@@ -436,10 +622,25 @@
436	622	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
437	623	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
438	624	memset(recv_mem, 0, total_len);
439		- EXPECT_EQ(recv(self->cfd, recv_mem, total_len, 0), total_len);
	625	+ EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
440	626
441	627	EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
442	628	EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
	629	+}
	630	+
	631	+TEST_F(tls, single_send_multiple_recv_non_align)
	632	+{
	633	+ const unsigned int total_len = 15;
	634	+ const unsigned int recv_len = 10;
	635	+ char recv_mem[recv_len * 2];
	636	+ char send_mem[total_len];
	637	+
	638	+ EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
	639	+ memset(recv_mem, 0, total_len);
	640	+
	641	+ EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len);
	642	+ EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5);
	643	+ EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
443	644	}
444	645
445	646	TEST_F(tls, recv_partial)
..	..	@@ -452,10 +653,12 @@
452	653
453	654	memset(recv_mem, 0, sizeof(recv_mem));
454	655	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);
	656	+ EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first),
	657	+ MSG_WAITALL), -1);
456	658	EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
457	659	memset(recv_mem, 0, sizeof(recv_mem));
458		- EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
	660	+ EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second),
	661	+ MSG_WAITALL), -1);
459	662	EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
460	663	0);
461	664	}
..	..	@@ -551,6 +754,84 @@
551	754	EXPECT_EQ(memcmp(test_str, buf, len), 0);
552	755	}
553	756
	757	+TEST_F(tls, recv_peek_large_buf_mult_recs)
	758	+{
	759	+ char const *test_str = "test_read_peek_mult_recs";
	760	+ char const *test_str_first = "test_read_peek";
	761	+ char const *test_str_second = "_mult_recs";
	762	+ int len;
	763	+ char buf[64];
	764	+
	765	+ len = strlen(test_str_first);
	766	+ EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
	767	+
	768	+ len = strlen(test_str_second) + 1;
	769	+ EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
	770	+
	771	+ len = strlen(test_str) + 1;
	772	+ memset(buf, 0, len);
	773	+ EXPECT_NE((len = recv(self->cfd, buf, len,
	774	+ MSG_PEEK \| MSG_WAITALL)), -1);
	775	+ len = strlen(test_str) + 1;
	776	+ EXPECT_EQ(memcmp(test_str, buf, len), 0);
	777	+}
	778	+
	779	+TEST_F(tls, recv_lowat)
	780	+{
	781	+ char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	782	+ char recv_mem[20];
	783	+ int lowat = 8;
	784	+
	785	+ EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10);
	786	+ EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5);
	787	+
	788	+ memset(recv_mem, 0, 20);
	789	+ EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT,
	790	+ &lowat, sizeof(lowat)), 0);
	791	+ EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1);
	792	+ EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6);
	793	+ EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8);
	794	+
	795	+ EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0);
	796	+ EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0);
	797	+}
	798	+
	799	+TEST_F(tls, bidir)
	800	+{
	801	+ char const *test_str = "test_read";
	802	+ int send_len = 10;
	803	+ char buf[10];
	804	+ int ret;
	805	+
	806	+ if (!self->notls) {
	807	+ struct tls12_crypto_info_aes_gcm_128 tls12;
	808	+
	809	+ memset(&tls12, 0, sizeof(tls12));
	810	+ tls12.info.version = variant->tls_version;
	811	+ tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
	812	+
	813	+ ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12,
	814	+ sizeof(tls12));
	815	+ ASSERT_EQ(ret, 0);
	816	+
	817	+ ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12,
	818	+ sizeof(tls12));
	819	+ ASSERT_EQ(ret, 0);
	820	+ }
	821	+
	822	+ ASSERT_EQ(strlen(test_str) + 1, send_len);
	823	+
	824	+ EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	825	+ EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
	826	+ EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	827	+
	828	+ memset(buf, 0, sizeof(buf));
	829	+
	830	+ EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len);
	831	+ EXPECT_NE(recv(self->fd, buf, send_len, 0), -1);
	832	+ EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	833	+};
	834	+
554	835	TEST_F(tls, pollin)
555	836	{
556	837	char const *test_str = "test_poll";
..	..	@@ -564,7 +845,7 @@
564	845
565	846	EXPECT_EQ(poll(&fd, 1, 20), 1);
566	847	EXPECT_EQ(fd.revents & POLLIN, 1);
567		- EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
	848	+ EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
568	849	/* Test timing out */
569	850	EXPECT_EQ(poll(&fd, 1, 20), 0);
570	851	}
..	..	@@ -582,7 +863,33 @@
582	863	/* Set timeout to inf. secs */
583	864	EXPECT_EQ(poll(&fd, 1, -1), 1);
584	865	EXPECT_EQ(fd.revents & POLLIN, 1);
585		- EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len);
	866	+ EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
	867	+}
	868	+
	869	+TEST_F(tls, poll_wait_split)
	870	+{
	871	+ struct pollfd fd = { 0, 0, 0 };
	872	+ char send_mem[20] = {};
	873	+ char recv_mem[15];
	874	+
	875	+ fd.fd = self->cfd;
	876	+ fd.events = POLLIN;
	877	+ /* Send 20 bytes */
	878	+ EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0),
	879	+ sizeof(send_mem));
	880	+ /* Poll with inf. timeout */
	881	+ EXPECT_EQ(poll(&fd, 1, -1), 1);
	882	+ EXPECT_EQ(fd.revents & POLLIN, 1);
	883	+ EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL),
	884	+ sizeof(recv_mem));
	885	+
	886	+ /* Now the remaining 5 bytes of record data are in TLS ULP */
	887	+ fd.fd = self->cfd;
	888	+ fd.events = POLLIN;
	889	+ EXPECT_EQ(poll(&fd, 1, -1), 1);
	890	+ EXPECT_EQ(fd.revents & POLLIN, 1);
	891	+ EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0),
	892	+ sizeof(send_mem) - sizeof(recv_mem));
586	893	}
587	894
588	895	TEST_F(tls, blocking)
..	..	@@ -693,6 +1000,114 @@
693	1000	}
694	1001	}
695	1002
	1003	+static void
	1004	+test_mutliproc(struct __test_metadata _metadata, struct _test_data_tls self,
	1005	+ bool sendpg, unsigned int n_readers, unsigned int n_writers)
	1006	+{
	1007	+ const unsigned int n_children = n_readers + n_writers;
	1008	+ const size_t data = 6 * 1000 * 1000;
	1009	+ const size_t file_sz = data / 100;
	1010	+ size_t read_bias, write_bias;
	1011	+ int i, fd, child_id;
	1012	+ char buf[file_sz];
	1013	+ pid_t pid;
	1014	+
	1015	+ /* Only allow multiples for simplicity */
	1016	+ ASSERT_EQ(!(n_readers % n_writers) \|\| !(n_writers % n_readers), true);
	1017	+ read_bias = n_writers / n_readers ?: 1;
	1018	+ write_bias = n_readers / n_writers ?: 1;
	1019	+
	1020	+ /* prep a file to send */
	1021	+ fd = open("/tmp/", O_TMPFILE \| O_RDWR, 0600);
	1022	+ ASSERT_GE(fd, 0);
	1023	+
	1024	+ memset(buf, 0xac, file_sz);
	1025	+ ASSERT_EQ(write(fd, buf, file_sz), file_sz);
	1026	+
	1027	+ /* spawn children */
	1028	+ for (child_id = 0; child_id < n_children; child_id++) {
	1029	+ pid = fork();
	1030	+ ASSERT_NE(pid, -1);
	1031	+ if (!pid)
	1032	+ break;
	1033	+ }
	1034	+
	1035	+ /* parent waits for all children */
	1036	+ if (pid) {
	1037	+ for (i = 0; i < n_children; i++) {
	1038	+ int status;
	1039	+
	1040	+ wait(&status);
	1041	+ EXPECT_EQ(status, 0);
	1042	+ }
	1043	+
	1044	+ return;
	1045	+ }
	1046	+
	1047	+ /* Split threads for reading and writing */
	1048	+ if (child_id < n_readers) {
	1049	+ size_t left = data * read_bias;
	1050	+ char rb[8001];
	1051	+
	1052	+ while (left) {
	1053	+ int res;
	1054	+
	1055	+ res = recv(self->cfd, rb,
	1056	+ left > sizeof(rb) ? sizeof(rb) : left, 0);
	1057	+
	1058	+ EXPECT_GE(res, 0);
	1059	+ left -= res;
	1060	+ }
	1061	+ } else {
	1062	+ size_t left = data * write_bias;
	1063	+
	1064	+ while (left) {
	1065	+ int res;
	1066	+
	1067	+ ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
	1068	+ if (sendpg)
	1069	+ res = sendfile(self->fd, fd, NULL,
	1070	+ left > file_sz ? file_sz : left);
	1071	+ else
	1072	+ res = send(self->fd, buf,
	1073	+ left > file_sz ? file_sz : left, 0);
	1074	+
	1075	+ EXPECT_GE(res, 0);
	1076	+ left -= res;
	1077	+ }
	1078	+ }
	1079	+}
	1080	+
	1081	+TEST_F(tls, mutliproc_even)
	1082	+{
	1083	+ test_mutliproc(_metadata, self, false, 6, 6);
	1084	+}
	1085	+
	1086	+TEST_F(tls, mutliproc_readers)
	1087	+{
	1088	+ test_mutliproc(_metadata, self, false, 4, 12);
	1089	+}
	1090	+
	1091	+TEST_F(tls, mutliproc_writers)
	1092	+{
	1093	+ test_mutliproc(_metadata, self, false, 10, 2);
	1094	+}
	1095	+
	1096	+TEST_F(tls, mutliproc_sendpage_even)
	1097	+{
	1098	+ test_mutliproc(_metadata, self, true, 6, 6);
	1099	+}
	1100	+
	1101	+TEST_F(tls, mutliproc_sendpage_readers)
	1102	+{
	1103	+ test_mutliproc(_metadata, self, true, 4, 12);
	1104	+}
	1105	+
	1106	+TEST_F(tls, mutliproc_sendpage_writers)
	1107	+{
	1108	+ test_mutliproc(_metadata, self, true, 10, 2);
	1109	+}
	1110	+
696	1111	TEST_F(tls, control_msg)
697	1112	{
698	1113	if (self->notls)
..	..	@@ -728,7 +1143,8 @@
728	1143	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
729	1144
730	1145	vec.iov_base = buf;
731		- EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len);
	1146	+ EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL \| MSG_PEEK), send_len);
	1147	+
732	1148	cmsg = CMSG_FIRSTHDR(&msg);
733	1149	EXPECT_NE(cmsg, NULL);
734	1150	EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
..	..	@@ -736,6 +1152,184 @@
736	1152	record_type = ((unsigned char )CMSG_DATA(cmsg));
737	1153	EXPECT_EQ(record_type, 100);
738	1154	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	1155	+
	1156	+ /* Recv the message again without MSG_PEEK */
	1157	+ record_type = 0;
	1158	+ memset(buf, 0, sizeof(buf));
	1159	+
	1160	+ EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL), send_len);
	1161	+ cmsg = CMSG_FIRSTHDR(&msg);
	1162	+ EXPECT_NE(cmsg, NULL);
	1163	+ EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
	1164	+ EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
	1165	+ record_type = ((unsigned char )CMSG_DATA(cmsg));
	1166	+ EXPECT_EQ(record_type, 100);
	1167	+ EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	1168	+}
	1169	+
	1170	+TEST_F(tls, shutdown)
	1171	+{
	1172	+ char const *test_str = "test_read";
	1173	+ int send_len = 10;
	1174	+ char buf[10];
	1175	+
	1176	+ ASSERT_EQ(strlen(test_str) + 1, send_len);
	1177	+
	1178	+ EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
	1179	+ EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
	1180	+ EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
	1181	+
	1182	+ shutdown(self->fd, SHUT_RDWR);
	1183	+ shutdown(self->cfd, SHUT_RDWR);
	1184	+}
	1185	+
	1186	+TEST_F(tls, shutdown_unsent)
	1187	+{
	1188	+ char const *test_str = "test_read";
	1189	+ int send_len = 10;
	1190	+
	1191	+ EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
	1192	+
	1193	+ shutdown(self->fd, SHUT_RDWR);
	1194	+ shutdown(self->cfd, SHUT_RDWR);
	1195	+}
	1196	+
	1197	+TEST_F(tls, shutdown_reuse)
	1198	+{
	1199	+ struct sockaddr_in addr;
	1200	+ int ret;
	1201	+
	1202	+ shutdown(self->fd, SHUT_RDWR);
	1203	+ shutdown(self->cfd, SHUT_RDWR);
	1204	+ close(self->cfd);
	1205	+
	1206	+ addr.sin_family = AF_INET;
	1207	+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
	1208	+ addr.sin_port = 0;
	1209	+
	1210	+ ret = bind(self->fd, &addr, sizeof(addr));
	1211	+ EXPECT_EQ(ret, 0);
	1212	+ ret = listen(self->fd, 10);
	1213	+ EXPECT_EQ(ret, -1);
	1214	+ EXPECT_EQ(errno, EINVAL);
	1215	+
	1216	+ ret = connect(self->fd, &addr, sizeof(addr));
	1217	+ EXPECT_EQ(ret, -1);
	1218	+ EXPECT_EQ(errno, EISCONN);
	1219	+}
	1220	+
	1221	+TEST(non_established) {
	1222	+ struct tls12_crypto_info_aes_gcm_256 tls12;
	1223	+ struct sockaddr_in addr;
	1224	+ int sfd, ret, fd;
	1225	+ socklen_t len;
	1226	+
	1227	+ len = sizeof(addr);
	1228	+
	1229	+ memset(&tls12, 0, sizeof(tls12));
	1230	+ tls12.info.version = TLS_1_2_VERSION;
	1231	+ tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
	1232	+
	1233	+ addr.sin_family = AF_INET;
	1234	+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
	1235	+ addr.sin_port = 0;
	1236	+
	1237	+ fd = socket(AF_INET, SOCK_STREAM, 0);
	1238	+ sfd = socket(AF_INET, SOCK_STREAM, 0);
	1239	+
	1240	+ ret = bind(sfd, &addr, sizeof(addr));
	1241	+ ASSERT_EQ(ret, 0);
	1242	+ ret = listen(sfd, 10);
	1243	+ ASSERT_EQ(ret, 0);
	1244	+
	1245	+ ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	1246	+ EXPECT_EQ(ret, -1);
	1247	+ /* TLS ULP not supported */
	1248	+ if (errno == ENOENT)
	1249	+ return;
	1250	+ EXPECT_EQ(errno, ENOTCONN);
	1251	+
	1252	+ ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	1253	+ EXPECT_EQ(ret, -1);
	1254	+ EXPECT_EQ(errno, ENOTCONN);
	1255	+
	1256	+ ret = getsockname(sfd, &addr, &len);
	1257	+ ASSERT_EQ(ret, 0);
	1258	+
	1259	+ ret = connect(fd, &addr, sizeof(addr));
	1260	+ ASSERT_EQ(ret, 0);
	1261	+
	1262	+ ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	1263	+ ASSERT_EQ(ret, 0);
	1264	+
	1265	+ ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	1266	+ EXPECT_EQ(ret, -1);
	1267	+ EXPECT_EQ(errno, EEXIST);
	1268	+
	1269	+ close(fd);
	1270	+ close(sfd);
	1271	+}
	1272	+
	1273	+TEST(keysizes) {
	1274	+ struct tls12_crypto_info_aes_gcm_256 tls12;
	1275	+ struct sockaddr_in addr;
	1276	+ int sfd, ret, fd, cfd;
	1277	+ socklen_t len;
	1278	+ bool notls;
	1279	+
	1280	+ notls = false;
	1281	+ len = sizeof(addr);
	1282	+
	1283	+ memset(&tls12, 0, sizeof(tls12));
	1284	+ tls12.info.version = TLS_1_2_VERSION;
	1285	+ tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
	1286	+
	1287	+ addr.sin_family = AF_INET;
	1288	+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
	1289	+ addr.sin_port = 0;
	1290	+
	1291	+ fd = socket(AF_INET, SOCK_STREAM, 0);
	1292	+ sfd = socket(AF_INET, SOCK_STREAM, 0);
	1293	+
	1294	+ ret = bind(sfd, &addr, sizeof(addr));
	1295	+ ASSERT_EQ(ret, 0);
	1296	+ ret = listen(sfd, 10);
	1297	+ ASSERT_EQ(ret, 0);
	1298	+
	1299	+ ret = getsockname(sfd, &addr, &len);
	1300	+ ASSERT_EQ(ret, 0);
	1301	+
	1302	+ ret = connect(fd, &addr, sizeof(addr));
	1303	+ ASSERT_EQ(ret, 0);
	1304	+
	1305	+ ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
	1306	+ if (ret != 0) {
	1307	+ notls = true;
	1308	+ printf("Failure setting TCP_ULP, testing without tls\n");
	1309	+ }
	1310	+
	1311	+ if (!notls) {
	1312	+ ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
	1313	+ sizeof(tls12));
	1314	+ EXPECT_EQ(ret, 0);
	1315	+ }
	1316	+
	1317	+ cfd = accept(sfd, &addr, &len);
	1318	+ ASSERT_GE(cfd, 0);
	1319	+
	1320	+ if (!notls) {
	1321	+ ret = setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls",
	1322	+ sizeof("tls"));
	1323	+ EXPECT_EQ(ret, 0);
	1324	+
	1325	+ ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,
	1326	+ sizeof(tls12));
	1327	+ EXPECT_EQ(ret, 0);
	1328	+ }
	1329	+
	1330	+ close(sfd);
	1331	+ close(fd);
	1332	+ close(cfd);
739	1333	}
740	1334
741	1335	TEST_HARNESS_MAIN