chpass/field.c

   1 /*
   2  * Copyright (c) 1988, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifndef lint
  35 static char sccsid[] = "@(#)field.c     8.4 (Berkeley) 4/2/94";
  36 #endif /* not lint */
  37
  38 #include <sys/param.h>
  39
  40 #include <ctype.h>
  41 #include <err.h>
  42 #include <errno.h>
  43 #include <grp.h>
  44 #include <pwd.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49
  50 #include "chpass.h"
  51 #include "pathnames.h"
  52
  53 /* ARGSUSED */
  54 int
  55 p_login(p, pw, ep)
  56         char *p;
  57         struct passwd *pw;
  58         ENTRY *ep;
  59 {
  60         if (!*p) {
  61                 warnx("empty login field");
  62                 return (1);
  63         }
  64         if (*p == '-') {
  65                 warnx("login names may not begin with a hyphen");
  66                 return (1);
  67         }
  68         if (!(pw->pw_name = strdup(p))) {
  69                 warnx("can't save entry");
  70                 return (1);
  71         }
  72         if (strchr(p, '.'))
  73                 warnx("\'.\' is dangerous in a login name");
  74         for (; *p; ++p)
  75                 if (isupper(*p)) {
  76                         warnx("upper-case letters are dangerous in a login name");
  77                         break;
  78                 }
  79         return (0);
  80 }
  81
  82 /* ARGSUSED */
  83 int
  84 p_passwd(p, pw, ep)
  85         char *p;
  86         struct passwd *pw;
  87         ENTRY *ep;
  88 {
  89         if (!*p)
  90                 pw->pw_passwd = "";     /* "NOLOGIN"; */
  91         else if (!(pw->pw_passwd = strdup(p))) {
  92                 warnx("can't save password entry");
  93                 return (1);
  94         }
  95
  96         return (0);
  97 }
  98
  99 /* ARGSUSED */
 100 int
 101 p_uid(p, pw, ep)
 102         char *p;
 103         struct passwd *pw;
 104         ENTRY *ep;
 105 {
 106         uid_t id;
 107         char *np;
 108
 109         if (!*p) {
 110                 warnx("empty uid field");
 111                 return (1);
 112         }
 113         if (!isdigit(*p)) {
 114                 warnx("illegal uid");
 115                 return (1);
 116         }
 117         errno = 0;
 118         id = strtoul(p, &np, 10);
 119         if (*np || (id == ULONG_MAX && errno == ERANGE)) {
 120                 warnx("illegal uid");
 121                 return (1);
 122         }
 123         pw->pw_uid = id;
 124         return (0);
 125 }
 126
 127 /* ARGSUSED */
 128 int
 129 p_gid(p, pw, ep)
 130         char *p;
 131         struct passwd *pw;
 132         ENTRY *ep;
 133 {
 134         struct group *gr;
 135         gid_t id;
 136         char *np;
 137
 138         if (!*p) {
 139                 warnx("empty gid field");
 140                 return (1);
 141         }
 142         if (!isdigit(*p)) {
 143                 if (!(gr = getgrnam(p))) {
 144                         warnx("unknown group %s", p);
 145                         return (1);
 146                 }
 147                 pw->pw_gid = gr->gr_gid;
 148                 return (0);
 149         }
 150         errno = 0;
 151         id = strtoul(p, &np, 10);
 152         if (*np || (id == ULONG_MAX && errno == ERANGE)) {
 153                 warnx("illegal gid");
 154                 return (1);
 155         }
 156         pw->pw_gid = id;
 157         return (0);
 158 }
 159
 160 /* ARGSUSED */
 161 int
 162 p_class(p, pw, ep)
 163         char *p;
 164         struct passwd *pw;
 165         ENTRY *ep;
 166 {
 167         if (!*p)
 168                 pw->pw_class = "";
 169         else if (!(pw->pw_class = strdup(p))) {
 170                 warnx("can't save entry");
 171                 return (1);
 172         }
 173
 174         return (0);
 175 }
 176
 177 /* ARGSUSED */
 178 int
 179 p_change(p, pw, ep)
 180         char *p;
 181         struct passwd *pw;
 182         ENTRY *ep;
 183 {
 184         if (!atot(p, &pw->pw_change))
 185                 return (0);
 186         warnx("illegal date for change field");
 187         return (1);
 188 }
 189
 190 /* ARGSUSED */
 191 int
 192 p_expire(p, pw, ep)
 193         char *p;
 194         struct passwd *pw;
 195         ENTRY *ep;
 196 {
 197         if (!atot(p, &pw->pw_expire))
 198                 return (0);
 199         warnx("illegal date for expire field");
 200         return (1);
 201 }
 202
 203 /* ARGSUSED */
 204 int
 205 p_gecos(p, pw, ep)
 206         char *p;
 207         struct passwd *pw;
 208         ENTRY *ep;
 209 {
 210         if (!*p)
 211                 ep->save = "";
 212         else if (!(ep->save = strdup(p))) {
 213                 warnx("can't save entry");
 214                 return (1);
 215         }
 216         return (0);
 217 }
 218
 219 /* ARGSUSED */
 220 int
 221 p_hdir(p, pw, ep)
 222         char *p;
 223         struct passwd *pw;
 224         ENTRY *ep;
 225 {
 226         if (!*p) {
 227                 warnx("empty home directory field");
 228                 return (1);
 229         }
 230         if (!(pw->pw_dir = strdup(p))) {
 231                 warnx("can't save entry");
 232                 return (1);
 233         }
 234         return (0);
 235 }
 236
 237 /* ARGSUSED */
 238 int
 239 p_shell(p, pw, ep)
 240         char *p;
 241         struct passwd *pw;
 242         ENTRY *ep;
 243 {
 244         char *t, *ok_shell();
 245
 246         if (!*p) {
 247                 pw->pw_shell = _PATH_BSHELL;
 248                 return (0);
 249         }
 250         /* only admin can change from or to "restricted" shells */
 251         if (uid && pw->pw_shell && !ok_shell(pw->pw_shell)) {
 252                 warnx("%s: current shell non-standard", pw->pw_shell);
 253                 return (1);
 254         }
 255         if (!(t = ok_shell(p))) {
 256                 if (uid) {
 257                         warnx("%s: non-standard shell", p);
 258                         return (1);
 259                 }
 260         }
 261         else
 262                 p = t;
 263         if (!(pw->pw_shell = strdup(p))) {
 264                 warnx("can't save entry");
 265                 return (1);
 266         }
 267         return (0);
 268 }