home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume18 / ru2 / ru.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-19  |  13.3 KB  |  583 lines
  1. /*
  2.  * ru - remote users(1)
  3.  *    usage: ru [-acdmrsuw] [-D domain] [-h host ... | -l user ...]
  4.  * List users on all "visible" hosts.
  5.  *
  6.  * Copyright (c) 1989 University of Toronto. All rights reserved.
  7.  * Anyone may use or copy this software, except that it may not be
  8.  * sold for profit, that this copyright notice remain intact, and that
  9.  * credit is given where it is due. The University of Toronto and the
  10.  * author make no warranty and accept no liability for this software.
  11.  *
  12.  * Written by P. Kern (pkern@utcsri)
  13.  * with bug fixes and suggestions from
  14.  *    nispa@hutcs.hut.fi <Tapani Lindgren>
  15.  *    kusalik@damask.uucp
  16.  *    pkh%cs.nott.ac.uk@nss.cs.ucl.ac.uk <Kevin Hopkins>
  17.  *    lamy@ai.toronto.edu <Jean-Francois Lamy>
  18.  *    moraes@csri.toronto.edu <Mark Moraes>
  19.  *
  20.  * $Header: ru.c,v 2.9 89/02/26 13:48:36 pkern Exp $
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include <sys/types.h>
  25. #include <sys/stat.h>
  26. #include <sys/dir.h>
  27. #include <sys/file.h>
  28. #include <netdb.h>
  29.  
  30. #define MINSTR    8        /* minimum string length */
  31. #define HNSZ    32        /* hostname length */
  32. #define RWFSZ    HNSZ+5        /* spool-file name length */
  33. #define MRGN    10        /* margin "tab" size */
  34. #define HOUR    3600        /* seconds in an hour */
  35. #define RWPERIOD    300    /* std. 5 minute rwho refresh period */
  36. #define MAXPORTS    160    /* max tty ports per host */
  37.  
  38. struct rw_utmp {    /* rwho file user info */
  39.     char tty[MINSTR];    /* user's tty */
  40.     char name[MINSTR];    /* user's login */
  41.     long time;        /* login time */
  42.     long idle;        /* idle time */
  43. } rut;
  44.  
  45. struct rw_hdr {        /* rwho data/host info */
  46.     char pad[4];        /* ignore first 4 bytes */
  47.     int sent, rcvd;        /* time sent,  time rec'vd */
  48.     char host[HNSZ];    /* host's name */
  49.     int loadav[3];        /* load averages */
  50.     int boot;        /* boot date */
  51. } hdr;
  52.  
  53. int rutsize, hdrsize;
  54. #ifdef debug
  55. #define RWHODIR    "rwho"
  56. #else
  57. #define RWHODIR "/usr/spool/rwho"
  58. #endif
  59.  
  60. long now;        /* it won't be ... (long now :-) */
  61. int n, fd;
  62. struct stat st;
  63. char *hnbuf, *hp;    /* hostname buffer & extra pointer */
  64. char *rubuf, *ep;    /* utmp data buffer & end pointer */
  65. char *program, *domain;
  66.     /* Flags: if (flag) then ... */
  67. int aflag=1;    /* ... only show users with <1 HR idle time */
  68. int sflag=1;    /* ... show output by domains (not by hosts) */
  69. int mflag=1;    /* ... drop multiple logins */
  70. int cflag=0;    /* ... (if mflag) show login counts */
  71. int dflag=1;    /* ... sort hostnames within domains */
  72. int Dflag=0;    /* ... show users in a given domain */
  73. int hflag=0;    /* ... show users on a given host */
  74. int lflag=0;    /* ... show hosts with given user */
  75. int rflag=0;    /* ... retro -- imitiate rwho */
  76. int uflag=0;    /* ... show uptimes (like ruptime) */
  77. int wflag=0;    /* ... break lines before wraparound */
  78. int errflag=0;
  79.  
  80. int wlim=80;    /* default screen width */
  81.  
  82. extern char *rindex(), *malloc(), *getenv();
  83.  
  84. main(argc, argv)
  85. int argc;
  86. char *argv[];
  87. {
  88.     DIR *dirp;
  89.     struct direct *dp;
  90.     int rwfcmp(), rutcmp(), drwcmp();    /* qsort() routines */
  91.     extern int optind;    /* see getopt(3C) */
  92.     extern char *optarg;    /* see getopt(3C) */
  93.  
  94.     program = argv[0];
  95.     now = time(0);
  96.     rutsize = sizeof(rut);
  97.     hdrsize = sizeof(hdr);
  98.  
  99.     while ((n = getopt(argc, argv, "acdhlmrsuwD:")) != EOF)
  100.         switch(n) {
  101.         case 'a': aflag=0; break;    /* same as rwho(1) */
  102.         case 'c': cflag=1; break;    /* show login count */
  103.         case 'd': dflag=0; break;    /* domain-wise sort */
  104.         case 'm': mflag=0; break;    /* show multi-logins */
  105.         case 'r': rflag++; break;    /* rwho-style output */
  106.         case 's': sflag=0; break;    /* domain-only lists */
  107.         case 'u': uflag++; break;    /* show uptimes */
  108.         case 'w': wflag++; break;    /* break long lines */
  109.         case 'D': Dflag++; domain = optarg; break;
  110.         case 'h': hflag++; break;    /* host-list follows */
  111.         case 'l': lflag++; break;    /* user-list follows */
  112.         default: errflag++;
  113.         }
  114.  
  115.     /*
  116.      * Note: -h and -l are mutually exclusive since both options
  117.      * use the remaining arguments as a search list. Either option
  118.      * should be followed by at least one name.  The getopt switch
  119.      * could have been arranged to only use whichever flag (l or h)
  120.      * was typed last but this way the user will know that there is
  121.      * a potential problem.
  122.      */
  123.     if (errflag || (lflag && hflag)
  124.         || (optind >= argc && (lflag || hflag))) {
  125.         fprintf(stderr, "Usage: %s [-acdmrsuw] [-D domain] [-h host ... | -l user ... ]\n", program);
  126.         exit(1);
  127.     }
  128.  
  129.     if (!dflag || lflag || rflag || uflag) sflag=0;
  130.     if (!mflag) cflag=0;    /* not really needed (see burp()) */
  131.  
  132.     if (chdir(RWHODIR) < 0) {    /* cd RWHODIR */
  133.         perror(RWHODIR);
  134.         exit(1);
  135.     }
  136.  
  137.     if (wflag) {    /* wrapping, eh? ok, get screen width */
  138.         int n;
  139.         char buf[1024];
  140.  
  141.         if ((hp = getenv("TERM")) == NULL) {
  142.             wflag = 0;
  143. #ifdef SQUAWK
  144.             fprintf(stderr, "%s: no TERM?\n", program);
  145. #endif
  146.         }
  147.         if (wflag && tgetent(buf, hp) < 0) {
  148.             wflag = 0;
  149. #ifdef SQUAWK
  150.             fprintf(stderr, "%s: no TERMCAP?\n", program);
  151. #endif
  152.         }
  153.         if (wflag && (n = tgetnum("co")) > 0 && n > MRGN+MINSTR)
  154.             wlim = n;
  155.     }
  156.  
  157.     if (hflag) {
  158.         sflag=0;
  159.         for ( ;optind < argc; optind++)
  160.             dohost(argv[optind]);
  161.         exit(0);
  162.     }
  163.  
  164.     /*
  165.      * read "." directory (assuming chdir() worked), 
  166.      * and get all files with the "whod." prefix.
  167.      * if Dflag, only get files ending with "domain".
  168.      */
  169.     if ((dirp = opendir(".")) == NULL
  170.         || stat(".", &st) < 0) { 
  171.         perror(RWHODIR);
  172.         exit(1);
  173.     }
  174.     dp = readdir(dirp);    /* get "." */
  175.     n = (st.st_size/(DIRSIZ(dp)+8))*RWFSZ;
  176.     hnbuf = malloc((unsigned)n);
  177.     n = 0; ep = hnbuf;
  178.     while (dp = readdir(dirp)) {
  179.         strncpy(ep, dp->d_name, dp->d_namlen);
  180.         *(ep+dp->d_namlen) = '\0';
  181.         if (strncmp(ep, "whod.", 5) == 0 &&
  182.            (!Dflag || strcmp(rindex(ep,'.')+1,domain) == 0)) {
  183.             ep += RWFSZ;
  184.             n++;
  185.         }
  186.     }
  187.     /* ep should now point to the end of the host name buffer */
  188.     closedir(dirp);
  189.  
  190.     if (dflag)    /* sort host names within domains */
  191.         qsort(hnbuf, n, RWFSZ, drwcmp);
  192.     else        /* sort full host name */
  193.         qsort(hnbuf, n, RWFSZ, rwfcmp);
  194.  
  195.     if (sflag) {    /* process by domains only */
  196.         dodomains();
  197.         exit(0);
  198.     }
  199.  
  200.     /*
  201.      * process each "whod." file in hnbuf list.
  202.      * - get <filesize> bytes of mem
  203.      * - gobble rutmp data from file
  204.      * - sort names alphabetically
  205.      * - print names (burp)
  206.      * - free up mem
  207.      */
  208.     hp = hnbuf;
  209.     while (hp < ep) {
  210.         if ((fd = open(hp, O_RDONLY)) < 0
  211.             || fstat(fd, &st) < 0) {
  212.             perror(hp);
  213.             exit(1);
  214.         }
  215.         if ((n = st.st_size-hdrsize) || uflag) {
  216.             if ((rubuf = malloc((unsigned)n)) == 0) {
  217.                 perror(program);
  218.                 exit(1);
  219.             }
  220.             n = read(fd, (char *)&hdr, hdrsize);
  221.             n = ldrut(fd,rubuf,st.st_size-hdrsize);
  222.             if (uflag)
  223.                 slurp(&hdr, n/rutsize);
  224.             else
  225. #ifdef debug
  226.             if (n > 0){
  227. #else
  228.             if (now-hdr.rcvd <= RWPERIOD && n > 0){
  229. #endif
  230.                 qsort(rubuf, n/rutsize, rutsize, rutcmp);
  231.                 if (!lflag || chew(rubuf,n,argc,argv))
  232.                     burp(hp, rubuf, n);
  233.             }
  234.         }
  235.         free(rubuf);
  236.         close(fd);
  237.         hp += RWFSZ;
  238.     }
  239. }
  240.  
  241. /*
  242.  * compare rwho spool-file names
  243.  */
  244. rwfcmp(p, q)
  245. register char *p, *q;
  246. {
  247.     return(strncmp(p, q, RWFSZ));
  248. }
  249.  
  250. /*
  251.  * compare utmp name entries
  252.  */
  253. rutcmp(p, q)
  254. register struct rw_utmp *p, *q;
  255. {
  256.     return(strncmp(p->name, q->name, MINSTR));
  257. } 
  258.  
  259. /*
  260.  * compare sub-domain names
  261.  */
  262. drwcmp(p, q)
  263. register char *p, *q;
  264. {
  265.     int x;
  266.     char *s, *t;
  267.  
  268.     s = rindex(p, '.');
  269.     t = rindex(q, '.');
  270.     if (s) s++; else s = p;
  271.     if (t) t++; else t = q;
  272.     if(x = strncmp(s, t, RWFSZ))
  273.         return(x);
  274.     return(strncmp(p, q, RWFSZ));
  275. }
  276.  
  277. /*
  278.  * print "host:       user1 user2 ... "
  279.  *    or whatever format the flags dictate.
  280.  * (blame creeping featurism for this mass of spaghetti)
  281.  */
  282. burp(s, r, n)
  283. register char *s, *r;
  284. int n;
  285. {    
  286.     int wdent;
  287.     register int l, wo, sl;
  288.     register char *xp;
  289.     char tbuf[RWFSZ+MINSTR+2];
  290.  
  291.     if (!sflag) s += 5;        /* skip "whod." prefix */
  292.  
  293.     if (rflag) {    /* rwho-like output */
  294.         register struct rw_utmp *rp;
  295.  
  296.         sprintf(tbuf, "%.*s:", HNSZ, s);
  297.         sl = strlen(tbuf);
  298.         for (xp = r; xp < (r+n); xp += rutsize) {
  299.             rp = (struct rw_utmp *)xp;
  300.             strncpy(tbuf + sl, rp->tty, MINSTR);
  301.             printf("%-8.8s %-23s %.12s",
  302.                  rp->name, tbuf, ctime(&rp->time) + 4);
  303.             if (rp->idle < 60)
  304.                 printf("\n");
  305.             else {
  306.                 l = rp->idle/HOUR;
  307.                 wo = (rp->idle % HOUR)/60;
  308.                 if (l > 99)
  309.                     wo = 59, l = 99;
  310.                 printf((l) ? " %2d" : "   ", l);
  311.                 printf(":%02d\n", wo);
  312.             }
  313.         }
  314.         return;
  315.     }
  316.  
  317.     /* print host- or domain-name */
  318.     if (sflag && cflag)    /* include # of hosts in domain */
  319.         sprintf(tbuf, "%.*s/%d:", MRGN, s, sflag);
  320.     else
  321.         sprintf(tbuf, "%.*s:", MRGN+((!sflag) * 4), s);
  322.  
  323.     printf("%-*s", wo = wdent = MRGN+((!sflag) * 5), s = tbuf);
  324.  
  325.     if (n && mflag) {    /* print "user1 user2 ..." */
  326.         for(l=0, xp=s=r+MINSTR; s < (r+n); s += rutsize)
  327.             if (strncmp(s, xp, MINSTR)) {
  328.                 sprintf(tbuf,
  329.                     (l>1)?" %.*s/%d":" %.*s",
  330.                     MINSTR, xp, l);
  331.                 if (wflag) {    /* wrap and indent */
  332.                     if ((sl=strlen(tbuf)) > wlim-wo)
  333.                         printf("\n%*s",
  334.                             wo = wdent, "");
  335.                     wo += sl;
  336.                 }
  337.                 fputs(tbuf, stdout);
  338.                 xp = s; l = cflag;
  339.             }
  340.             else
  341.                 l += cflag;
  342.         /* still one name left to do */
  343.         sprintf(tbuf,(l>1)?" %.*s/%d\n":" %.*s\n",MINSTR,xp,l);
  344.         if (wflag && (strlen(tbuf)-1) > wlim - wo)
  345.             printf("\n%*s", wo = wdent, "");
  346.         fputs(tbuf, stdout);
  347.         return;
  348.     }
  349.  
  350.     /* ... else don't ignore multi-logins */
  351.     for (s = r+MINSTR; s < (r+n); s += rutsize) {
  352.         if (wflag) {    /* wrap and indent */
  353.             if ((sl = strlen(s)) > MINSTR)
  354.                 sl = MINSTR;
  355.             if (++sl > wlim - wo)
  356.                 printf("\n%*s", wo = wdent, "");
  357.             wo += sl;
  358.         }
  359.         printf(" %.*s", MINSTR, s);
  360.     }
  361.     printf("\n");
  362. }
  363.  
  364. /*
  365.  * print uptimes (like ruptime(1))
  366.  */
  367. slurp(h, n)
  368. struct rw_hdr *h;
  369. int n;
  370. {
  371.     char tbuf[128];
  372.     register char *p;
  373.     register int tdif;
  374.  
  375.     /* host name */
  376.     p = tbuf;
  377.     sprintf(p, "%-15.15s", h->host);
  378.  
  379.     /* if rcvd-time is >1 hour old then assume host is down */
  380.     tdif = now - h->rcvd; p += 15;
  381.     if (tdif > HOUR) {
  382.         if (tdif > (24 * HOUR)) 
  383.             sprintf(p, "down %3d+%02d:%02d\n",
  384.                 (tdif / (24 * HOUR)),
  385.                 (tdif % (24 * HOUR)) / HOUR,
  386.                 (tdif % HOUR) / 60);
  387.         else
  388.             sprintf(p, "down %6d:%02d\n",
  389.                 tdif / HOUR, (tdif % HOUR) / 60);
  390.         fputs(tbuf, stdout);
  391.         return;
  392.     }
  393.  
  394.     /* print host's uptime but include a '*' if
  395.      * rcvd-time is between 5 mins and 1 hour old */
  396.     sprintf(p, "%c up ", (tdif > RWPERIOD) ? '*' : ' ');
  397.     tdif = now - h->boot; p += 5;
  398.     if (tdif < 1)    /* host's boottime > our current time */
  399.         sprintf(p, "    ??:??");
  400.     else if (tdif > (24 * HOUR)) 
  401.         sprintf(p, "%3d+%02d:%02d",
  402.             (tdif / (24 * HOUR)),
  403.             (tdif % (24 * HOUR)) / HOUR,
  404.             (tdif % HOUR) / 60);
  405.     else
  406.         sprintf(p, "%6d:%02d", tdif / HOUR, (tdif % HOUR) / 60);
  407.  
  408.     /* print # of users and the 3 load numbers */
  409.     p += 9;
  410.     sprintf(p, ", %5d user%s load: %2d.%02d, %2d.%02d, %2d.%02d\n",
  411.         n, (n == 1) ? ", " : "s,",
  412.         h->loadav[0]/100, h->loadav[0]%100,
  413.         h->loadav[1]/100, h->loadav[1]%100,
  414.         h->loadav[2]/100, h->loadav[2]%100);
  415.     fputs(tbuf, stdout);
  416. }
  417.  
  418. /*
  419.  * show users on a specific host
  420.  */
  421. dohost(host)
  422. char *host;
  423. {
  424.     struct hostent *h, *gethostbyname();
  425.  
  426.     /*
  427.      * try to get host's proper name
  428.      * and try to find the proper spool file
  429.      */
  430.     if((h = gethostbyname(host)) == NULL) {
  431.         hp = malloc(strlen(host)+MINSTR);
  432.         sprintf(hp, "whod.%s", host);
  433. /*
  434.         perror(host);
  435.         return(1);
  436.  */
  437.     }
  438.     else {
  439.         hp = malloc(strlen(h->h_name)+MINSTR);
  440.         sprintf(hp, "whod.%s", h->h_name);
  441.     }
  442.     if ((fd = open(hp, O_RDONLY)) < 0 && h != NULL) {
  443.         char **s;
  444.         /*
  445.          * can't find file related to h_name
  446.          * try the aliases instead.
  447.          */
  448.         s = h->h_aliases;
  449.         while(*s) {
  450.             free(hp);
  451.             hp = malloc(strlen(*s)+MINSTR);
  452.             sprintf(hp, "whod.%s", *s);
  453.             if ((fd = open(hp, O_RDONLY)) > 0)
  454.                 break;
  455.             s++;
  456.         }
  457.         if (*s == NULL) {
  458.             fprintf(stderr,  "%s: no data\n",  host);
  459.             return(1);
  460.         }
  461.     }
  462.     if ((fd > 0 && fstat(fd, &st) < 0) || stat(hp, &st) < 0) {
  463.         if (fd < 0)
  464.             fprintf(stderr, "%s: unknown host\n", host);
  465.         else
  466.             perror(hp);
  467.         return(1);
  468.     }
  469.     n = st.st_size - hdrsize;
  470.     if ((rubuf = malloc((unsigned)n)) == 0) {
  471.         perror(program);
  472.         exit(1);
  473.     }
  474.     n = read(fd, (char *)&hdr, hdrsize);
  475.     n = ldrut(fd,rubuf,st.st_size-hdrsize);
  476.     if (uflag)
  477.         slurp(&hdr, n/rutsize);
  478.     else {
  479.         if (now-hdr.rcvd > RWPERIOD)
  480.             strcat(hp, "*");
  481.         qsort(rubuf, n/rutsize, rutsize, rutcmp);
  482.         burp(hp, rubuf, n);
  483.     }
  484. }
  485.  
  486. /*
  487.  * show users by domain
  488.  */
  489. dodomains()
  490. {
  491.     int z;
  492.     register int i;
  493.     char *p0, *p1, *fnp, *rbp;
  494.  
  495.     fnp = hp = hnbuf;
  496.  
  497.     if ((rubuf = malloc(n * MAXPORTS * rutsize)) == NULL) {
  498.         perror(program);
  499.         exit(1);
  500.     }
  501.  
  502.     p0 = rindex(fnp, '.') + 1;
  503.     if ((int)p0 == 1) p0 = fnp;
  504.  
  505.     while (fnp < ep) {
  506.         rbp = rubuf;
  507.         for (p1=p0, n=i=0; fnp < ep && !strcmp(p1, p0); i++) {
  508.             if ((fd = open(fnp, O_RDONLY)) < 0
  509.                 || fstat(fd, &st) < 0) {
  510.                 perror(fnp);
  511.                 exit(1);
  512.             }
  513.             read(fd, (char *)&hdr, hdrsize);
  514.             z = ldrut(fd,rbp,st.st_size-hdrsize);
  515. #ifdef debug
  516.             if (z > 0) {
  517. #else
  518.             if (now-hdr.rcvd <= RWPERIOD && z > 0) {
  519. #endif
  520.                 n += z;
  521.                 rbp += z;
  522.             }
  523.             close(fd);
  524.             fnp += RWFSZ;
  525.             p1 = p0;
  526.             p0 = rindex(fnp, '.') + 1;
  527.             if ((int)p0 == 1) p0 = fnp;
  528.         }
  529.         if (!n) continue;
  530.         *rbp = '\0';
  531.         qsort(rubuf, n/rutsize, rutsize, rutcmp);
  532.         sflag = i;
  533.         burp(p1, rubuf, n);
  534.     }
  535.     free(rubuf);
  536. }
  537.  
  538. /*
  539.  * load rutmp data into buffer.
  540.  */
  541. ldrut(fd, p, n)
  542. int fd, n;
  543. char *p;
  544. {
  545.     register int m1, m2, nr;
  546.     register char *s;
  547.  
  548.     if (!aflag) return(read(fd, p, n));
  549.  
  550.     s = p;
  551.     m1 = m2 = 0;
  552.  
  553.     while (m2 < n && (nr = read(fd, s, rutsize)) > 0) {
  554.         m2 += nr;
  555.         if (((struct rw_utmp *)s)->idle > HOUR)
  556.             /* ignore entries with >1 hr idle time */
  557.             continue;
  558.         m1 += nr;
  559.         s += nr;
  560.     }
  561.     return(m1);
  562. }
  563.  
  564. /*
  565.  * search a file's data for given users
  566.  */
  567. chew(r, n, ac, av)
  568. char *r, *av[];
  569. int n, ac;
  570. {
  571.     register int i;
  572.     register char *p;
  573.     extern int optind;
  574.  
  575.     /* grotty old standard linear search */
  576.     for (p = r+MINSTR; p < (r+n); p += rutsize)
  577.         for (i=optind; i<ac; i++)
  578.             if (*p == av[i][0]
  579.                 && !strncmp(av[i], p, MINSTR))
  580.                 return (1);
  581.     return(0);
  582. }
  583.