pw/pw_conf.c

   1 /*-
   2  * Copyright (C) 1996
   3  *      David L. Nugent.  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  *
  14  * THIS SOFTWARE IS PROVIDED BY DAVID L. NUGENT AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL DAVID L. NUGENT OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #ifndef lint
  28 static const char rcsid[] =
  29   "$FreeBSD$";
  30 #endif /* not lint */
  31
  32 #include <sys/types.h>
  33 #include <sys/sbuf.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36 #include <fcntl.h>
  37
  38 #include "pw.h"
  39
  40 #define debugging 0
  41
  42 enum {
  43         _UC_NONE,
  44         _UC_DEFAULTPWD,
  45         _UC_REUSEUID,
  46         _UC_REUSEGID,
  47         _UC_NISPASSWD,
  48         _UC_DOTDIR,
  49         _UC_NEWMAIL,
  50         _UC_LOGFILE,
  51         _UC_HOMEROOT,
  52         _UC_HOMEMODE,
  53         _UC_SHELLPATH,
  54         _UC_SHELLS,
  55         _UC_DEFAULTSHELL,
  56         _UC_DEFAULTGROUP,
  57         _UC_EXTRAGROUPS,
  58         _UC_DEFAULTCLASS,
  59         _UC_MINUID,
  60         _UC_MAXUID,
  61         _UC_MINGID,
  62         _UC_MAXGID,
  63         _UC_EXPIRE,
  64         _UC_PASSWORD,
  65         _UC_FIELDS
  66 };
  67
  68 static char     bourne_shell[] = "sh";
  69
  70 static char    *system_shells[_UC_MAXSHELLS] =
  71 {
  72         bourne_shell,
  73         "csh",
  74         "tcsh"
  75 };
  76
  77 static char const *booltrue[] =
  78 {
  79         "yes", "true", "1", "on", NULL
  80 };
  81 static char const *boolfalse[] =
  82 {
  83         "no", "false", "0", "off", NULL
  84 };
  85
  86 static struct userconf config =
  87 {
  88         0,                      /* Default password for new users? (nologin) */
  89         0,                      /* Reuse uids? */
  90         0,                      /* Reuse gids? */
  91         NULL,                   /* NIS version of the passwd file */
  92         "/usr/share/skel",      /* Where to obtain skeleton files */
  93         NULL,                   /* Mail to send to new accounts */
  94         "/var/log/userlog",     /* Where to log changes */
  95         "/home",                /* Where to create home directory */
  96         _DEF_DIRMODE,           /* Home directory perms, modified by umask */
  97         "/bin",                 /* Where shells are located */
  98         system_shells,          /* List of shells (first is default) */
  99         bourne_shell,           /* Default shell */
 100         NULL,                   /* Default group name */
 101         NULL,                   /* Default (additional) groups */
 102         NULL,                   /* Default login class */
 103         1000, 32000,            /* Allowed range of uids */
 104         1000, 32000,            /* Allowed range of gids */
 105         0,                      /* Days until account expires */
 106         0,                      /* Days until password expires */
 107         0                       /* size of default_group array */
 108 };
 109
 110 static char const *comments[_UC_FIELDS] =
 111 {
 112         "#\n# pw.conf - user/group configuration defaults\n#\n",
 113         "\n# Password for new users? no=nologin yes=loginid none=blank random=random\n",
 114         "\n# Reuse gaps in uid sequence? (yes or no)\n",
 115         "\n# Reuse gaps in gid sequence? (yes or no)\n",
 116         "\n# Path to the NIS passwd file (blank or 'no' for none)\n",
 117         "\n# Obtain default dotfiles from this directory\n",
 118         "\n# Mail this file to new user (/etc/newuser.msg or no)\n",
 119         "\n# Log add/change/remove information in this file\n",
 120         "\n# Root directory in which $HOME directory is created\n",
 121         "\n# Mode for the new $HOME directory, will be modified by umask\n",
 122         "\n# Colon separated list of directories containing valid shells\n",
 123         "\n# Comma separated list of available shells (without paths)\n",
 124         "\n# Default shell (without path)\n",
 125         "\n# Default group (leave blank for new group per user)\n",
 126         "\n# Extra groups for new users\n",
 127         "\n# Default login class for new users\n",
 128         "\n# Range of valid default user ids\n",
 129         NULL,
 130         "\n# Range of valid default group ids\n",
 131         NULL,
 132         "\n# Days after which account expires (0=disabled)\n",
 133         "\n# Days after which password expires (0=disabled)\n"
 134 };
 135
 136 static char const *kwds[] =
 137 {
 138         "",
 139         "defaultpasswd",
 140         "reuseuids",
 141         "reusegids",
 142         "nispasswd",
 143         "skeleton",
 144         "newmail",
 145         "logfile",
 146         "home",
 147         "homemode",
 148         "shellpath",
 149         "shells",
 150         "defaultshell",
 151         "defaultgroup",
 152         "extragroups",
 153         "defaultclass",
 154         "minuid",
 155         "maxuid",
 156         "mingid",
 157         "maxgid",
 158         "expire_days",
 159         "password_days",
 160         NULL
 161 };
 162
 163 static char    *
 164 unquote(char const * str)
 165 {
 166         if (str && (*str == '"' || *str == '\'')) {
 167                 char           *p = strchr(str + 1, *str);
 168
 169                 if (p != NULL)
 170                         *p = '\0';
 171                 return (char *) (*++str ? str : NULL);
 172         }
 173         return (char *) str;
 174 }
 175
 176 int
 177 boolean_val(char const * str, int dflt)
 178 {
 179         if ((str = unquote(str)) != NULL) {
 180                 int             i;
 181
 182                 for (i = 0; booltrue[i]; i++)
 183                         if (strcmp(str, booltrue[i]) == 0)
 184                                 return 1;
 185                 for (i = 0; boolfalse[i]; i++)
 186                         if (strcmp(str, boolfalse[i]) == 0)
 187                                 return 0;
 188
 189                 /*
 190                  * Special cases for defaultpassword
 191                  */
 192                 if (strcmp(str, "random") == 0)
 193                         return -1;
 194                 if (strcmp(str, "none") == 0)
 195                         return -2;
 196         }
 197         return dflt;
 198 }
 199
 200 char const     *
 201 boolean_str(int val)
 202 {
 203         if (val == -1)
 204                 return "random";
 205         else if (val == -2)
 206                 return "none";
 207         else
 208                 return val ? booltrue[0] : boolfalse[0];
 209 }
 210
 211 char           *
 212 newstr(char const * p)
 213 {
 214         char           *q = NULL;
 215
 216         if ((p = unquote(p)) != NULL) {
 217                 int             l = strlen(p) + 1;
 218
 219                 if ((q = malloc(l)) != NULL)
 220                         memcpy(q, p, l);
 221         }
 222         return q;
 223 }
 224
 225 #define LNBUFSZ 1024
 226
 227
 228 struct userconf *
 229 read_userconfig(char const * file)
 230 {
 231         FILE    *fp;
 232         char    *buf, *p;
 233         size_t  linecap;
 234         ssize_t linelen;
 235
 236         buf = NULL;
 237         linecap = 0;
 238
 239         extendarray(&config.groups, &config.numgroups, 200);
 240         memset(config.groups, 0, config.numgroups * sizeof(char *));
 241         if (file == NULL)
 242                 file = _PATH_PW_CONF;
 243
 244         if ((fp = fopen(file, "r")) != NULL) {
 245                 while ((linelen = getline(&buf, &linecap, fp)) > 0) {
 246                         if (*buf && (p = strtok(buf, " \t\r\n=")) != NULL && *p != '#') {
 247                                 static char const toks[] = " \t\r\n,=";
 248                                 char           *q = strtok(NULL, toks);
 249                                 int             i = 0;
 250                                 mode_t          *modeset;
 251
 252                                 while (i < _UC_FIELDS && strcmp(p, kwds[i]) != 0)
 253                                         ++i;
 254 #if debugging
 255                                 if (i == _UC_FIELDS)
 256                                         printf("Got unknown kwd `%s' val=`%s'\n", p, q ? q : "");
 257                                 else
 258                                         printf("Got kwd[%s]=%s\n", p, q);
 259 #endif
 260                                 switch (i) {
 261                                 case _UC_DEFAULTPWD:
 262                                         config.default_password = boolean_val(q, 1);
 263                                         break;
 264                                 case _UC_REUSEUID:
 265                                         config.reuse_uids = boolean_val(q, 0);
 266                                         break;
 267                                 case _UC_REUSEGID:
 268                                         config.reuse_gids = boolean_val(q, 0);
 269                                         break;
 270                                 case _UC_NISPASSWD:
 271                                         config.nispasswd = (q == NULL || !boolean_val(q, 1))
 272                                                 ? NULL : newstr(q);
 273                                         break;
 274                                 case _UC_DOTDIR:
 275                                         config.dotdir = (q == NULL || !boolean_val(q, 1))
 276                                                 ? NULL : newstr(q);
 277                                         break;
 278                                 case _UC_NEWMAIL:
 279                                         config.newmail = (q == NULL || !boolean_val(q, 1))
 280                                                 ? NULL : newstr(q);
 281                                         break;
 282                                 case _UC_LOGFILE:
 283                                         config.logfile = (q == NULL || !boolean_val(q, 1))
 284                                                 ? NULL : newstr(q);
 285                                         break;
 286                                 case _UC_HOMEROOT:
 287                                         config.home = (q == NULL || !boolean_val(q, 1))
 288                                                 ? "/home" : newstr(q);
 289                                         break;
 290                                 case _UC_HOMEMODE:
 291                                         modeset = setmode(q);
 292                                         config.homemode = (q == NULL || !boolean_val(q, 1))
 293                                                 ? _DEF_DIRMODE : getmode(modeset, _DEF_DIRMODE);
 294                                         free(modeset);
 295                                         break;
 296                                 case _UC_SHELLPATH:
 297                                         config.shelldir = (q == NULL || !boolean_val(q, 1))
 298                                                 ? "/bin" : newstr(q);
 299                                         break;
 300                                 case _UC_SHELLS:
 301                                         for (i = 0; i < _UC_MAXSHELLS && q != NULL; i++, q = strtok(NULL, toks))
 302                                                 system_shells[i] = newstr(q);
 303                                         if (i > 0)
 304                                                 while (i < _UC_MAXSHELLS)
 305                                                         system_shells[i++] = NULL;
 306                                         break;
 307                                 case _UC_DEFAULTSHELL:
 308                                         config.shell_default = (q == NULL || !boolean_val(q, 1))
 309                                                 ? (char *) bourne_shell : newstr(q);
 310                                         break;
 311                                 case _UC_DEFAULTGROUP:
 312                                         q = unquote(q);
 313                                         config.default_group = (q == NULL || !boolean_val(q, 1) || GETGRNAM(q) == NULL)
 314                                                 ? NULL : newstr(q);
 315                                         break;
 316                                 case _UC_EXTRAGROUPS:
 317                                         for (i = 0; q != NULL; q = strtok(NULL, toks)) {
 318                                                 if (extendarray(&config.groups, &config.numgroups, i + 2) != -1)
 319                                                         config.groups[i++] = newstr(q);
 320                                         }
 321                                         if (i > 0)
 322                                                 while (i < config.numgroups)
 323                                                         config.groups[i++] = NULL;
 324                                         break;
 325                                 case _UC_DEFAULTCLASS:
 326                                         config.default_class = (q == NULL || !boolean_val(q, 1))
 327                                                 ? NULL : newstr(q);
 328                                         break;
 329                                 case _UC_MINUID:
 330                                         if ((q = unquote(q)) != NULL && isdigit(*q))
 331                                                 config.min_uid = (uid_t) atol(q);
 332                                         break;
 333                                 case _UC_MAXUID:
 334                                         if ((q = unquote(q)) != NULL && isdigit(*q))
 335                                                 config.max_uid = (uid_t) atol(q);
 336                                         break;
 337                                 case _UC_MINGID:
 338                                         if ((q = unquote(q)) != NULL && isdigit(*q))
 339                                                 config.min_gid = (gid_t) atol(q);
 340                                         break;
 341                                 case _UC_MAXGID:
 342                                         if ((q = unquote(q)) != NULL && isdigit(*q))
 343                                                 config.max_gid = (gid_t) atol(q);
 344                                         break;
 345                                 case _UC_EXPIRE:
 346                                         if ((q = unquote(q)) != NULL && isdigit(*q))
 347                                                 config.expire_days = atoi(q);
 348                                         break;
 349                                 case _UC_PASSWORD:
 350                                         if ((q = unquote(q)) != NULL && isdigit(*q))
 351                                                 config.password_days = atoi(q);
 352                                         break;
 353                                 case _UC_FIELDS:
 354                                 case _UC_NONE:
 355                                         break;
 356                                 }
 357                         }
 358                 }
 359                 if (linecap > 0)
 360                         free(buf);
 361                 fclose(fp);
 362         }
 363         return &config;
 364 }
 365
 366
 367 int
 368 write_userconfig(char const * file)
 369 {
 370         int             fd;
 371         struct sbuf     *buf;
 372
 373         if (file == NULL)
 374                 file = _PATH_PW_CONF;
 375
 376         if ((fd = open(file, O_CREAT | O_RDWR | O_TRUNC | O_EXLOCK, 0644)) != -1) {
 377                 FILE           *fp;
 378
 379                 if ((fp = fdopen(fd, "w")) == NULL)
 380                         close(fd);
 381                 else {
 382                         int             i, j;
 383
 384                         buf = sbuf_new_auto();
 385                         for (i = _UC_NONE; i < _UC_FIELDS; i++) {
 386                                 int             quote = 1;
 387
 388                                 sbuf_clear(buf);
 389                                 switch (i) {
 390                                 case _UC_DEFAULTPWD:
 391                                         sbuf_cat(buf, boolean_str(config.default_password));
 392                                         break;
 393                                 case _UC_REUSEUID:
 394                                         sbuf_cat(buf, boolean_str(config.reuse_uids));
 395                                         break;
 396                                 case _UC_REUSEGID:
 397                                         sbuf_cat(buf, boolean_str(config.reuse_gids));
 398                                         break;
 399                                 case _UC_NISPASSWD:
 400                                         sbuf_cat(buf, config.nispasswd ?
 401                                             config.nispasswd : "");
 402                                         quote = 0;
 403                                         break;
 404                                 case _UC_DOTDIR:
 405                                         sbuf_cat(buf, config.dotdir ?
 406                                             config.dotdir : boolean_str(0));
 407                                         break;
 408                                 case _UC_NEWMAIL:
 409                                         sbuf_cat(buf, config.newmail ?
 410                                             config.newmail : boolean_str(0));
 411                                         break;
 412                                 case _UC_LOGFILE:
 413                                         sbuf_cat(buf, config.logfile ?
 414                                             config.logfile : boolean_str(0));
 415                                         break;
 416                                 case _UC_HOMEROOT:
 417                                         sbuf_cat(buf, config.home);
 418                                         break;
 419                                 case _UC_HOMEMODE:
 420                                         sbuf_printf(buf, "%04o", config.homemode);
 421                                         quote = 0;
 422                                         break;
 423                                 case _UC_SHELLPATH:
 424                                         sbuf_cat(buf, config.shelldir);
 425                                         break;
 426                                 case _UC_SHELLS:
 427                                         for (j = 0; j < _UC_MAXSHELLS &&
 428                                             system_shells[j] != NULL; j++) {
 429                                                 sbuf_printf(buf, "%s\"%s\"", j ?
 430                                                      "," : "", system_shells[j]);
 431                                         }
 432                                         quote = 0;
 433                                         break;
 434                                 case _UC_DEFAULTSHELL:
 435                                         sbuf_cat(buf, config.shell_default ?
 436                                             config.shell_default : bourne_shell);
 437                                         break;
 438                                 case _UC_DEFAULTGROUP:
 439                                         sbuf_cat(buf, config.default_group ?
 440                                             config.default_group : "");
 441                                         break;
 442                                 case _UC_EXTRAGROUPS:
 443                                         extendarray(&config.groups, &config.numgroups, 200);
 444                                         for (j = 0; j < config.numgroups &&
 445                                             config.groups[j] != NULL; j++)
 446                                                 sbuf_printf(buf, "%s\"%s\"", j ?
 447                                                      "," : "", config.groups[j]);
 448                                         quote = 0;
 449                                         break;
 450                                 case _UC_DEFAULTCLASS:
 451                                         sbuf_cat(buf, config.default_class ?
 452                                             config.default_class : "");
 453                                         break;
 454                                 case _UC_MINUID:
 455                                         sbuf_printf(buf, "%lu", (unsigned long) config.min_uid);
 456                                         quote = 0;
 457                                         break;
 458                                 case _UC_MAXUID:
 459                                         sbuf_printf(buf, "%lu", (unsigned long) config.max_uid);
 460                                         quote = 0;
 461                                         break;
 462                                 case _UC_MINGID:
 463                                         sbuf_printf(buf, "%lu", (unsigned long) config.min_gid);
 464                                         quote = 0;
 465                                         break;
 466                                 case _UC_MAXGID:
 467                                         sbuf_printf(buf, "%lu", (unsigned long) config.max_gid);
 468                                         quote = 0;
 469                                         break;
 470                                 case _UC_EXPIRE:
 471                                         sbuf_printf(buf, "%d", config.expire_days);
 472                                         quote = 0;
 473                                         break;
 474                                 case _UC_PASSWORD:
 475                                         sbuf_printf(buf, "%d", config.password_days);
 476                                         quote = 0;
 477                                         break;
 478                                 case _UC_NONE:
 479                                         break;
 480                                 }
 481                                 sbuf_finish(buf);
 482
 483                                 if (comments[i])
 484                                         fputs(comments[i], fp);
 485
 486                                 if (*kwds[i]) {
 487                                         if (quote)
 488                                                 fprintf(fp, "%s = \"%s\"\n", kwds[i], sbuf_data(buf));
 489                                         else
 490                                                 fprintf(fp, "%s = %s\n", kwds[i], sbuf_data(buf));
 491 #if debugging
 492                                         printf("WROTE: %s = %s\n", kwds[i], sbuf_data(buf));
 493 #endif
 494                                 }
 495                         }
 496                         sbuf_delete(buf);
 497                         return fclose(fp) != EOF;
 498                 }
 499         }
 500         return 0;
 501 }