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 #include <pwd.h>
  18 #include <grp.h>
  19
  20 #ifdef HAVE_SYS_SYSCALL_H
  21 #include <sys/syscall.h>
  22 #endif
  23 #ifdef HAVE_SYSCALL_H
  24 #include <syscall.h>
  25 #endif
  26
  27 #define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x))
  28 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
  29
  30 static void test_uwrap_syscall_setreuid(void **state)
  31 {
  32         long int rc;
  33         uid_t u;
  34
  35         (void) state; /* unused */
  36
  37 #if defined(SYS_setreuid)
  38         rc = syscall(SYS_setreuid, -1, 0);
  39 #elif defined(SYS_setreuid32)
  40         rc = syscall(SYS_setreuid32, -1, 0);
  41 #endif
  42         assert_int_equal(rc, 0);
  43
  44         u = geteuid();
  45 #if defined(SYS_geteuid) /* not available on Solaris */
  46         assert_int_equal(u, syscall(SYS_geteuid));
  47 #elif defined(SYS_geteuid32)
  48         assert_int_equal(u, syscall(SYS_geteuid32));
  49 #endif
  50
  51 #if defined(SYS_setreuid)
  52         rc = syscall(SYS_setreuid, -1, 42);
  53 #elif defined(SYS_setreuid32)
  54         rc = syscall(SYS_setreuid32, -1, 42);
  55 #endif
  56         assert_int_equal(rc, 0);
  57
  58         u = geteuid();
  59         assert_int_equal(u, 42);
  60 }
  61
  62 static void test_uwrap_syscall_setresuid(void **state)
  63 {
  64         long int rc;
  65         uid_t u;
  66         uid_t u_r, u_e, u_s;
  67
  68         (void) state; /* unused */
  69
  70         rc = syscall(SYS_setresuid, 42, 0, -1);
  71         assert_int_equal(rc, 0);
  72
  73         u = geteuid();
  74 #if defined(SYS_getresuid) /* not available on Solaris */
  75         rc = syscall(SYS_getresuid, &u_r, &u_e, &u_s);
  76         assert_return_code(rc, errno);
  77
  78         assert_int_equal(u_r, 42);
  79         assert_int_equal(u, u_e);
  80 #elif defined(SYS_getresuid32)
  81         rc = syscall(SYS_getresuid32, &u_r, &u_e, &u_s);
  82         assert_return_code(rc, errno);
  83
  84         assert_int_equal(u_r, 42);
  85         assert_int_equal(u, u_e);
  86 #endif
  87
  88 #if defined(SYS_setreuid)
  89         rc = syscall(SYS_setreuid, -1, 42);
  90 #elif defined(SYS_setreuid)
  91         rc = syscall(SYS_setreuid32, -1, 42);
  92 #endif
  93         assert_return_code(rc, errno);
  94
  95         u = geteuid();
  96         assert_int_equal(u, 42);
  97 }
  98
  99 static void test_uwrap_syscall_setregid(void **state)
 100 {
 101         long int rc;
 102         gid_t g;
 103
 104         (void) state; /* unused */
 105
 106 #if defined(SYS_setregid)
 107         rc = syscall(SYS_setregid, -1, 0);
 108 #elif defined(SYS_setregid32)
 109         rc = syscall(SYS_setregid32, -1, 0);
 110 #endif
 111         assert_int_equal(rc, 0);
 112
 113         g = getegid();
 114 #if defined(SYS_getegid) /* Not available on Solaris */
 115         assert_int_equal(g, syscall(SYS_getegid));
 116 #elif defined(SYS_getegid32)
 117         assert_int_equal(g, syscall(SYS_getegid32));
 118 #endif
 119
 120 #if defined(SYS_setregid)
 121         rc = syscall(SYS_setregid, -1, 42);
 122 #elif defined(SYS_setregid32)
 123         rc = syscall(SYS_setregid32, -1, 42);
 124 #endif
 125         assert_int_equal(rc, 0);
 126
 127         g = getegid();
 128         assert_int_equal(g, 42);
 129 }
 130
 131 static void test_uwrap_syscall_setresgid(void **state)
 132 {
 133         long int rc;
 134         gid_t g;
 135         gid_t g_r, g_e, g_s;
 136
 137         (void) state; /* unused */
 138
 139         rc = syscall(SYS_setresgid, 42, 0, -1);
 140         assert_int_equal(rc, 0);
 141
 142         g = getegid();
 143 #if defined(SYS_getresgid) /* Not available on Solaris */
 144         rc = syscall(SYS_getresgid, &g_r, &g_e, &g_s);
 145         assert_return_code(rc, errno);
 146
 147         assert_int_equal(g_r, 42);
 148         assert_int_equal(g, g_e);
 149 #elif defined(SYS_getresgid32)
 150         rc = syscall(SYS_getresgid32, &g_r, &g_e, &g_s);
 151         assert_return_code(rc, errno);
 152
 153         assert_int_equal(g_r, 42);
 154         assert_int_equal(g, g_e);
 155 #endif
 156
 157         rc = syscall(SYS_setregid, -1, 42);
 158         assert_return_code(rc, errno);
 159
 160         g = getegid();
 161         assert_int_equal(g, 42);
 162 }
 163
 164 #if defined(SYS_setgroups) || defined(SYS_setroups32)
 165 static void test_uwrap_syscall_setgroups(void **state)
 166 {
 167         gid_t glist[] = { 100, 200, 300, 400, 500 };
 168         gid_t rlist[16];
 169         int rc = -1;
 170
 171         (void) state; /* unused */
 172
 173 #if defined(SYS_setgroups)
 174         rc = syscall(SYS_setgroups, ARRAY_SIZE(glist), glist);
 175 #elif defined (SYS_setgroups32)
 176         rc = syscall(SYS_setgroups32, ARRAY_SIZE(glist), glist);
 177 #endif
 178         assert_int_equal(rc, 0);
 179
 180         rc = getgroups(ARRAY_SIZE(rlist), rlist);
 181         assert_int_equal(rc, 5);
 182
 183         assert_memory_equal(glist, rlist, sizeof(glist));
 184
 185         /* Drop all supplementary groups. This is often done by daemons */
 186         memset(rlist, 0, sizeof(rlist));
 187 #if defined(SYS_setgroups)
 188         rc = syscall(SYS_setgroups, 0, NULL);
 189 #elif defined(SYS_setgroups32)
 190         rc = syscall(SYS_setgroups32, 0, NULL);
 191 #endif
 192         assert_int_equal(rc, 0);
 193
 194         rc = getgroups(ARRAY_SIZE(rlist), rlist);
 195         assert_int_equal(rc, 0);
 196
 197         assert_int_equal(rlist[0], 0);
 198 }
 199 #endif
 200
 201 int main(void) {
 202         int rc;
 203
 204         const struct CMUnitTest uwrap_tests[] = {
 205                 cmocka_unit_test(test_uwrap_syscall_setreuid),
 206                 cmocka_unit_test(test_uwrap_syscall_setresuid),
 207                 cmocka_unit_test(test_uwrap_syscall_setregid),
 208                 cmocka_unit_test(test_uwrap_syscall_setresgid),
 209 #if defined(SYS_setgroups) || defined(SYS_setroups32)
 210                 cmocka_unit_test(test_uwrap_syscall_setgroups),
 211 #endif
 212         };
 213
 214         rc = cmocka_run_group_tests(uwrap_tests, NULL, NULL);
 215
 216         return rc;
 217 }