BSD 4_1c_2 release

[unix-history] / usr / src / usr.lib / undoc / libpriv / wrtprivf.c

/*      @(#)wrtprivf.c  4.9     (Melbourne)     82/07/17        */

#include <stdio.h>
#include <ctype.h>
#include <sys/vlimit.h>
#include <sys/types.h>
#include <sys/quota.h>
#include <udata.h>
#include <lpdquota.h>
#include <mushmuck.h>
#include <grp.h>

static  struct  udata           udata;
static  struct  mushmuck        mm;
static  struct  lpquota         lpdq;
static  struct  dquot           dqb[16];
static  char                    dqfn[16][32];

int     psval(), plval(), psecs(), pmins(), pdate(), pbits(), pflags(), pgrps(),
       psflags(), pchar(), pdquot(), praise(), pmem(), psoct(), pnolog();

static FILE *fd;

static  struct  kwtab   {
       char    *kwname;
       int     (*kwfunc)();
       char    *kwcmt;
       char    *kwptr;
} kwtab[] = {
       "shares",       psval,  "",                     (char *)&mm.mm_qu.qu_shares,
       "plimit",       psval,  "max number of processes",(char *)&mm.mm_qu.qu_plim,
       "class",        pbits,  "user classes",         (char *)&mm.mm_qu.qu_class,
       "groups",       pgrps,  "system file access groups",    (char *)&udata.ud_grps,
       "umask",        psoct,  "initial umask",                (char *)&udata.ud_umask,
       "syflags",      psflags, "system flags",        (char *)&mm.mm_qu.qu_syflags,
       "flags",        pflags, "other flags",          (char *)&udata.ud_flags[0],
       "ttyclass",     pbits,  "permitted terminal classes",           (char *)&udata.ud_ttys,
       "expires",      pdate,  "Account expiry date",          (char *)&udata.ud_expires,
       "nologins",     pnolog, "",                             (char *)0,
       "maxsimul",     pchar,  "maximum simultaneous logins",  (char *)&udata.ud_maxlogin,
       "maxlogin",     psecs,  "maximum login time (hr:min:sec)",              (char *)&mm.mm_maxuse,
       "maxlsess",     pmins,  "maximum login session (hr:min)",               (char *)&mm.mm_smax,
       "sessgap",      pmins,  "gap between sessions (hr:min)",                (char *)&mm.mm_lgap,
       "sessleft",     pmins,  "time left in current session (hr:min)",        (char *)&mm.mm_left,
       "weeklmax",     pmins,  "max week's login time (hr:min)",               (char *)&mm.mm_wmax,
       "weeklinc",     pmins,  "weekly login allowance (hr:min)",              (char *)&mm.mm_winc,
       "weeklrem",     pmins,  "weekly allowance remaining (hr:min)",  (char *)&mm.mm_wrem,
       "daylmax",      pmins,  "Max day's login time (hr:min)",                (char *)&mm.mm_dmax,
       "daylinc",      pmins,  "daily login allowance (hr:min)",               (char *)&mm.mm_dinc,
       "daylrem",      pmins,  "daily allowance remaining (hr:min)",   (char *)&mm.mm_drem,
       "prclass",      pbits,  "permitted printer classes",            (char *)&lpdq.lpq_prclass,
       "lpdwmax",      psval,  "maximum pages in a week",              (char *)&lpdq.lpq_wmax,
       "lpdwinc",      psval,  "weekly page allowance",                (char *)&lpdq.lpq_allow,
       "lpdwrem",      psval,  "pages left this week",                 (char *)&lpdq.lpq_week,
       "lpddmax",      psval,  "maximum pages in a day",               (char *)&lpdq.lpq_dmax,
       "lpddinc",      psval,  "daily page allowance",         (char *)&lpdq.lpq_daily,
       "lpddrem",      psval,  "pages left today",             (char *)&lpdq.lpq_today,
       "lpdlimit",     plval,  "absolute page limit",          (char *)&lpdq.lpq_limit,
       "maxrss",       pmem,   "expected largest proc size",   (char *)&udata.ud_maxrss,
       "maxdata",      pmem,   "maximum data segment", (char *)&udata.ud_maxdata,
       "maxstack",     pmem,   "maximum stack segment",        (char *)&udata.ud_maxstack,
       "maxcore",      pmem,   "largest core file generated",  (char *)&udata.ud_maxcore,
       "maxfile",      pmem,   "largest file allowed", (char *)&udata.ud_maxfile,
       "maxcpu",       psecs,  "cpu time limit (hr:min:sec)",  (char *)&udata.ud_maxcpu,
       "noraise",      praise, "can't raise maximums",         (char *)&udata.ud_raise,
       "disc",         pdquot, "",                             (char *)0,
       (char *)0
};

