tls.c 18 KB

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