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

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.