home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3477 < prev    next >
Internet Message Format  |  1991-06-11  |  73KB
  1. From: jfh@rpp386.cactus.org (John F Haugh II)
  2. Newsgroups: alt.sources
  3. Subject: Shadow Login Suite, patch 4
  4. Message-ID: <19372@rpp386.cactus.org>
  5. Date: 11 Jun 91 11:27:15 GMT
  6.  
  7. [ Either this didn't make it off this site or I'm in really bad shape. ]
  8.  
  9. This is patch #4 for the current beta test release of the shadow login
  10. suite.  It adds three new commands, useradd, userdel and usermod.  The
  11. documentation that I promised in patch #3 hasn't been written.  I've been
  12. busy planning a wedding (mine) and I've not had the time.  You may refer
  13. either to the source code or your nearest SVR4 documentation for the
  14. behavior of these commands.
  15.  
  16. It is known that there are bugs in these three new commands.  Since they
  17. are the newest code in the entire suite, that's to be expected.  Have
  18. patience and I'll get it fixed.  Some of the bugs have been fixed already,
  19. and other fixes are due out in patch #6 (patch #5 is currently being
  20. verified by Chip).
  21.  
  22. Also added was a "patchlevel.h" file.  So many of you asked for it, so
  23. I've provided it ...
  24. --
  25. *** /dev/null    Fri Jun  7 11:02:59 1991
  26. --- patchlevel.h    Fri Jun  7 11:13:28 1991
  27. ***************
  28. *** 0 ****
  29. --- 1,13 ----
  30. + /*
  31. +  * Copyright 1991, John F. Haugh II
  32. +  * All rights reserved.
  33. +  *
  34. +  * Permission is granted to copy and create derivative works for any
  35. +  * non-commercial purpose, provided this copyright notice is preserved
  36. +  * in all copies of source code, or included in human readable form
  37. +  * and conspicuously displayed on all copies of object code or
  38. +  * distribution media.
  39. +  */
  40. + 
  41. + #define    RELEASE        3
  42. + #define    PATCHLEVEL    4
  43. *** rel3/config.h    Thu Jun  6 09:35:02 1991
  44. --- config.h    Fri Jun  7 11:11:26 1991
  45. ***************
  46. *** 12,18 ****
  47.   /*
  48.    * Configuration file for login.
  49.    *
  50. !  *    @(#)config.h    3.7    08:57:09    5/30/91
  51.    */
  52.   
  53.   /*
  54. --- 12,18 ----
  55.   /*
  56.    * Configuration file for login.
  57.    *
  58. !  *    @(#)config.h    3.8    11:11:17    6/7/91
  59.    */
  60.   
  61.   /*
  62. ***************
  63. *** 31,40 ****
  64. --- 31,44 ----
  65.    * for getpwuid() and getpwnam().  This provides compatibility for
  66.    * privileged applications which are shadow-ignorant.  YOU ARE
  67.    * ENCOURAGED TO NOT USE THIS OPTION UNLESS ABSOLUTELY NECESSARY.
  68. +  *
  69. +  * Define SHADOWGRP to user shadowed group files.  This feature adds
  70. +  * the concept of a group administrator.
  71.    */
  72.   
  73.   #define    SHADOWPWD
  74.   #undef    AUTOSHADOW
  75. + #define    SHADOWGRP
  76.   
  77.   /*
  78.    * Define DOUBLESIZE to use 16 character passwords
  79. ***************
  80. *** 270,275 ****
  81. --- 274,282 ----
  82.   #define    GETPWENT    /* Define if you want my GETPWENT(3) routines */
  83.   #define    GETGRENT    /* Define if you want my GETGRENT(3) routines */
  84.   #define    NEED_AL64    /* Define if library does not include a64l() */
  85. + #define    NEED_MKDIR    /* Define if system does not have mkdir() */
  86. + #define    NEED_RMDIR    /* Define if system does not have rmdir() */
  87. + #define    NEED_RENAME    /* Define if system does not have rename() */
  88.   #undef    NO_STRSTR    /* Define if library does not include strstr() */
  89.   
  90.   /*
  91. *** rel3/Makefile    Thu Jun  6 09:35:02 1991
  92. --- Makefile    Fri Jun  7 11:12:38 1991
  93. ***************
  94. *** 8,16 ****
  95.   # and conspicuously displayed on all copies of object code or
  96.   # distribution media.
  97.   #
  98. ! #    @(#)Makefile    3.10    09:05:50  - Shadow password system
  99.   #
  100. ! #    @(#)Makefile    3.10    09:05:50    5/30/91
  101.   #
  102.   SHELL = /bin/sh
  103.   
  104. --- 8,16 ----
  105.   # and conspicuously displayed on all copies of object code or
  106.   # distribution media.
  107.   #
  108. ! #    @(#)Makefile    3.11    11:11:42  - Shadow password system
  109.   #
  110. ! #    @(#)Makefile    3.11    11:11:42    6/7/91
  111.   #
  112.   SHELL = /bin/sh
  113.   
  114. ***************
  115. *** 127,135 ****
  116.       utmp.c valid.c port.c newgrp.c gpmain.c grent.c mkpasswd.c pwpack.c \
  117.       chfn.c chsh.c chage.c rad64.c encrypt.c chpasswd.c shadowio.c pwio.c \
  118.       newusers.c groupio.c fields.c pwdbm.c grpack.c grdbm.c sppack.c \
  119. !     spdbm.c dpmain.c gshadow.c gsdbm.c gspack.c sgroupio.c
  120.   
  121. ! FILES1 = README newgrp.c Makefile config.h pwunconv.c obscure.c age.c id.c
  122.   
  123.   FILES2 = passwd.c port.c lmain.c mkpasswd.c sulogin.c pwpack.c dialup.c \
  124.       sulog.c getpass.c
  125. --- 127,137 ----
  126.       utmp.c valid.c port.c newgrp.c gpmain.c grent.c mkpasswd.c pwpack.c \
  127.       chfn.c chsh.c chage.c rad64.c encrypt.c chpasswd.c shadowio.c pwio.c \
  128.       newusers.c groupio.c fields.c pwdbm.c grpack.c grdbm.c sppack.c \
  129. !     spdbm.c dpmain.c gshadow.c gsdbm.c gspack.c sgroupio.c useradd.c \
  130. !     userdel.c patchlevel.h usermod.c
  131.   
  132. ! FILES1 = README newgrp.c Makefile config.h pwunconv.c obscure.c age.c id.c \
  133. !     patchlevel.h
  134.   
  135.   FILES2 = passwd.c port.c lmain.c mkpasswd.c sulogin.c pwpack.c dialup.c \
  136.       sulog.c getpass.c
  137. ***************
  138. *** 147,152 ****
  139. --- 149,156 ----
  140.   
  141.   FILES7 = groupio.c shadowio.c sgroupio.c
  142.   
  143. + FILES8 = useradd.c userdel.c usermod.c
  144. + 
  145.   MAN_1 = chage.1 chfn.1 chsh.1 login.1 passwd.1 su.1
  146.   MAN_3 = shadow.3
  147.   MAN_4 = faillog.4 passwd.4 porttime.4 shadow.4
  148. ***************
  149. *** 155,161 ****
  150.   DOCS = $(MAN_1) $(MAN_3) $(MAN_4) $(MAN_8)
  151.   
  152.   BINS = su login pwconv pwunconv passwd sulogin faillog newgrp gpasswd \
  153. !     mkpasswd chfn chsh chage chpasswd newusers dpasswd id
  154.   
  155.   all:    $(BINS) $(DOCS)
  156.   
  157. --- 159,166 ----
  158.   DOCS = $(MAN_1) $(MAN_3) $(MAN_4) $(MAN_8)
  159.   
  160.   BINS = su login pwconv pwunconv passwd sulogin faillog newgrp gpasswd \
  161. !     mkpasswd chfn chsh chage chpasswd newusers dpasswd id useradd \
  162. !     userdel usermod
  163.   
  164.   all:    $(BINS) $(DOCS)
  165.   
  166. ***************
  167. *** 214,220 ****
  168.   
  169.   lint:    su.lint login.lint pwconv.lint pwunconv.lint passwd.lint sulogin.lint \
  170.       faillog.lint newgrp.lint gpasswd.lint mkpasswd.lint chfn.lint \
  171. !     chsh.lint chage.lint dpasswd.lint $(ALLSRCS:.c=.L)
  172.   
  173.   tags:    $(ALLSRCS)
  174.       $(TAGS) $(ALLSRCS)
  175. --- 219,226 ----
  176.   
  177.   lint:    su.lint login.lint pwconv.lint pwunconv.lint passwd.lint sulogin.lint \
  178.       faillog.lint newgrp.lint gpasswd.lint mkpasswd.lint chfn.lint \
  179. !     chsh.lint chage.lint dpasswd.lint id.lint useradd.lint userdel.lint \
  180. !     usermod.lint $(ALLSRCS:.c=.L)
  181.   
  182.   tags:    $(ALLSRCS)
  183.       $(TAGS) $(ALLSRCS)
  184. ***************
  185. *** 327,332 ****
  186. --- 333,356 ----
  187.   id.lint: id.c
  188.       $(LINT) $(LINTFLAGS) id.c > id.lint
  189.   
  190. + useradd: useradd.o libshadow.a
  191. +     $(CC) -o useradd $(LDFLAGS) useradd.o libshadow.a $(LIBS)
  192. + 
  193. + useradd.lint: useradd.c
  194. +     $(LINT) $(LINTFLAGS) useradd.c > useradd.lint
  195. + 
  196. + userdel: userdel.o libshadow.a
  197. +     $(CC) -o userdel $(LDFLAGS) userdel.o libshadow.a $(LIBS)
  198. + 
  199. + userdel.lint: userdel.c
  200. +     $(LINT) $(LINTFLAGS) userdel.c > userdel.lint
  201. + 
  202. + usermod: usermod.o libshadow.a
  203. +     $(CC) -o usermod $(LDFLAGS) usermod.o libshadow.a $(LIBS)
  204. + 
  205. + usermod.lint: usermod.c
  206. +     $(LINT) $(LINTFLAGS) usermod.c > usermod.lint
  207. + 
  208.   sulog.o: config.h
  209.   
  210.   susetup.c: setup.c
  211. ***************
  212. *** 395,400 ****
  213. --- 419,426 ----
  214.   id.o: pwd.h
  215.   newusers.o: config.h shadow.h pwd.h
  216.   dpmain.o: dialup.h
  217. + useradd.o: config.h shadow.h pwd.h
  218. + userdel.o: config.h shadow.h pwd.h
  219.   
  220.   clean:
  221.       -rm -f *.o a.out core npasswd nshadow *.pag *.dir
  222. ***************
  223. *** 410,416 ****
  224.       done
  225.   
  226.   shar:    login.sh.1 login.sh.2 login.sh.3 login.sh.4 login.sh.5 login.sh.6 \
  227. !     login.sh.7 login.sh.8
  228.   
  229.   login.sh.1: $(FILES1) Makefile
  230.       shar -a $(FILES1) > login.sh.1
  231. --- 436,442 ----
  232.       done
  233.   
  234.   shar:    login.sh.1 login.sh.2 login.sh.3 login.sh.4 login.sh.5 login.sh.6 \
  235. !     login.sh.7 login.sh.8 login.sh.9
  236.   
  237.   login.sh.1: $(FILES1) Makefile
  238.       shar -a $(FILES1) > login.sh.1
  239. ***************
  240. *** 433,437 ****
  241.   login.sh.7: $(FILES7) Makefile
  242.       shar -a $(FILES7) > login.sh.7
  243.   
  244. ! login.sh.8: $(DOCS) Makefile
  245. !     shar -a $(DOCS) > login.sh.8
  246. --- 459,466 ----
  247.   login.sh.7: $(FILES7) Makefile
  248.       shar -a $(FILES7) > login.sh.7
  249.   
  250. ! login.sh.8: $(FILES8) Makefile
  251. !     shar -a $(FILES8) > login.sh.8
  252. ! 
  253. ! login.sh.9: $(DOCS) Makefile
  254. !     shar -a $(DOCS) > login.sh.9
  255. *** /dev/null    Fri Jun  7 11:02:59 1991
  256. --- useradd.c    Fri Jun  7 11:10:07 1991
  257. ***************
  258. *** 0 ****
  259. --- 1,1245 ----
  260. + /*
  261. +  * Copyright 1991, John F. Haugh II
  262. +  * All rights reserved.
  263. +  *
  264. +  * Permission is granted to copy and create derivative works for any
  265. +  * non-commercial purpose, provided this copyright notice is preserved
  266. +  * in all copies of source code, or included in human readable form
  267. +  * and conspicuously displayed on all copies of object code or
  268. +  * distribution media.
  269. +  */
  270. + 
  271. + #ifndef lint
  272. + static    char    sccsid[] = "@(#)useradd.c    3.1    11:08:18    6/7/91";
  273. + #endif
  274. + 
  275. + #include <sys/types.h>
  276. + #include <sys/stat.h>
  277. + #include <stdio.h>
  278. + #include <errno.h>
  279. + #include <pwd.h>
  280. + #include <grp.h>
  281. + #include <ctype.h>
  282. + #include <fcntl.h>
  283. + #include <time.h>
  284. + 
  285. + #ifdef    BSD
  286. + #include <strings.h>
  287. + #else
  288. + #include <string.h>
  289. + #endif
  290. + 
  291. + #include "config.h"
  292. + #include "shadow.h"
  293. + 
  294. + #ifdef    USE_SYSLOG
  295. + #include <syslog.h>
  296. + 
  297. + #ifndef    LOG_WARN
  298. + #define    LOG_WARN LOG_WARNING
  299. + #endif
  300. + #endif
  301. + 
  302. + gid_t    def_group;
  303. + char    def_home[BUFSIZ];
  304. + char    def_shell[BUFSIZ];
  305. + long    def_inactive;
  306. + long    def_expire;
  307. + char    def_file[] = "/etc/default/useradd";
  308. + 
  309. + #ifndef    NGROUPS_MAX
  310. + #define    NGROUPS_MAX    64
  311. + #endif
  312. + 
  313. + char    user_name[BUFSIZ];
  314. + uid_t    user_id;
  315. + gid_t    user_gid;
  316. + char    user_comment[BUFSIZ];
  317. + char    user_home[BUFSIZ];
  318. + char    user_shell[BUFSIZ];
  319. + long    user_expire;
  320. + int    user_ngroups;
  321. + gid_t    user_groups[NGROUPS_MAX];
  322. + 
  323. + char    *Prog;
  324. + 
  325. + int    uflg;    /* specify user ID for new account                            */
  326. + int    oflg;    /* permit non-unique user ID to be specified with -u          */
  327. + int    gflg;    /* primary group ID  for new account                          */
  328. + int    Gflg;    /* secondary group set for new account                        */
  329. + int    dflg;    /* home directory for new account                             */
  330. + int    bflg;    /* new default root of home directory                         */
  331. + int    sflg;    /* shell program for new account                              */
  332. + int    cflg;    /* comment (GECOS) field for new account                      */
  333. + int    mflg;    /* create user's home directory if it doesn't exist           */
  334. + int    kflg;    /* specify a directory to fill new user directory             */
  335. + int    fflg;    /* days until account with expired password is locked         */
  336. + int    eflg;    /* days after password changed before it becomes expired      */
  337. + int    Dflg;    /* set/show new user default values                           */
  338. + 
  339. + #if defined(DBM) || defined(NDBM)
  340. + extern    int    pw_dbm_mode;
  341. + #endif
  342. + #ifdef    NDBM
  343. + extern    int    sp_dbm_mode;
  344. + extern    int    gr_dbm_mode;
  345. + extern    int    sg_dbm_mode;
  346. + #endif
  347. + extern    FILE    *fopen();
  348. + extern    int    fclose();
  349. + extern    char    *malloc();
  350. + extern    char    *mktemp();
  351. + 
  352. + extern    struct    group    *getgrnam();
  353. + extern    struct    group    *getgrgid();
  354. + extern    struct    group    *gr_next();
  355. + extern    struct    group    *gr_locate();
  356. + extern    int    gr_lock();
  357. + extern    int    gr_unlock();
  358. + extern    int    gr_rewind();
  359. + extern    int    gr_open();
  360. + 
  361. + #ifdef    SHADOWGRP
  362. + extern    struct    sgrp    *sgr_next();
  363. + extern    int    sgr_lock();
  364. + extern    int    sgr_unlock();
  365. + extern    int    sgr_rewind();
  366. + extern    int    sgr_open();
  367. + #endif
  368. + 
  369. + extern    struct    passwd    *getpwnam();
  370. + extern    struct    passwd    *pw_next();
  371. + extern    int    pw_lock();
  372. + extern    int    pw_unlock();
  373. + extern    int    pw_rewind();
  374. + extern    int    pw_open();
  375. + 
  376. + extern    int    spw_lock();
  377. + extern    int    spw_unlock();
  378. + extern    int    spw_open();
  379. + 
  380. + #define    DAY    (24L*3600L)
  381. + #define    WEEK    (7*DAY)
  382. + 
  383. + #ifdef    ITI_AGING
  384. + #define    SCALE    (1)
  385. + #else
  386. + #define    SCALE    (DAY)
  387. + #endif
  388. + 
  389. + /*
  390. +  * days and juldays are used to compute the number of days in the
  391. +  * current month, and the cummulative number of days in the preceding
  392. +  * months.  they are declared so that january is 1, not 0.
  393. +  */
  394. + 
  395. + static    short    days[13] = { 0,
  396. +     31,    28,    31,    30,    31,    30,    /* JAN - JUN */
  397. +     31,    31,    30,    31,    30,    31 };    /* JUL - DEC */
  398. + 
  399. + static    short    juldays[13] = { 0,
  400. +     0,    31,    59,    90,    120,    151,    /* JAN - JUN */
  401. +     181,    212,    243,    273,    304,    334 };    /* JUL - DEC */
  402. + 
  403. + #ifdef    NEED_MKDIR
  404. + /*
  405. +  * mkdir - create a directory
  406. +  *
  407. +  *    mkdir is provided for systems which do not include the mkdir()
  408. +  *    system call.
  409. +  */
  410. + 
  411. + int
  412. + mkdir (dir, mode)
  413. + char    *dir;
  414. + int    mode;
  415. + {
  416. +     int    status;
  417. + 
  418. +     if (fork ()) {
  419. +         while (wait (&status) != -1)
  420. +             ;
  421. + 
  422. +         return status >> 8;
  423. +     }
  424. + #ifdef    USE_SYSLOG
  425. +     closelog ();
  426. + #endif
  427. +     close (2);
  428. +     open ("/dev/null", O_WRONLY);
  429. +     umask (0777 & ~ mode);
  430. +     execl ("/bin/mkdir", "mkdir", dir, 0);
  431. +     _exit (128);
  432. + }
  433. + #endif
  434. + #ifdef    NEED_RENAME
  435. + /*
  436. +  * rename - rename a file to another name
  437. +  *
  438. +  *    rename is provided for systems which do not include the rename()
  439. +  *    system call.
  440. +  */
  441. + 
  442. + int
  443. + rename (begin, end)
  444. + char    *begin;
  445. + char    *end;
  446. + {
  447. +     struct    stat    s1, s2;
  448. +     extern    int    errno;
  449. +     int    orig_err = errno;
  450. + 
  451. +     if (stat (begin, &s1))
  452. +         return -1;
  453. + 
  454. +     if (stat (end, &s2)) {
  455. +         errno = orig_err;
  456. +     } else {
  457. + 
  458. +         /*
  459. +          * See if this is a cross-device link.  We do this to
  460. +          * insure that the link below has a chance of working.
  461. +          */
  462. + 
  463. +         if (s1.st_dev != s2.st_dev) {
  464. +             errno = EXDEV;
  465. +             return -1;
  466. +         }
  467. + 
  468. +         /*
  469. +          * See if we can unlink the existing destination
  470. +          * file.  If the unlink works the directory is writable,
  471. +          * so there is no need here to figure that out.
  472. +          */
  473. + 
  474. +         if (unlink (end))
  475. +             return -1;
  476. +     }
  477. + 
  478. +     /*
  479. +      * Now just link the original name to the final name.  If there
  480. +      * was no file previously, this link will fail if the target
  481. +      * directory isn't writable.  The unlink will fail if the source
  482. +      * directory isn't writable, but life stinks ...
  483. +      */
  484. + 
  485. +     if (link (begin, end) || unlink (begin))
  486. +         return -1;
  487. + 
  488. +     return 0;
  489. + }
  490. + #endif
  491. + 
  492. + /*
  493. +  * strtoday - compute the number of days since 1970.
  494. +  *
  495. +  * the total number of days prior to the current date is
  496. +  * computed.  january 1, 1970 is used as the origin with
  497. +  * it having a day number of 0.
  498. +  */
  499. + 
  500. + long
  501. + strtoday (str)
  502. + char    *str;
  503. + {
  504. +     char    slop[2];
  505. +     int    month;
  506. +     int    day;
  507. +     int    year;
  508. +     long    total;
  509. + 
  510. +     /*
  511. +      * start by separating the month, day and year.  this is
  512. +      * a chauvanistic program - it only takes date input in
  513. +      * the standard USA format.
  514. +      */
  515. + 
  516. +     if (sscanf (str, "%d/%d/%d%c", &month, &day, &year, slop) != 3)
  517. +         return -1;
  518. + 
  519. +     /*
  520. +      * the month, day of the month, and year are checked for
  521. +      * correctness and the year adjusted so it falls between
  522. +      * 1970 and 2069.
  523. +      */
  524. + 
  525. +     if (month < 1 || month > 12)
  526. +         return -1;
  527. + 
  528. +     if (day < 1)
  529. +         return -1;
  530. + 
  531. +     if ((month != 2 || (year % 4) != 0) && day > days[month])
  532. +         return -1;
  533. +     else if ((month == 2 && (year % 4) == 0) && day > 29)
  534. +         return -1;
  535. + 
  536. +     if (year < 0)
  537. +         return -1;
  538. +     else if (year < 69)
  539. +         year += 2000;
  540. +     else if (year < 99)
  541. +         year += 1900;
  542. + 
  543. +     if (year < 1970 || year > 2069)
  544. +         return -1;
  545. + 
  546. +     /*
  547. +      * the total number of days is the total number of days in all
  548. +      * the whole years, plus the number of leap days, plus the
  549. +      * number of days in the whole months preceding, plus the number
  550. +      * of days so far in the month.
  551. +      */
  552. + 
  553. +     total = (long) ((year - 1970) * 365L) + (((year + 1) - 1970) / 4);
  554. +     total += (long) juldays[month] + (month > 2 && (year % 4) == 0 ? 1:0);
  555. +     total += (long) day - 1;
  556. + 
  557. +     return total;
  558. + }
  559. + 
  560. + /*
  561. +  * add_list - add a member to a list of group members
  562. +  *
  563. +  *    the array of member names is searched for the new member
  564. +  *    name, and if not present it is added to a freshly allocated
  565. +  *    list of users.
  566. +  */
  567. + 
  568. + char **
  569. + add_list (list, member)
  570. + char    **list;
  571. + char    *member;
  572. + {
  573. +     int    i;
  574. +     char    **tmp;
  575. + 
  576. +     /*
  577. +      * Scan the list for the new name.  Return the original list
  578. +      * pointer if it is present.
  579. +      */
  580. + 
  581. +     for (i = 0;list[i] != (char *) 0;i++)
  582. +         if (strcmp (list[i], member) == 0)
  583. +             return list;
  584. + 
  585. +     /*
  586. +      * Allocate a new list pointer large enough to hold all the
  587. +      * old entries, and the new entries as well.
  588. +      */
  589. + 
  590. +     if (! (tmp = (char **) malloc ((i + 2) * sizeof member)))
  591. +         return 0;
  592. + 
  593. +     /*
  594. +      * Copy the original list to the new list, then append the
  595. +      * new member and NULL terminate the result.  This new list
  596. +      * is returned to the invoker.
  597. +      */
  598. + 
  599. +     for (i = 0;list[i] != (char *) 0;i++)
  600. +         tmp[i] = list[i];
  601. + 
  602. +     tmp[i++] = strdup (member);
  603. +     tmp[i] = (char *) 0;
  604. + 
  605. +     return tmp;
  606. + }
  607. + 
  608. + /*
  609. +  * get_defaults - read the defaults file
  610. +  *
  611. +  *    get_defaults() reads the defaults file for this command.  It sets
  612. +  *    the various values from the file, or uses built-in default values
  613. +  *    if the file does not exist.
  614. +  */
  615. + 
  616. + void
  617. + get_defaults ()
  618. + {
  619. +     FILE    *fp;
  620. +     char    buf[BUFSIZ];
  621. +     char    *cp;
  622. +     struct    group    *grp;
  623. + 
  624. +     /*
  625. +      * Open the defaults file for reading.
  626. +      */
  627. + 
  628. +     if (! (fp = fopen (def_file, "r"))) {
  629. + 
  630. +         /*
  631. +          * No defaults file - set up the defaults that are given
  632. +          * in the documentation.
  633. +          */
  634. + 
  635. +         def_group = 1;
  636. +         strcpy (def_home, "/home");
  637. +         def_inactive = 0;
  638. +         def_expire = 0;
  639. +         return;
  640. +     }
  641. + 
  642. +     /*
  643. +      * Read the file a line at a time.  Only the lines that have
  644. +      * relevant values are used, everything else can be ignored.
  645. +      */
  646. + 
  647. +     while (fgets (buf, BUFSIZ, fp)) {
  648. +         if (cp = strrchr (buf, '\n'))
  649. +             *cp = '\0';
  650. + 
  651. +         /*
  652. +          * Primary GROUP identifier
  653. +          */
  654. + 
  655. +         if (strncmp ("GROUP=", buf, 6) == 0) {
  656. +             cp = buf + 6;
  657. +             if (isdigit (*cp))
  658. +                 def_group = atoi (cp);
  659. +             else if (grp = getgrnam (cp))
  660. +                 def_group = grp->gr_gid;
  661. +             else
  662. +                 fprintf (stderr, "%s: unknown group %s\n", cp);
  663. +         }
  664. +         
  665. +         /*
  666. +          * Default HOME filesystem
  667. +          */
  668. +          
  669. +         else if (strncmp ("HOME=", buf, 5) == 0) {
  670. +             strncpy (def_home, buf + 5, BUFSIZ);
  671. +         }
  672. + 
  673. +         /*
  674. +          * Default Login Shell command
  675. +          */
  676. + 
  677. +         else if (strncmp ("SHELL=", buf, 6) == 0) {
  678. +             strncpy (def_shell, buf + 6, BUFSIZ);
  679. +         }
  680. + 
  681. +         /*
  682. +          * Default Password Inactive value
  683. +          */
  684. + 
  685. +         else if (strncmp ("INACTIVE=", buf, 9) == 0) {
  686. +             def_inactive = atoi (buf + 9);
  687. +         }
  688. +         
  689. +         /*
  690. +          * Default Password Expiration value
  691. +          */
  692. + 
  693. +         else if (strncmp ("EXPIRE=", buf, 7) == 0) {
  694. +             def_expire = atoi (buf + 7);
  695. +         }
  696. +     }
  697. + }
  698. + 
  699. + /*
  700. +  * show_defaults - show the contents of the defaults file
  701. +  *
  702. +  *    show_defaults() displays the values that are used from the default
  703. +  *    file and the built-in values.
  704. +  */
  705. + 
  706. + void
  707. + show_defaults ()
  708. + {
  709. +     printf ("GROUP=%d\n", def_group);
  710. +     printf ("HOME=%s\n", def_home);
  711. +     printf ("INACTIVE=%d\n", def_inactive);
  712. +     printf ("EXPIRE=%d\n", def_expire);
  713. + }
  714. + 
  715. + /*
  716. +  * set_defaults - write new defaults file
  717. +  *
  718. +  *    set_defaults() re-writes the defaults file using the values that
  719. +  *    are currently set.  Duplicated lines are pruned, missing lines are
  720. +  *    added, and unrecognized lines are copied as is.
  721. +  */
  722. + 
  723. + int
  724. + set_defaults ()
  725. + {
  726. +     FILE    *ifp;
  727. +     FILE    *ofp;
  728. +     char    buf[BUFSIZ];
  729. +     static    char    new_file[] = "/etc/default/nuaddXXXXXX";
  730. +     char    *cp;
  731. +     int    out_group = 0;
  732. +     int    out_home = 0;
  733. +     int    out_inactive = 0;
  734. +     int    out_expire = 0;
  735. + 
  736. +     /*
  737. +      * Create a temporary file to copy the new output to.
  738. +      */
  739. + 
  740. +     mktemp (new_file);
  741. +     if (! (ofp = fopen (new_file, "w"))) {
  742. +         fprintf (stderr, "%s: cannot create new defaults file\n", Prog);
  743. +         return -1;
  744. +     }
  745. + 
  746. +     /*
  747. +      * Open the existing defaults file and copy the lines to the
  748. +      * temporary files, using any new values.  Each line is checked
  749. +      * to insure that it is not output more than once.
  750. +      */
  751. + 
  752. +     if (ifp = fopen (def_file, "r")) {
  753. +         while (fgets (buf, BUFSIZ, ifp)) {
  754. +             if (cp = strrchr (buf, '\n'))
  755. +                 *cp = '\0';
  756. + 
  757. +             if (strncmp ("GROUP=", buf, 6) == 0) {
  758. +                 if (! out_group)
  759. +                     fprintf (ofp, "GROUP=%d\n", def_group);
  760. + 
  761. +                 out_group++;
  762. +             } else if (strncmp ("HOME=", buf, 5) == 0) {
  763. +                 if (! out_home)
  764. +                     fprintf (ofp, "HOME=%s\n", def_home);
  765. + 
  766. +                 out_home++;
  767. +             } else if (strncmp ("INACTIVE=", buf, 9) == 0) {
  768. +                 if (! out_inactive)
  769. +                     fprintf (ofp, "INACTIVE=%d\n",
  770. +                         def_inactive);
  771. + 
  772. +                 out_inactive++;
  773. +             } else if (strncmp ("EXPIRE=", buf, 7) == 0) {
  774. +                 if (! out_expire)
  775. +                     fprintf (ofp, "EXPIRE=%d\n",
  776. +                         def_expire);
  777. + 
  778. +                 out_expire++;
  779. +             } else
  780. +                 fprintf (ofp, "%s\n", buf);
  781. +         }
  782. +         fclose ((FILE *) ifp);
  783. +     }
  784. + 
  785. +     /*
  786. +      * Check each line to insure that every line was output.  This
  787. +      * causes new values to be added to a file which did not previously
  788. +      * have an entry for that value.
  789. +      */
  790. + 
  791. +     if (! out_group)
  792. +         fprintf (ofp, "GROUP=%d\n", def_group);
  793. + 
  794. +     if (! out_home)
  795. +         fprintf (ofp, "HOME=%s\n", def_home);
  796. + 
  797. +     if (! out_inactive)
  798. +         fprintf (ofp, "INACTIVE=%d\n", def_inactive);
  799. + 
  800. +     if (! out_expire)
  801. +         fprintf (ofp, "EXPIRE=%d\n", def_expire);
  802. + 
  803. +     /*
  804. +      * Flush and close the file.  Check for errors to make certain
  805. +      * the new file is intact.
  806. +      */
  807. + 
  808. +     (void) fflush (ofp);
  809. +     if (ferror (ofp) || fclose ((FILE *) ofp)) {
  810. +         unlink (new_file);
  811. +         return -1;
  812. +     }
  813. + 
  814. +     /*
  815. +      * Rename the current default file to its backup name.
  816. +      */
  817. + 
  818. +     sprintf (buf, "%s-", def_file);
  819. +     if (rename (def_file, buf) && errno != ENOENT) {
  820. +         sprintf (buf, "%s: rename: %s", Prog, def_file);
  821. +         perror (buf);
  822. +         unlink (new_file);
  823. +         return -1;
  824. +     }
  825. + 
  826. +     /*
  827. +      * Rename the new default file to its correct name.
  828. +      */
  829. + 
  830. +     if (rename (new_file, def_file)) {
  831. +         sprintf (buf, "%s: rename: %s", Prog, new_file);
  832. +         perror (buf);
  833. +         return -1;
  834. +     }
  835. + #ifdef    USE_SYSLOG
  836. +     syslog (LOG_INFO, "defaults: group=%d, home=%s, inactive=%d, expire=%d",
  837. +         def_group, def_home, def_inactive, def_expire);
  838. + #endif
  839. +     return 0;
  840. + }
  841. + 
  842. + /*
  843. +  * get_groups - convert a list of group names to an array of group IDs
  844. +  *
  845. +  *    get_groups() takes a comma-separated list of group names and
  846. +  *    converts it to an array of group ID values.  Any unknown group
  847. +  *    names are reported as errors.
  848. +  */
  849. + 
  850. + int
  851. + get_groups (list)
  852. + char    *list;
  853. + {
  854. +     char    *cp;
  855. +     struct    group    *grp;
  856. +     int    errors = 0;
  857. + 
  858. +     /*
  859. +      * Initialize the list to be empty
  860. +      */
  861. + 
  862. +     user_ngroups = 0;
  863. + 
  864. +     if (! *list)
  865. +         return 0;
  866. + 
  867. +     /*
  868. +      * So long as there is some data to be converted, strip off
  869. +      * each name and look it up.  A mix of numerical and string
  870. +      * values for group identifiers is permitted.
  871. +      */
  872. + 
  873. +     do {
  874. +         /*
  875. +          * Strip off a single name from the list
  876. +          */
  877. + 
  878. +         if (cp = strchr (list, ','))
  879. +             *cp++ = '\0';
  880. + 
  881. +         /*
  882. +          * Names starting with digits are treated as numerical
  883. +          * GID values, otherwise the string is looked up as is.
  884. +          */
  885. + 
  886. +         if (isdigit (*list))
  887. +             grp = getgrgid (atoi (list));
  888. +         else
  889. +             grp = getgrnam (list);
  890. + 
  891. +         /*
  892. +          * There must be a match, either by GID value or by
  893. +          * string name.
  894. +          */
  895. + 
  896. +         if (! grp) {
  897. +             fprintf (stderr, "%s: unknown group %s\n", Prog, list);
  898. +             errors++;
  899. +         }
  900. + 
  901. +         /*
  902. +          * Add the GID value from the group file to the user's
  903. +          * list of groups.
  904. +          */
  905. + 
  906. +         user_groups[user_ngroups++] = grp->gr_gid;
  907. + 
  908. +         list = cp;
  909. +     } while (list);
  910. + 
  911. +     /*
  912. +      * Any errors in finding group names are fatal
  913. +      */
  914. + 
  915. +     if (errors)
  916. +         return -1;
  917. + 
  918. +     return 0;
  919. + }
  920. + 
  921. + /*
  922. +  * usage - display usage message and exit
  923. +  */
  924. + 
  925. + usage ()
  926. + {
  927. +     fprintf (stderr,
  928. +         "usage:\tuseradd [-u uid [-o]] [-g group] [-G group,...] \n");
  929. +     fprintf (stderr,
  930. +         "\t\t[-d home] [-s shell] [-c comment] [-m [-k template]]\n");
  931. +     fprintf (stderr,
  932. +         "\t\t[-f inactive] [-e expire] name\n");
  933. + 
  934. +     fprintf (stderr,
  935. +         "\tuseradd -D [-g group] [-b base] [-f inactive] [-e expire]\n");
  936. + 
  937. +     exit (1);
  938. + }
  939. + 
  940. + /*
  941. +  * new_pwent - initialize the values in a password file entry
  942. +  *
  943. +  *    new_pwent() takes all of the values that have been entered and
  944. +  *    fills in a (struct passwd) with them.
  945. +  */
  946. + 
  947. + void
  948. + new_pwent (pwent)
  949. + struct    passwd    *pwent;
  950. + {
  951. +     memset (pwent, 0, sizeof *pwent);
  952. +     pwent->pw_name = user_name;
  953. +     pwent->pw_passwd = "*";
  954. +     pwent->pw_age = "";
  955. +     pwent->pw_uid = user_id;
  956. +     pwent->pw_gid = user_gid;
  957. +     pwent->pw_gecos = user_comment;
  958. +     pwent->pw_comment = "";
  959. +     pwent->pw_dir = user_home;
  960. +     pwent->pw_shell = user_shell;
  961. + }
  962. + 
  963. + /*
  964. +  * new_spent - initialize the values in a shadow password file entry
  965. +  *
  966. +  *    new_spent() takes all of the values that have been entered and
  967. +  *    fills in a (struct spwd) with them.
  968. +  */
  969. + 
  970. + void
  971. + new_spent (spent)
  972. + struct    spwd    *spent;
  973. + {
  974. +     memset (spent, 0, sizeof *spent);
  975. +     spent->sp_namp = user_name;
  976. +     spent->sp_pwdp = "!";
  977. +     spent->sp_lstchg = 0;
  978. +     spent->sp_min = 0;
  979. +     spent->sp_max = def_expire;
  980. +     spent->sp_warn = 0;
  981. +     spent->sp_inact = def_inactive;
  982. +     spent->sp_expire = user_expire;
  983. + }
  984. + 
  985. + /*
  986. +  * grp_update - add user to secondary group set
  987. +  *
  988. +  *    grp_update() takes the secondary group set given in user_groups
  989. +  *    and adds the user to each group given by that set.
  990. +  */
  991. + 
  992. + void
  993. + grp_update ()
  994. + {
  995. +     int    i;
  996. +     struct    group    *grp;
  997. +     struct    sgrp    *sgrp;
  998. + 
  999. +     /*
  1000. +      * Lock and open the group file.  This will load all of the group
  1001. +      * entries.
  1002. +      */
  1003. + 
  1004. +     if (! gr_lock ()) {
  1005. +         fprintf (stderr, "%s: error locking group file\n", Prog);
  1006. +         exit (1);
  1007. +     }
  1008. +     if (! gr_open (O_RDWR)) {
  1009. +         fprintf (stderr, "%s: error opening group file\n", Prog);
  1010. +         exit (1);
  1011. +     }
  1012. + #ifdef    SHADOWGRP
  1013. +     if (! sgr_lock ()) {
  1014. +         fprintf (stderr, "%s: error locking shadow group file\n", Prog);
  1015. +         exit (1);
  1016. +     }
  1017. +     if (! sgr_open (O_RDWR)) {
  1018. +         fprintf (stderr, "%s: error opening shadow group file\n", Prog);
  1019. +         exit (1);
  1020. +     }
  1021. + #endif
  1022. + 
  1023. +     /*
  1024. +      * Scan through the entire group file looking for the groups that
  1025. +      * the user is a member of.
  1026. +      */
  1027. + 
  1028. +     for (gr_rewind (), grp = gr_next ();grp;grp = gr_next ()) {
  1029. + 
  1030. +         /*
  1031. +          * See if the user specified this group as one of their
  1032. +          * concurrent groups.
  1033. +          */
  1034. + 
  1035. +         for (i = 0;i < user_ngroups;i++)
  1036. +             if (grp->gr_gid == user_groups[i])
  1037. +                 break;
  1038. + 
  1039. +         if (i == user_ngroups)
  1040. +             continue;
  1041. + 
  1042. +         /* 
  1043. +          * Add the username to the list of group members and
  1044. +          * update the group entry to reflect the change.
  1045. +          */
  1046. + 
  1047. +         grp->gr_mem = add_list (grp->gr_mem, user_name);
  1048. +         if (! gr_update (grp)) {
  1049. +             fprintf (stderr, "%s: error adding new group entry\n",
  1050. +                 Prog);
  1051. +             exit (1);
  1052. +         }
  1053. + #ifdef    NDBM
  1054. +         /*
  1055. +          * Update the DBM group file with the new entry as well.
  1056. +          */
  1057. + 
  1058. +         if (! gr_dbm_update (grp)) {
  1059. +             fprintf (stderr, "%s: cannot add new dbm group entry\n",
  1060. +                 Prog);
  1061. +             exit (1);
  1062. +         }
  1063. + #endif
  1064. + #ifdef    USE_SYSLOG
  1065. +         syslog (LOG_INFO, "add `%s' to group `%s'\n",
  1066. +             user_name, grp->gr_name);
  1067. + #endif
  1068. +     }
  1069. + 
  1070. + #ifdef    SHADOWGRP
  1071. +     /*
  1072. +      * Scan through the entire shadow group file looking for the groups
  1073. +      * that the user is a member of.  The administrative list isn't
  1074. +      * modified.
  1075. +      */
  1076. + 
  1077. +     for (sgr_rewind (), sgrp = sgr_next ();sgrp;sgrp = sgr_next ()) {
  1078. + 
  1079. +         /*
  1080. +          * See if the user specified this group as one of their
  1081. +          * concurrent groups.
  1082. +          */
  1083. + 
  1084. +         for (i = 0;i < user_ngroups;i++) {
  1085. +             if (! (grp = gr_locate (sgrp->sg_name)))
  1086. +                 continue;
  1087. + 
  1088. +             if (grp->gr_gid == user_groups[i])
  1089. +                 break;
  1090. +         }
  1091. +         if (i == user_ngroups)
  1092. +             continue;
  1093. + 
  1094. +         /* 
  1095. +          * Add the username to the list of group members and
  1096. +          * update the group entry to reflect the change.
  1097. +          */
  1098. + 
  1099. +         sgrp->sg_mem = add_list (sgrp->sg_mem, user_name);
  1100. +         if (! sgr_update (sgrp)) {
  1101. +             fprintf (stderr, "%s: error adding new group entry\n",
  1102. +                 Prog);
  1103. +             exit (1);
  1104. +         }
  1105. + #ifdef    NDBM
  1106. +         /*
  1107. +          * Update the DBM group file with the new entry as well.
  1108. +          */
  1109. + 
  1110. +         if (! sgr_dbm_update (sgrp)) {
  1111. +             fprintf (stderr, "%s: cannot add new dbm group entry\n",
  1112. +                 Prog);
  1113. +             exit (1);
  1114. +         }
  1115. + #endif
  1116. + #ifdef    USE_SYSLOG
  1117. +         syslog (LOG_INFO, "add `%s' to shadow group `%s'\n",
  1118. +             user_name, sgrp->sg_name);
  1119. + #endif
  1120. +     }
  1121. + #endif
  1122. + }
  1123. + 
  1124. + /*
  1125. +  * find_new_uid - find the next available UID
  1126. +  *
  1127. +  *    find_new_uid() locates the next highest unused UID in the password
  1128. +  *    file, or checks the given user ID against the existing ones for
  1129. +  *    uniqueness.
  1130. +  */
  1131. + 
  1132. + int
  1133. + find_new_uid ()
  1134. + {
  1135. +     struct    passwd    *pwd;
  1136. + 
  1137. +     /*
  1138. +      * Start with some UID value if the user didn't provide us with
  1139. +      * one already.
  1140. +      */
  1141. + 
  1142. +     if (! uflg)
  1143. +         user_id = 100;
  1144. + 
  1145. +     /*
  1146. +      * Search the entire password file, either looking for this
  1147. +      * UID (if the user specified one with -u) or looking for the
  1148. +      * largest unused value.
  1149. +      */
  1150. + 
  1151. +     for (pw_rewind (), pwd = pw_next ();pwd;pwd = pw_next ()) {
  1152. +         if (strcmp (user_name, pwd->pw_name) == 0) {
  1153. +             fprintf (stderr, "%s: name %s is not unique\n",
  1154. +                 Prog, user_name);
  1155. +             exit (1);
  1156. +         }
  1157. +         if (uflg && user_id == pwd->pw_uid) {
  1158. +             fprintf (stderr, "%s: uid %d is not unique\n",
  1159. +                 Prog, user_id);
  1160. +             exit (1);
  1161. +         }
  1162. +         if (! uflg && pwd->pw_uid >= user_id)
  1163. +             user_id = pwd->pw_uid + 1;
  1164. +     }
  1165. + }
  1166. + 
  1167. + /*
  1168. +  * process_flags - perform command line argument setting
  1169. +  *
  1170. +  *    process_flags() interprets the command line arguments and sets
  1171. +  *    the values that the user will be created with accordingly.  The
  1172. +  *    values are checked for sanity.
  1173. +  */
  1174. + 
  1175. + void
  1176. + process_flags (argc, argv)
  1177. + int    argc;
  1178. + char    **argv;
  1179. + {
  1180. +     extern    int    optind;
  1181. +     extern    char    *optarg;
  1182. +     struct    group    *grp;
  1183. +     int    anyflag = 0;
  1184. +     int    arg;
  1185. + 
  1186. +     while ((arg = getopt (argc, argv, "Du:og:G:d:s:c:mk:f:e:b:")) != EOF) {
  1187. +         switch (arg) {
  1188. +             case 'b':
  1189. +                 bflg++;
  1190. +                 if (! Dflg)
  1191. +                     usage ();
  1192. + 
  1193. +                 strncpy (def_home, optarg, BUFSIZ);
  1194. +                 break;
  1195. +             case 'c':
  1196. +                 cflg++;
  1197. +                 strncpy (user_comment, optarg, BUFSIZ);
  1198. +                 break;
  1199. +             case 'd':
  1200. +                 dflg++;
  1201. +                 strncpy (user_home, optarg, BUFSIZ);
  1202. +                 break;
  1203. +             case 'D':
  1204. +                 if (anyflag)
  1205. +                     usage ();
  1206. + 
  1207. +                 Dflg++;
  1208. +                 break;
  1209. +             case 'e':
  1210. +                 eflg++;
  1211. +                 if (Dflg)
  1212. +                     def_expire = atoi (optarg);
  1213. +                 else {
  1214. +                     user_expire = strtoday (optarg);
  1215. + #ifdef    ITI_AGING
  1216. +                     user_expire *= DAY;
  1217. + #endif
  1218. +                 }
  1219. +                 break;
  1220. +             case 'f':
  1221. +                 fflg++;
  1222. +                 def_inactive = atoi (optarg);
  1223. +                 break;
  1224. +             case 'g':
  1225. +                 gflg++;
  1226. +                 if (isdigit (optarg[0]))
  1227. +                     grp = getgrgid (atoi (optarg));
  1228. +                 else
  1229. +                     grp = getgrnam (optarg);
  1230. + 
  1231. +                 if (! grp) {
  1232. +                     fprintf (stderr,
  1233. +                         "%s: unknown group %s\n",
  1234. +                         optarg);
  1235. +                     exit (1);
  1236. +                 }
  1237. +                 def_group = grp->gr_gid;
  1238. +                 break;
  1239. +             case 'G':
  1240. +                 Gflg++;
  1241. +                 if (get_groups (optarg))
  1242. +                     exit (1);
  1243. + 
  1244. +                 break;
  1245. +             case 'k':
  1246. +                 if (! mflg)
  1247. +                     usage ();
  1248. + 
  1249. +                 kflg++;
  1250. +                 break;
  1251. +             case 'm':
  1252. +                 mflg++;
  1253. +                 break;
  1254. +             case 'o':
  1255. +                 if (! uflg)
  1256. +                     usage ();
  1257. + 
  1258. +                 oflg++;
  1259. +                 break;
  1260. +             case 's':
  1261. +                 sflg++;
  1262. +                 strncpy (user_shell, optarg, BUFSIZ);
  1263. +                 break;
  1264. +             case 'u':
  1265. +                 uflg++;
  1266. +                 user_id = atoi (optarg);
  1267. +                 break;
  1268. +             default:
  1269. +                 usage ();
  1270. +         }
  1271. +         anyflag++;
  1272. +     }
  1273. +     if (! Dflg && optind == argc - 1)
  1274. +         strcpy (user_name, argv[argc - 1]);
  1275. + 
  1276. +     if (! dflg)
  1277. +         sprintf (user_home, "%s/%s", def_home, user_name);
  1278. + 
  1279. +     if (! gflg)
  1280. +         user_gid = def_group;
  1281. + 
  1282. +     if (Dflg) {
  1283. +         if (optind != argc)
  1284. +             usage ();
  1285. + 
  1286. +         if (uflg || oflg || Gflg || dflg ||
  1287. +                 sflg || cflg || mflg || kflg)
  1288. +             usage ();
  1289. +     } else {
  1290. +         if (optind != argc - 1)
  1291. +             usage ();
  1292. +     }
  1293. + }
  1294. + 
  1295. + /*
  1296. +  * close_files - close all of the files that were opened
  1297. +  *
  1298. +  *    close_files() closes all of the files that were opened for this
  1299. +  *    new user.  This causes any modified entries to be written out.
  1300. +  */
  1301. + 
  1302. + close_files ()
  1303. + {
  1304. +     if (! pw_close ()) {
  1305. +         fprintf (stderr, "%s: cannot rewrite password file\n", Prog);
  1306. +         exit (1);
  1307. +     }
  1308. +     if (! spw_close ()) {
  1309. +         fprintf (stderr, "%s: cannot rewrite shadow password file\n",    
  1310. +             Prog);
  1311. +         exit (1);
  1312. +     }
  1313. +     if (user_ngroups > 0) {
  1314. +         if (! gr_close ()) {
  1315. +             fprintf (stderr, "%s: cannot rewrite group file\n",
  1316. +                 Prog);
  1317. +             exit (1);
  1318. +         }
  1319. +         (void) gr_unlock ();
  1320. + #ifdef    SHADOWGRP
  1321. +         if (! sgr_close ()) {
  1322. +             fprintf (stderr, "%s: cannot rewrite shadow group file\n",
  1323. +                 Prog);
  1324. +             exit (1);
  1325. +         }
  1326. + #endif
  1327. +     }
  1328. +     (void) pw_unlock ();
  1329. + }
  1330. + 
  1331. + /*
  1332. +  * open_files - lock and open the password files
  1333. +  *
  1334. +  *    open_files() opens the two password files.
  1335. +  */
  1336. + 
  1337. + open_files ()
  1338. + {
  1339. +     if (! pw_lock ()) {
  1340. +         fprintf (stderr, "%s: unable to lock password file\n", Prog);
  1341. +         exit (1);
  1342. +     }
  1343. +     if (! pw_open (O_RDWR)) {
  1344. +         fprintf (stderr, "%s: unable to open password file\n", Prog);
  1345. +         exit (1);
  1346. +     }
  1347. +     if (! spw_lock ()) {
  1348. +         fprintf ("%s: cannot lock shadow password file\n", Prog);
  1349. +         exit (1);
  1350. +     }
  1351. +     if (! spw_open (O_RDWR)) {
  1352. +         fprintf ("%s: cannot open shadow password file\n", Prog);
  1353. +         exit (1);
  1354. +     }
  1355. + }
  1356. + 
  1357. + /*
  1358. +  * usr_update - create the user entries
  1359. +  *
  1360. +  *    usr_update() creates the password file entries for this user
  1361. +  *    and will update the group entries if required.
  1362. +  */
  1363. + 
  1364. + usr_update ()
  1365. + {
  1366. +     struct    passwd    pwent;
  1367. +     struct    spwd    spent;
  1368. + 
  1369. +     if (! oflg)
  1370. +         find_new_uid ();
  1371. + 
  1372. +     new_pwent (&pwent);
  1373. +     if (! pw_update (&pwent)) {
  1374. +         fprintf (stderr, "%s: error adding new password entry\n", Prog);
  1375. +         exit (1);
  1376. +     }
  1377. +     new_spent (&spent);
  1378. +     if (! spw_update (&spent)) {
  1379. +         fprintf (stderr, "%s: error adding new shadow password entry\n",
  1380. +             Prog);
  1381. +         exit (1);
  1382. +     }
  1383. + #if defined(DBM) || defined(NDBM)
  1384. +     if (access ("/etc/passwd.pag", 0) == 0 && ! pw_dbm_update (&pwent)) {
  1385. +         fprintf (stderr, "%s: error updating password dbm entry\n",
  1386. +             Prog);
  1387. +         exit (1);
  1388. +     }
  1389. + #endif
  1390. + #ifdef    NDBM
  1391. +     if (access ("/etc/shadow.pag", 0) == 0 && ! sp_dbm_update (&spent)) {
  1392. +         fprintf (stderr, "%s: error updating shadow passwd dbm entry\n",
  1393. +             Prog);
  1394. +         exit (1);
  1395. +     }
  1396. + #endif
  1397. + #ifdef    USE_SYSLOG
  1398. +     syslog (LOG_INFO,
  1399. +         "new user: name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",
  1400. +         user_name, user_id, user_gid, user_home, user_shell);
  1401. + #endif
  1402. +     if (user_ngroups > 0)
  1403. +         grp_update ();
  1404. + }
  1405. + 
  1406. + /*
  1407. +  * create_home - create the user's home directory
  1408. +  *
  1409. +  *    create_home() creates the user's home directory if it does not
  1410. +  *    already exist.  It will be created mode 755 owned by the user
  1411. +  *    with the user's default group.
  1412. +  */
  1413. + 
  1414. + create_home ()
  1415. + {
  1416. +     if (access (user_home, 0)) {
  1417. +         if (mkdir (user_home, 0755)) {
  1418. +             fprintf (stderr, "%s: cannot create directory %s\n",
  1419. +                 Prog, user_home);
  1420. +             exit (1);
  1421. +         }
  1422. +         chown (user_home, user_id, user_gid);
  1423. +         chmod (user_home, 0755);
  1424. +     }
  1425. + }
  1426. + 
  1427. + /*
  1428. +  * main - useradd command
  1429. +  */
  1430. + 
  1431. + main (argc, argv)
  1432. + int    argc;
  1433. + char    **argv;
  1434. + {
  1435. +     /*
  1436. +      * Get my name so that I can use it to report errors.
  1437. +      */
  1438. + 
  1439. +     if (Prog = strrchr (argv[0], '/'))
  1440. +         Prog++;
  1441. +     else
  1442. +         Prog = argv[0];
  1443. + 
  1444. + #ifdef    USE_SYSLOG
  1445. +     openlog (Prog, LOG_PID|LOG_CONS|LOG_NOWAIT, LOG_AUTH);
  1446. + #endif
  1447. + 
  1448. +     /*
  1449. +      * The open routines for the DBM files don't use read-write
  1450. +      * as the mode, so we have to clue them in.
  1451. +      */
  1452. + 
  1453. + #if defined(DBM) || defined(NDBM)
  1454. +     pw_dbm_mode = O_RDWR;
  1455. + #endif
  1456. + #ifdef    NDBM
  1457. +     sp_dbm_mode = O_RDWR;
  1458. +     gr_dbm_mode = O_RDWR;
  1459. + #ifdef    SHADOWGRP
  1460. +     sg_dbm_mode = O_RDWR;
  1461. + #endif
  1462. + #endif
  1463. +     get_defaults ();
  1464. + 
  1465. +     process_flags (argc, argv);
  1466. + 
  1467. +     /*
  1468. +      * See if we are messing with the defaults file, or creating
  1469. +      * a new user.
  1470. +      */
  1471. + 
  1472. +     if (Dflg) {
  1473. +         if (gflg || bflg || fflg || eflg)
  1474. +             exit (set_defaults () ? 1:0);
  1475. + 
  1476. +         show_defaults ();
  1477. +         exit (0);
  1478. +     }
  1479. + 
  1480. +     /*
  1481. +      * Start with a quick check to see if the user exists.
  1482. +      */
  1483. + 
  1484. +     if (getpwnam (user_name)) {
  1485. +         fprintf (stderr, "%s: user %s exists\n", Prog, user_name);
  1486. +         exit (1);
  1487. +     }
  1488. + 
  1489. +     /*
  1490. +      * Do the hard stuff - open the files, create the user entries,
  1491. +      * create the home directory, then close and update the files.
  1492. +      */
  1493. + 
  1494. +     open_files ();
  1495. + 
  1496. +     usr_update ();
  1497. + 
  1498. +     if (mflg)
  1499. +         create_home ();
  1500. + 
  1501. +     close_files ();
  1502. +     exit (0);
  1503. +     /*NOTREACHED*/
  1504. + }
  1505. *** /dev/null    Fri Jun  7 11:02:59 1991
  1506. --- userdel.c    Fri Jun  7 11:10:08 1991
  1507. ***************
  1508. *** 0 ****
  1509. --- 1,499 ----
  1510. + /*
  1511. +  * Copyright 1991, John F. Haugh II
  1512. +  * All rights reserved.
  1513. +  *
  1514. +  * Permission is granted to copy and create derivative works for any
  1515. +  * non-commercial purpose, provided this copyright notice is preserved
  1516. +  * in all copies of source code, or included in human readable form
  1517. +  * and conspicuously displayed on all copies of object code or
  1518. +  * distribution media.
  1519. +  */
  1520. + 
  1521. + #ifndef lint
  1522. + static    char    sccsid[] = "@(#)userdel.c    3.1    11:08:47    6/7/91";
  1523. + #endif
  1524. + 
  1525. + #include <sys/types.h>
  1526. + #include <sys/stat.h>
  1527. + #include <stdio.h>
  1528. + #include <errno.h>
  1529. + #include <pwd.h>
  1530. + #include <grp.h>
  1531. + #include <ctype.h>
  1532. + #include <fcntl.h>
  1533. + #include <time.h>
  1534. + 
  1535. + #ifdef    BSD
  1536. + #include <strings.h>
  1537. + #else
  1538. + #include <string.h>
  1539. + #endif
  1540. + 
  1541. + #include "config.h"
  1542. + #include "shadow.h"
  1543. + 
  1544. + #ifdef    USE_SYSLOG
  1545. + #include <syslog.h>
  1546. + 
  1547. + #ifndef    LOG_WARN
  1548. + #define    LOG_WARN LOG_WARNING
  1549. + #endif
  1550. + #endif
  1551. + 
  1552. + gid_t    default_group;
  1553. + char    default_home[BUFSIZ];
  1554. + char    default_shell[BUFSIZ];
  1555. + long    default_inactive;
  1556. + long    default_expire;
  1557. + char    default_file[] = "/etc/default/useradd";
  1558. + 
  1559. + #ifndef    NGROUPS_MAX
  1560. + #define    NGROUPS_MAX    64
  1561. + #endif
  1562. + 
  1563. + char    user_name[BUFSIZ];
  1564. + uid_t    user_id;
  1565. + gid_t    user_group;
  1566. + char    user_comment[BUFSIZ];
  1567. + char    user_home[BUFSIZ];
  1568. + char    user_shell[BUFSIZ];
  1569. + int    user_ngroups;
  1570. + int    user_expire;
  1571. + gid_t    user_groups[NGROUPS_MAX];
  1572. + 
  1573. + char    *Prog;
  1574. + int    rflg;
  1575. + 
  1576. + #if defined(DBM) || defined(NDBM)
  1577. + extern    int    pw_dbm_mode;
  1578. + #endif
  1579. + #ifdef    NDBM
  1580. + extern    int    sp_dbm_mode;
  1581. + extern    int    gr_dbm_mode;
  1582. + #ifdef    SHADOWGRP
  1583. + extern    int    sg_dbm_mode;
  1584. + #endif
  1585. + #endif
  1586. + extern    struct    group    *getgrnam();
  1587. + extern    struct    group    *getgrgid();
  1588. + extern    struct    group    *gr_next();
  1589. + extern    struct    passwd    *getpwnam();
  1590. + extern    struct    passwd    *pw_next();
  1591. + 
  1592. + #ifdef    SHADOWGRP
  1593. + extern    int    sgr_lock();
  1594. + extern    int    sgr_unlock();
  1595. + extern    int    sgr_open();
  1596. + extern    int    sgr_close();
  1597. + extern    struct    sgrp    *sgr_next();
  1598. + #endif
  1599. + 
  1600. + extern    char    *malloc();
  1601. + 
  1602. + #ifdef    NEED_RMDIR
  1603. + /*
  1604. +  * rmdir - remove a directory
  1605. +  *
  1606. +  *    rmdir is provided for systems which do not include the rmdir()
  1607. +  *    system call.
  1608. +  */
  1609. + 
  1610. + int
  1611. + rmdir (dir)
  1612. + char    *dir;
  1613. + {
  1614. +     int    status;
  1615. + 
  1616. +     if (fork ()) {
  1617. +         while (wait (&status) != -1)
  1618. +             ;
  1619. + 
  1620. +         return status >> 8;
  1621. +     }
  1622. +     close (2);
  1623. +     open ("/dev/null", O_WRONLY);
  1624. +     execl ("/bin/rmdir", "rmdir", dir, 0);
  1625. +     _exit (128);
  1626. + }
  1627. + #endif
  1628. + 
  1629. + /*
  1630. +  * del_list - delete a member from a list of group members
  1631. +  *
  1632. +  *    the array of member names is searched for the old member
  1633. +  *    name, and if present it is deleted from a freshly allocated
  1634. +  *    list of users.
  1635. +  */
  1636. + 
  1637. + char **
  1638. + del_list (list, member)
  1639. + char    **list;
  1640. + char    *member;
  1641. + {
  1642. +     int    i, j;
  1643. +     char    **tmp;
  1644. + 
  1645. +     /*
  1646. +      * Scan the list for the new name.  Return the original list
  1647. +      * pointer if it is present.
  1648. +      */
  1649. + 
  1650. +     for (i = j = 0;list[i] != (char *) 0;i++)
  1651. +         if (strcmp (list[i], member))
  1652. +             j++;
  1653. + 
  1654. +     if (j == i)
  1655. +         return list;
  1656. + 
  1657. +     /*
  1658. +      * Allocate a new list pointer large enough to hold all the
  1659. +      * old entries, and the new entries as well.
  1660. +      */
  1661. + 
  1662. +     if (! (tmp = (char **) malloc ((j + 2) * sizeof member)))
  1663. +         return 0;
  1664. + 
  1665. +     /*
  1666. +      * Copy the original list to the new list, then append the
  1667. +      * new member and NULL terminate the result.  This new list
  1668. +      * is returned to the invoker.
  1669. +      */
  1670. + 
  1671. +     for (i = j = 0;list[i] != (char *) 0;i++)
  1672. +         if (strcmp (list[i], member))
  1673. +             tmp[j++] = list[i];
  1674. + 
  1675. +     tmp[j] = (char *) 0;
  1676. + 
  1677. +     return tmp;
  1678. + }
  1679. + 
  1680. + /*
  1681. +  * usage - display usage message and exit
  1682. +  */
  1683. + 
  1684. + usage ()
  1685. + {
  1686. +     fprintf (stderr, "usage: userdel [-r] name\n");
  1687. +     exit (1);
  1688. + }
  1689. + 
  1690. + /*
  1691. +  * update_groups - delete user from secondary group set
  1692. +  *
  1693. +  *    update_groups() takes the user name that was given and searches
  1694. +  *    the group files for membership in any group.
  1695. +  */
  1696. + 
  1697. + void
  1698. + update_groups ()
  1699. + {
  1700. +     int    i;
  1701. +     struct    group    *grp;
  1702. + #ifdef    SHADOWGRP
  1703. +     struct    sgrp    *sgrp;
  1704. + #endif
  1705. + 
  1706. +     /*
  1707. +      * Scan through the entire group file looking for the groups that
  1708. +      * the user is a member of.
  1709. +      */
  1710. + 
  1711. +     for (gr_rewind (), grp = gr_next ();grp;grp = gr_next ()) {
  1712. + 
  1713. +         /*
  1714. +          * See if the user specified this group as one of their
  1715. +          * concurrent groups.
  1716. +          */
  1717. + 
  1718. +         for (i = 0;grp->gr_mem[i];i++)
  1719. +             if (strcmp (grp->gr_mem[i], user_name) == 0)
  1720. +                 break;
  1721. + 
  1722. +         if (grp->gr_mem[i] == (char *) 0)
  1723. +             continue;
  1724. + 
  1725. +         /* 
  1726. +          * Delete the username from the list of group members and
  1727. +          * update the group entry to reflect the change.
  1728. +          */
  1729. + 
  1730. +         grp->gr_mem = del_list (grp->gr_mem, user_name);
  1731. +         if (! gr_update (grp)) {
  1732. +             fprintf (stderr, "%s: error updating group entry\n",
  1733. +                 Prog);
  1734. +             exit (1);
  1735. +         }
  1736. + #ifdef    NDBM
  1737. +         /*
  1738. +          * Update the DBM group file with the new entry as well.
  1739. +          */
  1740. + 
  1741. +         if (! gr_dbm_update (grp)) {
  1742. +             fprintf (stderr, "%s: cannot update dbm group entry\n",
  1743. +                 Prog);
  1744. +             exit (1);
  1745. +         }
  1746. + #endif
  1747. +     }
  1748. + 
  1749. + #ifdef    SHADOWGRP
  1750. +     /*
  1751. +      * Scan through the entire shadow group file looking for the groups
  1752. +      * that the user is a member of.  Both the administrative list and
  1753. +      * the ordinary membership list is checked.
  1754. +      */
  1755. + 
  1756. +     for (sgr_rewind (), sgrp = sgr_next ();sgrp;sgrp = sgr_next ()) {
  1757. +         int    group_changed = 0;
  1758. + 
  1759. +         /*
  1760. +          * See if the user specified this group as one of their
  1761. +          * concurrent groups.
  1762. +          */
  1763. + 
  1764. +         for (i = 0;sgrp->sg_mem[i];i++)
  1765. +             if (strcmp (sgrp->sg_mem[i], user_name) == 0)
  1766. +                 break;
  1767. + 
  1768. +         if (sgrp->sg_mem[i]) {
  1769. +             sgrp->sg_mem = del_list (sgrp->sg_mem, user_name);
  1770. +             group_changed = 1;
  1771. +         }
  1772. +         for (i = 0;sgrp->sg_adm[i];i++)
  1773. +             if (strcmp (sgrp->sg_adm[i], user_name) == 0)
  1774. +                 break;
  1775. + 
  1776. +         if (sgrp->sg_adm[i]) {
  1777. +             sgrp->sg_adm = del_list (sgrp->sg_adm, user_name);
  1778. +             group_changed = 1;
  1779. +         }
  1780. +         if (! group_changed)
  1781. +             continue;
  1782. + 
  1783. +         if (! sgr_update (sgrp)) {
  1784. +             fprintf (stderr, "%s: error updating group entry\n",
  1785. +                 Prog);
  1786. +             exit (1);
  1787. +         }
  1788. + #ifdef    NDBM
  1789. +         /*
  1790. +          * Update the DBM group file with the new entry as well.
  1791. +          */
  1792. + 
  1793. +         if (! sgr_dbm_update (sgrp)) {
  1794. +             fprintf (stderr, "%s: cannot update dbm group entry\n",
  1795. +                 Prog);
  1796. +             exit (1);
  1797. +         }
  1798. + #endif
  1799. +     }
  1800. + #endif
  1801. + }
  1802. + 
  1803. + /*
  1804. +  * close_files - close all of the files that were opened
  1805. +  *
  1806. +  *    close_files() closes all of the files that were opened for this
  1807. +  *    new user.  This causes any modified entries to be written out.
  1808. +  */
  1809. + 
  1810. + close_files ()
  1811. + {
  1812. +     if (! pw_close ()) {
  1813. +         fprintf (stderr, "%s: cannot rewrite password file\n", Prog);
  1814. +         exit (1);
  1815. +     }
  1816. +     if (! spw_close ()) {
  1817. +         fprintf (stderr, "%s: cannot rewrite shadow password file\n",    
  1818. +             Prog);
  1819. +         exit (1);
  1820. +     }
  1821. +     if (! gr_close ()) {
  1822. +         fprintf (stderr, "%s: cannot rewrite group file\n",
  1823. +             Prog);
  1824. +         exit (1);
  1825. +     }
  1826. +     (void) gr_unlock ();
  1827. + #ifdef    SHADOWGRP
  1828. +     if (! sgr_close ()) {
  1829. +         fprintf (stderr, "%s: cannot rewrite shadow group file\n",
  1830. +             Prog);
  1831. +         exit (1);
  1832. +     }
  1833. +     (void) sgr_unlock ();
  1834. + #endif
  1835. +     (void) pw_unlock ();
  1836. + }
  1837. + 
  1838. + /*
  1839. +  * open_files - lock and open the password files
  1840. +  *
  1841. +  *    open_files() opens the two password files.
  1842. +  */
  1843. + 
  1844. + open_files ()
  1845. + {
  1846. +     if (! pw_lock ()) {
  1847. +         fprintf (stderr, "%s: unable to lock password file\n", Prog);
  1848. +         exit (1);
  1849. +     }
  1850. +     if (! pw_open (O_RDWR)) {
  1851. +         fprintf (stderr, "%s: unable to open password file\n", Prog);
  1852. +         exit (1);
  1853. +     }
  1854. +     if (! spw_lock ()) {
  1855. +         fprintf ("%s: cannot lock shadow password file\n", Prog);
  1856. +         exit (1);
  1857. +     }
  1858. +     if (! spw_open (O_RDWR)) {
  1859. +         fprintf ("%s: cannot open shadow password file\n", Prog);
  1860. +         exit (1);
  1861. +     }
  1862. +     if (! gr_lock ()) {
  1863. +         fprintf (stderr, "%s: unable to lock group file\n", Prog);
  1864. +         exit (1);
  1865. +     }
  1866. +     if (! gr_open (O_RDWR)) {
  1867. +         fprintf (stderr, "%s: cannot open group file\n", Prog);
  1868. +         exit (1);
  1869. +     }
  1870. + #ifdef    SHADOWGRP
  1871. +     if (! sgr_lock ()) {
  1872. +         fprintf (stderr, "%s: unable to lock shadow group file\n", Prog);
  1873. +         exit (1);
  1874. +     }
  1875. +     if (! sgr_open (O_RDWR)) {
  1876. +         fprintf (stderr, "%s: cannot open shadow group file\n", Prog);
  1877. +         exit (1);
  1878. +     }
  1879. + #endif
  1880. + }
  1881. + 
  1882. + /*
  1883. +  * update_user - delete the user entries
  1884. +  *
  1885. +  *    update_user() deletes the password file entries for this user
  1886. +  *    and will update the group entries as required.
  1887. +  */
  1888. + 
  1889. + update_user ()
  1890. + {
  1891. +     struct    passwd    *pwd;
  1892. + 
  1893. +     if (! pw_remove (user_name))
  1894. +         fprintf (stderr, "%s: error deleting password entry\n", Prog);
  1895. + 
  1896. +     if (! spw_remove (user_name))
  1897. +         fprintf (stderr, "%s: error deleting shadow password entry\n",
  1898. +             Prog);
  1899. + 
  1900. + #if defined(DBM) || defined(NDBM)
  1901. +     if (access ("/etc/passwd.pag", 0) == 0) {
  1902. +         if ((pwd = getpwnam (user_name)) && ! pw_dbm_remove (pwd))
  1903. +             fprintf (stderr,
  1904. +                 "%s: error deleting password dbm entry\n",
  1905. +                 Prog);
  1906. +     }
  1907. + 
  1908. +     /*
  1909. +      * If the user's UID is a duplicate the duplicated entry needs
  1910. +      * to be updated so that a UID match can be found in the DBM
  1911. +      * files.
  1912. +      */
  1913. + 
  1914. +     for (pw_rewind (), pwd = pw_next ();pwd;pwd = pw_next ()) {
  1915. +         if (pwd->pw_uid == user_id) {
  1916. +             pw_dbm_update (pwd);
  1917. +             break;
  1918. +         }
  1919. +     }
  1920. + #endif
  1921. + #ifdef    NDBM
  1922. +     if (access ("/etc/shadow.pag", 0) == 0 && ! sp_dbm_remove (user_name))
  1923. +         fprintf (stderr, "%s: error deleting shadow passwd dbm entry\n",
  1924. +             Prog);
  1925. + #endif
  1926. + }
  1927. + 
  1928. + /*
  1929. +  * main - useradd command
  1930. +  */
  1931. + 
  1932. + main (argc, argv)
  1933. + int    argc;
  1934. + char    **argv;
  1935. + {
  1936. +     struct    passwd    *pwd;
  1937. +     int    arg;
  1938. +     extern    int    optind;
  1939. +     extern    char    *optarg;
  1940. + 
  1941. +     /*
  1942. +      * Get my name so that I can use it to report errors.
  1943. +      */
  1944. + 
  1945. +     if (Prog = strrchr (argv[0], '/'))
  1946. +         Prog++;
  1947. +     else
  1948. +         Prog = argv[0];
  1949. + 
  1950. + #ifdef    USE_SYSLOG
  1951. +     openlog (Prog, LOG_PID|LOG_CONS|LOG_NOWAIT, LOG_AUTH);
  1952. + #endif
  1953. + 
  1954. +     /*
  1955. +      * The open routines for the DBM files don't use read-write
  1956. +      * as the mode, so we have to clue them in.
  1957. +      */
  1958. + 
  1959. + #if defined(DBM) || defined(NDBM)
  1960. +     pw_dbm_mode = O_RDWR;
  1961. + #endif
  1962. + #ifdef    NDBM
  1963. +     sp_dbm_mode = O_RDWR;
  1964. +     gr_dbm_mode = O_RDWR;
  1965. + #ifdef    SHADOWGRP
  1966. +     sg_dbm_mode = O_RDWR;
  1967. + #endif
  1968. + #endif
  1969. +     while ((arg = getopt (argc, argv, "r")) != EOF)
  1970. +         if (arg != 'r')
  1971. +             usage ();
  1972. +         else
  1973. +             rflg++;
  1974. +     
  1975. +     if (optind == argc)
  1976. +         usage ();
  1977. + 
  1978. +     /*
  1979. +      * Start with a quick check to see if the user exists.
  1980. +      */
  1981. + 
  1982. +     strncpy (user_name, argv[argc - 1], BUFSIZ);
  1983. + 
  1984. +     if (! (pwd = getpwnam (user_name))) {
  1985. +         fprintf (stderr, "%s: user %s does not exist\n",
  1986. +             Prog, user_name);
  1987. +         exit (1);
  1988. +     }
  1989. +     user_id = pwd->pw_uid;
  1990. +     strcpy (user_home, pwd->pw_dir);
  1991. + 
  1992. +     /*
  1993. +      * Do the hard stuff - open the files, create the user entries,
  1994. +      * create the home directory, then close and update the files.
  1995. +      */
  1996. + 
  1997. +     open_files ();
  1998. + 
  1999. +     update_user ();
  2000. +     update_groups ();
  2001. + 
  2002. +     if (rflg)
  2003. +         rmdir (user_home);
  2004. + 
  2005. +     close_files ();
  2006. +     exit (0);
  2007. +     /*NOTREACHED*/
  2008. + }
  2009. *** /dev/null    Fri Jun  7 11:02:59 1991
  2010. --- usermod.c    Fri Jun  7 11:10:08 1991
  2011. ***************
  2012. *** 0 ****
  2013. --- 1,1149 ----
  2014. + /*
  2015. +  * Copyright 1991, John F. Haugh II
  2016. +  * All rights reserved.
  2017. +  *
  2018. +  * Permission is granted to copy and create derivative works for any
  2019. +  * non-commercial purpose, provided this copyright notice is preserved
  2020. +  * in all copies of source code, or included in human readable form
  2021. +  * and conspicuously displayed on all copies of object code or
  2022. +  * distribution media.
  2023. +  */
  2024. + 
  2025. + #ifndef lint
  2026. + static    char    sccsid[] = "@(#)usermod.c    3.1    11:08:35    6/7/91";
  2027. + #endif
  2028. + 
  2029. + #include <sys/types.h>
  2030. + #include <sys/stat.h>
  2031. + #include <stdio.h>
  2032. + #include <errno.h>
  2033. + #include <pwd.h>
  2034. + #include <grp.h>
  2035. + #include <ctype.h>
  2036. + #include <fcntl.h>
  2037. + #include <time.h>
  2038. + 
  2039. + #ifdef    BSD
  2040. + #include <strings.h>
  2041. + #else
  2042. + #include <string.h>
  2043. + #endif
  2044. + 
  2045. + #include "config.h"
  2046. + #include "shadow.h"
  2047. + 
  2048. + #ifdef    USE_SYSLOG
  2049. + #include <syslog.h>
  2050. + 
  2051. + #ifndef    LOG_WARN
  2052. + #define    LOG_WARN LOG_WARNING
  2053. + #endif
  2054. + #endif
  2055. + 
  2056. + #ifndef    NGROUPS_MAX
  2057. + #define    NGROUPS_MAX    64
  2058. + #endif
  2059. + 
  2060. + char    user_name[BUFSIZ];
  2061. + char    user_newname[BUFSIZ];
  2062. + uid_t    user_id;
  2063. + uid_t    user_newid;
  2064. + gid_t    user_gid;
  2065. + char    user_comment[BUFSIZ];
  2066. + char    user_home[BUFSIZ];
  2067. + char    user_newhome[BUFSIZ];
  2068. + char    user_shell[BUFSIZ];
  2069. + long    user_expire;
  2070. + long    user_inactive;
  2071. + int    user_ngroups;
  2072. + gid_t    user_groups[NGROUPS_MAX];
  2073. + struct    passwd    user_pwd;
  2074. + struct    spwd    user_spwd;
  2075. + 
  2076. + char    *Prog;
  2077. + 
  2078. + int    uflg;    /* specify user ID for new account                            */
  2079. + int    oflg;    /* permit non-unique user ID to be specified with -u          */
  2080. + int    gflg;    /* primary group ID  for new account                          */
  2081. + int    Gflg;    /* secondary group set for new account                        */
  2082. + int    dflg;    /* home directory for new account                             */
  2083. + int    sflg;    /* shell program for new account                              */
  2084. + int    cflg;    /* comment (GECOS) field for new account                      */
  2085. + int    mflg;    /* create user's home directory if it doesn't exist           */
  2086. + int    fflg;    /* days until account with expired password is locked         */
  2087. + int    eflg;    /* days after password changed before it becomes expired      */
  2088. + int    lflg;    /* new user name for user                                     */
  2089. + 
  2090. + #if defined(DBM) || defined(NDBM)
  2091. + extern    int    pw_dbm_mode;
  2092. + #endif
  2093. + #ifdef    NDBM
  2094. + extern    int    sp_dbm_mode;
  2095. + extern    int    gr_dbm_mode;
  2096. + extern    int    sg_dbm_mode;
  2097. + #endif
  2098. + extern    FILE    *fopen();
  2099. + extern    int    fclose();
  2100. + extern    char    *malloc();
  2101. + extern    char    *mktemp();
  2102. + 
  2103. + extern    struct    group    *getgrnam();
  2104. + extern    struct    group    *getgrgid();
  2105. + extern    struct    group    *gr_next();
  2106. + extern    struct    group    *gr_locate();
  2107. + extern    int    gr_lock();
  2108. + extern    int    gr_unlock();
  2109. + extern    int    gr_rewind();
  2110. + extern    int    gr_open();
  2111. + 
  2112. + #ifdef    SHADOWGRP
  2113. + extern    struct    sgrp    *sgr_next();
  2114. + extern    int    sgr_lock();
  2115. + extern    int    sgr_unlock();
  2116. + extern    int    sgr_rewind();
  2117. + extern    int    sgr_open();
  2118. + #endif
  2119. + 
  2120. + extern    struct    passwd    *getpwnam();
  2121. + extern    struct    passwd    *pw_next();
  2122. + extern    struct    passwd    *pw_locate();
  2123. + extern    int    pw_lock();
  2124. + extern    int    pw_unlock();
  2125. + extern    int    pw_rewind();
  2126. + extern    int    pw_open();
  2127. + 
  2128. + extern    int    spw_lock();
  2129. + extern    int    spw_unlock();
  2130. + extern    int    spw_open();
  2131. + extern    int    spw_locate();
  2132. + 
  2133. + #define    DAY    (24L*3600L)
  2134. + #define    WEEK    (7*DAY)
  2135. + 
  2136. + #ifdef    ITI_AGING
  2137. + #define    SCALE    (1)
  2138. + #else
  2139. + #define    SCALE    (DAY)
  2140. + #endif
  2141. + 
  2142. + /*
  2143. +  * days and juldays are used to compute the number of days in the
  2144. +  * current month, and the cummulative number of days in the preceding
  2145. +  * months.  they are declared so that january is 1, not 0.
  2146. +  */
  2147. + 
  2148. + static    short    days[13] = { 0,
  2149. +     31,    28,    31,    30,    31,    30,    /* JAN - JUN */
  2150. +     31,    31,    30,    31,    30,    31 };    /* JUL - DEC */
  2151. + 
  2152. + static    short    juldays[13] = { 0,
  2153. +     0,    31,    59,    90,    120,    151,    /* JAN - JUN */
  2154. +     181,    212,    243,    273,    304,    334 };    /* JUL - DEC */
  2155. + 
  2156. + #ifdef    NEED_MKDIR
  2157. + /*
  2158. +  * mkdir - create a directory
  2159. +  *
  2160. +  *    mkdir is provided for systems which do not include the mkdir()
  2161. +  *    system call.
  2162. +  */
  2163. + 
  2164. + int
  2165. + mkdir (dir, mode)
  2166. + char    *dir;
  2167. + int    mode;
  2168. + {
  2169. +     int    status;
  2170. + 
  2171. +     if (fork ()) {
  2172. +         while (wait (&status) != -1)
  2173. +             ;
  2174. + 
  2175. +         return status >> 8;
  2176. +     }
  2177. + #ifdef    USE_SYSLOG
  2178. +     closelog ();
  2179. + #endif
  2180. +     close (2);
  2181. +     open ("/dev/null", O_WRONLY);
  2182. +     umask (0777 & ~ mode);
  2183. +     execl ("/bin/mkdir", "mkdir", dir, 0);
  2184. +     _exit (128);
  2185. + }
  2186. + #endif
  2187. + #ifdef    NEED_RENAME
  2188. + /*
  2189. +  * rename - rename a file to another name
  2190. +  *
  2191. +  *    rename is provided for systems which do not include the rename()
  2192. +  *    system call.
  2193. +  */
  2194. + 
  2195. + int
  2196. + rename (begin, end)
  2197. + char    *begin;
  2198. + char    *end;
  2199. + {
  2200. +     struct    stat    s1, s2;
  2201. +     extern    int    errno;
  2202. +     int    orig_err = errno;
  2203. + 
  2204. +     if (stat (begin, &s1))
  2205. +         return -1;
  2206. + 
  2207. +     if (stat (end, &s2)) {
  2208. +         errno = orig_err;
  2209. +     } else {
  2210. + 
  2211. +         /*
  2212. +          * See if this is a cross-device link.  We do this to
  2213. +          * insure that the link below has a chance of working.
  2214. +          */
  2215. + 
  2216. +         if (s1.st_dev != s2.st_dev) {
  2217. +             errno = EXDEV;
  2218. +             return -1;
  2219. +         }
  2220. + 
  2221. +         /*
  2222. +          * See if we can unlink the existing destination
  2223. +          * file.  If the unlink works the directory is writable,
  2224. +          * so there is no need here to figure that out.
  2225. +          */
  2226. + 
  2227. +         if (unlink (end))
  2228. +             return -1;
  2229. +     }
  2230. + 
  2231. +     /*
  2232. +      * Now just link the original name to the final name.  If there
  2233. +      * was no file previously, this link will fail if the target
  2234. +      * directory isn't writable.  The unlink will fail if the source
  2235. +      * directory isn't writable, but life stinks ...
  2236. +      */
  2237. + 
  2238. +     if (link (begin, end) || unlink (begin))
  2239. +         return -1;
  2240. + 
  2241. +     return 0;
  2242. + }
  2243. + #endif
  2244. + 
  2245. + /*
  2246. +  * strtoday - compute the number of days since 1970.
  2247. +  *
  2248. +  * the total number of days prior to the current date is
  2249. +  * computed.  january 1, 1970 is used as the origin with
  2250. +  * it having a day number of 0.
  2251. +  */
  2252. + 
  2253. + long
  2254. + strtoday (str)
  2255. + char    *str;
  2256. + {
  2257. +     char    slop[2];
  2258. +     int    month;
  2259. +     int    day;
  2260. +     int    year;
  2261. +     long    total;
  2262. + 
  2263. +     /*
  2264. +      * start by separating the month, day and year.  this is
  2265. +      * a chauvanistic program - it only takes date input in
  2266. +      * the standard USA format.
  2267. +      */
  2268. + 
  2269. +     if (sscanf (str, "%d/%d/%d%c", &month, &day, &year, slop) != 3)
  2270. +         return -1;
  2271. + 
  2272. +     /*
  2273. +      * the month, day of the month, and year are checked for
  2274. +      * correctness and the year adjusted so it falls between
  2275. +      * 1970 and 2069.
  2276. +      */
  2277. + 
  2278. +     if (month < 1 || month > 12)
  2279. +         return -1;
  2280. + 
  2281. +     if (day < 1)
  2282. +         return -1;
  2283. + 
  2284. +     if ((month != 2 || (year % 4) != 0) && day > days[month])
  2285. +         return -1;
  2286. +     else if ((month == 2 && (year % 4) == 0) && day > 29)
  2287. +         return -1;
  2288. + 
  2289. +     if (year < 0)
  2290. +         return -1;
  2291. +     else if (year < 69)
  2292. +         year += 2000;
  2293. +     else if (year < 99)
  2294. +         year += 1900;
  2295. + 
  2296. +     if (year < 1970 || year > 2069)
  2297. +         return -1;
  2298. + 
  2299. +     /*
  2300. +      * the total number of days is the total number of days in all
  2301. +      * the whole years, plus the number of leap days, plus the
  2302. +      * number of days in the whole months preceding, plus the number
  2303. +      * of days so far in the month.
  2304. +      */
  2305. + 
  2306. +     total = (long) ((year - 1970) * 365L) + (((year + 1) - 1970) / 4);
  2307. +     total += (long) juldays[month] + (month > 2 && (year % 4) == 0 ? 1:0);
  2308. +     total += (long) day - 1;
  2309. + 
  2310. +     return total;
  2311. + }
  2312. + 
  2313. + /*
  2314. +  * add_list - add a member to a list of group members
  2315. +  *
  2316. +  *    the array of member names is searched for the new member
  2317. +  *    name, and if not present it is added to a freshly allocated
  2318. +  *    list of users.
  2319. +  */
  2320. + 
  2321. + char **
  2322. + add_list (list, member)
  2323. + char    **list;
  2324. + char    *member;
  2325. + {
  2326. +     int    i;
  2327. +     char    **tmp;
  2328. + 
  2329. +     /*
  2330. +      * Scan the list for the new name.  Return the original list
  2331. +      * pointer if it is present.
  2332. +      */
  2333. + 
  2334. +     for (i = 0;list[i] != (char *) 0;i++)
  2335. +         if (strcmp (list[i], member) == 0)
  2336. +             return list;
  2337. + 
  2338. +     /*
  2339. +      * Allocate a new list pointer large enough to hold all the
  2340. +      * old entries, and the new entries as well.
  2341. +      */
  2342. + 
  2343. +     if (! (tmp = (char **) malloc ((i + 2) * sizeof member)))
  2344. +         return 0;
  2345. + 
  2346. +     /*
  2347. +      * Copy the original list to the new list, then append the
  2348. +      * new member and NULL terminate the result.  This new list
  2349. +      * is returned to the invoker.
  2350. +      */
  2351. + 
  2352. +     for (i = 0;list[i] != (char *) 0;i++)
  2353. +         tmp[i] = list[i];
  2354. + 
  2355. +     tmp[i++] = strdup (member);
  2356. +     tmp[i] = (char *) 0;
  2357. + 
  2358. +     return tmp;
  2359. + }
  2360. + 
  2361. + /*
  2362. +  * del_list - delete a member from a list of group members
  2363. +  *
  2364. +  *    the array of member names is searched for the old member
  2365. +  *    name, and if present it is deleted from a freshly allocated
  2366. +  *    list of users.
  2367. +  */
  2368. + 
  2369. + char **
  2370. + del_list (list, member)
  2371. + char    **list;
  2372. + char    *member;
  2373. + {
  2374. +     int    i, j;
  2375. +     char    **tmp;
  2376. + 
  2377. +     /*
  2378. +      * Scan the list for the new name.  Return the original list
  2379. +      * pointer if it is present.
  2380. +      */
  2381. + 
  2382. +     for (i = j = 0;list[i] != (char *) 0;i++)
  2383. +         if (strcmp (list[i], member))
  2384. +             j++;
  2385. + 
  2386. +     if (j == i)
  2387. +         return list;
  2388. + 
  2389. +     /*
  2390. +      * Allocate a new list pointer large enough to hold all the
  2391. +      * old entries, and the new entries as well.
  2392. +      */
  2393. + 
  2394. +     if (! (tmp = (char **) malloc ((j + 2) * sizeof member)))
  2395. +         return 0;
  2396. + 
  2397. +     /*
  2398. +      * Copy the original list to the new list, then append the
  2399. +      * new member and NULL terminate the result.  This new list
  2400. +      * is returned to the invoker.
  2401. +      */
  2402. + 
  2403. +     for (i = j = 0;list[i] != (char *) 0;i++)
  2404. +         if (strcmp (list[i], member))
  2405. +             tmp[j++] = list[i];
  2406. + 
  2407. +     tmp[j] = (char *) 0;
  2408. + 
  2409. +     return tmp;
  2410. + }
  2411. + 
  2412. + /*
  2413. +  * get_groups - convert a list of group names to an array of group IDs
  2414. +  *
  2415. +  *    get_groups() takes a comma-separated list of group names and
  2416. +  *    converts it to an array of group ID values.  Any unknown group
  2417. +  *    names are reported as errors.
  2418. +  */
  2419. + 
  2420. + int
  2421. + get_groups (list)
  2422. + char    *list;
  2423. + {
  2424. +     char    *cp;
  2425. +     struct    group    *grp;
  2426. +     int    errors = 0;
  2427. + 
  2428. +     /*
  2429. +      * Initialize the list to be empty
  2430. +      */
  2431. + 
  2432. +     user_ngroups = 0;
  2433. + 
  2434. +     if (! *list)
  2435. +         return 0;
  2436. + 
  2437. +     /*
  2438. +      * So long as there is some data to be converted, strip off
  2439. +      * each name and look it up.  A mix of numerical and string
  2440. +      * values for group identifiers is permitted.
  2441. +      */
  2442. + 
  2443. +     do {
  2444. +         /*
  2445. +          * Strip off a single name from the list
  2446. +          */
  2447. + 
  2448. +         if (cp = strchr (list, ','))
  2449. +             *cp++ = '\0';
  2450. + 
  2451. +         /*
  2452. +          * Names starting with digits are treated as numerical
  2453. +          * GID values, otherwise the string is looked up as is.
  2454. +          */
  2455. + 
  2456. +         if (isdigit (*list))
  2457. +             grp = getgrgid (atoi (list));
  2458. +         else
  2459. +             grp = getgrnam (list);
  2460. + 
  2461. +         /*
  2462. +          * There must be a match, either by GID value or by
  2463. +          * string name.
  2464. +          */
  2465. + 
  2466. +         if (! grp) {
  2467. +             fprintf (stderr, "%s: unknown group %s\n", Prog, list);
  2468. +             errors++;
  2469. +         }
  2470. + 
  2471. +         /*
  2472. +          * Add the GID value from the group file to the user's
  2473. +          * list of groups.
  2474. +          */
  2475. + 
  2476. +         user_groups[user_ngroups++] = grp->gr_gid;
  2477. + 
  2478. +         list = cp;
  2479. +     } while (list);
  2480. + 
  2481. +     /*
  2482. +      * Any errors in finding group names are fatal
  2483. +      */
  2484. + 
  2485. +     if (errors)
  2486. +         return -1;
  2487. + 
  2488. +     return 0;
  2489. + }
  2490. + 
  2491. + /*
  2492. +  * usage - display usage message and exit
  2493. +  */
  2494. + 
  2495. + usage ()
  2496. + {
  2497. +     fprintf (stderr,
  2498. +         "usage: %s [-u uid [-o]] [-g group] [-G group,...] \n", Prog);
  2499. +     fprintf (stderr,
  2500. +         "\t\t[-d home [-m]] [-s shell] [-c comment] [-l new_name]\n");
  2501. +     fprintf (stderr,
  2502. +         "\t\t[-f inactive] [-e expire] name\n");
  2503. + 
  2504. +     exit (2);
  2505. + }
  2506. + 
  2507. + /*
  2508. +  * new_pwent - initialize the values in a password file entry
  2509. +  *
  2510. +  *    new_pwent() takes all of the values that have been entered and
  2511. +  *    fills in a (struct passwd) with them.
  2512. +  */
  2513. + 
  2514. + void
  2515. + new_pwent (pwent)
  2516. + struct    passwd    *pwent;
  2517. + {
  2518. +     if (lflg)
  2519. +         pwent->pw_name = strdup (user_newname);
  2520. + 
  2521. +     if (uflg)
  2522. +         pwent->pw_uid = user_newid;
  2523. + 
  2524. +     if (gflg)
  2525. +         pwent->pw_gid = user_gid;
  2526. + 
  2527. +     if (cflg)
  2528. +         pwent->pw_gecos = strdup (user_comment);
  2529. + 
  2530. +     if (dflg)
  2531. +         pwent->pw_dir = strdup (user_newhome);
  2532. + 
  2533. +     if (sflg)
  2534. +         pwent->pw_shell = strdup (user_shell);
  2535. + }
  2536. + 
  2537. + /*
  2538. +  * new_spent - initialize the values in a shadow password file entry
  2539. +  *
  2540. +  *    new_spent() takes all of the values that have been entered and
  2541. +  *    fills in a (struct spwd) with them.
  2542. +  */
  2543. + 
  2544. + void
  2545. + new_spent (spent)
  2546. + struct    spwd    *spent;
  2547. + {
  2548. +     if (lflg)
  2549. +         spent->sp_namp = strdup (user_newname);
  2550. + 
  2551. +     spent->sp_inact = user_inactive;
  2552. +     spent->sp_expire = user_expire;
  2553. + }
  2554. + 
  2555. + /*
  2556. +  * grp_update - add user to secondary group set
  2557. +  *
  2558. +  *    grp_update() takes the secondary group set given in user_groups
  2559. +  *    and adds the user to each group given by that set.
  2560. +  */
  2561. + 
  2562. + void
  2563. + grp_update ()
  2564. + {
  2565. +     int    i;
  2566. +     int    is_member;
  2567. +     int    was_member;
  2568. +     int    was_admin;
  2569. +     struct    group    *grp;
  2570. +     struct    sgrp    *sgrp;
  2571. + 
  2572. +     /*
  2573. +      * Lock and open the group file.  This will load all of the group
  2574. +      * entries.
  2575. +      */
  2576. + 
  2577. +     if (! gr_lock ()) {
  2578. +         fprintf (stderr, "%s: error locking group file\n", Prog);
  2579. +         exit (1);
  2580. +     }
  2581. +     if (! gr_open (O_RDWR)) {
  2582. +         fprintf (stderr, "%s: error opening group file\n", Prog);
  2583. +         exit (1);
  2584. +     }
  2585. + #ifdef    SHADOWGRP
  2586. +     if (! sgr_lock ()) {
  2587. +         fprintf (stderr, "%s: error locking shadow group file\n", Prog);
  2588. +         exit (1);
  2589. +     }
  2590. +     if (! sgr_open (O_RDWR)) {
  2591. +         fprintf (stderr, "%s: error opening shadow group file\n", Prog);
  2592. +         exit (1);
  2593. +     }
  2594. + #endif
  2595. + 
  2596. +     /*
  2597. +      * Scan through the entire group file looking for the groups that
  2598. +      * the user is a member of.
  2599. +      */
  2600. + 
  2601. +     for (gr_rewind (), grp = gr_next ();grp;grp = gr_next ()) {
  2602. + 
  2603. +         /*
  2604. +          * See if the user specified this group as one of their
  2605. +          * concurrent groups.
  2606. +          */
  2607. + 
  2608. +         for (i = 0;i < user_ngroups;i++)
  2609. +             if (grp->gr_gid == user_groups[i])
  2610. +                 break;
  2611. + 
  2612. +         is_member = i == user_ngroups ? -1:i;
  2613. + 
  2614. +         for (i = 0;grp->gr_mem[i];i++)
  2615. +             if (strcmp (user_name, grp->gr_mem[i]) == 0)
  2616. +                 break;
  2617. + 
  2618. +         was_member = grp->gr_mem[i] ? i:-1;
  2619. + 
  2620. +         if (is_member == -1 && was_member == -1)
  2621. +             continue;
  2622. + 
  2623. +         if (was_member >= 0 && (! Gflg || is_member >= 0)) {
  2624. +             if (lflg) {
  2625. +                 grp->gr_mem = del_list (grp->gr_mem,
  2626. +                     user_name);
  2627. +                 grp->gr_mem = add_list (grp->gr_mem,
  2628. +                     user_newname);
  2629. + #ifdef    USE_SYSLOG
  2630. +                 syslog (LOG_INFO,
  2631. +                     "change `%s' to `%s' in group `%s'\n",
  2632. +                     user_name, user_newname, grp->gr_name);
  2633. + #endif
  2634. +             }
  2635. +         } else if (was_member >= 0 && Gflg && is_member < 0) {
  2636. +             grp->gr_mem = del_list (grp->gr_mem, user_name);
  2637. + #ifdef    USE_SYSLOG
  2638. +             syslog (LOG_INFO, "delete `%s' from group `%s'\n",
  2639. +                 user_name, grp->gr_name);
  2640. + #endif
  2641. +         } else if (was_member < 0 && Gflg && is_member >= 0) {
  2642. +             grp->gr_mem = add_list (grp->gr_mem,
  2643. +                 lflg ? user_newname:user_name);
  2644. + #ifdef    USE_SYSLOG
  2645. +             syslog (LOG_INFO, "add `%s' to group `%s'\n",
  2646. +                 lflg ? user_newname:user_name, grp->gr_name);
  2647. + #endif
  2648. +         } else
  2649. +             continue;
  2650. + 
  2651. +         if (! gr_update (grp)) {
  2652. +             fprintf (stderr, "%s: error adding new group entry\n",
  2653. +                 Prog);
  2654. +             exit (1);
  2655. +         }
  2656. + #ifdef    NDBM
  2657. +         /*
  2658. +          * Update the DBM group file with the new entry as well.
  2659. +          */
  2660. + 
  2661. +         if (! gr_dbm_update (grp)) {
  2662. +             fprintf (stderr, "%s: cannot add new dbm group entry\n",
  2663. +                 Prog);
  2664. +             exit (1);
  2665. +         }
  2666. + #endif
  2667. +     }
  2668. + 
  2669. + #ifdef    SHADOWGRP
  2670. +     /*
  2671. +      * Scan through the entire shadow group file looking for the groups
  2672. +      * that the user is a member of.
  2673. +      */
  2674. + 
  2675. +     for (sgr_rewind (), sgrp = sgr_next ();sgrp;sgrp = sgr_next ()) {
  2676. + 
  2677. +         /*
  2678. +          * See if the user was a member of this group
  2679. +          */
  2680. + 
  2681. +         for (i = 0;sgrp->sg_mem[i];i++)
  2682. +             if (strcmp (sgrp->sg_mem[i], user_name) == 0)
  2683. +                 break;
  2684. + 
  2685. +         was_member = sgrp->sg_mem[i] ? i:-1;
  2686. + 
  2687. +         /*
  2688. +          * See if the user was an administrator of this group
  2689. +          */
  2690. + 
  2691. +         for (i = 0;sgrp->sg_adm[i];i++)
  2692. +             if (strcmp (sgrp->sg_adm[i], user_name) == 0)
  2693. +                 break;
  2694. + 
  2695. +         was_admin = sgrp->sg_adm[i] ? i:-1;
  2696. + 
  2697. +         /*
  2698. +          * See if the user specified this group as one of their
  2699. +          * concurrent groups.
  2700. +          */
  2701. + 
  2702. +         for (i = 0;i < user_ngroups;i++) {
  2703. +             if (! (grp = gr_locate (sgrp->sg_name)))
  2704. +                 continue;
  2705. + 
  2706. +             if (grp->gr_gid == user_groups[i])
  2707. +                 break;
  2708. +         }
  2709. +         is_member = i == user_ngroups ? -1:i;
  2710. + 
  2711. +         if (is_member == -1 && was_admin == -1 && was_member == -1)
  2712. +             continue;
  2713. + 
  2714. +         if (was_admin >= 0 && lflg) {
  2715. +             sgrp->sg_adm = del_list (sgrp->sg_adm, user_name);
  2716. +             sgrp->sg_adm = add_list (sgrp->sg_adm, user_newname);
  2717. + #ifdef    USE_SYSLOG
  2718. +             syslog (LOG_INFO, "change admin `%s' to `%s' in shadow group `%s'\n",
  2719. +                 user_name, user_newname, sgrp->sg_name);
  2720. + #endif
  2721. +         }
  2722. +         if (was_member >= 0 && (! Gflg || is_member >= 0)) {
  2723. +             if (lflg) {
  2724. +                 sgrp->sg_mem = del_list (sgrp->sg_mem,
  2725. +                     user_name);
  2726. +                 sgrp->sg_mem = add_list (sgrp->sg_mem,
  2727. +                     user_newname);
  2728. + #ifdef    USE_SYSLOG
  2729. +                 syslog (LOG_INFO, "change `%s' to `%s' in shadow group `%s'\n",
  2730. +                     user_name, user_newname, sgrp->sg_name);
  2731. + #endif
  2732. +             }
  2733. +         } else if (was_member >= 0 && Gflg && is_member < 0) {
  2734. +             sgrp->sg_mem = del_list (sgrp->sg_mem, user_name);
  2735. + #ifdef    USE_SYSLOG
  2736. +             syslog (LOG_INFO, "delete `%s' from shadow group `%s'\n",
  2737. +                 user_name, sgrp->sg_name);
  2738. + #endif
  2739. +         } else if (was_member < 0 && Gflg && is_member >= 0) {
  2740. +             sgrp->sg_mem = add_list (sgrp->sg_mem,
  2741. +                 lflg ? user_newname:user_name);
  2742. + #ifdef    USE_SYSLOG
  2743. +             syslog (LOG_INFO, "add `%s' to shadow group `%s'\n",
  2744. +                 lflg ? user_newname:user_name, grp->gr_name);
  2745. + #endif
  2746. +         } else
  2747. +             continue;
  2748. + 
  2749. +         /* 
  2750. +          * Update the group entry to reflect the changes.
  2751. +          */
  2752. + 
  2753. +         if (! sgr_update (sgrp)) {
  2754. +             fprintf (stderr, "%s: error adding new group entry\n",
  2755. +                 Prog);
  2756. +             exit (1);
  2757. +         }
  2758. + #ifdef    NDBM
  2759. +         /*
  2760. +          * Update the DBM group file with the new entry as well.
  2761. +          */
  2762. + 
  2763. +         if (! sgr_dbm_update (sgrp)) {
  2764. +             fprintf (stderr, "%s: cannot add new dbm group entry\n",
  2765. +                 Prog);
  2766. +             exit (1);
  2767. +         }
  2768. + #endif
  2769. +     }
  2770. + #endif
  2771. + }
  2772. + 
  2773. + /*
  2774. +  * check_new_id - verify the new UID for uniqueness
  2775. +  *
  2776. +  *    check_new_id() insures that the new UID does not exist already.
  2777. +  *    It does this by checking that the UID has changed and that there
  2778. +  *    is no current entry for this user ID.
  2779. +  */
  2780. + 
  2781. + int
  2782. + check_new_id ()
  2783. + {
  2784. +     /*
  2785. +      * First, the easy stuff.  If the ID can be duplicated, or if
  2786. +      * the ID didn't really change, just return.  If the ID didn't
  2787. +      * change, turn off those flags.  No sense doing needless work.
  2788. +      */
  2789. + 
  2790. +     if (oflg)
  2791. +         return 0;
  2792. + 
  2793. +     if (user_id == user_newid) {
  2794. +         uflg = lflg = 0;
  2795. +         return 0;
  2796. +     }
  2797. +     if (getpwuid (user_newid))
  2798. +         return -1;
  2799. + 
  2800. +     return 0;
  2801. + }
  2802. + 
  2803. + /*
  2804. +  * process_flags - perform command line argument setting
  2805. +  *
  2806. +  *    process_flags() interprets the command line arguments and sets
  2807. +  *    the values that the user will be created with accordingly.  The
  2808. +  *    values are checked for sanity.
  2809. +  */
  2810. + 
  2811. + void
  2812. + process_flags (argc, argv)
  2813. + int    argc;
  2814. + char    **argv;
  2815. + {
  2816. +     extern    int    optind;
  2817. +     extern    char    *optarg;
  2818. +     struct    group    *grp;
  2819. +     struct    passwd    *pwd;
  2820. +     struct    spwd    *spwd;
  2821. +     long    l;
  2822. +     int    anyflag = 0;
  2823. +     int    arg;
  2824. + 
  2825. +     if (argc == 1 || argv[argc - 1][0] == '-')
  2826. +         usage ();
  2827. + 
  2828. +     if (! (pwd = getpwnam (argv[argc - 1]))) {
  2829. +         fprintf (stderr, "%s: user %s does not exist\n",
  2830. +             Prog, argv[argc - 1]);
  2831. +         exit (6);
  2832. +     }
  2833. +     strcpy (user_name, pwd->pw_name);
  2834. +     user_id = pwd->pw_uid;
  2835. +     user_gid = pwd->pw_gid;
  2836. +     strcpy (user_comment, pwd->pw_gecos);
  2837. +     strcpy (user_home, pwd->pw_dir);
  2838. +     strcpy (user_shell, pwd->pw_shell);
  2839. + 
  2840. +     if (spwd = getspnam (user_name)) {
  2841. +         user_expire = spwd->sp_expire;
  2842. +         user_inactive = spwd->sp_inact;
  2843. +     }
  2844. +     while ((arg = getopt (argc, argv, "u:og:G:d:s:c:mf:e:l:")) != EOF) {
  2845. +         switch (arg) {
  2846. +             case 'c':
  2847. +                 if (strcmp (optarg, user_comment)) {
  2848. +                     cflg++;
  2849. +                     strncpy (user_comment, optarg, BUFSIZ);
  2850. +                 }
  2851. +                 break;
  2852. +             case 'd':
  2853. +                 dflg++;
  2854. +                 strncpy (user_newhome, optarg, BUFSIZ);
  2855. +                 break;
  2856. +             case 'e':
  2857. +                 l = strtoday (optarg);
  2858. + #ifdef    ITI_AGING
  2859. +                 l *= DAY;
  2860. + #endif
  2861. +                 if (l != user_expire) {
  2862. +                     eflg++;
  2863. +                     user_expire = l;
  2864. +                 }
  2865. +                 break;
  2866. +             case 'f':
  2867. +                 if (user_inactive != atoi (optarg)) {
  2868. +                     fflg++;
  2869. +                     user_inactive = atoi (optarg);
  2870. +                 }
  2871. +                 break;
  2872. +             case 'g':
  2873. +                 if (isdigit (optarg[0]))
  2874. +                     grp = getgrgid (atoi (optarg));
  2875. +                 else
  2876. +                     grp = getgrnam (optarg);
  2877. + 
  2878. +                 if (! grp) {
  2879. +                     fprintf (stderr,
  2880. +                         "%s: unknown group %s\n",
  2881. +                         optarg);
  2882. +                     exit (1);
  2883. +                 }
  2884. +                 if (grp->gr_gid != user_gid) {
  2885. +                     gflg++;
  2886. +                     user_gid = grp->gr_gid;
  2887. +                 }
  2888. +                 break;
  2889. +             case 'G':
  2890. +                 Gflg++;
  2891. +                 if (get_groups (optarg))
  2892. +                     exit (1);
  2893. + 
  2894. +                 break;
  2895. +             case 'l':
  2896. +                 if (strcmp (user_name, optarg)) {
  2897. +                     lflg++;
  2898. +                     strcpy (user_newname, optarg);
  2899. +                 }
  2900. +                 break;
  2901. +             case 'm':
  2902. +                 if (! dflg)
  2903. +                     usage ();
  2904. + 
  2905. +                 mflg++;
  2906. +                 break;
  2907. +             case 'o':
  2908. +                 if (! uflg)
  2909. +                     usage ();
  2910. + 
  2911. +                 oflg++;
  2912. +                 break;
  2913. +             case 's':
  2914. +                 if (strcmp (user_shell, optarg)) {
  2915. +                     strncpy (user_shell, optarg, BUFSIZ);
  2916. +                     sflg++;
  2917. +                 }
  2918. +                 break;
  2919. +             case 'u':
  2920. +                 uflg++;
  2921. +                 user_newid = atoi (optarg);
  2922. +                 break;
  2923. +             default:
  2924. +                 usage ();
  2925. +         }
  2926. +         anyflag++;
  2927. +     }
  2928. +     if (optind != argc - 1)
  2929. +         usage ();
  2930. + 
  2931. +     if (dflg && strcmp (user_home, user_newhome) == 0)
  2932. +         dflg = mflg = 0;
  2933. + 
  2934. +     if (uflg && user_id == user_newid)
  2935. +         uflg = oflg = 0;
  2936. + 
  2937. +     if (lflg && getpwnam (user_newname)) {
  2938. +         fprintf (stderr, "%s: user %s exists\n", user_newname);
  2939. +         exit (9);
  2940. +     }
  2941. + }
  2942. + 
  2943. + /*
  2944. +  * close_files - close all of the files that were opened
  2945. +  *
  2946. +  *    close_files() closes all of the files that were opened for this
  2947. +  *    new user.  This causes any modified entries to be written out.
  2948. +  */
  2949. + 
  2950. + close_files ()
  2951. + {
  2952. +     if (! pw_close ()) {
  2953. +         fprintf (stderr, "%s: cannot rewrite password file\n", Prog);
  2954. +         exit (1);
  2955. +     }
  2956. +     if (! spw_close ()) {
  2957. +         fprintf (stderr, "%s: cannot rewrite shadow password file\n",    
  2958. +             Prog);
  2959. +         exit (1);
  2960. +     }
  2961. +     if (user_ngroups > 0) {
  2962. +         if (! gr_close ()) {
  2963. +             fprintf (stderr, "%s: cannot rewrite group file\n",
  2964. +                 Prog);
  2965. +             exit (1);
  2966. +         }
  2967. +         (void) gr_unlock ();
  2968. + #ifdef    SHADOWGRP
  2969. +         if (! sgr_close ()) {
  2970. +             fprintf (stderr, "%s: cannot rewrite shadow group file\n",
  2971. +                 Prog);
  2972. +             exit (1);
  2973. +         }
  2974. + #endif
  2975. +     }
  2976. +     (void) pw_unlock ();
  2977. + }
  2978. + 
  2979. + /*
  2980. +  * open_files - lock and open the password files
  2981. +  *
  2982. +  *    open_files() opens the two password files.
  2983. +  */
  2984. + 
  2985. + open_files ()
  2986. + {
  2987. +     if (! pw_lock ()) {
  2988. +         fprintf (stderr, "%s: unable to lock password file\n", Prog);
  2989. +         exit (1);
  2990. +     }
  2991. +     if (! pw_open (O_RDWR)) {
  2992. +         fprintf (stderr, "%s: unable to open password file\n", Prog);
  2993. +         exit (1);
  2994. +     }
  2995. +     if (! spw_lock ()) {
  2996. +         fprintf ("%s: cannot lock shadow password file\n", Prog);
  2997. +         exit (1);
  2998. +     }
  2999. +     if (! spw_open (O_RDWR)) {
  3000. +         fprintf ("%s: cannot open shadow password file\n", Prog);
  3001. +         exit (1);
  3002. +     }
  3003. + }
  3004. + 
  3005. + /*
  3006. +  * usr_update - create the user entries
  3007. +  *
  3008. +  *    usr_update() creates the password file entries for this user
  3009. +  *    and will update the group entries if required.
  3010. +  */
  3011. + 
  3012. + usr_update ()
  3013. + {
  3014. +     struct    passwd    pwent;
  3015. +     struct    spwd    spent;
  3016. +     struct    passwd    *pwd;
  3017. +     struct    spwd    *spwd;
  3018. + 
  3019. +     pwd = pw_locate (user_name);
  3020. +     pwent = *pwd;
  3021. + 
  3022. +     spwd = spw_locate (user_name);
  3023. +     spent = *spwd;
  3024. + 
  3025. +     new_pwent (&pwent);
  3026. +     new_spent (&spent);
  3027. + 
  3028. +     if (lflg || uflg || gflg || cflg || dflg || sflg) {
  3029. +         if (! pw_update (&pwent)) {
  3030. +             fprintf (stderr, "%s: error changing password entry\n");
  3031. +             exit (1);
  3032. +         }
  3033. +         if (lflg && ! pw_remove (user_name)) {
  3034. +             fprintf (stderr, "%s: error removing password entry\n");
  3035. +             exit (1);
  3036. +         }
  3037. + #if defined(DBM) || defined(NDBM)
  3038. +         if (access ("/etc/passwd.pag", 0) == 0) {
  3039. +             if (! pw_dbm_update (&pwent)) {
  3040. +                 fprintf (stderr, "%s: error adding password dbm entry\n",
  3041. +                     Prog);
  3042. +                 exit (1);
  3043. +             }
  3044. +             if (lflg && (pwd = getpwnam (user_name)) && ! pw_dbm_remove (pwd)) {
  3045. +                 fprintf (stderr, "%s: error removing passwd dbm entry\n",
  3046. +                     Prog);
  3047. +                 exit (1);
  3048. +             }
  3049. +         }
  3050. + #endif
  3051. +     }
  3052. +     if (lflg || eflg || fflg) {
  3053. +         if (! spw_update (&spent)) {
  3054. +             fprintf (stderr, "%s: error adding new shadow password entry\n",
  3055. +                 Prog);
  3056. +             exit (1);
  3057. +         }
  3058. +         if (lflg && ! spw_remove (user_name)) {
  3059. +             fprintf (stderr, "%s: error removing shadow password entry\n",
  3060. +                 Prog);
  3061. +             exit (1);
  3062. +         }
  3063. +     }
  3064. + #ifdef    NDBM
  3065. +     if (access ("/etc/shadow.pag", 0) == 0) {
  3066. +         if (! sp_dbm_update (&spent)) {
  3067. +             fprintf (stderr, "%s: error updating shadow passwd dbm entry\n",
  3068. +                 Prog);
  3069. +             exit (1);
  3070. +         }
  3071. +         if (lflg && ! sp_dbm_remove (user_name)) {
  3072. +             fprintf (stderr, "%s: error removing shadow passwd db entry\n",
  3073. +                 Prog);
  3074. +             exit (1);
  3075. +         }
  3076. +     }
  3077. + #endif
  3078. +     if (Gflg || lflg)
  3079. +         grp_update ();
  3080. + }
  3081. + 
  3082. + /*
  3083. +  * move_home - move the user's home directory
  3084. +  *
  3085. +  *    move_home() creates the user's home directory if it does not
  3086. +  *    already exist.  It will be created mode 755 owned by the user
  3087. +  *    with the user's default group.
  3088. +  */
  3089. + 
  3090. + move_home ()
  3091. + {
  3092. +     if (mflg && access (user_home, 0) == 0) {
  3093. +         if (access (user_newhome, 0) == 0) {
  3094. +             fprintf (stderr, "%s: directory %s exists\n",
  3095. +                 Prog, user_newhome);
  3096. +             exit (12);
  3097. +         } else if (rename (user_home, user_newhome)) {
  3098. +             fprintf (stderr,
  3099. +                 "%s: cannot rename directory %s to %s\n",
  3100. +                 Prog, user_home, user_newhome);
  3101. +             exit (12);
  3102. +         }
  3103. +     }
  3104. +     if (uflg || gflg)
  3105. +         chown (dflg ? user_newhome:user_home, user_id, user_gid);
  3106. + }
  3107. + 
  3108. + /*
  3109. +  * main - useradd command
  3110. +  */
  3111. + 
  3112. + main (argc, argv)
  3113. + int    argc;
  3114. + char    **argv;
  3115. + {
  3116. +     /*
  3117. +      * Get my name so that I can use it to report errors.
  3118. +      */
  3119. + 
  3120. +     if (Prog = strrchr (argv[0], '/'))
  3121. +         Prog++;
  3122. +     else
  3123. +         Prog = argv[0];
  3124. + 
  3125. + #ifdef    USE_SYSLOG
  3126. +     openlog (Prog, LOG_PID|LOG_CONS|LOG_NOWAIT, LOG_AUTH);
  3127. + #endif
  3128. + 
  3129. +     /*
  3130. +      * The open routines for the DBM files don't use read-write
  3131. +      * as the mode, so we have to clue them in.
  3132. +      */
  3133. + 
  3134. + #if defined(DBM) || defined(NDBM)
  3135. +     pw_dbm_mode = O_RDWR;
  3136. + #endif
  3137. + #ifdef    NDBM
  3138. +     sp_dbm_mode = O_RDWR;
  3139. +     gr_dbm_mode = O_RDWR;
  3140. + #ifdef    SHADOWGRP
  3141. +     sg_dbm_mode = O_RDWR;
  3142. + #endif
  3143. + #endif
  3144. +     process_flags (argc, argv);
  3145. + 
  3146. +     /*
  3147. +      * Do the hard stuff - open the files, change the user entries,
  3148. +      * change the home directory, then close and update the files.
  3149. +      */
  3150. + 
  3151. +     open_files ();
  3152. + 
  3153. +     usr_update ();
  3154. + 
  3155. +     close_files ();
  3156. + 
  3157. +     if (mflg)
  3158. +         move_home ();
  3159. + 
  3160. +     exit (0);
  3161. +     /*NOTREACHED*/
  3162. + }
  3163. -- 
  3164. John F. Haugh II        | Distribution to  | UUCP: ...!cs.utexas.edu!rpp386!jfh
  3165. Ma Bell: (512) 255-8251 | GEnie PROHIBITED :-) |  Domain: jfh@rpp386.cactus.org
  3166. "If liberals interpreted the 2nd Amendment the same way they interpret the
  3167.  rest of the Constitution, gun ownership would be mandatory."
  3168.