Return to scanmail.c CVS log

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

Annotation of researchv9/jerq/src/sysmon/scanmail.c, revision 1.1

1.1     ! root        1: #include <sys/types.h>
        !             2: #include <dir.h>
        !             3: #include <sys/stat.h>
        !             4: #include <stdio.h>
        !             5: #include "defs.h"
        !             6: #include "scanmail.h"
        !             7: 
        !             8: /* import */
        !             9: extern char *strcat(), *strcpy(), *strncpy();
        !            10: 
        !            11: /* init the file */
        !            12: void
        !            13: sminit (smp, file, name)
        !            14:        struct scanmail *smp;
        !            15:        char *file;
        !            16:        char *name;
        !            17: {
        !            18:        char *p;
        !            19:        struct stat buf;
        !            20:        char dir[128];
        !            21:        char *strrchr();
        !            22:        char islog = FALSE;
        !            23:        int fd;
        !            24: 
        !            25:        /* look for a mail log */
        !            26:        if ((fd=open(MAILLOG, 0)) >= 0)
        !            27:                islog = TRUE;
        !            28:        close(fd);
        !            29: 
        !            30:        /* defaults */
        !            31:        strcpy (smp->sm_match, "From ");
        !            32:        smp->sm_log = FALSE;
        !            33: 
        !            34:        /* change directory to avoid screwing with namei */
        !            35:        strcpy(dir, MAILDIR);
        !            36:        strcat(dir, "/");
        !            37:        strcat(dir, name);
        !            38:        if (file == NULL || strcmp(dir, file) == 0) {
        !            39: 
        !            40:                /* use the standard mail directory if none is specified */
        !            41:                chdir (MAILDIR);
        !            42:                if (islog) {
        !            43:                        smp->sm_log = TRUE;
        !            44:                        strcpy (smp->sm_file, MAILNAME);
        !            45:                        strcpy (smp->sm_match, "delivered ");
        !            46:                        strcat (smp->sm_match, name);
        !            47:                        strcat (smp->sm_match, " From ");
        !            48:                } else {
        !            49:                        strcpy (smp->sm_file, name);
        !            50:                }
        !            51:        } else {
        !            52: 
        !            53:                /* use whatever was specified */
        !            54:                if ((p = strrchr(file, '/')) != NULL) {
        !            55:                        strcpy (smp->sm_file, ++p);
        !            56:                        strncpy (dir, file, p - file);
        !            57:                        dir[p-file] = '\0';
        !            58:                        chdir (dir);
        !            59:                } else {
        !            60:                        strcpy (smp->sm_file, file);
        !            61:                }
        !            62:        }
        !            63: 
        !            64:        /* get the end point */
        !            65:        smp->sm_pos = (stat(smp->sm_file, &buf) < 0)? 0 : buf.st_size;
        !            66: }
        !            67: 
        !            68: /* get the next header line (if the file has changed) */
        !            69: char *
        !            70: smnext (smp, fp)
        !            71:        struct scanmail *smp;
        !            72:        FILE *fp;
        !            73: {
        !            74:        struct stat buf;
        !            75:        static char line[128];
        !            76:        int len;
        !            77:        char *sp=NULL, *mp, *ep;
        !            78:        FILE *f;
        !            79:        char *strchr();
        !            80: 
        !            81:        /* return if it hasn't gotten longer */
        !            82:        if (stat(smp->sm_file, &buf) < 0)
        !            83:                return 0;
        !            84:        if (buf.st_size <= smp->sm_pos) {
        !            85:                smp->sm_pos = buf.st_size;
        !            86:                return 0;
        !            87:        }
        !            88: 
        !            89:        /* it's grown, read it line by line */
        !            90:        f = (fp != NULL && smp->sm_log) ? fp : fopen (smp->sm_file, "r");
        !            91:        fseek (f, smp->sm_pos, 0);
        !            92:        len = strlen(smp->sm_match);
        !            93:        while (fgets(line, sizeof line, f) != NULL) {
        !            94: 
        !            95:                /* remember how far we've read */
        !            96:                smp->sm_pos += strlen (line);
        !            97: 
        !            98:                /* look for a match */
        !            99:                if (strncmp(line, smp->sm_match, strlen(smp->sm_match)) == 0) {
        !           100: 
        !           101:                        /* get the sender's name and machine */
        !           102:                        ep = mp = line+len;
        !           103:                        while (1) {
        !           104:                                sp = mp;
        !           105:                                mp = ep;
        !           106:                                if ((ep = strchr(ep, '!')) == NULL)
        !           107:                                        break;
        !           108:                                ep++;
        !           109:                        }
        !           110:                        for (ep = sp; *ep != ' ' && *ep != '\0'; ep++)
        !           111:                                ;
        !           112:                        *ep = '\0';
        !           113:                        break;
        !           114:                }
        !           115:        }
        !           116:        if (fp == NULL || !smp->sm_log)
        !           117:                fclose (f);
        !           118:        return sp;
        !           119: }

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