Make <libutil.h> work when included by itself.

[pw-darwin.git] / libutil / pw_util.c

diff --git a/libutil/pw_util.c b/libutil/pw_util.c
index e28f3c956b7d6c3c53a13801e52551f18d453ad2..75459e338b12a7e7377c403bd28a0fdb336a04de 100644 (file)
--- a/libutil/pw_util.c
+++ b/libutil/pw_util.c
@@ -17,10 +17,6 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.

- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.

  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.


@@ -58,8 +54,8 @@ static const char rcsid[] =
 #include <sys/stat.h>
 #include <sys/wait.h>
 
 #include <sys/stat.h>
 #include <sys/wait.h>
 

-#include <err.h>

 #include <ctype.h>
 #include <ctype.h>

+#include <err.h>

 #include <fcntl.h>
 #include <inttypes.h>
 #include <libgen.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <libgen.h>


@@ -80,6 +76,7 @@ static char passwd_dir[PATH_MAX];
 static char tempname[PATH_MAX];
 static int initialized;
 
 static char tempname[PATH_MAX];
 static int initialized;
 

+#if 0

 void
 pw_cont(int sig)
 {
 void
 pw_cont(int sig)
 {


@@ -87,6 +84,7 @@ pw_cont(int sig)
        if (editpid != -1)
                kill(editpid, sig);
 }
        if (editpid != -1)
                kill(editpid, sig);
 }

+#endif

 
 /*
  * Initialize statics and set limits, signals & umask to try to avoid
 
 /*
  * Initialize statics and set limits, signals & umask to try to avoid


@@ -102,7 +100,7 @@ pw_init(const char *dir, const char *master)
        if (dir == NULL) {
                strcpy(passwd_dir, _PATH_ETC);
        } else {
        if (dir == NULL) {
                strcpy(passwd_dir, _PATH_ETC);
        } else {

-               if (strlen(dir) >= sizeof passwd_dir) {
+               if (strlen(dir) >= sizeof(passwd_dir)) {

                        errno = ENAMETOOLONG;
                        return (-1);
                }
                        errno = ENAMETOOLONG;
                        return (-1);
                }


@@ -112,13 +110,13 @@ pw_init(const char *dir, const char *master)
        if (master == NULL) {
                if (dir == NULL) {
                        strcpy(masterpasswd, _PATH_MASTERPASSWD);
        if (master == NULL) {
                if (dir == NULL) {
                        strcpy(masterpasswd, _PATH_MASTERPASSWD);

-               } else if (snprintf(masterpasswd, sizeof masterpasswd, "%s/%s",
-                   passwd_dir, _MASTERPASSWD) > sizeof masterpasswd) {
+               } else if (snprintf(masterpasswd, sizeof(masterpasswd), "%s/%s",
+                   passwd_dir, _MASTERPASSWD) > (int)sizeof(masterpasswd)) {

                        errno = ENAMETOOLONG;
                        return (-1);
                }
        } else {
                        errno = ENAMETOOLONG;
                        return (-1);
                }
        } else {

-               if (strlen(master) >= sizeof masterpasswd) {
+               if (strlen(master) >= sizeof(masterpasswd)) {

                        errno = ENAMETOOLONG;
                        return (-1);
                }
                        errno = ENAMETOOLONG;
                        return (-1);
                }


@@ -185,16 +183,21 @@ pw_lock(void)
                if (lockfd < 0 || fcntl(lockfd, F_SETFD, 1) == -1)
                        err(1, "%s", masterpasswd);
                /* XXX vulnerable to race conditions */
                if (lockfd < 0 || fcntl(lockfd, F_SETFD, 1) == -1)
                        err(1, "%s", masterpasswd);
                /* XXX vulnerable to race conditions */

