add stmac read mac form eeprom

hc

2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c

 kernel/tools/testing/selftests/net/tls.c
..
..
@@ -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
 {
..
..
@@ -306,7 +491,7 @@
306
491
 	EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
307
492
 	EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
308
493
 	EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
309
-	EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
494
+	EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
310
495
 	EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
311
496
 }
312
497
 
..
..
@@ -436,10 +621,25 @@
436
621
 	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
437
622
 	EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
438
623
 	memset(recv_mem, 0, total_len);
439
-	EXPECT_EQ(recv(self->cfd, recv_mem, total_len, 0), total_len);
624
+	EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
440
625
 
441
626
 	EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
442
627
 	EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
628
+}
629
+
630
+TEST_F(tls, single_send_multiple_recv_non_align)
631
+{
632
+	const unsigned int total_len = 15;
633
+	const unsigned int recv_len = 10;
634
+	char recv_mem[recv_len * 2];
635
+	char send_mem[total_len];
636
+
637
+	EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
638
+	memset(recv_mem, 0, total_len);
639
+
640
+	EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len);
641
+	EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5);
642
+	EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
443
643
 }
444
644
 
445
645
 TEST_F(tls, recv_partial)
..
..
@@ -452,10 +652,12 @@
452
652
 
453
653
 	memset(recv_mem, 0, sizeof(recv_mem));
454
654
 	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);
655
+	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first),
656
+		       MSG_WAITALL), -1);
456
657
 	EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
457
658
 	memset(recv_mem, 0, sizeof(recv_mem));
458
-	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
659
+	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second),
660
+		       MSG_WAITALL), -1);
459
661
 	EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
460
662
 		  0);
461
663
 }
..
..
@@ -551,6 +753,84 @@
551
753
 	EXPECT_EQ(memcmp(test_str, buf, len), 0);
552
754
 }
553
755
 
756
+TEST_F(tls, recv_peek_large_buf_mult_recs)
757
+{
758
+	char const *test_str = "test_read_peek_mult_recs";
759
+	char const *test_str_first = "test_read_peek";
760
+	char const *test_str_second = "_mult_recs";
761
+	int len;
762
+	char buf[64];
763
+
764
+	len = strlen(test_str_first);
765
+	EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
766
+
767
+	len = strlen(test_str_second) + 1;
768
+	EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
769
+
770
+	len = strlen(test_str) + 1;
771
+	memset(buf, 0, len);
772
+	EXPECT_NE((len = recv(self->cfd, buf, len,
773
+			      MSG_PEEK | MSG_WAITALL)), -1);
774
+	len = strlen(test_str) + 1;
775
+	EXPECT_EQ(memcmp(test_str, buf, len), 0);
776
+}
777
+
778
+TEST_F(tls, recv_lowat)
779
+{
780
+	char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
781
+	char recv_mem[20];
782
+	int lowat = 8;
783
+
784
+	EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10);
785
+	EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5);
786
+
787
+	memset(recv_mem, 0, 20);
788
+	EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT,
789
+			     &lowat, sizeof(lowat)), 0);
790
+	EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1);
791
+	EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6);
792
+	EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8);
793
+
794
+	EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0);
795
+	EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0);
796
+}
797
+
798
+TEST_F(tls, bidir)
799
+{
800
+	char const *test_str = "test_read";
801
+	int send_len = 10;
802
+	char buf[10];
803
+	int ret;
804
+
805
+	if (!self->notls) {
806
+		struct tls12_crypto_info_aes_gcm_128 tls12;
807
+
808
+		memset(&tls12, 0, sizeof(tls12));
809
+		tls12.info.version = variant->tls_version;
810
+		tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
811
+
812
+		ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12,
813
+				 sizeof(tls12));
814
+		ASSERT_EQ(ret, 0);
815
+
816
+		ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12,
817
+				 sizeof(tls12));
818
+		ASSERT_EQ(ret, 0);
819
+	}
820
+
821
+	ASSERT_EQ(strlen(test_str) + 1, send_len);
822
+
823
+	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
824
+	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
825
+	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
826
+
827
+	memset(buf, 0, sizeof(buf));
828
+
829
+	EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len);
830
+	EXPECT_NE(recv(self->fd, buf, send_len, 0), -1);
831
+	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
832
+};
833
+
554
834
 TEST_F(tls, pollin)
