Return to generate.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / sysmon

Annotation of researchv9/jerq/src/sysmon/generate.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <errno.h>
                      3: #include <sys/param.h>
                      4: #include <sys/types.h>
                      5: #include <sys/stat.h>
                      6: #include <dir.h>
                      7: #include "defs.h"
                      8: #include "load.h"
                      9: 
                     10: /* globals for mail scanning */
                     11: FILE *mlfp = NULL;
                     12: struct stat s;
                     13: struct stat os;
                     14: int doscan = FALSE;
                     15: char *user[NOFILE];
                     16: 
                     17: /* imported */
                     18: extern int errno;
                     19: 
                     20: /* initialize */
                     21: init()
                     22: {
                     23:        initload();
                     24: }
                     25: 
                     26: /* return my name */
                     27: char *
                     28: myname()
                     29: {
                     30:        return ("mon");
                     31: }
                     32: 
                     33: /* send the current information to a client */
                     34: sendinfo (fd)
                     35: int fd;
                     36: {
                     37:        char *p, *strchr();
                     38:        char buf[128];
                     39:        char line[128];
                     40:        char token[128];
                     41:        int len, n;
                     42: 
                     43:        /* send the load */
                     44:        sprintf(buf, "load %f time %d vec %d %d %d %d %d\n",
                     45:                load.l_runq, load.l_time, load.l_cp[0], load.l_cp[1],
                     46:                load.l_cp[2], load.l_cp[3], load.l_cp[4]);
                     47:        len = strlen(buf);
                     48:        if (write (fd, buf, len) != len)
                     49:                return (-1);
                     50: 
                     51:        /* check for mail if its time */
                     52:        strcpy(token, "delivered ");
                     53:        strcat(token, user);
                     54:        strcat(token, " From ");
                     55:        n = strlen(token);
                     56:        if (doscan) {
                     57:                if (fseek(mlfp, os.st_size, 0) < 0) {
                     58:                        os.st_ino = 0;
                     59:                        return 0;
                     60:                }
                     61:                while (fgets(line, sizeof(line), mlfp)!=NULL) {
                     62:                        if (strncmp(token, line, n)!=0)
                     63:                                continue;
                     64:                        p = strchr(&line[n], ' ');
                     65:                        if (p==NULL)
                     66:                                continue;
                     67:                        *p = '\0';
                     68:                        sprintf(buf, "from %s\n", &line[n]);
                     69:                        len = strlen(buf);
                     70:                        if (write (fd, buf, len) != len)
                     71:                                return (-1);
                     72:                }
                     73:        }
                     74:        return (0);
                     75: }
                     76: 
                     77: /* generate the current information */
                     78: generate()
                     79: {
                     80:        long now;
                     81:        static long lastscan;
                     82: #define MAILNAME "/usr/spool/mail/mail.log"
                     83: 
                     84:        /* get load info */
                     85:        genload ();
                     86: 
                     87:        /* find out if we should scanmn the mail */
                     88:        now = time (NULL);
                     89:        doscan = (now - lastscan) > 60;
                     90:        if (doscan) {
                     91:                os = s;
                     92:                lastscan = now;
                     93:                if (stat(MAILNAME, &s)<0) {
                     94:                        doscan = FALSE;
                     95:                } else if (os.st_dev != s.st_dev || os.st_ino != s.st_ino) {
                     96:                        if (mlfp)
                     97:                                fclose(mlfp);
                     98:                        mlfp = fopen (MAILNAME, "r");
                     99:                        os.st_size = 0;
                    100:                } else if (os.st_size == s.st_size) {
                    101:                        doscan = FALSE;
                    102:                }
                    103:        }
                    104: }
                    105: 
                    106: /* add a client */
                    107: void
                    108: add (fd, who)
                    109:        int fd;
                    110:        char *who;
                    111: {
                    112:        char *strdup();
                    113: 
                    114:        if (user[fd])
                    115:                free(user[fd]);
                    116:        user[fd] = strdup(who);
                    117: }
                    118: 
                    119: /* drop a client */
                    120: void
                    121: drop (fd)
                    122: {
                    123: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.