static  struct  syf     {
       char    *syfname;
       char    *syfcmt;
       long    syfval;
} syf[] = {
       "modtty",       "modify terminals other than login tty",        QF_MODTTY,
       "ttyfast",      "increase tty speed > 1200 baud",       QF_FASTTY,
       "nasync",       "remaining procs niced at logout",      QF_NASYNC,
       "kasync",       "remaining procs killed at logout",     QF_KASYNC,
       "noumask",      "not permitted to alter umask", QF_UMASK,
       (char *)0
};

static  struct  flg     {
       char    *flgname;
       char    *flgcmt;
       enum    u_priv  flgval;
} flg[] = {
       "usecu",        "use 'cu' to connect to remote machine",        USE_REMOTE,
       "useuucp",      "use 'uucp' to transfer files", USE_UUCP,
       "tutor",        "various tutor priveleges",     TUTOR,
       "supertute",    "special tutor privs (incl modify privs)",      SUPER_TUTE,
       "student",      "account is a student (misc restrictions)",     STUDENT,
       "stumail",      "students permitted to send mail to user",      GET_STU_MAIL,
       "mailstu",      "permitted to send mail to students",   SEND_STU_MAIL,
       "uucpmail",     "permitted to mail to remote machines", UUCP_MAIL,
       "nonewgrp",     "not permitted to alter login group",   NO_NEWGRP,
       "studsu",       "students can 'su' to this account",    STUD_SU,
       (char *)0
};

static struct vnm {
       char *valname;
       long  valval[4];
} vnm[] = {
               /* char data */ /* short data */                /* long data */
       "none",         0,              0,              0,              0,
       "unlimited", INFINITY>>24, INFINITY>>16,        0,       INFINITY,
       "all",          ~0,             ~0,             0,              ~0,
       (char *)0
};

wrtprivf(name, mp, lp, dp, dnp, up)
char *name;
struct mushmuck *mp;
struct lpquota *lp;
struct dquot *dp;
char (*dnp)[32];
struct udata *up;
{
       register struct kwtab *k;
       char    keyw[32];
       register n;

       udata = *up;
       mm = *mp;
       lpdq = *lp;
       for (n = 0; n < 16; n++) {
               if (dnp[0][0]) {
                       strcpy(dqfn[n], dnp[0]);
                       dqb[n] = *dp++;
                       dnp++;
               } else
                       break;
       }
       if (n < 16)
               dqfn[n][0] = 0;

       if ((fd = fopen(name, "w")) != NULL) {
               for (k = kwtab; k->kwname; k++)
                       (*k->kwfunc)(k);
               fclose(fd);
               fd = NULL;
               return(0);
       } else
               return(-1);
}

static
plval(k)
struct kwtab *k;
{
       if (nameval(k, *(long *)k->kwptr, sizeof(long)))
               return;
       fprintf(fd,
               "%s %ld         /* %s */\n"
               , k->kwname
               , *(long *)k->kwptr
               , k->kwcmt
       );
}

static
psval(k)
struct kwtab *k;
{
       if (nameval(k, (long)*(short *)k->kwptr, sizeof(short)))
               return;
       fprintf(fd,
               "%s %d          /* %s */\n"
               , k->kwname
               , *(short *)k->kwptr
               , k->kwcmt
       );
}

static
pchar(k)
struct kwtab *k;
{
       if (nameval(k, (long)*(char *)k->kwptr, sizeof(char)))
               return;
       fprintf(fd,
               "%s %d          /* %s */\n"
               , k->kwname
               , *(char *)k->kwptr
               , k->kwcmt
       );
}

static
psoct(k)
struct kwtab *k;
{
       if (nameval(k, (long)*(short *)k->kwptr, sizeof(short)))
               return;
       fprintf(fd,
               "%s %o          /* %s */\n"
               , k->kwname
               , *(short *)k->kwptr
               , k->kwcmt
       );
}

static
pmem(k)
struct kwtab *k;
{
       register long n;

       n = *(long *)k->kwptr;
       if (nameval(k, n, sizeof(long)))
               return;
       fprintf(fd, "%s ", k->kwname);
       if (n && (n & (1 << 20)-1) == 0)
               fprintf(fd, "%ldM", n>>20);
       else if (n && (n & (1 << 10)-1) == 0)
               fprintf(fd, "%ldK", n>>10);
       else
               fprintf(fd, "%ld", n);
       fprintf(fd, "           /* %s */\n", k->kwcmt);
}

static
psecs(k)
struct kwtab *k;
{
       register long secs;

       secs = *(long *)k->kwptr;
       if (nameval(k, secs, sizeof(long)))
               return;
       fprintf(fd,
               "%s %ld:%02ld:%02ld             /* %s */\n"
               , k->kwname
               , secs / 3600
               , (secs % 3600) / 60
               , secs % 60
               , k->kwcmt
       );
}

static
pmins(k)
struct kwtab *k;
{
       register mins;