555
835
 {
556
836
 	char const *test_str = "test_poll";
..
..
@@ -564,7 +844,7 @@
564
844
 
565
845
 	EXPECT_EQ(poll(&fd, 1, 20), 1);
566
846
 	EXPECT_EQ(fd.revents & POLLIN, 1);
567
-	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
847
+	EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
568
848
 	/* Test timing out */
569
849
 	EXPECT_EQ(poll(&fd, 1, 20), 0);
570
850
 }
..
..
@@ -582,7 +862,33 @@
582
862
 	/* Set timeout to inf. secs */
583
863
 	EXPECT_EQ(poll(&fd, 1, -1), 1);
584
864
 	EXPECT_EQ(fd.revents & POLLIN, 1);
585
-	EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len);
865
+	EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
866
+}
867
+
868
+TEST_F(tls, poll_wait_split)
869
+{
870
+	struct pollfd fd = { 0, 0, 0 };
871
+	char send_mem[20] = {};
872
+	char recv_mem[15];
873
+
874
+	fd.fd = self->cfd;
875
+	fd.events = POLLIN;
876
+	/* Send 20 bytes */
877
+	EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0),
878
+		  sizeof(send_mem));
879
+	/* Poll with inf. timeout */
880
+	EXPECT_EQ(poll(&fd, 1, -1), 1);
881
+	EXPECT_EQ(fd.revents & POLLIN, 1);
882
+	EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL),
883
+		  sizeof(recv_mem));
884
+
885
+	/* Now the remaining 5 bytes of record data are in TLS ULP */
886
+	fd.fd = self->cfd;
887
+	fd.events = POLLIN;
888
+	EXPECT_EQ(poll(&fd, 1, -1), 1);
889
+	EXPECT_EQ(fd.revents & POLLIN, 1);
890
+	EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0),
891
+		  sizeof(send_mem) - sizeof(recv_mem));
586
892
 }
587
893
 
588
894
 TEST_F(tls, blocking)
..
..
@@ -693,6 +999,114 @@
693
999
 	}
694
1000
 }
695
1001
 
1002
+static void
1003
+test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self,
1004
+	       bool sendpg, unsigned int n_readers, unsigned int n_writers)
1005
+{
1006
+	const unsigned int n_children = n_readers + n_writers;
1007
+	const size_t data = 6 * 1000 * 1000;
1008
+	const size_t file_sz = data / 100;
1009
+	size_t read_bias, write_bias;
1010
+	int i, fd, child_id;
1011
+	char buf[file_sz];
1012
+	pid_t pid;
1013
+
1014
+	/* Only allow multiples for simplicity */
1015
+	ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true);
1016
+	read_bias = n_writers / n_readers ?: 1;
1017
+	write_bias = n_readers / n_writers ?: 1;
1018
+
1019
+	/* prep a file to send */
1020
+	fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600);
1021
+	ASSERT_GE(fd, 0);
1022
+
1023
+	memset(buf, 0xac, file_sz);
1024
+	ASSERT_EQ(write(fd, buf, file_sz), file_sz);
1025
+
1026
+	/* spawn children */
1027
+	for (child_id = 0; child_id < n_children; child_id++) {
1028
+		pid = fork();
1029
+		ASSERT_NE(pid, -1);
1030
+		if (!pid)
1031
+			break;
1032
+	}
1033
+
1034
+	/* parent waits for all children */
1035
+	if (pid) {
1036
+		for (i = 0; i < n_children; i++) {
1037
+			int status;
1038
+
1039
+			wait(&status);
1040
+			EXPECT_EQ(status, 0);
1041
+		}
1042
+
1043
+		return;
1044
+	}
1045
+
1046
+	/* Split threads for reading and writing */
1047
+	if (child_id < n_readers) {
1048
+		size_t left = data * read_bias;
1049
+		char rb[8001];
1050
+
1051
+		while (left) {
1052
+			int res;
1053
+
1054
+			res = recv(self->cfd, rb,
1055
+				   left > sizeof(rb) ? sizeof(rb) : left, 0);
1056
+
1057
+			EXPECT_GE(res, 0);
1058
+			left -= res;
1059
+		}
1060
+	} else {
1061
+		size_t left = data * write_bias;
1062
+
1063
+		while (left) {
1064
+			int res;
1065
+
1066
+			ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
1067
+			if (sendpg)
1068
+				res = sendfile(self->fd, fd, NULL,
1069
+					       left > file_sz ? file_sz : left);
1070
+			else
1071
+				res = send(self->fd, buf,
1072
+					   left > file_sz ? file_sz : left, 0);
1073
+
1074
+			EXPECT_GE(res, 0);
1075
+			left -= res;
1076
+		}
1077
+	}
1078
+}
1079
+
1080
+TEST_F(tls, mutliproc_even)
1081
+{
1082
+	test_mutliproc(_metadata, self, false, 6, 6);
1083
+}
1084
+
1085
+TEST_F(tls, mutliproc_readers)
1086
+{
1087
+	test_mutliproc(_metadata, self, false, 4, 12);
1088
+}
1089
+
1090
+TEST_F(tls, mutliproc_writers)
1091
+{
1092
+	test_mutliproc(_metadata, self, false, 10, 2);
1093
+}
1094
+
1095
+TEST_F(tls, mutliproc_sendpage_even)
1096
+{
1097
+	test_mutliproc(_metadata, self, true, 6, 6);
1098
+}
1099
+
1100
+TEST_F(tls, mutliproc_sendpage_readers)
1101
+{
1102
+	test_mutliproc(_metadata, self, true, 4, 12);
1103
+}
1104
+
1105
+TEST_F(tls, mutliproc_sendpage_writers)
1106
+{
1107
+	test_mutliproc(_metadata, self, true, 10, 2);
1108
+}
1109
+
696
1110
 TEST_F(tls, control_msg)
