Return to vacation.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb

Annotation of 43BSD/ucb/vacation.c, revision 1.1

1.1     ! root        1: /*
        !             2: **  Vacation
        !             3: **  Copyright (c) 1983  Eric P. Allman
        !             4: **  Berkeley, California
        !             5: **
        !             6: **  Copyright (c) 1983 Regents of the University of California.
        !             7: **  All rights reserved.  The Berkeley software License Agreement
        !             8: **  specifies the terms and conditions for redistribution.
        !             9: */
        !            10: 
        !            11: #ifndef lint
        !            12: static char    SccsId[] = "@(#)vacation.c      5.3 (Berkeley) 7/1/85";
        !            13: #endif not lint
        !            14: 
        !            15: # include <sys/types.h>
        !            16: # include <pwd.h>
        !            17: # include <stdio.h>
        !            18: # include <sysexits.h>
        !            19: # include <ctype.h>
        !            20: 
        !            21: /*
        !            22: **  VACATION -- return a message to the sender when on vacation.
        !            23: **
        !            24: **     This program could be invoked as a message receiver
        !            25: **     when someone is on vacation.  It returns a message
        !            26: **     specified by the user to whoever sent the mail, taking
        !            27: **     care not to return a message too often to prevent
        !            28: **     "I am on vacation" loops.
        !            29: **
        !            30: **     Positional Parameters:
        !            31: **             the user to collect the vacation message from.
        !            32: **
        !            33: **     Flag Parameters:
        !            34: **             -I      initialize the database.
        !            35: **             -d      turn on debugging.
        !            36: **
        !            37: **     Side Effects:
        !            38: **             A message is sent back to the sender.
        !            39: **
        !            40: **     Author:
        !            41: **             Eric Allman
        !            42: **             UCB/INGRES
        !            43: */
        !            44: 
        !            45: typedef int    bool;
        !            46: 
        !            47: # define TRUE          1
        !            48: # define FALSE         0
        !            49: 
        !            50: # define MAXLINE       256     /* max size of a line */
        !            51: # define MAXNAME       128     /* max size of one name */
        !            52: 
        !            53: # define ONEWEEK       (60L*60L*24L*7L)
        !            54: 
        !            55: time_t Timeout = ONEWEEK;      /* timeout between notices per user */
        !            56: 
        !            57: struct dbrec
        !            58: {
        !            59:        long    sentdate;
        !            60: };
        !            61: 
        !            62: typedef struct
        !            63: {
        !            64:        char    *dptr;
        !            65:        int     dsize;
        !            66: } DATUM;
        !            67: 
        !            68: extern DATUM fetch();
        !            69: 
        !            70: 
        !            71: 
        !            72: bool   Debug = FALSE;
        !            73: 
        !            74: main(argc, argv)
        !            75:        char **argv;
        !            76: {
        !            77:        char *from;
        !            78:        register char *p;
        !            79:        struct passwd *pw;
        !            80:        char *homedir;
        !            81:        char *myname;
        !            82:        char buf[MAXLINE];
        !            83:        extern struct passwd *getpwnam();
        !            84:        extern char *newstr();
        !            85:        extern char *getfrom();
        !            86:        extern bool knows();
        !            87:        extern bool junkmail();
        !            88:        extern time_t convtime();
        !            89: 
        !            90:        /* process arguments */
        !            91:        while (--argc > 0 && (p = *++argv) != NULL && *p == '-')
        !            92:        {
        !            93:                switch (*++p)
        !            94:                {
        !            95:                  case 'I':     /* initialize */
        !            96:                        initialize();
        !            97:                        exit(EX_OK);
        !            98: 
        !            99:                  case 'd':     /* debug */
        !           100:                        Debug = TRUE;
        !           101:                        break;
        !           102: 
        !           103:                  default:
        !           104:                        usrerr("Unknown flag -%s", p);
        !           105:                        exit(EX_USAGE);
        !           106:                }
        !           107:        }
        !           108: 
        !           109:        /* verify recipient argument */
        !           110:        if (argc != 1)
        !           111:        {
        !           112:                usrerr("Usage: vacation username (or) vacation -I");
        !           113:                exit(EX_USAGE);
        !           114:        }
        !           115: 
        !           116:        myname = p;
        !           117: 
        !           118:        /* find user's home directory */
        !           119:        pw = getpwnam(myname);
        !           120:        if (pw == NULL)
        !           121:        {
        !           122:                usrerr("Unknown user %s", myname);
        !           123:                exit(EX_NOUSER);
        !           124:        }
        !           125:        homedir = newstr(pw->pw_dir);
        !           126:        (void) strcpy(buf, homedir);
        !           127:        (void) strcat(buf, "/.vacation");
        !           128:        dbminit(buf);
        !           129: 
        !           130:        /* read message from standard input (just from line) */
        !           131:        from = getfrom();
        !           132: 
        !           133:        /* check if junk mail or this person is already informed */
        !           134:        if (!junkmail(from) && !knows(from))
        !           135:        {
        !           136:                /* mark this person as knowing */
        !           137:                setknows(from);
        !           138: 
        !           139:                /* send the message back */
        !           140:                (void) strcpy(buf, homedir);
        !           141:                (void) strcat(buf, "/.vacation.msg");
        !           142:                if (Debug)
        !           143:                        printf("Sending %s to %s\n", buf, from);
        !           144:                else
        !           145:                {
        !           146:                        sendmessage(buf, from, myname);
        !           147:                        /*NOTREACHED*/
        !           148:                }
        !           149:        }
        !           150:        exit (EX_OK);
        !           151: }
        !           152: /*
        !           153: **  GETFROM -- read message from standard input and return sender
        !           154: **
        !           155: **     Parameters:
        !           156: **             none.
        !           157: **
        !           158: **     Returns:
        !           159: **             pointer to the sender address.
        !           160: **
        !           161: **     Side Effects:
        !           162: **             Reads first line from standard input.
        !           163: */
        !           164: 
        !           165: char *
        !           166: getfrom()
        !           167: {
        !           168:        static char line[MAXLINE];
        !           169:        register char *p;
        !           170:        extern char *index();
        !           171: 
        !           172:        /* read the from line */
        !           173:        if (fgets(line, sizeof line, stdin) == NULL ||
        !           174:            strncmp(line, "From ", 5) != NULL)
        !           175:        {
        !           176:                usrerr("No initial From line");
        !           177:                exit(EX_USAGE);
        !           178:        }
        !           179: 
        !           180:        /* find the end of the sender address and terminate it */
        !           181:        p = index(&line[5], ' ');
        !           182:        if (p == NULL)
        !           183:        {
        !           184:                usrerr("Funny From line '%s'", line);
        !           185:                exit(EX_USAGE);
        !           186:        }
        !           187:        *p = '\0';
        !           188: 
        !           189:        /* return the sender address */
        !           190:        return (&line[5]);
        !           191: }
        !           192: /*
        !           193: **  JUNKMAIL -- read the header and tell us if this is junk/bulk mail.
        !           194: **
        !           195: **     Parameters:
        !           196: **             from -- the Return-Path of the sender.  We assume that
        !           197: **                     anything from "*-REQUEST@*" is bulk mail.
        !           198: **
        !           199: **     Returns:
        !           200: **             TRUE -- if this is junk or bulk mail (that is, if the
        !           201: **                     sender shouldn't receive a response).
        !           202: **             FALSE -- if the sender deserves a response.
        !           203: **
        !           204: **     Side Effects:
        !           205: **             May read the header from standard input.  When this
        !           206: **             returns the position on stdin is undefined.
        !           207: */
        !           208: 
        !           209: bool
        !           210: junkmail(from)
        !           211:        char *from;
        !           212: {
        !           213:        register char *p;
        !           214:        char buf[MAXLINE+1];
        !           215:        extern char *index();
        !           216:        extern char *rindex();
        !           217:        extern bool sameword();
        !           218: 
        !           219:        /* test for inhuman sender */
        !           220:        p = rindex(from, '@');
        !           221:        if (p != NULL)
        !           222:        {
        !           223:                *p = '\0';
        !           224:                if (sameword(&p[-8],  "-REQUEST") ||
        !           225:                    sameword(&p[-10], "Postmaster") ||
        !           226:                    sameword(&p[-13], "MAILER-DAEMON"))
        !           227:                {
        !           228:                        *p = '@';
        !           229:                        return (TRUE);
        !           230:                }
        !           231:                *p = '@';
        !           232:        }
        !           233: 
        !           234:        /* read the header looking for a "Precedence:" line */
        !           235:        while (fgets(buf, MAXLINE, stdin) != NULL && buf[0] != '\n')
        !           236:        {
        !           237:                /* should ignore case, but this is reasonably safe */
        !           238:                if (strncmp(buf, "Precedence", 10) != 0 ||
        !           239:                    !(buf[10] == ':' || buf[10] == ' ' || buf[10] == '\t'))
        !           240:                {
        !           241:                        continue;
        !           242:                }
        !           243: 
        !           244:                /* find the value of this field */
        !           245:                p = index(buf, ':');
        !           246:                if (p == NULL)
        !           247:                        continue;
        !           248:                while (*++p != '\0' && isspace(*p))
        !           249:                        continue;
        !           250:                if (*p == '\0')
        !           251:                        continue;
        !           252: 
        !           253:                /* see if it is "junk" or "bulk" */
        !           254:                p[4] = '\0';
        !           255:                if (sameword(p, "junk") || sameword(p, "bulk"))
        !           256:                        return (TRUE);
        !           257:        }
        !           258:        return (FALSE);
        !           259: }
        !           260: /*
        !           261: **  KNOWS -- predicate telling if user has already been informed.
        !           262: **
        !           263: **     Parameters:
        !           264: **             user -- the user who sent this message.
        !           265: **
        !           266: **     Returns:
        !           267: **             TRUE if 'user' has already been informed that the
        !           268: **                     recipient is on vacation.
        !           269: **             FALSE otherwise.
        !           270: **
        !           271: **     Side Effects:
        !           272: **             none.
        !           273: */
        !           274: 
        !           275: bool
        !           276: knows(user)
        !           277:        char *user;
        !           278: {
        !           279:        DATUM k, d;
        !           280:        long now;
        !           281:        auto long then;
        !           282: 
        !           283:        time(&now);
        !           284:        k.dptr = user;
        !           285:        k.dsize = strlen(user) + 1;
        !           286:        d = fetch(k);
        !           287:        if (d.dptr == NULL)
        !           288:                return (FALSE);
        !           289:        
        !           290:        /* be careful on 68k's and others with alignment restrictions */
        !           291:        bcopy((char *) &((struct dbrec *) d.dptr)->sentdate, (char *) &then, sizeof then);
        !           292:        if (then + Timeout < now)
        !           293:                return (FALSE);
        !           294:        return (TRUE);
        !           295: }
        !           296: /*
        !           297: **  SETKNOWS -- set that this user knows about the vacation.
        !           298: **
        !           299: **     Parameters:
        !           300: **             user -- the user who should be marked.
        !           301: **
        !           302: **     Returns:
        !           303: **             none.
        !           304: **
        !           305: **     Side Effects:
        !           306: **             The dbm file is updated as appropriate.
        !           307: */
        !           308: 
        !           309: setknows(user)
        !           310:        char *user;
        !           311: {
        !           312:        DATUM k, d;
        !           313:        struct dbrec xrec;
        !           314: 
        !           315:        k.dptr = user;
        !           316:        k.dsize = strlen(user) + 1;
        !           317:        time(&xrec.sentdate);
        !           318:        d.dptr = (char *) &xrec;
        !           319:        d.dsize = sizeof xrec;
        !           320:        store(k, d);
        !           321: }
        !           322: /*
        !           323: **  SENDMESSAGE -- send a message to a particular user.
        !           324: **
        !           325: **     Parameters:
        !           326: **             msgf -- filename containing the message.
        !           327: **             user -- user who should receive it.
        !           328: **
        !           329: **     Returns:
        !           330: **             none.
        !           331: **
        !           332: **     Side Effects:
        !           333: **             sends mail to 'user' using /usr/lib/sendmail.
        !           334: */
        !           335: 
        !           336: sendmessage(msgf, user, myname)
        !           337:        char *msgf;
        !           338:        char *user;
        !           339:        char *myname;
        !           340: {
        !           341:        FILE *f;
        !           342: 
        !           343:        /* find the message to send */
        !           344:        f = freopen(msgf, "r", stdin);
        !           345:        if (f == NULL)
        !           346:        {
        !           347:                f = freopen("/usr/lib/vacation.def", "r", stdin);
        !           348:                if (f == NULL)
        !           349:                        syserr("No message to send");
        !           350:        }
        !           351: 
        !           352:        execl("/usr/lib/sendmail", "sendmail", "-f", myname, user, NULL);
        !           353:        syserr("Cannot exec /usr/lib/sendmail");
        !           354: }
        !           355: /*
        !           356: **  INITIALIZE -- initialize the database before leaving for vacation
        !           357: **
        !           358: **     Parameters:
        !           359: **             none.
        !           360: **
        !           361: **     Returns:
        !           362: **             none.
        !           363: **
        !           364: **     Side Effects:
        !           365: **             Initializes the files .vacation.{pag,dir} in the
        !           366: **             caller's home directory.
        !           367: */
        !           368: 
        !           369: initialize()
        !           370: {
        !           371:        char *homedir;
        !           372:        char buf[MAXLINE];
        !           373:        extern char *getenv();
        !           374: 
        !           375:        setgid(getgid());
        !           376:        setuid(getuid());
        !           377:        homedir = getenv("HOME");
        !           378:        if (homedir == NULL)
        !           379:                syserr("No home!");
        !           380:        (void) strcpy(buf, homedir);
        !           381:        (void) strcat(buf, "/.vacation.dir");
        !           382:        if (close(creat(buf, 0644)) < 0)
        !           383:                syserr("Cannot create %s", buf);
        !           384:        (void) strcpy(buf, homedir);
        !           385:        (void) strcat(buf, "/.vacation.pag");
        !           386:        if (close(creat(buf, 0644)) < 0)
        !           387:                syserr("Cannot create %s", buf);
        !           388: }
        !           389: /*
        !           390: **  USRERR -- print user error
        !           391: **
        !           392: **     Parameters:
        !           393: **             f -- format.
        !           394: **             p -- first parameter.
        !           395: **
        !           396: **     Returns:
        !           397: **             none.
        !           398: **
        !           399: **     Side Effects:
        !           400: **             none.
        !           401: */
        !           402: 
        !           403: usrerr(f, p)
        !           404:        char *f;
        !           405:        char *p;
        !           406: {
        !           407:        fprintf(stderr, "vacation: ");
        !           408:        _doprnt(f, &p, stderr);
        !           409:        fprintf(stderr, "\n");
        !           410: }
        !           411: /*
        !           412: **  SYSERR -- print system error
        !           413: **
        !           414: **     Parameters:
        !           415: **             f -- format.
        !           416: **             p -- first parameter.
        !           417: **
        !           418: **     Returns:
        !           419: **             none.
        !           420: **
        !           421: **     Side Effects:
        !           422: **             none.
        !           423: */
        !           424: 
        !           425: syserr(f, p)
        !           426:        char *f;
        !           427:        char *p;
        !           428: {
        !           429:        fprintf(stderr, "vacation: ");
        !           430:        _doprnt(f, &p, stderr);
        !           431:        fprintf(stderr, "\n");
        !           432:        exit(EX_USAGE);
        !           433: }
        !           434: /*
        !           435: **  NEWSTR -- copy a string
        !           436: **
        !           437: **     Parameters:
        !           438: **             s -- the string to copy.
        !           439: **
        !           440: **     Returns:
        !           441: **             A copy of the string.
        !           442: **
        !           443: **     Side Effects:
        !           444: **             none.
        !           445: */
        !           446: 
        !           447: char *
        !           448: newstr(s)
        !           449:        char *s;
        !           450: {
        !           451:        char *p;
        !           452:        extern char *malloc();
        !           453: 
        !           454:        p = malloc(strlen(s) + 1);
        !           455:        if (p == NULL)
        !           456:        {
        !           457:                syserr("newstr: cannot alloc memory");
        !           458:                exit(EX_OSERR);
        !           459:        }
        !           460:        strcpy(p, s);
        !           461:        return (p);
        !           462: }
        !           463: /*
        !           464: **  SAMEWORD -- return TRUE if the words are the same
        !           465: **
        !           466: **     Ignores case.
        !           467: **
        !           468: **     Parameters:
        !           469: **             a, b -- the words to compare.
        !           470: **
        !           471: **     Returns:
        !           472: **             TRUE if a & b match exactly (modulo case)
        !           473: **             FALSE otherwise.
        !           474: **
        !           475: **     Side Effects:
        !           476: **             none.
        !           477: */
        !           478: 
        !           479: bool
        !           480: sameword(a, b)
        !           481:        register char *a, *b;
        !           482: {
        !           483:        char ca, cb;
        !           484: 
        !           485:        do
        !           486:        {
        !           487:                ca = *a++;
        !           488:                cb = *b++;
        !           489:                if (isascii(ca) && isupper(ca))
        !           490:                        ca = ca - 'A' + 'a';
        !           491:                if (isascii(cb) && isupper(cb))
        !           492:                        cb = cb - 'A' + 'a';
        !           493:        } while (ca != '\0' && ca == cb);
        !           494:        return (ca == cb);
        !           495: }

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