chpass.tproj/chpass.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
   7  * Reserved.  This file contains Original Code and/or Modifications of
   8  * Original Code as defined in and that are subject to the Apple Public
   9  * Source License Version 1.0 (the 'License').  You may not use this file
  10  * except in compliance with the License.  Please obtain a copy of the
  11  * License at http://www.apple.com/publicsource and read it before using
  12  * this file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  19  * License for the specific language governing rights and limitations
  20  * under the License."
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24 /*-
  25  * Copyright (c) 1990, 1993, 1994
  26  *      The Regents of the University of California.  All rights reserved.
  27  *
  28  * Redistribution and use in source and binary forms, with or without
  29  * modification, are permitted provided that the following conditions
  30  * are met:
  31  * 1. Redistributions of source code must retain the above copyright
  32  *    notice, this list of conditions and the following disclaimer.
  33  * 2. Redistributions in binary form must reproduce the above copyright
  34  *    notice, this list of conditions and the following disclaimer in the
  35  *    documentation and/or other materials provided with the distribution.
  36  * 3. All advertising materials mentioning features or use of this software
  37  *    must display the following acknowledgement:
  38  *      This product includes software developed by the University of
  39  *      California, Berkeley and its contributors.
  40  * 4. Neither the name of the University nor the names of its contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  */
  56
  57 #ifndef lint
  58 static char copyright[] =
  59 "@(#) Copyright (c) 1988, 1993, 1994\n\
  60         The Regents of the University of California.  All rights reserved.\n";
  61 #endif /* not lint */
  62
  63 #include <sys/param.h>
  64 #include <sys/stat.h>
  65 #include <sys/signal.h>
  66 #include <sys/time.h>
  67 #include <sys/resource.h>
  68
  69 #include <ctype.h>
  70 #include <err.h>
  71 #include <errno.h>
  72 #include <fcntl.h>
  73 #include <pwd.h>
  74 #include <stdio.h>
  75 #include <stdlib.h>
  76 #include <string.h>
  77 #include <unistd.h>
  78
  79 #include <pw_scan.h>
  80 #include <pw_util.h>
  81 #include "pw_copy.h"
  82
  83 #include "chpass.h"
  84 #include "pathnames.h"
  85 #ifdef DIRECTORY_SERVICE
  86 #include "directory_service.h"
  87
  88 #define PWSETFIELD(field, in, out)      if(in->field) out.field = strdup(in->field)
  89 #endif /* DIRECTORY_SERVICE */
  90
  91 char *progname = "chpass";
  92 char *tempname;
  93 uid_t uid;
  94 #ifdef DIRECTORY_SERVICE
  95 int dswhere;
  96 #endif /* DIRECTORY_SERVICE */
  97
  98 void    baduser __P((void));
  99 void    usage __P((void));
 100
 101 int
 102 main(argc, argv)
 103         int argc;
 104         char **argv;
 105 {
 106         enum { NEWSH, LOADENTRY, EDITENTRY } op;
 107         struct passwd *pw, lpw;
 108         int ch, pfd, tfd;
 109         char *arg;
 110 #ifdef DIRECTORY_SERVICE
 111         struct passwd pworig;
 112         char *task_argv[3] = { NULL };
 113 #endif /* DIRECTORY_SERVICE */
 114
 115         op = EDITENTRY;
 116         while ((ch = getopt(argc, argv, "a:s:")) != EOF)
 117                 switch(ch) {
 118                 case 'a':
 119                         op = LOADENTRY;
 120                         arg = optarg;
 121                         break;
 122                 case 's':
 123                         op = NEWSH;
 124                         arg = optarg;
 125                         break;
 126                 case '?':
 127                 default:
 128                         usage();
 129                 }
 130         argc -= optind;
 131         argv += optind;
 132
 133         uid = getuid();
 134
 135         if (op == EDITENTRY || op == NEWSH)
 136 #ifdef DIRECTORY_SERVICE
 137         {
 138 #endif /* DIRECTORY_SERVICE */
 139                 switch(argc) {
 140                 case 0:
 141                         if (!(pw = getpwuid(uid)))
 142                                 errx(1, "unknown user: uid %u", uid);
 143                         break;
 144                 case 1:
 145                         if (!(pw = getpwnam(*argv)))
 146                                 errx(1, "unknown user: %s", *argv);
 147 #ifndef DIRECTORY_SERVICE
 148                         if (uid && uid != pw->pw_uid)
 149                                 baduser();
 150 #endif /* DIRECTORY_SERVICE */
 151                         break;
 152                 default:
 153                         usage();
 154                 }
 155
 156                 /* getpwnam(3) returns a pointer to local storage */
 157                 lpw = *pw;
 158                 PWSETFIELD(pw_name, pw, lpw);
 159                 PWSETFIELD(pw_passwd, pw, lpw);
 160                 PWSETFIELD(pw_class, pw, lpw);
 161                 PWSETFIELD(pw_gecos, pw, lpw);
 162                 PWSETFIELD(pw_dir, pw, lpw);
 163                 PWSETFIELD(pw_shell, pw, lpw);
 164
 165                 pw = &lpw;
 166
 167 #ifdef DIRECTORY_SERVICE
 168                 if ((dswhere = wherepwent(pw->pw_name)) < 0) {
 169                         if(dswhere > E_NOTFOUND)
 170                                 errc(1, dswhere, "wherepwent");
 171                         else
 172                                 errx(1, "wherepwent returned %d", dswhere);
 173                 }
 174                 switch(dswhere) {
 175                 case WHERE_REMOTENI:
 176                         errx(1,
 177 "Can't change info for user \"%s\", which resides in the\n"
 178 "netinfo domain \"%s\"",
 179                          pw->pw_name, DSPath);
 180                 case WHERE_DS:
 181                         errx(1,
 182 "Can't change info for user \"%s\", which resides in the\n"
 183 "Directory Service path \"%s\"",
 184                          pw->pw_name, DSPath);
 185                 case WHERE_NIS:
 186                         errx(1,
 187 "Can't change info for user \"%s\", which resides in NIS",
 188                          pw->pw_name);
 189                 case WHERE_LOCALNI:
 190                         pworig = *pw;
 191                         PWSETFIELD(pw_name, pw, pworig);
 192                         PWSETFIELD(pw_passwd, pw, pworig);
 193                         PWSETFIELD(pw_class, pw, pworig);
 194                         PWSETFIELD(pw_gecos, pw, pworig);
 195                         PWSETFIELD(pw_dir, pw, pworig);
 196                         PWSETFIELD(pw_shell, pw, pworig);
 197                         /* drop through */
 198                 default:
 199                         if (uid && uid != pw->pw_uid)
 200                                 baduser();
 201                 }
 202         }
 203 #endif /* DIRECTORY_SERVICE */
 204
 205         if (op == NEWSH) {
 206                 /* protect p_shell -- it thinks NULL is /bin/sh */
 207                 if (!arg[0])
 208                         usage();
 209                 if (p_shell(arg, pw, (ENTRY *)NULL))
 210                         pw_error((char *)NULL, 0, 1);
 211         }
 212
 213         if (op == LOADENTRY) {
 214 #ifdef DIRECTORY_SERVICE
 215                 warnx("-a is only supported for %s", MasterPasswd);
 216                 dswhere = WHERE_FILES;
 217 #endif /* DIRECTORY_SERVICE */
 218                 if (uid)
 219                         baduser();
 220                 pw = &lpw;
 221                 if (!pw_scan(arg, pw, NULL))
 222                         exit(1);
 223         }
 224
 225         /*
 226          * The temporary file/file descriptor usage is a little tricky here.
 227          * 1:   We start off with two fd's, one for the master password
 228          *      file (used to lock everything), and one for a temporary file.
 229          * 2:   Display() gets an fp for the temporary file, and copies the
 230          *      user's information into it.  It then gives the temporary file
 231          *      to the user and closes the fp, closing the underlying fd.
 232          * 3:   The user edits the temporary file some number of times.
 233          * 4:   Verify() gets an fp for the temporary file, and verifies the
 234          *      contents.  It can't use an fp derived from the step #2 fd,
 235          *      because the user's editor may have created a new instance of
 236          *      the file.  Once the file is verified, its contents are stored
 237          *      in a password structure.  The verify routine closes the fp,
 238          *      closing the underlying fd.
 239          * 5:   Delete the temporary file.
 240          * 6:   Get a new temporary file/fd.  Pw_copy() gets an fp for it
 241          *      file and copies the master password file into it, replacing
 242          *      the user record with a new one.  We can't use the first
 243          *      temporary file for this because it was owned by the user.
 244          *      Pw_copy() closes its fp, flushing the data and closing the
 245          *      underlying file descriptor.  We can't close the master
 246          *      password fp, or we'd lose the lock.
 247          * 7:   Call pw_mkdb() (which renames the temporary file) and exit.
 248          *      The exit closes the master passwd fp/fd.
 249          */
 250         pw_init();
 251 #ifdef DIRECTORY_SERVICE
 252         if (dswhere == WHERE_FILES)
 253 #endif /* DIRECTORY_SERVICE */
 254                 pfd = pw_lock();
 255         tfd = pw_tmp();
 256
 257         if (op == EDITENTRY) {
 258 #ifdef DIRECTORY_SERVICE
 259                 setrestricted(dswhere, pw);
 260 #endif /* DIRECTORY_SERVICE */
 261                 display(tfd, pw);
 262                 edit(pw);
 263                 (void)unlink(tempname);
 264 #ifdef DIRECTORY_SERVICE
 265                 if (dswhere == WHERE_FILES)
 266 #endif /* DIRECTORY_SERVICE */
 267                         tfd = pw_tmp();
 268         }
 269
 270 #ifdef DIRECTORY_SERVICE
 271         switch (dswhere) {
 272         case WHERE_LOCALNI:
 273                 update_local_ni(&pworig, pw);
 274                 break;
 275         case WHERE_FILES:
 276 #endif /* DIRECTORY_SERVICE */
 277                 pw_copy(pfd, tfd, pw);
 278
 279                 if (pw_mkdb() != 0)
 280                         pw_error((char *)NULL, 0, 1);
 281 #ifdef DIRECTORY_SERVICE
 282         }
 283         task_argv[0] = "/usr/sbin/lookupd";
 284         task_argv[1] = "-flushcache";
 285         task_argv[2] = NULL;
 286         LaunchTaskWithPipes( task_argv[0], task_argv, NULL, NULL );
 287 #endif /* DIRECTORY_SERVICE */
 288         exit(0);
 289 }
 290
 291 #ifdef DIRECTORY_SERVICE
 292 // read from 0
 293 int LaunchTaskWithPipes(const char *path, char *const argv[], int *outPipe0, int *outPipe1)
 294 {
 295         int outputPipe[2];
 296         pid_t pid;
 297
 298         if (outPipe0 != NULL)
 299                 pipe(outputPipe);
 300
 301         pid = fork();
 302         if (pid == -1)
 303                 return -1;
 304
 305         /* Handle the child */
 306         if (pid == 0)
 307         {
 308                 int result = -1;
 309
 310                 if (outPipe0 != NULL)
 311                         dup2(outputPipe[1], fileno(stdout));
 312
 313                 result = execv(path, argv);
 314                 if (result == -1) {
 315                         _exit(1);
 316                 }
 317
 318                 /* This should never be reached */
 319                 _exit(1);
 320         }
 321
 322         /* Now the parent */
 323         if ( outPipe0 != NULL )
 324                 *outPipe0 = outputPipe[0];
 325         if ( outPipe1 != NULL )
 326                 *outPipe1 = outputPipe[1];
 327
 328         return 0;
 329 }
 330 #endif /* DIRECTORY_SERVICE */
 331
 332 void
 333 baduser()
 334 {
 335
 336         errx(1, "%s", strerror(EACCES));
 337 }
 338
 339 void
 340 usage()
 341 {
 342
 343         (void)fprintf(stderr, "usage: chpass [-a list] [-s shell] [user]\n");
 344         exit(1);
 345 }