697
1111
 {
698
1112
 	if (self->notls)
..
..
@@ -728,7 +1142,8 @@
728
1142
 	EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
729
1143
 
730
1144
 	vec.iov_base = buf;
731
-	EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len);
1145
+	EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL | MSG_PEEK), send_len);
1146
+
732
1147
 	cmsg = CMSG_FIRSTHDR(&msg);
733
1148
 	EXPECT_NE(cmsg, NULL);
734
1149
 	EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
..
..
@@ -736,6 +1151,184 @@
736
1151
 	record_type = *((unsigned char *)CMSG_DATA(cmsg));
737
1152
 	EXPECT_EQ(record_type, 100);
738
1153
 	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1154
+
1155
+	/* Recv the message again without MSG_PEEK */
1156
+	record_type = 0;
1157
+	memset(buf, 0, sizeof(buf));
1158
+
1159
+	EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL), send_len);
1160
+	cmsg = CMSG_FIRSTHDR(&msg);
1161
+	EXPECT_NE(cmsg, NULL);
1162
+	EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
1163
+	EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
1164
+	record_type = *((unsigned char *)CMSG_DATA(cmsg));
1165
+	EXPECT_EQ(record_type, 100);
1166
+	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1167
+}
1168
+
1169
+TEST_F(tls, shutdown)
1170
+{
1171
+	char const *test_str = "test_read";
1172
+	int send_len = 10;
1173
+	char buf[10];
1174
+
1175
+	ASSERT_EQ(strlen(test_str) + 1, send_len);
1176
+
1177
+	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1178
+	EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1179
+	EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1180
+
1181
+	shutdown(self->fd, SHUT_RDWR);
1182
+	shutdown(self->cfd, SHUT_RDWR);
1183
+}
1184
+
1185
+TEST_F(tls, shutdown_unsent)
1186
+{
1187
+	char const *test_str = "test_read";
1188
+	int send_len = 10;
1189
+
1190
+	EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
1191
+
1192
+	shutdown(self->fd, SHUT_RDWR);
1193
+	shutdown(self->cfd, SHUT_RDWR);
1194
+}
1195
+
1196
+TEST_F(tls, shutdown_reuse)
1197
+{
1198
+	struct sockaddr_in addr;
1199
+	int ret;
1200
+
1201
+	shutdown(self->fd, SHUT_RDWR);
1202
+	shutdown(self->cfd, SHUT_RDWR);
1203
+	close(self->cfd);
1204
+
1205
+	addr.sin_family = AF_INET;
1206
+	addr.sin_addr.s_addr = htonl(INADDR_ANY);
1207
+	addr.sin_port = 0;
1208
+
1209
+	ret = bind(self->fd, &addr, sizeof(addr));
1210
+	EXPECT_EQ(ret, 0);
1211
+	ret = listen(self->fd, 10);
1212
+	EXPECT_EQ(ret, -1);
1213
+	EXPECT_EQ(errno, EINVAL);
1214
+
1215
+	ret = connect(self->fd, &addr, sizeof(addr));
1216
+	EXPECT_EQ(ret, -1);
1217
+	EXPECT_EQ(errno, EISCONN);
1218
+}
1219
+
1220
+TEST(non_established) {
1221
+	struct tls12_crypto_info_aes_gcm_256 tls12;
1222
+	struct sockaddr_in addr;
1223
+	int sfd, ret, fd;
1224
+	socklen_t len;
1225
+
1226
+	len = sizeof(addr);
1227
+
1228
+	memset(&tls12, 0, sizeof(tls12));
1229
+	tls12.info.version = TLS_1_2_VERSION;
1230
+	tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1231
+
1232
+	addr.sin_family = AF_INET;
1233
+	addr.sin_addr.s_addr = htonl(INADDR_ANY);
1234
+	addr.sin_port = 0;
1235
+
1236
+	fd = socket(AF_INET, SOCK_STREAM, 0);
1237
+	sfd = socket(AF_INET, SOCK_STREAM, 0);
1238
+
1239
+	ret = bind(sfd, &addr, sizeof(addr));
1240
+	ASSERT_EQ(ret, 0);
1241
+	ret = listen(sfd, 10);
1242
+	ASSERT_EQ(ret, 0);
1243
+
1244
+	ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1245
+	EXPECT_EQ(ret, -1);
1246
+	/* TLS ULP not supported */
1247
+	if (errno == ENOENT)
1248
+		return;
1249
+	EXPECT_EQ(errno, ENOTCONN);
1250
+
1251
+	ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1252
+	EXPECT_EQ(ret, -1);
1253
+	EXPECT_EQ(errno, ENOTCONN);
1254
+
1255
+	ret = getsockname(sfd, &addr, &len);
1256
+	ASSERT_EQ(ret, 0);
1257
+
1258
+	ret = connect(fd, &addr, sizeof(addr));
1259
+	ASSERT_EQ(ret, 0);
1260
+
1261
+	ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1262
+	ASSERT_EQ(ret, 0);
1263
+
1264
+	ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1265
+	EXPECT_EQ(ret, -1);
1266
+	EXPECT_EQ(errno, EEXIST);
1267
+
1268
+	close(fd);
1269
+	close(sfd);
1270
+}
1271
+
1272
+TEST(keysizes) {
1273
+	struct tls12_crypto_info_aes_gcm_256 tls12;
1274
+	struct sockaddr_in addr;
1275
+	int sfd, ret, fd, cfd;
1276
+	socklen_t len;
1277
+	bool notls;
1278
+
1279
+	notls = false;
1280
+	len = sizeof(addr);
1281
+
1282
+	memset(&tls12, 0, sizeof(tls12));
1283
+	tls12.info.version = TLS_1_2_VERSION;
1284
+	tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1285
+
1286
+	addr.sin_family = AF_INET;
1287
+	addr.sin_addr.s_addr = htonl(INADDR_ANY);
1288
+	addr.sin_port = 0;
1289
+
1290
+	fd = socket(AF_INET, SOCK_STREAM, 0);
1291
+	sfd = socket(AF_INET, SOCK_STREAM, 0);
1292
+
1293
+	ret = bind(sfd, &addr, sizeof(addr));
1294
+	ASSERT_EQ(ret, 0);
1295
+	ret = listen(sfd, 10);
1296
+	ASSERT_EQ(ret, 0);
1297
+
1298
+	ret = getsockname(sfd, &addr, &len);
1299
+	ASSERT_EQ(ret, 0);
1300
+
1301
+	ret = connect(fd, &addr, sizeof(addr));
1302
+	ASSERT_EQ(ret, 0);
1303
+
1304
+	ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1305
+	if (ret != 0) {
1306
+		notls = true;
1307
+		printf("Failure setting TCP_ULP, testing without tls\n");
1308
+	}
1309
+
1310
+	if (!notls) {
1311
+		ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
1312
+				 sizeof(tls12));
1313
+		EXPECT_EQ(ret, 0);
1314
+	}
1315
+
1316
+	cfd = accept(sfd, &addr, &len);
1317
+	ASSERT_GE(cfd, 0);
1318
+
1319
+	if (!notls) {
1320
+		ret = setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls",
1321
+				 sizeof("tls"));
1322
+		EXPECT_EQ(ret, 0);
1323
+
1324
+		ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,
1325
+				 sizeof(tls12));
1326
+		EXPECT_EQ(ret, 0);
1327
+	}
1328
+
1329
+	close(sfd);
1330
+	close(fd);
1331
+	close(cfd);
739
1332
 }
740
1333
 
741
1334
 TEST_HARNESS_MAIN