uess_test.c

   1 /*
   2   a simple UESS test harness for AIX
   3
   4   Andrew Tridgell <tridge@au.ibm.com>
   5   January 2004
   6
   7
   8   Usage:
   9       uess_test <MODULE_NAME> <nloops>
  10
  11   for example "uess_test LDAP" will load the LDAP module using methods.cfg
  12   and will call directly into the supplied methods
  13
  14   If nloops is not supplied then 1 is assumed. Note that the built-in
  15   memory leak checking can only be performed with nloops > 1
  16
  17
  18   You can force uess_test not to free the gr_passwd entry in struct group by setting the
  19   environment variable "DONT_FREE_GR_PASSWD". This is needed for the AIX 5.2 LDAP module,
  20   as it incorrectly returns a constant string in that field.
  21
  22
  23   I also strongly recommend you run this test program with the following malloc debug options set:
  24
  25     MALLOCDEBUG=validate_ptrs,report_allocations,record_allocations
  26     MALLOCTYPE=debug
  27
  28
  29   Thanks to Julianne Haugh for assistance in understanding the UESS interface.
  30
  31 */
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <pwd.h>
  36 #include <grp.h>
  37 #include <errno.h>
  38 #include <string.h>
  39 #include <sys/types.h>
  40 #include <usersec.h>
  41 #include <malloc.h>
  42
  43
  44 static struct secmethod_table *methods;
  45 static int err_count;
  46
  47 #define INVALID_STRING "INVALID"
  48 #define INVALID_INT    123456
  49
  50 /*
  51   test method_attrlist
  52  */
  53 static void test_attrlist(void)
  54 {
  55         attrlist_t **a;
  56         int i;
  57
  58         if (!methods->method_attrlist) {
  59                 printf("WARNING: module has no method_attrlist\n");
  60                 return;
  61         }
  62
  63         printf("\ntesting method_attrlist\n");
  64
  65         a = methods->method_attrlist();
  66         if (!a) {
  67                 printf("ERROR: attrlist failed - %s\n", strerror(errno));
  68                 err_count++;
  69                 return;
  70         }
  71
  72         for (i=0;a[i];i++) {
  73                 printf("\tattrib '%s' flags=0x%x type=%d\n",
  74                        a[i]->al_name, a[i]->al_flags, a[i]->al_type);
  75                 free(a[i]->al_name);
  76         }
  77         free(a);
  78 }
  79
  80
  81 /*
  82   test listing users
  83 */
  84 static void test_userlist(void)
  85 {
  86         int ret;
  87         attrval_t a;
  88         char *attribs = "users";
  89         char *s;
  90
  91         if (!methods->method_getentry) {
  92                 printf("WARNING: module has no method_getentry\n");
  93                 return;
  94         }
  95
  96         printf("\ntesting method_getentry(ALL, user)\n");
  97
  98         ret = methods->method_getentry("ALL", "user", &attribs, &a, 1);
  99         if (ret != 0) {
 100                 printf("ERROR: method_getentry failed ret=%d - %s\n", ret, strerror(errno));
 101                 err_count++;
 102                 return;
 103         }
 104
 105         printf("\tattr_flag=%d ptr=%p\n", a.attr_flag, a.attr_un.au_char);
 106         for (s=a.attr_un.au_char; s && *s; s += strlen(s) + 1) {
 107                 printf("\t'%s'\n", s);
 108         }
 109
 110         free(a.attr_un.au_char);
 111
 112         /* try an invalid table */
 113         printf("Trying an invalid table\n");
 114         ret = methods->method_getentry("ALL", INVALID_STRING, &attribs, &a, 1);
 115         if (ret == 0 || errno != ENOSYS) {
 116                 printf("ERROR: method_getentry expected\n\t%d/%s\n", -1, strerror(ENOSYS));
 117                 printf("got\t%d/%s\n", ret, strerror(errno));
 118                 err_count++;
 119         }
 120
 121         printf("Trying an invalid user\n");
 122         ret = methods->method_getentry(INVALID_STRING, "user", &attribs, &a, 1);
 123         if (ret == 0 || errno != ENOENT) {
 124                 printf("ERROR: method_getentry expected\n\t%d/%s\n", -1, strerror(ENOENT));
 125                 printf("got\t%d/%s\n", ret, strerror(errno));
 126                 err_count++;
 127         }
 128
 129 }
 130
 131 /*
 132   test listing groups
 133 */
 134 static void test_grouplist(void)
 135 {
 136         int ret;
 137         attrval_t a;
 138         char *attribs = "groups";
 139         char *s;
 140
 141         if (!methods->method_getentry) {
 142                 printf("WARNING: module has no method_getentry\n");
 143                 return;
 144         }
 145
 146         printf("\ntesting method_getentry(ALL, group)\n");
 147
 148         ret = methods->method_getentry("ALL", "group", &attribs, &a, 1);
 149         if (ret != 0) {
 150                 printf("ERROR: method_getentry failed ret=%d - %s\n", ret, strerror(errno));
 151                 err_count++;
 152                 return;
 153         }
 154
 155         printf("\tattr_flag=%d ptr=%p\n", a.attr_flag, a.attr_un.au_char);
 156         for (s=a.attr_un.au_char; s && *s; s += strlen(s) + 1) {
 157                 printf("\t'%s'\n", s);
 158         }
 159
 160         free(a.attr_un.au_char);
 161
 162
 163         printf("Trying an invalid group\n");
 164         ret = methods->method_getentry(INVALID_STRING, "group", &attribs, &a, 1);
 165         if (ret == 0 || errno != ENOENT) {
 166                 printf("ERROR: method_getentry expected\n\t%d/%s\n", -1, strerror(ENOENT));
 167                 printf("got\t%d/%s\n", ret, strerror(errno));
 168                 err_count++;
 169         }
 170 }
 171
 172
 173 static void show_pwd(struct passwd *pwd)
 174 {
 175         printf("\t%s:%s:%d:%d:%s:%s:%s\n",
 176                pwd->pw_name,
 177                pwd->pw_passwd,
 178                pwd->pw_uid,
 179                pwd->pw_gid,
 180                pwd->pw_gecos,
 181                pwd->pw_dir,
 182                pwd->pw_shell);
 183 }
 184
 185 static void free_pwd(struct passwd *pwd)
 186 {
 187         free(pwd->pw_name);
 188         free(pwd->pw_passwd);
 189         free(pwd->pw_gecos);
 190         free(pwd->pw_dir);
 191         free(pwd->pw_shell);
 192         free(pwd);
 193 }
 194
 195
 196 static void show_grp(struct group *grp)
 197 {
 198         int i;
 199
 200         printf("\t%s:%s:%d: ",
 201                grp->gr_name,
 202                grp->gr_passwd,
 203                grp->gr_gid);
 204
 205         if (!grp->gr_mem[0]) {
 206                 printf("\n");
 207                 return;
 208         }
 209
 210         for (i=0; grp->gr_mem[i+1]; i++) {
 211                 printf("%s, ", grp->gr_mem[i]);
 212         }
 213         printf("%s\n", grp->gr_mem[i]);
 214 }
 215
 216 static void free_grp(struct group *grp)
 217 {
 218         int i;
 219
 220         free(grp->gr_name);
 221         if (!getenv("DONT_FREE_GR_PASSWD")) {
 222                 free(grp->gr_passwd);
 223         }
 224
 225         if (!grp->gr_mem) {
 226                 free(grp);
 227                 return;
 228         }
 229
 230         for (i=0; grp->gr_mem[i]; i++) {
 231                 free(grp->gr_mem[i]);
 232         }
 233
 234         free(grp->gr_mem);
 235         free(grp);
 236 }
 237
 238
 239 /*
 240   test method_getpwnam
 241 */
 242 static void test_getpwnam(char *name)
 243 {
 244         struct passwd *pwd;
 245
 246         printf("\ntesting method_getpwnam for user '%s'\n", name);
 247
 248         pwd = methods->method_getpwnam(name);
 249
 250         if (strcmp(name, INVALID_STRING) == 0) {
 251                 if (pwd || errno != ENOENT) {
 252                         printf("ERROR: method_getpwnam expected\n\t%p/%s\n", 0, strerror(ENOENT));
 253                         printf("got\t%p/%s\n", pwd, strerror(errno));
 254                         err_count++;
 255                 }
 256                 return;
 257         }
 258
 259         if (!pwd) {
 260                 printf("ERROR: method_getpwnam failed - %s\n", strerror(errno));
 261                 err_count++;
 262                 return;
 263         }
 264
 265         show_pwd(pwd);
 266         free_pwd(pwd);
 267 }
 268
 269 /*
 270   test method_getpwuid
 271 */
 272 static void test_getpwuid(int uid)
 273 {
 274         struct passwd *pwd;
 275
 276         printf("\ntesting method_getpwuid for uid %d\n", uid);
 277
 278         pwd = methods->method_getpwuid(uid);
 279
 280         if (uid == INVALID_INT) {
 281                 if (pwd || errno != ENOENT) {
 282                         printf("ERROR: method_getpwuid expected\n\t%p/%s\n", 0, strerror(ENOENT));
 283                         printf("got\t%p/%s\n", pwd, strerror(errno));
 284                         err_count++;
 285                 }
 286                 return;
 287         }
 288
 289         if (!pwd) {
 290                 printf("ERROR: method_getpwuid failed - %s\n", strerror(errno));
 291                 err_count++;
 292                 return;
 293         }
 294
 295         show_pwd(pwd);
 296         free_pwd(pwd);
 297 }
 298
 299
 300 /*
 301   test method_getgrnam
 302 */
 303 static void test_getgrnam(char *name)
 304 {
 305         struct group *grp;
 306
 307         printf("\ntesting method_getgrnam for group '%s'\n", name);
 308
 309         grp = methods->method_getgrnam(name);
 310         if (strcmp(name, INVALID_STRING) == 0) {
 311                 if (grp || errno != ENOENT) {
 312                         printf("ERROR: method_getgrnam expected\n\t%p/%s\n", 0, strerror(ENOENT));
 313                         printf("got\t%p/%s\n", grp, strerror(errno));
 314                         err_count++;
 315                 }
 316                 return;
 317         }
 318
 319
 320         if (!grp) {
 321                 printf("ERROR: method_getgrnam failed - %s\n", strerror(errno));
 322                 err_count++;
 323                 return;
 324         }
 325
 326         show_grp(grp);
 327         free_grp(grp);
 328 }
 329
 330 /*
 331   test method_getgracct
 332 */
 333 static void test_getgracct(char *name)
 334 {
 335         struct group *grp;
 336         int gid;
 337
 338         printf("\ntesting method_getgracct for group '%s'\n", name);
 339
 340         grp = methods->method_getgracct((void *)name, 1);
 341
 342         if (strcmp(name, INVALID_STRING) == 0) {
 343                 if (grp || errno != ENOENT) {
 344                         printf("ERROR: method_getgracct expected\n\t%p/%s\n", 0, strerror(ENOENT));
 345                         printf("got\t%p/%s\n", grp, strerror(errno));
 346                         err_count++;
 347                 }
 348                 return;
 349         }
 350
 351         if (!grp) {
 352                 printf("ERROR: method_getgracct(name, 1) failed - %s\n", strerror(errno));
 353                 err_count++;
 354                 return;
 355         }
 356
 357         gid = grp->gr_gid;
 358         show_grp(grp);
 359         free_grp(grp);
 360
 361         grp = methods->method_getgracct((void *)&gid, 0);
 362         if (!grp) {
 363                 printf("ERROR: method_getgracct(gid, 0) failed - %s\n", strerror(errno));
 364                 err_count++;
 365                 return;
 366         }
 367
 368         show_grp(grp);
 369         free_grp(grp);
 370 }
 371
 372 /*
 373   test method_getgrset
 374 */
 375 static void test_getgrset(char *name)
 376 {
 377         char *grps;
 378
 379         printf("\ntesting method_getgrset for user '%s'\n", name);
 380
 381         grps = methods->method_getgrset(name);
 382
 383         if (strcmp(name, INVALID_STRING) == 0) {
 384                 if (grps || errno != ENOENT) {
 385                         printf("ERROR: method_getgrset expected\n\t%p/%s\n", 0, strerror(ENOENT));
 386                         printf("got\t%p/%s\n", grps, strerror(errno));
 387                         err_count++;
 388                 }
 389                 return;
 390         }
 391
 392         if (!grps) {
 393                 printf("ERROR: method_getgrset failed - %s\n", strerror(errno));
 394                 err_count++;
 395                 return;
 396         }
 397
 398         printf("\t%s\n", grps);
 399
 400         free(grps);
 401 }
 402
 403 /*
 404   test method_normalize
 405 */
 406 static void test_normalize(char *name)
 407 {
 408         int ret;
 409         char shortname[S_NAMELEN];
 410
 411         printf("\ntesting method_normalize for user '%s' (namelen=%d)\n",
 412                name, S_NAMELEN);
 413
 414         ret = methods->method_normalize(name, shortname);
 415
 416         if (strcmp(name, INVALID_STRING) == 0) {
 417                 /* there seems to be no defined behaviour for this?! */
 418                 return;
 419         }
 420
 421         if (ret == 0) {
 422                 printf("ERROR: method_normalize failed - %s\n", strerror(errno));
 423                 err_count++;
 424                 return;
 425         }
 426
 427         printf("\t%s\n", shortname);
 428 }
 429
 430 /*
 431   test method_getgrgid
 432 */
 433 static void test_getgrgid(int gid)
 434 {
 435         struct group *grp;
 436
 437         printf("\ntesting method_getgrgid for gid %d\n", gid);
 438
 439         grp = methods->method_getgrgid(gid);
 440         if (gid == INVALID_INT) {
 441                 if (grp || errno != ENOENT) {
 442                         printf("ERROR: method_getgrgid expected\n\t%p/%s\n", 0, strerror(ENOENT));
 443                         printf("got\t%p/%s\n", grp, strerror(errno));
 444                         err_count++;
 445                 }
 446                 return;
 447         }
 448
 449         if (!grp) {
 450                 printf("ERROR: method_getgrgid failed - %s\n", strerror(errno));
 451                 err_count++;
 452                 return;
 453         }
 454
 455         show_grp(grp);
 456         free_grp(grp);
 457 }
 458
 459
 460 /*
 461   loop over all users
 462 */
 463 static void forallusers(void (*fn)(char *name))
 464 {
 465         int ret;
 466         attrval_t a;
 467         char *attribs = "users";
 468         char *s;
 469
 470         if (!methods->method_getentry) {
 471                 return;
 472         }
 473         ret = methods->method_getentry("ALL", "user", &attribs, &a, 1);
 474         if (ret != 0) {
 475                 return;
 476         }
 477         for (s=a.attr_un.au_char; s && *s; s += strlen(s) + 1) {
 478                 fn(s);
 479         }
 480
 481         free(a.attr_un.au_char);
 482
 483         fn(INVALID_STRING);
 484 }
 485
 486
 487 /*
 488   loop over all groups
 489 */
 490 static void forallgroups(void (*fn)(char *name))
 491 {
 492         int ret;
 493         attrval_t a;
 494         char *attribs = "groups";
 495         char *s;
 496
 497         if (!methods->method_getentry) {
 498                 return;
 499         }
 500         ret = methods->method_getentry("ALL", "group", &attribs, &a, 1);
 501         if (ret != 0) {
 502                 return;
 503         }
 504         for (s=a.attr_un.au_char; s && *s; s += strlen(s) + 1) {
 505                 fn(s);
 506         }
 507
 508         free(a.attr_un.au_char);
 509
 510         fn(INVALID_STRING);
 511 }
 512
 513 /*
 514   loop over all uids
 515 */
 516 static void foralluids(void (*fn)(int uid))
 517 {
 518         int ret;
 519         attrval_t a;
 520         char *attribs = "users";
 521         char *s;
 522
 523         if (!methods->method_getentry) {
 524                 return;
 525         }
 526         ret = methods->method_getentry("ALL", "user", &attribs, &a, 1);
 527         if (ret != 0) {
 528                 return;
 529         }
 530         for (s=a.attr_un.au_char; s && *s; s += strlen(s) + 1) {
 531                 attrval_t a2;
 532                 char *id_attribs = S_ID;
 533                 ret = methods->method_getentry(s, "user", &id_attribs, &a2, 1);
 534                 if (ret != 0) {
 535                         printf("ERROR: failed to get S_ID for '%s' - ret=%d - %s\n",
 536                                s, ret, strerror(errno));
 537                         err_count++;
 538                 }
 539                 fn(a2.attr_un.au_int);
 540         }
 541
 542         free(a.attr_un.au_char);
 543
 544         fn(INVALID_INT);
 545 }
 546
 547 /*
 548   loop over all gids
 549 */
 550 static void forallgids(void (*fn)(int gid))
 551 {
 552         int ret;
 553         attrval_t a;
 554         char *attribs = "groups";
 555         char *s;
 556
 557         if (!methods->method_getentry) {
 558                 return;
 559         }
 560         ret = methods->method_getentry("ALL", "group", &attribs, &a, 1);
 561         if (ret != 0) {
 562                 return;
 563         }
 564         for (s=a.attr_un.au_char; s && *s; s += strlen(s) + 1) {
 565                 attrval_t a2;
 566                 char *id_attribs = S_ID;
 567                 ret = methods->method_getentry(s, "group", &id_attribs, &a2, 1);
 568                 if (ret != 0) {
 569                         printf("ERROR: failed to get S_ID for '%s' - ret=%d - %s\n",
 570                                s, ret, strerror(errno));
 571                         err_count++;
 572                 }
 573                 fn(a2.attr_un.au_int);
 574         }
 575
 576         free(a.attr_un.au_char);
 577
 578         fn(INVALID_INT);
 579 }
 580
 581
 582 /*
 583   the main test harness
 584 */
 585 static void uess_test(void)
 586 {
 587         test_attrlist();
 588
 589         test_userlist();
 590
 591         test_grouplist();
 592
 593         if (methods->method_getpwnam) {
 594                 forallusers(test_getpwnam);
 595         }
 596         if (methods->method_getpwuid) {
 597                 foralluids(test_getpwuid);
 598         }
 599         if (methods->method_getgrset) {
 600                 forallusers(test_getgrset);
 601         }
 602         if (methods->method_normalize) {
 603                 forallusers(test_normalize);
 604         }
 605         if (methods->method_getgrnam) {
 606                 forallgroups(test_getgrnam);
 607         }
 608         if (methods->method_getgracct) {
 609                 forallgroups(test_getgracct);
 610         }
 611         if (methods->method_getgrgid) {
 612                 forallgids(test_getgrgid);
 613         }
 614 }
 615
 616
 617 /*
 618   return the current size of the heap (in blocks)
 619 */
 620 static unsigned long heap_size(void)
 621 {
 622         struct mallinfo m = mallinfo();
 623         return m.ordblks + m.smblks;
 624 }
 625
 626
 627 struct secmethod_desc {
 628         char *name;
 629         char *module_path;
 630         struct secmethod_table *methods;
 631 };
 632
 633 extern struct secmethod_desc *_load_secmethod(const char *name);
 634
 635 int main(int argc, const char *argv[])
 636 {
 637         const char *name;
 638         struct secmethod_desc *r;
 639         int i, nloops = 1;
 640         unsigned long prev_alloc = 0;
 641
 642         if (argc < 2) {
 643                 printf("Usage: uess_test <MODULE_NAME> <nloops>\n");
 644                 exit(1);
 645         }
 646
 647         name = argv[1];
 648
 649         if (argc > 2) {
 650                 nloops = atoi(argv[2]);
 651         }
 652
 653         errno = 0;
 654
 655         r = _load_secmethod(name);
 656
 657         if (!r) {
 658                 printf("Unable to load module '%s'\n", name);
 659                 exit(1);
 660         }
 661
 662         printf("Loaded '%s' with path '%s'\n", r->name, r->module_path);
 663         printf("method_version=%d\n", r->methods->method_version);
 664
 665         methods = r->methods;
 666
 667         for (i=0;i<nloops; i++) {
 668                 unsigned long hsize;
 669
 670                 printf("Test loop %d\n", i);
 671
 672                 uess_test();
 673
 674                 hsize = heap_size();
 675
 676                 if (prev_alloc && hsize > prev_alloc) {
 677                         printf("ERROR: heap grew by %d blocks. Probable memory leak\n",
 678                                hsize - prev_alloc);
 679                         err_count++;
 680                 }
 681                 prev_alloc = hsize;
 682         }
 683
 684         if (err_count != 0) {
 685                 printf("WARNING: %d errors detected\n", err_count);
 686         }
 687
 688         return err_count;
 689 }