home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / unix / volume01 / uucpanz.v7 < prev    next >
Encoding:
Internet Message Format  |  1988-09-11  |  13.7 KB
  1. From: allegra!ihnp4!bradley!brad@genrad.UUCP
  2. Newsgroups: mod.sources
  3. Subject: another uucp status program: uucpanz
  4. Date: 2 Nov 84 01:48:12 GMT
  5. Organization: GenRad, Inc., Bolton, Mass.
  6.  
  7. The uuque program as posted doesn't work on the rti version of uucp, i.e.
  8. all the files in one directory.
  9.  
  10. But for your enjoyment here is a program I wrote to monitor uucp useage.
  11. Included is just a sample of my LOGFILE & SYSLOG, to show how mine is set up.
  12.  
  13. Bradley Smith            UUCP: {cepu,ihnp4,noao,uiucdcs}!bradley!brad
  14. Text Processing            ARPA: cepu!bradley!brad@UCLA-LOCUS
  15. Bradley University        PH: (309) 676-7611 Ext. 446
  16. Peoria, IL 61625
  17.  
  18. ======cut here======
  19. : The rest of this file is a shell script which will extract:
  20. : uucpanz.c LOGFILE SYSLOG
  21. echo x - uucpanz.c
  22. cat >uucpanz.c <<'!End!Of!Stuff!'
  23. /*
  24. * uucpanz.c
  25. *    program to print out stats about uucp usage.
  26. *
  27. *  Permission is given by me for the use,
  28. * modification, and distribution of this program
  29. * exception:  It may not be sold for profit individually nor as part of any
  30. * software package, regardless of modifications.
  31. *
  32. *
  33. *    Bradley Smith
  34. *    Bradley University
  35. *    {ihnp4,cepu,uiucdcs,noao}!bradley!brad
  36. */
  37. #include    <stdio.h>
  38. #include    <ctype.h>
  39.  
  40. char *getfield();
  41.  
  42. #define    SYSLOG    "/usr/spool/uucp/SYSLOG"
  43. #define    LOGFILE    "/usr/spool/uucp/LOGFILE"
  44. #define    MAXSYS    5
  45.  
  46. struct    dayrec {
  47.     int used;    /* used */
  48.     long recv;    /* bytes recv */
  49.     long sent;    /* bytes sent */
  50.     long trecv;    /* seconds spent rec */
  51.     long tsent;    /* seconds spent sending */
  52. };
  53.  
  54. struct    sys1 {
  55.     char sname[9];    /* system name */
  56.     long bbsent;    /* bytes sent */
  57.     long brec;    /* bytes rec. */
  58.     long btsent;    /* time spen sending */
  59.     long btrec;    /* time spent rec */
  60.     int suc;    /* succesfull calls */
  61.     int fail;    /* calls fail */
  62.     int ugot;    /* number of files we got */
  63.     int lock;    /* times of locked */
  64.     int usent;    /* number of files we sent */
  65.     int okstr;    /* number of conversations started */
  66.     int okstop;    /* number of conversations stop */
  67. };
  68.  
  69. struct    users {
  70.     char *name;    /* login name */
  71.     long bsent;    /* bytes sent */
  72.     long utim;    /* time spent */
  73.     long nsent;    /* number sent */
  74.     struct    users    *nuser;
  75. };
  76.  
  77. struct    call {
  78.     int times;
  79.     char *cname;
  80.     struct call *ncall;
  81. };
  82.  
  83. struct    dayrec    dayacc[13] [32];
  84. struct    sys1    sysacc[MAXSYS];
  85. struct    call    *cmd, *tcall();
  86. struct    users    *usage;
  87. struct    users    *tree();
  88. char    *malloc(), *strsave();
  89.  
  90. long    byt, tim, atol();
  91. int    cmdcount;
  92. long    hour, min,second, hourtmp;
  93. FILE *fpin;
  94.  
  95. main()
  96. {
  97.     char line[512], field[128], date[10], cx[128],*cp, *c;
  98.     char sysname[9], username[9];
  99.     register int i,j,k;
  100.     int d, m;
  101.  
  102. /* intialize */
  103.     usage = NULL;
  104.     cmdcount = 0;
  105.     cmd = NULL;
  106.     for(i = 1; i <= 12; i++)
  107.         for(j = 1; j <= 31; j++) {
  108.             dayacc[i][j].recv= 0L;
  109.             dayacc[i][j].used= 0;
  110.             dayacc[i][j].trecv= 0L;
  111.             dayacc[i][j].sent= 0L;
  112.             dayacc[i][j].tsent =0L;
  113.         }
  114. /* lets do SYSLOG first */
  115.  
  116.     if((fpin = fopen(SYSLOG,"r")) == NULL)
  117.         error("Can't open SYSLOG");
  118.  
  119.     while(fgets(line,512,fpin) != NULL) {
  120.         strcpy(cx,getfield(2,line,' '));
  121.         cp = cx;
  122.         cp++;    /* puts at first number */
  123.         c = cp;
  124.         cp++;
  125.         if(isdigit(*cp))
  126.             cp++;
  127.         *cp = '\0';
  128.         m = atoi(c);
  129.         cp++;
  130.         c = cp;
  131.         cp++;
  132.         if(isdigit(*cp))
  133.             cp++;
  134.         *cp = '\0';
  135.         d = atoi(c);
  136.         strcpy(sysname, getfield(1,line,' '));
  137.         byt = atol(getfield(6,line,' '));
  138.         tim = atol(getfield(8,line,' '));
  139.         strcpy(username, getfield(0,line,' '));
  140.         strcpy(field,getfield(4,line,' '));
  141.  
  142.         if(tindex(field,"sent") != -1) {
  143.             for(i = 0;i < MAXSYS;i ++) {
  144.               if(strlen(sysacc[i].sname) <= 0) {
  145.                 strcpy(sysacc[i].sname, sysname);
  146.                 sysacc[i].bbsent = byt;
  147.                 sysacc[i].btsent = tim;
  148.                 break;
  149.               }
  150.               else if(strcmp(sysacc[i].sname, sysname) == 0) {
  151.                 sysacc[i].bbsent += byt;
  152.                 sysacc[i].btsent += tim;
  153.                 break;
  154.               }
  155.             }
  156.             usage = tree(usage, username);
  157.             dayacc[m][d].sent += byt;
  158.             dayacc[m][d].tsent += tim;
  159.             dayacc[m][d].used = 1;
  160.         }
  161.         else {
  162.             dayacc[m][d].recv += byt;
  163.             dayacc[m][d].trecv += tim;
  164.             dayacc[m][d].used = 1;
  165.             for(i=0;i< MAXSYS; i++) {
  166.               if(strlen(sysacc[i].sname) <= 0) {
  167.                 strcpy(sysacc[i].sname, sysname);
  168.                 sysacc[i].brec = byt;
  169.                 sysacc[i].btrec = tim;
  170.                 break;
  171.               }
  172.               else if(strcmp(sysacc[i].sname, sysname) == 0) {
  173.                 sysacc[i].brec += byt;
  174.                 sysacc[i].btrec += tim;
  175.                 break;
  176.               }
  177.             }
  178.         }
  179.     }
  180.     fclose(fpin);
  181.  
  182.     if((fpin = fopen(LOGFILE,"r")) == NULL )
  183.         error("Can't open LOGFILE");
  184.  
  185.     while(fgets(line,512,fpin) != NULL) {
  186.         c = getfield(4,line,' ');
  187.         if(strcmp(c,"XQT") == 0) {
  188.             strcpy(field,getfield(1,line,';'));
  189.             field[strlen(field)-4] = '\0';
  190.             cmd = tcall(cmd,field);
  191.         }
  192.         else if(tindex(c,"call") != -1) {
  193.             
  194.             cp = getfield(3,line,' ');
  195.             if(strcmp(cp,"SUCCEEDED") == 0) {
  196.                 for(i=0;i< MAXSYS;i++)
  197.                   if(strcmp(sysacc[i].sname,getfield(1,line,' ')) == 0)
  198.                     sysacc[i].suc++;
  199.             }
  200.             else if(strcmp(cp,"FAILED") == 0) {
  201.                 for(i=0;i< MAXSYS;i++)
  202.                   if(strcmp(sysacc[i].sname,getfield(1,line,' ')) == 0)
  203.                     sysacc[i].fail++;
  204.             }
  205.             else if(strcmp(cp,"LOCKED") == 0) {
  206.                 for(i=0;i< MAXSYS;i++)
  207.                   if(strcmp(sysacc[i].sname,getfield(1,line,' ')) == 0)
  208.                     sysacc[i].lock++;
  209.             }
  210.         }
  211.         cp = getfield(3,line,' ');
  212.         if(strcmp(cp,"REQUEST") == 0) {
  213.             for(i=0;i< MAXSYS;i++)
  214.               if(strcmp(sysacc[i].sname,getfield(1,line,' ')) == 0)
  215.                 sysacc[i].usent++;
  216.         }
  217.         else if(strcmp(cp,"COPY") == 0) {
  218.             for(i=0;i< MAXSYS;i++) {
  219.               if(strcmp(sysacc[i].sname,getfield(1,line,' ')) == 0)
  220.                 sysacc[i].ugot++;
  221.             }
  222.         }
  223.         else if(strcmp(cp,"OK") == 0) {
  224.             if(tindex(getfield(4,line,' '),"startup") != -1 ) {
  225.                 for(i=0;i<MAXSYS;i++) {
  226.                     if(strcmp(sysacc[i].sname,
  227.                         getfield(1,line,' ')) == 0)
  228.                         sysacc[i].okstr++;
  229.                 }
  230.             }
  231.             else {
  232.                 for(i=0;i < MAXSYS;i++) {
  233.                     if(strcmp(sysacc[i].sname,
  234.                         getfield(1,line,' ')) == 0)
  235.                         sysacc[i].okstop++;
  236.                 }
  237.             }
  238.         }
  239.     }
  240.     fclose(fpin);
  241.     printf("UUCP ANALYZER:\n");
  242.     printf("%5sBy system:\n","");
  243.     for(i=0;i < MAXSYS;i++) {
  244.     if(strlen(sysacc[i].sname) > 0) {
  245.         printf("%10s%s\n", "", sysacc[i].sname);
  246.         hourtmp = sysacc[i].btsent / 60;    /* gives interger min */
  247.         second = sysacc[i].btsent - ( hourtmp * 60); /* seconds */
  248.         hour =  hourtmp / 60;    /* gives integer hour */
  249.         min = hourtmp - ( hour * 60);
  250.         printf("%15ssent       %10ld bytes %5stime ", "", sysacc[i].bbsent,"");
  251.         printf("%02ld:%02ld:%02ld\n", hour, min, second);
  252.         printf("%15srecieved   %10ld bytes %5stime ","",sysacc[i].brec,"");
  253.         hourtmp = sysacc[i].btrec / 60;    /* gives interger min */
  254.         second = sysacc[i].btrec - ( hourtmp * 60); /* seconds */
  255.         hour =  hourtmp / 60;    /* gives integer hour */
  256.         min = hourtmp - ( hour * 60);
  257.         printf("%02ld:%02ld:%02ld\n", hour, min, second);
  258.         printf("%15s# of files %10d sent   %5s %5d recieved\n",
  259.             "",sysacc[i].usent, "",sysacc[i].ugot);
  260.         printf("%15s# of calls %10d suc     %10d fail   %10d lock\n",
  261.             "", sysacc[i].suc, sysacc[i].fail, sysacc[i].lock);
  262.         printf("%15sConversations OK  %5d (startup)   %5d (completed)\n",
  263.             "", sysacc[i].okstr, sysacc[i].okstop);
  264.         /* next do total */
  265.         hour = sysacc[i].bbsent - sysacc[i].brec;
  266.         if(hour < 0) {    /* means we rec more */
  267.             hour *= -1;
  268.             printf("%15srecieved %ld bytes more than sent\n",
  269.                 "", hour);
  270.         }
  271.         else if(hour > 0)    /* means we sent more */
  272.             printf("%15ssent %ld bytes more that recieved\n",
  273.                 "", hour);
  274.         else
  275.             printf("%15ssent the same amount as recieved\n","");
  276.         hourtmp = (sysacc[i].btrec + sysacc[i].btsent)  / 60;
  277.         second = (sysacc[i].btrec + sysacc[i].btsent) 
  278.                 - ( hourtmp * 60); /* seconds */
  279.         hour =  hourtmp / 60;    /* gives integer hour */
  280.         min = hourtmp - ( hour * 60);
  281.         printf("%15stotal connect time %02ld:%02ld:%02ld\n",
  282.             "", hour, min, second);
  283.     }
  284.     }
  285.     printf("\n%5sBy user:\n", "");
  286.     treeprint(usage);
  287.     printf("\n%5sBy commands:\n", "");
  288.     trsort();
  289.     tcallpr(cmd);
  290.     printf("\n%5sBy day:\n","");
  291.     for(i = 1; i <= 12; i++)
  292.         for(j = 1; j <= 31; j++) {
  293.             if(dayacc[i][j].used) {
  294.                 hourtmp = dayacc[i][j].trecv / 60;
  295.                 second = dayacc[i][j].trecv - ( hourtmp * 60);
  296.                 hour =  hourtmp / 60;    /* gives integer hour */
  297.                 min = hourtmp - ( hour * 60);
  298.                 printf("%5s%2d/%02d ", "", i,j);
  299.                 printf("recieved %8ld bytes in ", dayacc[i][j].recv);
  300.                 printf("%02ld:%02ld:%02ld/sent %8ld bytes in ",
  301.                     hour,min,second, dayacc[i][j].sent);
  302.                 hourtmp = dayacc[i][j].tsent / 60;
  303.                 second = dayacc[i][j].tsent - ( hourtmp * 60);
  304.                 hour =  hourtmp / 60;    /* gives integer hour */
  305.                 min = hourtmp - ( hour * 60);
  306.                 printf("%02ld:%02ld:%02ld\n", hour,min,second);
  307.             }
  308.         }
  309.     exit(0);
  310. }
  311. error(s)
  312. char *s;
  313. {
  314.     fprintf(stderr,"%s\n", s);
  315.     exit(1);
  316. }
  317. tindex(s,t)
  318. char s[], t[];
  319. {
  320.     register int j,k,i;
  321.     for(i=0;s[i] != '\0'; i++) {
  322.         for(j=i,k=0;t[k] != '\0' && s[j]== t[k]; j++, k++)
  323.             ;
  324.         if(t[k] == '\0')
  325.             return(i);
  326.     }
  327.     return(-1);
  328. }
  329. char *strsave(s)    /* save string s somewhere */
  330. char *s;
  331. {
  332.     char *p;
  333.  
  334.     if((p = malloc(strlen(s)+1)) != NULL)
  335.         strcpy(p,s);
  336.     else {
  337.         error("strsave: out of mem");
  338.     }
  339.     return(p);
  340. }
  341. struct users *tree(p,w)
  342. struct users *p;
  343. char *w;
  344. {
  345.     if(p == NULL) { /* new word */
  346.         p = (struct users *) malloc (sizeof(struct users));
  347.         p->name = strsave(w);
  348.         p->bsent = byt;
  349.         p->utim = tim;
  350.         p->nsent = 1;
  351.         p->nuser = NULL;
  352.     }
  353.     else if(strcmp(w,p->name) == 0) {
  354.         p->bsent += byt;
  355.         p->utim += tim;
  356.         p->nsent++;
  357.     }
  358.     else {
  359.         p->nuser = tree(p->nuser,w);
  360.     }
  361.     return(p);
  362. }
  363. struct call *tcall(p,w)
  364. struct call *p;
  365. char *w;
  366. {
  367.     if(p == NULL) { /* new cmd */
  368.         p = (struct call *) malloc (sizeof(struct call));
  369.         if(p == NULL)
  370.             error("tcall out of Mem");
  371.         p->ncall = NULL;
  372.         p->cname = strsave(w);
  373.         p->times = 1;
  374.         cmdcount++;
  375.     }
  376.     else if(strcmp(w,p->cname) == 0) {
  377.         p->times++;
  378.     }
  379.     else {
  380.         p->ncall = tcall(p->ncall,w);
  381.     }
  382.     return(p);
  383. }
  384. treeprint(p)
  385. struct users *p;
  386. {
  387.     if(p != NULL) {
  388.         printf("%10s%10s ", "", p->name);
  389.         printf("sent %4ld files & %10ld bytes ", p->nsent, p->bsent);
  390.         hourtmp = p->utim /60;
  391.         second = p->utim - ( hourtmp * 60 );
  392.         hour = hourtmp / 60;
  393.         min = hourtmp - (hour * 60);
  394.         printf("%02ld:%02ld:%02ld\n", hour,min,second);
  395.         treeprint(p->nuser);
  396.     }
  397. }
  398. tcallpr(p)
  399. struct call *p;
  400. {
  401.     if(p != NULL ) {
  402.         printf("%10d %s\n", p->times, p->cname);
  403.         tcallpr(p->ncall);
  404.     }
  405. }
  406. trsort()
  407. {
  408.     struct call *q;
  409.     struct call *p;
  410.     register int i, sw, n,m;
  411.     char *c;
  412.     char *d;
  413.  
  414. loop:
  415.     p = cmd;
  416.     sw = 0;
  417.     for(i=0;i< cmdcount-1; i++) {
  418.         q = p->ncall;
  419.         if(p->times < q->times) { /* switch */
  420.             c = p->cname;
  421.             n = p->times;
  422.             d = q->cname;
  423.             m = q->times;
  424.             p->cname = d;
  425.             p->times = m;
  426.             q->cname = c;
  427.             q->times = n;
  428.             sw = 1;
  429.         }
  430.         p = p->ncall;
  431.     }
  432.     if(sw)
  433.         goto loop;
  434. }
  435. #define NULLP ""
  436. char *
  437. getfield(field,buffer,separator)
  438. char separator;
  439. char buffer[];
  440. int field;
  441. {
  442.     register int i;
  443.     char *bp, *p, buff[512];
  444.     int sht;
  445.     sht = 0;
  446.     strcpy(buff,buffer);
  447.     p = &buff[0];
  448.     i = 0;
  449.     if((*p == separator) && (field != 0)) {
  450.         field -= 1;
  451.         sht = 1;
  452.     }
  453.     while( i != field) {
  454.         for(++p; *p != separator; p++) {
  455.             if (*p == '\0') {
  456.                 return(NULLP);
  457.             }
  458.         }
  459.         i++;
  460.     }
  461.     if(sht)
  462.         field += 1;
  463.     if(field != 0) p++;
  464.     bp =p;
  465.     for (; *p != separator; p++)
  466.         if(*p == '\0')
  467.             return(bp);
  468.     *p = '\0';
  469.     return(bp);
  470. }
  471. !End!Of!Stuff!
  472. echo x - LOGFILE
  473. cat >LOGFILE <<'!End!Of!Stuff!'
  474. root uiucdcs (11/1-7:01-28696) notes XQT (PATH=/usr/ucb:/bin:/usr/bin:/etc;nfrcv net.news.group uiucdcs ) 
  475. root uiucdcs (11/1-7:01-28696) notes XQT (PATH=/usr/ucb:/bin:/usr/bin:/etc;nfrcv net.rec.photo uiucdcs ) 
  476. uucp cepu (11/1-7:07-28717) OK (startup) 
  477. uucp cepu (11/1-7:07-28717) OK (conversation complete) 
  478. brad ihnp4 (11/1-8:013-29001) WRONG TIME TO CALL (ihnp4) 
  479. brad ihnp4 (11/1-8:013-29001) FAILED (call to ihnp4 ) 
  480. brad ihnp4 (11/1-8:020-29043) WRONG TIME TO CALL (ihnp4) 
  481. brad ihnp4 (11/1-8:020-29043) FAILED (call to ihnp4 ) 
  482. brad uiucdcs (11/1-8:025-29072) WRONG TIME TO CALL (uiucdcs) 
  483. brad uiucdcs (11/1-8:025-29072) FAILED (call to uiucdcs ) 
  484. brad ihnp4 (11/1-8:042-29152) WRONG TIME TO CALL (ihnp4) 
  485. brad ihnp4 (11/1-8:042-29152) FAILED (call to ihnp4 ) 
  486. root ihnp4 (11/1-8:054-29298) SUCCEEDED (call to ihnp4 ) 
  487. root ihnp4 (11/1-8:054-29298) OK (startup) 
  488. brad ihnp4 (11/1-8:054-29298) REQUEST (S D.ihnp4B23lu D.ihnp4B23lu brad) 
  489. brad ihnp4 (11/1-8:055-29298) REQUESTED (CY) 
  490. brad ihnp4 (11/1-8:055-29298) REQUEST (S D.bradleyX23ls X.bradleyX23ls brad) 
  491. brad ihnp4 (11/1-8:055-29298) REQUESTED (CY) 
  492. !End!Of!Stuff!
  493. echo x - SYSLOG
  494. cat >SYSLOG <<'!End!Of!Stuff!'
  495. brad ihnp4 (11/1-8:055) (468168935) sent data 433 bytes 4 secs
  496. brad ihnp4 (11/1-8:055) (468168943) sent data 75 bytes 1 secs
  497. uucp ihnp4 (11/1-8:055) (468168959) received data 771 bytes 10 secs
  498. uucp ihnp4 (11/1-8:056) (468168964) received data 166 bytes 3 secs
  499. euucp ihnp4 (11/1-8:056) (468168994) received data 2629 bytes 26 secs
  500. euucp ihnp4 (11/1-8:056) (468169001) received data 160 bytes 3 secs
  501. uucp ihnp4 (11/1-8:056) (468169019) received data 1312 bytes 15 secs
  502. uucp ihnp4 (11/1-8:057) (468169025) received data 141 bytes 4 secs
  503. brad uiucdcs (11/1-8:058) (468169104) sent data 183 bytes 1 secs
  504. brad uiucdcs (11/1-8:058) (468169110) sent data 73 bytes 0 secs
  505. !End!Of!Stuff!
  506. exit
  507.  
  508.  
  509.