?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update.
[glibc.git] / nis / nss_compat / compat-pwd.c
blobeec2634f3ab1ab0d9d17ff7b377e3482d06908f0
1 /* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1996.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
19
20 #include <nss.h>
21 #include <pwd.h>
22 #include <errno.h>
23 #include <ctype.h>
24 #include <fcntl.h>
25 #include <netdb.h>
26 #include <string.h>
27 #include <bits/libc-lock.h>
28 #include <rpcsvc/yp.h>
29 #include <rpcsvc/ypclnt.h>
30 #include <rpcsvc/nis.h>
31 #include <nsswitch.h>
32
33 #include "netgroup.h"
34 #include "nss-nisplus.h"
35 #include "nisplus-parser.h"
36
37 static service_user *ni = NULL;
38 static bool_t use_nisplus = FALSE; /* default: passwd_compat: nis */
39 static nis_name pwdtable = NULL; /* Name of the pwd table */
40 static size_t pwdtablelen = 0;
41
42 /* Get the declaration of the parser function. */
43 #define ENTNAME pwent
44 #define STRUCTURE passwd
45 #define EXTERN_PARSER
46 #include <nss/nss_files/files-parse.c>
47
48 /* Structure for remembering -@netgroup and -user members ... */
49 #define BLACKLIST_INITIAL_SIZE 512
50 #define BLACKLIST_INCREMENT 256
51 struct blacklist_t
52 {
53 char *data;
54 int current;
55 int size;
56 };
57
58 struct ent_t
59 {
60 bool_t netgroup;
61 bool_t nis;
62 bool_t first;
63 char *oldkey;
64 int oldkeylen;
65 nis_result *result;
66 FILE *stream;
67 struct blacklist_t blacklist;
68 struct passwd pwd;
69 struct __netgrent netgrdata;
70 };
71 typedef struct ent_t ent_t;
72
73 static ent_t ext_ent = {0, 0, 0, NULL, 0, NULL, NULL, {NULL, 0, 0},
74 {NULL, NULL, 0, 0, NULL, NULL, NULL}};
75
76 /* Protect global state against multiple changers. */
77 __libc_lock_define_initialized (static, lock)
78
79 /* Prototypes for local functions. */
80 static void blacklist_store_name (const char *, ent_t *);
81 static int in_blacklist (const char *, int, ent_t *);
82
83 static void
84 give_pwd_free (struct passwd *pwd)
85 {
86 if (pwd->pw_name != NULL)
87 free (pwd->pw_name);
88 if (pwd->pw_passwd != NULL)
89 free (pwd->pw_passwd);
90 if (pwd->pw_gecos != NULL)
91 free (pwd->pw_gecos);
92 if (pwd->pw_dir != NULL)
93 free (pwd->pw_dir);
94 if (pwd->pw_shell != NULL)
95 free (pwd->pw_shell);
96
97 memset (pwd, '\0', sizeof (struct passwd));
98 }
99
100 static size_t
101 pwd_need_buflen (struct passwd *pwd)
102 {
103 size_t len = 0;
104
105 if (pwd->pw_passwd != NULL)
106 len += strlen (pwd->pw_passwd) + 1;
107
108 if (pwd->pw_gecos != NULL)
109 len += strlen (pwd->pw_gecos) + 1;
110
111 if (pwd->pw_dir != NULL)
112 len += strlen (pwd->pw_dir) + 1;
113
114 if (pwd->pw_shell != NULL)
115 len += strlen (pwd->pw_shell) + 1;
116
117 return len;
118 }
119
120 static void
121 copy_pwd_changes (struct passwd *dest, struct passwd *src,
122 char *buffer, size_t buflen)
123 {
124 if (src->pw_passwd != NULL && strlen (src->pw_passwd))
125 {
126 if (buffer == NULL)
127 dest->pw_passwd = strdup (src->pw_passwd);
128 else if (dest->pw_passwd &&
129 strlen (dest->pw_passwd) >= strlen (src->pw_passwd))
130 strcpy (dest->pw_passwd, src->pw_passwd);
131 else
132 {
133 dest->pw_passwd = buffer;
134 strcpy (dest->pw_passwd, src->pw_passwd);
135 buffer += strlen (dest->pw_passwd) + 1;
136 buflen = buflen - (strlen (dest->pw_passwd) + 1);
137 }
138 }
139
140 if (src->pw_gecos != NULL && strlen (src->pw_gecos))
141 {
142 if (buffer == NULL)
143 dest->pw_gecos = strdup (src->pw_gecos);
144 else if (dest->pw_gecos &&
145 strlen (dest->pw_gecos) >= strlen (src->pw_gecos))
146 strcpy (dest->pw_gecos, src->pw_gecos);
147 else
148 {
149 dest->pw_gecos = buffer;
150 strcpy (dest->pw_gecos, src->pw_gecos);
151 buffer += strlen (dest->pw_gecos) + 1;
152 buflen = buflen - (strlen (dest->pw_gecos) + 1);
153 }
154 }
155 if (src->pw_dir != NULL && strlen (src->pw_dir))
156 {
157 if (buffer == NULL)
158 dest->pw_dir = strdup (src->pw_dir);
159 else if (dest->pw_dir &&
160 strlen (dest->pw_dir) >= strlen (src->pw_dir))
161 strcpy (dest->pw_dir, src->pw_dir);
162 else
163 {
164 dest->pw_dir = buffer;
165 strcpy (dest->pw_dir, src->pw_dir);
166 buffer += strlen (dest->pw_dir) + 1;
167 buflen = buflen - (strlen (dest->pw_dir) + 1);
168 }
169 }
170
171 if (src->pw_shell != NULL && strlen (src->pw_shell))
172 {
173 if (buffer == NULL)
174 dest->pw_shell = strdup (src->pw_shell);
175 else if (dest->pw_shell &&
176 strlen (dest->pw_shell) >= strlen (src->pw_shell))
177 strcpy (dest->pw_shell, src->pw_shell);
178 else
179 {
180 dest->pw_shell = buffer;
181 strcpy (dest->pw_shell, src->pw_shell);
182 buffer += strlen (dest->pw_shell) + 1;
183 buflen = buflen - (strlen (dest->pw_shell) + 1);
184 }
185 }
186 }
187
188 static enum nss_status
189 internal_setpwent (ent_t *ent)
190 {
191 enum nss_status status = NSS_STATUS_SUCCESS;
192
193 ent->nis = ent->first = ent->netgroup = 0;
194
195 /* If something was left over free it. */
196 if (ent->netgroup)
197 __internal_endnetgrent (&ent->netgrdata);
198
199 if (ent->oldkey != NULL)
200 {
201 free (ent->oldkey);
202 ent->oldkey = NULL;
203 ent->oldkeylen = 0;
204 }
205
206 if (ent->result != NULL)
207 {
208 nis_freeresult (ent->result);
209 ent->result = NULL;
210 }
211
212 if (pwdtable == NULL)
213 {
214 static const char key[] = "passwd.org_dir.";
215 const char *local_dir = nis_local_directory ();
216 size_t len_local_dir = strlen (local_dir);
217
218 pwdtable = malloc (sizeof (key) + len_local_dir);
219 if (pwdtable == NULL)
220 return NSS_STATUS_TRYAGAIN;
221
222 pwdtablelen = ((char *) mempcpy (mempcpy (pwdtable,
223 key, sizeof (key) - 1),
224 local_dir, len_local_dir + 1)
225 - pwdtable) - 1;
226 }
227
228 if (ent->blacklist.data != NULL)
229 {
230 ent->blacklist.current = 1;
231 ent->blacklist.data[0] = '|';
232 ent->blacklist.data[1] = '\0';
233 }
234 else
235 ent->blacklist.current = 0;
236
237 if (ent->stream == NULL)
238 {
239 ent->stream = fopen ("/etc/passwd", "r");
240
241 if (ent->stream == NULL)
242 status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
243 else
244 {
245 /* We have to make sure the file is `closed on exec'. */
246 int result, flags;
247
248 result = flags = fcntl (fileno (ent->stream), F_GETFD, 0);
249 if (result >= 0)
250 {
251 flags |= FD_CLOEXEC;
252 result = fcntl (fileno (ent->stream), F_SETFD, flags);
253 }
254 if (result < 0)
255 {
256 /* Something went wrong. Close the stream and return a
257 failure. */
258 fclose (ent->stream);
259 ent->stream = NULL;
260 status = NSS_STATUS_UNAVAIL;
261 }
262 }
263 }
264 else
265 rewind (ent->stream);
266
267 give_pwd_free (&ent->pwd);
268
269 return status;
270 }
271
272
273 enum nss_status
274 _nss_compat_setpwent (void)
275 {
276 enum nss_status result;
277
278 __libc_lock_lock (lock);
279
280 if (ni == NULL)
281 {
282 __nss_database_lookup ("passwd_compat", NULL, "nis", &ni);
283 use_nisplus = (strcmp (ni->name, "nisplus") == 0);
284 }
285
286 result = internal_setpwent (&ext_ent);
287
288 __libc_lock_unlock (lock);
289
290 return result;
291 }
292
293
294 static enum nss_status
295 internal_endpwent (ent_t *ent)
296 {
297 if (ent->stream != NULL)
298 {
299 fclose (ent->stream);
300 ent->stream = NULL;
301 }
302
303 if (ent->netgroup)
304 __internal_endnetgrent (&ent->netgrdata);
305
306 ent->nis = ent->first = ent->netgroup = 0;
307
308 if (ent->oldkey != NULL)
309 {
310 free (ent->oldkey);
311 ent->oldkey = NULL;
312 ent->oldkeylen = 0;
313 }
314
315 if (ent->result != NULL)
316 {
317 nis_freeresult (ent->result);
318 ent->result = NULL;
319 }
320
321 if (ent->blacklist.data != NULL)
322 {
323 ent->blacklist.current = 1;
324 ent->blacklist.data[0] = '|';
325 ent->blacklist.data[1] = '\0';
326 }
327 else
328 ent->blacklist.current = 0;
329
330 give_pwd_free (&ent->pwd);
331
332 return NSS_STATUS_SUCCESS;
333 }
334
335 enum nss_status
336 _nss_compat_endpwent (void)
337 {
338 enum nss_status result;
339
340 __libc_lock_lock (lock);
341
342 result = internal_endpwent (&ext_ent);
343
344 __libc_lock_unlock (lock);
345
346 return result;
347 }
348
349 static enum nss_status
350 getpwent_next_nis_netgr (const char *name, struct passwd *result, ent_t *ent,
351 char *group, char *buffer, size_t buflen, int *errnop)
352 {
353 struct parser_data *data = (void *) buffer;
354 char *ypdomain, *host, *user, *domain, *outval, *p, *p2;
355 int status, outvallen;
356 size_t p2len;
357
358 if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS)
359 {
360 ent->netgroup = 0;
361 ent->first = 0;
362 give_pwd_free (&ent->pwd);
363 return NSS_STATUS_UNAVAIL;
364 }
365
366 if (ent->first == TRUE)
367 {
368 memset (&ent->netgrdata, 0, sizeof (struct __netgrent));
369 __internal_setnetgrent (group, &ent->netgrdata);
370 ent->first = FALSE;
371 }
372
373 while (1)
374 {
375 char *saved_cursor;
376 int parse_res;
377
378 saved_cursor = ent->netgrdata.cursor;
379 status = __internal_getnetgrent_r (&host, &user, &domain,
380 &ent->netgrdata, buffer, buflen,
381 errnop);
382 if (status != 1)
383 {
384 __internal_endnetgrent (&ent->netgrdata);
385 ent->netgroup = 0;
386 give_pwd_free (&ent->pwd);
387 return NSS_STATUS_RETURN;
388 }
389
390 if (user == NULL || user[0] == '-')
391 continue;
392
393 if (domain != NULL && strcmp (ypdomain, domain) != 0)
394 continue;
395
396 /* If name != NULL, we are called from getpwnam. */
397 if (name != NULL)
398 if (strcmp (user, name) != 0)
399 continue;
400
401 if (yp_match (ypdomain, "passwd.byname", user,
402 strlen (user), &outval, &outvallen)
403 != YPERR_SUCCESS)
404 continue;
405
406 p2len = pwd_need_buflen (&ent->pwd);
407 if (p2len > buflen)
408 {
409 free (outval);
410 *errnop = ERANGE;
411 return NSS_STATUS_TRYAGAIN;
412 }
413 p2 = buffer + (buflen - p2len);
414 buflen -= p2len;
415
416 if (buflen < ((size_t) outvallen + 1))
417 {
418 free (outval);
419 *errnop = ERANGE;
420 return NSS_STATUS_TRYAGAIN;
421 }
422 p = strncpy (buffer, outval, buflen);
423
424 while (isspace (*p))
425 p++;
426 free (outval);
427 parse_res = _nss_files_parse_pwent (p, result, data, buflen, errnop);
428 if (parse_res == -1)
429 {
430 ent->netgrdata.cursor = saved_cursor;
431 return NSS_STATUS_TRYAGAIN;
432 }
433
434 if (parse_res)
435 {
436 /* Store the User in the blacklist for the "+" at the end of
437 /etc/passwd */
438 blacklist_store_name (result->pw_name, ent);
439 copy_pwd_changes (result, &ent->pwd, p2, p2len);
440 break;
441 }
442 }
443
444 return NSS_STATUS_SUCCESS;
445 }
446
447 static enum nss_status
448 getpwent_next_nisplus_netgr (const char *name, struct passwd *result,
449 ent_t *ent, char *group, char *buffer,
450 size_t buflen, int *errnop)
451 {
452 char *ypdomain, *host, *user, *domain, *p2;
453 int status, parse_res;
454 size_t p2len;
455 nis_result *nisres;
456
457 /* Maybe we should use domainname here ? We need the current
458 domainname for the domain field in netgroups */
459 if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS)
460 {
461 ent->netgroup = 0;
462 ent->first = 0;
463 give_pwd_free (&ent->pwd);
464 return NSS_STATUS_UNAVAIL;
465 }
466
467 if (ent->first == TRUE)
468 {
469 bzero (&ent->netgrdata, sizeof (struct __netgrent));
470 __internal_setnetgrent (group, &ent->netgrdata);
471 ent->first = FALSE;
472 }
473
474 while (1)
475 {
476 char *saved_cursor;
477
478 saved_cursor = ent->netgrdata.cursor;
479 status = __internal_getnetgrent_r (&host, &user, &domain,
480 &ent->netgrdata, buffer, buflen,
481 errnop);
482 if (status != 1)
483 {
484 __internal_endnetgrent (&ent->netgrdata);
485 ent->netgroup = 0;
486 give_pwd_free (&ent->pwd);
487 return NSS_STATUS_RETURN;
488 }
489
490 if (user == NULL || user[0] == '-')
491 continue;
492
493 if (domain != NULL && strcmp (ypdomain, domain) != 0)
494 continue;
495
496 /* If name != NULL, we are called from getpwnam */
497 if (name != NULL)
498 if (strcmp (user, name) != 0)
499 continue;
500
501 p2len = pwd_need_buflen (&ent->pwd);
502 if (p2len > buflen)
503 {
504 *errnop = ERANGE;
505 return NSS_STATUS_TRYAGAIN;
506 }
507 p2 = buffer + (buflen - p2len);
508 buflen -= p2len;
509 {
510 char buf[strlen (user) + 30 + pwdtablelen];
511 sprintf(buf, "[name=%s],%s", user, pwdtable);
512 nisres = nis_list(buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
513 }
514 if (niserr2nss (nisres->status) != NSS_STATUS_SUCCESS)
515 {
516 nis_freeresult (nisres);
517 continue;
518 }
519 parse_res = _nss_nisplus_parse_pwent (nisres, result, buffer,
520 buflen, errnop);
521 if (parse_res == -1)
522 {
523 nis_freeresult (nisres);
524 ent->netgrdata.cursor = saved_cursor;
525 *errnop = ERANGE;
526 return NSS_STATUS_TRYAGAIN;
527 }
528 nis_freeresult (nisres);
529
530 if (parse_res)
531 {
532 /* Store the User in the blacklist for the "+" at the end of
533 /etc/passwd */
534 blacklist_store_name (result->pw_name, ent);
535 copy_pwd_changes (result, &ent->pwd, p2, p2len);
536 break;
537 }
538 }
539
540 return NSS_STATUS_SUCCESS;
541 }
542
543 /* get the next user from NIS+ (+ entry) */
544 static enum nss_status
545 getpwent_next_nisplus (struct passwd *result, ent_t *ent, char *buffer,
546 size_t buflen, int *errnop)
547 {
548 int parse_res;
549 size_t p2len;
550 char *p2;
551
552 p2len = pwd_need_buflen (&ent->pwd);
553 if (p2len > buflen)
554 {
555 *errnop = ERANGE;
556 return NSS_STATUS_TRYAGAIN;
557 }
558 p2 = buffer + (buflen - p2len);
559 buflen -= p2len;
560 do
561 {
562 bool_t saved_first;
563 nis_result *saved_res;
564
565 if (ent->first)
566 {
567 saved_first = TRUE;
568 saved_res = ent->result;
569
570 ent->result = nis_first_entry (pwdtable);
571 if (niserr2nss (ent->result->status) != NSS_STATUS_SUCCESS)
572 {
573 ent->nis = 0;
574 give_pwd_free (&ent->pwd);
575 return niserr2nss (ent->result->status);
576 }
577 ent->first = FALSE;
578 }
579 else
580 {
581 nis_result *res;
582
583 res = nis_next_entry (pwdtable, &ent->result->cookie);
584 saved_res = ent->result;
585 saved_first = FALSE;
586 ent->result = res;
587 if (niserr2nss (ent->result->status) != NSS_STATUS_SUCCESS)
588 {
589 ent->nis = 0;
590 nis_freeresult (saved_res);
591 give_pwd_free (&ent->pwd);
592 return niserr2nss (ent->result->status);
593 }
594 }
595 parse_res = _nss_nisplus_parse_pwent (ent->result, result, buffer,
596 buflen, errnop);
597 if (parse_res == -1)
598 {
599 nis_freeresult (ent->result);
600 ent->result = saved_res;
601 ent->first = saved_first;
602 *errnop = ERANGE;
603 return NSS_STATUS_TRYAGAIN;
604 }
605 else
606 {
607 if (!saved_first)
608 nis_freeresult (saved_res);
609 }
610
611 if (parse_res &&
612 in_blacklist (result->pw_name, strlen (result->pw_name), ent))
613 parse_res = 0; /* if result->pw_name in blacklist,search next entry */
614 }
615 while (!parse_res);
616
617 copy_pwd_changes (result, &ent->pwd, p2, p2len);
618
619 return NSS_STATUS_SUCCESS;
620 }
621
622 static enum nss_status
623 getpwent_next_nis (struct passwd *result, ent_t *ent, char *buffer,
624 size_t buflen, int *errnop)
625 {
626 struct parser_data *data = (void *) buffer;
627 char *domain, *outkey, *outval, *p, *p2;
628 int outkeylen, outvallen, parse_res;
629 size_t p2len;
630
631 if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
632 {
633 ent->nis = 0;
634 give_pwd_free (&ent->pwd);
635 return NSS_STATUS_UNAVAIL;
636 }
637
638 p2len = pwd_need_buflen (&ent->pwd);
639 if (p2len > buflen)
640 {
641 *errnop = ERANGE;
642 return NSS_STATUS_TRYAGAIN;
643 }
644 p2 = buffer + (buflen - p2len);
645 buflen -= p2len;
646 do
647 {
648 bool_t saved_first;
649 char *saved_oldkey;
650 int saved_oldlen;
651
652 if (ent->first)
653 {
654 if (yp_first (domain, "passwd.byname", &outkey, &outkeylen,
655 &outval, &outvallen) != YPERR_SUCCESS)
656 {
657 ent->nis = 0;
658 give_pwd_free (&ent->pwd);
659 return NSS_STATUS_UNAVAIL;
660 }
661
662 if (buflen < ((size_t) outvallen + 1))
663 {
664 free (outval);
665 *errnop = ERANGE;
666 return NSS_STATUS_TRYAGAIN;
667 }
668
669 saved_first = TRUE;
670 saved_oldkey = ent->oldkey;
671 saved_oldlen = ent->oldkeylen;
672 ent->oldkey = outkey;
673 ent->oldkeylen = outkeylen;
674 ent->first = FALSE;
675 }
676 else
677 {
678 if (yp_next (domain, "passwd.byname", ent->oldkey, ent->oldkeylen,
679 &outkey, &outkeylen, &outval, &outvallen)
680 != YPERR_SUCCESS)
681 {
682 ent->nis = 0;
683 give_pwd_free (&ent->pwd);
684 return NSS_STATUS_NOTFOUND;
685 }
686
687 if (buflen < ((size_t) outvallen + 1))
688 {
689 free (outval);
690 *errnop = ERANGE;
691 return NSS_STATUS_TRYAGAIN;
692 }
693
694 saved_first = FALSE;
695 saved_oldkey = ent->oldkey;
696 saved_oldlen = ent->oldkeylen;
697 ent->oldkey = outkey;
698 ent->oldkeylen = outkeylen;
699 }
700
701 /* Copy the found data to our buffer */
702 p = strncpy (buffer, outval, buflen);
703
704 /* ...and free the data. */
705 free (outval);
706
707 while (isspace (*p))
708 ++p;
709 parse_res = _nss_files_parse_pwent (p, result, data, buflen, errnop);
710 if (parse_res == -1)
711 {
712 free (ent->oldkey);
713 ent->oldkey = saved_oldkey;
714 ent->oldkeylen = saved_oldlen;
715 ent->first = saved_first;
716 *errnop = ERANGE;
717 return NSS_STATUS_TRYAGAIN;
718 }
719 else
720 {
721 if (!saved_first)
722 free (saved_oldkey);
723 }
724 if (parse_res
725 && in_blacklist (result->pw_name, strlen (result->pw_name), ent))
726 parse_res = 0;
727 }
728 while (!parse_res);
729
730 copy_pwd_changes (result, &ent->pwd, p2, p2len);
731
732 return NSS_STATUS_SUCCESS;
733 }
734
735 /* This function handle the +user entrys in /etc/passwd */
736 static enum nss_status
737 getpwnam_plususer (const char *name, struct passwd *result, char *buffer,
738 size_t buflen, int *errnop)
739 {
740 struct parser_data *data = (void *) buffer;
741 struct passwd pwd;
742 int parse_res;
743 char *p;
744 size_t plen;
745
746 memset (&pwd, '\0', sizeof (struct passwd));
747
748 copy_pwd_changes (&pwd, result, NULL, 0);
749
750 plen = pwd_need_buflen (&pwd);
751 if (plen > buflen)
752 {
753 *errnop = ERANGE;
754 return NSS_STATUS_TRYAGAIN;
755 }
756 p = buffer + (buflen - plen);
757 buflen -= plen;
758
759 if (use_nisplus) /* Do the NIS+ query here */
760 {
761 nis_result *res;
762 char buf[strlen (name) + 24 + pwdtablelen];
763
764 sprintf(buf, "[name=%s],%s", name, pwdtable);
765 res = nis_list(buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
766 if (niserr2nss (res->status) != NSS_STATUS_SUCCESS)
767 {
768 enum nss_status status = niserr2nss (res->status);
769
770 nis_freeresult (res);
771 return status;
772 }
773 parse_res = _nss_nisplus_parse_pwent (res, result, buffer,
774 buflen, errnop);
775 if (parse_res == -1)
776 {
777 nis_freeresult (res);
778 *errnop = ERANGE;
779 return NSS_STATUS_TRYAGAIN;
780 }
781 nis_freeresult (res);
782 }
783 else /* Use NIS */
784 {
785 char *domain, *outval, *ptr;
786 int outvallen;
787
788 if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
789 return NSS_STATUS_NOTFOUND;
790
791 if (yp_match (domain, "passwd.byname", name, strlen (name),
792 &outval, &outvallen) != YPERR_SUCCESS)
793 return NSS_STATUS_NOTFOUND;
794
795 if (buflen < ((size_t) outvallen + 1))
796 {
797 free (outval);
798 *errnop = ERANGE;
799 return NSS_STATUS_TRYAGAIN;
800 }
801 ptr = strncpy (buffer, outval, buflen);
802 free (outval);
803 while (isspace (*ptr))
804 ptr++;
805 parse_res = _nss_files_parse_pwent (ptr, result, data, buflen, errnop);
806 if (parse_res == -1)
807 return NSS_STATUS_TRYAGAIN;
808 }
809
810 if (parse_res > 0)
811 {
812 copy_pwd_changes (result, &pwd, p, plen);
813 give_pwd_free (&pwd);
814 /* We found the entry. */
815 return NSS_STATUS_SUCCESS;
816 }
817 else
818 {
819 /* Give buffer the old len back */
820 buflen += plen;
821 give_pwd_free (&pwd);
822 }
823 return NSS_STATUS_RETURN;
824 }
825
826 static enum nss_status
827 getpwent_next_file (struct passwd *result, ent_t *ent,
828 char *buffer, size_t buflen, int *errnop)
829 {
830 struct parser_data *data = (void *) buffer;
831 while (1)
832 {
833 fpos_t pos;
834 char *p;
835 int parse_res;
836
837 do
838 {
839 fgetpos (ent->stream, &pos);
840 buffer[buflen - 1] = '\xff';
841 p = fgets (buffer, buflen, ent->stream);
842 if (p == NULL && feof (ent->stream))
843 return NSS_STATUS_NOTFOUND;
844 if (p == NULL || buffer[buflen - 1] != '\xff')
845 {
846 fsetpos (ent->stream, &pos);
847 *errnop = ERANGE;
848 return NSS_STATUS_TRYAGAIN;
849 }
850
851 /* Terminate the line for any case. */
852 buffer[buflen - 1] = '\0';
853
854 /* Skip leading blanks. */
855 while (isspace (*p))
856 ++p;
857 }
858 while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
859 /* Parse the line. If it is invalid, loop to
860 get the next line of the file to parse. */
861 !(parse_res = _nss_files_parse_pwent (p, result, data, buflen,
862 errnop)));
863
864 if (parse_res == -1)
865 {
866 /* The parser ran out of space. */
867 fsetpos (ent->stream, &pos);
868 *errnop = ERANGE;
869 return NSS_STATUS_TRYAGAIN;
870 }
871
872 if (result->pw_name[0] != '+' && result->pw_name[0] != '-')
873 /* This is a real entry. */
874 break;
875
876 /* -@netgroup */
877 if (result->pw_name[0] == '-' && result->pw_name[1] == '@'
878 && result->pw_name[2] != '\0')
879 {
880 /* XXX Do not use fixed length buffer. */
881 char buf2[1024];
882 char *user, *host, *domain;
883 struct __netgrent netgrdata;
884
885 bzero (&netgrdata, sizeof (struct __netgrent));
886 __internal_setnetgrent (&result->pw_name[2], &netgrdata);
887 while (__internal_getnetgrent_r (&host, &user, &domain, &netgrdata,
888 buf2, sizeof (buf2), errnop))
889 {
890 if (user != NULL && user[0] != '-')
891 blacklist_store_name (user, ent);
892 }
893 __internal_endnetgrent (&netgrdata);
894 continue;
895 }
896
897 /* +@netgroup */
898 if (result->pw_name[0] == '+' && result->pw_name[1] == '@'
899 && result->pw_name[2] != '\0')
900 {
901 int status;
902
903 ent->netgroup = TRUE;
904 ent->first = TRUE;
905 copy_pwd_changes (&ent->pwd, result, NULL, 0);
906
907 if (use_nisplus)
908 status = getpwent_next_nisplus_netgr (NULL, result, ent,
909 &result->pw_name[2],
910 buffer, buflen, errnop);
911 else
912 status = getpwent_next_nis_netgr (NULL, result, ent,
913 &result->pw_name[2],
914 buffer, buflen, errnop);
915 if (status == NSS_STATUS_RETURN)
916 continue;
917 else
918 return status;
919 }
920
921 /* -user */
922 if (result->pw_name[0] == '-' && result->pw_name[1] != '\0'
923 && result->pw_name[1] != '@')
924 {
925 blacklist_store_name (&result->pw_name[1], ent);
926 continue;
927 }
928
929 /* +user */
930 if (result->pw_name[0] == '+' && result->pw_name[1] != '\0'
931 && result->pw_name[1] != '@')
932 {
933 enum nss_status status;
934
935 /* Store the User in the blacklist for the "+" at the end of
936 /etc/passwd */
937 blacklist_store_name (&result->pw_name[1], ent);
938 status = getpwnam_plususer (&result->pw_name[1], result, buffer,
939 buflen, errnop);
940 if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
941 break;
942 else
943 if (status == NSS_STATUS_RETURN /* We couldn't parse the entry */
944 || status == NSS_STATUS_NOTFOUND) /* entry doesn't exist */
945 continue;
946 else
947 {
948 if (status == NSS_STATUS_TRYAGAIN)
949 {
950 /* The parser ran out of space */
951 fsetpos (ent->stream, &pos);
952 *errnop = ERANGE;
953 }
954 return status;
955 }
956 }
957
958 /* +:... */
959 if (result->pw_name[0] == '+' && result->pw_name[1] == '\0')
960 {
961 ent->nis = TRUE;
962 ent->first = TRUE;
963 copy_pwd_changes (&ent->pwd, result, NULL, 0);
964
965 if (use_nisplus)
966 return getpwent_next_nisplus (result, ent, buffer, buflen, errnop);
967 else
968 return getpwent_next_nis (result, ent, buffer, buflen, errnop);
969 }
970 }
971
972 return NSS_STATUS_SUCCESS;
973 }
974
975
976 static enum nss_status
977 internal_getpwent_r (struct passwd *pw, ent_t *ent, char *buffer,
978 size_t buflen, int *errnop)
979 {
980 if (ent->netgroup)
981 {
982 int status;
983
984 /* We are searching members in a netgroup */
985 /* Since this is not the first call, we don't need the group name */
986 if (use_nisplus)
987 status = getpwent_next_nisplus_netgr (NULL, pw, ent, NULL, buffer,
988 buflen, errnop);
989 else
990 status = getpwent_next_nis_netgr (NULL, pw, ent, NULL, buffer, buflen,
991 errnop);
992 if (status == NSS_STATUS_RETURN)
993 return getpwent_next_file (pw, ent, buffer, buflen, errnop);
994 else
995 return status;
996 }
997 else
998 if (ent->nis)
999 {
1000 if (use_nisplus)
1001 return getpwent_next_nisplus (pw, ent, buffer, buflen, errnop);
1002 else
1003 return getpwent_next_nis (pw, ent, buffer, buflen, errnop);
1004 }
1005 else
1006 return getpwent_next_file (pw, ent, buffer, buflen, errnop);
1007 }
1008
1009 enum nss_status
1010 _nss_compat_getpwent_r (struct passwd *pwd, char *buffer, size_t buflen,
1011 int *errnop)
1012 {
1013 enum nss_status status = NSS_STATUS_SUCCESS;
1014
1015 __libc_lock_lock (lock);
1016
1017 if (ni == NULL)
1018 {
1019 __nss_database_lookup ("passwd_compat", NULL, "nis", &ni);
1020 use_nisplus = (strcmp (ni->name, "nisplus") == 0);
1021 }
1022
1023 /* Be prepared that the setpwent function was not called before. */
1024 if (ext_ent.stream == NULL)
1025 status = internal_setpwent (&ext_ent);
1026
1027 if (status == NSS_STATUS_SUCCESS)
1028 status = internal_getpwent_r (pwd, &ext_ent, buffer, buflen, errnop);
1029
1030 __libc_lock_unlock (lock);
1031
1032 return status;
1033 }
1034
1035 /* Searches in /etc/passwd and the NIS/NIS+ map for a special user */
1036 static enum nss_status
1037 internal_getpwnam_r (const char *name, struct passwd *result, ent_t *ent,
1038 char *buffer, size_t buflen, int *errnop)
1039 {
1040 struct parser_data *data = (void *) buffer;
1041
1042 while (1)
1043 {
1044 fpos_t pos;
1045 char *p;
1046 int parse_res;
1047
1048 do
1049 {
1050 fgetpos (ent->stream, &pos);
1051 buffer[buflen - 1] = '\xff';
1052 p = fgets (buffer, buflen, ent->stream);
1053 if (p == NULL && feof (ent->stream))
1054 return NSS_STATUS_NOTFOUND;
1055 if (p == NULL || buffer[buflen - 1] != '\xff')
1056 {
1057 fsetpos (ent->stream, &pos);
1058 *errnop = ERANGE;
1059 return NSS_STATUS_TRYAGAIN;
1060 }
1061
1062 /* Terminate the line for any case. */
1063 buffer[buflen - 1] = '\0';
1064
1065 /* Skip leading blanks. */
1066 while (isspace (*p))
1067 ++p;
1068 }
1069 while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
1070 /* Parse the line. If it is invalid, loop to
1071 get the next line of the file to parse. */
1072 !(parse_res = _nss_files_parse_pwent (p, result, data, buflen,
1073 errnop)));
1074
1075 if (parse_res == -1)
1076 {
1077 /* The parser ran out of space. */
1078 fsetpos (ent->stream, &pos);
1079 *errnop = ERANGE;
1080 return NSS_STATUS_TRYAGAIN;
1081 }
1082
1083 /* This is a real entry. */
1084 if (result->pw_name[0] != '+' && result->pw_name[0] != '-')
1085 {
1086 if (strcmp (result->pw_name, name) == 0)
1087 return NSS_STATUS_SUCCESS;
1088 else
1089 continue;
1090 }
1091
1092 /* -@netgroup */
1093 if (result->pw_name[0] == '-' && result->pw_name[1] == '@'
1094 && result->pw_name[2] != '\0')
1095 {
1096 /* XXX Do not use fixed length buffers. */
1097 char buf2[1024];
1098 char *user, *host, *domain;
1099 struct __netgrent netgrdata;
1100
1101 bzero (&netgrdata, sizeof (struct __netgrent));
1102 __internal_setnetgrent (&result->pw_name[2], &netgrdata);
1103 while (__internal_getnetgrent_r (&host, &user, &domain, &netgrdata,
1104 buf2, sizeof (buf2), errnop))
1105 {
1106 if (user != NULL && user[0] != '-')
1107 if (strcmp (user, name) == 0)
1108 return NSS_STATUS_NOTFOUND;
1109 }
1110 __internal_endnetgrent (&netgrdata);
1111 continue;
1112 }
1113
1114 /* +@netgroup */
1115 if (result->pw_name[0] == '+' && result->pw_name[1] == '@'
1116 && result->pw_name[2] != '\0')
1117 {
1118 char buf[strlen (result->pw_name)];
1119 int status;
1120
1121 strcpy (buf, &result->pw_name[2]);
1122 ent->netgroup = TRUE;
1123 ent->first = TRUE;
1124 copy_pwd_changes (&ent->pwd, result, NULL, 0);
1125
1126 do
1127 {
1128 if (use_nisplus)
1129 status = getpwent_next_nisplus_netgr (name, result, ent, buf,
1130 buffer, buflen, errnop);
1131 else
1132 status = getpwent_next_nis_netgr (name, result, ent, buf,
1133 buffer, buflen, errnop);
1134 if (status == NSS_STATUS_RETURN)
1135 continue;
1136
1137 if (status == NSS_STATUS_SUCCESS &&
1138 strcmp (result->pw_name, name) == 0)
1139 return NSS_STATUS_SUCCESS;
1140 } while (status == NSS_STATUS_SUCCESS);
1141 continue;
1142 }
1143
1144 /* -user */
1145 if (result->pw_name[0] == '-' && result->pw_name[1] != '\0'
1146 && result->pw_name[1] != '@')
1147 {
1148 if (strcmp (&result->pw_name[1], name) == 0)
1149 return NSS_STATUS_NOTFOUND;
1150 else
1151 continue;
1152 }
1153
1154 /* +user */
1155 if (result->pw_name[0] == '+' && result->pw_name[1] != '\0'
1156 && result->pw_name[1] != '@')
1157 {
1158 if (strcmp (name, &result->pw_name[1]) == 0)
1159 {
1160 enum nss_status status;
1161
1162 status = getpwnam_plususer (name, result, buffer, buflen,
1163 errnop);
1164 if (status == NSS_STATUS_RETURN)
1165 /* We couldn't parse the entry */
1166 return NSS_STATUS_NOTFOUND;
1167 else
1168 return status;
1169 }
1170 }
1171
1172 /* +:... */
1173 if (result->pw_name[0] == '+' && result->pw_name[1] == '\0')
1174 {
1175 enum nss_status status;
1176
1177 status = getpwnam_plususer (name, result, buffer, buflen, errnop);
1178 if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
1179 break;
1180 else
1181 if (status == NSS_STATUS_RETURN) /* We couldn't parse the entry */
1182 return NSS_STATUS_NOTFOUND;
1183 else
1184 return status;
1185 }
1186 }
1187 return NSS_STATUS_SUCCESS;
1188 }
1189
1190 enum nss_status
1191 _nss_compat_getpwnam_r (const char *name, struct passwd *pwd,
1192 char *buffer, size_t buflen, int *errnop)
1193 {
1194 ent_t ent = {0, 0, 0, NULL, 0, NULL, NULL, {NULL, 0, 0},
1195 {NULL, NULL, 0, 0, NULL, NULL, NULL}};
1196 enum nss_status status;
1197
1198 if (name[0] == '-' || name[0] == '+')
1199 return NSS_STATUS_NOTFOUND;
1200
1201 __libc_lock_lock (lock);
1202
1203 if (ni == NULL)
1204 {
1205 __nss_database_lookup ("passwd_compat", NULL, "nis", &ni);
1206 use_nisplus = (strcmp (ni->name, "nisplus") == 0);
1207 }
1208
1209 __libc_lock_unlock (lock);
1210
1211 status = internal_setpwent (&ent);
1212 if (status != NSS_STATUS_SUCCESS)
1213 return status;
1214
1215 status = internal_getpwnam_r (name, pwd, &ent, buffer, buflen, errnop);
1216
1217 internal_endpwent (&ent);
1218
1219 return status;
1220 }
1221
1222 /* This function handle the + entry in /etc/passwd for getpwuid */
1223 static enum nss_status
1224 getpwuid_plususer (uid_t uid, struct passwd *result, char *buffer,
1225 size_t buflen, int *errnop)
1226 {
1227 struct parser_data *data = (void *) buffer;
1228 struct passwd pwd;
1229 int parse_res;
1230 char *p;
1231 size_t plen;
1232
1233 memset (&pwd, '\0', sizeof (struct passwd));
1234
1235 copy_pwd_changes (&pwd, result, NULL, 0);
1236
1237 plen = pwd_need_buflen (&pwd);
1238 if (plen > buflen)
1239 {
1240 *errnop = ERANGE;
1241 return NSS_STATUS_TRYAGAIN;
1242 }
1243 p = buffer + (buflen - plen);
1244 buflen -= plen;
1245
1246 if (use_nisplus) /* Do the NIS+ query here */
1247 {
1248 nis_result *res;
1249 char buf[1024 + pwdtablelen];
1250
1251 snprintf(buf, sizeof (buf), "[uid=%d],%s", uid, pwdtable);
1252 res = nis_list(buf, FOLLOW_PATH | FOLLOW_LINKS, NULL, NULL);
1253 if (niserr2nss (res->status) != NSS_STATUS_SUCCESS)
1254 {
1255 enum nss_status status = niserr2nss (res->status);
1256
1257 nis_freeresult (res);
1258 return status;
1259 }
1260 if ((parse_res = _nss_nisplus_parse_pwent (res, result, buffer,
1261 buflen, errnop)) == -1)
1262 {
1263 nis_freeresult (res);
1264 *errnop = ERANGE;
1265 return NSS_STATUS_TRYAGAIN;
1266 }
1267 nis_freeresult (res);
1268 }
1269 else /* Use NIS */
1270 {
1271 char buf[1024];
1272 char *domain, *outval, *ptr;
1273 int outvallen;
1274
1275 if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
1276 {
1277 *errnop = errno;
1278 return NSS_STATUS_TRYAGAIN;
1279 }
1280
1281 sprintf (buf, "%d", uid);
1282 if (yp_match (domain, "passwd.byuid", buf, strlen (buf),
1283 &outval, &outvallen)
1284 != YPERR_SUCCESS)
1285 {
1286 *errnop = errno;
1287 return NSS_STATUS_TRYAGAIN;
1288 }
1289
1290 if ( buflen < ((size_t) outvallen + 1))
1291 {
1292 free (outval);
1293 *errnop = ERANGE;
1294 return NSS_STATUS_TRYAGAIN;
1295 }
1296
1297 ptr = strncpy (buffer, outval, buflen);
1298 free (outval);
1299
1300 while (isspace (*ptr))
1301 ptr++;
1302 parse_res = _nss_files_parse_pwent (ptr, result, data, buflen, errnop);
1303 if (parse_res == -1)
1304 return NSS_STATUS_TRYAGAIN;
1305 }
1306
1307 if (parse_res > 0)
1308 {
1309 copy_pwd_changes (result, &pwd, p, plen);
1310 give_pwd_free (&pwd);
1311 /* We found the entry. */
1312 return NSS_STATUS_SUCCESS;
1313 }
1314 else
1315 {
1316 /* Give buffer the old len back */
1317 buflen += plen;
1318 give_pwd_free (&pwd);
1319 }
1320 return NSS_STATUS_RETURN;
1321 }
1322
1323 /* Searches in /etc/passwd and the NIS/NIS+ map for a special user id */
1324 static enum nss_status
1325 internal_getpwuid_r (uid_t uid, struct passwd *result, ent_t *ent,
1326 char *buffer, size_t buflen, int *errnop)
1327 {
1328 struct parser_data *data = (void *) buffer;
1329
1330 while (1)
1331 {
1332 fpos_t pos;
1333 char *p;
1334 int parse_res;
1335
1336 do
1337 {
1338 fgetpos (ent->stream, &pos);
1339 buffer[buflen - 1] = '\xff';
1340 p = fgets (buffer, buflen, ent->stream);
1341 if (p == NULL && feof (ent->stream))
1342 return NSS_STATUS_NOTFOUND;
1343 if (p == NULL || buffer[buflen - 1] != '\xff')
1344 {
1345 fsetpos (ent->stream, &pos);
1346 *errnop = ERANGE;
1347 return NSS_STATUS_TRYAGAIN;
1348 }
1349
1350 /* Terminate the line for any case. */
1351 buffer[buflen - 1] = '\0';
1352
1353 /* Skip leading blanks. */
1354 while (isspace (*p))
1355 ++p;
1356 }
1357 while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
1358 /* Parse the line. If it is invalid, loop to
1359 get the next line of the file to parse. */
1360 !(parse_res = _nss_files_parse_pwent (p, result, data, buflen,
1361 errnop)));
1362
1363 if (parse_res == -1)
1364 {
1365 /* The parser ran out of space. */
1366 fsetpos (ent->stream, &pos);
1367 *errnop = ERANGE;
1368 return NSS_STATUS_TRYAGAIN;
1369 }
1370
1371 /* This is a real entry. */
1372 if (result->pw_name[0] != '+' && result->pw_name[0] != '-')
1373 {
1374 if (result->pw_uid == uid)
1375 return NSS_STATUS_SUCCESS;
1376 else
1377 continue;
1378 }
1379
1380 /* -@netgroup */
1381 if (result->pw_name[0] == '-' && result->pw_name[1] == '@'
1382 && result->pw_name[2] != '\0')
1383 {
1384 /* XXX Do not use fixed length buffers. */
1385 char buf2[1024];
1386 char *user, *host, *domain;
1387 struct __netgrent netgrdata;
1388
1389 bzero (&netgrdata, sizeof (struct __netgrent));
1390 __internal_setnetgrent (&result->pw_name[2], &netgrdata);
1391 while (__internal_getnetgrent_r (&host, &user, &domain, &netgrdata,
1392 buf2, sizeof (buf2), errnop))
1393 {
1394 if (user != NULL && user[0] != '-')
1395 blacklist_store_name (user, ent);
1396 }
1397 __internal_endnetgrent (&netgrdata);
1398 continue;
1399 }
1400
1401 /* +@netgroup */
1402 if (result->pw_name[0] == '+' && result->pw_name[1] == '@'
1403 && result->pw_name[2] != '\0')
1404 {
1405 char buf[strlen (result->pw_name)];
1406 int status;
1407
1408 strcpy (buf, &result->pw_name[2]);
1409 ent->netgroup = TRUE;
1410 ent->first = TRUE;
1411 copy_pwd_changes (&ent->pwd, result, NULL, 0);
1412
1413 do
1414 {
1415 if (use_nisplus)
1416 status = getpwent_next_nisplus_netgr (NULL, result, ent, buf,
1417 buffer, buflen, errnop);
1418 else
1419 status = getpwent_next_nis_netgr (NULL, result, ent, buf,
1420 buffer, buflen, errnop);
1421 if (status == NSS_STATUS_RETURN)
1422 continue;
1423
1424 if (status == NSS_STATUS_SUCCESS && uid == result->pw_uid)
1425 return NSS_STATUS_SUCCESS;
1426 } while (status == NSS_STATUS_SUCCESS);
1427 continue;
1428 }
1429
1430 /* -user */
1431 if (result->pw_name[0] == '-' && result->pw_name[1] != '\0'
1432 && result->pw_name[1] != '@')
1433 {
1434 blacklist_store_name (&result->pw_name[1], ent);
1435 continue;
1436 }
1437
1438 /* +user */
1439 if (result->pw_name[0] == '+' && result->pw_name[1] != '\0'
1440 && result->pw_name[1] != '@')
1441 {
1442 enum nss_status status;
1443
1444 /* Store the User in the blacklist for the "+" at the end of
1445 /etc/passwd */
1446 blacklist_store_name (&result->pw_name[1], ent);
1447 status = getpwnam_plususer (&result->pw_name[1], result, buffer,
1448 buflen, errnop);
1449 if (status == NSS_STATUS_SUCCESS && result->pw_uid == uid)
1450 break;
1451 else
1452 continue;
1453 }
1454
1455 /* +:... */
1456 if (result->pw_name[0] == '+' && result->pw_name[1] == '\0')
1457 {
1458 enum nss_status status;
1459
1460 status = getpwuid_plususer (uid, result, buffer, buflen, errnop);
1461 if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
1462 break;
1463 else
1464 if (status == NSS_STATUS_RETURN) /* We couldn't parse the entry */
1465 return NSS_STATUS_NOTFOUND;
1466 else
1467 return status;
1468 }
1469 }
1470 return NSS_STATUS_SUCCESS;
1471 }
1472
1473 enum nss_status
1474 _nss_compat_getpwuid_r (uid_t uid, struct passwd *pwd,
1475 char *buffer, size_t buflen, int *errnop)
1476 {
1477 ent_t ent = {0, 0, 0, NULL, 0, NULL, NULL, {NULL, 0, 0},
1478 {NULL, NULL, 0, 0, NULL, NULL, NULL}};
1479 enum nss_status status;
1480
1481 __libc_lock_lock (lock);
1482
1483 if (ni == NULL)
1484 {
1485 __nss_database_lookup ("passwd_compat", NULL, "nis", &ni);
1486 use_nisplus = (strcmp (ni->name, "nisplus") == 0);
1487 }
1488
1489 __libc_lock_unlock (lock);
1490
1491 status = internal_setpwent (&ent);
1492 if (status != NSS_STATUS_SUCCESS)
1493 return status;
1494
1495 status = internal_getpwuid_r (uid, pwd, &ent, buffer, buflen, errnop);
1496
1497 internal_endpwent (&ent);
1498
1499 return status;
1500 }
1501
1502
1503 /* Support routines for remembering -@netgroup and -user entries.
1504 The names are stored in a single string with `|' as separator. */
1505 static void
1506 blacklist_store_name (const char *name, ent_t *ent)
1507 {
1508 int namelen = strlen (name);
1509 char *tmp;
1510
1511 /* first call, setup cache */
1512 if (ent->blacklist.size == 0)
1513 {
1514 ent->blacklist.size = MAX (BLACKLIST_INITIAL_SIZE, 2 * namelen);
1515 ent->blacklist.data = malloc (ent->blacklist.size);
1516 if (ent->blacklist.data == NULL)
1517 return;
1518 ent->blacklist.data[0] = '|';
1519 ent->blacklist.data[1] = '\0';
1520 ent->blacklist.current = 1;
1521 }
1522 else
1523 {
1524 if (in_blacklist (name, namelen, ent))
1525 return; /* no duplicates */
1526
1527 if (ent->blacklist.current + namelen + 1 >= ent->blacklist.size)
1528 {
1529 ent->blacklist.size += MAX (BLACKLIST_INCREMENT, 2 * namelen);
1530 tmp = realloc (ent->blacklist.data, ent->blacklist.size);
1531 if (tmp == NULL)
1532 {
1533 free (ent->blacklist.data);
1534 ent->blacklist.size = 0;
1535 return;
1536 }
1537 ent->blacklist.data = tmp;
1538 }
1539 }
1540
1541 tmp = stpcpy (ent->blacklist.data + ent->blacklist.current, name);
1542 *tmp++ = '|';
1543 *tmp = '\0';
1544 ent->blacklist.current += namelen + 1;
1545
1546 return;
1547 }
1548
1549 /* returns TRUE if ent->blacklist contains name, else FALSE */
1550 static bool_t
1551 in_blacklist (const char *name, int namelen, ent_t *ent)
1552 {
1553 char buf[namelen + 3];
1554 char *cp;
1555
1556 if (ent->blacklist.data == NULL)
1557 return FALSE;
1558
1559 buf[0] = '|';
1560 cp = stpcpy (&buf[1], name);
1561 *cp++= '|';
1562 *cp = '\0';
1563 return strstr (ent->blacklist.data, buf) != NULL;
1564 }
sources.redhat.com git mirror of glibc CVS