Contents of /trunk/mkinitrd-magellan/busybox/libpwdgrp/pwd_grp.c
Parent Directory | Revision Log
Revision 816 -
(show annotations)
(download)
Fri Apr 24 18:33:46 2009 UTC (15 years, 5 months ago) by niro
File MIME type: text/plain
File size: 25356 byte(s)
Fri Apr 24 18:33:46 2009 UTC (15 years, 5 months ago) by niro
File MIME type: text/plain
File size: 25356 byte(s)
-updated to busybox-1.13.4
1 | /* vi: set sw=4 ts=4: */ |
2 | /* Copyright (C) 2003 Manuel Novoa III |
3 | * |
4 | * Licensed under GPL v2, or later. See file LICENSE in this tarball. |
5 | */ |
6 | |
7 | /* Nov 6, 2003 Initial version. |
8 | * |
9 | * NOTE: This implementation is quite strict about requiring all |
10 | * field seperators. It also does not allow leading whitespace |
11 | * except when processing the numeric fields. glibc is more |
12 | * lenient. See the various glibc difference comments below. |
13 | * |
14 | * TODO: |
15 | * Move to dynamic allocation of (currently statically allocated) |
16 | * buffers; especially for the group-related functions since |
17 | * large group member lists will cause error returns. |
18 | * |
19 | */ |
20 | |
21 | #include "libbb.h" |
22 | #include <features.h> |
23 | #include <assert.h> |
24 | |
25 | #ifndef _PATH_SHADOW |
26 | #define _PATH_SHADOW "/etc/shadow" |
27 | #endif |
28 | #ifndef _PATH_PASSWD |
29 | #define _PATH_PASSWD "/etc/passwd" |
30 | #endif |
31 | #ifndef _PATH_GROUP |
32 | #define _PATH_GROUP "/etc/group" |
33 | #endif |
34 | |
35 | /**********************************************************************/ |
36 | /* Sizes for statically allocated buffers. */ |
37 | |
38 | /* If you change these values, also change _SC_GETPW_R_SIZE_MAX and |
39 | * _SC_GETGR_R_SIZE_MAX in libc/unistd/sysconf.c to match */ |
40 | #define PWD_BUFFER_SIZE 256 |
41 | #define GRP_BUFFER_SIZE 256 |
42 | |
43 | /**********************************************************************/ |
44 | /* Prototypes for internal functions. */ |
45 | |
46 | static int bb__pgsreader(int (*parserfunc)(void *d, char *line), void *data, |
47 | char *__restrict line_buff, size_t buflen, FILE *f); |
48 | |
49 | static int bb__parsepwent(void *pw, char *line); |
50 | static int bb__parsegrent(void *gr, char *line); |
51 | #if ENABLE_USE_BB_SHADOW |
52 | static int bb__parsespent(void *sp, char *line); |
53 | #endif |
54 | |
55 | /**********************************************************************/ |
56 | /* We avoid having big global data. */ |
57 | |
58 | struct statics { |
59 | /* Smaller things first */ |
60 | struct passwd getpwuid_resultbuf; |
61 | struct group getgrgid_resultbuf; |
62 | struct passwd getpwnam_resultbuf; |
63 | struct group getgrnam_resultbuf; |
64 | |
65 | char getpwuid_buffer[PWD_BUFFER_SIZE]; |
66 | char getgrgid_buffer[GRP_BUFFER_SIZE]; |
67 | char getpwnam_buffer[PWD_BUFFER_SIZE]; |
68 | char getgrnam_buffer[GRP_BUFFER_SIZE]; |
69 | #if 0 |
70 | struct passwd fgetpwent_resultbuf; |
71 | struct group fgetgrent_resultbuf; |
72 | struct spwd fgetspent_resultbuf; |
73 | char fgetpwent_buffer[PWD_BUFFER_SIZE]; |
74 | char fgetgrent_buffer[GRP_BUFFER_SIZE]; |
75 | char fgetspent_buffer[PWD_BUFFER_SIZE]; |
76 | #endif |
77 | #if 0 //ENABLE_USE_BB_SHADOW |
78 | struct spwd getspuid_resultbuf; |
79 | struct spwd getspnam_resultbuf; |
80 | char getspuid_buffer[PWD_BUFFER_SIZE]; |
81 | char getspnam_buffer[PWD_BUFFER_SIZE]; |
82 | #endif |
83 | // Not converted - too small to bother |
84 | //pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER; |
85 | //FILE *pwf /*= NULL*/; |
86 | //FILE *grf /*= NULL*/; |
87 | //FILE *spf /*= NULL*/; |
88 | #if 0 |
89 | struct passwd getpwent_pwd; |
90 | struct group getgrent_gr; |
91 | char getpwent_line_buff[PWD_BUFFER_SIZE]; |
92 | char getgrent_line_buff[GRP_BUFFER_SIZE]; |
93 | #endif |
94 | #if 0 //ENABLE_USE_BB_SHADOW |
95 | struct spwd getspent_spwd; |
96 | struct spwd sgetspent_spwd; |
97 | char getspent_line_buff[PWD_BUFFER_SIZE]; |
98 | char sgetspent_line_buff[PWD_BUFFER_SIZE]; |
99 | #endif |
100 | }; |
101 | |
102 | static struct statics *ptr_to_statics; |
103 | |
104 | static struct statics *get_S(void) |
105 | { |
106 | if (!ptr_to_statics) |
107 | ptr_to_statics = xzalloc(sizeof(*ptr_to_statics)); |
108 | return ptr_to_statics; |
109 | } |
110 | |
111 | /* Always use in this order, get_S() must be called first */ |
112 | #define RESULTBUF(name) &((S = get_S())->name##_resultbuf) |
113 | #define BUFFER(name) (S->name##_buffer) |
114 | |
115 | /**********************************************************************/ |
116 | /* For the various fget??ent_r funcs, return |
117 | * |
118 | * 0: success |
119 | * ENOENT: end-of-file encountered |
120 | * ERANGE: buflen too small |
121 | * other error values possible. See bb__pgsreader. |
122 | * |
123 | * Also, *result == resultbuf on success and NULL on failure. |
124 | * |
125 | * NOTE: glibc difference - For the ENOENT case, glibc also sets errno. |
126 | * We do not, as it really isn't an error if we reach the end-of-file. |
127 | * Doing so is analogous to having fgetc() set errno on EOF. |
128 | */ |
129 | /**********************************************************************/ |
130 | |
131 | int fgetpwent_r(FILE *__restrict stream, struct passwd *__restrict resultbuf, |
132 | char *__restrict buffer, size_t buflen, |
133 | struct passwd **__restrict result) |
134 | { |
135 | int rv; |
136 | |
137 | *result = NULL; |
138 | |
139 | rv = bb__pgsreader(bb__parsepwent, resultbuf, buffer, buflen, stream); |
140 | if (!rv) { |
141 | *result = resultbuf; |
142 | } |
143 | |
144 | return rv; |
145 | } |
146 | |
147 | int fgetgrent_r(FILE *__restrict stream, struct group *__restrict resultbuf, |
148 | char *__restrict buffer, size_t buflen, |
149 | struct group **__restrict result) |
150 | { |
151 | int rv; |
152 | |
153 | *result = NULL; |
154 | |
155 | rv = bb__pgsreader(bb__parsegrent, resultbuf, buffer, buflen, stream); |
156 | if (!rv) { |
157 | *result = resultbuf; |
158 | } |
159 | |
160 | return rv; |
161 | } |
162 | |
163 | #if ENABLE_USE_BB_SHADOW |
164 | int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf, |
165 | char *__restrict buffer, size_t buflen, |
166 | struct spwd **__restrict result) |
167 | { |
168 | int rv; |
169 | |
170 | *result = NULL; |
171 | |
172 | rv = bb__pgsreader(bb__parsespent, resultbuf, buffer, buflen, stream); |
173 | if (!rv) { |
174 | *result = resultbuf; |
175 | } |
176 | |
177 | return rv; |
178 | } |
179 | #endif |
180 | |
181 | /**********************************************************************/ |
182 | /* For the various fget??ent funcs, return NULL on failure and a |
183 | * pointer to the appropriate struct (statically allocated) on success. |
184 | * TODO: audit & stop using these in bbox, they pull in static buffers */ |
185 | /**********************************************************************/ |
186 | |
187 | #if 0 |
188 | struct passwd *fgetpwent(FILE *stream) |
189 | { |
190 | struct statics *S; |
191 | struct passwd *resultbuf = RESULTBUF(fgetpwent); |
192 | char *buffer = BUFFER(fgetpwent); |
193 | struct passwd *result; |
194 | |
195 | fgetpwent_r(stream, resultbuf, buffer, sizeof(BUFFER(fgetpwent)), &result); |
196 | return result; |
197 | } |
198 | |
199 | struct group *fgetgrent(FILE *stream) |
200 | { |
201 | struct statics *S; |
202 | struct group *resultbuf = RESULTBUF(fgetgrent); |
203 | char *buffer = BUFFER(fgetgrent); |
204 | struct group *result; |
205 | |
206 | fgetgrent_r(stream, resultbuf, buffer, sizeof(BUFFER(fgetgrent)), &result); |
207 | return result; |
208 | } |
209 | #endif |
210 | |
211 | #if ENABLE_USE_BB_SHADOW |
212 | #if 0 |
213 | struct spwd *fgetspent(FILE *stream) |
214 | { |
215 | struct statics *S; |
216 | struct spwd *resultbuf = RESULTBUF(fgetspent); |
217 | char *buffer = BUFFER(fgetspent); |
218 | struct spwd *result; |
219 | |
220 | fgetspent_r(stream, resultbuf, buffer, sizeof(BUFFER(fgetspent)), &result); |
221 | return result; |
222 | } |
223 | #endif |
224 | |
225 | int sgetspent_r(const char *string, struct spwd *result_buf, |
226 | char *buffer, size_t buflen, struct spwd **result) |
227 | { |
228 | int rv = ERANGE; |
229 | |
230 | *result = NULL; |
231 | |
232 | if (buflen < PWD_BUFFER_SIZE) { |
233 | DO_ERANGE: |
234 | errno=rv; |
235 | goto DONE; |
236 | } |
237 | |
238 | if (string != buffer) { |
239 | if (strlen(string) >= buflen) { |
240 | goto DO_ERANGE; |
241 | } |
242 | strcpy(buffer, string); |
243 | } |
244 | |
245 | rv = bb__parsespent(result_buf, buffer); |
246 | if (!rv) { |
247 | *result = result_buf; |
248 | } |
249 | |
250 | DONE: |
251 | return rv; |
252 | } |
253 | #endif |
254 | |
255 | /**********************************************************************/ |
256 | |
257 | #define GETXXKEY_R_FUNC getpwnam_r |
258 | #define GETXXKEY_R_PARSER bb__parsepwent |
259 | #define GETXXKEY_R_ENTTYPE struct passwd |
260 | #define GETXXKEY_R_TEST(ENT) (!strcmp((ENT)->pw_name, key)) |
261 | #define GETXXKEY_R_KEYTYPE const char *__restrict |
262 | #define GETXXKEY_R_PATHNAME _PATH_PASSWD |
263 | #include "pwd_grp_internal.c" |
264 | |
265 | #define GETXXKEY_R_FUNC getgrnam_r |
266 | #define GETXXKEY_R_PARSER bb__parsegrent |
267 | #define GETXXKEY_R_ENTTYPE struct group |
268 | #define GETXXKEY_R_TEST(ENT) (!strcmp((ENT)->gr_name, key)) |
269 | #define GETXXKEY_R_KEYTYPE const char *__restrict |
270 | #define GETXXKEY_R_PATHNAME _PATH_GROUP |
271 | #include "pwd_grp_internal.c" |
272 | |
273 | #if ENABLE_USE_BB_SHADOW |
274 | #define GETXXKEY_R_FUNC getspnam_r |
275 | #define GETXXKEY_R_PARSER bb__parsespent |
276 | #define GETXXKEY_R_ENTTYPE struct spwd |
277 | #define GETXXKEY_R_TEST(ENT) (!strcmp((ENT)->sp_namp, key)) |
278 | #define GETXXKEY_R_KEYTYPE const char *__restrict |
279 | #define GETXXKEY_R_PATHNAME _PATH_SHADOW |
280 | #include "pwd_grp_internal.c" |
281 | #endif |
282 | |
283 | #define GETXXKEY_R_FUNC getpwuid_r |
284 | #define GETXXKEY_R_PARSER bb__parsepwent |
285 | #define GETXXKEY_R_ENTTYPE struct passwd |
286 | #define GETXXKEY_R_TEST(ENT) ((ENT)->pw_uid == key) |
287 | #define GETXXKEY_R_KEYTYPE uid_t |
288 | #define GETXXKEY_R_PATHNAME _PATH_PASSWD |
289 | #include "pwd_grp_internal.c" |
290 | |
291 | #define GETXXKEY_R_FUNC getgrgid_r |
292 | #define GETXXKEY_R_PARSER bb__parsegrent |
293 | #define GETXXKEY_R_ENTTYPE struct group |
294 | #define GETXXKEY_R_TEST(ENT) ((ENT)->gr_gid == key) |
295 | #define GETXXKEY_R_KEYTYPE gid_t |
296 | #define GETXXKEY_R_PATHNAME _PATH_GROUP |
297 | #include "pwd_grp_internal.c" |
298 | |
299 | /**********************************************************************/ |
300 | /* TODO: audit & stop using these in bbox, they pull in static buffers */ |
301 | |
302 | /* This one has many users */ |
303 | struct passwd *getpwuid(uid_t uid) |
304 | { |
305 | struct statics *S; |
306 | struct passwd *resultbuf = RESULTBUF(getpwuid); |
307 | char *buffer = BUFFER(getpwuid); |
308 | struct passwd *result; |
309 | |
310 | getpwuid_r(uid, resultbuf, buffer, sizeof(BUFFER(getpwuid)), &result); |
311 | return result; |
312 | } |
313 | |
314 | /* This one has many users */ |
315 | struct group *getgrgid(gid_t gid) |
316 | { |
317 | struct statics *S; |
318 | struct group *resultbuf = RESULTBUF(getgrgid); |
319 | char *buffer = BUFFER(getgrgid); |
320 | struct group *result; |
321 | |
322 | getgrgid_r(gid, resultbuf, buffer, sizeof(BUFFER(getgrgid)), &result); |
323 | return result; |
324 | } |
325 | |
326 | #if 0 //ENABLE_USE_BB_SHADOW |
327 | /* This function is non-standard and is currently not built. It seems |
328 | * to have been created as a reentrant version of the non-standard |
329 | * functions getspuid. Why getspuid was added, I do not know. */ |
330 | int getspuid_r(uid_t uid, struct spwd *__restrict resultbuf, |
331 | char *__restrict buffer, size_t buflen, |
332 | struct spwd **__restrict result) |
333 | { |
334 | int rv; |
335 | struct passwd *pp; |
336 | struct passwd password; |
337 | char pwd_buff[PWD_BUFFER_SIZE]; |
338 | |
339 | *result = NULL; |
340 | rv = getpwuid_r(uid, &password, pwd_buff, sizeof(pwd_buff), &pp); |
341 | if (!rv) { |
342 | rv = getspnam_r(password.pw_name, resultbuf, buffer, buflen, result); |
343 | } |
344 | |
345 | return rv; |
346 | } |
347 | |
348 | /* This function is non-standard and is currently not built. |
349 | * Why it was added, I do not know. */ |
350 | struct spwd *getspuid(uid_t uid) |
351 | { |
352 | struct statics *S; |
353 | struct spwd *resultbuf = RESULTBUF(getspuid); |
354 | char *buffer = BUFFER(getspuid); |
355 | struct spwd *result; |
356 | |
357 | getspuid_r(uid, resultbuf, buffer, sizeof(BUFFER(getspuid)), &result); |
358 | return result; |
359 | } |
360 | #endif |
361 | |
362 | /* This one has many users */ |
363 | struct passwd *getpwnam(const char *name) |
364 | { |
365 | struct statics *S; |
366 | struct passwd *resultbuf = RESULTBUF(getpwnam); |
367 | char *buffer = BUFFER(getpwnam); |
368 | struct passwd *result; |
369 | |
370 | getpwnam_r(name, resultbuf, buffer, sizeof(BUFFER(getpwnam)), &result); |
371 | return result; |
372 | } |
373 | |
374 | /* This one has many users */ |
375 | struct group *getgrnam(const char *name) |
376 | { |
377 | struct statics *S; |
378 | struct group *resultbuf = RESULTBUF(getgrnam); |
379 | char *buffer = BUFFER(getgrnam); |
380 | struct group *result; |
381 | |
382 | getgrnam_r(name, resultbuf, buffer, sizeof(BUFFER(getgrnam)), &result); |
383 | return result; |
384 | } |
385 | |
386 | #if 0 //ENABLE_USE_BB_SHADOW |
387 | struct spwd *getspnam(const char *name) |
388 | { |
389 | struct statics *S; |
390 | struct spwd *resultbuf = RESULTBUF(getspnam); |
391 | char *buffer = BUFFER(getspnam); |
392 | struct spwd *result; |
393 | |
394 | getspnam_r(name, resultbuf, buffer, sizeof(BUFFER(getspnam)), &result); |
395 | return result; |
396 | } |
397 | #endif |
398 | |
399 | #ifdef THIS_ONE_IS_UNUSED |
400 | /* This one doesn't use static buffers */ |
401 | int getpw(uid_t uid, char *buf) |
402 | { |
403 | struct passwd resultbuf; |
404 | struct passwd *result; |
405 | char buffer[PWD_BUFFER_SIZE]; |
406 | |
407 | if (!buf) { |
408 | errno = EINVAL; |
409 | } else if (!getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result)) { |
410 | if (sprintf(buf, "%s:%s:%lu:%lu:%s:%s:%s\n", |
411 | resultbuf.pw_name, resultbuf.pw_passwd, |
412 | (unsigned long)(resultbuf.pw_uid), |
413 | (unsigned long)(resultbuf.pw_gid), |
414 | resultbuf.pw_gecos, resultbuf.pw_dir, |
415 | resultbuf.pw_shell) >= 0 |
416 | ) { |
417 | return 0; |
418 | } |
419 | } |
420 | |
421 | return -1; |
422 | } |
423 | #endif |
424 | |
425 | /**********************************************************************/ |
426 | |
427 | /* FIXME: we don't have such CONFIG_xx - ?! */ |
428 | |
429 | #if defined CONFIG_USE_BB_THREADSAFE_SHADOW && defined PTHREAD_MUTEX_INITIALIZER |
430 | static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER; |
431 | # define LOCK pthread_mutex_lock(&mylock) |
432 | # define UNLOCK pthread_mutex_unlock(&mylock); |
433 | #else |
434 | # define LOCK ((void) 0) |
435 | # define UNLOCK ((void) 0) |
436 | #endif |
437 | |
438 | static FILE *pwf /*= NULL*/; |
439 | void setpwent(void) |
440 | { |
441 | LOCK; |
442 | if (pwf) { |
443 | rewind(pwf); |
444 | } |
445 | UNLOCK; |
446 | } |
447 | |
448 | void endpwent(void) |
449 | { |
450 | LOCK; |
451 | if (pwf) { |
452 | fclose(pwf); |
453 | pwf = NULL; |
454 | } |
455 | UNLOCK; |
456 | } |
457 | |
458 | |
459 | int getpwent_r(struct passwd *__restrict resultbuf, |
460 | char *__restrict buffer, size_t buflen, |
461 | struct passwd **__restrict result) |
462 | { |
463 | int rv; |
464 | |
465 | LOCK; |
466 | *result = NULL; /* In case of error... */ |
467 | |
468 | if (!pwf) { |
469 | pwf = fopen_for_read(_PATH_PASSWD); |
470 | if (!pwf) { |
471 | rv = errno; |
472 | goto ERR; |
473 | } |
474 | } |
475 | |
476 | rv = bb__pgsreader(bb__parsepwent, resultbuf, buffer, buflen, pwf); |
477 | if (!rv) { |
478 | *result = resultbuf; |
479 | } |
480 | |
481 | ERR: |
482 | UNLOCK; |
483 | return rv; |
484 | } |
485 | |
486 | static FILE *grf /*= NULL*/; |
487 | void setgrent(void) |
488 | { |
489 | LOCK; |
490 | if (grf) { |
491 | rewind(grf); |
492 | } |
493 | UNLOCK; |
494 | } |
495 | |
496 | void endgrent(void) |
497 | { |
498 | LOCK; |
499 | if (grf) { |
500 | fclose(grf); |
501 | grf = NULL; |
502 | } |
503 | UNLOCK; |
504 | } |
505 | |
506 | int getgrent_r(struct group *__restrict resultbuf, |
507 | char *__restrict buffer, size_t buflen, |
508 | struct group **__restrict result) |
509 | { |
510 | int rv; |
511 | |
512 | LOCK; |
513 | *result = NULL; /* In case of error... */ |
514 | |
515 | if (!grf) { |
516 | grf = fopen_for_read(_PATH_GROUP); |
517 | if (!grf) { |
518 | rv = errno; |
519 | goto ERR; |
520 | } |
521 | } |
522 | |
523 | rv = bb__pgsreader(bb__parsegrent, resultbuf, buffer, buflen, grf); |
524 | if (!rv) { |
525 | *result = resultbuf; |
526 | } |
527 | |
528 | ERR: |
529 | UNLOCK; |
530 | return rv; |
531 | } |
532 | |
533 | #if ENABLE_USE_BB_SHADOW |
534 | static FILE *spf /*= NULL*/; |
535 | void setspent(void) |
536 | { |
537 | LOCK; |
538 | if (spf) { |
539 | rewind(spf); |
540 | } |
541 | UNLOCK; |
542 | } |
543 | |
544 | void endspent(void) |
545 | { |
546 | LOCK; |
547 | if (spf) { |
548 | fclose(spf); |
549 | spf = NULL; |
550 | } |
551 | UNLOCK; |
552 | } |
553 | |
554 | int getspent_r(struct spwd *resultbuf, char *buffer, |
555 | size_t buflen, struct spwd **result) |
556 | { |
557 | int rv; |
558 | |
559 | LOCK; |
560 | *result = NULL; /* In case of error... */ |
561 | |
562 | if (!spf) { |
563 | spf = fopen_for_read(_PATH_SHADOW); |
564 | if (!spf) { |
565 | rv = errno; |
566 | goto ERR; |
567 | } |
568 | } |
569 | |
570 | rv = bb__pgsreader(bb__parsespent, resultbuf, buffer, buflen, spf); |
571 | if (!rv) { |
572 | *result = resultbuf; |
573 | } |
574 | |
575 | ERR: |
576 | UNLOCK; |
577 | return rv; |
578 | } |
579 | #endif |
580 | |
581 | #if 0 |
582 | struct passwd *getpwent(void) |
583 | { |
584 | static char line_buff[PWD_BUFFER_SIZE]; |
585 | static struct passwd pwd; |
586 | struct passwd *result; |
587 | |
588 | getpwent_r(&pwd, line_buff, sizeof(line_buff), &result); |
589 | return result; |
590 | } |
591 | |
592 | struct group *getgrent(void) |
593 | { |
594 | static char line_buff[GRP_BUFFER_SIZE]; |
595 | static struct group gr; |
596 | struct group *result; |
597 | |
598 | getgrent_r(&gr, line_buff, sizeof(line_buff), &result); |
599 | return result; |
600 | } |
601 | #endif |
602 | |
603 | #if 0 //ENABLE_USE_BB_SHADOW |
604 | struct spwd *getspent(void) |
605 | { |
606 | static char line_buff[PWD_BUFFER_SIZE]; |
607 | static struct spwd spwd; |
608 | struct spwd *result; |
609 | |
610 | getspent_r(&spwd, line_buff, sizeof(line_buff), &result); |
611 | return result; |
612 | } |
613 | |
614 | struct spwd *sgetspent(const char *string) |
615 | { |
616 | static char line_buff[PWD_BUFFER_SIZE]; |
617 | static struct spwd spwd; |
618 | struct spwd *result; |
619 | |
620 | sgetspent_r(string, &spwd, line_buff, sizeof(line_buff), &result); |
621 | return result; |
622 | } |
623 | #endif |
624 | |
625 | static gid_t *getgrouplist_internal(int *ngroups_ptr, const char *user, gid_t gid) |
626 | { |
627 | FILE *grfile; |
628 | gid_t *group_list; |
629 | int ngroups; |
630 | struct group group; |
631 | char buff[PWD_BUFFER_SIZE]; |
632 | |
633 | /* We alloc space for 8 gids at a time. */ |
634 | group_list = xmalloc(8 * sizeof(group_list[0])); |
635 | group_list[0] = gid; |
636 | ngroups = 1; |
637 | |
638 | grfile = fopen_for_read(_PATH_GROUP); |
639 | if (grfile) { |
640 | while (!bb__pgsreader(bb__parsegrent, &group, buff, sizeof(buff), grfile)) { |
641 | char **m; |
642 | assert(group.gr_mem); /* Must have at least a NULL terminator. */ |
643 | if (group.gr_gid == gid) |
644 | continue; |
645 | for (m = group.gr_mem; *m; m++) { |
646 | if (strcmp(*m, user) != 0) |
647 | continue; |
648 | group_list = xrealloc_vector(group_list, 3, ngroups); |
649 | group_list[ngroups++] = group.gr_gid; |
650 | break; |
651 | } |
652 | } |
653 | fclose(grfile); |
654 | } |
655 | *ngroups_ptr = ngroups; |
656 | return group_list; |
657 | } |
658 | |
659 | int initgroups(const char *user, gid_t gid) |
660 | { |
661 | int ngroups; |
662 | gid_t *group_list = getgrouplist_internal(&ngroups, user, gid); |
663 | |
664 | ngroups = setgroups(ngroups, group_list); |
665 | free(group_list); |
666 | return ngroups; |
667 | } |
668 | |
669 | int getgrouplist(const char *user, gid_t gid, gid_t *groups, int *ngroups) |
670 | { |
671 | int ngroups_old = *ngroups; |
672 | gid_t *group_list = getgrouplist_internal(ngroups, user, gid); |
673 | |
674 | if (*ngroups <= ngroups_old) { |
675 | ngroups_old = *ngroups; |
676 | memcpy(groups, group_list, ngroups_old * sizeof(groups[0])); |
677 | } else { |
678 | ngroups_old = -1; |
679 | } |
680 | free(group_list); |
681 | return ngroups_old; |
682 | } |
683 | |
684 | int putpwent(const struct passwd *__restrict p, FILE *__restrict f) |
685 | { |
686 | int rv = -1; |
687 | |
688 | if (!p || !f) { |
689 | errno = EINVAL; |
690 | } else { |
691 | /* No extra thread locking is needed above what fprintf does. */ |
692 | if (fprintf(f, "%s:%s:%lu:%lu:%s:%s:%s\n", |
693 | p->pw_name, p->pw_passwd, |
694 | (unsigned long)(p->pw_uid), |
695 | (unsigned long)(p->pw_gid), |
696 | p->pw_gecos, p->pw_dir, p->pw_shell) >= 0 |
697 | ) { |
698 | rv = 0; |
699 | } |
700 | } |
701 | |
702 | return rv; |
703 | } |
704 | |
705 | int putgrent(const struct group *__restrict p, FILE *__restrict f) |
706 | { |
707 | static const char format[] ALIGN1 = ",%s"; |
708 | |
709 | char **m; |
710 | const char *fmt; |
711 | int rv = -1; |
712 | |
713 | if (!p || !f) { /* Sigh... glibc checks. */ |
714 | errno = EINVAL; |
715 | } else { |
716 | if (fprintf(f, "%s:%s:%lu:", |
717 | p->gr_name, p->gr_passwd, |
718 | (unsigned long)(p->gr_gid)) >= 0 |
719 | ) { |
720 | |
721 | fmt = format + 1; |
722 | |
723 | assert(p->gr_mem); |
724 | m = p->gr_mem; |
725 | |
726 | do { |
727 | if (!*m) { |
728 | if (fputc('\n', f) >= 0) { |
729 | rv = 0; |
730 | } |
731 | break; |
732 | } |
733 | if (fprintf(f, fmt, *m) < 0) { |
734 | break; |
735 | } |
736 | ++m; |
737 | fmt = format; |
738 | } while (1); |
739 | |
740 | } |
741 | |
742 | } |
743 | |
744 | return rv; |
745 | } |
746 | |
747 | #if ENABLE_USE_BB_SHADOW |
748 | static const unsigned char _sp_off[] ALIGN1 = { |
749 | offsetof(struct spwd, sp_lstchg), /* 2 - not a char ptr */ |
750 | offsetof(struct spwd, sp_min), /* 3 - not a char ptr */ |
751 | offsetof(struct spwd, sp_max), /* 4 - not a char ptr */ |
752 | offsetof(struct spwd, sp_warn), /* 5 - not a char ptr */ |
753 | offsetof(struct spwd, sp_inact), /* 6 - not a char ptr */ |
754 | offsetof(struct spwd, sp_expire) /* 7 - not a char ptr */ |
755 | }; |
756 | |
757 | int putspent(const struct spwd *p, FILE *stream) |
758 | { |
759 | static const char ld_format[] ALIGN1 = "%ld:"; |
760 | |
761 | const char *f; |
762 | long x; |
763 | int i; |
764 | int rv = -1; |
765 | |
766 | /* Unlike putpwent and putgrent, glibc does not check the args. */ |
767 | if (fprintf(stream, "%s:%s:", p->sp_namp, |
768 | (p->sp_pwdp ? p->sp_pwdp : "")) < 0 |
769 | ) { |
770 | goto DO_UNLOCK; |
771 | } |
772 | |
773 | for (i = 0; i < sizeof(_sp_off); i++) { |
774 | f = ld_format; |
775 | x = *(const long *)(((const char *) p) + _sp_off[i]); |
776 | if (x == -1) { |
777 | f += 3; |
778 | } |
779 | if (fprintf(stream, f, x) < 0) { |
780 | goto DO_UNLOCK; |
781 | } |
782 | } |
783 | |
784 | if ((p->sp_flag != ~0UL) && (fprintf(stream, "%lu", p->sp_flag) < 0)) { |
785 | goto DO_UNLOCK; |
786 | } |
787 | |
788 | if (fputc('\n', stream) > 0) { |
789 | rv = 0; |
790 | } |
791 | |
792 | DO_UNLOCK: |
793 | return rv; |
794 | } |
795 | #endif |
796 | |
797 | /**********************************************************************/ |
798 | /* Internal uClibc functions. */ |
799 | /**********************************************************************/ |
800 | |
801 | static const unsigned char pw_off[] ALIGN1 = { |
802 | offsetof(struct passwd, pw_name), /* 0 */ |
803 | offsetof(struct passwd, pw_passwd), /* 1 */ |
804 | offsetof(struct passwd, pw_uid), /* 2 - not a char ptr */ |
805 | offsetof(struct passwd, pw_gid), /* 3 - not a char ptr */ |
806 | offsetof(struct passwd, pw_gecos), /* 4 */ |
807 | offsetof(struct passwd, pw_dir), /* 5 */ |
808 | offsetof(struct passwd, pw_shell) /* 6 */ |
809 | }; |
810 | |
811 | static int bb__parsepwent(void *data, char *line) |
812 | { |
813 | char *endptr; |
814 | char *p; |
815 | int i; |
816 | |
817 | i = 0; |
818 | do { |
819 | p = ((char *) ((struct passwd *) data)) + pw_off[i]; |
820 | |
821 | if ((i & 6) ^ 2) { /* i!=2 and i!=3 */ |
822 | *((char **) p) = line; |
823 | if (i==6) { |
824 | return 0; |
825 | } |
826 | /* NOTE: glibc difference - glibc allows omission of |
827 | * ':' seperators after the gid field if all remaining |
828 | * entries are empty. We require all separators. */ |
829 | line = strchr(line, ':'); |
830 | if (!line) { |
831 | break; |
832 | } |
833 | } else { |
834 | unsigned long t = strtoul(line, &endptr, 10); |
835 | /* Make sure we had at least one digit, and that the |
836 | * failing char is the next field seperator ':'. See |
837 | * glibc difference note above. */ |
838 | /* TODO: Also check for leading whitespace? */ |
839 | if ((endptr == line) || (*endptr != ':')) { |
840 | break; |
841 | } |
842 | line = endptr; |
843 | if (i & 1) { /* i == 3 -- gid */ |
844 | *((gid_t *) p) = t; |
845 | } else { /* i == 2 -- uid */ |
846 | *((uid_t *) p) = t; |
847 | } |
848 | } |
849 | |
850 | *line++ = 0; |
851 | ++i; |
852 | } while (1); |
853 | |
854 | return -1; |
855 | } |
856 | |
857 | /**********************************************************************/ |
858 | |
859 | static const unsigned char gr_off[] ALIGN1 = { |
860 | offsetof(struct group, gr_name), /* 0 */ |
861 | offsetof(struct group, gr_passwd), /* 1 */ |
862 | offsetof(struct group, gr_gid) /* 2 - not a char ptr */ |
863 | }; |
864 | |
865 | static int bb__parsegrent(void *data, char *line) |
866 | { |
867 | char *endptr; |
868 | char *p; |
869 | int i; |
870 | char **members; |
871 | char *end_of_buf; |
872 | |
873 | end_of_buf = ((struct group *) data)->gr_name; /* Evil hack! */ |
874 | i = 0; |
875 | do { |
876 | p = ((char *) ((struct group *) data)) + gr_off[i]; |
877 | |
878 | if (i < 2) { |
879 | *((char **) p) = line; |
880 | line = strchr(line, ':'); |
881 | if (!line) { |
882 | break; |
883 | } |
884 | *line++ = 0; |
885 | ++i; |
886 | } else { |
887 | *((gid_t *) p) = strtoul(line, &endptr, 10); |
888 | |
889 | /* NOTE: glibc difference - glibc allows omission of the |
890 | * trailing colon when there is no member list. We treat |
891 | * this as an error. */ |
892 | |
893 | /* Make sure we had at least one digit, and that the |
894 | * failing char is the next field seperator ':'. See |
895 | * glibc difference note above. */ |
896 | if ((endptr == line) || (*endptr != ':')) { |
897 | break; |
898 | } |
899 | |
900 | i = 1; /* Count terminating NULL ptr. */ |
901 | p = endptr; |
902 | |
903 | if (p[1]) { /* We have a member list to process. */ |
904 | /* Overwrite the last ':' with a ',' before counting. |
905 | * This allows us to test for initial ',' and adds |
906 | * one ',' so that the ',' count equals the member |
907 | * count. */ |
908 | *p = ','; |
909 | do { |
910 | /* NOTE: glibc difference - glibc allows and trims leading |
911 | * (but not trailing) space. We treat this as an error. */ |
912 | /* NOTE: glibc difference - glibc allows consecutive and |
913 | * trailing commas, and ignores "empty string" users. We |
914 | * treat this as an error. */ |
915 | if (*p == ',') { |
916 | ++i; |
917 | *p = 0; /* nul-terminate each member string. */ |
918 | if (!*++p || (*p == ',') || isspace(*p)) { |
919 | goto ERR; |
920 | } |
921 | } |
922 | } while (*++p); |
923 | } |
924 | |
925 | /* Now align (p+1), rounding up. */ |
926 | /* Assumes sizeof(char **) is a power of 2. */ |
927 | members = (char **)( (((intptr_t) p) + sizeof(char **)) |
928 | & ~((intptr_t)(sizeof(char **) - 1)) ); |
929 | |
930 | if (((char *)(members + i)) > end_of_buf) { /* No space. */ |
931 | break; |
932 | } |
933 | |
934 | ((struct group *) data)->gr_mem = members; |
935 | |
936 | if (--i) { |
937 | p = endptr; /* Pointing to char prior to first member. */ |
938 | do { |
939 | *members++ = ++p; |
940 | if (!--i) break; |
941 | while (*++p) {} |
942 | } while (1); |
943 | } |
944 | *members = NULL; |
945 | |
946 | return 0; |
947 | } |
948 | } while (1); |
949 | |
950 | ERR: |
951 | return -1; |
952 | } |
953 | |
954 | /**********************************************************************/ |
955 | |
956 | #if ENABLE_USE_BB_SHADOW |
957 | static const unsigned char sp_off[] ALIGN1 = { |
958 | offsetof(struct spwd, sp_namp), /* 0 */ |
959 | offsetof(struct spwd, sp_pwdp), /* 1 */ |
960 | offsetof(struct spwd, sp_lstchg), /* 2 - not a char ptr */ |
961 | offsetof(struct spwd, sp_min), /* 3 - not a char ptr */ |
962 | offsetof(struct spwd, sp_max), /* 4 - not a char ptr */ |
963 | offsetof(struct spwd, sp_warn), /* 5 - not a char ptr */ |
964 | offsetof(struct spwd, sp_inact), /* 6 - not a char ptr */ |
965 | offsetof(struct spwd, sp_expire), /* 7 - not a char ptr */ |
966 | offsetof(struct spwd, sp_flag) /* 8 - not a char ptr */ |
967 | }; |
968 | |
969 | static int bb__parsespent(void *data, char * line) |
970 | { |
971 | char *endptr; |
972 | char *p; |
973 | int i; |
974 | |
975 | i = 0; |
976 | do { |
977 | p = ((char *) ((struct spwd *) data)) + sp_off[i]; |
978 | if (i < 2) { |
979 | *((char **) p) = line; |
980 | line = strchr(line, ':'); |
981 | if (!line) { |
982 | break; |
983 | } |
984 | } else { |
985 | *((long *) p) = (long) strtoul(line, &endptr, 10); |
986 | |
987 | if (endptr == line) { |
988 | *((long *) p) = ((i != 8) ? -1L : ((long)(~0UL))); |
989 | } |
990 | |
991 | line = endptr; |
992 | |
993 | if (i == 8) { |
994 | if (!*endptr) { |
995 | return 0; |
996 | } |
997 | break; |
998 | } |
999 | |
1000 | if (*endptr != ':') { |
1001 | break; |
1002 | } |
1003 | |
1004 | } |
1005 | |
1006 | *line++ = 0; |
1007 | ++i; |
1008 | } while (1); |
1009 | |
1010 | return EINVAL; |
1011 | } |
1012 | #endif |
1013 | |
1014 | /**********************************************************************/ |
1015 | |
1016 | /* Reads until if EOF, or until if finds a line which fits in the buffer |
1017 | * and for which the parser function succeeds. |
1018 | * |
1019 | * Returns 0 on success and ENOENT for end-of-file (glibc concession). |
1020 | */ |
1021 | |
1022 | static int bb__pgsreader(int (*parserfunc)(void *d, char *line), void *data, |
1023 | char *__restrict line_buff, size_t buflen, FILE *f) |
1024 | { |
1025 | int line_len; |
1026 | int skip; |
1027 | int rv = ERANGE; |
1028 | |
1029 | if (buflen < PWD_BUFFER_SIZE) { |
1030 | errno = rv; |
1031 | } else { |
1032 | skip = 0; |
1033 | do { |
1034 | if (!fgets(line_buff, buflen, f)) { |
1035 | if (feof(f)) { |
1036 | rv = ENOENT; |
1037 | } |
1038 | break; |
1039 | } |
1040 | |
1041 | line_len = strlen(line_buff) - 1; /* strlen() must be > 0. */ |
1042 | if (line_buff[line_len] == '\n') { |
1043 | line_buff[line_len] = 0; |
1044 | } else if (line_len + 2 == buflen) { /* line too long */ |
1045 | ++skip; |
1046 | continue; |
1047 | } |
1048 | |
1049 | if (skip) { |
1050 | --skip; |
1051 | continue; |
1052 | } |
1053 | |
1054 | /* NOTE: glibc difference - glibc strips leading whitespace from |
1055 | * records. We do not allow leading whitespace. */ |
1056 | |
1057 | /* Skip empty lines, comment lines, and lines with leading |
1058 | * whitespace. */ |
1059 | if (*line_buff && (*line_buff != '#') && !isspace(*line_buff)) { |
1060 | if (parserfunc == bb__parsegrent) { /* Do evil group hack. */ |
1061 | /* The group entry parsing function needs to know where |
1062 | * the end of the buffer is so that it can construct the |
1063 | * group member ptr table. */ |
1064 | ((struct group *) data)->gr_name = line_buff + buflen; |
1065 | } |
1066 | |
1067 | if (!parserfunc(data, line_buff)) { |
1068 | rv = 0; |
1069 | break; |
1070 | } |
1071 | } |
1072 | } while (1); |
1073 | |
1074 | } |
1075 | |
1076 | return rv; |
1077 | } |