home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3348 / gshadow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-17  |  4.5 KB  |  284 lines
  1. /*
  2.  * Copyright 1990, John F. Haugh II
  3.  * All rights reserved.
  4.  *
  5.  * Permission is granted to copy and create derivative works for any
  6.  * non-commercial purpose, provided this copyright notice is preserved
  7.  * in all copies of source code, or included in human readable form
  8.  * and conspicuously displayed on all copies of object code or
  9.  * distribution media.
  10.  */
  11.  
  12. #include "shadow.h"
  13. #include "config.h"
  14. #include <stdio.h>
  15. #ifndef    BSD
  16. #include <string.h>
  17. #include <memory.h>
  18. #else
  19. #include <strings.h>
  20. #define    strchr    index
  21. #define    strrchr    rindex
  22. #endif
  23.  
  24. #ifdef    NDBM
  25. #include <ndbm.h>
  26. #include <fcntl.h>
  27. DBM    *sg_dbm;
  28. int    sg_dbm_mode;
  29. static    int    dbmopened;
  30. static    int    dbmerror;
  31. #endif
  32.  
  33.  
  34. #ifndef    lint
  35. static    char    sccsid[] = "@(#)gshadow.c    3.3    11:25:55    12/19/90";
  36. #endif
  37.  
  38. #define    MAXMEM    1024
  39.  
  40. static    FILE    *shadow;
  41. static    char    *sgrpfile = "/etc/gshadow";
  42. static    char    sgrbuf[BUFSIZ*4];
  43. static    char    *members[MAXMEM+1];
  44. static    char    *admins[MAXMEM+1];
  45. static    struct    sgrp    sgroup;
  46.  
  47. extern    char    *fgetsx();
  48. extern    int    fputsx();
  49.  
  50. #define    FIELDS    4
  51.  
  52. static char **
  53. list (s, l)
  54. char    *s;
  55. char    **l;
  56. {
  57.     int    nmembers = 0;
  58.  
  59.     while (*s) {
  60.         l[nmembers++] = s;
  61.         if (s = strchr (s, ','))
  62.             *s++ = '\0';
  63.     }
  64.     l[nmembers] = (char *) 0;
  65.     return l;
  66. }
  67.  
  68. void
  69. setsgent ()
  70. {
  71. #ifdef    NDBM
  72.     int    mode;
  73. #endif    /* NDBM */
  74.  
  75.     if (shadow)
  76.         rewind (shadow);
  77.     else
  78.         shadow = fopen (GSHADOW, "r");
  79.  
  80.     /*
  81.      * Attempt to open the DBM files if they have never been opened
  82.      * and an error has never been returned.
  83.      */
  84.  
  85. #ifdef NDBM
  86.     if (! dbmerror && ! dbmopened) {
  87.         char    dbmfiles[BUFSIZ];
  88.  
  89.         strcpy (dbmfiles, sgrpfile);
  90.         strcat (dbmfiles, ".pag");
  91.         if (sg_dbm_mode != -1)
  92.             mode = O_RDONLY;
  93.         else
  94.             mode = (sg_dbm_mode == O_RDONLY ||
  95.                 sg_dbm_mode == O_RDWR) ? sg_dbm_mode:O_RDONLY;
  96.  
  97.         if (access (dbmfiles, 0) ||
  98.             (! (sg_dbm = dbm_open (sgrpfile, mode, 0))))
  99.             dbmerror = 1;
  100.         else
  101.             dbmopened = 1;
  102.     }
  103. #endif    /* NDBM */
  104. }
  105.  
  106. void
  107. endsgent ()
  108. {
  109.     if (shadow)
  110.         (void) fclose (shadow);
  111.  
  112.     shadow = (FILE *) 0;
  113. #ifdef    NDBM
  114.     if (dbmopened && sg_dbm) {
  115.         dbm_close (sg_dbm);
  116.         dbmopened = 0;
  117.         sg_dbm = 0;
  118.     }
  119. #endif
  120. }
  121.  
  122. struct sgrp *
  123. sgetsgent (string)
  124. char    *string;
  125. {
  126.     char    *fields[FIELDS];
  127.     char    *cp;
  128.     char    *cpp;
  129.     int    atoi ();
  130.     long    atol ();
  131.     int    i;
  132.  
  133.     strncpy (sgrbuf, string, sizeof sgrbuf - 1);
  134.     sgrbuf[sizeof sgrbuf - 1] = '\0';
  135.  
  136.     if (cp = strrchr (sgrbuf, '\n'))
  137.         *cp = '\0';
  138.  
  139.     for (cp = sgrbuf, i = 0;*cp && i < FIELDS;i++) {
  140.         fields[i] = cp;
  141.         while (*cp && *cp != ':')
  142.             cp++;
  143.  
  144.         if (*cp)
  145.             *cp++ = '\0';
  146.     }
  147.     if (*cp || i != FIELDS)
  148.         return 0;
  149.  
  150.     sgroup.sg_name = fields[0];
  151.     sgroup.sg_passwd = fields[1];
  152.     sgroup.sg_adm = list (fields[2], admins);
  153.     sgroup.sg_mem = list (fields[3], members);
  154.  
  155.     return &sgroup;
  156. }
  157.  
  158. struct sgrp
  159. *fgetsgent (fp)
  160. FILE    *fp;
  161. {
  162.     char    buf[sizeof sgrbuf];
  163.  
  164.     if (! fp)
  165.         return (0);
  166.  
  167.     if (fgetsx (buf, sizeof buf, fp) == (char *) 0)
  168.         return (0);
  169.  
  170.     return sgetsgent (buf);
  171. }
  172.  
  173. struct sgrp
  174. *getsgent ()
  175. {
  176.     if (! shadow)
  177.         setsgent ();
  178.  
  179.     return (fgetsgent (shadow));
  180. }
  181.  
  182. struct sgrp *
  183. getsgnam (name)
  184. char    *name;
  185. {
  186.     struct    sgrp    *sgrp;
  187. #ifdef NDBM
  188.     datum    key;
  189.     datum    content;
  190. #endif
  191.  
  192.     setsgent ();
  193.  
  194. #ifdef NDBM
  195.  
  196.     /*
  197.      * If the DBM file are now open, create a key for this group and
  198.      * try to fetch the entry from the database.  A matching record
  199.      * will be unpacked into a static structure and returned to
  200.      * the user.
  201.      */
  202.  
  203.     if (dbmopened) {
  204.         key.dsize = strlen (name);
  205.         key.dptr = name;
  206.  
  207.         content = dbm_fetch (sg_dbm, key);
  208.         if (content.dptr != 0) {
  209.             memcpy (sgrbuf, content.dptr, content.dsize);
  210.             sgroup.sg_mem = members;
  211.             sgroup.sg_adm = admins;
  212.             sgr_unpack (sgrbuf, content.dsize, &sgroup);
  213.             return &sgroup;
  214.         }
  215.     }
  216. #endif
  217.     while ((sgrp = getsgent ()) != (struct sgrp *) 0) {
  218.         if (strcmp (name, sgrp->sg_name) == 0)
  219.             return (sgrp);
  220.     }
  221.     return (0);
  222. }
  223.  
  224. int
  225. putsgent (sgrp, fp)
  226. struct    sgrp    *sgrp;
  227. FILE    *fp;
  228. {
  229.     char    buf[sizeof sgrbuf];
  230.     char    *cp = buf;
  231.     int    errors = 0;
  232.     int    i;
  233.  
  234.     if (! fp || ! sgrp)
  235.         return -1;
  236.  
  237.     /*
  238.      * Copy the group name and passwd.
  239.      */
  240.  
  241.     strcpy (cp, sgrp->sg_name);
  242.     cp += strlen (cp);
  243.     *cp++ = ':';
  244.  
  245.     strcpy (cp, sgrp->sg_passwd);
  246.     cp += strlen (cp);
  247.     *cp++ = ':';
  248.  
  249.     /*
  250.      * Copy the administrators, separating each from the other
  251.      * with a ",".
  252.      */
  253.  
  254.     for (i = 0;sgrp->sg_adm[i];i++) {
  255.         if (i > 0)
  256.             *cp++ = ',';
  257.  
  258.         strcpy (cp, sgrp->sg_adm[i]);
  259.         cp += strlen (cp);
  260.     }
  261.     *cp++ = ':';
  262.  
  263.     /*
  264.      * Now do likewise with the group members.
  265.      */
  266.  
  267.     for (i = 0;sgrp->sg_mem[i];i++) {
  268.         if (i > 0)
  269.             *cp++ = ',';
  270.  
  271.         strcpy (cp, sgrp->sg_mem[i]);
  272.         cp += strlen (cp);
  273.     }
  274.     *cp++ = '\n';
  275.     *cp = '\0';
  276.  
  277.     /*
  278.      * Output using the function which understands the line
  279.      * continuation conventions.
  280.      */
  281.  
  282.     return fputsx (buf, fp);
  283. }
  284.