Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/libpwdgrp/pwd_grp.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/libpwdgrp/pwd_grp.c (modified) (33 diffs)

branches/2.2.9/mindi-busybox/libpwdgrp/pwd_grp.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-/*  Copyright (C) 2003     Manuel Novoa III
+/* Copyright (C) 2003     Manuel Novoa III
  *
- *  Licensed under GPL v2, or later.  See file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
-/*  Nov 6, 2003  Initial version.
+/* Nov 6, 2003  Initial version.
  *
- *  NOTE: This implementation is quite strict about requiring all
+ * NOTE: This implementation is quite strict about requiring all
  *    field seperators.  It also does not allow leading whitespace
  *    except when processing the numeric fields.  glibc is more
  *    lenient.  See the various glibc difference comments below.
  *
- *  TODO:
+ * TODO:
  *    Move to dynamic allocation of (currently statically allocated)
  *      buffers; especially for the group-related functions since
  *      large group member lists will cause error returns.
- *
  */
 
 #include "libbb.h"
-#include <features.h>
 #include <assert.h>
 
 #ifndef _PATH_SHADOW
-#define _PATH_SHADOW    "/etc/shadow"
+#define _PATH_SHADOW    "/etc/shadow"
 #endif
 #ifndef _PATH_PASSWD
-#define _PATH_PASSWD    "/etc/passwd"
+#define _PATH_PASSWD    "/etc/passwd"
 #endif
 #ifndef _PATH_GROUP
-#define _PATH_GROUP "/etc/group"
+#define _PATH_GROUP "/etc/group"
 #endif
 
@@ -44 +42 @@
 /* Prototypes for internal functions. */
 
-static int bb__pgsreader(int (*parserfunc)(void *d, char *line), void *data,
-        char *__restrict line_buff, size_t buflen, FILE *f);
-
-static int bb__parsepwent(void *pw, char *line);
-static int bb__parsegrent(void *gr, char *line);
+static int bb__pgsreader(
+        int FAST_FUNC (*parserfunc)(void *d, char *line),
+        void *data,
+        char *__restrict line_buff,
+        size_t buflen,
+        FILE *f);
+
+static int FAST_FUNC bb__parsepwent(void *pw, char *line);
+static int FAST_FUNC bb__parsegrent(void *gr, char *line);
 #if ENABLE_USE_BB_SHADOW
-static int bb__parsespent(void *sp, char *line);
+static int FAST_FUNC bb__parsespent(void *sp, char *line);
 #endif
 
@@ -162 +164 @@
 
 #if ENABLE_USE_BB_SHADOW
+#ifdef UNUSED_FOR_NOW
 int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
                 char *__restrict buffer, size_t buflen,
@@ -178 +181 @@
 }
 #endif
+#endif
 
 /**********************************************************************/
@@ -185 +189 @@
 /**********************************************************************/
 
-#if 0
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 struct passwd *fgetpwent(FILE *stream)
 {
@@ -210 +214 @@
 
 #if ENABLE_USE_BB_SHADOW
-#if 0
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 struct spwd *fgetspent(FILE *stream)
 {
@@ -223 +227 @@
 #endif
 
+#ifdef UNUSED_FOR_NOW
 int sgetspent_r(const char *string, struct spwd *result_buf,
                 char *buffer, size_t buflen, struct spwd **result)
@@ -231 +236 @@
 
     if (buflen < PWD_BUFFER_SIZE) {
-    DO_ERANGE:
-        errno=rv;
+ DO_ERANGE:
+        errno = rv;
         goto DONE;
     }
@@ -252 +257 @@
 }
 #endif
+#endif /* ENABLE_USE_BB_SHADOW */
 
 /**********************************************************************/
@@ -397 +403 @@
 #endif
 
-/* This one doesn't use static buffers */
-int getpw(uid_t uid, char *buf)
-{
-    struct passwd resultbuf;
-    struct passwd *result;
-    char buffer[PWD_BUFFER_SIZE];
-
-    if (!buf) {
-        errno = EINVAL;
-    } else if (!getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result)) {
-        if (sprintf(buf, "%s:%s:%lu:%lu:%s:%s:%s\n",
-                    resultbuf.pw_name, resultbuf.pw_passwd,
-                    (unsigned long)(resultbuf.pw_uid),
-                    (unsigned long)(resultbuf.pw_gid),
-                    resultbuf.pw_gecos, resultbuf.pw_dir,
-                    resultbuf.pw_shell) >= 0
-            ) {
-            return 0;
-        }
-    }
-
-    return -1;
-}
-
 /**********************************************************************/
 
