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>
49 typedef struct msgstr msgstr_t;
52 static int msqid, shmid, semid;
53 static union semun semarg;
54 static struct pollfd fds[1];
55 static struct msqid_ds msgbuff;
56 static struct shmid_ds shmbuff;
57 static struct semid_ds sembuff;
58 static char ipcregex[BUFFSIZE];
59 static const char *auclass = "ip";
60 static char path[BUFFSIZE] = "/fileforaudit";
61 static unsigned short semvals[BUFFSIZE];
64 ATF_TC_WITH_CLEANUP(msgget_success);
65 ATF_TC_HEAD(msgget_success, tc)
67 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
71 ATF_TC_BODY(msgget_success, tc)
73 FILE *pipefd = setup(fds, auclass);
74 /* Create a message queue and obtain the corresponding identifier */
75 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
76 /* Check the presence of message queue ID in audit record */
77 snprintf(ipcregex, sizeof(ipcregex),
78 "msgget.*return,success,%d", msqid);
79 check_audit(fds, ipcregex, pipefd);
81 /* Destroy the message queue with ID = msqid */
82 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
85 ATF_TC_CLEANUP(msgget_success, tc)
91 ATF_TC_WITH_CLEANUP(msgget_failure);
92 ATF_TC_HEAD(msgget_failure, tc)
94 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
98 ATF_TC_BODY(msgget_failure, tc)
100 const char *regex = "msgget.*return,failure.*No such file or directory";
101 FILE *pipefd = setup(fds, auclass);
102 ATF_REQUIRE_EQ(-1, msgget((key_t)(-1), 0));
103 check_audit(fds, regex, pipefd);
106 ATF_TC_CLEANUP(msgget_failure, tc)
112 ATF_TC_WITH_CLEANUP(msgsnd_success);
113 ATF_TC_HEAD(msgsnd_success, tc)
115 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
119 ATF_TC_BODY(msgsnd_success, tc)
121 /* Create a message queue and obtain the corresponding identifier */
122 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
124 /* Initialize a msgstr_t structure to store message */
127 memset(msg.mtext, 0, BUFFSIZE);
129 /* Check the presence of message queue ID in audit record */
130 snprintf(ipcregex, sizeof(ipcregex),
131 "msgsnd.*Message IPC.*%d.*return,success", msqid);
133 FILE *pipefd = setup(fds, auclass);
134 ATF_REQUIRE_EQ(0, msgsnd(msqid, &msg, BUFFSIZE, IPC_NOWAIT));
135 check_audit(fds, ipcregex, pipefd);
137 /* Destroy the message queue with ID = msqid */
138 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
141 ATF_TC_CLEANUP(msgsnd_success, tc)
147 ATF_TC_WITH_CLEANUP(msgsnd_failure);
148 ATF_TC_HEAD(msgsnd_failure, tc)
150 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
154 ATF_TC_BODY(msgsnd_failure, tc)
156 const char *regex = "msgsnd.*Message IPC.*return,failure : Bad address";
157 FILE *pipefd = setup(fds, auclass);
158 ATF_REQUIRE_EQ(-1, msgsnd(-1, NULL, 0, IPC_NOWAIT));
159 check_audit(fds, regex, pipefd);
162 ATF_TC_CLEANUP(msgsnd_failure, tc)
168 ATF_TC_WITH_CLEANUP(msgrcv_success);
169 ATF_TC_HEAD(msgrcv_success, tc)
171 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
175 ATF_TC_BODY(msgrcv_success, tc)
178 /* Create a message queue and obtain the corresponding identifier */
179 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
181 /* Initialize two msgstr_t structures to store respective messages */
184 memset(msg1.mtext, 0, BUFFSIZE);
186 /* Send a message to the queue with ID = msqid */
187 ATF_REQUIRE_EQ(0, msgsnd(msqid, &msg1, BUFFSIZE, IPC_NOWAIT));
189 FILE *pipefd = setup(fds, auclass);
190 ATF_REQUIRE((recv_bytes = msgrcv(msqid, &msg2,
191 BUFFSIZE, 0, MSG_NOERROR | IPC_NOWAIT)) != -1);
192 /* Check the presence of queue ID and returned bytes in audit record */
193 snprintf(ipcregex, sizeof(ipcregex),
194 "msgrcv.*Message IPC,*%d.*return,success,%zd", msqid, recv_bytes);
195 check_audit(fds, ipcregex, pipefd);
197 /* Destroy the message queue with ID = msqid */
198 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
201 ATF_TC_CLEANUP(msgrcv_success, tc)
207 ATF_TC_WITH_CLEANUP(msgrcv_failure);
208 ATF_TC_HEAD(msgrcv_failure, tc)
210 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
214 ATF_TC_BODY(msgrcv_failure, tc)
216 const char *regex = "msgrcv.*return,failure : Invalid argument";
217 FILE *pipefd = setup(fds, auclass);
218 ATF_REQUIRE_EQ(-1, msgrcv(-1, NULL, 0, 0, MSG_NOERROR | IPC_NOWAIT));
219 check_audit(fds, regex, pipefd);
222 ATF_TC_CLEANUP(msgrcv_failure, tc)
228 ATF_TC_WITH_CLEANUP(msgctl_rmid_success);
229 ATF_TC_HEAD(msgctl_rmid_success, tc)
231 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
232 "msgctl(2) call for IPC_RMID command");
235 ATF_TC_BODY(msgctl_rmid_success, tc)
237 /* Create a message queue and obtain the corresponding identifier */
238 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
240 FILE *pipefd = setup(fds, auclass);
241 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
242 /* Check the presence of queue ID and IPC_RMID in audit record */
243 snprintf(ipcregex, sizeof(ipcregex),
244 "msgctl.*IPC_RMID.*%d.*return,success", msqid);
245 check_audit(fds, ipcregex, pipefd);
248 ATF_TC_CLEANUP(msgctl_rmid_success, tc)
254 ATF_TC_WITH_CLEANUP(msgctl_rmid_failure);
255 ATF_TC_HEAD(msgctl_rmid_failure, tc)
257 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
258 "msgctl(2) call for IPC_RMID command");
261 ATF_TC_BODY(msgctl_rmid_failure, tc)
263 const char *regex = "msgctl.*IPC_RMID.*return,failur.*Invalid argument";
264 FILE *pipefd = setup(fds, auclass);
265 ATF_REQUIRE_EQ(-1, msgctl(-1, IPC_RMID, NULL));
266 check_audit(fds, regex, pipefd);
269 ATF_TC_CLEANUP(msgctl_rmid_failure, tc)
275 ATF_TC_WITH_CLEANUP(msgctl_stat_success);
276 ATF_TC_HEAD(msgctl_stat_success, tc)
278 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
279 "msgctl(2) call for IPC_STAT command");
282 ATF_TC_BODY(msgctl_stat_success, tc)
284 /* Create a message queue and obtain the corresponding identifier */
285 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
287 FILE *pipefd = setup(fds, auclass);
288 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_STAT, &msgbuff));
289 /* Check the presence of queue ID and IPC_STAT in audit record */
290 snprintf(ipcregex, sizeof(ipcregex),
291 "msgctl.*IPC_STAT.*%d.*return,success", msqid);
292 check_audit(fds, ipcregex, pipefd);
294 /* Destroy the message queue with ID = msqid */
295 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
298 ATF_TC_CLEANUP(msgctl_stat_success, tc)
304 ATF_TC_WITH_CLEANUP(msgctl_stat_failure);
305 ATF_TC_HEAD(msgctl_stat_failure, tc)
307 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
308 "msgctl(2) call for IPC_STAT command");
311 ATF_TC_BODY(msgctl_stat_failure, tc)
313 const char *regex = "msgctl.*IPC_STAT.*return,failur.*Invalid argument";
314 FILE *pipefd = setup(fds, auclass);
315 ATF_REQUIRE_EQ(-1, msgctl(-1, IPC_STAT, &msgbuff));
316 check_audit(fds, regex, pipefd);
319 ATF_TC_CLEANUP(msgctl_stat_failure, tc)
325 ATF_TC_WITH_CLEANUP(msgctl_set_success);
326 ATF_TC_HEAD(msgctl_set_success, tc)
328 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
329 "msgctl(2) call for IPC_SET command");
332 ATF_TC_BODY(msgctl_set_success, tc)
334 /* Create a message queue and obtain the corresponding identifier */
335 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
336 /* Fill up the msgbuff structure to be used with IPC_SET */
337 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_STAT, &msgbuff));
339 FILE *pipefd = setup(fds, auclass);
340 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_SET, &msgbuff));
341 /* Check the presence of message queue ID in audit record */
342 snprintf(ipcregex, sizeof(ipcregex),
343 "msgctl.*IPC_SET.*%d.*return,success", msqid);
344 check_audit(fds, ipcregex, pipefd);
346 /* Destroy the message queue with ID = msqid */
347 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
350 ATF_TC_CLEANUP(msgctl_set_success, tc)
356 ATF_TC_WITH_CLEANUP(msgctl_set_failure);
357 ATF_TC_HEAD(msgctl_set_failure, tc)
359 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
360 "msgctl(2) call for IPC_SET command");
363 ATF_TC_BODY(msgctl_set_failure, tc)
365 const char *regex = "msgctl.*IPC_SET.*return,failure.*Invalid argument";
366 FILE *pipefd = setup(fds, auclass);
367 ATF_REQUIRE_EQ(-1, msgctl(-1, IPC_SET, &msgbuff));
368 check_audit(fds, regex, pipefd);
371 ATF_TC_CLEANUP(msgctl_set_failure, tc)
377 ATF_TC_WITH_CLEANUP(msgctl_illegal_command);
378 ATF_TC_HEAD(msgctl_illegal_command, tc)
380 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
381 "msgctl(2) call for illegal cmd value");
384 ATF_TC_BODY(msgctl_illegal_command, tc)
386 /* Create a message queue and obtain the corresponding identifier */
387 ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1);
389 const char *regex = "msgctl.*illegal command.*failur.*Invalid argument";
390 FILE *pipefd = setup(fds, auclass);
391 ATF_REQUIRE_EQ(-1, msgctl(msqid, -1, &msgbuff));
392 check_audit(fds, regex, pipefd);
394 /* Destroy the message queue with ID = msqid */
395 ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL));
398 ATF_TC_CLEANUP(msgctl_illegal_command, tc)
404 ATF_TC_WITH_CLEANUP(shmget_success);
405 ATF_TC_HEAD(shmget_success, tc)
407 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
411 ATF_TC_BODY(shmget_success, tc)
413 FILE *pipefd = setup(fds, auclass);
415 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
416 /* Check the presence of shared memory ID in audit record */
417 snprintf(ipcregex, sizeof(ipcregex), "shmget.*ret.*success,%d", shmid);
418 check_audit(fds, ipcregex, pipefd);
420 /* Destroy the shared memory with ID = shmid */
421 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
424 ATF_TC_CLEANUP(shmget_success, tc)
430 ATF_TC_WITH_CLEANUP(shmget_failure);
431 ATF_TC_HEAD(shmget_failure, tc)
433 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
437 ATF_TC_BODY(shmget_failure, tc)
439 const char *regex = "shmget.*return,failure.*No such file or directory";
440 FILE *pipefd = setup(fds, auclass);
441 ATF_REQUIRE_EQ(-1, shmget((key_t)(-1), 0, 0));
442 check_audit(fds, regex, pipefd);
445 ATF_TC_CLEANUP(shmget_failure, tc)
451 ATF_TC_WITH_CLEANUP(shmat_success);
452 ATF_TC_HEAD(shmat_success, tc)
454 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
458 ATF_TC_BODY(shmat_success, tc)
461 /* Create a shared memory segment and obtain the identifier */
463 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
465 FILE *pipefd = setup(fds, auclass);
466 ATF_REQUIRE((intptr_t)(addr = shmat(shmid, NULL, 0)) != -1);
468 /* Check for shared memory ID and process address in record */
469 snprintf(ipcregex, sizeof(ipcregex), "shmat.*Shared Memory "
470 "IPC.*%d.*return,success", shmid);
471 check_audit(fds, ipcregex, pipefd);
473 /* Destroy the shared memory with ID = shmid */
474 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
477 ATF_TC_CLEANUP(shmat_success, tc)
483 ATF_TC_WITH_CLEANUP(shmat_failure);
484 ATF_TC_HEAD(shmat_failure, tc)
486 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
490 ATF_TC_BODY(shmat_failure, tc)
492 const char *regex = "shmat.*Shared Memory IPC.*return,failure";
493 FILE *pipefd = setup(fds, auclass);
494 ATF_REQUIRE_EQ(-1, (intptr_t)shmat(-1, NULL, 0));
495 check_audit(fds, regex, pipefd);
498 ATF_TC_CLEANUP(shmat_failure, tc)
504 ATF_TC_WITH_CLEANUP(shmdt_success);
505 ATF_TC_HEAD(shmdt_success, tc)
507 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
511 ATF_TC_BODY(shmdt_success, tc)
515 snprintf(ipcregex, sizeof(ipcregex), "shmdt.*%d.*return,success", pid);
517 /* Create a shared memory segment and obtain the identifier */
519 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
521 /* Attach the shared memory to calling process's address space */
522 ATF_REQUIRE((intptr_t)(addr = shmat(shmid, NULL, 0)) != -1);
524 FILE *pipefd = setup(fds, auclass);
525 ATF_REQUIRE_EQ(0, shmdt(addr));
526 check_audit(fds, ipcregex, pipefd);
528 /* Destroy the shared memory with ID = shmid */
529 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
532 ATF_TC_CLEANUP(shmdt_success, tc)
538 ATF_TC_WITH_CLEANUP(shmdt_failure);
539 ATF_TC_HEAD(shmdt_failure, tc)
541 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
545 ATF_TC_BODY(shmdt_failure, tc)
547 const char *regex = "shmdt.*return,failure : Invalid argument";
548 FILE *pipefd = setup(fds, auclass);
549 ATF_REQUIRE_EQ(-1, shmdt(NULL));
550 check_audit(fds, regex, pipefd);
553 ATF_TC_CLEANUP(shmdt_failure, tc)
559 ATF_TC_WITH_CLEANUP(shmctl_rmid_success);
560 ATF_TC_HEAD(shmctl_rmid_success, tc)
562 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
563 "shmctl(2) call for IPC_RMID command");
566 ATF_TC_BODY(shmctl_rmid_success, tc)
568 /* Create a shared memory segment and obtain the identifier */
570 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
572 FILE *pipefd = setup(fds, auclass);
573 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
574 /* Check the presence of shmid and IPC_RMID in audit record */
575 snprintf(ipcregex, sizeof(ipcregex),
576 "shmctl.*IPC_RMID.*%d.*return,success", shmid);
577 check_audit(fds, ipcregex, pipefd);
580 ATF_TC_CLEANUP(shmctl_rmid_success, tc)
586 ATF_TC_WITH_CLEANUP(shmctl_rmid_failure);
587 ATF_TC_HEAD(shmctl_rmid_failure, tc)
589 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
590 "shmctl(2) call for IPC_RMID command");
593 ATF_TC_BODY(shmctl_rmid_failure, tc)
595 const char *regex = "shmctl.*IPC_RMID.*return,fail.*Invalid argument";
596 FILE *pipefd = setup(fds, auclass);
597 ATF_REQUIRE_EQ(-1, shmctl(-1, IPC_RMID, NULL));
598 check_audit(fds, regex, pipefd);
601 ATF_TC_CLEANUP(shmctl_rmid_failure, tc)
607 ATF_TC_WITH_CLEANUP(shmctl_stat_success);
608 ATF_TC_HEAD(shmctl_stat_success, tc)
610 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
611 "shmctl(2) call for IPC_STAT command");
614 ATF_TC_BODY(shmctl_stat_success, tc)
616 /* Create a shared memory segment and obtain the identifier */
618 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
620 FILE *pipefd = setup(fds, auclass);
621 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_STAT, &shmbuff));
622 /* Check if shared memory ID and IPC_STAT are present in audit record */
623 snprintf(ipcregex, sizeof(ipcregex),
624 "shmctl.*IPC_STAT.*%d.*return,success", shmid);
625 check_audit(fds, ipcregex, pipefd);
627 /* Destroy the shared memory with ID = shmid */
628 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
631 ATF_TC_CLEANUP(shmctl_stat_success, tc)
637 ATF_TC_WITH_CLEANUP(shmctl_stat_failure);
638 ATF_TC_HEAD(shmctl_stat_failure, tc)
640 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
641 "shmctl(2) call for IPC_STAT command");
644 ATF_TC_BODY(shmctl_stat_failure, tc)
646 const char *regex = "shmctl.*IPC_STAT.*return,fail.*Invalid argument";
647 FILE *pipefd = setup(fds, auclass);
648 ATF_REQUIRE_EQ(-1, shmctl(-1, IPC_STAT, &shmbuff));
649 check_audit(fds, regex, pipefd);
652 ATF_TC_CLEANUP(shmctl_stat_failure, tc)
658 ATF_TC_WITH_CLEANUP(shmctl_set_success);
659 ATF_TC_HEAD(shmctl_set_success, tc)
661 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
662 "shmctl(2) call for IPC_SET command");
665 ATF_TC_BODY(shmctl_set_success, tc)
667 /* Create a shared memory segment and obtain the identifier */
669 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
670 /* Fill up the shmbuff structure to be used with IPC_SET */
671 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_STAT, &shmbuff));
673 FILE *pipefd = setup(fds, auclass);
674 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_SET, &shmbuff));
675 /* Check the presence of shared memory ID in audit record */
676 snprintf(ipcregex, sizeof(ipcregex),
677 "shmctl.*IPC_SET.*%d.*return,success", msqid);
678 check_audit(fds, ipcregex, pipefd);
680 /* Destroy the shared memory with ID = shmid */
681 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
684 ATF_TC_CLEANUP(shmctl_set_success, tc)
690 ATF_TC_WITH_CLEANUP(shmctl_set_failure);
691 ATF_TC_HEAD(shmctl_set_failure, tc)
693 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
694 "shmctl(2) call for IPC_SET command");
697 ATF_TC_BODY(shmctl_set_failure, tc)
699 const char *regex = "shmctl.*IPC_SET.*return,failure.*Invalid argument";
700 FILE *pipefd = setup(fds, auclass);
701 ATF_REQUIRE_EQ(-1, shmctl(-1, IPC_SET, &shmbuff));
702 check_audit(fds, regex, pipefd);
705 ATF_TC_CLEANUP(shmctl_set_failure, tc)
711 ATF_TC_WITH_CLEANUP(shmctl_illegal_command);
712 ATF_TC_HEAD(shmctl_illegal_command, tc)
714 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
715 "shmctl(2) call for illegal cmd value");
718 ATF_TC_BODY(shmctl_illegal_command, tc)
720 /* Create a shared memory segment and obtain the identifier */
722 shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
724 const char *regex = "shmctl.*illegal command.*fail.*Invalid argument";
725 FILE *pipefd = setup(fds, auclass);
726 ATF_REQUIRE_EQ(-1, shmctl(shmid, -1, &shmbuff));
727 check_audit(fds, regex, pipefd);
729 /* Destroy the shared memory with ID = shmid */
730 ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL));
733 ATF_TC_CLEANUP(shmctl_illegal_command, tc)
739 ATF_TC_WITH_CLEANUP(semget_success);
740 ATF_TC_HEAD(semget_success, tc)
742 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
746 ATF_TC_BODY(semget_success, tc)
748 FILE *pipefd = setup(fds, auclass);
750 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
752 /* Check the presence of semaphore set ID in audit record */
753 snprintf(ipcregex, sizeof(ipcregex),
754 "semget.*return,success,%d", semid);
755 check_audit(fds, ipcregex, pipefd);
757 /* Destroy the semaphore set with ID = semid */
758 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
761 ATF_TC_CLEANUP(semget_success, tc)
767 ATF_TC_WITH_CLEANUP(semget_failure);
768 ATF_TC_HEAD(semget_failure, tc)
770 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
774 ATF_TC_BODY(semget_failure, tc)
777 snprintf(ipcregex, sizeof(ipcregex), "semget.*%d.*return,failure", pid);
779 FILE *pipefd = setup(fds, auclass);
780 /* Failure reason: nsems is a negative number */
781 ATF_REQUIRE_EQ(-1, semget(IPC_PRIVATE, -1, 0));
782 check_audit(fds, ipcregex, pipefd);
785 ATF_TC_CLEANUP(semget_failure, tc)
791 ATF_TC_WITH_CLEANUP(semop_success);
792 ATF_TC_HEAD(semop_success, tc)
794 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
798 ATF_TC_BODY(semop_success, tc)
800 /* Create a semaphore set and obtain the set identifier */
802 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
804 /* Initialize a sembuf structure to operate on semaphore set */
805 struct sembuf sop[1] = {{0, 1, 0}};
806 /* Check the presence of semaphore set ID in audit record */
807 snprintf(ipcregex, sizeof(ipcregex),
808 "semop.*Semaphore IPC.*%d.*return,success", semid);
810 FILE *pipefd = setup(fds, auclass);
811 ATF_REQUIRE_EQ(0, semop(semid, sop, sizeof(sop)/sizeof(struct sembuf)));
812 check_audit(fds, ipcregex, pipefd);
814 /* Destroy the semaphore set with ID = semid */
815 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
818 ATF_TC_CLEANUP(semop_success, tc)
824 ATF_TC_WITH_CLEANUP(semop_failure);
825 ATF_TC_HEAD(semop_failure, tc)
827 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
831 ATF_TC_BODY(semop_failure, tc)
833 const char *regex = "semop.*0xffff.*return,failure : Invalid argument";
834 FILE *pipefd = setup(fds, auclass);
835 ATF_REQUIRE_EQ(-1, semop(-1, NULL, 0));
836 check_audit(fds, regex, pipefd);
839 ATF_TC_CLEANUP(semop_failure, tc)
845 ATF_TC_WITH_CLEANUP(semctl_getval_success);
846 ATF_TC_HEAD(semctl_getval_success, tc)
848 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
849 "semctl(2) call for GETVAL command");
852 ATF_TC_BODY(semctl_getval_success, tc)
854 /* Create a semaphore set and obtain the set identifier */
856 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
858 FILE *pipefd = setup(fds, auclass);
859 ATF_REQUIRE_EQ(0, semctl(semid, 0, GETVAL));
860 /* Check the presence of semaphore ID and GETVAL in audit record */
861 snprintf(ipcregex, sizeof(ipcregex),
862 "semctl.*GETVAL.*%d.*return,success", semid);
863 check_audit(fds, ipcregex, pipefd);
865 /* Destroy the semaphore set with ID = semid */
866 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
869 ATF_TC_CLEANUP(semctl_getval_success, tc)
875 ATF_TC_WITH_CLEANUP(semctl_getval_failure);
876 ATF_TC_HEAD(semctl_getval_failure, tc)
878 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
879 "semctl(2) call for GETVAL command");
882 ATF_TC_BODY(semctl_getval_failure, tc)
884 const char *regex = "semctl.*GETVAL.*return,failure : Invalid argument";
885 FILE *pipefd = setup(fds, auclass);
886 ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETVAL));
887 check_audit(fds, regex, pipefd);
890 ATF_TC_CLEANUP(semctl_getval_failure, tc)
896 ATF_TC_WITH_CLEANUP(semctl_setval_success);
897 ATF_TC_HEAD(semctl_setval_success, tc)
899 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
900 "semctl(2) call for SETVAL command");
903 ATF_TC_BODY(semctl_setval_success, tc)
905 /* Create a semaphore set and obtain the set identifier */
907 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
910 FILE *pipefd = setup(fds, auclass);
911 ATF_REQUIRE_EQ(0, semctl(semid, 0, SETVAL, semarg));
912 /* Check the presence of semaphore ID and SETVAL in audit record */
913 snprintf(ipcregex, sizeof(ipcregex),
914 "semctl.*SETVAL.*%d.*return,success", semid);
915 check_audit(fds, ipcregex, pipefd);
917 /* Destroy the semaphore set with ID = semid */
918 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
921 ATF_TC_CLEANUP(semctl_setval_success, tc)
927 ATF_TC_WITH_CLEANUP(semctl_setval_failure);
928 ATF_TC_HEAD(semctl_setval_failure, tc)
930 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
931 "semctl(2) call for SETVAL command");
934 ATF_TC_BODY(semctl_setval_failure, tc)
936 const char *regex = "semctl.*SETVAL.*return,failure : Invalid argument";
937 FILE *pipefd = setup(fds, auclass);
938 ATF_REQUIRE_EQ(-1, semctl(-1, 0, SETVAL, semarg));
939 check_audit(fds, regex, pipefd);
942 ATF_TC_CLEANUP(semctl_setval_failure, tc)
948 ATF_TC_WITH_CLEANUP(semctl_getpid_success);
949 ATF_TC_HEAD(semctl_getpid_success, tc)
951 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
952 "semctl(2) call for GETPID command");
955 ATF_TC_BODY(semctl_getpid_success, tc)
957 /* Create a semaphore set and obtain the set identifier */
959 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
961 FILE *pipefd = setup(fds, auclass);
962 ATF_REQUIRE_EQ(0, semctl(semid, 0, GETPID));
963 /* Check the presence of semaphore ID and GETVAL in audit record */
964 snprintf(ipcregex, sizeof(ipcregex),
965 "semctl.*GETPID.*%d.*return,success", semid);
966 check_audit(fds, ipcregex, pipefd);
968 /* Destroy the semaphore set with ID = semid */
969 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
972 ATF_TC_CLEANUP(semctl_getpid_success, tc)
978 ATF_TC_WITH_CLEANUP(semctl_getpid_failure);
979 ATF_TC_HEAD(semctl_getpid_failure, tc)
981 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
982 "semctl(2) call for GETPID command");
985 ATF_TC_BODY(semctl_getpid_failure, tc)
987 const char *regex = "semctl.*GETPID.*return,failure : Invalid argument";
988 FILE *pipefd = setup(fds, auclass);
989 ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETPID));
990 check_audit(fds, regex, pipefd);
993 ATF_TC_CLEANUP(semctl_getpid_failure, tc)
999 ATF_TC_WITH_CLEANUP(semctl_getncnt_success);
1000 ATF_TC_HEAD(semctl_getncnt_success, tc)
1002 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1003 "semctl(2) call for GETNCNT command");
1006 ATF_TC_BODY(semctl_getncnt_success, tc)
1008 /* Create a semaphore set and obtain the set identifier */
1009 ATF_REQUIRE((semid =
1010 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1012 FILE *pipefd = setup(fds, auclass);
1013 ATF_REQUIRE_EQ(0, semctl(semid, 0, GETNCNT));
1014 /* Check the presence of semaphore ID and GETNCNT in audit record */
1015 snprintf(ipcregex, sizeof(ipcregex),
1016 "semctl.*GETNCNT.*%d.*return,success", semid);
1017 check_audit(fds, ipcregex, pipefd);
1019 /* Destroy the semaphore set with ID = semid */
1020 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1023 ATF_TC_CLEANUP(semctl_getncnt_success, tc)
1029 ATF_TC_WITH_CLEANUP(semctl_getncnt_failure);
1030 ATF_TC_HEAD(semctl_getncnt_failure, tc)
1032 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1033 "semctl(2) call for GETNCNT command");
1036 ATF_TC_BODY(semctl_getncnt_failure, tc)
1038 const char *regex = "semctl.*GETNCNT.*return,failure.*Invalid argument";
1039 FILE *pipefd = setup(fds, auclass);
1040 ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETNCNT));
1041 check_audit(fds, regex, pipefd);
1044 ATF_TC_CLEANUP(semctl_getncnt_failure, tc)
1050 ATF_TC_WITH_CLEANUP(semctl_getzcnt_success);
1051 ATF_TC_HEAD(semctl_getzcnt_success, tc)
1053 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1054 "semctl(2) call for GETZCNT command");
1057 ATF_TC_BODY(semctl_getzcnt_success, tc)
1059 /* Create a semaphore set and obtain the set identifier */
1060 ATF_REQUIRE((semid =
1061 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1063 FILE *pipefd = setup(fds, auclass);
1064 ATF_REQUIRE_EQ(0, semctl(semid, 0, GETZCNT));
1065 /* Check the presence of semaphore ID and GETZCNT in audit record */
1066 snprintf(ipcregex, sizeof(ipcregex),
1067 "semctl.*GETZCNT.*%d.*return,success", semid);
1068 check_audit(fds, ipcregex, pipefd);
1070 /* Destroy the semaphore set with ID = semid */
1071 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1074 ATF_TC_CLEANUP(semctl_getzcnt_success, tc)
1080 ATF_TC_WITH_CLEANUP(semctl_getzcnt_failure);
1081 ATF_TC_HEAD(semctl_getzcnt_failure, tc)
1083 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1084 "semctl(2) call for GETZCNT command");
1087 ATF_TC_BODY(semctl_getzcnt_failure, tc)
1089 const char *regex = "semctl.*GETZCNT.*return,failure.*Invalid argument";
1090 FILE *pipefd = setup(fds, auclass);
1091 ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETZCNT));
1092 check_audit(fds, regex, pipefd);
1095 ATF_TC_CLEANUP(semctl_getzcnt_failure, tc)
1101 ATF_TC_WITH_CLEANUP(semctl_getall_success);
1102 ATF_TC_HEAD(semctl_getall_success, tc)
1104 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1105 "semctl(2) call for GETALL command");
1108 ATF_TC_BODY(semctl_getall_success, tc)
1110 /* Create a semaphore set and obtain the set identifier */
1111 ATF_REQUIRE((semid =
1112 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1114 semarg.array = semvals;
1115 FILE *pipefd = setup(fds, auclass);
1116 ATF_REQUIRE(semctl(semid, 0, GETALL, semarg) != -1);
1117 /* Check the presence of semaphore ID and GETALL in audit record */
1118 snprintf(ipcregex, sizeof(ipcregex),
1119 "semctl.*GETALL.*%d.*return,success", semid);
1120 check_audit(fds, ipcregex, pipefd);
1122 /* Destroy the semaphore set with ID = semid */
1123 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1126 ATF_TC_CLEANUP(semctl_getall_success, tc)
1132 ATF_TC_WITH_CLEANUP(semctl_getall_failure);
1133 ATF_TC_HEAD(semctl_getall_failure, tc)
1135 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1136 "semctl(2) call for GETALL command");
1139 ATF_TC_BODY(semctl_getall_failure, tc)
1141 const char *regex = "semctl.*GETALL.*return,failure : Invalid argument";
1142 FILE *pipefd = setup(fds, auclass);
1143 ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETALL, semarg));
1144 check_audit(fds, regex, pipefd);
1147 ATF_TC_CLEANUP(semctl_getall_failure, tc)
1153 ATF_TC_WITH_CLEANUP(semctl_setall_success);
1154 ATF_TC_HEAD(semctl_setall_success, tc)
1156 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1157 "semctl(2) call for SETALL command");
1160 ATF_TC_BODY(semctl_setall_success, tc)
1162 /* Create a semaphore set and obtain the set identifier */
1163 ATF_REQUIRE((semid =
1164 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1166 semarg.array = semvals;
1167 /* Initialize semvals to be used with SETALL */
1168 ATF_REQUIRE(semctl(semid, 0, GETALL, semarg) != -1);
1170 FILE *pipefd = setup(fds, auclass);
1171 ATF_REQUIRE_EQ(0, semctl(semid, 0, SETALL, semarg));
1172 /* Check the presence of semaphore ID and SETALL in audit record */
1173 snprintf(ipcregex, sizeof(ipcregex),
1174 "semctl.*SETALL.*%d.*return,success", semid);
1175 check_audit(fds, ipcregex, pipefd);
1177 /* Destroy the semaphore set with ID = semid */
1178 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1181 ATF_TC_CLEANUP(semctl_setall_success, tc)
1187 ATF_TC_WITH_CLEANUP(semctl_setall_failure);
1188 ATF_TC_HEAD(semctl_setall_failure, tc)
1190 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1191 "semctl(2) call for SETALL command");
1194 ATF_TC_BODY(semctl_setall_failure, tc)
1196 const char *regex = "semctl.*SETALL.*return,failure : Invalid argument";
1197 FILE *pipefd = setup(fds, auclass);
1198 ATF_REQUIRE_EQ(-1, semctl(-1, 0, SETALL, semarg));
1199 check_audit(fds, regex, pipefd);
1202 ATF_TC_CLEANUP(semctl_setall_failure, tc)
1208 ATF_TC_WITH_CLEANUP(semctl_stat_success);
1209 ATF_TC_HEAD(semctl_stat_success, tc)
1211 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1212 "semctl(2) call for IPC_STAT command");
1215 ATF_TC_BODY(semctl_stat_success, tc)
1217 /* Create a semaphore set and obtain the set identifier */
1218 ATF_REQUIRE((semid =
1219 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1221 semarg.buf = &sembuff;
1222 FILE *pipefd = setup(fds, auclass);
1223 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_STAT, semarg));
1224 /* Check the presence of semaphore ID and IPC_STAT in audit record */
1225 snprintf(ipcregex, sizeof(ipcregex),
1226 "semctl.*IPC_STAT.*%d.*return,success", semid);
1227 check_audit(fds, ipcregex, pipefd);
1229 /* Destroy the semaphore set with ID = semid */
1230 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1233 ATF_TC_CLEANUP(semctl_stat_success, tc)
1239 ATF_TC_WITH_CLEANUP(semctl_stat_failure);
1240 ATF_TC_HEAD(semctl_stat_failure, tc)
1242 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1243 "semctl(2) call for IPC_STAT command");
1246 ATF_TC_BODY(semctl_stat_failure, tc)
1248 const char *regex = "semctl.*IPC_STAT.*return,fail.*Invalid argument";
1249 FILE *pipefd = setup(fds, auclass);
1250 ATF_REQUIRE_EQ(-1, semctl(-1, 0, IPC_STAT, semarg));
1251 check_audit(fds, regex, pipefd);
1254 ATF_TC_CLEANUP(semctl_stat_failure, tc)
1260 ATF_TC_WITH_CLEANUP(semctl_set_success);
1261 ATF_TC_HEAD(semctl_set_success, tc)
1263 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1264 "semctl(2) call for IPC_SET command");
1267 ATF_TC_BODY(semctl_set_success, tc)
1269 /* Create a semaphore set and obtain the set identifier */
1270 ATF_REQUIRE((semid =
1271 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1273 semarg.buf = &sembuff;
1274 /* Fill up the sembuff structure to be used with IPC_SET */
1275 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_STAT, semarg));
1277 FILE *pipefd = setup(fds, auclass);
1278 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_SET, semarg));
1279 /* Check the presence of semaphore ID and IPC_SET in audit record */
1280 snprintf(ipcregex, sizeof(ipcregex),
1281 "semctl.*IPC_SET.*%d.*return,success", semid);
1282 check_audit(fds, ipcregex, pipefd);
1284 /* Destroy the semaphore set with ID = semid */
1285 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1288 ATF_TC_CLEANUP(semctl_set_success, tc)
1294 ATF_TC_WITH_CLEANUP(semctl_set_failure);
1295 ATF_TC_HEAD(semctl_set_failure, tc)
1297 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1298 "semctl(2) call for IPC_SET command");
1301 ATF_TC_BODY(semctl_set_failure, tc)
1303 /* Create a semaphore set and obtain the set identifier */
1304 ATF_REQUIRE((semid =
1305 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1307 semarg.buf = &sembuff;
1308 /* Fill up the sembuff structure to be used with IPC_SET */
1309 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_STAT, semarg));
1311 const char *regex = "semctl.*IPC_SET.*return,failure.*Invalid argument";
1312 FILE *pipefd = setup(fds, auclass);
1313 ATF_REQUIRE_EQ(-1, semctl(-1, 0, IPC_SET, semarg));
1314 check_audit(fds, regex, pipefd);
1316 /* Destroy the semaphore set with ID = semid */
1317 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1320 ATF_TC_CLEANUP(semctl_set_failure, tc)
1326 ATF_TC_WITH_CLEANUP(semctl_rmid_success);
1327 ATF_TC_HEAD(semctl_rmid_success, tc)
1329 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1330 "semctl(2) call for IPC_RMID command");
1333 ATF_TC_BODY(semctl_rmid_success, tc)
1335 /* Create a semaphore set and obtain the set identifier */
1336 ATF_REQUIRE((semid =
1337 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1339 FILE *pipefd = setup(fds, auclass);
1340 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID, semarg));
1341 /* Check the presence of semaphore ID and IPC_RMID in audit record */
1342 snprintf(ipcregex, sizeof(ipcregex),
1343 "semctl.*IPC_RMID.*%d.*return,success", semid);
1344 check_audit(fds, ipcregex, pipefd);
1347 ATF_TC_CLEANUP(semctl_rmid_success, tc)
1353 ATF_TC_WITH_CLEANUP(semctl_rmid_failure);
1354 ATF_TC_HEAD(semctl_rmid_failure, tc)
1356 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1357 "semctl(2) call for IPC_RMID command");
1360 ATF_TC_BODY(semctl_rmid_failure, tc)
1362 const char *regex = "semctl.*IPC_RMID.*return,fail.*Invalid argument";
1363 FILE *pipefd = setup(fds, auclass);
1364 ATF_REQUIRE_EQ(-1, semctl(-1, 0, IPC_RMID, semarg));
1365 check_audit(fds, regex, pipefd);
1368 ATF_TC_CLEANUP(semctl_rmid_failure, tc)
1374 ATF_TC_WITH_CLEANUP(semctl_illegal_command);
1375 ATF_TC_HEAD(semctl_illegal_command, tc)
1377 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1378 "semctl(2) call for illegal cmd value");
1381 ATF_TC_BODY(semctl_illegal_command, tc)
1383 /* Create a semaphore set and obtain the set identifier */
1384 ATF_REQUIRE((semid =
1385 semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1);
1387 const char *regex = "semctl.*illegal command.*fail.*Invalid argument";
1388 FILE *pipefd = setup(fds, auclass);
1389 ATF_REQUIRE_EQ(-1, semctl(semid, 0, -1));
1390 check_audit(fds, regex, pipefd);
1392 /* Destroy the semaphore set with ID = semid */
1393 ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID));
1396 ATF_TC_CLEANUP(semctl_illegal_command, tc)
1402 ATF_TC_WITH_CLEANUP(shm_open_success);
1403 ATF_TC_HEAD(shm_open_success, tc)
1405 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1406 "shm_open(2) call");
1409 ATF_TC_BODY(shm_open_success, tc)
1412 snprintf(ipcregex, sizeof(ipcregex), "shm_open.*%d.*ret.*success", pid);
1414 FILE *pipefd = setup(fds, auclass);
1415 ATF_REQUIRE(shm_open(SHM_ANON, O_CREAT | O_TRUNC | O_RDWR, 0600) != -1);
1416 check_audit(fds, ipcregex, pipefd);
1419 ATF_TC_CLEANUP(shm_open_success, tc)
1425 ATF_TC_WITH_CLEANUP(shm_open_failure);
1426 ATF_TC_HEAD(shm_open_failure, tc)
1428 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1429 "shm_open(2) call");
1432 ATF_TC_BODY(shm_open_failure, tc)
1434 const char *regex = "shm_open.*fileforaudit.*return,failure";
1435 FILE *pipefd = setup(fds, auclass);
1436 /* Failure reason: File does not exist */
1437 ATF_REQUIRE_EQ(-1, shm_open(path, O_TRUNC | O_RDWR, 0600));
1438 check_audit(fds, regex, pipefd);
1441 ATF_TC_CLEANUP(shm_open_failure, tc)
1447 ATF_TC_WITH_CLEANUP(shm_unlink_success);
1448 ATF_TC_HEAD(shm_unlink_success, tc)
1450 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1451 "shm_unlink(2) call");
1454 ATF_TC_BODY(shm_unlink_success, tc)
1456 /* Build an absolute path to a file in the test-case directory */
1458 ATF_REQUIRE(getcwd(dirpath, sizeof(dirpath)) != NULL);
1459 strlcat(dirpath, path, sizeof(dirpath));
1460 ATF_REQUIRE(shm_open(dirpath, O_CREAT | O_TRUNC | O_RDWR, 0600) != -1);
1462 const char *regex = "shm_unlink.*fileforaudit.*return,success";
1463 FILE *pipefd = setup(fds, auclass);
1464 ATF_REQUIRE_EQ(0, shm_unlink(dirpath));
1465 check_audit(fds, regex, pipefd);
1468 ATF_TC_CLEANUP(shm_unlink_success, tc)
1474 ATF_TC_WITH_CLEANUP(shm_unlink_failure);
1475 ATF_TC_HEAD(shm_unlink_failure, tc)
1477 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1478 "shm_unlink(2) call");
1481 ATF_TC_BODY(shm_unlink_failure, tc)
1483 const char *regex = "shm_unlink.*fileforaudit.*return,failure";
1484 FILE *pipefd = setup(fds, auclass);
1485 ATF_REQUIRE_EQ(-1, shm_unlink(path));
1486 check_audit(fds, regex, pipefd);
1489 ATF_TC_CLEANUP(shm_unlink_failure, tc)
1495 ATF_TC_WITH_CLEANUP(pipe_success);
1496 ATF_TC_HEAD(pipe_success, tc)
1498 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1502 ATF_TC_BODY(pipe_success, tc)
1506 snprintf(ipcregex, sizeof(ipcregex), "pipe.*%d.*return,success", pid);
1507 FILE *pipefd = setup(fds, auclass);
1508 ATF_REQUIRE_EQ(0, pipe(filedesc));
1509 check_audit(fds, ipcregex, pipefd);
1515 ATF_TC_CLEANUP(pipe_success, tc)
1521 ATF_TC_WITH_CLEANUP(pipe_failure);
1522 ATF_TC_HEAD(pipe_failure, tc)
1524 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1528 ATF_TC_BODY(pipe_failure, tc)
1531 snprintf(ipcregex, sizeof(ipcregex), "pipe.*%d.*return.failure", pid);
1533 FILE *pipefd = setup(fds, auclass);
1534 ATF_REQUIRE_EQ(-1, pipe(NULL));
1535 check_audit(fds, ipcregex, pipefd);
1538 ATF_TC_CLEANUP(pipe_failure, tc)
1544 ATF_TC_WITH_CLEANUP(posix_openpt_success);
1545 ATF_TC_HEAD(posix_openpt_success, tc)
1547 atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
1548 "posix_openpt(2) call");
1551 ATF_TC_BODY(posix_openpt_success, tc)
1554 FILE *pipefd = setup(fds, auclass);
1555 ATF_REQUIRE((filedesc = posix_openpt(O_RDWR | O_NOCTTY)) != -1);
1556 /* Check for the presence of filedesc in the audit record */
1557 snprintf(ipcregex, sizeof(ipcregex),
1558 "posix_openpt.*return,success,%d", filedesc);
1559 check_audit(fds, ipcregex, pipefd);
1563 ATF_TC_CLEANUP(posix_openpt_success, tc)
1569 ATF_TC_WITH_CLEANUP(posix_openpt_failure);
1570 ATF_TC_HEAD(posix_openpt_failure, tc)
1572 atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
1573 "posix_openpt(2) call");
1576 ATF_TC_BODY(posix_openpt_failure, tc)
1578 const char *regex = "posix_openpt.*return,failure : Invalid argument";
1579 FILE *pipefd = setup(fds, auclass);
1580 ATF_REQUIRE_EQ(-1, posix_openpt(-1));
1581 check_audit(fds, regex, pipefd);
1584 ATF_TC_CLEANUP(posix_openpt_failure, tc)
1592 ATF_TP_ADD_TC(tp, msgget_success);
1593 ATF_TP_ADD_TC(tp, msgget_failure);
1594 ATF_TP_ADD_TC(tp, msgsnd_success);
1595 ATF_TP_ADD_TC(tp, msgsnd_failure);
1596 ATF_TP_ADD_TC(tp, msgrcv_success);
1597 ATF_TP_ADD_TC(tp, msgrcv_failure);
1599 ATF_TP_ADD_TC(tp, msgctl_rmid_success);
1600 ATF_TP_ADD_TC(tp, msgctl_rmid_failure);
1601 ATF_TP_ADD_TC(tp, msgctl_stat_success);
1602 ATF_TP_ADD_TC(tp, msgctl_stat_failure);
1603 ATF_TP_ADD_TC(tp, msgctl_set_success);
1604 ATF_TP_ADD_TC(tp, msgctl_set_failure);
1605 ATF_TP_ADD_TC(tp, msgctl_illegal_command);
1607 ATF_TP_ADD_TC(tp, shmget_success);
1608 ATF_TP_ADD_TC(tp, shmget_failure);
1609 ATF_TP_ADD_TC(tp, shmat_success);
1610 ATF_TP_ADD_TC(tp, shmat_failure);
1611 ATF_TP_ADD_TC(tp, shmdt_success);
1612 ATF_TP_ADD_TC(tp, shmdt_failure);
1614 ATF_TP_ADD_TC(tp, shmctl_rmid_success);
1615 ATF_TP_ADD_TC(tp, shmctl_rmid_failure);
1616 ATF_TP_ADD_TC(tp, shmctl_stat_success);
1617 ATF_TP_ADD_TC(tp, shmctl_stat_failure);
1618 ATF_TP_ADD_TC(tp, shmctl_set_success);
1619 ATF_TP_ADD_TC(tp, shmctl_set_failure);
1620 ATF_TP_ADD_TC(tp, shmctl_illegal_command);
1622 ATF_TP_ADD_TC(tp, semget_success);
1623 ATF_TP_ADD_TC(tp, semget_failure);
1624 ATF_TP_ADD_TC(tp, semop_success);
1625 ATF_TP_ADD_TC(tp, semop_failure);
1627 ATF_TP_ADD_TC(tp, semctl_getval_success);
1628 ATF_TP_ADD_TC(tp, semctl_getval_failure);
1629 ATF_TP_ADD_TC(tp, semctl_setval_success);
1630 ATF_TP_ADD_TC(tp, semctl_setval_failure);
1631 ATF_TP_ADD_TC(tp, semctl_getpid_success);
1632 ATF_TP_ADD_TC(tp, semctl_getpid_failure);
1633 ATF_TP_ADD_TC(tp, semctl_getncnt_success);
1634 ATF_TP_ADD_TC(tp, semctl_getncnt_failure);
1635 ATF_TP_ADD_TC(tp, semctl_getzcnt_success);
1636 ATF_TP_ADD_TC(tp, semctl_getzcnt_failure);
1637 ATF_TP_ADD_TC(tp, semctl_getall_success);
1638 ATF_TP_ADD_TC(tp, semctl_getall_failure);
1639 ATF_TP_ADD_TC(tp, semctl_setall_success);
1640 ATF_TP_ADD_TC(tp, semctl_setall_failure);
1641 ATF_TP_ADD_TC(tp, semctl_stat_success);
1642 ATF_TP_ADD_TC(tp, semctl_stat_failure);
1643 ATF_TP_ADD_TC(tp, semctl_set_success);
1644 ATF_TP_ADD_TC(tp, semctl_set_failure);
1645 ATF_TP_ADD_TC(tp, semctl_rmid_success);
1646 ATF_TP_ADD_TC(tp, semctl_rmid_failure);
1647 ATF_TP_ADD_TC(tp, semctl_illegal_command);
1649 ATF_TP_ADD_TC(tp, shm_open_success);
1650 ATF_TP_ADD_TC(tp, shm_open_failure);
1651 ATF_TP_ADD_TC(tp, shm_unlink_success);
1652 ATF_TP_ADD_TC(tp, shm_unlink_failure);
1654 ATF_TP_ADD_TC(tp, pipe_success);
1655 ATF_TP_ADD_TC(tp, pipe_failure);
1656 ATF_TP_ADD_TC(tp, posix_openpt_success);
1657 ATF_TP_ADD_TC(tp, posix_openpt_failure);
1659 return (atf_no_error());