       mins = *(short *)k->kwptr;
       if (nameval(k, (long)mins, sizeof(short)))
               return;
       fprintf(fd,
               "%s %d:%02d             /* %s */\n"
               , k->kwname
               , mins / 60
               , mins % 60
               , k->kwcmt
       );
}

static
pbits(k)
struct kwtab *k;
{
       register unsigned long bits;
       register ch = 'a';

       bits = *(long *)k->kwptr;
       fprintf(fd, "%s ", k->kwname);
       while (bits) {
               if (bits & 1)
                       putc(ch, fd);
               bits >>= 1;
               ch++;
               if (ch > 'z')
                       break;
       }
       fprintf(fd, "           /* %s */\n", k->kwcmt);
}

pnolog(k)
struct kwtab *k;
{
       register t_range *rp = udata.ud_logon;
       register ok = 1;
       static char *dofw[] = {
               "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", ""
       };

       if (rp->tr_low.xt_ok == rp->tr_high.xt_ok)
               return;

       fprintf(fd, "%s ", k->kwname);

       for (;;) {
               if (rp->tr_low.xt_ok != ok)
                       fprintf(fd, "except ");
               ok = rp->tr_low.xt_ok;
               fprintf(fd, "%s ", dofw[rp->tr_low.xt_day]);
               if (rp->tr_low.xt_day != rp->tr_high.xt_day)
                       fprintf(fd, "- %s ", dofw[rp->tr_high.xt_day]);
               if (rp->tr_low.xt_min != 0 || rp->tr_high.xt_min != 24*60)
                       fprintf(fd, "%02d:%02d-%02d:%02d "
                           , rp->tr_low.xt_min/60
                           , rp->tr_low.xt_min % 60
                           , rp->tr_high.xt_min/60
                           , rp->tr_high.xt_min % 60
                       );
               if (++rp >= &udata.ud_logon[4] ||
                   rp->tr_low.xt_ok == rp->tr_high.xt_ok)
                       break;
               fprintf(fd, ", ");
       }
       fprintf(fd, "   /* %s */\n", k->kwcmt);
}
               

static
pdate(k)
struct kwtab *k;
{
       time_t date;
       char *ctime();

       date = *(long *)k->kwptr;
       fprintf(fd,
               "%s %.20s               /* %s */\n"
               , k->kwname
               , date ? ctime(&date)+4 : "never"
               , k->kwcmt
       );
}

static
pdquot()
{
       register char (*fs)[32];
       register struct dquot *dqp = dqb;

       for (fs = dqfn; fs[0][0]; fs++) {
               fprintf(fd,
                   "disc %.32s blks = %d blim = %d iq = %d ilim = %d\n"
                       , fs[0]
                       , dqp->dq_quot
                       , dqp->dq_blim
                       , dqp->dq_iq
                       , dqp->dq_ilim
               );
               dqp++;
       }
}

static
pflags(k)
struct kwtab *k;
{
       register long f;
       register struct flg *fp;
       register n = 0;

       f = *(long *)k->kwptr;

       fprintf(fd, "flags");
       for (fp = flg; fp->flgname; fp++)
               if (f & (1 << (int)fp->flgval))
                       fprintf(fd, "%s %s", n++ ? "," : "", fp->flgname);
       fprintf(fd, "   /* %s */\n", k->kwcmt);
}

static
psflags(k)
struct kwtab *k;
{
       register long f;
       register struct syf *fp;
       register n = 0;

       f = *(long *)k->kwptr;

       fprintf(fd, "syflags");
       for (fp = syf; fp->syfname; fp++)
               if (f & fp->syfval)
                       fprintf(fd, "%s %s", n++ ? "," : "", fp->syfname);
       fprintf(fd, "   /* %s */\n", k->kwcmt);
}

static
praise(k)
struct kwtab *k;
{
       if (*(long *)k->kwptr)
               fprintf(fd,
                   "%s                 /* %s */\n"
                       , k->kwname
                       , k->kwcmt
               );
}

nameval(k, val, size)
struct kwtab *k;
register long val;
register size;
{
       register struct vnm *vp;

       for (vp = vnm; vp->valname; vp++)
               if (val == vp->valval[size-1]) {
                       fprintf(fd, "%s %s              /* %s */\n"
                               , k->kwname
                               , vp->valname
                               , k->kwcmt
                       );
                       return(1);
               }
       return(0);
}

static
pgrps(k)
struct kwtab *k;
{
       register int n;
       register long grps;
       register struct group *gp;
       register char *sep = "";

       grps = *(long *)k->kwptr;

       fprintf(fd, "%s", k->kwname);
       setgrent();
       for (n = 128; n < 128+32; n++) {        /* much magic here */
               if (grps & 1) {
                       gp = getgrgid(n);
                       if (gp) {
                               fprintf(fd, "%s %s", sep, gp->gr_name);
                               sep = ",";
                       }
               }
               grps >>= 1;     /* any sort of shift will do */
       }
       endgrent();
       fprintf(fd, "           /* %s */\n", k->kwcmt);
}