@@ -465 +447 @@
 
     if (!pwf) {
-        pwf = fopen(_PATH_PASSWD, "r");
+        pwf = fopen_for_read(_PATH_PASSWD);
         if (!pwf) {
             rv = errno;
@@ -512 +494 @@
 
     if (!grf) {
-        grf = fopen(_PATH_GROUP, "r");
+        grf = fopen_for_read(_PATH_GROUP);
         if (!grf) {
             rv = errno;
@@ -529 +511 @@
 }
 
+#ifdef UNUSED_FOR_NOW
 #if ENABLE_USE_BB_SHADOW
 static FILE *spf /*= NULL*/;
@@ -559 +542 @@
 
     if (!spf) {
-        spf = fopen(_PATH_SHADOW, "r");
+        spf = fopen_for_read(_PATH_SHADOW);
         if (!spf) {
             rv = errno;
@@ -576 +559 @@
 }
 #endif
-
-#if 0
+#endif /* UNUSED_FOR_NOW */
+
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 struct passwd *getpwent(void)
 {
@@ -597 +581 @@
     return result;
 }
-#endif
-
-#if 0 //ENABLE_USE_BB_SHADOW
+
+#if ENABLE_USE_BB_SHADOW
 struct spwd *getspent(void)
 {
@@ -620 +603 @@
 }
 #endif
-
-int initgroups(const char *user, gid_t gid)
+#endif /* UNUSED_SINCE_WE_AVOID_STATIC_BUFS */
+
+static gid_t *getgrouplist_internal(int *ngroups_ptr, const char *user, gid_t gid)
 {
     FILE *grfile;
     gid_t *group_list;
-    int num_groups, rv;
-    char **m;
+    int ngroups;
     struct group group;
     char buff[PWD_BUFFER_SIZE];
 
-    rv = -1;
-
     /* We alloc space for 8 gids at a time. */
-    group_list = (gid_t *) malloc(8*sizeof(gid_t *));
-    if (group_list
-     && ((grfile = fopen(_PATH_GROUP, "r")) != NULL)
+    group_list = xmalloc(8 * sizeof(group_list[0]));
+    group_list[0] = gid;
+    ngroups = 1;
+
+    grfile = fopen_for_read(_PATH_GROUP);
+    if (grfile) {
+        while (!bb__pgsreader(bb__parsegrent, &group, buff, sizeof(buff), grfile)) {
+            char **m;
+            assert(group.gr_mem); /* Must have at least a NULL terminator. */
+            if (group.gr_gid == gid)
+                continue;
+            for (m = group.gr_mem; *m; m++) {
+                if (strcmp(*m, user) != 0)
+                    continue;
+                group_list = xrealloc_vector(group_list, /*8=2^3:*/ 3, ngroups);
+                group_list[ngroups++] = group.gr_gid;
+                break;
+            }
+        }
+        fclose(grfile);
+    }
+    *ngroups_ptr = ngroups;
+    return group_list;
+}
+
+int initgroups(const char *user, gid_t gid)
+{
+    int ngroups;
+    gid_t *group_list = getgrouplist_internal(&ngroups, user, gid);
+
+    ngroups = setgroups(ngroups, group_list);
+    free(group_list);
+    return ngroups;
+}
+
+int getgrouplist(const char *user, gid_t gid, gid_t *groups, int *ngroups)
+{
+    int ngroups_old = *ngroups;
+    gid_t *group_list = getgrouplist_internal(ngroups, user, gid);
+
+    if (*ngroups <= ngroups_old) {
+        ngroups_old = *ngroups;
+        memcpy(groups, group_list, ngroups_old * sizeof(groups[0]));
+    } else {
+        ngroups_old = -1;
+    }
+    free(group_list);
+    return ngroups_old;
+}
+
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
+int putpwent(const struct passwd *__restrict p, FILE *__restrict f)
+{
+    int rv = -1;
+
+#if 0
+    /* glibc does this check */
+    if (!p || !f) {
+        errno = EINVAL;
+        return rv;
+    }
+#endif
+
+    /* No extra thread locking is needed above what fprintf does. */
+    if (fprintf(f, "%s:%s:%lu:%lu:%s:%s:%s\n",
+                p->pw_name, p->pw_passwd,
+                (unsigned long)(p->pw_uid),
+                (unsigned long)(p->pw_gid),
+                p->pw_gecos, p->pw_dir, p->pw_shell) >= 0
+        ) {
+        rv = 0;
+    }
+
+    return rv;
+}
+
+int putgrent(const struct group *__restrict p, FILE *__restrict f)
+{
+    int rv = -1;
+
+#if 0
+    /* glibc does this check */
+    if (!p || !f) {
+        errno = EINVAL;
+        return rv;
+    }
+#endif
+
+    if (fprintf(f, "%s:%s:%lu:",
+                p->gr_name, p->gr_passwd,
+                (unsigned long)(p->gr_gid)) >= 0
     ) {
-        *group_list = gid;
-        num_groups = 1;
-
-        while (!bb__pgsreader(bb__parsegrent, &group, buff, sizeof(buff), grfile)) {
-            assert(group.gr_mem); /* Must have at least a NULL terminator. */
-            if (group.gr_gid != gid) {
-                for (m = group.gr_mem; *m; m++) {
-                    if (!strcmp(*m, user)) {
-                        if (!(num_groups & 7)) {
-                            gid_t *tmp = (gid_t *)
-                                realloc(group_list,
-                                        (num_groups+8) * sizeof(gid_t *));
-                            if (!tmp) {
-                                rv = -1;
-                                goto DO_CLOSE;
-                            }
-                            group_list = tmp;
-                        }
-                        group_list[num_groups++] = group.gr_gid;
-                        break;
-                    }
+        static const char format[] ALIGN1 = ",%s";
+
+        char **m;
+        const char *fmt;
+
+        fmt = format + 1;
+
+        assert(p->gr_mem);
+        m = p->gr_mem;
+
+        while (1) {
+            if (!*m) {
+                if (fputc('\n', f) >= 0) {
+                    rv = 0;
                 }
-            }
-        }
-
-        rv = setgroups(num_groups, group_list);
-    DO_CLOSE:
-        fclose(grfile);
-    }
-
-    /* group_list will be NULL if initial malloc failed, which may trigger
-     * warnings from various malloc debuggers. */
-    free(group_list);
-    return rv;
-}
-
-int putpwent(const struct passwd *__restrict p, FILE *__restrict f)
-{
-    int rv = -1;
-
-    if (!p || !f) {
-        errno=EINVAL;
-    } else {
-        /* No extra thread locking is needed above what fprintf does. */
-        if (fprintf(f, "%s:%s:%lu:%lu:%s:%s:%s\n",
-                    p->pw_name, p->pw_passwd,
-                    (unsigned long)(p->pw_uid),
-                    (unsigned long)(p->pw_gid),
-                    p->pw_gecos, p->pw_dir, p->pw_shell) >= 0
-            ) {
-            rv = 0;
-        }
-    }
-
-    return rv;
-}
-
-int putgrent(const struct group *__restrict p, FILE *__restrict f)
-{
-    static const char format[] ALIGN1 = ",%s";
-
-    char **m;
-    const char *fmt;
-    int rv = -1;
-
-    if (!p || !f) {             /* Sigh... glibc checks. */
-        errno=EINVAL;
-    } else {
-        if (fprintf(f, "%s:%s:%lu:",
-                    p->gr_name, p->gr_passwd,
-                    (unsigned long)(p->gr_gid)) >= 0
-            ) {
-
-            fmt = format + 1;
-
-            assert(p->gr_mem);
-            m = p->gr_mem;
-
-            do {
-                if (!*m) {
-                    if (fputc('\n', f) >= 0) {
-                        rv = 0;
-                    }
-                    break;
-                }
-                if (fprintf(f, fmt, *m) < 0) {
-                    break;
-                }
-                ++m;
-                fmt = format;
-            } while (1);
-
-        }
-
-    }
-
-    return rv;
-}
+                break;
+            }
+            if (fprintf(f, fmt, *m) < 0) {
+                break;
+            }
+            m++;
+            fmt = format;
+        }
+    }
+
+    return rv;
+}
+#endif
 
 #if ENABLE_USE_BB_SHADOW
-static const unsigned char _sp_off[] ALIGN1 = {
+#ifdef UNUSED_FOR_NOW
+static const unsigned char put_sp_off[] ALIGN1 = {
     offsetof(struct spwd, sp_lstchg),       /* 2 - not a char ptr */
     offsetof(struct spwd, sp_min),          /* 3 - not a char ptr */
@@ -748 +748 @@
 int putspent(const struct spwd *p, FILE *stream)
 {
-    static const char ld_format[] ALIGN1 = "%ld:";
-
-    const char *f;
+    const char *fmt;
     long x;
     int i;
@@ -762 +760 @@
     }
 
-    for (i = 0; i < sizeof(_sp_off); i++) {
-        f = ld_format;
-        x = *(const long *)(((const char *) p) + _sp_off[i]);
+    for (i = 0; i < sizeof(put_sp_off); i++) {
+        fmt = "%ld:";
+        x = *(long *)((char *)p + put_sp_off[i]);
         if (x == -1) {
-            f += 3;
-        }
-        if (fprintf(stream, f, x) < 0) {
+            fmt += 3;
+        }
+        if (fprintf(stream, fmt, x) < 0) {
             goto DO_UNLOCK;
         }
@@ -781 +779 @@
     }
 
-DO_UNLOCK:
-    return rv;
-}
-#endif
-
-/**********************************************************************/
-/* Internal uClibc functions.                                         */
+ DO_UNLOCK:
+    return rv;
+}
+#endif
+#endif /* USE_BB_SHADOW */
+
+/**********************************************************************/
+/* Internal functions                                                 */
 /**********************************************************************/
 
@@ -800 +799 @@
 };
 
-static int bb__parsepwent(void *data, char *line)
+static int FAST_FUNC bb__parsepwent(void *data, char *line)
 {
     char *endptr;
@@ -807 +806 @@
 
     i = 0;
-    do {
-        p = ((char *) ((struct passwd *) data)) + pw_off[i];
-
-        if ((i & 6) ^ 2) {  /* i!=2 and i!=3 */
+    while (1) {
+        p = (char *) data + pw_off[i];
+
+        if (i < 2 || i > 3) {
             *((char **) p) = line;
-            if (i==6) {
+            if (i == 6) {
                 return 0;
             }
@@ -839 +838 @@
         }
 
-        *line++ = 0;
-        ++i;
-    } while (1);
+        *line++ = '\0';
+        i++;
+    } /* while (1) */
 
     return -1;
@@ -854 +853 @@
 };
 
-static int bb__parsegrent(void *data, char *line)
+static int FAST_FUNC bb__parsegrent(void *data, char *line)
 {
     char *endptr;
@@ -864 +863 @@
     end_of_buf = ((struct group *) data)->gr_name; /* Evil hack! */
     i = 0;
-    do {
-        p = ((char *) ((struct group *) data)) + gr_off[i];
+    while (1) {
+        p = (char *) data + gr_off[i];
 
         if (i < 2) {
@@ -873 +872 @@
                 break;
             }
-            *line++ = 0;
-            ++i;
+            *line++ = '\0';
+            i++;
         } else {
             *((gid_t *) p) = strtoul(line, &endptr, 10);
@@ -894 +893 @@
             if (p[1]) { /* We have a member list to process. */
                 /* Overwrite the last ':' with a ',' before counting.
-                 * This allows us to test for initial ',' and adds
-                 * one ',' so that the ',' count equals the member
-                 * count. */
+                 * This allows us to (1) test for initial ','
+                 * and (2) adds one ',' so that the number of commas
+                 * equals the member count. */
                 *p = ',';
                 do {
@@ -927 +926 @@
             if (--i) {
                 p = endptr; /* Pointing to char prior to first member. */
-                do {
+                while (1) {
                     *members++ = ++p;
-                    if (!--i) break;
-                    while (*++p) {}
-                } while (1);
+                    if (!--i)
+                        break;
+                    while (*++p)
+                        continue;
+                }
             }
             *members = NULL;
@@ -937 +938 @@
             return 0;
         }
-    } while (1);
+    } /* while (1) */
 
  ERR:
@@ -947 +948 @@
 #if ENABLE_USE_BB_SHADOW
 static const unsigned char sp_off[] ALIGN1 = {
-    offsetof(struct spwd, sp_namp),         /* 0 */
-    offsetof(struct spwd, sp_pwdp),         /* 1 */
-    offsetof(struct spwd, sp_lstchg),       /* 2 - not a char ptr */
-    offsetof(struct spwd, sp_min),          /* 3 - not a char ptr */
-    offsetof(struct spwd, sp_max),          /* 4 - not a char ptr */
-    offsetof(struct spwd, sp_warn),         /* 5 - not a char ptr */
-    offsetof(struct spwd, sp_inact),        /* 6 - not a char ptr */
-    offsetof(struct spwd, sp_expire),       /* 7 - not a char ptr */
-    offsetof(struct spwd, sp_flag)          /* 8 - not a char ptr */
+    offsetof(struct spwd, sp_namp),         /* 0: char* */
+    offsetof(struct spwd, sp_pwdp),         /* 1: char* */
+    offsetof(struct spwd, sp_lstchg),       /* 2: long */
+    offsetof(struct spwd, sp_min),          /* 3: long */
+    offsetof(struct spwd, sp_max),          /* 4: long */
+    offsetof(struct spwd, sp_warn),         /* 5: long */
+    offsetof(struct spwd, sp_inact),        /* 6: long */
+    offsetof(struct spwd, sp_expire),       /* 7: long */
+    offsetof(struct spwd, sp_flag)          /* 8: unsigned long */
 };
 
-static int bb__parsespent(void *data, char * line)
+static int FAST_FUNC bb__parsespent(void *data, char *line)
 {
     char *endptr;
@@ -965 +966 @@
 
     i = 0;
-    do {
-        p = ((char *) ((struct spwd *) data)) + sp_off[i];
+    while (1) {
+        p = (char *) data + sp_off[i];
         if (i < 2) {
             *((char **) p) = line;
             line = strchr(line, ':');
             if (!line) {
-                break;
+                break; /* error */
             }
         } else {
-            *((long *) p) = (long) strtoul(line, &endptr, 10);
-
+            *((long *) p) = strtoul(line, &endptr, 10);
             if (endptr == line) {
-                *((long *) p) = ((i != 8) ? -1L : ((long)(~0UL)));
-            }
-
+                *((long *) p) = -1L;
+            }
             line = endptr;
-
             if (i == 8) {
-                if (!*endptr) {
-                    return 0;
+                if (*line != '\0') {
+                    break; /* error */
                 }
-                break;
-            }
-
-            if (*endptr != ':') {
-                break;
-            }
-
-        }
-
-        *line++ = 0;
-        ++i;
-    } while (1);
+                return 0; /* all ok */
+            }
+            if (*line != ':') {
+                break; /* error */
+            }
+        }
+        *line++ = '\0';
+        i++;
+    }
 
     return EINVAL;
@@ -1005 +1000 @@
 /**********************************************************************/
 
-/* Reads until if EOF, or until if finds a line which fits in the buffer
+/* Reads until EOF, or until it finds a line which fits in the buffer
  * and for which the parser function succeeds.
  *
- * Returns 0 on success and ENOENT for end-of-file (glibc concession).
+ * Returns 0 on success and ENOENT for end-of-file (glibc convention).
  */
-
-static int bb__pgsreader(int (*parserfunc)(void *d, char *line), void *data,
-                char *__restrict line_buff, size_t buflen, FILE *f)
-{
-    int line_len;
+static int bb__pgsreader(
+        int FAST_FUNC (*parserfunc)(void *d, char *line),
+        void *data,
+        char *__restrict line_buff,
+        size_t buflen,
+        FILE *f)
+{
     int skip;
     int rv = ERANGE;
@@ -1020 +1017 @@
     if (buflen < PWD_BUFFER_SIZE) {
         errno = rv;
-    } else {
-        skip = 0;
-        do {
-            if (!fgets(line_buff, buflen, f)) {
-                if (feof(f)) {
-                    rv = ENOENT;
-                }
+        return rv;
+    }
+
+    skip = 0;
+    while (1) {
+        if (!fgets(line_buff, buflen, f)) {
+            if (feof(f)) {
+                rv = ENOENT;
+            }
+            break;
+        }
+
+        {
+            int line_len = strlen(line_buff) - 1;
+            if (line_len >= 0 && line_buff[line_len] == '\n') {
+                line_buff[line_len] = '\0';
+            } else
+            if (line_len + 2 == buflen) {
+                /* A start (or continuation) of overlong line */
+                skip = 1;
+                continue;
+            } /* else: a last line in the file, and it has no '\n' */
+        }
+
+        if (skip) {
+            /* This "line" is a remainder of overlong line, ignore */
+            skip = 0;
+            continue;
+        }
+
+        /* NOTE: glibc difference - glibc strips leading whitespace from
+         * records.  We do not allow leading whitespace. */
+
+        /* Skip empty lines, comment lines, and lines with leading
+         * whitespace. */
+        if (line_buff[0] != '\0' && line_buff[0] != '#' && !isspace(line_buff[0])) {
+            if (parserfunc == bb__parsegrent) {
+                /* Do evil group hack:
+                 * The group entry parsing function needs to know where
+                 * the end of the buffer is so that it can construct the
+                 * group member ptr table. */
+                ((struct group *) data)->gr_name = line_buff + buflen;
+            }
+            if (parserfunc(data, line_buff) == 0) {
+                rv = 0;
                 break;
             }
-
-            line_len = strlen(line_buff) - 1; /* strlen() must be > 0. */
-            if (line_buff[line_len] == '\n') {
-                line_buff[line_len] = 0;
-            } else if (line_len + 2 == buflen) { /* line too long */
-                ++skip;
-                continue;
-            }
-
-            if (skip) {
-                --skip;
-                continue;
-            }
-
-            /* NOTE: glibc difference - glibc strips leading whitespace from
-             * records.  We do not allow leading whitespace. */
-
-            /* Skip empty lines, comment lines, and lines with leading
-             * whitespace. */
-            if (*line_buff && (*line_buff != '#') && !isspace(*line_buff)) {
-                if (parserfunc == bb__parsegrent) { /* Do evil group hack. */
-                    /* The group entry parsing function needs to know where
-                     * the end of the buffer is so that it can construct the
-                     * group member ptr table. */
-                    ((struct group *) data)->gr_name = line_buff + buflen;
-                }
-
-                if (!parserfunc(data, line_buff)) {
-                    rv = 0;
-                    break;
-                }
-            }
-        } while (1);
-
-    }
-
-    return rv;
-}
+        }
+    } /* while (1) */
+
+    return rv;
+}