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