test/ipc/shmctl/shmctl03.c

   1 /*
   2  *
   3  *   Copyright (c) International Business Machines  Corp., 2001
   4  *
   5  *   This program is free software;  you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  13  *   the GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program;  if not, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  */
  19
  20 /*
  21  * NAME
  22  *      shmctl03.c
  23  *
  24  * DESCRIPTION
  25  *      shmctl03 - check for EACCES, and EPERM errors
  26  *
  27  * ALGORITHM
  28  *      create a shared memory segment with root only read & write permissions
  29  *      fork a child process
  30  *      if child
  31  *        set the ID of the child process to that of "ltpuser1"
  32  *        call do_child()
  33  *        loop if that option was specified
  34  *          call shmctl() using three different invalid cases
  35  *          check the errno value
  36  *            issue a PASS message if we get EACCES or EPERM
  37  *          otherwise, the tests fails
  38  *            issue a FAIL message
  39  *        call cleanup
  40  *      if parent
  41  *        wait for child to exit
  42  *        remove the shared memory segment
  43  *
  44  * USAGE:  <for command-line>
  45  *  shmctl03 [-c n] [-e] [-i n] [-I x] [-P x] [-t]
  46  *     where,  -c n : Run n copies concurrently.
  47  *             -e   : Turn on errno logging.
  48  *             -i n : Execute test n times.
  49  *             -I x : Execute test for x seconds.
  50  *             -P x : Pause for x seconds between iterations.
  51  *             -t   : Turn on syscall timing.
  52  *
  53  * HISTORY
  54  *      03/2001 - Written by Wayne Boyer
  55  *
  56  * RESTRICTIONS
  57  *      test must be run as root
  58  */
  59
  60 #include "ipcshm.h"
  61 #include <sys/types.h>
  62 #include <sys/wait.h>
  63
  64 char *TCID = "shmctl03";
  65 extern int Tst_count;
  66
  67 int exp_enos[] = {EACCES, EPERM, 0};    /* 0 terminated list of */
  68                                         /* expected errnos      */
  69 int shm_id_1 = -1;
  70
  71 uid_t ltp_uid;
  72 char *ltp_user = "nobody";
  73
  74 struct shmid_ds buf;
  75
  76 struct test_case_t {
  77         int *shmid;
  78         int cmd;
  79         struct shmid_ds *sbuf;
  80         int error;
  81 } TC[] = {
  82         /* EACCES - child has no read permission for segment */
  83         {&shm_id_1, IPC_STAT, &buf, EACCES},
  84
  85         /* EPERM - IPC_SET - child doesn't have permission to change segment */
  86         {&shm_id_1, IPC_SET, &buf, EPERM},
  87
  88         /* EPERM - IPC_RMID - child can not remove the segment */
  89         {&shm_id_1, IPC_RMID, &buf, EPERM},
  90 };
  91
  92 int TST_TOTAL = (sizeof(TC) / sizeof(*TC));
  93
  94 int main(int ac, char **av)
  95 {
  96         char *msg;                      /* message returned from parse_opts */
  97         int pid;
  98         void do_child(void);
  99
 100         /* parse standard options */
 101         if ((msg = parse_opts(ac, av, (option_t *)NULL, NULL)) != (char *)NULL){
 102                 tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
 103         }
 104
 105         setup();                        /* global setup */
 106
 107         if ((pid = FORK_OR_VFORK()) == -1) {
 108                 tst_brkm(TBROK, cleanup, "could not fork");
 109         }
 110
 111         if (pid == 0) {         /* child */
 112                 /* set  the user ID of the child to the non root user */
 113                 if (setuid(ltp_uid) == -1) {
 114                         tst_resm(TBROK, "setuid() failed");
 115                         exit(1);
 116                 }
 117
 118                 do_child();
 119         } else {
 120                 /* wait for the child to return */
 121                 if (waitpid(pid, NULL, 0) == -1) {
 122                         tst_brkm(TBROK, cleanup, "waitpid failed");
 123                 }
 124
 125                 /* if it exists, remove the shared memory resource */
 126                 rm_shm(shm_id_1);
 127
 128                 /* Remove the temporary directory */
 129                 tst_rmdir();
 130         }
 131
 132         cleanup ();
 133         return(0);
 134 }
 135
 136 /*
 137  * do_child - make the call as the child process
 138  */
 139 void
 140 do_child(void)
 141 {
 142         int i, lc;
 143
 144         /* The following loop checks looping state if -i option given */
 145
 146         for (lc = 0; TEST_LOOPING(lc); lc++) {
 147                 /* reset Tst_count in case we are looping */
 148                 Tst_count = 0;
 149
 150                 /* loop through the test cases */
 151                 for (i=0; i<TST_TOTAL; i++) {
 152                         /*
 153                          * use the TEST() macro to make the call
 154                          */
 155
 156                         TEST(shmctl(*(TC[i].shmid), TC[i].cmd, TC[i].sbuf));
 157
 158                         if (TEST_RETURN != -1) {
 159                                 tst_resm(TFAIL, "call succeeded unexpectedly");
 160                                 continue;
 161                         }
 162
 163                         TEST_ERROR_LOG(TEST_ERRNO);
 164
 165                         if (TEST_ERRNO == TC[i].error) {
 166                                 tst_resm(TPASS, "expected failure - errno = "
 167                                          "%d : %s", TEST_ERRNO,
 168                                          strerror(TEST_ERRNO));
 169                         } else {
 170                                 tst_resm(TFAIL, "call failed with an "
 171                                          "unexpected error - %d : %s",
 172                                          TEST_ERRNO, strerror(TEST_ERRNO));
 173                         }
 174                 }
 175         }
 176 }
 177
 178 /*
 179  * setup() - performs all the ONE TIME setup for this test.
 180  */
 181 void
 182 setup(void)
 183 {
 184         /* check for root as process owner */
 185         check_root();
 186
 187         /* capture signals */
 188         tst_sig(FORK, DEF_HANDLER, cleanup);
 189
 190         /* Set up the expected error numbers for -e option */
 191         TEST_EXP_ENOS(exp_enos);
 192
 193         /* Pause if that option was specified */
 194         TEST_PAUSE;
 195
 196         /*
 197          * Create a temporary directory and cd into it.
 198          * This helps to ensure that a unique msgkey is created.
 199          * See ../lib/libipc.c for more information.
 200          */
 201         tst_tmpdir();
 202
 203         /* get an IPC resource key */
 204         shmkey = getipckey();
 205
 206         /* create a shared memory segment with read and write permissions */
 207         if ((shm_id_1 = shmget(shmkey, SHM_SIZE, IPC_CREAT | IPC_EXCL |
 208              SHM_RW)) == -1) {
 209                 tst_brkm(TBROK, cleanup, "couldn't create shared memory "
 210                          "segment in setup()");
 211         }
 212
 213         /* get the userid for a non root user */
 214         ltp_uid = getuserid(ltp_user);
 215 }
 216
 217 /*
 218  * cleanup() - performs all the ONE TIME cleanup for this test at completion
 219  *             or premature exit.
 220  */
 221 void
 222 cleanup(void)
 223 {
 224         /*
 225          * print timing stats if that option was specified.
 226          * print errno log if that option was specified.
 227          */
 228         TEST_CLEANUP;
 229
 230         /* exit with return code appropriate for results */
 231         tst_exit();
 232 }
 233