Debian Codegraph @

tests/testsuite.c

raw
1 #include "config.h"
2
3 #include <stdarg.h>
4 #include <stddef.h>
5 #include <stdint.h>
6 #include <setjmp.h>
7 #include <cmocka.h>
8
9 #include <errno.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13 #include <stdbool.h>
14 #include <unistd.h>
15
16 /*
17 * Defining _POSIX_PTHREAD_SEMANTICS before including pwd.h and grp.h gives us
18 * the posix getpwnam_r(), getpwuid_r(), getgrnam_r and getgrgid_r calls on
19 * Solaris
20 */
21 #ifndef _POSIX_PTHREAD_SEMANTICS
22 #define _POSIX_PTHREAD_SEMANTICS
23 #endif
24
25 #include <sys/types.h>
26 #include <pwd.h>
27 #include <grp.h>
28
29 #include <netdb.h>
30 #include <netinet/in.h>
31 #include <arpa/inet.h>
32
33 #ifdef NDEBUG
34 #define DEBUG(...)
35 #else
36 #define DEBUG(...) printf(__VA_ARGS__)
37 #endif
38
39 #ifndef SAFE_FREE
40 #define SAFE_FREE(x) do { if ((x) != NULL) {free((x)); (x)=NULL;} } while(0)
41 #endif
42
43 static void assert_passwd_equal(const struct passwd *p1,
44 const struct passwd *p2)
45 {
46 assert_string_equal(p1->pw_name, p2->pw_name);
47 assert_string_equal(p1->pw_passwd, p2->pw_passwd);
48 assert_int_equal(p1->pw_uid, p2->pw_uid);
49 assert_int_equal(p1->pw_gid, p2->pw_gid);
50 assert_string_equal(p1->pw_gecos, p2->pw_gecos);
51 assert_string_equal(p1->pw_dir, p2->pw_dir);
52 assert_string_equal(p1->pw_shell, p2->pw_shell);
53 }
54
55 static void assert_group_equal(const struct group *g1,
56 const struct group *g2)
57 {
58 int i;
59
60 assert_string_equal(g1->gr_name, g2->gr_name);
61 assert_string_equal(g1->gr_passwd, g2->gr_passwd);
62 assert_int_equal(g1->gr_gid, g2->gr_gid);
63 assert_false(g1->gr_mem != NULL && g2->gr_mem == NULL);
64 assert_false(g1->gr_mem == NULL && g2->gr_mem != NULL);
65 if (g1->gr_mem == NULL && g2->gr_mem == NULL) {
66 return;
67 }
68 for (i=0; g1->gr_mem[i] && g2->gr_mem[i]; i++) {
69 assert_string_equal(g1->gr_mem[i], g2->gr_mem[i]);
70 }
71 }
72
73 static bool copy_passwd(const struct passwd *pwd, struct passwd *p)
74 {
75 p->pw_name = strdup(pwd->pw_name);
76 p->pw_passwd = strdup(pwd->pw_passwd);
77 p->pw_uid = pwd->pw_uid;
78 p->pw_gid = pwd->pw_gid;
79 #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
80 p->pw_class = strdup(pwd->pw_class);
81 #endif
82 #ifdef HAVE_STRUCT_PASSWD_PW_CHANGE
83 p->pw_change = pwd->pw_change;
84 #endif
85 #ifdef HAVE_STRUCT_PASSWD_PW_EXPIRE
86 p->pw_expire = pwd->pw_expire;
87 #endif
88 p->pw_gecos = strdup(pwd->pw_gecos);
89 p->pw_dir = strdup(pwd->pw_dir);
90 p->pw_shell = strdup(pwd->pw_shell);
91
92 return true;
93 }
94
95 static void free_passwd(struct passwd *p)
96 {
97 SAFE_FREE(p->pw_name);
98 SAFE_FREE(p->pw_passwd);
99 #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
100 SAFE_FREE(p->pw_class);
101 #endif
102 SAFE_FREE(p->pw_gecos);
103 SAFE_FREE(p->pw_dir);
104 SAFE_FREE(p->pw_shell);
105 }
106
107 static void free_passwds(struct passwd *pwds, size_t num_pwds)
108 {
109 size_t i;
110
111 for(i = 0; i < num_pwds; i++) {
112 free_passwd(&pwds[i]);
113 }
114 free(pwds);
115 }
116
117 static void print_passwd(struct passwd *pwd)
118 {
119 (void)pwd;
120
121 DEBUG("%s:%s:%lu:%lu:%s:%s:%s\n",
122 pwd->pw_name,
123 pwd->pw_passwd,
124 (unsigned long)pwd->pw_uid,
125 (unsigned long)pwd->pw_gid,
126 pwd->pw_gecos,
127 pwd->pw_dir,
128 pwd->pw_shell);
129 }
130
131 static bool test_nwrap_getpwnam(const char *name, struct passwd *pwd_p)
132 {
133 struct passwd *pwd = NULL;
134 bool ok;
135
136 DEBUG("Testing getpwnam: %s\n", name);
137
138 pwd = getpwnam(name);
139 if (pwd == NULL) {
140 return false;
141 }
142
143 print_passwd(pwd);
144
145 if (pwd_p == NULL) {
146 return true;
147 }
148
149 ok = copy_passwd(pwd, pwd_p);
150
151 return ok;
152 }
153
154 static void test_nwrap_getpwnam_r(const char *name,
155 struct passwd *pwd_p)
156 {
157 struct passwd pwd, *pwdp;
158 char buffer[4096];
159 int ret;
160
161 DEBUG("Testing getpwnam_r: %s\n", name);
162
163 ret = getpwnam_r(name, &pwd, buffer, sizeof(buffer), &pwdp);
164 if (ret != 0) {
165 if (ret != ENOENT) {
166 DEBUG("got %d return code\n", ret);
167 }
168 assert_true(ret);
169 }
170 assert_ptr_equal(&pwd, pwdp);
171
172 print_passwd(&pwd);
173
174 if (pwd_p) {
175 copy_passwd(&pwd, pwd_p);
176 }
177 }
178
179 static bool test_nwrap_getpwuid(uid_t uid,
180 struct passwd *pwd_p)
181 {
182 struct passwd *pwd = NULL;
183 bool ok;
184
185 DEBUG("Testing getpwuid: %lu\n", (unsigned long)uid);
186
187 pwd = getpwuid(uid);
188 if (pwd == NULL) {
189 return false;
190 }
191
192 print_passwd(pwd);
193
194 if (pwd_p == NULL) {
195 return true;
196 }
197
198 ok = copy_passwd(pwd, pwd_p);
199
200 return ok;
201 }
202
203 static bool test_nwrap_getpwuid_r(uid_t uid,
204 struct passwd *pwd_p)
205 {
206 struct passwd pwd, *pwdp;
207 char buffer[4096];
208 int ret;
209
210 DEBUG("Testing getpwuid_r: %lu\n", (unsigned long)uid);
211
212 ret = getpwuid_r(uid, &pwd, buffer, sizeof(buffer), &pwdp);
213 if (ret != 0) {
214 if (ret != ENOENT) {
215 DEBUG("got %d return code\n", ret);
216 }
217 assert_true(ret);
218 }
219 assert_ptr_equal(&pwd, pwdp);
220
221 print_passwd(&pwd);
222
223 if (pwd_p) {
224 copy_passwd(&pwd, pwd_p);
225 }
226
227 return true;
228 }
229
230 static bool copy_group(const struct group *grp,
231 struct group *g)
232 {
233 int i;
234
235 g->gr_name = strdup(grp->gr_name);
236 g->gr_passwd = strdup(grp->gr_passwd);
237 g->gr_gid = grp->gr_gid;
238 g->gr_mem = NULL;
239
240 for (i = 0; grp->gr_mem != NULL && grp->gr_mem[i] != NULL; i++) {
241 char **mem;
242
243 mem = realloc(g->gr_mem, sizeof(char *) * (i + 2));
244 assert_non_null(mem);
245 g->gr_mem = mem;
246
247 g->gr_mem[i] = strdup(grp->gr_mem[i]);
248 assert_non_null(g->gr_mem[i]);
249
250 g->gr_mem[i + 1] = NULL;
251 }
252
253 return true;
254 }
255
256 static void free_group(struct group *g)
257 {
258 SAFE_FREE(g->gr_name);
259 SAFE_FREE(g->gr_passwd);
260 if (g->gr_mem != NULL) {
261 int i;
262
263 for (i = 0; g->gr_mem[i] != NULL; i++) {
264 SAFE_FREE(g->gr_mem[i]);
265 }
266
267 SAFE_FREE(g->gr_mem);
268 }
269 }
270
271 static void free_groups(struct group *grps, size_t num_grps)
272 {
273 size_t i;
274
275 for(i = 0; i < num_grps; i++) {
276 free_group(&grps[i]);
277 }
278 free(grps);
279 }
280
281 static void print_group(struct group *grp)
282 {
283 int i;
284 DEBUG("%s:%s:%lu:",
285 grp->gr_name,
286 grp->gr_passwd,
287 (unsigned long)grp->gr_gid);
288
289 if ((grp->gr_mem == NULL) || !grp->gr_mem[0]) {
290 DEBUG("\n");
291 return;
292 }
293
294 for (i=0; grp->gr_mem[i+1]; i++) {
295 DEBUG("%s,", grp->gr_mem[i]);
296 }
297 DEBUG("%s\n", grp->gr_mem[i]);
298 }
299
300 static bool test_nwrap_getgrnam(const char *name,
301 struct group *grp_p)
302 {
303 struct group *grp = NULL;
304 bool ok;
305
306 DEBUG("Testing getgrnam: %s\n", name);
307
308 grp = getgrnam(name);
309 if (grp == NULL) {
310 return false;
311 }
312
313 print_group(grp);
314
315 if (grp_p == NULL) {
316 return true;
317 }
318
319 ok = copy_group(grp, grp_p);
320
321 return ok;
322 }
323
324 static bool test_nwrap_getgrnam_r(const char *name,
325 struct group *grp_p)
326 {
327 struct group grp, *grpp;
328 char buffer[4096];
329 int ret;
330
331 DEBUG("Testing getgrnam_r: %s\n", name);
332
333 ret = getgrnam_r(name, &grp, buffer, sizeof(buffer), &grpp);
334 if (ret != 0) {
335 if (ret != ENOENT) {
336 DEBUG("got %d return code\n", ret);
337 }
338 assert_true(ret);
339 }
340 assert_ptr_equal(&grp, grpp);
341
342 print_group(&grp);
343
344 if (grp_p) {
345 copy_group(&grp, grp_p);
346 }
347
348 return true;
349 }
350
351 static bool test_nwrap_getgrgid(gid_t gid,
352 struct group *grp_p)
353 {
354 struct group *grp = NULL;
355 bool ok;
356
357 DEBUG("Testing getgrgid: %lu\n", (unsigned long)gid);
358
359 grp = getgrgid(gid);
360 if (grp == NULL) {
361 return false;
362 }
363
364 print_group(grp);
365
366 if (grp_p == NULL) {
367 return true;
368 }
369
370 ok = copy_group(grp, grp_p);
371
372 return ok;
373 }
374
375 static bool test_nwrap_getgrgid_r(gid_t gid,
376 struct group *grp_p)
377 {
378 struct group grp, *grpp;
379 char buffer[4096];
380 int ret;
381
382 DEBUG("Testing getgrgid_r: %lu\n", (unsigned long)gid);
383
384 ret = getgrgid_r(gid, &grp, buffer, sizeof(buffer), &grpp);
385 if (ret != 0) {
386 if (ret != ENOENT) {
387 DEBUG("got %d return code\n", ret);
388 }
389 assert_true(ret);
390 }
391 assert_ptr_equal(&grp, grpp);
392
393 print_group(&grp);
394
395 if (grp_p) {
396 copy_group(&grp, grp_p);
397 }
398
399 return true;
400 }
401
402 static bool test_nwrap_enum_passwd(struct passwd **pwd_array_p,
403 size_t *num_pwd_p)
404 {
405 struct passwd *pwd;
406 struct passwd *pwd_array = NULL;
407 size_t num_pwd = 0;
408
409 DEBUG("Testing setpwent\n");
410
411 setpwent();
412
413 while ((pwd = getpwent()) != NULL) {
414 DEBUG("Testing getpwent\n");
415
416 print_passwd(pwd);
417 if (pwd_array_p && num_pwd_p) {
418 pwd_array = realloc(pwd_array, sizeof(struct passwd) * (num_pwd + 1));
419 assert_non_null(pwd_array);
420 copy_passwd(pwd, &pwd_array[num_pwd]);
421 num_pwd++;
422 }
423 }
424
425 DEBUG("Testing endpwent\n");
426 endpwent();
427
428 if (pwd_array_p) {
429 *pwd_array_p = pwd_array;
430 }
431 if (num_pwd_p) {
432 *num_pwd_p = num_pwd;
433 }
434
435 return true;
436 }
437
438 static bool test_nwrap_enum_r_passwd(struct passwd **pwd_array_p,
439 size_t *num_pwd_p)
440 {
441 struct passwd *pwd_array = NULL;
442 size_t num_pwd = 0;
443 /* Skip these tests if the platform does not provide getpwent_r() */
444 #ifdef HAVE_GETPWENT_R
445 struct passwd pwd, *pwdp;
446 char buffer[4096];
447 int ret;
448
449 DEBUG("Testing setpwent\n");
450 setpwent();
451
452 while (1) {
453 DEBUG("Testing getpwent_r\n");
454
455 #ifdef HAVE_SOLARIS_GETPWENT_R
456 pwdp = getpwent_r(&pwd, buffer, sizeof(buffer));
457 if (pwdp == NULL) {
458 break;
459 }
460 #else /* HAVE_SOLARIS_GETPWENT_R */
461 ret = getpwent_r(&pwd, buffer, sizeof(buffer), &pwdp);
462 if (ret != 0) {
463 if (ret != ENOENT) {
464 DEBUG("got %d return code\n", ret);
465 }
466 break;
467 }
468 #endif /* HAVE_SOLARIS_GETPWENT_R */
469 print_passwd(&pwd);
470 if (pwd_array_p && num_pwd_p) {
471 pwd_array = realloc(pwd_array, sizeof(struct passwd) * (num_pwd + 1));
472 assert_non_null(pwd_array);
473 copy_passwd(&pwd, &pwd_array[num_pwd]);
474 num_pwd++;
475 }
476 }
477
478 DEBUG("Testing endpwent\n");
479 endpwent();
480 #endif /* HAVE_GETPWENT_R */
481
482 if (pwd_array_p) {
483 *pwd_array_p = pwd_array;
484 }
485 if (num_pwd_p) {
486 *num_pwd_p = num_pwd;
487 }
488
489 return true;
490 }
491
492 static bool test_nwrap_passwd(void)
493 {
494 struct passwd *pwd, pwd1, pwd2;
495 size_t i, num_pwd;
496
497 test_nwrap_enum_passwd(&pwd, &num_pwd);
498
499 for (i=0; i < num_pwd; i++) {
500 test_nwrap_getpwnam(pwd[i].pw_name, &pwd1);
501 assert_passwd_equal(&pwd[i], &pwd1);
502
503 test_nwrap_getpwuid(pwd[i].pw_uid, &pwd2);
504 assert_passwd_equal(&pwd[i], &pwd2);
505 assert_passwd_equal(&pwd1, &pwd2);
506
507 free_passwd(&pwd1);
508 free_passwd(&pwd2);
509 }
510 free_passwds(pwd, num_pwd);
511
512 return true;
513 }
514
515 static void test_nwrap_passwd_r(void)
516 {
517 struct passwd *pwd, pwd1, pwd2;
518 size_t i, num_pwd;
519
520 test_nwrap_enum_r_passwd(&pwd, &num_pwd);
521
522 for (i=0; i < num_pwd; i++) {
523 test_nwrap_getpwnam_r(pwd[i].pw_name, &pwd1);
524 assert_passwd_equal(&pwd[i], &pwd1);
525
526 test_nwrap_getpwuid_r(pwd[i].pw_uid, &pwd2);
527 assert_passwd_equal(&pwd[i], &pwd2);
528
529 assert_passwd_equal(&pwd1, &pwd2);
530
531 free_passwd(&pwd1);
532 free_passwd(&pwd2);
533 }
534 free_passwds(pwd, num_pwd);
535 }
536
537 static bool test_nwrap_passwd_r_cross(void)
538 {
539 struct passwd *pwd, pwd1, pwd2, pwd3, pwd4;
540 size_t i, num_pwd;
541
542 test_nwrap_enum_r_passwd(&pwd, &num_pwd);
543
544 for (i=0; i < num_pwd; i++) {
545 test_nwrap_getpwnam_r(pwd[i].pw_name, &pwd1);
546 assert_passwd_equal(&pwd[i], &pwd1);
547
548 test_nwrap_getpwuid_r(pwd[i].pw_uid, &pwd2);
549 assert_passwd_equal(&pwd[i], &pwd2);
550
551 assert_passwd_equal(&pwd1, &pwd2);
552
553 test_nwrap_getpwnam(pwd[i].pw_name, &pwd3);
554 assert_passwd_equal(&pwd[i], &pwd3);
555
556 test_nwrap_getpwuid(pwd[i].pw_uid, &pwd4);
557 assert_passwd_equal(&pwd[i], &pwd4);
558
559 assert_passwd_equal(&pwd3, &pwd4);
560
561 free_passwd(&pwd1);
562 free_passwd(&pwd2);
563 free_passwd(&pwd3);
564 free_passwd(&pwd4);
565 }
566 free_passwds(pwd, num_pwd);
567
568 return true;
569 }
570
571 static bool test_nwrap_enum_group(struct group **grp_array_p,
572 size_t *num_grp_p)
573 {
574 struct group *grp;
575 struct group *grp_array = NULL;
576 size_t num_grp = 0;
577
578 DEBUG("Testing setgrent\n");
579 setgrent();
580
581 while ((grp = getgrent()) != NULL) {
582 DEBUG("Testing getgrent\n");
583
584 print_group(grp);
585 if (grp_array_p && num_grp_p) {
586 grp_array = realloc(grp_array, sizeof(struct group) * (num_grp + 1));
587 assert_non_null(grp_array);
588 copy_group(grp, &grp_array[num_grp]);
589 num_grp++;
590 }
591 }
592
593 DEBUG("Testing endgrent\n");
594 endgrent();
595
596 if (grp_array_p) {
597 *grp_array_p = grp_array;
598 }
599 if (num_grp_p) {
600 *num_grp_p = num_grp;
601 }
602
603 return true;
604 }
605
606 static bool test_nwrap_enum_r_group(struct group **grp_array_p,
607 size_t *num_grp_p)
608 {
609 struct group *grp_array = NULL;
610 size_t num_grp = 0;
611 /* Skip these tests if the platform does not provide getgrent_r() */
612 #ifdef HAVE_GETGRENT_R
613 struct group grp, *grpp;
614 char buffer[4096];
615 int ret;
616
617 DEBUG("Testing setgrent\n");
618 setgrent();
619
620 while (1) {
621 DEBUG("Testing getgrent_r\n");
622
623 #ifdef HAVE_SOLARIS_GETGRENT_R
624 grpp = getgrent_r(&grp, buffer, sizeof(buffer));
625 if (grpp == NULL) {
626 break;
627 }
628 #else /* HAVE_SOLARIS_GETGRENT_R */
629 ret = getgrent_r(&grp, buffer, sizeof(buffer), &grpp);
630 if (ret != 0) {
631 if (ret != ENOENT) {
632 DEBUG("got %d return code\n", ret);
633 }
634 break;
635 }
636 #endif /* HAVE_SOLARIS_GETGRENT_R */
637 print_group(&grp);
638 if (grp_array_p && num_grp_p) {
639 grp_array = realloc(grp_array, sizeof(struct group) * (num_grp + 1));
640 assert_non_null(grp_array);
641 copy_group(&grp, &grp_array[num_grp]);
642 num_grp++;
643 }
644 }
645
646 DEBUG("Testing endgrent\n");
647 endgrent();
648 #endif /* HAVE_GETGRENT_R */
649
650 if (grp_array_p) {
651 *grp_array_p = grp_array;
652 }
653 if (num_grp_p) {
654 *num_grp_p = num_grp;
655 }
656
657 return true;
658 }
659
660 static bool test_nwrap_group(void)
661 {
662 struct group *grp, grp1, grp2;
663 size_t i, num_grp;
664
665 test_nwrap_enum_group(&grp, &num_grp);
666
667 for (i=0; i < num_grp; i++) {
668 test_nwrap_getgrnam(grp[i].gr_name, &grp1);
669 assert_group_equal(&grp[i], &grp1);
670
671 test_nwrap_getgrgid(grp[i].gr_gid, &grp2);
672 assert_group_equal(&grp[i], &grp2);
673
674 assert_group_equal(&grp1, &grp2);
675
676 free_group(&grp1);
677 free_group(&grp2);
678 }
679 free_groups(grp, num_grp);
680
681 return true;
682 }
683
684 static bool test_nwrap_group_r(void)
685 {
686 struct group *grp, grp1, grp2;
687 size_t i, num_grp;
688
689 test_nwrap_enum_r_group(&grp, &num_grp);
690
691 for (i=0; i < num_grp; i++) {
692 test_nwrap_getgrnam_r(grp[i].gr_name, &grp1);
693 assert_group_equal(&grp[i], &grp1);
694
695 test_nwrap_getgrgid_r(grp[i].gr_gid, &grp2);
696 assert_group_equal(&grp[i], &grp2);
697
698 assert_group_equal(&grp1, &grp2);
699
700 free_group(&grp1);
701 free_group(&grp2);
702 }
703 free_groups(grp, num_grp);
704
705 return true;
706 }
707
708 static bool test_nwrap_group_r_cross(void)
709 {
710 struct group *grp, grp1, grp2, grp3, grp4;
711 size_t i, num_grp;
712
713 test_nwrap_enum_r_group(&grp, &num_grp);
714
715 for (i=0; i < num_grp; i++) {
716 test_nwrap_getgrnam_r(grp[i].gr_name, &grp1);
717 assert_group_equal(&grp[i], &grp1);
718
719 test_nwrap_getgrgid_r(grp[i].gr_gid, &grp2);
720 assert_group_equal(&grp[i], &grp2);
721
722 assert_group_equal(&grp1, &grp2);
723
724 test_nwrap_getgrnam(grp[i].gr_name, &grp3);
725 assert_group_equal(&grp[i], &grp3);
726
727 test_nwrap_getgrgid(grp[i].gr_gid, &grp4);
728 assert_group_equal(&grp[i], &grp4);
729
730 assert_group_equal(&grp3, &grp4);
731
732 free_group(&grp1);
733 free_group(&grp2);
734 free_group(&grp3);
735 free_group(&grp4);
736 }
737 free_groups(grp, num_grp);
738
739 return true;
740 }
741
742 #ifdef HAVE_GETGROUPLIST
743 static bool test_nwrap_getgrouplist(const char *user,
744 gid_t gid,
745 gid_t **gids_p,
746 int *num_gids_p)
747 {
748 int ret;
749 int num_groups = 0;
750 gid_t *groups = NULL;
751
752 DEBUG("Testing getgrouplist: %s\n", user);
753
754 ret = getgrouplist(user, gid, NULL, &num_groups);
755 if (ret == -1 || num_groups != 0) {
756
757 groups = malloc(sizeof(gid_t) * num_groups);
758 assert_non_null(groups);
759
760 ret = getgrouplist(user, gid, groups, &num_groups);
761 }
762
763 assert_false(ret == -1);
764
765 DEBUG("%s is member in %d groups\n", user, num_groups);
766
767 if (gids_p) {
768 *gids_p = groups;
769 }
770 if (num_gids_p) {
771 *num_gids_p = num_groups;
772 }
773
774 return true;
775 }
776
777 static bool test_nwrap_user_in_group(const struct passwd *pwd,
778 const struct group *grp)
779 {
780 int i;
781
782 for (i = 0; grp->gr_mem != NULL && grp->gr_mem[i] != NULL; i++) {
783 if (strcmp(grp->gr_mem[i], pwd->pw_name) == 0) {
784 return true;
785 }
786 }
787
788 return false;
789 }
790
791 static bool test_nwrap_membership_user(const struct passwd *pwd,
792 struct group *grp_array,
793 size_t num_grp)
794 {
795 int num_user_groups = 0;
796 size_t num_user_groups_from_enum = 0;
797 gid_t *user_groups = NULL;
798 size_t i;
799 int g;
800 bool primary_group_had_user_member = false;
801
802 test_nwrap_getgrouplist(pwd->pw_name,
803 pwd->pw_gid,
804 &user_groups,
805 &num_user_groups);
806
807 for (g=0; g < num_user_groups; g++) {
808 test_nwrap_getgrgid(user_groups[g], NULL);
809 }
810 free(user_groups);
811
812 for (i=0; i < num_grp; i++) {
813 struct group grp = grp_array[i];
814
815 if (test_nwrap_user_in_group(pwd, &grp)) {
816 struct group current_grp = {
817 .gr_name = NULL,
818 };
819
820 num_user_groups_from_enum++;
821
822 test_nwrap_getgrnam(grp.gr_name, &current_grp);
823
824 if (current_grp.gr_gid == pwd->pw_gid) {
825 DEBUG("primary group %s of user %s lists user as member\n",
826 current_grp.gr_name,
827 pwd->pw_name);
828 primary_group_had_user_member = true;
829 }
830 free_group(&current_grp);
831
832 continue;
833 }
834 }
835
836 if (!primary_group_had_user_member) {
837 num_user_groups_from_enum++;
838 }
839
840 assert_int_equal(num_user_groups, num_user_groups_from_enum);
841
842 return true;
843 }
844
845 static void test_nwrap_membership(void **state)
846 {
847 const char *old_pwd = getenv("NSS_WRAPPER_PASSWD");
848 const char *old_group = getenv("NSS_WRAPPER_GROUP");
849 struct passwd *pwd;
850 size_t num_pwd;
851 struct group *grp;
852 size_t num_grp;
853 size_t i;
854
855 (void) state; /* unused */
856
857 if (!old_pwd || !old_group) {
858 DEBUG("ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
859 return;
860 }
861
862 test_nwrap_enum_passwd(&pwd, &num_pwd);
863 test_nwrap_enum_group(&grp, &num_grp);
864
865 for (i=0; i < num_pwd; i++) {
866 test_nwrap_membership_user(&pwd[i], grp, num_grp);
867 }
868 free_passwds(pwd, num_pwd);
869 free_groups(grp, num_grp);
870 }
871 #endif /* HAVE_GETGROUPLIST */
872
873 static void test_nwrap_enumeration(void **state)
874 {
875 const char *old_pwd = getenv("NSS_WRAPPER_PASSWD");
876 const char *old_group = getenv("NSS_WRAPPER_GROUP");
877
878 (void) state; /* unused */
879
880 if (!old_pwd || !old_group) {
881 DEBUG("ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
882 return;
883 }
884
885 test_nwrap_passwd();
886 test_nwrap_group();
887 }
888
889 static void test_nwrap_reentrant_enumeration(void **state)
890 {
891 const char *old_pwd = getenv("NSS_WRAPPER_PASSWD");
892 const char *old_group = getenv("NSS_WRAPPER_GROUP");
893
894 (void) state; /* unused */
895
896 if (!old_pwd || !old_group) {
897 DEBUG("ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
898 return;
899 }
900
901 DEBUG("Testing re-entrant calls\n");
902
903 test_nwrap_passwd_r();
904 test_nwrap_group_r();
905 }
906
907 static void test_nwrap_reentrant_enumeration_crosschecks(void **state)
908 {
909 const char *old_pwd = getenv("NSS_WRAPPER_PASSWD");
910 const char *old_group = getenv("NSS_WRAPPER_GROUP");
911
912 (void) state; /* unused */
913
914 if (!old_pwd || !old_group) {
915 DEBUG("ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
916 return;
917 }
918
919 DEBUG("Testing re-entrant calls with cross checks\n");
920
921 test_nwrap_passwd_r_cross();
922 test_nwrap_group_r_cross();
923 }
924
925 static bool test_nwrap_passwd_duplicates(void)
926 {
927 struct passwd *pwd;
928 size_t d, i, num_pwd;
929 int duplicates = 0;
930
931 test_nwrap_enum_passwd(&pwd, &num_pwd);
932
933 for (i=0; i < num_pwd; i++) {
934 const char *current_name = pwd[i].pw_name;
935 for (d=0; d < num_pwd; d++) {
936 const char *dup_name = pwd[d].pw_name;
937 if (d == i) {
938 continue;
939 }
940 if (strcmp(current_name, dup_name) != 0) {
941 continue;
942 }
943
944 DEBUG("found duplicate names:");
945
946 print_passwd(&pwd[d]);
947 print_passwd(&pwd[i]);
948 duplicates++;
949 }
950 }
951 free_passwds(pwd, num_pwd);
952
953 assert_false(duplicates);
954
955 return true;
956 }
957
958 static bool test_nwrap_group_duplicates(void)
959 {
960 struct group *grp;
961 size_t d, i, num_grp;
962 int duplicates = 0;
963
964 test_nwrap_enum_group(&grp, &num_grp);
965
966 for (i=0; i < num_grp; i++) {
967 const char *current_name = grp[i].gr_name;
968 for (d=0; d < num_grp; d++) {
969 const char *dup_name = grp[d].gr_name;
970 if (d == i) {
971 continue;
972 }
973 if (strcmp(current_name, dup_name) != 0) {
974 continue;
975 }
976
977 DEBUG("found duplicate names:");
978
979 print_group(&grp[d]);
980 print_group(&grp[i]);
981 duplicates++;
982 }
983 }
984 free_groups(grp, num_grp);
985
986 assert_false(duplicates);
987
988 return true;
989 }
990
991 static void test_nwrap_duplicates(void **state)
992 {
993 const char *old_pwd = getenv("NSS_WRAPPER_PASSWD");
994 const char *old_group = getenv("NSS_WRAPPER_GROUP");
995
996 (void) state; /* unused */
997
998 if (!old_pwd || !old_group) {
999 DEBUG("ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
1000 return;
1001 }
1002
1003 test_nwrap_passwd_duplicates();
1004 test_nwrap_group_duplicates();
1005 }
1006
1007 int main(void) {
1008 int rc;
1009
1010 const struct CMUnitTest tests[] = {
1011 cmocka_unit_test(test_nwrap_enumeration),
1012 cmocka_unit_test(test_nwrap_reentrant_enumeration),
1013 cmocka_unit_test(test_nwrap_reentrant_enumeration_crosschecks),
1014 #ifdef HAVE_GETGROUPLIST
1015 cmocka_unit_test(test_nwrap_membership),
1016 #endif
1017 cmocka_unit_test(test_nwrap_duplicates),
1018 };
1019
1020 rc = cmocka_run_group_tests(tests, NULL, NULL);
1021
1022 return rc;
1023 }