2 * Copyright (c) 2018 Aniket Pandey
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 #include <sys/types.h>
29 #include <sys/socket.h>
39 #define SERVER_PATH "server"
41 static int sockfd, sockfd2;
43 static struct pollfd fds[1];
44 static char extregex[80];
45 static const char *auclass = "nt";
46 static const char *nosupregex = "return,failure : Address family "
47 "not supported by protocol family";
48 static const char *invalregex = "return,failure : Bad file descriptor";
51 * Variadic function to close socket descriptors
54 close_sockets(int count, ...)
58 va_start(socklist, count);
59 for (sockd = 0; sockd < count; sockd++) {
60 close(va_arg(socklist, int));
66 * Assign local filesystem address to a Unix domain socket
69 assign_address(struct sockaddr_un *server)
71 memset(server, 0, sizeof(*server));
72 server->sun_family = AF_UNIX;
73 strcpy(server->sun_path, SERVER_PATH);
77 ATF_TC_WITH_CLEANUP(socket_success);
78 ATF_TC_HEAD(socket_success, tc)
80 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
84 ATF_TC_BODY(socket_success, tc)
86 FILE *pipefd = setup(fds, auclass);
87 ATF_REQUIRE((sockfd = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
88 /* Check the presence of sockfd in audit record */
89 snprintf(extregex, sizeof(extregex), "socket.*ret.*success,%d", sockfd);
90 check_audit(fds, extregex, pipefd);
94 ATF_TC_CLEANUP(socket_success, tc)
100 ATF_TC_WITH_CLEANUP(socket_failure);
101 ATF_TC_HEAD(socket_failure, tc)
103 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
107 ATF_TC_BODY(socket_failure, tc)
109 snprintf(extregex, sizeof(extregex), "socket.*%s", nosupregex);
110 FILE *pipefd = setup(fds, auclass);
111 /* Failure reason: Unsupported value of 'domain' argument: 0 */
112 ATF_REQUIRE_EQ(-1, socket(0, SOCK_STREAM, 0));
113 check_audit(fds, extregex, pipefd);
116 ATF_TC_CLEANUP(socket_failure, tc)
122 ATF_TC_WITH_CLEANUP(socketpair_success);
123 ATF_TC_HEAD(socketpair_success, tc)
125 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
126 "socketpair(2) call");
129 ATF_TC_BODY(socketpair_success, tc)
132 FILE *pipefd = setup(fds, auclass);
133 ATF_REQUIRE_EQ(0, socketpair(PF_UNIX, SOCK_STREAM, 0, sv));
135 /* Check for 0x0 (argument 3: default protocol) in the audit record */
136 snprintf(extregex, sizeof(extregex), "socketpair.*0x0.*return,success");
137 check_audit(fds, extregex, pipefd);
138 close_sockets(2, sv[0], sv[1]);
141 ATF_TC_CLEANUP(socketpair_success, tc)
147 ATF_TC_WITH_CLEANUP(socketpair_failure);
148 ATF_TC_HEAD(socketpair_failure, tc)
150 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
151 "socketpair(2) call");
154 ATF_TC_BODY(socketpair_failure, tc)
156 snprintf(extregex, sizeof(extregex), "socketpair.*%s", nosupregex);
157 FILE *pipefd = setup(fds, auclass);
158 /* Failure reason: Unsupported value of 'domain' argument: 0 */
159 ATF_REQUIRE_EQ(-1, socketpair(0, SOCK_STREAM, 0, NULL));
160 check_audit(fds, extregex, pipefd);
163 ATF_TC_CLEANUP(socketpair_failure, tc)
169 ATF_TC_WITH_CLEANUP(setsockopt_success);
170 ATF_TC_HEAD(setsockopt_success, tc)
172 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
173 "setsockopt(2) call");
176 ATF_TC_BODY(setsockopt_success, tc)
179 ATF_REQUIRE((sockfd = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
180 /* Check the presence of sockfd in audit record */
181 snprintf(extregex, sizeof(extregex),
182 "setsockopt.*0x%x.*return,success", sockfd);
184 FILE *pipefd = setup(fds, auclass);
185 ATF_REQUIRE_EQ(0, setsockopt(sockfd, SOL_SOCKET,
186 SO_REUSEADDR, &tr, sizeof(int)));
187 check_audit(fds, extregex, pipefd);
191 ATF_TC_CLEANUP(setsockopt_success, tc)
197 ATF_TC_WITH_CLEANUP(setsockopt_failure);
198 ATF_TC_HEAD(setsockopt_failure, tc)
200 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
201 "setsockopt(2) call");
204 ATF_TC_BODY(setsockopt_failure, tc)
207 snprintf(extregex, sizeof(extregex), "setsockopt.*%s", invalregex);
208 FILE *pipefd = setup(fds, auclass);
209 /* Failure reason: Invalid socket descriptor */
210 ATF_REQUIRE_EQ(-1, setsockopt(-1, SOL_SOCKET,
211 SO_REUSEADDR, &tr, sizeof(int)));
212 check_audit(fds, extregex, pipefd);
215 ATF_TC_CLEANUP(setsockopt_failure, tc)
221 ATF_TC_WITH_CLEANUP(bind_success);
222 ATF_TC_HEAD(bind_success, tc)
224 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
228 ATF_TC_BODY(bind_success, tc)
230 struct sockaddr_un server;
231 assign_address(&server);
232 len = sizeof(struct sockaddr_un);
234 /* Preliminary socket setup */
235 ATF_REQUIRE((sockfd = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
236 /* Check the presence of AF_UNIX address path in audit record */
237 snprintf(extregex, sizeof(extregex),
238 "bind.*unix.*%s.*return,success", SERVER_PATH);
240 FILE *pipefd = setup(fds, auclass);
241 ATF_REQUIRE_EQ(0, bind(sockfd, (struct sockaddr *)&server, len));
242 check_audit(fds, extregex, pipefd);
246 ATF_TC_CLEANUP(bind_success, tc)
252 ATF_TC_WITH_CLEANUP(bind_failure);
253 ATF_TC_HEAD(bind_failure, tc)
255 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
259 ATF_TC_BODY(bind_failure, tc)
261 /* Preliminary socket setup */
262 struct sockaddr_un server;
263 assign_address(&server);
264 len = sizeof(struct sockaddr_un);
265 /* Check the presence of AF_UNIX path in audit record */
266 snprintf(extregex, sizeof(extregex),
267 "bind.*%s.*return,failure", SERVER_PATH);
269 FILE *pipefd = setup(fds, auclass);
270 /* Failure reason: Invalid socket descriptor */
271 ATF_REQUIRE_EQ(-1, bind(0, (struct sockaddr *)&server, len));
272 check_audit(fds, extregex, pipefd);
275 ATF_TC_CLEANUP(bind_failure, tc)
281 ATF_TC_WITH_CLEANUP(bindat_success);
282 ATF_TC_HEAD(bindat_success, tc)
284 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
288 ATF_TC_BODY(bindat_success, tc)
290 struct sockaddr_un server;
291 assign_address(&server);
292 len = sizeof(struct sockaddr_un);
294 /* Preliminary socket setup */
295 ATF_REQUIRE((sockfd = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
296 /* Check the presence of socket descriptor in audit record */
297 snprintf(extregex, sizeof(extregex),
298 "bindat.*0x%x.*return,success", sockfd);
300 FILE *pipefd = setup(fds, auclass);
301 ATF_REQUIRE_EQ(0, bindat(AT_FDCWD, sockfd,
302 (struct sockaddr *)&server, len));
303 check_audit(fds, extregex, pipefd);
307 ATF_TC_CLEANUP(bindat_success, tc)
313 ATF_TC_WITH_CLEANUP(bindat_failure);
314 ATF_TC_HEAD(bindat_failure, tc)
316 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
320 ATF_TC_BODY(bindat_failure, tc)
322 /* Preliminary socket setup */
323 struct sockaddr_un server;
324 assign_address(&server);
325 len = sizeof(struct sockaddr_un);
326 snprintf(extregex, sizeof(extregex), "bindat.*%s", invalregex);
328 FILE *pipefd = setup(fds, auclass);
329 /* Failure reason: Invalid socket descriptor */
330 ATF_REQUIRE_EQ(-1, bindat(AT_FDCWD, -1,
331 (struct sockaddr *)&server, len));
332 check_audit(fds, extregex, pipefd);
335 ATF_TC_CLEANUP(bindat_failure, tc)
341 ATF_TC_WITH_CLEANUP(listen_success);
342 ATF_TC_HEAD(listen_success, tc)
344 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
348 ATF_TC_BODY(listen_success, tc)
350 struct sockaddr_un server;
351 assign_address(&server);
352 len = sizeof(struct sockaddr_un);
354 /* Preliminary socket setup */
355 ATF_REQUIRE((sockfd = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
356 ATF_REQUIRE_EQ(0, bind(sockfd, (struct sockaddr *)&server, len));
357 /* Check the presence of socket descriptor in the audit record */
358 snprintf(extregex, sizeof(extregex),
359 "listen.*0x%x.*return,success", sockfd);
361 FILE *pipefd = setup(fds, auclass);
362 ATF_REQUIRE_EQ(0, listen(sockfd, 1));
363 check_audit(fds, extregex, pipefd);
367 ATF_TC_CLEANUP(listen_success, tc)
373 ATF_TC_WITH_CLEANUP(listen_failure);
374 ATF_TC_HEAD(listen_failure, tc)
376 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
380 ATF_TC_BODY(listen_failure, tc)
382 snprintf(extregex, sizeof(extregex), "listen.*%s", invalregex);
383 FILE *pipefd = setup(fds, auclass);
384 /* Failure reason: Invalid socket descriptor */
385 ATF_REQUIRE_EQ(-1, listen(-1, 1));
386 check_audit(fds, extregex, pipefd);
389 ATF_TC_CLEANUP(listen_failure, tc)
395 ATF_TC_WITH_CLEANUP(connect_success);
396 ATF_TC_HEAD(connect_success, tc)
398 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
402 ATF_TC_BODY(connect_success, tc)
404 struct sockaddr_un server;
405 assign_address(&server);
406 len = sizeof(struct sockaddr_un);
408 /* Setup a non-blocking server socket */
409 ATF_REQUIRE((sockfd = socket(PF_UNIX,
410 SOCK_STREAM | SOCK_NONBLOCK, 0)) != -1);
411 /* Bind to the specified address and wait for connection */
412 ATF_REQUIRE_EQ(0, bind(sockfd, (struct sockaddr *)&server, len));
413 ATF_REQUIRE_EQ(0, listen(sockfd, 1));
415 /* Set up "blocking" client socket */
416 ATF_REQUIRE((sockfd2 = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
418 /* Audit record must contain AF_UNIX address path & sockfd2 */
419 snprintf(extregex, sizeof(extregex),
420 "connect.*0x%x.*%s.*success", sockfd2, SERVER_PATH);
422 FILE *pipefd = setup(fds, auclass);
423 ATF_REQUIRE_EQ(0, connect(sockfd2, (struct sockaddr *)&server, len));
424 check_audit(fds, extregex, pipefd);
426 /* Close all socket descriptors */
427 close_sockets(2, sockfd, sockfd2);
430 ATF_TC_CLEANUP(connect_success, tc)
436 ATF_TC_WITH_CLEANUP(connect_failure);
437 ATF_TC_HEAD(connect_failure, tc)
439 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
443 ATF_TC_BODY(connect_failure, tc)
445 /* Preliminary socket setup */
446 struct sockaddr_un server;
447 assign_address(&server);
448 len = sizeof(struct sockaddr_un);
450 /* Audit record must contain AF_UNIX address path */
451 snprintf(extregex, sizeof(extregex),
452 "connect.*%s.*return,failure", SERVER_PATH);
454 FILE *pipefd = setup(fds, auclass);
455 /* Failure reason: Invalid socket descriptor */
456 ATF_REQUIRE_EQ(-1, connect(-1, (struct sockaddr *)&server, len));
457 check_audit(fds, extregex, pipefd);
460 ATF_TC_CLEANUP(connect_failure, tc)
466 ATF_TC_WITH_CLEANUP(connectat_success);
467 ATF_TC_HEAD(connectat_success, tc)
469 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
470 "connectat(2) call");
473 ATF_TC_BODY(connectat_success, tc)
475 struct sockaddr_un server;
476 assign_address(&server);
477 len = sizeof(struct sockaddr_un);
479 /* Setup a non-blocking server socket */
480 ATF_REQUIRE((sockfd = socket(PF_UNIX,
481 SOCK_STREAM | SOCK_NONBLOCK, 0)) != -1);
482 /* Bind to the specified address and wait for connection */
483 ATF_REQUIRE_EQ(0, bind(sockfd, (struct sockaddr *)&server, len));
484 ATF_REQUIRE_EQ(0, listen(sockfd, 1));
486 /* Set up "blocking" client socket */
487 ATF_REQUIRE((sockfd2 = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
489 /* Audit record must contain sockfd2 */
490 snprintf(extregex, sizeof(extregex),
491 "connectat.*0x%x.*return,success", sockfd2);
493 FILE *pipefd = setup(fds, auclass);
494 ATF_REQUIRE_EQ(0, connectat(AT_FDCWD, sockfd2,
495 (struct sockaddr *)&server, len));
496 check_audit(fds, extregex, pipefd);
498 /* Close all socket descriptors */
499 close_sockets(2, sockfd, sockfd2);
502 ATF_TC_CLEANUP(connectat_success, tc)
508 ATF_TC_WITH_CLEANUP(connectat_failure);
509 ATF_TC_HEAD(connectat_failure, tc)
511 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
512 "connectat(2) call");
515 ATF_TC_BODY(connectat_failure, tc)
517 /* Preliminary socket setup */
518 struct sockaddr_un server;
519 assign_address(&server);
520 len = sizeof(struct sockaddr_un);
521 snprintf(extregex, sizeof(extregex), "connectat.*%s", invalregex);
523 FILE *pipefd = setup(fds, auclass);
524 /* Failure reason: Invalid socket descriptor */
525 ATF_REQUIRE_EQ(-1, connectat(AT_FDCWD, -1,
526 (struct sockaddr *)&server, len));
527 check_audit(fds, extregex, pipefd);
530 ATF_TC_CLEANUP(connectat_failure, tc)
536 ATF_TC_WITH_CLEANUP(accept_success);
537 ATF_TC_HEAD(accept_success, tc)
539 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
543 ATF_TC_BODY(accept_success, tc)
546 struct sockaddr_un server;
547 assign_address(&server);
548 len = sizeof(struct sockaddr_un);
550 /* Setup a non-blocking server socket */
551 ATF_REQUIRE((sockfd = socket(PF_UNIX,
552 SOCK_STREAM | SOCK_NONBLOCK, 0)) != -1);
553 /* Bind to the specified address and wait for connection */
554 ATF_REQUIRE_EQ(0, bind(sockfd, (struct sockaddr *)&server, len));
555 ATF_REQUIRE_EQ(0, listen(sockfd, 1));
557 /* Set up "blocking" client socket */
558 ATF_REQUIRE((sockfd2 = socket(PF_UNIX, SOCK_STREAM, 0)) != -1);
559 ATF_REQUIRE_EQ(0, connect(sockfd2, (struct sockaddr *)&server, len));
561 FILE *pipefd = setup(fds, auclass);
562 ATF_REQUIRE((clientfd = accept(sockfd, NULL, &len)) != -1);
564 /* Audit record must contain clientfd & sockfd */
565 snprintf(extregex, sizeof(extregex),
566 "accept.*0x%x.*return,success,%d", sockfd, clientfd);
567 check_audit(fds, extregex, pipefd);
569 /* Close all socket descriptors */
570 close_sockets(3, sockfd, sockfd2, clientfd);
573 ATF_TC_CLEANUP(accept_success, tc)
579 ATF_TC_WITH_CLEANUP(accept_failure);
580 ATF_TC_HEAD(accept_failure, tc)
582 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
586 ATF_TC_BODY(accept_failure, tc)
588 /* Preliminary socket setup */
589 struct sockaddr_un client;
590 len = sizeof(struct sockaddr_un);
591 snprintf(extregex, sizeof(extregex), "accept.*%s", invalregex);
593 FILE *pipefd = setup(fds, auclass);
594 /* Failure reason: Invalid socket descriptor */
595 ATF_REQUIRE_EQ(-1, accept(-1, (struct sockaddr *)&client, &len));
596 check_audit(fds, extregex, pipefd);
599 ATF_TC_CLEANUP(accept_failure, tc)
607 ATF_TP_ADD_TC(tp, socket_success);
608 ATF_TP_ADD_TC(tp, socket_failure);
609 ATF_TP_ADD_TC(tp, socketpair_success);
610 ATF_TP_ADD_TC(tp, socketpair_failure);
611 ATF_TP_ADD_TC(tp, setsockopt_success);
612 ATF_TP_ADD_TC(tp, setsockopt_failure);
614 ATF_TP_ADD_TC(tp, bind_success);
615 ATF_TP_ADD_TC(tp, bind_failure);
616 ATF_TP_ADD_TC(tp, bindat_success);
617 ATF_TP_ADD_TC(tp, bindat_failure);
618 ATF_TP_ADD_TC(tp, listen_success);
619 ATF_TP_ADD_TC(tp, listen_failure);
621 ATF_TP_ADD_TC(tp, connect_success);
622 ATF_TP_ADD_TC(tp, connect_failure);
623 ATF_TP_ADD_TC(tp, connectat_success);
624 ATF_TP_ADD_TC(tp, connectat_failure);
625 ATF_TP_ADD_TC(tp, accept_success);
626 ATF_TP_ADD_TC(tp, accept_failure);
628 return (atf_no_error());