home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3561 < prev    next >
Encoding:
Internet Message Format  |  1991-06-29  |  52.9 KB
  1. From: jfh@rpp386.cactus.org (John F Haugh II)
  2. Newsgroups: alt.sources
  3. Subject: Shadow login suite, patch 6
  4. Message-ID: <19411@rpp386.cactus.org>
  5. Date: 27 Jun 91 13:00:47 GMT
  6.  
  7. This is getting close to the end of the current beta test cycle, so you
  8. won't be seeing many more of these large patches.
  9.  
  10. There are three features to this patch.  The first is the continued
  11. introduction of the SVR4 user administration commands.  Earlier I posted
  12. the useradd, userdel and usermod clones.  This patch gives you the
  13. groupadd, groupdel and groupmod clones.  The second round of changes
  14. involves support code added to the libraries to perform deletions from
  15. the DBM files.  Finally there are a number of bug fixes of the more
  16. common "buggy code" variety.
  17.  
  18. There are two current patches in the pipeline.  The first ports the
  19. code to SunOS.  It was performed by Dr. Michael Newberry "down under",
  20. and I would like to welcome him to the group of people currently
  21. working on this project.  The second provides for run-time configuration
  22. of the programs [ as opposed to the current compile-time configuration ]
  23. and was performed by Chip Rosenthal, who has been involved with this
  24. project for several years now.  I don't know what the order will be
  25. for posting them.
  26. --
  27. Prereq: "3.0.5"
  28. Index: patchlevel.h
  29. *** rel3/patchlevel.h    Tue Jun 25 09:38:24 1991
  30. --- patchlevel.h    Wed Jun 26 09:43:23 1991
  31. ***************
  32. *** 10,14 ****
  33.    */
  34.   
  35.   #define    RELEASE        3
  36. ! #define    PATCHLEVEL    5
  37. ! #define    VERSION        "3.0.5"
  38. --- 10,14 ----
  39.    */
  40.   
  41.   #define    RELEASE        3
  42. ! #define    PATCHLEVEL    6
  43. ! #define    VERSION        "3.0.6"
  44. Index: Makefile
  45. *** rel3/Makefile    Tue Jun 25 09:38:24 1991
  46. --- Makefile    Wed Jun 26 09:43:26 1991
  47. ***************
  48. *** 8,16 ****
  49.   # and conspicuously displayed on all copies of object code or
  50.   # distribution media.
  51.   #
  52. ! #    @(#)Makefile    3.15    20:52:45  - Shadow password system
  53.   #
  54. ! #    @(#)Makefile    3.15    20:52:45    6/13/91
  55.   #
  56.   SHELL = /bin/sh
  57.   
  58. --- 8,16 ----
  59.   # and conspicuously displayed on all copies of object code or
  60.   # distribution media.
  61.   #
  62. ! #    @(#)Makefile    3.17    09:41:38  - Shadow password system
  63.   #
  64. ! #    @(#)Makefile    3.17    09:41:38    6/25/91
  65.   #
  66.   SHELL = /bin/sh
  67.   
  68. ***************
  69. *** 18,24 ****
  70.   # Set this flag to decide what level of code "get" returns.
  71.   # The base USENET release was release 1.  It is no longer supported.
  72.   # The version with the utilities added was release 2.
  73. ! # The unreleased version with database-like file access is release 3.
  74.   RELEASE = 3
  75.   GFLAGS = -t -r$(RELEASE)
  76.   
  77. --- 18,24 ----
  78.   # Set this flag to decide what level of code "get" returns.
  79.   # The base USENET release was release 1.  It is no longer supported.
  80.   # The version with the utilities added was release 2.
  81. ! # The version with database-like file access is release 3.
  82.   RELEASE = 3
  83.   GFLAGS = -t -r$(RELEASE)
  84.   
  85. ***************
  86. *** 141,150 ****
  87.       chfn.c chsh.c chage.c rad64.c encrypt.c chpasswd.c shadowio.c pwio.c \
  88.       newusers.c groupio.c fields.c pwdbm.c grpack.c grdbm.c sppack.c \
  89.       spdbm.c dpmain.c gshadow.c gsdbm.c gspack.c sgroupio.c useradd.c \
  90. !     userdel.c patchlevel.h usermod.c copydir.c mkrmdir.c
  91.   
  92. ! FILES1 = README newgrp.c Makefile config.h pwunconv.c obscure.c age.c id.c \
  93. !     patchlevel.h
  94.   
  95.   FILES2 = passwd.c port.c lmain.c mkpasswd.c sulogin.c pwpack.c dialup.c \
  96.       sulog.c getpass.c
  97. --- 141,151 ----
  98.       chfn.c chsh.c chage.c rad64.c encrypt.c chpasswd.c shadowio.c pwio.c \
  99.       newusers.c groupio.c fields.c pwdbm.c grpack.c grdbm.c sppack.c \
  100.       spdbm.c dpmain.c gshadow.c gsdbm.c gspack.c sgroupio.c useradd.c \
  101. !     userdel.c patchlevel.h usermod.c copydir.c mkrmdir.c groupadd.c \
  102. !     groupdel.c groupmod.c
  103.   
  104. ! FILES1 = README patchlevel.h newgrp.c Makefile config.h pwunconv.c obscure.c \
  105. !     age.c id.c
  106.   
  107.   FILES2 = passwd.c port.c lmain.c mkpasswd.c sulogin.c pwpack.c dialup.c \
  108.       sulog.c getpass.c
  109. ***************
  110. *** 164,169 ****
  111. --- 165,172 ----
  112.   
  113.   FILES8 = useradd.c userdel.c usermod.c copydir.c mkrmdir.c
  114.   
  115. + FILES9 = groupadd.c groupdel.c groupmod.c
  116. + 
  117.   MAN_1 = chage.1 chfn.1 chsh.1 login.1 passwd.1 su.1
  118.   MAN_3 = shadow.3
  119.   MAN_4 = faillog.4 passwd.4 porttime.4 shadow.4
  120. ***************
  121. *** 173,179 ****
  122.   
  123.   BINS = su login pwconv pwunconv passwd sulogin faillog newgrp gpasswd \
  124.       mkpasswd chfn chsh chage chpasswd newusers dpasswd id useradd \
  125. !     userdel usermod
  126.   
  127.   all:    $(BINS) $(DOCS)
  128.   
  129. --- 176,182 ----
  130.   
  131.   BINS = su login pwconv pwunconv passwd sulogin faillog newgrp gpasswd \
  132.       mkpasswd chfn chsh chage chpasswd newusers dpasswd id useradd \
  133. !     userdel usermod groupadd groupdel groupmod
  134.   
  135.   all:    $(BINS) $(DOCS)
  136.   
  137. ***************
  138. *** 209,229 ****
  139.   install: all
  140.       strip $(BINS)
  141.       cp login $(LOGINDIR)/login
  142. !     cp mkpasswd pwconv pwunconv sulogin chpasswd newusers /etc
  143. !     cp su passwd gpasswd dpasswd faillog newgrp chfn chsh id /bin
  144.       cp dialup.h shadow.h pwd.h /usr/include
  145.       chown $(RUID) $(LOGINDIR)/login /etc/pwconv /etc/pwunconv /etc/sulogin \
  146.           /bin/su /bin/passwd /bin/gpasswd /bin/newgrp /etc/mkpasswd \
  147. !         /bin/dpasswd /bin/chsh /bin/chfn /bin/chage
  148.       chgrp $(RGID) $(LOGINDIR)/login /etc/pwconv /etc/pwunconv /etc/sulogin \
  149.           /bin/su /bin/passwd /bin/gpasswd /bin/newgrp /etc/mkpasswd \
  150. !         /bin/dpasswd /bin/chsh /bin/chfn /bin/chage
  151.       chown $(BUID) /bin/faillog /bin/id /usr/include/shadow.h \
  152.           /usr/include/dialup.h /usr/include/pwd.h
  153.       chgrp $(BGID) /bin/faillog /bin/id /usr/include/shadow.h \
  154.           /usr/include/dialup.h /usr/include/pwd.h
  155.       chmod 700 /etc/pwconv /etc/pwunconv /etc/sulogin /etc/mkpasswd \
  156. !         /etc/chpasswd /etc/newusers /bin/dpasswd /bin/chage
  157.       chmod 4711 $(LOGINDIR)/login /bin/su /bin/passwd /bin/gpasswd \
  158.           /bin/newgrp /bin/chfn /bin/chsh
  159.       chmod 711 /bin/faillog /bin/id
  160. --- 212,239 ----
  161.   install: all
  162.       strip $(BINS)
  163.       cp login $(LOGINDIR)/login
  164. !     cp mkpasswd pwconv pwunconv sulogin chpasswd newusers \
  165. !         useradd userdel usermod groupadd groupdel groupmod /etc
  166. !     cp su passwd gpasswd dpasswd faillog newgrp chfn chsh chage id /bin
  167.       cp dialup.h shadow.h pwd.h /usr/include
  168.       chown $(RUID) $(LOGINDIR)/login /etc/pwconv /etc/pwunconv /etc/sulogin \
  169.           /bin/su /bin/passwd /bin/gpasswd /bin/newgrp /etc/mkpasswd \
  170. !         /bin/dpasswd /bin/chsh /bin/chfn /bin/chage /etc/useradd \
  171. !         /etc/userdel /etc/usermod /etc/groupadd /etc/groupdel \
  172. !         /etc/groupmod
  173.       chgrp $(RGID) $(LOGINDIR)/login /etc/pwconv /etc/pwunconv /etc/sulogin \
  174.           /bin/su /bin/passwd /bin/gpasswd /bin/newgrp /etc/mkpasswd \
  175. !         /bin/dpasswd /bin/chsh /bin/chfn /bin/chage /etc/useradd \
  176. !         /etc/userdel /etc/usermod /etc/groupadd /etc/groupdel \
  177. !         /etc/groupmod
  178.       chown $(BUID) /bin/faillog /bin/id /usr/include/shadow.h \
  179.           /usr/include/dialup.h /usr/include/pwd.h
  180.       chgrp $(BGID) /bin/faillog /bin/id /usr/include/shadow.h \
  181.           /usr/include/dialup.h /usr/include/pwd.h
  182.       chmod 700 /etc/pwconv /etc/pwunconv /etc/sulogin /etc/mkpasswd \
  183. !         /etc/chpasswd /etc/newusers /bin/dpasswd /bin/chage \
  184. !         /etc/useradd /etc/userdel /etc/usermod /etc/groupadd \
  185. !         /etc/groupdel /etc/groupmod
  186.       chmod 4711 $(LOGINDIR)/login /bin/su /bin/passwd /bin/gpasswd \
  187.           /bin/newgrp /bin/chfn /bin/chsh
  188.       chmod 711 /bin/faillog /bin/id
  189. ***************
  190. *** 233,248 ****
  191.   lint:    su.lint login.lint pwconv.lint pwunconv.lint passwd.lint sulogin.lint \
  192.       faillog.lint newgrp.lint gpasswd.lint mkpasswd.lint chfn.lint \
  193.       chsh.lint chage.lint dpasswd.lint id.lint useradd.lint userdel.lint \
  194. !     usermod.lint $(ALLSRCS:.c=.L)
  195.   
  196.   tags:    $(ALLSRCS)
  197.       $(TAGS) $(ALLSRCS)
  198.   
  199. ! README:    s.README
  200. !     get -t -r$(RELEASE) s.README
  201.       
  202.   $(DOCS):
  203. !     get -t -r$(RELEASE) s.$@
  204.   
  205.   login:    $(LOBJS) libshadow.a
  206.       $(CC) -o login $(LDFLAGS) $(LOBJS) libshadow.a $(LIBS)
  207. --- 243,258 ----
  208.   lint:    su.lint login.lint pwconv.lint pwunconv.lint passwd.lint sulogin.lint \
  209.       faillog.lint newgrp.lint gpasswd.lint mkpasswd.lint chfn.lint \
  210.       chsh.lint chage.lint dpasswd.lint id.lint useradd.lint userdel.lint \
  211. !     usermod.lint groupadd.lint groupdel.lint groupmod.lint $(ALLSRCS:.c=.L)
  212.   
  213.   tags:    $(ALLSRCS)
  214.       $(TAGS) $(ALLSRCS)
  215.   
  216. ! README:
  217. !     [ -f s.README ] && get -t -r$(RELEASE) s.README
  218.       
  219.   $(DOCS):
  220. !     [ -f s.$@ ] && get -t -r$(RELEASE) s.$@
  221.   
  222.   login:    $(LOBJS) libshadow.a
  223.       $(CC) -o login $(LDFLAGS) $(LOBJS) libshadow.a $(LIBS)
  224. ***************
  225. *** 367,372 ****
  226. --- 377,400 ----
  227.   usermod.lint: usermod.c copydir.c mkrmdir.c
  228.       $(LINT) $(LINTFLAGS) usermod.c copydir.c mkrmdir.c > usermod.lint
  229.   
  230. + groupadd: groupadd.o libshadow.a
  231. +     $(CC) -o groupadd $(LDFLAGS) groupadd.o libshadow.a $(LIBS)
  232. + 
  233. + groupadd.lint: groupadd.c
  234. +     $(LINT) $(LINTFLAGS) groupadd.c > groupadd.lint
  235. + 
  236. + groupdel: groupdel.o libshadow.a
  237. +     $(CC) -o groupdel $(LDFLAGS) groupdel.o libshadow.a $(LIBS)
  238. + 
  239. + groupdel.lint: groupdel.c
  240. +     $(LINT) $(LINTFLAGS) groupdel.c > groupdel.lint
  241. + 
  242. + groupmod: groupmod.o libshadow.a
  243. +     $(CC) -o groupmod $(LDFLAGS) groupmod.o libshadow.a $(LIBS)
  244. + 
  245. + groupmod.lint: groupmod.c
  246. +     $(LINT) $(LINTFLAGS) groupmod.c > groupmod.lint
  247. + 
  248.   sulog.o: config.h
  249.   
  250.   susetup.c: setup.c
  251. ***************
  252. *** 437,442 ****
  253. --- 465,474 ----
  254.   dpmain.o: dialup.h
  255.   useradd.o: config.h shadow.h pwd.h
  256.   userdel.o: config.h shadow.h pwd.h
  257. + usermod.o: config.h shadow.h pwd.h
  258. + groupadd.o: config.h shadow.h
  259. + groupdel.o: config.h shadow.h
  260. + groupmod.o: config.h shadow.h
  261.   
  262.   clean:
  263.       -rm -f *.o a.out core npasswd nshadow *.pag *.dir
  264. ***************
  265. *** 451,483 ****
  266.           fi ;\
  267.       done
  268.   
  269. ! shar:    login.sh.1 login.sh.2 login.sh.3 login.sh.4 login.sh.5 login.sh.6 \
  270. !     login.sh.7 login.sh.8 login.sh.9
  271. ! 
  272. ! login.sh.1: $(FILES1) Makefile
  273. !     shar -a $(FILES1) > login.sh.1
  274. ! 
  275. ! login.sh.2: $(FILES2) Makefile
  276. !     shar -a $(FILES2) > login.sh.2
  277. ! 
  278. ! login.sh.3: $(FILES3) Makefile
  279. !     shar -a $(FILES3) > login.sh.3
  280. ! 
  281. ! login.sh.4: $(FILES4) Makefile
  282. !     shar -a $(FILES4) > login.sh.4
  283. ! 
  284. ! login.sh.5: $(FILES5) Makefile
  285. !     shar -a $(FILES5) > login.sh.5
  286. ! 
  287. ! login.sh.6: $(FILES6) Makefile
  288. !     shar -a $(FILES6) > login.sh.6
  289. ! 
  290. ! login.sh.7: $(FILES7) Makefile
  291. !     shar -a $(FILES7) > login.sh.7
  292. ! 
  293. ! login.sh.8: $(FILES8) Makefile
  294. !     shar -a $(FILES8) > login.sh.8
  295.   
  296. ! login.sh.9: $(DOCS) Makefile
  297. !     shar -a $(DOCS) > login.sh.9
  298.   
  299. --- 483,517 ----
  300.           fi ;\
  301.       done
  302.   
  303. ! shar:    login.sh.01 login.sh.02 login.sh.03 login.sh.04 login.sh.05 \
  304. !     login.sh.06 login.sh.07 login.sh.08 login.sh.09 login.sh.10
  305.   
  306. ! login.sh.01: $(FILES1) Makefile
  307. !     shar -a $(FILES1) > login.sh.01
  308. ! 
  309. ! login.sh.02: $(FILES2) Makefile
  310. !     shar -a $(FILES2) > login.sh.02
  311. ! 
  312. ! login.sh.03: $(FILES3) Makefile
  313. !     shar -a $(FILES3) > login.sh.03
  314. ! 
  315. ! login.sh.04: $(FILES4) Makefile
  316. !     shar -a $(FILES4) > login.sh.04
  317. ! 
  318. ! login.sh.05: $(FILES5) Makefile
  319. !     shar -a $(FILES5) > login.sh.05
  320. ! 
  321. ! login.sh.06: $(FILES6) Makefile
  322. !     shar -a $(FILES6) > login.sh.06
  323. ! 
  324. ! login.sh.07: $(FILES7) Makefile
  325. !     shar -a $(FILES7) > login.sh.07
  326. ! 
  327. ! login.sh.08: $(FILES8) Makefile
  328. !     shar -a $(FILES8) > login.sh.08
  329. ! 
  330. ! login.sh.09: $(FILES9) Makefile
  331. !     shar -a $(FILES9) > login.sh.09
  332.   
  333. + login.sh.10: $(DOCS) Makefile
  334. +     shar -a $(DOCS) > login.sh.10
  335. Index: grdbm.c
  336. *** rel3/grdbm.c    Tue Jun 25 09:35:40 1991
  337. --- grdbm.c    Wed Jun 26 09:43:28 1991
  338. ***************
  339. *** 7,13 ****
  340.    */
  341.   
  342.   #ifndef    lint
  343. ! static    char    sccsid[] = "@(#)grdbm.c    3.1    08:11:52    11/21/90";
  344.   #endif
  345.   
  346.   #include <string.h>
  347. --- 7,13 ----
  348.    */
  349.   
  350.   #ifndef    lint
  351. ! static    char    sccsid[] = "@(#)grdbm.c    3.2    22:53:58    6/13/91";
  352.   #endif
  353.   
  354.   #include <string.h>
  355. ***************
  356. *** 104,108 ****
  357. --- 104,187 ----
  358.           }
  359.       }
  360.       return 1;
  361. + }
  362. + 
  363. + /*
  364. +  * gr_dbm_remove
  365. +  *
  366. +  * Deletes the DBM group file entries, if they exist.
  367. +  */
  368. + 
  369. + int
  370. + gr_dbm_remove (gr)
  371. + struct    group    *gr;
  372. + {
  373. +     datum    key;
  374. +     datum    content;
  375. +     char    data[BUFSIZ*8];
  376. +     char    grpkey[60];
  377. +     char    *cp;
  378. +     int    len;
  379. +     int    i;
  380. +     int    cnt;
  381. +     int    errors = 0;
  382. +     static    int    once;
  383. + 
  384. +     if (! once) {
  385. +         if (! gr_dbm)
  386. +             setgrent ();
  387. + 
  388. +         once++;
  389. +     }
  390. +     if (! gr_dbm)
  391. +         return 0;
  392. + 
  393. +     key.dsize = strlen (gr->gr_name);
  394. +     key.dptr = gr->gr_name;
  395. +     content = dbm_fetch (gr_dbm, key);
  396. +     if (content.dptr == 0)
  397. +         ++errors;
  398. +     else {
  399. +         if (content.dsize == sizeof (int)) {
  400. +             memcpy (&cnt, content.dptr, sizeof cnt);
  401. + 
  402. +             for (i = 0;i < cnt;i++) {
  403. +                 key.dsize = sizeof i + strlen (gr->gr_name);
  404. +                 key.dptr = grpkey;
  405. +                 memcpy (grpkey, &i, sizeof i);
  406. +                 strcpy (grpkey + sizeof i, gr->gr_name);
  407. +                 if (dbm_delete (gr_dbm, key))
  408. +                     ++errors;
  409. +             }
  410. +         } else {
  411. +             if (dbm_delete (gr_dbm, key))
  412. +                 ++errors;
  413. +         }
  414. +     }
  415. +     key.dsize = sizeof gr->gr_gid;
  416. +     key.dptr = &gr->gr_gid;
  417. +     content = dbm_fetch (gr_dbm, key);
  418. +     if (content.dptr == 0)
  419. +         ++errors;
  420. +     else {
  421. +         if (content.dsize == sizeof (int)) {
  422. +             memcpy (&cnt, content.dptr, sizeof cnt);
  423. + 
  424. +             for (i = 0;i < cnt;i++) {
  425. +                 key.dsize = sizeof i + sizeof gr->gr_gid;
  426. +                 key.dptr = grpkey;
  427. +                 memcpy (grpkey, &i, sizeof i);
  428. +                 memcpy (grpkey + sizeof i,
  429. +                     &gr->gr_gid, sizeof gr->gr_gid);
  430. + 
  431. +                 if (dbm_delete (gr_dbm, key))
  432. +                     ++errors;
  433. +             }
  434. +         } else {
  435. +             if (dbm_delete (gr_dbm, key))
  436. +                 ++errors;
  437. +         }
  438. +     }
  439. +     return errors ? 0:1;
  440.   }
  441.   #endif
  442. Index: gsdbm.c
  443. *** rel3/gsdbm.c    Tue Jun 25 09:35:52 1991
  444. --- gsdbm.c    Wed Jun 26 09:43:29 1991
  445. ***************
  446. *** 10,16 ****
  447.    */
  448.   
  449.   #ifndef    lint
  450. ! static    char    sccsid[] = "@(#)gsdbm.c    3.3    11:25:29    12/19/90";
  451.   #endif
  452.   
  453.   #include <string.h>
  454. --- 10,16 ----
  455.    */
  456.   
  457.   #ifndef    lint
  458. ! static    char    sccsid[] = "@(#)gsdbm.c    3.4    22:55:17    6/13/91";
  459.   #endif
  460.   
  461.   #include <string.h>
  462. ***************
  463. *** 88,92 ****
  464. --- 88,145 ----
  465.           }
  466.       }
  467.       return 1;
  468. + }
  469. + 
  470. + /*
  471. +  * sgr_dbm_remove
  472. +  *
  473. +  * Deletes the DBM shadow group file entries, if they exist.
  474. +  */
  475. + 
  476. + int
  477. + sgr_dbm_remove (name)
  478. + char    *name;
  479. + {
  480. +     datum    key;
  481. +     datum    content;
  482. +     char    grpkey[60];
  483. +     char    *cp;
  484. +     int    i;
  485. +     int    cnt;
  486. +     int    errors = 0;
  487. +     static    int    once;
  488. + 
  489. +     if (! once) {
  490. +         if (! sgr_dbm)
  491. +             setsgent ();
  492. + 
  493. +         once++;
  494. +     }
  495. +     if (! sgr_dbm)
  496. +         return 0;
  497. + 
  498. +     key.dsize = strlen (name);
  499. +     key.dptr = name;
  500. +     content = dbm_fetch (sgr_dbm, key);
  501. +     if (content.dptr == 0)
  502. +         ++errors;
  503. +     else {
  504. +         if (content.dsize == sizeof (int)) {
  505. +             memcpy (&cnt, content.dptr, sizeof cnt);
  506. + 
  507. +             for (i = 0;i < cnt;i++) {
  508. +                 key.dsize = sizeof i + strlen (name);
  509. +                 key.dptr = grpkey;
  510. +                 memcpy (grpkey, &i, sizeof i);
  511. +                 strcpy (grpkey + sizeof i, name);
  512. +                 if (dbm_delete (sgr_dbm, key))
  513. +                     ++errors;
  514. +             }
  515. +         } else {
  516. +             if (dbm_delete (sgr_dbm, key))
  517. +                 ++errors;
  518. +         }
  519. +     }
  520. +     return errors ? 0:1;
  521.   }
  522.   #endif
  523. Index: gshadow.c
  524. *** rel3/gshadow.c    Tue Jun 25 09:38:10 1991
  525. --- gshadow.c    Wed Jun 26 09:43:30 1991
  526. ***************
  527. *** 32,38 ****
  528.   
  529.   
  530.   #ifndef    lint
  531. ! static    char    sccsid[] = "@(#)gshadow.c    3.4    07:31:22    6/6/91";
  532.   #endif
  533.   
  534.   #define    MAXMEM    1024
  535. --- 32,38 ----
  536.   
  537.   
  538.   #ifndef    lint
  539. ! static    char    sccsid[] = "@(#)gshadow.c    3.5    22:56:08    6/13/91";
  540.   #endif
  541.   
  542.   #define    MAXMEM    1024
  543. ***************
  544. *** 136,147 ****
  545.       if (cp = strrchr (sgrbuf, '\n'))
  546.           *cp = '\0';
  547.   
  548. !     for (cp = sgrbuf, i = 0;*cp && i < FIELDS;i++) {
  549.           fields[i] = cp;
  550. !         while (*cp && *cp != ':')
  551. !             cp++;
  552. ! 
  553. !         if (*cp)
  554.               *cp++ = '\0';
  555.       }
  556.       if (*cp || i != FIELDS)
  557. --- 136,144 ----
  558.       if (cp = strrchr (sgrbuf, '\n'))
  559.           *cp = '\0';
  560.   
  561. !     for (cp = sgrbuf, i = 0;i < FIELDS && cp;i++) {
  562.           fields[i] = cp;
  563. !         if (cp = strchr (cp, ':'))
  564.               *cp++ = '\0';
  565.       }
  566.       if (*cp || i != FIELDS)
  567. *** /dev/null    Wed Jun 26 09:26:31 1991
  568. --- groupadd.c    Wed Jun 26 09:43:32 1991
  569. ***************
  570. *** 0 ****
  571. --- 1,390 ----
  572. + /*
  573. +  * Copyright 1991, John F. Haugh II
  574. +  * All rights reserved.
  575. +  *
  576. +  * Permission is granted to copy and create derivative works for any
  577. +  * non-commercial purpose, provided this copyright notice is preserved
  578. +  * in all copies of source code, or included in human readable form
  579. +  * and conspicuously displayed on all copies of object code or
  580. +  * distribution media.
  581. +  */
  582. + 
  583. + #ifndef lint
  584. + static    char    sccsid[] = "@(#)groupadd.c    3.1    22:59:04    6/13/91";
  585. + #endif
  586. + 
  587. + #include <sys/types.h>
  588. + #include <stdio.h>
  589. + #include <grp.h>
  590. + #include <ctype.h>
  591. + #include <fcntl.h>
  592. + 
  593. + #ifdef    BSD
  594. + #include <strings.h>
  595. + #else
  596. + #include <string.h>
  597. + #endif
  598. + 
  599. + #include "config.h"
  600. + #include "shadow.h"
  601. + 
  602. + #ifdef    USE_SYSLOG
  603. + #include <syslog.h>
  604. + #endif
  605. + 
  606. + char    group_name[BUFSIZ];
  607. + int    group_id;
  608. + 
  609. + char    *Prog;
  610. + 
  611. + int    oflg;    /* permit non-unique group ID to be specified with -g         */
  612. + int    gflg;    /* ID value for the new group                                 */
  613. + 
  614. + #ifdef    NDBM
  615. + extern    int    gr_dbm_mode;
  616. + extern    int    sg_dbm_mode;
  617. + #endif
  618. + extern    char    *malloc();
  619. + 
  620. + extern    struct    group    *getgrnam();
  621. + extern    struct    group    *gr_next();
  622. + extern    int    gr_lock();
  623. + extern    int    gr_unlock();
  624. + extern    int    gr_rewind();
  625. + extern    int    gr_open();
  626. + 
  627. + #ifdef    SHADOWGRP
  628. + extern    int    sgr_lock();
  629. + extern    int    sgr_unlock();
  630. + extern    int    sgr_open();
  631. + #endif
  632. + 
  633. + /*
  634. +  * usage - display usage message and exit
  635. +  */
  636. + 
  637. + usage ()
  638. + {
  639. +     fprintf (stderr, "usage: groupadd [-g gid [-o]] group\n");
  640. +     exit (2);
  641. + }
  642. + 
  643. + /*
  644. +  * new_grent - initialize the values in a group file entry
  645. +  *
  646. +  *    new_grent() takes all of the values that have been entered and
  647. +  *    fills in a (struct group) with them.
  648. +  */
  649. + 
  650. + void
  651. + new_grent (grent)
  652. + struct    group    *grent;
  653. + {
  654. +     static    char    *empty_list = 0;
  655. + 
  656. +     memset (grent, 0, sizeof *grent);
  657. +     grent->gr_name = group_name;
  658. +     grent->gr_passwd = "*";
  659. +     grent->gr_gid = group_id;
  660. +     grent->gr_mem = &empty_list;
  661. + }
  662. + 
  663. + #ifdef    SHADOWGRP
  664. + /*
  665. +  * new_sgent - initialize the values in a shadow group file entry
  666. +  *
  667. +  *    new_sgent() takes all of the values that have been entered and
  668. +  *    fills in a (struct sgrp) with them.
  669. +  */
  670. + 
  671. + void
  672. + new_sgent (sgent)
  673. + struct    sgrp    *sgent;
  674. + {
  675. +     static    char    *empty_list = 0;
  676. + 
  677. +     memset (sgent, 0, sizeof *sgent);
  678. +     sgent->sg_name = group_name;
  679. +     sgent->sg_passwd = "!";
  680. +     sgent->sg_adm = &empty_list;
  681. +     sgent->sg_mem = &empty_list;
  682. + }
  683. + #endif    /* SHADOWGRP */
  684. + 
  685. + /*
  686. +  * grp_update - add new group file entries
  687. +  *
  688. +  *    grp_update() writes the new records to the group files.
  689. +  */
  690. + 
  691. + void
  692. + grp_update ()
  693. + {
  694. +     int    i;
  695. +     struct    group    grp;
  696. + #ifdef    SHADOWGRP
  697. +     struct    sgrp    sgrp;
  698. + #endif    /* SHADOWGRP */
  699. + 
  700. +     /*
  701. +      * Create the initial entries for this new group.
  702. +      */
  703. + 
  704. +     new_grent (&grp);
  705. + #ifdef    SHADOWGRP
  706. +     new_sgent (&sgrp);
  707. + #endif    /* SHADOWGRP */
  708. + 
  709. +     /*
  710. +      * Write out the new group file entry.
  711. +      */
  712. + 
  713. +     if (! gr_update (&grp)) {
  714. +         fprintf (stderr, "%s: error adding new group entry\n", Prog);
  715. +         exit (1);
  716. +     }
  717. + #ifdef    NDBM
  718. + 
  719. +     /*
  720. +      * Update the DBM group file with the new entry as well.
  721. +      */
  722. + 
  723. +     if (! gr_dbm_update (&grp)) {
  724. +         fprintf (stderr, "%s: cannot add new dbm group entry\n", Prog);
  725. +         exit (1);
  726. +     }
  727. + #endif    /* NDBM */
  728. + 
  729. + #ifdef    SHADOWGRP
  730. + 
  731. +     /*
  732. +      * Write out the new shadow group entries as well.
  733. +      */
  734. + 
  735. +     if (! sgr_update (&sgrp)) {
  736. +         fprintf (stderr, "%s: error adding new group entry\n", Prog);
  737. +         exit (1);
  738. +     }
  739. + #ifdef    NDBM
  740. + 
  741. +     /*
  742. +      * Update the DBM group file with the new entry as well.
  743. +      */
  744. + 
  745. +     if (! sgr_dbm_update (&sgrp)) {
  746. +         fprintf (stderr, "%s: cannot add new dbm group entry\n", Prog);
  747. +         exit (1);
  748. +     }
  749. + #endif    /* NDBM */
  750. + #endif    /* SHADOWGRP */
  751. + #ifdef    USE_SYSLOG
  752. +     syslog (LOG_INFO, "new group: name=%s, gid=%d\n",
  753. +         group_name, group_id);
  754. + #endif    /* USE_SYSLOG */
  755. + }
  756. + 
  757. + /*
  758. +  * find_new_gid - find the next available GID
  759. +  *
  760. +  *    find_new_gid() locates the next highest unused GID in the group
  761. +  *    file, or checks the given group ID against the existing ones for
  762. +  *    uniqueness.
  763. +  */
  764. + 
  765. + int
  766. + find_new_gid ()
  767. + {
  768. +     struct    group    *grp;
  769. + 
  770. +     /*
  771. +      * Start with some GID value if the user didn't provide us with
  772. +      * one already.
  773. +      */
  774. + 
  775. +     if (! gflg)
  776. +         group_id = 100;
  777. + 
  778. +     /*
  779. +      * Search the entire group file, either looking for this
  780. +      * GID (if the user specified one with -g) or looking for the
  781. +      * largest unused value.
  782. +      */
  783. + 
  784. +     for (gr_rewind (), grp = gr_next ();grp;grp = gr_next ()) {
  785. +         if (strcmp (group_name, grp->gr_name) == 0) {
  786. +             fprintf (stderr, "%s: name %s is not unique\n",
  787. +                 Prog, group_name);
  788. +             exit (1);
  789. +         }
  790. +         if (gflg && group_id == grp->gr_gid) {
  791. +             fprintf (stderr, "%s: gid %d is not unique\n",
  792. +                 Prog, group_id);
  793. +             exit (1);
  794. +         }
  795. +         if (! gflg && grp->gr_gid >= group_id)
  796. +             group_id = grp->gr_gid + 1;
  797. +     }
  798. + }
  799. + 
  800. + /*
  801. +  * process_flags - perform command line argument setting
  802. +  *
  803. +  *    process_flags() interprets the command line arguments and sets
  804. +  *    the values that the user will be created with accordingly.  The
  805. +  *    values are checked for sanity.
  806. +  */
  807. + 
  808. + void
  809. + process_flags (argc, argv)
  810. + int    argc;
  811. + char    **argv;
  812. + {
  813. +     extern    int    optind;
  814. +     extern    char    *optarg;
  815. +     struct    group    *grp;
  816. +     char    *end;
  817. +     int    anyflag = 0;
  818. +     int    arg;
  819. + 
  820. +     while ((arg = getopt (argc, argv, "og:")) != EOF) {
  821. +         switch (arg) {
  822. +             case 'g':
  823. +                 gflg++;
  824. +                 if (! isdigit (optarg[0]))
  825. +                     usage ();
  826. + 
  827. +                 group_id = strtol (optarg, &end, 10);
  828. +                 if (*end != '\0') {
  829. +                     fprintf (stderr, "%s: invalid group %s\n",
  830. +                         Prog, optarg);
  831. +                     exit (3);
  832. +                 }
  833. +                 break;
  834. +             case 'o':
  835. +                 if (! gflg)
  836. +                     usage ();
  837. + 
  838. +                 oflg++;
  839. +                 break;
  840. +             default:
  841. +                 usage ();
  842. +         }
  843. +         anyflag++;
  844. +     }
  845. +     if (optind == argc - 1)
  846. +         strcpy (group_name, argv[argc - 1]);
  847. +     else
  848. +         usage ();
  849. + }
  850. + 
  851. + /*
  852. +  * close_files - close all of the files that were opened
  853. +  *
  854. +  *    close_files() closes all of the files that were opened for this
  855. +  *    new group.  This causes any modified entries to be written out.
  856. +  */
  857. + 
  858. + close_files ()
  859. + {
  860. +     if (! gr_close ()) {
  861. +         fprintf (stderr, "%s: cannot rewrite group file\n", Prog);
  862. +         exit (1);
  863. +     }
  864. +     (void) gr_unlock ();
  865. + #ifdef    SHADOWGRP
  866. +     if (! sgr_close ()) {
  867. +         fprintf (stderr, "%s: cannot rewrite shadow group file\n",
  868. +             Prog);
  869. +         exit (1);
  870. +     }
  871. +     (void) sgr_unlock ();
  872. + #endif    /* SHADOWGRP */
  873. + }
  874. + 
  875. + /*
  876. +  * open_files - lock and open the group files
  877. +  *
  878. +  *    open_files() opens the two group files.
  879. +  */
  880. + 
  881. + open_files ()
  882. + {
  883. +     if (! gr_lock ()) {
  884. +         fprintf (stderr, "%s: unable to lock group file\n", Prog);
  885. +         exit (1);
  886. +     }
  887. +     if (! gr_open (O_RDWR)) {
  888. +         fprintf (stderr, "%s: unable to open group file\n", Prog);
  889. +         exit (1);
  890. +     }
  891. + #ifdef    SHADOWGRP
  892. +     if (! sgr_lock ()) {
  893. +         fprintf (stderr, "%s: unable to lock shadow group file\n",
  894. +             Prog);
  895. +         exit (1);
  896. +     }
  897. +     if (! sgr_open (O_RDWR)) {
  898. +         fprintf (stderr, "%s: unable to open shadow group file\n",
  899. +             Prog);
  900. +         exit (1);
  901. +     }
  902. + #endif    /* SHADOWGRP */
  903. + }
  904. + 
  905. + /*
  906. +  * main - useradd command
  907. +  */
  908. + 
  909. + main (argc, argv)
  910. + int    argc;
  911. + char    **argv;
  912. + {
  913. + 
  914. +     /*
  915. +      * Get my name so that I can use it to report errors.
  916. +      */
  917. + 
  918. +     if (Prog = strrchr (argv[0], '/'))
  919. +         Prog++;
  920. +     else
  921. +         Prog = argv[0];
  922. + 
  923. + #ifdef    USE_SYSLOG
  924. +     openlog (Prog, LOG_PID|LOG_CONS|LOG_NOWAIT, LOG_AUTH);
  925. + #endif    /* USE_SYSLOG */
  926. + 
  927. +     /*
  928. +      * The open routines for the DBM files don't use read-write
  929. +      * as the mode, so we have to clue them in.
  930. +      */
  931. + 
  932. + #ifdef    NDBM
  933. +     gr_dbm_mode = O_RDWR;
  934. + #ifdef    SHADOWGRP
  935. +     sg_dbm_mode = O_RDWR;
  936. + #endif    /* SHADOWGRP */
  937. + #endif    /* NDBM */
  938. +     process_flags (argc, argv);
  939. + 
  940. +     /*
  941. +      * Start with a quick check to see if the group exists.
  942. +      */
  943. + 
  944. +     if (getgrnam (group_name)) {
  945. +         fprintf (stderr, "%s: group %s exists\n", Prog, group_name);
  946. +         exit (9);
  947. +     }
  948. + 
  949. +     /*
  950. +      * Do the hard stuff - open the files, create the group entries,
  951. +      * then close and update the files.
  952. +      */
  953. + 
  954. +     open_files ();
  955. + 
  956. +     grp_update ();
  957. + 
  958. +     close_files ();
  959. +     exit (0);
  960. +     /*NOTREACHED*/
  961. + }
  962. *** /dev/null    Wed Jun 26 09:26:31 1991
  963. --- groupdel.c    Wed Jun 26 09:43:33 1991
  964. ***************
  965. *** 0 ****
  966. --- 1,254 ----
  967. + /*
  968. +  * Copyright 1991, John F. Haugh II
  969. +  * All rights reserved.
  970. +  *
  971. +  * Permission is granted to copy and create derivative works for any
  972. +  * non-commercial purpose, provided this copyright notice is preserved
  973. +  * in all copies of source code, or included in human readable form
  974. +  * and conspicuously displayed on all copies of object code or
  975. +  * distribution media.
  976. +  */
  977. + 
  978. + #ifndef lint
  979. + static    char    sccsid[] = "@(#)groupdel.c    3.1    22:59:09    6/13/91";
  980. + #endif
  981. + 
  982. + #include <sys/types.h>
  983. + #include <stdio.h>
  984. + #include <grp.h>
  985. + #include <ctype.h>
  986. + #include <fcntl.h>
  987. + 
  988. + #ifdef    BSD
  989. + #include <strings.h>
  990. + #else
  991. + #include <string.h>
  992. + #endif
  993. + 
  994. + #include "config.h"
  995. + #include "shadow.h"
  996. + 
  997. + #ifdef    USE_SYSLOG
  998. + #include <syslog.h>
  999. + #endif
  1000. + 
  1001. + char    group_name[BUFSIZ];
  1002. + char    *Prog;
  1003. + 
  1004. + #ifdef    NDBM
  1005. + extern    int    gr_dbm_mode;
  1006. + extern    int    sg_dbm_mode;
  1007. + #endif
  1008. + extern    char    *malloc();
  1009. + 
  1010. + extern    struct    group    *getgrnam();
  1011. + extern    struct    group    *gr_next();
  1012. + extern    struct    group    *gr_locate();
  1013. + extern    int    gr_lock();
  1014. + extern    int    gr_unlock();
  1015. + extern    int    gr_rewind();
  1016. + extern    int    gr_open();
  1017. + 
  1018. + #ifdef    SHADOWGRP
  1019. + extern    struct    sgrp    *sgr_locate();
  1020. + extern    int    sgr_lock();
  1021. + extern    int    sgr_unlock();
  1022. + extern    int    sgr_open();
  1023. + #endif
  1024. + 
  1025. + /*
  1026. +  * usage - display usage message and exit
  1027. +  */
  1028. + 
  1029. + usage ()
  1030. + {
  1031. +     fprintf (stderr, "usage: groupmod group\n");
  1032. +     exit (2);
  1033. + }
  1034. + 
  1035. + /*
  1036. +  * grp_update - update group file entries
  1037. +  *
  1038. +  *    grp_update() writes the new records to the group files.
  1039. +  */
  1040. + 
  1041. + void
  1042. + grp_update ()
  1043. + {
  1044. +     int    i;
  1045. +     struct    group    *ogrp;
  1046. + 
  1047. +     if (! gr_remove (group_name)) {
  1048. +         fprintf (stderr, "%s: error removing group entry\n", Prog);
  1049. +         exit (1);
  1050. +     }
  1051. + #ifdef    NDBM
  1052. + 
  1053. +     /*
  1054. +      * Update the DBM group file
  1055. +      */
  1056. + 
  1057. +     if (access ("/etc/group.pag", 0) == 0) {
  1058. +         if ((ogrp = getgrnam (group_name)) &&
  1059. +                 ! gr_dbm_remove (ogrp)) {
  1060. +             fprintf (stderr, "%s: error removing group dbm entry\n",
  1061. +                 Prog);
  1062. +             exit (1);
  1063. +         }
  1064. +     }
  1065. + #endif    /* NDBM */
  1066. + 
  1067. + #ifdef    SHADOWGRP
  1068. + 
  1069. +     /*
  1070. +      * Delete the shadow group entries as well.
  1071. +      */
  1072. + 
  1073. +     if (! sgr_remove (group_name)) {
  1074. +         fprintf (stderr, "%s: error removing shadow group entry\n",
  1075. +             Prog);
  1076. +         exit (1);
  1077. +     }
  1078. + #ifdef    NDBM
  1079. + 
  1080. +     /*
  1081. +      * Update the DBM shadow group file
  1082. +      */
  1083. + 
  1084. +     if (access ("/etc/gshadow.pag", 0) == 0) {
  1085. +         if (! sgr_dbm_remove (group_name)) {
  1086. +             fprintf (stderr,
  1087. +                 "%s: error removing shadow group dbm entry\n",
  1088. +                 Prog);
  1089. +             exit (1);
  1090. +         }
  1091. +     }
  1092. + #endif    /* NDBM */
  1093. + #endif    /* SHADOWGRP */
  1094. + #ifdef    USE_SYSLOG
  1095. +     syslog (LOG_INFO, "remove group `%s'\n", group_name);
  1096. + #endif    /* USE_SYSLOG */
  1097. + }
  1098. + 
  1099. + /*
  1100. +  * close_files - close all of the files that were opened
  1101. +  *
  1102. +  *    close_files() closes all of the files that were opened for this
  1103. +  *    new group.  This causes any modified entries to be written out.
  1104. +  */
  1105. + 
  1106. + close_files ()
  1107. + {
  1108. +     if (! gr_close ()) {
  1109. +         fprintf (stderr, "%s: cannot rewrite group file\n", Prog);
  1110. +         exit (1);
  1111. +     }
  1112. +     (void) gr_unlock ();
  1113. + #ifdef    SHADOWGRP
  1114. +     if (! sgr_close ()) {
  1115. +         fprintf (stderr, "%s: cannot rewrite shadow group file\n",
  1116. +             Prog);
  1117. +         exit (1);
  1118. +     }
  1119. +     (void) sgr_unlock ();
  1120. + #endif    /* SHADOWGRP */
  1121. + }
  1122. + 
  1123. + /*
  1124. +  * open_files - lock and open the group files
  1125. +  *
  1126. +  *    open_files() opens the two group files.
  1127. +  */
  1128. + 
  1129. + open_files ()
  1130. + {
  1131. +     if (! gr_lock ()) {
  1132. +         fprintf (stderr, "%s: unable to lock group file\n", Prog);
  1133. +         exit (1);
  1134. +     }
  1135. +     if (! gr_open (O_RDWR)) {
  1136. +         fprintf (stderr, "%s: unable to open group file\n", Prog);
  1137. +         exit (1);
  1138. +     }
  1139. + #ifdef    SHADOWGRP
  1140. +     if (! sgr_lock ()) {
  1141. +         fprintf (stderr, "%s: unable to lock shadow group file\n",
  1142. +             Prog);
  1143. +         exit (1);
  1144. +     }
  1145. +     if (! sgr_open (O_RDWR)) {
  1146. +         fprintf (stderr, "%s: unable to open shadow group file\n",
  1147. +             Prog);
  1148. +         exit (1);
  1149. +     }
  1150. + #endif    /* SHADOWGRP */
  1151. + }
  1152. + 
  1153. + /*
  1154. +  * main - groupdel command
  1155. +  *
  1156. +  *    The syntax of the groupdel command is
  1157. +  *    
  1158. +  *    groupdel group
  1159. +  *
  1160. +  *    The named group will be deleted.
  1161. +  */
  1162. + 
  1163. + main (argc, argv)
  1164. + int    argc;
  1165. + char    **argv;
  1166. + {
  1167. + 
  1168. +     /*
  1169. +      * Get my name so that I can use it to report errors.
  1170. +      */
  1171. + 
  1172. +     if (Prog = strrchr (argv[0], '/'))
  1173. +         Prog++;
  1174. +     else
  1175. +         Prog = argv[0];
  1176. + 
  1177. +     if (argc != 2)
  1178. +         usage ();
  1179. + 
  1180. +     strncpy (group_name, argv[1], BUFSIZ);
  1181. + 
  1182. + #ifdef    USE_SYSLOG
  1183. +     openlog (Prog, LOG_PID|LOG_CONS|LOG_NOWAIT, LOG_AUTH);
  1184. + #endif    /* USE_SYSLOG */
  1185. + 
  1186. +     /*
  1187. +      * The open routines for the DBM files don't use read-write
  1188. +      * as the mode, so we have to clue them in.
  1189. +      */
  1190. + 
  1191. + #ifdef    NDBM
  1192. +     gr_dbm_mode = O_RDWR;
  1193. + #ifdef    SHADOWGRP
  1194. +     sg_dbm_mode = O_RDWR;
  1195. + #endif    /* SHADOWGRP */
  1196. + #endif    /* NDBM */
  1197. + 
  1198. +     /*
  1199. +      * Start with a quick check to see if the group exists.
  1200. +      */
  1201. + 
  1202. +     if (! getgrnam (group_name)) {
  1203. +         fprintf (stderr, "%s: group %s does not exist\n",
  1204. +             Prog, group_name);
  1205. +         exit (9);
  1206. +     }
  1207. + 
  1208. +     /*
  1209. +      * Do the hard stuff - open the files, delete the group entries,
  1210. +      * then close and update the files.
  1211. +      */
  1212. + 
  1213. +     open_files ();
  1214. + 
  1215. +     grp_update ();
  1216. + 
  1217. +     close_files ();
  1218. +     exit (0);
  1219. +     /*NOTREACHED*/
  1220. + }
  1221. *** /dev/null    Wed Jun 26 09:26:31 1991
  1222. --- groupmod.c    Wed Jun 26 09:43:34 1991
  1223. ***************
  1224. *** 0 ****
  1225. --- 1,421 ----
  1226. + /*
  1227. +  * Copyright 1991, John F. Haugh II
  1228. +  * All rights reserved.
  1229. +  *
  1230. +  * Permission is granted to copy and create derivative works for any
  1231. +  * non-commercial purpose, provided this copyright notice is preserved
  1232. +  * in all copies of source code, or included in human readable form
  1233. +  * and conspicuously displayed on all copies of object code or
  1234. +  * distribution media.
  1235. +  */
  1236. + 
  1237. + #ifndef lint
  1238. + static    char    sccsid[] = "@(#)groupmod.c    3.1    22:59:07    6/13/91";
  1239. + #endif
  1240. + 
  1241. + #include <sys/types.h>
  1242. + #include <stdio.h>
  1243. + #include <grp.h>
  1244. + #include <ctype.h>
  1245. + #include <fcntl.h>
  1246. + 
  1247. + #ifdef    BSD
  1248. + #include <strings.h>
  1249. + #else
  1250. + #include <string.h>
  1251. + #endif
  1252. + 
  1253. + #include "config.h"
  1254. + #include "shadow.h"
  1255. + 
  1256. + #ifdef    USE_SYSLOG
  1257. + #include <syslog.h>
  1258. + #endif
  1259. + 
  1260. + char    group_name[BUFSIZ];
  1261. + char    group_newname[BUFSIZ];
  1262. + int    group_id;
  1263. + int    group_newid;
  1264. + 
  1265. + char    *Prog;
  1266. + 
  1267. + int    oflg;    /* permit non-unique group ID to be specified with -g         */
  1268. + int    gflg;    /* new ID value for the group                                 */
  1269. + int    nflg;    /* a new name has been specified for the group                */
  1270. + 
  1271. + #ifdef    NDBM
  1272. + extern    int    gr_dbm_mode;
  1273. + extern    int    sg_dbm_mode;
  1274. + #endif
  1275. + extern    char    *malloc();
  1276. + 
  1277. + extern    struct    group    *getgrnam();
  1278. + extern    struct    group    *gr_next();
  1279. + extern    struct    group    *gr_locate();
  1280. + extern    int    gr_lock();
  1281. + extern    int    gr_unlock();
  1282. + extern    int    gr_rewind();
  1283. + extern    int    gr_open();
  1284. + 
  1285. + #ifdef    SHADOWGRP
  1286. + extern    struct    sgrp    *sgr_locate();
  1287. + extern    int    sgr_lock();
  1288. + extern    int    sgr_unlock();
  1289. + extern    int    sgr_open();
  1290. + #endif
  1291. + 
  1292. + /*
  1293. +  * usage - display usage message and exit
  1294. +  */
  1295. + 
  1296. + usage ()
  1297. + {
  1298. +     fprintf (stderr, "usage: groupmod [-g gid [-o]] [-n name] group\n");
  1299. +     exit (2);
  1300. + }
  1301. + 
  1302. + /*
  1303. +  * new_grent - updates the values in a group file entry
  1304. +  *
  1305. +  *    new_grent() takes all of the values that have been entered and
  1306. +  *    fills in a (struct group) with them.
  1307. +  */
  1308. + 
  1309. + void
  1310. + new_grent (grent)
  1311. + struct    group    *grent;
  1312. + {
  1313. +     if (nflg)
  1314. +         grent->gr_name = strdup (group_newname);
  1315. + 
  1316. +     if (gflg)
  1317. +         grent->gr_gid = group_newid;
  1318. + }
  1319. + 
  1320. + #ifdef    SHADOWGRP
  1321. + /*
  1322. +  * new_sgent - updates the values in a shadow group file entry
  1323. +  *
  1324. +  *    new_sgent() takes all of the values that have been entered and
  1325. +  *    fills in a (struct sgrp) with them.
  1326. +  */
  1327. + 
  1328. + void
  1329. + new_sgent (sgent)
  1330. + struct    sgrp    *sgent;
  1331. + {
  1332. +     if (nflg)
  1333. +         sgent->sg_name = strdup (group_newname);
  1334. + }
  1335. + #endif    /* SHADOWGRP */
  1336. + 
  1337. + /*
  1338. +  * grp_update - update group file entries
  1339. +  *
  1340. +  *    grp_update() writes the new records to the group files.
  1341. +  */
  1342. + 
  1343. + void
  1344. + grp_update ()
  1345. + {
  1346. +     int    i;
  1347. +     struct    group    grp;
  1348. +     struct    group    *ogrp;
  1349. + #ifdef    SHADOWGRP
  1350. +     struct    sgrp    sgrp;
  1351. + #endif    /* SHADOWGRP */
  1352. + 
  1353. +     /*
  1354. +      * Create the initial entries for this new group.
  1355. +      */
  1356. + 
  1357. +     grp = *(gr_locate (group_name));
  1358. +     new_grent (&grp);
  1359. + #ifdef    SHADOWGRP
  1360. +     sgrp = *(sgr_locate (group_name));
  1361. +     new_sgent (&sgrp);
  1362. + #endif    /* SHADOWGRP */
  1363. + 
  1364. +     /*
  1365. +      * Write out the new group file entry.
  1366. +      */
  1367. + 
  1368. +     if (! gr_update (&grp)) {
  1369. +         fprintf (stderr, "%s: error adding new group entry\n", Prog);
  1370. +         exit (1);
  1371. +     }
  1372. +     if (nflg && ! gr_remove (group_name)) {
  1373. +         fprintf (stderr, "%s: error removing group entry\n", Prog);
  1374. +         exit (1);
  1375. +     }
  1376. + #ifdef    NDBM
  1377. + 
  1378. +     /*
  1379. +      * Update the DBM group file with the new entry as well.
  1380. +      */
  1381. + 
  1382. +     if (access ("/etc/group.pag", 0) == 0) {
  1383. +         if (! gr_dbm_update (&grp)) {
  1384. +             fprintf (stderr, "%s: cannot add new dbm group entry\n",
  1385. +                 Prog);
  1386. +             exit (1);
  1387. +         }
  1388. +         if (nflg && (ogrp = getgrnam (group_name)) &&
  1389. +                 ! gr_dbm_remove (ogrp)) {
  1390. +             fprintf (stderr, "%s: error removing group dbm entry\n",
  1391. +                 Prog);
  1392. +             exit (1);
  1393. +         }
  1394. +     }
  1395. + #endif    /* NDBM */
  1396. + 
  1397. + #ifdef    SHADOWGRP
  1398. + 
  1399. +     /*
  1400. +      * Write out the new shadow group entries as well.
  1401. +      */
  1402. + 
  1403. +     if (! sgr_update (&sgrp)) {
  1404. +         fprintf (stderr, "%s: error adding new group entry\n", Prog);
  1405. +         exit (1);
  1406. +     }
  1407. +     if (nflg && ! sgr_remove (group_name)) {
  1408. +         fprintf (stderr, "%s: error removing group entry\n", Prog);
  1409. +         exit (1);
  1410. +     }
  1411. + #ifdef    NDBM
  1412. + 
  1413. +     /*
  1414. +      * Update the DBM shadow group file with the new entry as well.
  1415. +      */
  1416. + 
  1417. +     if (access ("/etc/gshadow.pag", 0) == 0) {
  1418. +         if (! sgr_dbm_update (&sgrp)) {
  1419. +             fprintf (stderr,
  1420. +                 "%s: cannot add new dbm shadow group entry\n",
  1421. +                 Prog);
  1422. +             exit (1);
  1423. +         }
  1424. +         if (nflg && ! sgr_dbm_remove (group_name)) {
  1425. +             fprintf (stderr,
  1426. +                 "%s: error removing shadow group dbm entry\n",
  1427. +                 Prog);
  1428. +             exit (1);
  1429. +         }
  1430. +     }
  1431. + #endif    /* NDBM */
  1432. + #endif    /* SHADOWGRP */
  1433. + #ifdef    USE_SYSLOG
  1434. +     if (nflg)
  1435. +         syslog (LOG_INFO, "change group `%s' to `%s'\n",
  1436. +             group_name, group_newname);
  1437. + 
  1438. +     if (gflg)
  1439. +         syslog (LOG_INFO, "change gid for `%s' to %d\n",
  1440. +             nflg ? group_name:group_newname, group_newid);
  1441. + #endif    /* USE_SYSLOG */
  1442. + }
  1443. + 
  1444. + /*
  1445. +  * check_new_gid - check the new GID value for uniqueness
  1446. +  *
  1447. +  *    check_new_gid() insures that the new GID value is unique.
  1448. +  */
  1449. + 
  1450. + int
  1451. + check_new_gid ()
  1452. + {
  1453. +     /*
  1454. +      * First, the easy stuff.  If the ID can be duplicated, or if
  1455. +      * the ID didn't really change, just return.  If the ID didn't
  1456. +      * change, turn off those flags.  No sense doing needless work.
  1457. +      */
  1458. + 
  1459. +     if (oflg)
  1460. +         return 0;
  1461. + 
  1462. +     if (group_id == group_newid) {
  1463. +         gflg = 0;
  1464. +         return 0;
  1465. +     }
  1466. +     if (getgrgid (group_newid))
  1467. +         return -1;
  1468. + 
  1469. +     return 0;
  1470. + }
  1471. + 
  1472. + /*
  1473. +  * process_flags - perform command line argument setting
  1474. +  *
  1475. +  *    process_flags() interprets the command line arguments and sets
  1476. +  *    the values that the user will be created with accordingly.  The
  1477. +  *    values are checked for sanity.
  1478. +  */
  1479. + 
  1480. + void
  1481. + process_flags (argc, argv)
  1482. + int    argc;
  1483. + char    **argv;
  1484. + {
  1485. +     extern    int    optind;
  1486. +     extern    char    *optarg;
  1487. +     struct    group    *grp;
  1488. +     char    *end;
  1489. +     int    anyflag = 0;
  1490. +     int    arg;
  1491. + 
  1492. +     while ((arg = getopt (argc, argv, "og:n:")) != EOF) {
  1493. +         switch (arg) {
  1494. +             case 'g':
  1495. +                 gflg++;
  1496. +                 group_newid = strtol (optarg, &end, 10);
  1497. +                 if (*end != '\0') {
  1498. +                     fprintf (stderr, "%s: invalid group %s\n",
  1499. +                         Prog, optarg);
  1500. +                     exit (3);
  1501. +                 }
  1502. +                 break;
  1503. +             case 'n':
  1504. +                 if (strcmp (group_name, optarg)) {
  1505. +                     nflg++;
  1506. +                     strncpy (group_newname, optarg, BUFSIZ);
  1507. +                 }
  1508. +                 break;
  1509. +             case 'o':
  1510. +                 if (! gflg)
  1511. +                     usage ();
  1512. + 
  1513. +                 oflg++;
  1514. +                 break;
  1515. +             default:
  1516. +                 usage ();
  1517. +         }
  1518. +         anyflag++;
  1519. +     }
  1520. +     if (optind == argc - 1)
  1521. +         strcpy (group_name, argv[argc - 1]);
  1522. +     else
  1523. +         usage ();
  1524. + }
  1525. + 
  1526. + /*
  1527. +  * close_files - close all of the files that were opened
  1528. +  *
  1529. +  *    close_files() closes all of the files that were opened for this
  1530. +  *    new group.  This causes any modified entries to be written out.
  1531. +  */
  1532. + 
  1533. + close_files ()
  1534. + {
  1535. +     if (! gr_close ()) {
  1536. +         fprintf (stderr, "%s: cannot rewrite group file\n", Prog);
  1537. +         exit (1);
  1538. +     }
  1539. +     (void) gr_unlock ();
  1540. + #ifdef    SHADOWGRP
  1541. +     if (! sgr_close ()) {
  1542. +         fprintf (stderr, "%s: cannot rewrite shadow group file\n",
  1543. +             Prog);
  1544. +         exit (1);
  1545. +     }
  1546. +     (void) sgr_unlock ();
  1547. + #endif    /* SHADOWGRP */
  1548. + }
  1549. + 
  1550. + /*
  1551. +  * open_files - lock and open the group files
  1552. +  *
  1553. +  *    open_files() opens the two group files.
  1554. +  */
  1555. + 
  1556. + open_files ()
  1557. + {
  1558. +     if (! gr_lock ()) {
  1559. +         fprintf (stderr, "%s: unable to lock group file\n", Prog);
  1560. +         exit (1);
  1561. +     }
  1562. +     if (! gr_open (O_RDWR)) {
  1563. +         fprintf (stderr, "%s: unable to open group file\n", Prog);
  1564. +         exit (1);
  1565. +     }
  1566. + #ifdef    SHADOWGRP
  1567. +     if (! sgr_lock ()) {
  1568. +         fprintf (stderr, "%s: unable to lock shadow group file\n",
  1569. +             Prog);
  1570. +         exit (1);
  1571. +     }
  1572. +     if (! sgr_open (O_RDWR)) {
  1573. +         fprintf (stderr, "%s: unable to open shadow group file\n",
  1574. +             Prog);
  1575. +         exit (1);
  1576. +     }
  1577. + #endif    /* SHADOWGRP */
  1578. + }
  1579. + 
  1580. + /*
  1581. +  * main - groupmod command
  1582. +  *
  1583. +  *    The syntax of the groupmod command is
  1584. +  *    
  1585. +  *    groupmod [ -g gid [ -o ]] [ -n name ] group
  1586. +  *
  1587. +  *    The flags are
  1588. +  *        -g - specify a new group ID value
  1589. +  *        -o - permit the group ID value to be non-unique
  1590. +  *        -n - specify a new group name
  1591. +  */
  1592. + 
  1593. + main (argc, argv)
  1594. + int    argc;
  1595. + char    **argv;
  1596. + {
  1597. + 
  1598. +     /*
  1599. +      * Get my name so that I can use it to report errors.
  1600. +      */
  1601. + 
  1602. +     if (Prog = strrchr (argv[0], '/'))
  1603. +         Prog++;
  1604. +     else
  1605. +         Prog = argv[0];
  1606. + 
  1607. + #ifdef    USE_SYSLOG
  1608. +     openlog (Prog, LOG_PID|LOG_CONS|LOG_NOWAIT, LOG_AUTH);
  1609. + #endif    /* USE_SYSLOG */
  1610. + 
  1611. +     /*
  1612. +      * The open routines for the DBM files don't use read-write
  1613. +      * as the mode, so we have to clue them in.
  1614. +      */
  1615. + 
  1616. + #ifdef    NDBM
  1617. +     gr_dbm_mode = O_RDWR;
  1618. + #ifdef    SHADOWGRP
  1619. +     sg_dbm_mode = O_RDWR;
  1620. + #endif    /* SHADOWGRP */
  1621. + #endif    /* NDBM */
  1622. +     process_flags (argc, argv);
  1623. + 
  1624. +     /*
  1625. +      * Start with a quick check to see if the group exists.
  1626. +      */
  1627. + 
  1628. +     if (! getgrnam (group_name)) {
  1629. +         fprintf (stderr, "%s: group %s does not exist\n",
  1630. +             Prog, group_name);
  1631. +         exit (9);
  1632. +     }
  1633. + 
  1634. +     /*
  1635. +      * Do the hard stuff - open the files, create the group entries,
  1636. +      * then close and update the files.
  1637. +      */
  1638. + 
  1639. +     open_files ();
  1640. + 
  1641. +     grp_update ();
  1642. + 
  1643. +     close_files ();
  1644. +     exit (0);
  1645. +     /*NOTREACHED*/
  1646. + }
  1647. Index: useradd.c
  1648. *** rel3/useradd.c    Tue Jun 25 09:38:28 1991
  1649. --- useradd.c    Wed Jun 26 09:43:37 1991
  1650. ***************
  1651. *** 10,16 ****
  1652.    */
  1653.   
  1654.   #ifndef lint
  1655. ! static    char    sccsid[] = "@(#)useradd.c    3.2    20:15:10    6/11/91";
  1656.   #endif
  1657.   
  1658.   #include <sys/types.h>
  1659. --- 10,16 ----
  1660.    */
  1661.   
  1662.   #ifndef lint
  1663. ! static    char    sccsid[] = "@(#)useradd.c    3.4    09:39:58    6/26/91";
  1664.   #endif
  1665.   
  1666.   #include <sys/types.h>
  1667. ***************
  1668. *** 80,93 ****
  1669.   int    eflg;    /* days after password changed before it becomes expired      */
  1670.   int    Dflg;    /* set/show new user default values                           */
  1671.   
  1672. ! #if defined(DBM) || defined(NDBM)
  1673.   extern    int    pw_dbm_mode;
  1674. - #endif
  1675. - #ifdef    NDBM
  1676.   extern    int    sp_dbm_mode;
  1677.   extern    int    gr_dbm_mode;
  1678.   extern    int    sg_dbm_mode;
  1679.   #endif
  1680.   extern    FILE    *fopen();
  1681.   extern    int    fclose();
  1682.   extern    char    *malloc();
  1683. --- 80,93 ----
  1684.   int    eflg;    /* days after password changed before it becomes expired      */
  1685.   int    Dflg;    /* set/show new user default values                           */
  1686.   
  1687. ! #ifdef NDBM
  1688.   extern    int    pw_dbm_mode;
  1689.   extern    int    sp_dbm_mode;
  1690.   extern    int    gr_dbm_mode;
  1691. + #ifdef    SHADOWGRP
  1692.   extern    int    sg_dbm_mode;
  1693.   #endif
  1694. + #endif
  1695.   extern    FILE    *fopen();
  1696.   extern    int    fclose();
  1697.   extern    char    *malloc();
  1698. ***************
  1699. *** 372,378 ****
  1700.               else if (grp = getgrnam (cp))
  1701.                   def_group = grp->gr_gid;
  1702.               else
  1703. !                 fprintf (stderr, "%s: unknown group %s\n", cp);
  1704.           }
  1705.           
  1706.           /*
  1707. --- 372,379 ----
  1708.               else if (grp = getgrnam (cp))
  1709.                   def_group = grp->gr_gid;
  1710.               else
  1711. !                 fprintf (stderr, "%s: unknown group %s\n",
  1712. !                     Prog, cp);
  1713.           }
  1714.           
  1715.           /*
  1716. ***************
  1717. *** 638,644 ****
  1718.   usage ()
  1719.   {
  1720.       fprintf (stderr,
  1721. !         "usage:\tuseradd [-u uid [-o]] [-g group] [-G group,...] \n");
  1722.       fprintf (stderr,
  1723.           "\t\t[-d home] [-s shell] [-c comment] [-m [-k template]]\n");
  1724.       fprintf (stderr,
  1725. --- 639,645 ----
  1726.   usage ()
  1727.   {
  1728.       fprintf (stderr,
  1729. !         "usage:\t%s [-u uid [-o]] [-g group] [-G group,...] \n", Prog);
  1730.       fprintf (stderr,
  1731.           "\t\t[-d home] [-s shell] [-c comment] [-m [-k template]]\n");
  1732.       fprintf (stderr,
  1733. ***************
  1734. *** 645,651 ****
  1735.           "\t\t[-f inactive] [-e expire] name\n");
  1736.   
  1737.       fprintf (stderr,
  1738. !         "\tuseradd -D [-g group] [-b base] [-f inactive] [-e expire]\n");
  1739.   
  1740.       exit (1);
  1741.   }
  1742. --- 646,653 ----
  1743.           "\t\t[-f inactive] [-e expire] name\n");
  1744.   
  1745.       fprintf (stderr,
  1746. !         "\t%s -D [-g group] [-b base] [-f inactive] [-e expire]\n",
  1747. !             Prog);
  1748.   
  1749.       exit (1);
  1750.   }
  1751. ***************
  1752. *** 962,971 ****
  1753.                   if (! grp) {
  1754.                       fprintf (stderr,
  1755.                           "%s: unknown group %s\n",
  1756. !                         optarg);
  1757.                       exit (1);
  1758.                   }
  1759. !                 def_group = grp->gr_gid;
  1760.                   break;
  1761.               case 'G':
  1762.                   Gflg++;
  1763. --- 964,973 ----
  1764.                   if (! grp) {
  1765.                       fprintf (stderr,
  1766.                           "%s: unknown group %s\n",
  1767. !                         Prog, optarg);
  1768.                       exit (1);
  1769.                   }
  1770. !                 user_gid = grp->gr_gid;
  1771.                   break;
  1772.               case 'G':
  1773.                   Gflg++;
  1774. ***************
  1775. *** 1061,1068 ****
  1776. --- 1063,1072 ----
  1777.                   Prog);
  1778.               exit (1);
  1779.           }
  1780. +         (void) sgr_unlock ();
  1781.   #endif
  1782.       }
  1783. +     (void) spw_unlock ();
  1784.       (void) pw_unlock ();
  1785.   }
  1786.   
  1787. Index: userdel.c
  1788. *** rel3/userdel.c    Tue Jun 25 09:38:29 1991
  1789. --- userdel.c    Wed Jun 26 09:43:39 1991
  1790. ***************
  1791. *** 10,16 ****
  1792.    */
  1793.   
  1794.   #ifndef lint
  1795. ! static    char    sccsid[] = "@(#)userdel.c    3.5    20:53:04    6/13/91";
  1796.   #endif
  1797.   
  1798.   #include <sys/types.h>
  1799. --- 10,16 ----
  1800.    */
  1801.   
  1802.   #ifndef lint
  1803. ! static    char    sccsid[] = "@(#)userdel.c    3.7    09:40:05    6/26/91";
  1804.   #endif
  1805.   
  1806.   #include <sys/types.h>
  1807. ***************
  1808. *** 64,73 ****
  1809.   char    *Prog;
  1810.   int    rflg;
  1811.   
  1812. - #if defined(DBM) || defined(NDBM)
  1813. - extern    int    pw_dbm_mode;
  1814. - #endif
  1815.   #ifdef    NDBM
  1816.   extern    int    sp_dbm_mode;
  1817.   extern    int    gr_dbm_mode;
  1818.   #ifdef    SHADOWGRP
  1819. --- 64,71 ----
  1820.   char    *Prog;
  1821.   int    rflg;
  1822.   
  1823.   #ifdef    NDBM
  1824. + extern    int    pw_dbm_mode;
  1825.   extern    int    sp_dbm_mode;
  1826.   extern    int    gr_dbm_mode;
  1827.   #ifdef    SHADOWGRP
  1828. ***************
  1829. *** 147,153 ****
  1830.   
  1831.   usage ()
  1832.   {
  1833. !     fprintf (stderr, "usage: userdel [-r] name\n");
  1834.       exit (2);
  1835.   }
  1836.   
  1837. --- 145,151 ----
  1838.   
  1839.   usage ()
  1840.   {
  1841. !     fprintf (stderr, "usage: %s [-r] name\n", Prog);
  1842.       exit (2);
  1843.   }
  1844.   
  1845. ***************
  1846. *** 266,272 ****
  1847.   #endif
  1848.   #ifdef    USE_SYSLOG
  1849.           syslog (LOG_INFO, "delete `%s' from shadow group `%s'\n",
  1850. !             user_name, grp->gr_name);
  1851.   #endif
  1852.       }
  1853.   #endif
  1854. --- 264,270 ----
  1855.   #endif
  1856.   #ifdef    USE_SYSLOG
  1857.           syslog (LOG_INFO, "delete `%s' from shadow group `%s'\n",
  1858. !             user_name, sgrp->sg_name);
  1859.   #endif
  1860.       }
  1861.   #endif
  1862. ***************
  1863. *** 304,309 ****
  1864. --- 302,308 ----
  1865.       }
  1866.       (void) sgr_unlock ();
  1867.   #endif
  1868. +     (void) spw_unlock ();
  1869.       (void) pw_unlock ();
  1870.   }
  1871.   
  1872. Index: usermod.c
  1873. *** rel3/usermod.c    Tue Jun 25 09:38:29 1991
  1874. --- usermod.c    Wed Jun 26 09:43:42 1991
  1875. ***************
  1876. *** 10,16 ****
  1877.    */
  1878.   
  1879.   #ifndef lint
  1880. ! static    char    sccsid[] = "@(#)usermod.c    3.2    20:26:57    6/11/91";
  1881.   #endif
  1882.   
  1883.   #include <sys/types.h>
  1884. --- 10,16 ----
  1885.    */
  1886.   
  1887.   #ifndef lint
  1888. ! static    char    sccsid[] = "@(#)usermod.c    3.3    09:29:57    6/26/91";
  1889.   #endif
  1890.   
  1891.   #include <sys/types.h>
  1892. ***************
  1893. *** 57,63 ****
  1894.   char    user_shell[BUFSIZ];
  1895.   long    user_expire;
  1896.   long    user_inactive;
  1897. ! int    user_ngroups;
  1898.   gid_t    user_groups[NGROUPS_MAX];
  1899.   struct    passwd    user_pwd;
  1900.   struct    spwd    user_spwd;
  1901. --- 57,63 ----
  1902.   char    user_shell[BUFSIZ];
  1903.   long    user_expire;
  1904.   long    user_inactive;
  1905. ! int    user_ngroups = -1;
  1906.   gid_t    user_groups[NGROUPS_MAX];
  1907.   struct    passwd    user_pwd;
  1908.   struct    spwd    user_spwd;
  1909. ***************
  1910. *** 76,89 ****
  1911.   int    eflg;    /* days after password changed before it becomes expired      */
  1912.   int    lflg;    /* new user name for user                                     */
  1913.   
  1914. - #if defined(DBM) || defined(NDBM)
  1915. - extern    int    pw_dbm_mode;
  1916. - #endif
  1917.   #ifdef    NDBM
  1918.   extern    int    sp_dbm_mode;
  1919.   extern    int    gr_dbm_mode;
  1920.   extern    int    sg_dbm_mode;
  1921.   #endif
  1922.   extern    FILE    *fopen();
  1923.   extern    int    fclose();
  1924.   extern    char    *malloc();
  1925. --- 76,89 ----
  1926.   int    eflg;    /* days after password changed before it becomes expired      */
  1927.   int    lflg;    /* new user name for user                                     */
  1928.   
  1929.   #ifdef    NDBM
  1930. + extern    int    pw_dbm_mode;
  1931.   extern    int    sp_dbm_mode;
  1932.   extern    int    gr_dbm_mode;
  1933. + #ifdef    SHADOWGRP
  1934.   extern    int    sg_dbm_mode;
  1935.   #endif
  1936. + #endif
  1937.   extern    FILE    *fopen();
  1938.   extern    int    fclose();
  1939.   extern    char    *malloc();
  1940. ***************
  1941. *** 848,854 ****
  1942.                   if (! grp) {
  1943.                       fprintf (stderr,
  1944.                           "%s: unknown group %s\n",
  1945. !                         optarg);
  1946.                       exit (1);
  1947.                   }
  1948.                   if (grp->gr_gid != user_gid) {
  1949. --- 848,854 ----
  1950.                   if (! grp) {
  1951.                       fprintf (stderr,
  1952.                           "%s: unknown group %s\n",
  1953. !                         Prog, optarg);
  1954.                       exit (1);
  1955.                   }
  1956.                   if (grp->gr_gid != user_gid) {
  1957. ***************
  1958. *** 907,912 ****
  1959. --- 907,916 ----
  1960.           }
  1961.           anyflag++;
  1962.       }
  1963. +     if (anyflag == 0) {
  1964. +         fprintf (stderr, "%s: no flags given\n", Prog);
  1965. +         exit (1);
  1966. +     }
  1967.       if (optind != argc - 1)
  1968.           usage ();
  1969.   
  1970. ***************
  1971. *** 917,923 ****
  1972.           uflg = oflg = 0;
  1973.   
  1974.       if (lflg && getpwnam (user_newname)) {
  1975. !         fprintf (stderr, "%s: user %s exists\n", user_newname);
  1976.           exit (9);
  1977.       }
  1978.   }
  1979. --- 921,927 ----
  1980.           uflg = oflg = 0;
  1981.   
  1982.       if (lflg && getpwnam (user_newname)) {
  1983. !         fprintf (stderr, "%s: user %s exists\n", Prog, user_newname);
  1984.           exit (9);
  1985.       }
  1986.   }
  1987. ***************
  1988. *** 940,946 ****
  1989.               Prog);
  1990.           exit (1);
  1991.       }
  1992. !     if (user_ngroups > 0) {
  1993.           if (! gr_close ()) {
  1994.               fprintf (stderr, "%s: cannot rewrite group file\n",
  1995.                   Prog);
  1996. --- 944,950 ----
  1997.               Prog);
  1998.           exit (1);
  1999.       }
  2000. !     if (user_ngroups >= 0) {
  2001.           if (! gr_close ()) {
  2002.               fprintf (stderr, "%s: cannot rewrite group file\n",
  2003.                   Prog);
  2004. ***************
  2005. *** 953,960 ****
  2006. --- 957,966 ----
  2007.                   Prog);
  2008.               exit (1);
  2009.           }
  2010. +         (void) sgr_unlock ();
  2011.   #endif
  2012.       }
  2013. +     (void) spw_unlock ();
  2014.       (void) pw_unlock ();
  2015.   }
  2016.   
  2017. ***************
  2018. *** 1009,1019 ****
  2019.   
  2020.       if (lflg || uflg || gflg || cflg || dflg || sflg) {
  2021.           if (! pw_update (&pwent)) {
  2022. !             fprintf (stderr, "%s: error changing password entry\n");
  2023.               exit (1);
  2024.           }
  2025.           if (lflg && ! pw_remove (user_name)) {
  2026. !             fprintf (stderr, "%s: error removing password entry\n");
  2027.               exit (1);
  2028.           }
  2029.   #if defined(DBM) || defined(NDBM)
  2030. --- 1015,1027 ----
  2031.   
  2032.       if (lflg || uflg || gflg || cflg || dflg || sflg) {
  2033.           if (! pw_update (&pwent)) {
  2034. !             fprintf (stderr, "%s: error changing password entry\n",
  2035. !                 Prog);
  2036.               exit (1);
  2037.           }
  2038.           if (lflg && ! pw_remove (user_name)) {
  2039. !             fprintf (stderr, "%s: error removing password entry\n",
  2040. !                 Prog);
  2041.               exit (1);
  2042.           }
  2043.   #if defined(DBM) || defined(NDBM)
  2044. Index: shadowio.c
  2045. *** rel3/shadowio.c    Tue Jun 25 09:37:59 1991
  2046. --- shadowio.c    Wed Jun 26 09:43:44 1991
  2047. ***************
  2048. *** 24,30 ****
  2049.    */
  2050.   
  2051.   #ifndef    lint
  2052. ! static    char    sccsid[] = "@(#)shadowio.c    3.5    09:08:15    5/28/91";
  2053.   #endif
  2054.   
  2055.   #include <sys/types.h>
  2056. --- 24,30 ----
  2057.    */
  2058.   
  2059.   #ifndef    lint
  2060. ! static    char    sccsid[] = "@(#)shadowio.c    3.6    09:17:38    6/26/91";
  2061.   #endif
  2062.   
  2063.   #include <sys/types.h>
  2064. ***************
  2065. *** 338,351 ****
  2066.   spw_close ()
  2067.   {
  2068.       char    backup[BUFSIZ];
  2069. -     int    fd;
  2070.       int    mask;
  2071.       int    c;
  2072. -     int    i;
  2073.       int    errors = 0;
  2074.       FILE    *bkfp;
  2075.       struct    spw_file_entry *spwf;
  2076. !     struct    spw_file_entry *ospwf;
  2077.   
  2078.       if (! isopen) {
  2079.           errno = EINVAL;
  2080. --- 338,349 ----
  2081.   spw_close ()
  2082.   {
  2083.       char    backup[BUFSIZ];
  2084.       int    mask;
  2085.       int    c;
  2086.       int    errors = 0;
  2087.       FILE    *bkfp;
  2088.       struct    spw_file_entry *spwf;
  2089. !     struct    stat    sb;
  2090.   
  2091.       if (! isopen) {
  2092.           errno = EINVAL;
  2093. ***************
  2094. *** 361,372 ****
  2095.       strcat (backup, "-");
  2096.   
  2097.       if (open_modes == O_RDWR && sp_changed) {
  2098. !         mask = umask (077);
  2099.           if ((bkfp = fopen (backup, "w")) == 0) {
  2100.               umask (mask);
  2101.               return 0;
  2102.           }
  2103.           umask (mask);
  2104.   
  2105.           rewind (spwfp);
  2106.           while ((c = getc (spwfp)) != EOF) {
  2107. --- 359,372 ----
  2108.       strcat (backup, "-");
  2109.   
  2110.       if (open_modes == O_RDWR && sp_changed) {
  2111. !         mask = umask (0377);
  2112.           if ((bkfp = fopen (backup, "w")) == 0) {
  2113.               umask (mask);
  2114.               return 0;
  2115.           }
  2116.           umask (mask);
  2117. +         fstat (fileno (spwfp), &sb);
  2118. +         chown (backup, sb.st_uid, sb.st_gid);
  2119.   
  2120.           rewind (spwfp);
  2121.           while ((c = getc (spwfp)) != EOF) {
  2122. ***************
  2123. *** 381,387 ****
  2124.           isopen = 0;
  2125.           (void) fclose (spwfp);
  2126.   
  2127. !         mask = umask (077);
  2128.           if (! (spwfp = fopen (spw_filename, "w"))) {
  2129.               umask (mask);
  2130.               return 0;
  2131. --- 381,387 ----
  2132.           isopen = 0;
  2133.           (void) fclose (spwfp);
  2134.   
  2135. !         mask = umask (0377);
  2136.           if (! (spwfp = fopen (spw_filename, "w"))) {
  2137.               umask (mask);
  2138.               return 0;
  2139. ***************
  2140. *** 429,434 ****
  2141. --- 429,435 ----
  2142.           free (spwf);
  2143.       }
  2144.       spwf_tail = 0;
  2145. +     isopen = 0;
  2146.       return 1;
  2147.   }
  2148.   
  2149. Index: groupio.c
  2150. *** rel3/groupio.c    Tue Jun 25 09:37:51 1991
  2151. --- groupio.c    Wed Jun 26 09:43:47 1991
  2152. ***************
  2153. *** 36,42 ****
  2154.   #endif
  2155.   
  2156.   #ifndef    lint
  2157. ! static    char    sccsid[] = "@(#)groupio.c    3.7 09:07:28 5/28/91";
  2158.   #endif
  2159.   
  2160.   static    int    islocked;
  2161. --- 36,42 ----
  2162.   #endif
  2163.   
  2164.   #ifndef    lint
  2165. ! static    char    sccsid[] = "@(#)groupio.c    3.8 09:03:34 6/26/91";
  2166.   #endif
  2167.   
  2168.   static    int    islocked;
  2169. ***************
  2170. *** 365,370 ****
  2171. --- 365,371 ----
  2172.       FILE    *bkfp;
  2173.       struct    gr_file_entry *grf;
  2174.       struct    gr_file_entry *ogrf;
  2175. +     struct    stat    sb;
  2176.   
  2177.       if (! isopen) {
  2178.           errno = EINVAL;
  2179. ***************
  2180. *** 386,391 ****
  2181. --- 387,394 ----
  2182.               return 0;
  2183.           }
  2184.           umask (mask);
  2185. +         fstat (fileno (grfp), &sb);
  2186. +         chown (backup, sb.st_uid, sb.st_gid);
  2187.   
  2188.           rewind (grfp);
  2189.           while ((c = getc (grfp)) != EOF) {
  2190. ***************
  2191. *** 448,453 ****
  2192. --- 451,457 ----
  2193.           free (grf);
  2194.       }
  2195.       grf_tail = 0;
  2196. +     isopen = 0;
  2197.       return 1;
  2198.   }
  2199.   
  2200. Index: sgroupio.c
  2201. *** rel3/sgroupio.c    Tue Jun 25 09:38:10 1991
  2202. --- sgroupio.c    Wed Jun 26 09:43:49 1991
  2203. ***************
  2204. *** 38,44 ****
  2205.   #include "shadow.h"
  2206.   
  2207.   #ifndef    lint
  2208. ! static    char    sccsid[] = "@(#)sgroupio.c    3.3    07:06:36    6/6/91";
  2209.   #endif
  2210.   
  2211.   static    int    islocked;
  2212. --- 38,44 ----
  2213.   #include "shadow.h"
  2214.   
  2215.   #ifndef    lint
  2216. ! static    char    sccsid[] = "@(#)sgroupio.c    3.4    09:11:25    6/26/91";
  2217.   #endif
  2218.   
  2219.   static    int    islocked;
  2220. ***************
  2221. *** 369,382 ****
  2222.   sgr_close ()
  2223.   {
  2224.       char    backup[BUFSIZ];
  2225. -     int    fd;
  2226.       int    mask;
  2227.       int    c;
  2228. -     int    i;
  2229.       int    errors = 0;
  2230.       FILE    *bkfp;
  2231.       struct    sg_file_entry *sgrf;
  2232. !     struct    sg_file_entry *osgrf;
  2233.   
  2234.       if (! isopen) {
  2235.           errno = EINVAL;
  2236. --- 369,380 ----
  2237.   sgr_close ()
  2238.   {
  2239.       char    backup[BUFSIZ];
  2240.       int    mask;
  2241.       int    c;
  2242.       int    errors = 0;
  2243.       FILE    *bkfp;
  2244.       struct    sg_file_entry *sgrf;
  2245. !     struct    stat    sb;
  2246.   
  2247.       if (! isopen) {
  2248.           errno = EINVAL;
  2249. ***************
  2250. *** 398,403 ****
  2251. --- 396,403 ----
  2252.               return 0;
  2253.           }
  2254.           umask (mask);
  2255. +         fstat (fileno (sgrfp), &sb);
  2256. +         chown (backup, sb.st_uid, sb.st_gid);
  2257.   
  2258.           rewind (sgrfp);
  2259.           while ((c = getc (sgrfp)) != EOF) {
  2260. ***************
  2261. *** 460,465 ****
  2262. --- 460,466 ----
  2263.           free (sgrf);
  2264.       }
  2265.       sgr_tail = 0;
  2266. +     isopen = 0;
  2267.       return 1;
  2268.   }
  2269.   
  2270. Index: pwio.c
  2271. *** rel3/pwio.c    Tue Jun 25 09:37:56 1991
  2272. --- pwio.c    Wed Jun 26 09:43:52 1991
  2273. ***************
  2274. *** 37,43 ****
  2275.   #endif
  2276.   
  2277.   #ifndef lint
  2278. ! static    char    sccsid[] = "@(#)pwio.c    3.7    09:08:02    5/28/91";
  2279.   #endif
  2280.   
  2281.   static    int    islocked;
  2282. --- 37,43 ----
  2283.   #endif
  2284.   
  2285.   #ifndef lint
  2286. ! static    char    sccsid[] = "@(#)pwio.c    3.8    09:04:48    6/26/91";
  2287.   #endif
  2288.   
  2289.   static    int    islocked;
  2290. ***************
  2291. *** 361,366 ****
  2292. --- 361,367 ----
  2293.       FILE    *bkfp;
  2294.       struct    pw_file_entry *pwf;
  2295.       struct    pw_file_entry *opwf;
  2296. +     struct    stat    sb;
  2297.   
  2298.       if (! isopen) {
  2299.           errno = EINVAL;
  2300. ***************
  2301. *** 376,387 ****
  2302.       strcat (backup, "-");
  2303.   
  2304.       if (open_modes == O_RDWR && pw_changed) {
  2305. !         mask = umask (022);
  2306.           if ((bkfp = fopen (backup, "w")) == 0) {
  2307.               umask (mask);
  2308.               return 0;
  2309.           }
  2310.           umask (mask);
  2311.   
  2312.           rewind (pwfp);
  2313.           while ((c = getc (pwfp)) != EOF) {
  2314. --- 377,390 ----
  2315.       strcat (backup, "-");
  2316.   
  2317.       if (open_modes == O_RDWR && pw_changed) {
  2318. !         mask = umask (0222);
  2319.           if ((bkfp = fopen (backup, "w")) == 0) {
  2320.               umask (mask);
  2321.               return 0;
  2322.           }
  2323.           umask (mask);
  2324. +         fstat (fileno (pwfp), &sb);
  2325. +         chown (backup, sb.st_uid, sb.st_gid);
  2326.   
  2327.           rewind (pwfp);
  2328.           while ((c = getc (pwfp)) != EOF) {
  2329. ***************
  2330. *** 396,402 ****
  2331.           isopen = 0;
  2332.           (void) fclose (pwfp);
  2333.   
  2334. !         mask = umask (022);
  2335.           if (! (pwfp = fopen (pw_filename, "w"))) {
  2336.               umask (mask);
  2337.               return 0;
  2338. --- 399,405 ----
  2339.           isopen = 0;
  2340.           (void) fclose (pwfp);
  2341.   
  2342. !         mask = umask (0222);
  2343.           if (! (pwfp = fopen (pw_filename, "w"))) {
  2344.               umask (mask);
  2345.               return 0;
  2346. ***************
  2347. *** 443,448 ****
  2348. --- 446,452 ----
  2349.           free (pwf);
  2350.       }
  2351.       pwf_tail = 0;
  2352. +     isopen = 0;
  2353.       return 1;
  2354.   }
  2355.   
  2356. Index: chage.c
  2357. *** rel3/chage.c    Tue Jun 25 09:38:02 1991
  2358. --- chage.c    Wed Jun 26 09:43:59 1991
  2359. ***************
  2360. *** 17,23 ****
  2361.   #include <time.h>
  2362.   
  2363.   #ifndef    lint
  2364. ! static    char    sccsid[] = "@(#)chage.c    3.7    06:35:00    5/29/91";
  2365.   #endif
  2366.   
  2367.   /*
  2368. --- 17,23 ----
  2369.   #include <time.h>
  2370.   
  2371.   #ifndef    lint
  2372. ! static    char    sccsid[] = "@(#)chage.c    3.8    09:01:54    6/26/91";
  2373.   #endif
  2374.   
  2375.   /*
  2376. ***************
  2377. *** 406,418 ****
  2378.   char    **argv;
  2379.   {
  2380.       int    flag;
  2381. !     int    lflg;
  2382. !     int    mflg;
  2383. !     int    Mflg;
  2384. !     int    dflg;
  2385. !     int    Wflg;
  2386. !     int    Iflg;
  2387. !     int    Eflg;
  2388.       int    ruid = getuid ();
  2389.       struct    passwd    *pw;
  2390.       struct    passwd    pwent;
  2391. --- 406,418 ----
  2392.   char    **argv;
  2393.   {
  2394.       int    flag;
  2395. !     int    lflg = 0;
  2396. !     int    mflg = 0;
  2397. !     int    Mflg = 0;
  2398. !     int    dflg = 0;
  2399. !     int    Wflg = 0;
  2400. !     int    Iflg = 0;
  2401. !     int    Eflg = 0;
  2402.       int    ruid = getuid ();
  2403.       struct    passwd    *pw;
  2404.       struct    passwd    pwent;
  2405. Index: obscure.c
  2406. *** rel3/obscure.c    Tue Jun 25 09:37:55 1991
  2407. --- obscure.c    Wed Jun 26 09:44:01 1991
  2408. ***************
  2409. *** 21,27 ****
  2410.   #include "config.h"
  2411.   
  2412.   #ifndef    lint
  2413. ! static    char    sccsid[] = "@(#)obscure.c    3.2    09:07:51    5/28/91";
  2414.   #endif
  2415.   
  2416.   #ifdef    NO_STRSTR
  2417. --- 21,27 ----
  2418.   #include "config.h"
  2419.   
  2420.   #ifndef    lint
  2421. ! static    char    sccsid[] = "@(#)obscure.c    3.3    09:05:34    6/26/91";
  2422.   #endif
  2423.   
  2424.   #ifdef    NO_STRSTR
  2425. ***************
  2426. *** 95,101 ****
  2427.       if (similiar (newmono, oldmono))    /* jumbled version */
  2428.           return (0);
  2429.   
  2430. !     if (simple (new, old))            /* keyspace size */
  2431.           return (0);
  2432.   
  2433.       strcpy (wrapped, oldmono);
  2434. --- 95,101 ----
  2435.       if (similiar (newmono, oldmono))    /* jumbled version */
  2436.           return (0);
  2437.   
  2438. !     if (simple (old, new))            /* keyspace size */
  2439.           return (0);
  2440.   
  2441.       strcpy (wrapped, oldmono);
  2442. -- 
  2443. John F. Haugh II        | Distribution to  | UUCP: ...!cs.utexas.edu!rpp386!jfh
  2444. Ma Bell: (512) 255-8251 | GEnie PROHIBITED :-) |  Domain: jfh@rpp386.cactus.org
  2445. "UNIX signals are not interrupts.  Worse, SIGCHLD/SIGCLD is not even a UNIX
  2446.  signal, it's an abomination."  -- Doug Gwyn
  2447.