diff options
Diffstat (limited to 'tests/sys/audit/inter-process.c')
| -rw-r--r-- | tests/sys/audit/inter-process.c | 1658 |
1 files changed, 1658 insertions, 0 deletions
diff --git a/tests/sys/audit/inter-process.c b/tests/sys/audit/inter-process.c new file mode 100644 index 000000000000..4912da43fe95 --- /dev/null +++ b/tests/sys/audit/inter-process.c @@ -0,0 +1,1658 @@ +/*- + * Copyright (c) 2018 Aniket Pandey + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * SUCH DAMAGE. + */ + +#include <sys/types.h> +#include <sys/ipc.h> +#include <sys/mman.h> +#include <sys/msg.h> +#include <sys/shm.h> +#define _WANT_SEMUN +#include <sys/sem.h> +#include <sys/stat.h> + +#include <atf-c.h> +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> + +#include "utils.h" +#define BUFFSIZE 80 + +struct msgstr { + long int mtype; + char mtext[BUFFSIZE]; +}; +typedef struct msgstr msgstr_t; + +static pid_t pid; +static int msqid, shmid, semid; +static union semun semarg; +static struct pollfd fds[1]; +static struct msqid_ds msgbuff; +static struct shmid_ds shmbuff; +static struct semid_ds sembuff; +static char ipcregex[BUFFSIZE]; +static const char *auclass = "ip"; +static char path[BUFFSIZE] = "/fileforaudit"; +static unsigned short semvals[BUFFSIZE]; + + +ATF_TC_WITH_CLEANUP(msgget_success); +ATF_TC_HEAD(msgget_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "msgget(2) call"); +} + +ATF_TC_BODY(msgget_success, tc) +{ + FILE *pipefd = setup(fds, auclass); + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + /* Check the presence of message queue ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "msgget.*return,success,%d", msqid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the message queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(msgget_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgget_failure); +ATF_TC_HEAD(msgget_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgget(2) call"); +} + +ATF_TC_BODY(msgget_failure, tc) +{ + const char *regex = "msgget.*return,failure.*No such file or directory"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgget((key_t)(-1), 0)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(msgget_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgsnd_success); +ATF_TC_HEAD(msgsnd_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "msgsnd(2) call"); +} + +ATF_TC_BODY(msgsnd_success, tc) +{ + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + + /* Initialize a msgstr_t structure to store message */ + msgstr_t msg; + msg.mtype = 1; + memset(msg.mtext, 0, BUFFSIZE); + + /* Check the presence of message queue ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "msgsnd.*Message IPC.*%d.*return,success", msqid); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, msgsnd(msqid, &msg, BUFFSIZE, IPC_NOWAIT)); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the message queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(msgsnd_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgsnd_failure); +ATF_TC_HEAD(msgsnd_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgsnd(2) call"); +} + +ATF_TC_BODY(msgsnd_failure, tc) +{ + const char *regex = "msgsnd.*Message IPC.*return,failure : Bad address"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgsnd(-1, NULL, 0, IPC_NOWAIT)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(msgsnd_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgrcv_success); +ATF_TC_HEAD(msgrcv_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "msgrcv(2) call"); +} + +ATF_TC_BODY(msgrcv_success, tc) +{ + ssize_t recv_bytes; + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + + /* Initialize two msgstr_t structures to store respective messages */ + msgstr_t msg1, msg2; + msg1.mtype = 1; + memset(msg1.mtext, 0, BUFFSIZE); + + /* Send a message to the queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgsnd(msqid, &msg1, BUFFSIZE, IPC_NOWAIT)); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE((recv_bytes = msgrcv(msqid, &msg2, + BUFFSIZE, 0, MSG_NOERROR | IPC_NOWAIT)) != -1); + /* Check the presence of queue ID and returned bytes in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "msgrcv.*Message IPC,*%d.*return,success,%zd", msqid, recv_bytes); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the message queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(msgrcv_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgrcv_failure); +ATF_TC_HEAD(msgrcv_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgrcv(2) call"); +} + +ATF_TC_BODY(msgrcv_failure, tc) +{ + const char *regex = "msgrcv.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgrcv(-1, NULL, 0, 0, MSG_NOERROR | IPC_NOWAIT)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(msgrcv_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_rmid_success); +ATF_TC_HEAD(msgctl_rmid_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "msgctl(2) call for IPC_RMID command"); +} + +ATF_TC_BODY(msgctl_rmid_success, tc) +{ + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); + /* Check the presence of queue ID and IPC_RMID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "msgctl.*IPC_RMID.*%d.*return,success", msqid); + check_audit(fds, ipcregex, pipefd); +} + +ATF_TC_CLEANUP(msgctl_rmid_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_rmid_failure); +ATF_TC_HEAD(msgctl_rmid_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgctl(2) call for IPC_RMID command"); +} + +ATF_TC_BODY(msgctl_rmid_failure, tc) +{ + const char *regex = "msgctl.*IPC_RMID.*return,failur.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgctl(-1, IPC_RMID, NULL)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(msgctl_rmid_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_stat_success); +ATF_TC_HEAD(msgctl_stat_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "msgctl(2) call for IPC_STAT command"); +} + +ATF_TC_BODY(msgctl_stat_success, tc) +{ + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_STAT, &msgbuff)); + /* Check the presence of queue ID and IPC_STAT in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "msgctl.*IPC_STAT.*%d.*return,success", msqid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the message queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(msgctl_stat_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_stat_failure); +ATF_TC_HEAD(msgctl_stat_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgctl(2) call for IPC_STAT command"); +} + +ATF_TC_BODY(msgctl_stat_failure, tc) +{ + const char *regex = "msgctl.*IPC_STAT.*return,failur.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgctl(-1, IPC_STAT, &msgbuff)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(msgctl_stat_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_set_success); +ATF_TC_HEAD(msgctl_set_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "msgctl(2) call for IPC_SET command"); +} + +ATF_TC_BODY(msgctl_set_success, tc) +{ + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + /* Fill up the msgbuff structure to be used with IPC_SET */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_STAT, &msgbuff)); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_SET, &msgbuff)); + /* Check the presence of message queue ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "msgctl.*IPC_SET.*%d.*return,success", msqid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the message queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(msgctl_set_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_set_failure); +ATF_TC_HEAD(msgctl_set_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgctl(2) call for IPC_SET command"); +} + +ATF_TC_BODY(msgctl_set_failure, tc) +{ + const char *regex = "msgctl.*IPC_SET.*return,failure.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgctl(-1, IPC_SET, &msgbuff)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(msgctl_set_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(msgctl_illegal_command); +ATF_TC_HEAD(msgctl_illegal_command, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "msgctl(2) call for illegal cmd value"); +} + +ATF_TC_BODY(msgctl_illegal_command, tc) +{ + /* Create a message queue and obtain the corresponding identifier */ + ATF_REQUIRE((msqid = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR)) != -1); + + const char *regex = "msgctl.*illegal command.*failur.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, msgctl(msqid, -1, &msgbuff)); + check_audit(fds, regex, pipefd); + + /* Destroy the message queue with ID = msqid */ + ATF_REQUIRE_EQ(0, msgctl(msqid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(msgctl_illegal_command, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmget_success); +ATF_TC_HEAD(shmget_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shmget(2) call"); +} + +ATF_TC_BODY(shmget_success, tc) +{ + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + /* Check the presence of shared memory ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), "shmget.*ret.*success,%d", shmid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the shared memory with ID = shmid */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(shmget_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmget_failure); +ATF_TC_HEAD(shmget_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmget(2) call"); +} + +ATF_TC_BODY(shmget_failure, tc) +{ + const char *regex = "shmget.*return,failure.*No such file or directory"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shmget((key_t)(-1), 0, 0)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shmget_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmat_success); +ATF_TC_HEAD(shmat_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shmat(2) call"); +} + +ATF_TC_BODY(shmat_success, tc) +{ + void *addr; + /* Create a shared memory segment and obtain the identifier */ + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE((intptr_t)(addr = shmat(shmid, NULL, 0)) != -1); + + /* Check for shared memory ID and process address in record */ + snprintf(ipcregex, sizeof(ipcregex), "shmat.*Shared Memory " + "IPC.*%d.*return,success", shmid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the shared memory with ID = shmid */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(shmat_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmat_failure); +ATF_TC_HEAD(shmat_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmat(2) call"); +} + +ATF_TC_BODY(shmat_failure, tc) +{ + const char *regex = "shmat.*Shared Memory IPC.*return,failure"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, (intptr_t)shmat(-1, NULL, 0)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shmat_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmdt_success); +ATF_TC_HEAD(shmdt_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shmdt(2) call"); +} + +ATF_TC_BODY(shmdt_success, tc) +{ + void *addr; + pid = getpid(); + snprintf(ipcregex, sizeof(ipcregex), "shmdt.*%d.*return,success", pid); + + /* Create a shared memory segment and obtain the identifier */ + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + /* Attach the shared memory to calling process's address space */ + ATF_REQUIRE((intptr_t)(addr = shmat(shmid, NULL, 0)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, shmdt(addr)); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the shared memory with ID = shmid */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(shmdt_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmdt_failure); +ATF_TC_HEAD(shmdt_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmdt(2) call"); +} + +ATF_TC_BODY(shmdt_failure, tc) +{ + const char *regex = "shmdt.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shmdt(NULL)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shmdt_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_rmid_success); +ATF_TC_HEAD(shmctl_rmid_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shmctl(2) call for IPC_RMID command"); +} + +ATF_TC_BODY(shmctl_rmid_success, tc) +{ + /* Create a shared memory segment and obtain the identifier */ + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); + /* Check the presence of shmid and IPC_RMID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "shmctl.*IPC_RMID.*%d.*return,success", shmid); + check_audit(fds, ipcregex, pipefd); +} + +ATF_TC_CLEANUP(shmctl_rmid_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_rmid_failure); +ATF_TC_HEAD(shmctl_rmid_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmctl(2) call for IPC_RMID command"); +} + +ATF_TC_BODY(shmctl_rmid_failure, tc) +{ + const char *regex = "shmctl.*IPC_RMID.*return,fail.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shmctl(-1, IPC_RMID, NULL)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shmctl_rmid_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_stat_success); +ATF_TC_HEAD(shmctl_stat_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shmctl(2) call for IPC_STAT command"); +} + +ATF_TC_BODY(shmctl_stat_success, tc) +{ + /* Create a shared memory segment and obtain the identifier */ + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_STAT, &shmbuff)); + /* Check if shared memory ID and IPC_STAT are present in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "shmctl.*IPC_STAT.*%d.*return,success", shmid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the shared memory with ID = shmid */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(shmctl_stat_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_stat_failure); +ATF_TC_HEAD(shmctl_stat_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmctl(2) call for IPC_STAT command"); +} + +ATF_TC_BODY(shmctl_stat_failure, tc) +{ + const char *regex = "shmctl.*IPC_STAT.*return,fail.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shmctl(-1, IPC_STAT, &shmbuff)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shmctl_stat_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_set_success); +ATF_TC_HEAD(shmctl_set_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shmctl(2) call for IPC_SET command"); +} + +ATF_TC_BODY(shmctl_set_success, tc) +{ + /* Create a shared memory segment and obtain the identifier */ + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + /* Fill up the shmbuff structure to be used with IPC_SET */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_STAT, &shmbuff)); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_SET, &shmbuff)); + /* Check the presence of shared memory ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "shmctl.*IPC_SET.*%d.*return,success", msqid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the shared memory with ID = shmid */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(shmctl_set_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_set_failure); +ATF_TC_HEAD(shmctl_set_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmctl(2) call for IPC_SET command"); +} + +ATF_TC_BODY(shmctl_set_failure, tc) +{ + const char *regex = "shmctl.*IPC_SET.*return,failure.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shmctl(-1, IPC_SET, &shmbuff)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shmctl_set_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shmctl_illegal_command); +ATF_TC_HEAD(shmctl_illegal_command, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shmctl(2) call for illegal cmd value"); +} + +ATF_TC_BODY(shmctl_illegal_command, tc) +{ + /* Create a shared memory segment and obtain the identifier */ + ATF_REQUIRE((shmid = + shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + const char *regex = "shmctl.*illegal command.*fail.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shmctl(shmid, -1, &shmbuff)); + check_audit(fds, regex, pipefd); + + /* Destroy the shared memory with ID = shmid */ + ATF_REQUIRE_EQ(0, shmctl(shmid, IPC_RMID, NULL)); +} + +ATF_TC_CLEANUP(shmctl_illegal_command, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semget_success); +ATF_TC_HEAD(semget_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semget(2) call"); +} + +ATF_TC_BODY(semget_success, tc) +{ + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + /* Check the presence of semaphore set ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semget.*return,success,%d", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semget_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semget_failure); +ATF_TC_HEAD(semget_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semget(2) call"); +} + +ATF_TC_BODY(semget_failure, tc) +{ + pid = getpid(); + snprintf(ipcregex, sizeof(ipcregex), "semget.*%d.*return,failure", pid); + + FILE *pipefd = setup(fds, auclass); + /* Failure reason: nsems is a negative number */ + ATF_REQUIRE_EQ(-1, semget(IPC_PRIVATE, -1, 0)); + check_audit(fds, ipcregex, pipefd); +} + +ATF_TC_CLEANUP(semget_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semop_success); +ATF_TC_HEAD(semop_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semop(2) call"); +} + +ATF_TC_BODY(semop_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + /* Initialize a sembuf structure to operate on semaphore set */ + struct sembuf sop[1] = {{0, 1, 0}}; + /* Check the presence of semaphore set ID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semop.*Semaphore IPC.*%d.*return,success", semid); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semop(semid, sop, sizeof(sop)/sizeof(struct sembuf))); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semop_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semop_failure); +ATF_TC_HEAD(semop_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semop(2) call"); +} + +ATF_TC_BODY(semop_failure, tc) +{ + const char *regex = "semop.*0xffff.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semop(-1, NULL, 0)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semop_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getval_success); +ATF_TC_HEAD(semctl_getval_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for GETVAL command"); +} + +ATF_TC_BODY(semctl_getval_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, GETVAL)); + /* Check the presence of semaphore ID and GETVAL in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*GETVAL.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_getval_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getval_failure); +ATF_TC_HEAD(semctl_getval_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for GETVAL command"); +} + +ATF_TC_BODY(semctl_getval_failure, tc) +{ + const char *regex = "semctl.*GETVAL.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETVAL)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_getval_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_setval_success); +ATF_TC_HEAD(semctl_setval_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for SETVAL command"); +} + +ATF_TC_BODY(semctl_setval_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + semarg.val = 1; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, SETVAL, semarg)); + /* Check the presence of semaphore ID and SETVAL in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*SETVAL.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_setval_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_setval_failure); +ATF_TC_HEAD(semctl_setval_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for SETVAL command"); +} + +ATF_TC_BODY(semctl_setval_failure, tc) +{ + const char *regex = "semctl.*SETVAL.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, SETVAL, semarg)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_setval_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getpid_success); +ATF_TC_HEAD(semctl_getpid_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for GETPID command"); +} + +ATF_TC_BODY(semctl_getpid_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, GETPID)); + /* Check the presence of semaphore ID and GETVAL in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*GETPID.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_getpid_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getpid_failure); +ATF_TC_HEAD(semctl_getpid_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for GETPID command"); +} + +ATF_TC_BODY(semctl_getpid_failure, tc) +{ + const char *regex = "semctl.*GETPID.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETPID)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_getpid_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getncnt_success); +ATF_TC_HEAD(semctl_getncnt_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for GETNCNT command"); +} + +ATF_TC_BODY(semctl_getncnt_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, GETNCNT)); + /* Check the presence of semaphore ID and GETNCNT in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*GETNCNT.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_getncnt_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getncnt_failure); +ATF_TC_HEAD(semctl_getncnt_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for GETNCNT command"); +} + +ATF_TC_BODY(semctl_getncnt_failure, tc) +{ + const char *regex = "semctl.*GETNCNT.*return,failure.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETNCNT)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_getncnt_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getzcnt_success); +ATF_TC_HEAD(semctl_getzcnt_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for GETZCNT command"); +} + +ATF_TC_BODY(semctl_getzcnt_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, GETZCNT)); + /* Check the presence of semaphore ID and GETZCNT in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*GETZCNT.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_getzcnt_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getzcnt_failure); +ATF_TC_HEAD(semctl_getzcnt_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for GETZCNT command"); +} + +ATF_TC_BODY(semctl_getzcnt_failure, tc) +{ + const char *regex = "semctl.*GETZCNT.*return,failure.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETZCNT)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_getzcnt_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getall_success); +ATF_TC_HEAD(semctl_getall_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for GETALL command"); +} + +ATF_TC_BODY(semctl_getall_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + semarg.array = semvals; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE(semctl(semid, 0, GETALL, semarg) != -1); + /* Check the presence of semaphore ID and GETALL in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*GETALL.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_getall_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_getall_failure); +ATF_TC_HEAD(semctl_getall_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for GETALL command"); +} + +ATF_TC_BODY(semctl_getall_failure, tc) +{ + const char *regex = "semctl.*GETALL.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, GETALL, semarg)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_getall_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_setall_success); +ATF_TC_HEAD(semctl_setall_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for SETALL command"); +} + +ATF_TC_BODY(semctl_setall_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + semarg.array = semvals; + /* Initialize semvals to be used with SETALL */ + ATF_REQUIRE(semctl(semid, 0, GETALL, semarg) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, SETALL, semarg)); + /* Check the presence of semaphore ID and SETALL in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*SETALL.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_setall_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_setall_failure); +ATF_TC_HEAD(semctl_setall_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for SETALL command"); +} + +ATF_TC_BODY(semctl_setall_failure, tc) +{ + const char *regex = "semctl.*SETALL.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, SETALL, semarg)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_setall_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_stat_success); +ATF_TC_HEAD(semctl_stat_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for IPC_STAT command"); +} + +ATF_TC_BODY(semctl_stat_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + semarg.buf = &sembuff; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_STAT, semarg)); + /* Check the presence of semaphore ID and IPC_STAT in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*IPC_STAT.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_stat_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_stat_failure); +ATF_TC_HEAD(semctl_stat_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for IPC_STAT command"); +} + +ATF_TC_BODY(semctl_stat_failure, tc) +{ + const char *regex = "semctl.*IPC_STAT.*return,fail.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, IPC_STAT, semarg)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_stat_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_set_success); +ATF_TC_HEAD(semctl_set_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for IPC_SET command"); +} + +ATF_TC_BODY(semctl_set_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + semarg.buf = &sembuff; + /* Fill up the sembuff structure to be used with IPC_SET */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_STAT, semarg)); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_SET, semarg)); + /* Check the presence of semaphore ID and IPC_SET in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*IPC_SET.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_set_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_set_failure); +ATF_TC_HEAD(semctl_set_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for IPC_SET command"); +} + +ATF_TC_BODY(semctl_set_failure, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + semarg.buf = &sembuff; + /* Fill up the sembuff structure to be used with IPC_SET */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_STAT, semarg)); + + const char *regex = "semctl.*IPC_SET.*return,failure.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, IPC_SET, semarg)); + check_audit(fds, regex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_set_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_rmid_success); +ATF_TC_HEAD(semctl_rmid_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "semctl(2) call for IPC_RMID command"); +} + +ATF_TC_BODY(semctl_rmid_success, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID, semarg)); + /* Check the presence of semaphore ID and IPC_RMID in audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "semctl.*IPC_RMID.*%d.*return,success", semid); + check_audit(fds, ipcregex, pipefd); +} + +ATF_TC_CLEANUP(semctl_rmid_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_rmid_failure); +ATF_TC_HEAD(semctl_rmid_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for IPC_RMID command"); +} + +ATF_TC_BODY(semctl_rmid_failure, tc) +{ + const char *regex = "semctl.*IPC_RMID.*return,fail.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(-1, 0, IPC_RMID, semarg)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(semctl_rmid_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(semctl_illegal_command); +ATF_TC_HEAD(semctl_illegal_command, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "semctl(2) call for illegal cmd value"); +} + +ATF_TC_BODY(semctl_illegal_command, tc) +{ + /* Create a semaphore set and obtain the set identifier */ + ATF_REQUIRE((semid = + semget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR)) != -1); + + const char *regex = "semctl.*illegal command.*fail.*Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, semctl(semid, 0, -1)); + check_audit(fds, regex, pipefd); + + /* Destroy the semaphore set with ID = semid */ + ATF_REQUIRE_EQ(0, semctl(semid, 0, IPC_RMID)); +} + +ATF_TC_CLEANUP(semctl_illegal_command, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shm_open_success); +ATF_TC_HEAD(shm_open_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shm_open(2) call"); +} + +ATF_TC_BODY(shm_open_success, tc) +{ + pid = getpid(); + snprintf(ipcregex, sizeof(ipcregex), "shm_open.*%d.*ret.*success", pid); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE(shm_open(SHM_ANON, O_CREAT | O_TRUNC | O_RDWR, 0600) != -1); + check_audit(fds, ipcregex, pipefd); +} + +ATF_TC_CLEANUP(shm_open_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shm_open_failure); +ATF_TC_HEAD(shm_open_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shm_open(2) call"); +} + +ATF_TC_BODY(shm_open_failure, tc) +{ + const char *regex = "shm_open.*fileforaudit.*return,failure"; + FILE *pipefd = setup(fds, auclass); + /* Failure reason: File does not exist */ + ATF_REQUIRE_EQ(-1, shm_open(path, O_TRUNC | O_RDWR, 0600)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shm_open_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shm_unlink_success); +ATF_TC_HEAD(shm_unlink_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "shm_unlink(2) call"); +} + +ATF_TC_BODY(shm_unlink_success, tc) +{ + /* Build an absolute path to a file in the test-case directory */ + char dirpath[PATH_MAX]; + ATF_REQUIRE(getcwd(dirpath, sizeof(dirpath)) != NULL); + strlcat(dirpath, path, sizeof(dirpath)); + ATF_REQUIRE(shm_open(dirpath, O_CREAT | O_TRUNC | O_RDWR, 0600) != -1); + + const char *regex = "shm_unlink.*fileforaudit.*return,success"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, shm_unlink(dirpath)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shm_unlink_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(shm_unlink_failure); +ATF_TC_HEAD(shm_unlink_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "shm_unlink(2) call"); +} + +ATF_TC_BODY(shm_unlink_failure, tc) +{ + const char *regex = "shm_unlink.*fileforaudit.*return,failure"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, shm_unlink(path)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(shm_unlink_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(pipe_success); +ATF_TC_HEAD(pipe_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "pipe(2) call"); +} + +ATF_TC_BODY(pipe_success, tc) +{ + int filedesc[2]; + pid = getpid(); + snprintf(ipcregex, sizeof(ipcregex), "pipe.*%d.*return,success", pid); + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, pipe(filedesc)); + check_audit(fds, ipcregex, pipefd); + + close(filedesc[0]); + close(filedesc[1]); +} + +ATF_TC_CLEANUP(pipe_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(pipe_failure); +ATF_TC_HEAD(pipe_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "pipe(2) call"); +} + +ATF_TC_BODY(pipe_failure, tc) +{ + pid = getpid(); + snprintf(ipcregex, sizeof(ipcregex), "pipe.*%d.*return.failure", pid); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, pipe(NULL)); + check_audit(fds, ipcregex, pipefd); +} + +ATF_TC_CLEANUP(pipe_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(posix_openpt_success); +ATF_TC_HEAD(posix_openpt_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "posix_openpt(2) call"); +} + +ATF_TC_BODY(posix_openpt_success, tc) +{ + int filedesc; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE((filedesc = posix_openpt(O_RDWR | O_NOCTTY)) != -1); + /* Check for the presence of filedesc in the audit record */ + snprintf(ipcregex, sizeof(ipcregex), + "posix_openpt.*return,success,%d", filedesc); + check_audit(fds, ipcregex, pipefd); + close(filedesc); +} + +ATF_TC_CLEANUP(posix_openpt_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(posix_openpt_failure); +ATF_TC_HEAD(posix_openpt_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "posix_openpt(2) call"); +} + +ATF_TC_BODY(posix_openpt_failure, tc) +{ + const char *regex = "posix_openpt.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, posix_openpt(-1)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(posix_openpt_failure, tc) +{ + cleanup(); +} + + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, msgget_success); + ATF_TP_ADD_TC(tp, msgget_failure); + ATF_TP_ADD_TC(tp, msgsnd_success); + ATF_TP_ADD_TC(tp, msgsnd_failure); + ATF_TP_ADD_TC(tp, msgrcv_success); + ATF_TP_ADD_TC(tp, msgrcv_failure); + + ATF_TP_ADD_TC(tp, msgctl_rmid_success); + ATF_TP_ADD_TC(tp, msgctl_rmid_failure); + ATF_TP_ADD_TC(tp, msgctl_stat_success); + ATF_TP_ADD_TC(tp, msgctl_stat_failure); + ATF_TP_ADD_TC(tp, msgctl_set_success); + ATF_TP_ADD_TC(tp, msgctl_set_failure); + ATF_TP_ADD_TC(tp, msgctl_illegal_command); + + ATF_TP_ADD_TC(tp, shmget_success); + ATF_TP_ADD_TC(tp, shmget_failure); + ATF_TP_ADD_TC(tp, shmat_success); + ATF_TP_ADD_TC(tp, shmat_failure); + ATF_TP_ADD_TC(tp, shmdt_success); + ATF_TP_ADD_TC(tp, shmdt_failure); + + ATF_TP_ADD_TC(tp, shmctl_rmid_success); + ATF_TP_ADD_TC(tp, shmctl_rmid_failure); + ATF_TP_ADD_TC(tp, shmctl_stat_success); + ATF_TP_ADD_TC(tp, shmctl_stat_failure); + ATF_TP_ADD_TC(tp, shmctl_set_success); + ATF_TP_ADD_TC(tp, shmctl_set_failure); + ATF_TP_ADD_TC(tp, shmctl_illegal_command); + + ATF_TP_ADD_TC(tp, semget_success); + ATF_TP_ADD_TC(tp, semget_failure); + ATF_TP_ADD_TC(tp, semop_success); + ATF_TP_ADD_TC(tp, semop_failure); + + ATF_TP_ADD_TC(tp, semctl_getval_success); + ATF_TP_ADD_TC(tp, semctl_getval_failure); + ATF_TP_ADD_TC(tp, semctl_setval_success); + ATF_TP_ADD_TC(tp, semctl_setval_failure); + ATF_TP_ADD_TC(tp, semctl_getpid_success); + ATF_TP_ADD_TC(tp, semctl_getpid_failure); + ATF_TP_ADD_TC(tp, semctl_getncnt_success); + ATF_TP_ADD_TC(tp, semctl_getncnt_failure); + ATF_TP_ADD_TC(tp, semctl_getzcnt_success); + ATF_TP_ADD_TC(tp, semctl_getzcnt_failure); + ATF_TP_ADD_TC(tp, semctl_getall_success); + ATF_TP_ADD_TC(tp, semctl_getall_failure); + ATF_TP_ADD_TC(tp, semctl_setall_success); + ATF_TP_ADD_TC(tp, semctl_setall_failure); + ATF_TP_ADD_TC(tp, semctl_stat_success); + ATF_TP_ADD_TC(tp, semctl_stat_failure); + ATF_TP_ADD_TC(tp, semctl_set_success); + ATF_TP_ADD_TC(tp, semctl_set_failure); + ATF_TP_ADD_TC(tp, semctl_rmid_success); + ATF_TP_ADD_TC(tp, semctl_rmid_failure); + ATF_TP_ADD_TC(tp, semctl_illegal_command); + + ATF_TP_ADD_TC(tp, shm_open_success); + ATF_TP_ADD_TC(tp, shm_open_failure); + ATF_TP_ADD_TC(tp, shm_unlink_success); + ATF_TP_ADD_TC(tp, shm_unlink_failure); + + ATF_TP_ADD_TC(tp, pipe_success); + ATF_TP_ADD_TC(tp, pipe_failure); + ATF_TP_ADD_TC(tp, posix_openpt_success); + ATF_TP_ADD_TC(tp, posix_openpt_failure); + + return (atf_no_error()); +} |