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_setgid(void **state)
 112 {
 113         int rc;
 114         gid_t u;
 115         char *env;
 116
 117         env = getenv("UID_WRAPPER");
 118         if (env == NULL) {
 119                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 120                 return;
 121         }
 122
 123         (void) state; /* unused */
 124
 125         rc = setgid(-1);
 126         assert_int_equal(rc, -1);
 127
 128         rc = setgid(42);
 129         assert_int_equal(rc, 0);
 130
 131         u = getgid();
 132         assert_int_equal(u, 42);
 133 }
 134
 135 static void test_uwrap_syscall(void **state)
 136 {
 137         long int rc;
 138         char *env;
 139         struct timeval tv1, tv2;
 140         struct timezone tz1, tz2;
 141
 142         env = getenv("UID_WRAPPER");
 143         if (env == NULL) {
 144                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 145                 return;
 146         }
 147
 148         (void) state; /* unused */
 149
 150         rc = syscall(SYS_getpid);
 151         assert_int_equal(rc, getpid());
 152
 153         rc = access(".", R_OK);
 154         assert_int_equal(rc, 0);
 155
 156         rc = syscall(SYS_access, ".", R_OK);
 157         assert_int_equal(rc, 0);
 158
 159         ZERO_STRUCT(tv1);
 160         ZERO_STRUCT(tv2);
 161         ZERO_STRUCT(tz1);
 162         ZERO_STRUCT(tz2);
 163
 164         rc = gettimeofday(&tv1, &tz1);
 165         assert_int_equal(rc, 0);
 166
 167         rc = syscall(SYS_gettimeofday, &tv2, &tz2);
 168         assert_int_equal(rc, 0);
 169
 170         assert_int_equal(tv1.tv_sec, tv2.tv_sec);
 171         assert_int_equal(tz2.tz_dsttime, tz2.tz_dsttime);
 172         assert_int_equal(tz2.tz_minuteswest, tz2.tz_minuteswest);
 173 }
 174
 175 static void test_uwrap_syscall_setreuid(void **state)
 176 {
 177         long int rc;
 178         uid_t u;
 179         char *env;
 180
 181         env = getenv("UID_WRAPPER");
 182         if (env == NULL) {
 183                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 184                 return;
 185         }
 186
 187         (void) state; /* unused */
 188
 189         rc = syscall(SYS_setreuid, -1, 0);
 190         assert_int_equal(rc, 0);
 191
 192         u = geteuid();
 193 #ifdef SYS_geteuid /* not available on Solaris */
 194         assert_int_equal(u, syscall(SYS_geteuid));
 195 #endif
 196
 197         rc = syscall(SYS_setreuid, -1, 42);
 198         assert_int_equal(rc, 0);
 199
 200         u = geteuid();
 201         assert_int_equal(u, 42);
 202 }
 203
 204 static void test_uwrap_syscall_setregid(void **state)
 205 {
 206         long int rc;
 207         gid_t g;
 208         char *env;
 209
 210         env = getenv("UID_WRAPPER");
 211         if (env == NULL) {
 212                 printf("UID_WRAPPER env not set, uid_wrapper is disabled\n");
 213                 return;
 214         }
 215
 216         (void) state; /* unused */
 217
 218         rc = syscall(SYS_setregid, -1, 0);
 219         assert_int_equal(rc, 0);
 220
 221         g = getegid();
 222 #ifdef SYS_getegid /* Not available on Solaris */
 223         assert_int_equal(g, syscall(SYS_getegid));
 224 #endif
 225
 226         rc = syscall(SYS_setregid, -1, 42);
 227         assert_int_equal(rc, 0);
 228
 229         g = getegid();
 230         assert_int_equal(g, 42);
 231 }
 232
 233 int main(void) {
 234         int rc;
 235
 236         const UnitTest tests[] = {
 237                 unit_test(test_uwrap_syscall),
 238                 unit_test(test_uwrap_seteuid),
 239                 unit_test(test_uwrap_setuid),
 240                 unit_test(test_uwrap_setegid),
 241                 unit_test(test_uwrap_setgid),
 242                 unit_test(test_uwrap_syscall_setreuid),
 243                 unit_test(test_uwrap_syscall_setregid),
 244         };
 245
 246         rc = run_tests(tests);
 247
 248         return rc;
 249 }