Return to log.c CVS log

Up to [Research Unix] / researchv10no / cmd / upas / send

Annotation of researchv10no/cmd/upas/send/log.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     WARNING! the mail log does not get locked.
        !             3:  *
        !             4:  *     Vismon users beware!
        !             5:  */
        !             6: #include "mail.h"
        !             7: #include "string.h"
        !             8: #include "message.h"
        !             9: #include "aux.h"
        !            10: #include "dest.h"
        !            11: #include <sys/stat.h>
        !            12: 
        !            13: /* configuration */
        !            14: #define LOGFILE "mail.log"
        !            15: 
        !            16: /* imports */
        !            17: extern struct tm *localtime();
        !            18: extern char *asctime();
        !            19: extern long time();
        !            20: 
        !            21: /* open log file for appending */
        !            22: static int
        !            23: logopen()
        !            24: {
        !            25:        int out;
        !            26:        string *file=s_new();
        !            27:        long lseek();
        !            28: 
        !            29:        umask(0);
        !            30:        abspath(LOGFILE, MAILROOT, file);
        !            31:        out = open(s_to_c(file), 2);
        !            32:        if(out<0)
        !            33:                out = creat(s_to_c(file), 0666);
        !            34:        s_free(file);
        !            35:        return out;
        !            36: }
        !            37: 
        !            38: /* log mail delivery */
        !            39: logdelivery(list, rcvr, mp)
        !            40:        dest *list;     /* receiver(s) */
        !            41:        char *rcvr;     /* mailbox */
        !            42:        message *mp;    /* message */
        !            43: {
        !            44:        dest *next;
        !            45:        int out;
        !            46:        char buf[2048];
        !            47:        dest *parent;
        !            48:        char *dp;
        !            49:        struct tm *bp;
        !            50:        long thetime;
        !            51: 
        !            52:        out = logopen();
        !            53: 
        !            54:        thetime = time((long *)0);
        !            55:        bp = localtime(&thetime);
        !            56:        dp = asctime(bp);
        !            57: 
        !            58:        for(parent=list; parent->parent!=NULL; parent=parent->parent)
        !            59:                ;
        !            60:        if(parent!=list && strcmp(s_to_c(parent->addr), rcvr)!=0)
        !            61:                sprintf(buf,"delivered %s From %.256s %.256s (%.256s) [%.5s] %d\n",
        !            62:                        rcvr,
        !            63:                        s_to_c(mp->sender), s_to_c(mp->date),
        !            64:                        s_to_c(parent->addr), dp+11, mp->size);
        !            65:        else
        !            66:                sprintf(buf, "delivered %s From %.256s %.256s [%.5s] %d\n", rcvr,
        !            67:                        s_to_c(mp->sender), s_to_c(mp->date), dp+11, mp->size);
        !            68:        lseek(out, 0L, 2);
        !            69:        write(out, buf, strlen(buf));
        !            70: 
        !            71:        close(out);
        !            72: }
        !            73: 
        !            74: /* log mail forwarding */
        !            75: loglist(list, mp, tag)
        !            76:        dest *list;     /* receiver(s) */
        !            77:        message *mp;    /* message */
        !            78:        char *tag;      /* type of mail */
        !            79: {
        !            80:        dest *next;
        !            81:        int out;
        !            82:        char buf[2048];
        !            83:        dest *parent;
        !            84:        char *dp;
        !            85:        struct tm *bp;
        !            86:        long thetime;
        !            87: 
        !            88:        out = logopen();
        !            89: 
        !            90:        thetime = time((long *)0);
        !            91:        bp = localtime(&thetime);
        !            92:        dp = asctime(bp);
        !            93: 
        !            94:        for(next=d_rm(&list); next != NULL; next = d_rm(&list)) {
        !            95:                for(parent=next; parent->parent!=NULL; parent=parent->parent)
        !            96:                        ;
        !            97:                if(parent!=next)
        !            98:                        sprintf(buf, "%s %.256s From %.256s %.256s (%.256s) [%.5s] %d\n",
        !            99:                                tag,
        !           100:                                s_to_c(next->addr), s_to_c(mp->sender),
        !           101:                                s_to_c(mp->date), s_to_c(parent->addr), dp+11,
        !           102:                                mp->size);
        !           103:                else
        !           104:                        sprintf(buf, "%s %.256s From %.256s %.256s [%.5s] %d\n", tag,
        !           105:                                s_to_c(next->addr), s_to_c(mp->sender),
        !           106:                                s_to_c(mp->date), dp+11, mp->size);
        !           107:                lseek(out, 0L, 2);
        !           108:                write(out, buf, strlen(buf));
        !           109:        }
        !           110:        close(out);
        !           111: }
        !           112: 
        !           113: /* log a mail refusal */
        !           114: logrefusal(dp, mp, msg)
        !           115:        dest *dp;       /* receiver */
        !           116:        message *mp;    /* message */
        !           117:        char *msg;      /* error message */
        !           118: {
        !           119:        int out;
        !           120:        char buf[2048];
        !           121:        char *cp, *ep;
        !           122: 
        !           123:        out = logopen();
        !           124:        sprintf(buf, "error %.256s From %.256s %.256s\nerror+ ", s_to_c(dp->addr),
        !           125:                s_to_c(mp->sender), s_to_c(mp->date));
        !           126:        cp = buf + strlen(buf);
        !           127:        ep = buf + sizeof(buf) - sizeof("error + ");
        !           128:        while(*msg && cp<ep) {
        !           129:                *cp++ = *msg;
        !           130:                if (*msg++ == '\n') {
        !           131:                        strcpy(cp, "error+ ");
        !           132:                        cp += sizeof("error+ ") - 1;
        !           133:                }
        !           134:        }
        !           135:        *cp++ = '\n';
        !           136:        lseek(out, 0L, 2);
        !           137:        write(out, buf, cp - buf);
        !           138:        close(out);
        !           139: }

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