minix/tests/test34.c

   1 /* test34: chmod() chown()      Author: Jan-Mark Wams (jms@cs.vu.nl) */
   2
   3 /* There is a problem getting valid uids and gids, so we use the passwd
   4 ** file (ie. /etc/passwd). I don't like this, but I see no other way.
   5 ** The read-only-device-error (EROFS) is not checked!
   6 ** Supplementary group IDs are ignored.
   7 */
   8
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <sys/wait.h>
  12 #include <stdlib.h>
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include <fcntl.h>
  16 #include <limits.h>
  17 #include <errno.h>
  18 #include <ctype.h>
  19 #include <time.h>
  20 #include <stdio.h>
  21
  22 int max_error =         4;
  23 #include "common.h"
  24
  25 #define ITERATIONS      4
  26 #define N 100
  27
  28
  29 #define ALL_RWXB        (S_IRWXU | S_IRWXG | S_IRWXO)
  30 #define ALL_SETB        (S_ISUID | S_ISGID)
  31 #define ALL_BITS        (ALL_RWXB | ALL_SETB)
  32
  33 #define System(cmd)   if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
  34 #define Chdir(dir)    if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
  35 #define Stat(a,b)     if (stat(a,b) != 0) printf("Can't stat %s\n", a)
  36 #define Mkfifo(f)     if (mkfifo(f,0777)!=0) printf("Can't make fifo %s\n", f)
  37 #define Mkdir(f)      if (mkdir(f,0777)!=0) printf("Can't make dir %s\n", f)
  38 #define Creat(f)      if (close(creat(f,0777))!=0) printf("Can't creat %s\n",f)
  39
  40 /* This program uses /etc/passwd and assumes things about it's contents. */
  41 #define PASSWD_FILE     "/etc/passwd"
  42
  43 int superuser;
  44 int I_can_chown;
  45 char *MaxName;                  /* Name of maximum length */
  46 char MaxPath[PATH_MAX];         /* Same for path */
  47 char *NameTooLong;              /* Name of maximum +1 length */
  48 char PathTooLong[PATH_MAX + 1]; /* Same for path, both too long */
  49
  50 void test34a(void);
  51 void test34b(void);
  52 void test34c(void);
  53 mode_t mode(char *file_name);
  54 void makelongnames(void);
  55 void getids(uid_t * uid, gid_t * gid);
  56
  57 int main(int argc, char *argv[])
  58 {
  59   int i, m = 0xFFFF;
  60
  61   sync();
  62   if (argc == 2) m = atoi(argv[1]);
  63   umask(0000);
  64   start(34);
  65   makelongnames();
  66   superuser = (geteuid() == (uid_t) 0);
  67
  68 #ifdef _POSIX_CHOWN_RESTRICTED
  69   I_can_chown = superuser;
  70 #else
  71   I_can_chown = 1;
  72 #endif
  73
  74
  75   for (i = 1; i < ITERATIONS; i++) {
  76         if (m & 0001) test34a();
  77         if (m & 0002) test34b();
  78         if (m & 0004) test34c();
  79   }
  80   quit();
  81
  82   return(-1);   /* Unreachable */
  83 }
  84
  85 void test34a()
  86 {                               /* Test normal operation. */
  87   time_t time1, time2;
  88   mode_t mod;
  89   struct stat st1, st2;
  90   int cnt;
  91   uid_t uid, uid2;
  92   gid_t gid, gid2;
  93   int stat_loc;
  94
  95   subtest = 1;
  96
  97   /* Make scratch file. */
  98   Creat("foo");
  99
 100   for (mod = 0; mod <= ALL_BITS; mod++) {
 101         if ((mod & ALL_BITS) != mod)    /* If not a valid mod next. */
 102                 continue;
 103         Stat("foo", &st1);
 104         if (time(&time1) == (time_t) - 1) e(1);
 105         if (chmod("foo", mod) != 0) e(2);
 106         Stat("foo", &st2);
 107         if (time(&time2) == (time_t) - 1) e(3);
 108         if (superuser)
 109                 if ((st2.st_mode & ALL_BITS) != mod) e(4);
 110         if (!superuser)
 111                 if ((st2.st_mode & ALL_RWXB) != (mod & ALL_RWXB)) e(5);
 112
 113         /* Test the C time feald. */
 114         if (st1.st_ctime > st2.st_ctime) e(6);
 115         if (st1.st_ctime > time1) e(7);
 116         if (st1.st_ctime > time2) e(8);
 117 #ifndef V1_FILESYSTEM
 118         if (st2.st_ctime < time1) e(9);
 119 #endif
 120         if (st2.st_ctime > time2) e(10);
 121         if (st1.st_atime != st2.st_atime) e(11);
 122         if (st1.st_mtime != st2.st_mtime) e(12);
 123   }                             /* End for loop. */
 124
 125   /* Check if chown(file, geteuid(), getegid()) works. */
 126   for (cnt = 0; cnt < 20; cnt++) {
 127         /* Set all rights on foo, including the set .id bits. */
 128         if (chmod("foo", ALL_BITS) != 0) e(13);
 129         Stat("foo", &st1);
 130         if (time(&time1) == (time_t) -1) e(14);
 131
 132         if (chown("foo", geteuid(), getegid()) != 0) e(15);
 133         Stat("foo", &st2);
 134         if (time(&time2) == (time_t) -1) e(16);
 135
 136         /* Check ``chown()'' killed the set .id bits. */
 137         if (!superuser) {
 138                 if ((st1.st_mode & ALL_RWXB) != ALL_RWXB) e(17);
 139                 if ((st2.st_mode & ALL_BITS) != ALL_RWXB) e(18);
 140         }
 141         if (superuser) {
 142                 if ((st1.st_mode & ALL_BITS) != ALL_BITS) e(19);
 143                 if ((st1.st_mode & ALL_RWXB) != ALL_RWXB) e(20);
 144         }
 145
 146         /* Check the timing. */
 147         if (st1.st_ctime > st2.st_ctime) e(21);
 148         if (st1.st_ctime > time1) e(22);
 149         if (st1.st_ctime > time2) e(23);
 150 #ifndef V1_FILESYSTEM
 151         if (st2.st_ctime < time1) e(24);
 152 #endif
 153         if (st2.st_ctime > time2) e(25);
 154         if (st1.st_atime != st2.st_atime) e(26);
 155         if (st1.st_mtime != st2.st_mtime) e(27);
 156   }                             /* End for loop. */
 157
 158   /* Make scratch file. */
 159   if (chmod("foo", ALL_RWXB) != 0) e(28);
 160
 161   if (I_can_chown) {
 162         /* Do a 20 tests on a gid and uid. */
 163         for (cnt = 0; cnt < 20; cnt++) {
 164                 /* Get a uid and a gid, test chown. */
 165                 getids(&uid, &gid);
 166                 Stat("foo", &st1);
 167                 if (time(&time1) == (time_t) -1) e(29);
 168                 if (chown("foo", (uid_t) 0, (gid_t) 0) != 0) e(30);
 169                 Stat("foo", &st2);
 170                 if (time(&time2) == (time_t) -1) e(31);
 171
 172                 /* Test the C time field. */
 173                 if (st1.st_ctime > st2.st_ctime) e(32);
 174                 if (st1.st_ctime > time1) e(33);
 175                 if (st1.st_ctime > time2) e(34);
 176                 if (st2.st_ctime < time1) e(35);
 177                 if (st2.st_ctime > time2) e(36);
 178                 if (st1.st_atime != st2.st_atime) e(37);
 179                 if (st1.st_mtime != st2.st_mtime) e(38);
 180
 181                 /* Do aditional tests. */
 182                 if (chown("foo", (uid_t) 0, gid) != 0) e(39);
 183                 if (chown("foo", uid, (gid_t) 0) != 0) e(40);
 184                 if (chown("foo", uid, gid) != 0) e(41);
 185         }
 186   }
 187   if (superuser) {
 188         /* Check if a non-superuser can change a files gid to gid2 *
 189          * if gid2 is the current process gid. */
 190         for (cnt = 0; cnt < 5; cnt++) {
 191                 switch (fork()) {
 192                     case -1:
 193                         printf("Can't fork\n");
 194                         break;
 195                     case 0:
 196                         alarm(20);
 197
 198                         getids(&uid, &gid);
 199                         if (uid == 0) {
 200                                 getids(&uid, &gid);
 201                                 if (uid == 0) e(42);
 202                         }
 203                         getids(&uid2, &gid2);
 204                         if (gid == gid2) e(43);
 205
 206                         /* Creat boo and bar for user uid of group gid. */
 207                         Creat("boo");
 208                         if (chown("boo", uid, gid) != 0) e(44);
 209                         if (chmod("boo", ALL_BITS) != 0) e(45);
 210                         Creat("bar");
 211                         if (chown("bar", uid, gid) != 0) e(46);
 212                         if (chmod("bar", ALL_BITS) != 0) e(47);
 213
 214                         /* We now become user uid of group gid2. */
 215                         setgid(gid2);
 216                         setuid(uid);
 217
 218                         Stat("bar", &st1);
 219                         if (time(&time1) == (time_t) -1) e(48);
 220                         if (chown("bar", uid, gid2) != 0) e(49);
 221                         Stat("bar", &st2);
 222                         if (time(&time2) == (time_t) -1) e(50);
 223
 224                         /* Check if the SET_BITS are cleared. */
 225                         if ((st1.st_mode & ALL_BITS) != ALL_BITS) e(51);
 226                         if ((st2.st_mode & ALL_BITS) != ALL_RWXB) e(52);
 227
 228                         /* Check the st_times. */
 229                         if (st1.st_ctime > st2.st_ctime) e(53);
 230                         if (st1.st_ctime > time1) e(54);
 231                         if (st1.st_ctime > time2) e(55);
 232                         if (st2.st_ctime < time1) e(56);
 233                         if (st2.st_ctime > time2) e(57);
 234                         if (st1.st_atime != st2.st_atime) e(58);
 235                         if (st1.st_mtime != st2.st_mtime) e(59);
 236
 237                         Stat("boo", &st1);
 238                         if (chmod("boo", ALL_BITS) != 0) e(60);
 239                         Stat("boo", &st2);
 240
 241                         /* Check if the set gid bit is cleared. */
 242                         if ((st1.st_mode & ALL_RWXB) != ALL_RWXB) e(61);
 243                         if ((st2.st_mode & S_ISGID) != 0) e(62);
 244
 245                         if (chown("boo", uid, gid2) != 0) e(63);
 246                         Stat("boo", &st1);
 247
 248                         /* Check if the set uid bit is cleared. */
 249                         if ((st1.st_mode & S_ISUID) != 0) e(64);
 250
 251                         exit(0);
 252                     default:
 253                         wait(&stat_loc);
 254                         if (stat_loc != 0) e(65);       /* Alarm? */
 255                 }
 256         }                       /* end for loop. */
 257   }                             /* end if (superuser). */
 258   if (chmod("foo", ALL_BITS) != 0) e(66);
 259   Stat("foo", &st1);
 260   if (chown("foo", geteuid(), getegid()) != 0) e(67);
 261   Stat("foo", &st2);
 262   if ((st1.st_mode & ALL_BITS) != ALL_BITS) e(68);      /* See intro! */
 263   if (superuser)
 264         if ((st2.st_mode & ALL_RWXB) != ALL_RWXB) e(69);
 265   if (!superuser)
 266         if ((st2.st_mode & ALL_BITS) != ALL_RWXB) e(70);
 267
 268   (void) system("chmod 777 ../DIR_34/* > /dev/null 2> /dev/null");
 269   System("rm -rf ../DIR_34/*");
 270 }
 271
 272 void test34b()
 273 {
 274   time_t time1, time2;
 275   mode_t mod;
 276   struct stat st1, st2;
 277
 278   subtest = 2;
 279
 280   /* Test chmod() and chown() on non regular files and on MaxName and
 281    * MaxPath. * Funny, but dirs should also have S_IS.ID bits.
 282    */
 283   Mkfifo("fifo");
 284   Mkdir("dir");
 285   Creat(MaxName);
 286   MaxPath[strlen(MaxPath) - 2] = '/';
 287   MaxPath[strlen(MaxPath) - 1] = 'a';   /* make ././.../a */
 288   Creat(MaxPath);
 289
 290   for (mod = 1; mod <= ALL_BITS; mod <<= 1) {
 291         if ((mod & ALL_BITS) != mod) continue;  /* bad mod */
 292         Stat("dir", &st1);
 293         if (time(&time1) == (time_t) -1) e(1);
 294         if (chmod("dir", mod) != 0) e(2);
 295         Stat("dir", &st2);
 296         if (time(&time2) == (time_t) -1) e(3);
 297         if (superuser)
 298                 if ((st2.st_mode & ALL_BITS) != mod) e(4);
 299         if (!superuser)
 300                 if ((st2.st_mode & ALL_RWXB) != (mod & ALL_RWXB)) e(5);
 301
 302         /* Test the C time field. */
 303         if (st1.st_ctime > st2.st_ctime) e(6);
 304         if (st1.st_ctime > time1) e(7);
 305         if (st1.st_ctime > time2) e(8);
 306 #ifndef V1_FILESYSTEM
 307         if (st2.st_ctime < time1) e(9);
 308 #endif
 309         if (st2.st_ctime > time2) e(10);
 310         if (st1.st_atime != st2.st_atime) e(11);
 311         if (st1.st_mtime != st2.st_mtime) e(12);
 312
 313         Stat("fifo", &st1);
 314         if (time(&time1) == (time_t) -1) e(13);
 315         if (chmod("fifo", mod) != 0) e(14);
 316         Stat("fifo", &st2);
 317         if (time(&time2) == (time_t) -1) e(15);
 318         if (superuser)
 319                 if ((st2.st_mode & ALL_BITS) != mod) e(16);
 320         if (!superuser)
 321                 if ((st2.st_mode & ALL_RWXB) != (mod & ALL_RWXB)) e(17);
 322
 323         /* Test the C time field. */
 324         if (st1.st_ctime > st2.st_ctime) e(18);
 325         if (st1.st_ctime > time1) e(19);
 326         if (st1.st_ctime > time2) e(20);
 327 #ifndef V1_FILESYSTEM
 328         if (st2.st_ctime < time1) e(21);
 329 #endif
 330         if (st2.st_ctime > time2) e(22);
 331         if (st1.st_atime != st2.st_atime) e(23);
 332         if (st1.st_mtime != st2.st_mtime) e(24);
 333
 334         Stat(MaxName, &st1);
 335         if (time(&time1) == (time_t) -1) e(25);
 336         if (chmod(MaxName, mod) != 0) e(26);
 337         Stat(MaxName, &st2);
 338         if (time(&time2) == (time_t) -1) e(27);
 339         if (superuser)
 340                 if ((st2.st_mode & ALL_BITS) != mod) e(28);
 341         if (!superuser)
 342                 if ((st2.st_mode & ALL_RWXB) != (mod & ALL_RWXB)) e(29);
 343
 344         /* Test the C time field. */
 345         if (st1.st_ctime > st2.st_ctime) e(30);
 346         if (st1.st_ctime > time1) e(31);
 347         if (st1.st_ctime > time2) e(32);
 348 #ifndef V1_FILESYSTEM
 349         if (st2.st_ctime < time1) e(33);
 350 #endif
 351         if (st2.st_ctime > time2) e(34);
 352         if (st1.st_atime != st2.st_atime) e(35);
 353         if (st1.st_mtime != st2.st_mtime) e(36);
 354
 355         Stat(MaxPath, &st1);
 356         if (time(&time1) == (time_t) -1) e(37);
 357         if (chmod(MaxPath, mod) != 0) e(38);
 358         Stat(MaxPath, &st2);
 359         if (time(&time2) == (time_t) -1) e(39);
 360         if (superuser)
 361                 if ((st2.st_mode & ALL_BITS) != mod) e(40);
 362         if (!superuser)
 363                 if ((st2.st_mode & ALL_RWXB) != (mod & ALL_RWXB)) e(41);
 364
 365         /* Test the C time field. */
 366         if (st1.st_ctime > st2.st_ctime) e(42);
 367         if (st1.st_ctime > time1) e(43);
 368         if (st1.st_ctime > time2) e(44);
 369 #ifndef V1_FILESYSTEM
 370         if (st2.st_ctime < time1) e(45);
 371 #endif
 372         if (st2.st_ctime > time2) e(46);
 373         if (st1.st_atime != st2.st_atime) e(47);
 374         if (st1.st_mtime != st2.st_mtime) e(48);
 375   }
 376
 377   if (chmod("dir", 0777) != 0) e(49);
 378   if (chmod("fifo", 0777) != 0) e(50);
 379   if (chmod(MaxName, 0777) != 0) e(51);
 380   if (chmod(MaxPath, 0777) != 0) e(52);
 381
 382   (void) system("chmod 777 ../DIR_34/* > /dev/null 2> /dev/null");
 383   System("rm -rf ../DIR_34/*");
 384 }
 385
 386 void test34c()
 387 {
 388   struct stat st;
 389   uid_t uid, uid2;
 390   gid_t gid, gid2;
 391   int fd, does_truncate, stat_loc;
 392
 393   subtest = 3;
 394
 395   Mkdir("dir");
 396   Creat("dir/try_me");
 397
 398   /* Disalow search permission and see if chmod() and chown() return
 399    * EACCES.
 400    */
 401   if (chmod("dir", ALL_BITS & ~S_IXUSR) != 0) e(1);
 402   if (!superuser) {
 403         if (chmod("dir/try_me", 0) != -1) e(2);
 404         if (errno != EACCES) e(3);
 405         if (I_can_chown) {
 406                 if (chown("dir/try_me", geteuid(), getegid()) != -1) e(4);
 407                 if (errno != EACCES) e(5);
 408         }
 409   }
 410
 411   /* Check ENOTDIR. */
 412   Mkfifo("fifo");
 413   if (chmod("fifo/try_me", 0) != -1) e(6);
 414   if (errno != ENOTDIR) e(7);
 415   if (chown("fifo/try_me", geteuid(), getegid()) != -1) e(8);
 416   if (errno != ENOTDIR) e(9);
 417
 418   Creat("file");
 419   if (chmod("file/try_me", 0) != -1) e(10);
 420   if (errno != ENOTDIR) e(11);
 421   if (chown("file/try_me", geteuid(), getegid()) != -1) e(12);
 422   if (errno != ENOTDIR) e(13);
 423
 424   /* Check empty path. */
 425   if (chmod("", 0) != -1) e(14);
 426   if (errno != ENOENT) e(15);
 427   if (chown("", geteuid(), getegid()) != -1) e(16);
 428   if (errno != ENOENT) e(17);
 429
 430   /* Check non existing file name. */
 431   if (chmod("non_exist", 0) != -1) e(18);
 432   if (errno != ENOENT) e(19);
 433   if (chown("non_exist", geteuid(), getegid()) != -1) e(20);
 434   if (errno != ENOENT) e(21);
 435
 436   /* Check what we get if we do not have permisson. */
 437   if (!superuser) {
 438         Stat("/", &st);
 439         if (st.st_uid == geteuid()) e(22);
 440
 441         /* First I had 0, I changed it to st.st_mode 8-). */
 442         if (chmod("/", st.st_mode) != -1) e(23);
 443         if (errno != EPERM) e(24);
 444   }
 445   if (!I_can_chown) {
 446         Stat("/", &st);
 447         if (st.st_uid == geteuid()) e(25);
 448         if (chown("/", geteuid(), getegid()) != -1) e(26);
 449         if (errno != EPERM) e(27);
 450   }
 451
 452   /* If we are superuser, we can test all id combinations. */
 453   if (superuser) {
 454         switch (fork()) {
 455             case -1:    printf("Can't fork\n"); break;
 456             case 0:
 457                 alarm(20);
 458
 459                 getids(&uid, &gid);
 460                 if (uid == 0) {
 461                         getids(&uid, &gid);
 462                         if (uid == 0) e(28);
 463                 }
 464                 getids(&uid2, &gid2);
 465                 if (gid == gid2) e(29);
 466                 if (uid == uid2) e(30);
 467
 468                 /* Creat boo, owned by root. */
 469                 Creat("boo");
 470                 if (chmod("boo", ALL_BITS) != 0) e(31);
 471
 472                 /* Creat boo for user uid2 of group gid2. */
 473                 Creat("bar");
 474                 if (chown("bar", uid2, gid2) != 0) e(32);
 475                 if (chmod("bar", ALL_BITS) != 0) e(33);
 476
 477                 /* Creat my_gid for user uid2 of group gid. */
 478                 Creat("my_gid");
 479                 if (chown("my_gid", uid2, gid) != 0) e(34);
 480                 if (chmod("my_gid", ALL_BITS) != 0) e(35);
 481
 482                 /* Creat my_uid for user uid of uid gid. */
 483                 Creat("my_uid");
 484                 if (chown("my_uid", uid, gid) != 0) e(36);
 485                 if (chmod("my_uid", ALL_BITS) != 0) e(37);
 486
 487                 /* We now become user uid of uid gid. */
 488                 setgid(gid);
 489                 setuid(uid);
 490
 491                 if (chown("boo", uid, gid) != -1) e(38);
 492                 if (errno != EPERM) e(39);
 493                 if (chown("bar", uid, gid) != -1) e(40);
 494                 if (errno != EPERM) e(41);
 495                 if (chown("my_gid", uid, gid) != -1) e(42);
 496                 if (errno != EPERM) e(43);
 497                 if (chown("my_uid", uid, gid2) != -1) e(44);
 498
 499                 /* The EPERM is not strict POSIX. */
 500                 if (errno != EPERM) e(45);
 501
 502                 if (chmod("boo", 0) != -1) e(46);
 503                 if (errno != EPERM) e(47);
 504                 if (chmod("bar", 0) != -1) e(48);
 505                 if (errno != EPERM) e(49);
 506                 if (chmod("my_gid", 0) != -1) e(50);
 507                 if (errno != EPERM) e(51);
 508
 509                 exit(0);
 510             default:
 511                 wait(&stat_loc);
 512                 if (stat_loc != 0) e(52);       /* Alarm? */
 513         }
 514   }
 515
 516   /* Check too long path ed. */
 517   does_truncate = does_fs_truncate();
 518   fd = creat(NameTooLong, 0777);
 519   if (does_truncate) {
 520         if (fd == -1) e(53);
 521         if (close(fd) != 0) e(54);
 522         if (chmod(NameTooLong, 0777) != 0) e(55);
 523         if (chown(NameTooLong, geteuid(), getegid()) != 0) e(56);
 524   } else {
 525         if (fd != -1) e(57);
 526         if (errno != ENAMETOOLONG) e(58);
 527         (void) close(fd);               /* Just in case */
 528   }
 529
 530   /* Make PathTooLong contain ././.../a */
 531   PathTooLong[strlen(PathTooLong) - 2] = '/';
 532   PathTooLong[strlen(PathTooLong) - 1] = 'a';
 533   Creat("a");
 534   if (chmod(PathTooLong, 0777) != -1) e(59);
 535   if (errno != ENAMETOOLONG) e(60);
 536   if (chown(PathTooLong, geteuid(), getegid()) != -1) e(61);
 537   if (errno != ENAMETOOLONG) e(62);
 538
 539   (void) system("chmod 777 ../DIR_34/* > /dev/null 2> /dev/null");
 540   System("rm -rf ../DIR_34/*");
 541 }
 542
 543 void makelongnames()
 544 {
 545   register int i;
 546   int max_name_length;
 547
 548   max_name_length = name_max("."); /* Aka NAME_MAX, but not every FS supports
 549                                     * the same length, hence runtime check */
 550   MaxName = malloc(max_name_length + 1);
 551   NameTooLong = malloc(max_name_length + 1 + 1); /* Name of maximum +1 length */
 552   memset(MaxName, 'a', max_name_length);
 553   MaxName[max_name_length] = '\0';
 554
 555   for (i = 0; i < PATH_MAX - 1; i++) {  /* idem path */
 556         MaxPath[i++] = '.';
 557         MaxPath[i] = '/';
 558   }
 559   MaxPath[PATH_MAX - 1] = '\0';
 560
 561   strcpy(NameTooLong, MaxName); /* copy them Max to ToLong */
 562   strcpy(PathTooLong, MaxPath);
 563
 564   NameTooLong[max_name_length] = 'a';
 565   NameTooLong[max_name_length+1] = '\0';/* extend ToLongName by one too many */
 566   PathTooLong[PATH_MAX - 1] = '/';
 567   PathTooLong[PATH_MAX] = '\0'; /* inc ToLongPath by one */
 568 }
 569
 570 /* Getids returns a valid uid and gid. Is used PASSWD FILE.
 571  * It assumes the following format for a passwd file line:
 572  * <user_name>:<passwd>:<uid>:<gid>:<other_stuff>
 573  * If no uids and gids can be found, it will only return 0 ids.
 574  */
 575 void getids(r_uid, r_gid)
 576 uid_t * r_uid;
 577 gid_t * r_gid;
 578 {
 579   char line[N];
 580   unsigned char *p;
 581   uid_t uid;
 582   gid_t gid;
 583   FILE *fp;
 584   int i;
 585
 586   static uid_t a_uid[N];        /* Array for uids. */
 587   static gid_t a_gid[N];        /* Array for gids. */
 588   static int nuid = 0, ngid = 0;/* The number of user & group ids. */
 589   static int cuid = 0, cgid = 0;/* The current id index. */
 590
 591   /* If we don't have any uids go read some from the passwd file. */
 592   if (nuid == 0) {
 593         a_uid[nuid++] = 0;      /* Root uid and gid. */
 594         a_gid[ngid++] = 0;
 595         if ((fp = fopen(PASSWD_FILE, "r")) == NULL) {
 596                 printf("Can't open ");
 597                 perror(PASSWD_FILE);
 598         }
 599         while (fp != NULL && fgets(line, sizeof(line), fp) != NULL) {
 600                 p = (unsigned char *)strchr(line, ':');
 601                 if (p != NULL) p = (unsigned char *)strchr((char *)p + 1, ':');
 602                 if (p != NULL) {
 603                         p++;
 604                         uid = 0;
 605                         while (isdigit(*p)) {
 606                                 uid *= 10;
 607                                 uid += (uid_t) (*p - '0');
 608                                 p++;
 609                         }
 610                         if (*p != ':') continue;
 611                         p++;
 612                         gid = 0;
 613                         while (isdigit(*p)) {
 614                                 gid *= 10;
 615                                 gid += (gid_t) (*p - '0');
 616                                 p++;
 617                         }
 618                         if (*p != ':') continue;
 619                         if (nuid < N) {
 620                                 for (i = 0; i < nuid; i++)
 621                                         if (a_uid[i] == uid) break;
 622                                 if (i == nuid) a_uid[nuid++] = uid;
 623                         }
 624                         if (ngid < N) {
 625                                 for (i = 0; i < ngid; i++)
 626                                         if (a_gid[i] == gid) break;
 627                                 if (i == ngid) a_gid[ngid++] = gid;
 628                         }
 629                         if (nuid >= N && ngid >= N) break;
 630                 }
 631         }
 632         if (fp != NULL) fclose(fp);
 633   }
 634
 635   /* We now have uids and gids in a_uid and a_gid. */
 636   if (cuid >= nuid) cuid = 0;
 637   if (cgid >= ngid) cgid = 0;
 638   *r_uid = a_uid[cuid++];
 639   *r_gid = a_gid[cgid++];
 640 }