tests/testsuite.c

   1 #include "config.h"
   2
   3 #include <stdarg.h>
   4 #include <stddef.h>
   5 #include <setjmp.h>
   6 #include <cmocka.h>
   7
   8 #include <errno.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <sys/time.h>
  15 #include <unistd.h>
  16
  17 #ifdef HAVE_SYS_SYSCALL_H
  18 #include <sys/syscall.h>
  19 #endif
  20 #ifdef HAVE_SYSCALL_H
  21 #include <syscall.h>
  22 #endif
  23
  24 #define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x))
  25
  26 static void test_uwrap_seteuid(void **state)
  27 {
  28         int rc;
  29         uid_t u;
  30         char *env;
  31
  32         env = getenv("UID_WRAPPER");
  33         if (env == NULL) {
  34                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
  35                 return;
  36         }
  37
  38         (void) state; /* unused */
  39
  40         rc = seteuid(-1);
  41         assert_int_equal(rc, -1);
  42
  43         rc = seteuid(0);
  44         assert_int_equal(rc, 0);
  45
  46         u = geteuid();
  47 #ifdef SYS_geteuid /* not available on Solaris */
  48         assert_int_equal(u, syscall(SYS_geteuid));
  49 #endif
  50
  51         rc = setuid(42);
  52         assert_int_equal(rc, 0);
  53
  54         u = getuid();
  55         assert_int_equal(u, 42);
  56 }
  57
  58 static void test_uwrap_setuid(void **state)
  59 {
  60         int rc;
  61         uid_t u;
  62         char *env;
  63
  64         env = getenv("UID_WRAPPER");
  65         if (env == NULL) {
  66                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
  67                 return;
  68         }
  69
  70         (void) state; /* unused */
  71
  72         rc = setuid(-1);
  73         assert_int_equal(rc, -1);
  74
  75         rc = setuid(42);
  76         assert_int_equal(rc, 0);
  77
  78         u = getuid();
  79         assert_int_equal(u, 42);
  80 }
  81
  82 static void test_uwrap_setegid(void **state)
  83 {
  84         int rc;
  85         uid_t u;
  86         char *env;
  87
  88         env = getenv("UID_WRAPPER");
  89         if (env == NULL) {
  90                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
  91                 return;
  92         }
  93
  94         (void) state; /* unused */
  95
  96         rc = setegid(0);
  97         assert_int_equal(rc, 0);
  98
  99         u = getegid();
 100 #ifdef SYS_getegid /* Not available on Solaris */
 101         assert_int_equal(u, syscall(SYS_getegid));
 102 #endif
 103
 104         rc = setegid(42);
 105         assert_int_equal(rc, 0);
 106
 107         u = getegid();
 108         assert_int_equal(u, 42);
 109 }
 110
 111 static void test_uwrap_syscall(void **state)
 112 {
 113         long int rc;
 114         char *env;
 115         struct timeval tv1, tv2;
 116         struct timezone tz1, tz2;
 117
 118         env = getenv("UID_WRAPPER");
 119         if (env == NULL) {
 120                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 121                 return;
 122         }
 123
 124         (void) state; /* unused */
 125
 126         rc = syscall(SYS_getpid);
 127         assert_int_equal(rc, getpid());
 128
 129         rc = access(".", R_OK);
 130         assert_int_equal(rc, 0);
 131
 132         rc = syscall(SYS_access, ".", R_OK);
 133         assert_int_equal(rc, 0);
 134
 135         ZERO_STRUCT(tv1);
 136         ZERO_STRUCT(tv2);
 137         ZERO_STRUCT(tz1);
 138         ZERO_STRUCT(tz2);
 139
 140         rc = gettimeofday(&tv1, &tz1);
 141         assert_int_equal(rc, 0);
 142
 143         rc = syscall(SYS_gettimeofday, &tv2, &tz2);
 144         assert_int_equal(rc, 0);
 145
 146         assert_int_equal(tv1.tv_sec, tv2.tv_sec);
 147         assert_int_equal(tz2.tz_dsttime, tz2.tz_dsttime);
 148         assert_int_equal(tz2.tz_minuteswest, tz2.tz_minuteswest);
 149 }
 150
 151 static void test_uwrap_syscall_setreuid(void **state)
 152 {
 153         long int rc;
 154         uid_t u;
 155         char *env;
 156
 157         env = getenv("UID_WRAPPER");
 158         if (env == NULL) {
 159                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 160                 return;
 161         }
 162
 163         (void) state; /* unused */
 164
 165         rc = syscall(SYS_setreuid, -1, 0);
 166         assert_int_equal(rc, 0);
 167
 168         u = geteuid();
 169 #ifdef SYS_geteuid /* not available on Solaris */
 170         assert_int_equal(u, syscall(SYS_geteuid));
 171 #endif
 172
 173         rc = syscall(SYS_setreuid, -1, 42);
 174         assert_int_equal(rc, 0);
 175
 176         u = geteuid();
 177         assert_int_equal(u, 42);
 178 }
 179
 180 static void test_uwrap_syscall_setregid(void **state)
 181 {
 182         long int rc;
 183         gid_t g;
 184         char *env;
 185
 186         env = getenv("UID_WRAPPER");
 187         if (env == NULL) {
 188                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 189                 return;
 190         }
 191
 192         (void) state; /* unused */
 193
 194         rc = syscall(SYS_setregid, -1, 0);
 195         assert_int_equal(rc, 0);
 196
 197         g = getegid();
 198 #ifdef SYS_getegid /* Not available on Solaris */
 199         assert_int_equal(g, syscall(SYS_getegid));
 200 #endif
 201
 202         rc = syscall(SYS_setregid, -1, 42);
 203         assert_int_equal(rc, 0);
 204
 205         g = getegid();
 206         assert_int_equal(g, 42);
 207 }
 208
 209 int main(void) {
 210         int rc;
 211
 212         const UnitTest tests[] = {
 213                 unit_test(test_uwrap_syscall),
 214                 unit_test(test_uwrap_seteuid),
 215                 unit_test(test_uwrap_setuid),
 216                 unit_test(test_uwrap_setegid),
 217                 unit_test(test_uwrap_syscall_setreuid),
 218                 unit_test(test_uwrap_syscall_setregid),
 219         };
 220
 221         rc = run_tests(tests);
 222
 223         return rc;
 224 }