-               if (flock(lockfd, LOCK_EX|LOCK_NB))
-                       errx(1, "the password db file is busy");
+               if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {
+                       if (errno == EWOULDBLOCK) {
+                               errx(1, "the password db file is busy");
+                       } else {
+                               err(1, "could not lock the passwd file: ");
+                       }
+               }

 
                /*
                 * If the password file was replaced while we were trying to
                 * get the lock, our hardlink count will be 0 and we have to
                 * close and retry.
                 */
 
                /*
                 * If the password file was replaced while we were trying to
                 * get the lock, our hardlink count will be 0 and we have to
                 * close and retry.
                 */

-               if (fstat(lockfd, &st) < 0)
-                       errx(1, "fstat() failed");
+               if (fstat(lockfd, &st) == -1)
+                       err(1, "fstat() failed: ");

                if (st.st_nlink != 0)
                        break;
                close(lockfd);
                if (st.st_nlink != 0)
                        break;
                close(lockfd);


@@ -211,7 +214,7 @@ int
 pw_tmp(int mfd)
 {
        char buf[8192];
 pw_tmp(int mfd)
 {
        char buf[8192];

-       ssize_t nr, nw;
+       ssize_t nr;

        const char *p;
        int tfd;
 
        const char *p;
        int tfd;
 


@@ -221,16 +224,16 @@ pw_tmp(int mfd)
                ++p;
        else
                p = masterpasswd;
                ++p;
        else
                p = masterpasswd;

-       if (snprintf(tempname, sizeof tempname, "%.*spw.XXXXXX",
-               (int)(p - masterpasswd), masterpasswd) >= sizeof tempname) {
+       if (snprintf(tempname, sizeof(tempname), "%.*spw.XXXXXX",
+               (int)(p - masterpasswd), masterpasswd) >= (int)sizeof(tempname)) {

                errno = ENAMETOOLONG;
                return (-1);
        }
        if ((tfd = mkstemp(tempname)) == -1)
                return (-1);
        if (mfd != -1) {
                errno = ENAMETOOLONG;
                return (-1);
        }
        if ((tfd = mkstemp(tempname)) == -1)
                return (-1);
        if (mfd != -1) {

-               while ((nr = read(mfd, buf, sizeof buf)) > 0)
-                       if ((nw = write(tfd, buf, nr)) != nr)
+               while ((nr = read(mfd, buf, sizeof(buf))) > 0)
+                       if (write(tfd, buf, (size_t)nr) != nr)

                                break;
                if (nr != 0) {
                        unlink(tempname);
                                break;
                if (nr != 0) {
                        unlink(tempname);


@@ -259,11 +262,13 @@ pw_mkdb(const char *user)
                /* child */
                if (user == NULL)
                        execl(_PATH_PWD_MKDB, "pwd_mkdb", "-p",
                /* child */
                if (user == NULL)
                        execl(_PATH_PWD_MKDB, "pwd_mkdb", "-p",

-                           "-d", passwd_dir, tempname, NULL);
+                           "-d", passwd_dir, tempname, (char *)NULL);

                else
                        execl(_PATH_PWD_MKDB, "pwd_mkdb", "-p",
                else
                        execl(_PATH_PWD_MKDB, "pwd_mkdb", "-p",

-                           "-d", passwd_dir, "-u", user, tempname, NULL);
+                           "-d", passwd_dir, "-u", user, tempname,
+                           (char *)NULL);

                _exit(1);
                _exit(1);

+               /* NOTREACHED */

        default:
                /* parent */
                break;
        default:
                /* parent */
                break;


@@ -283,6 +288,8 @@ pw_mkdb(const char *user)
 int
 pw_edit(int notsetuid)
 {
 int
 pw_edit(int notsetuid)
 {

+       struct sigaction sa, sa_int, sa_quit;
+       sigset_t oldsigset, nsigset;

        struct stat st1, st2;
        const char *editor;
        int pstat;
        struct stat st1, st2;
        const char *editor;
        int pstat;


@@ -291,27 +298,39 @@ pw_edit(int notsetuid)
                editor = _PATH_VI;
        if (stat(tempname, &st1) == -1)
                return (-1);
                editor = _PATH_VI;
        if (stat(tempname, &st1) == -1)
                return (-1);

+       sa.sa_handler = SIG_IGN;
+       sigemptyset(&sa.sa_mask);
+       sa.sa_flags = 0;
+       sigaction(SIGINT, &sa, &sa_int);
+       sigaction(SIGQUIT, &sa, &sa_quit);
+       sigemptyset(&nsigset);
+       sigaddset(&nsigset, SIGCHLD);
+       sigprocmask(SIG_BLOCK, &nsigset, &oldsigset);

        switch ((editpid = fork())) {
        case -1:
                return (-1);
        case 0:
        switch ((editpid = fork())) {
        case -1:
                return (-1);
        case 0:

-               /* child */
+               sigaction(SIGINT, &sa_int, NULL);
+               sigaction(SIGQUIT, &sa_quit, NULL);
+               sigprocmask(SIG_SETMASK, &oldsigset, NULL);

                if (notsetuid) {
                        (void)setgid(getgid());
                        (void)setuid(getuid());
                }
                errno = 0;
                if (notsetuid) {
                        (void)setgid(getgid());
                        (void)setuid(getuid());
                }
                errno = 0;

-               execlp(editor, basename(editor), tempname, NULL);
+               execlp(editor, basename(editor), tempname, (char *)NULL);

                _exit(errno);
        default:
                /* parent */
                break;
        }
        for (;;) {
                _exit(errno);
        default:
                /* parent */
                break;
        }
        for (;;) {

-               editpid = waitpid(editpid, &pstat, WUNTRACED);
-               if (editpid == -1) {
+               if (waitpid(editpid, &pstat, WUNTRACED) == -1) {
+                       if (errno == EINTR)
+                               continue;

                        unlink(tempname);
                        unlink(tempname);

-                       return (-1);
+                       editpid = -1;
+                       break;

                } else if (WIFSTOPPED(pstat)) {
                        raise(WSTOPSIG(pstat));
                } else if (WIFEXITED(pstat) && WEXITSTATUS(pstat) == 0) {
                } else if (WIFSTOPPED(pstat)) {
                        raise(WSTOPSIG(pstat));
                } else if (WIFEXITED(pstat) && WEXITSTATUS(pstat) == 0) {


@@ -319,11 +338,13 @@ pw_edit(int notsetuid)
                        break;
                } else {
                        unlink(tempname);
                        break;
                } else {
                        unlink(tempname);

-                       *tempname = '\0';

                        editpid = -1;
                        editpid = -1;

-                       return (-1);
+                       break;

                }
        }
                }
        }

+       sigaction(SIGINT, &sa_int, NULL);
+       sigaction(SIGQUIT, &sa_quit, NULL);
+       sigprocmask(SIG_SETMASK, &oldsigset, NULL);

        if (stat(tempname, &st2) == -1)
                return (-1);
        return (st1.st_mtime != st2.st_mtime);
        if (stat(tempname, &st2) == -1)
                return (-1);
        return (st1.st_mtime != st2.st_mtime);


@@ -360,7 +381,7 @@ pw_fini(void)
  * Compares two struct pwds.
  */
 int
  * Compares two struct pwds.
  */
 int

-pw_equal(struct passwd *pw1, struct passwd *pw2)
+pw_equal(const struct passwd *pw1, const struct passwd *pw2)

 {
        return (strcmp(pw1->pw_name, pw2->pw_name) == 0 &&
            pw1->pw_uid == pw2->pw_uid &&
 {
        return (strcmp(pw1->pw_name, pw2->pw_name) == 0 &&
            pw1->pw_uid == pw2->pw_uid &&


@@ -377,7 +398,7 @@ pw_equal(struct passwd *pw1, struct passwd *pw2)
  * Make a passwd line out of a struct passwd.
  */
 char *
  * Make a passwd line out of a struct passwd.
  */
 char *

-pw_make(struct passwd *pw)
+pw_make(const struct passwd *pw)

 {
        char *line;
 
 {
        char *line;
 


@@ -393,12 +414,12 @@ pw_make(struct passwd *pw)
  * a single record on the way.
  */
 int
  * a single record on the way.
  */
 int

-pw_copy(int ffd, int tfd, struct passwd *pw, struct passwd *old_pw)
+pw_copy(int ffd, int tfd, const struct passwd *pw, struct passwd *old_pw)

 {
        char buf[8192], *end, *line, *p, *q, *r, t;
        struct passwd *fpw;
 {
        char buf[8192], *end, *line, *p, *q, *r, t;
        struct passwd *fpw;

-       ssize_t len;
-       int eof;
+       size_t len;
+       int eof, readlen;

 
        if ((line = pw_make(pw)) == NULL)
                return (-1);
 
        if ((line = pw_make(pw)) == NULL)
                return (-1);


@@ -416,7 +437,7 @@ pw_copy(int ffd, int tfd, struct passwd *pw, struct passwd *old_pw)
                if (q >= end) {
                        if (eof)
                                break;
                if (q >= end) {
                        if (eof)
                                break;

-                       if (q - p >= sizeof buf) {
+                       if ((size_t)(q - p) >= sizeof(buf)) {

                                warnx("passwd line too long");
                                errno = EINVAL; /* hack */
                                goto err;
                                warnx("passwd line too long");
                                errno = EINVAL; /* hack */
                                goto err;


@@ -427,14 +448,16 @@ pw_copy(int ffd, int tfd, struct passwd *pw, struct passwd *old_pw)
                        } else {
                                p = q = end = buf;
                        }
                        } else {
                                p = q = end = buf;
                        }

-                       len = read(ffd, end, sizeof buf - (end - buf));
-                       if (len == -1)
+                       readlen = read(ffd, end, sizeof(buf) - (end - buf));
+                       if (readlen == -1)

                                goto err;
                                goto err;

+                       else
+                               len = (size_t)readlen;

                        if (len == 0 && p == buf)
                                break;
                        end += len;
                        len = end - buf;
                        if (len == 0 && p == buf)
                                break;
                        end += len;
                        len = end - buf;

-                       if (len < sizeof buf) {
+                       if (len < (ssize_t)sizeof(buf)) {

                                eof = 1;
                                if (len > 0 && buf[len - 1] != '\n')
                                        ++len, *end++ = '\n';
                                eof = 1;
                                if (len > 0 && buf[len - 1] != '\n')
                                        ++len, *end++ = '\n';


@@ -454,23 +477,38 @@ pw_copy(int ffd, int tfd, struct passwd *pw, struct passwd *old_pw)
                }
 
                /* is it the one we're looking for? */
                }
 
                /* is it the one we're looking for? */

+

                t = *q;
                *q = '\0';
                t = *q;
                *q = '\0';

+

                fpw = pw_scan(r, PWSCAN_MASTER);
                fpw = pw_scan(r, PWSCAN_MASTER);

+
+               /*
+                * fpw is either the struct passwd for the current line,
+                * or NULL if the line is malformed.
+                */
+

                *q = t;
                *q = t;

-               if (old_pw == NULL || !pw_equal(pw, old_pw)) {
+               if (fpw == NULL || strcmp(fpw->pw_name, pw->pw_name) != 0) {

                        /* nope */
                        /* nope */

-                       free(fpw);
+                       if (fpw != NULL)
+                               free(fpw);

                        if (write(tfd, p, q - p + 1) != q - p + 1)
                                goto err;
                        ++q;
                        continue;
                }
                        if (write(tfd, p, q - p + 1) != q - p + 1)
                                goto err;
                        ++q;
                        continue;
                }

+               if (old_pw && !pw_equal(fpw, old_pw)) {
+                       warnx("entry inconsistent");
+                       free(fpw);
+                       errno = EINVAL; /* hack */
+                       goto err;
+               }

                free(fpw);
 
                /* it is, replace it */
                len = strlen(line);
                free(fpw);
 
                /* it is, replace it */
                len = strlen(line);

-               if (write(tfd, line, len) != len)
+               if (write(tfd, line, len) != (int)len)

                        goto err;
 
                /* we're done, just copy the rest over */
                        goto err;
 
                /* we're done, just copy the rest over */


@@ -478,10 +516,12 @@ pw_copy(int ffd, int tfd, struct passwd *pw, struct passwd *old_pw)
                        if (write(tfd, q, end - q) != end - q)
                                goto err;
                        q = buf;
                        if (write(tfd, q, end - q) != end - q)
                                goto err;
                        q = buf;

-                       len = read(ffd, buf, sizeof buf);
-                       if (len == 0)
+                       readlen = read(ffd, buf, sizeof(buf));
+                       if (readlen == 0)

                                break;
                                break;

-                       if (len == -1)
+                       else
+                               len = (size_t)readlen;
+                       if (readlen == -1)

                                goto err;
                        end = buf + len;
                }
                                goto err;
                        end = buf + len;
                }


@@ -490,7 +530,8 @@ pw_copy(int ffd, int tfd, struct passwd *pw, struct passwd *old_pw)
 
        /* if we got here, we have a new entry */
        len = strlen(line);
 
        /* if we got here, we have a new entry */
        len = strlen(line);

-       if (write(tfd, line, len) != len)
+       if ((size_t)write(tfd, line, len) != len ||
+           write(tfd, "\n", 1) != 1)

                goto err;
  done:
        free(line);
                goto err;
  done:
        free(line);


@@ -514,22 +555,22 @@ pw_tempname(void)
  * Duplicate a struct passwd.
  */
 struct passwd *
  * Duplicate a struct passwd.
  */
 struct passwd *

-pw_dup(struct passwd *pw)
+pw_dup(const struct passwd *pw)

 {
        struct passwd *npw;
 {
        struct passwd *npw;

-       size_t len;
+       ssize_t len;

 
 

-       len = sizeof *npw +
+       len = sizeof(*npw) +

            (pw->pw_name ? strlen(pw->pw_name) + 1 : 0) +
            (pw->pw_passwd ? strlen(pw->pw_passwd) + 1 : 0) +
            (pw->pw_class ? strlen(pw->pw_class) + 1 : 0) +
            (pw->pw_gecos ? strlen(pw->pw_gecos) + 1 : 0) +
            (pw->pw_dir ? strlen(pw->pw_dir) + 1 : 0) +
            (pw->pw_shell ? strlen(pw->pw_shell) + 1 : 0);
            (pw->pw_name ? strlen(pw->pw_name) + 1 : 0) +
            (pw->pw_passwd ? strlen(pw->pw_passwd) + 1 : 0) +
            (pw->pw_class ? strlen(pw->pw_class) + 1 : 0) +
            (pw->pw_gecos ? strlen(pw->pw_gecos) + 1 : 0) +
            (pw->pw_dir ? strlen(pw->pw_dir) + 1 : 0) +
            (pw->pw_shell ? strlen(pw->pw_shell) + 1 : 0);

-       if ((npw = malloc(len)) == NULL)
+       if ((npw = malloc((size_t)len)) == NULL)

                return (NULL);
                return (NULL);

-       memcpy(npw, pw, sizeof *npw);
-       len = sizeof *npw;
+       memcpy(npw, pw, sizeof(*npw));
+       len = sizeof(*npw);

        if (pw->pw_name) {
                npw->pw_name = ((char *)npw) + len;
                len += sprintf(npw->pw_name, "%s", pw->pw_name) + 1;
        if (pw->pw_name) {
                npw->pw_name = ((char *)npw) + len;
                len += sprintf(npw->pw_name, "%s", pw->pw_name) + 1;