Return to err.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.lib / sendmail / src

Annotation of 43BSD/usr.lib/sendmail/src/err.c, revision 1.1

1.1     ! root        1: /*
        !             2: **  Sendmail
        !             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[] = "@(#)err.c   5.7 (Berkeley) 11/22/85";
        !            13: #endif not lint
        !            14: 
        !            15: # include "sendmail.h"
        !            16: # include <errno.h>
        !            17: # include <netdb.h>
        !            18: 
        !            19: /*
        !            20: **  SYSERR -- Print error message.
        !            21: **
        !            22: **     Prints an error message via printf to the diagnostic
        !            23: **     output.  If LOG is defined, it logs it also.
        !            24: **
        !            25: **     Parameters:
        !            26: **             f -- the format string
        !            27: **             a, b, c, d, e -- parameters
        !            28: **
        !            29: **     Returns:
        !            30: **             none
        !            31: **             Through TopFrame if QuickAbort is set.
        !            32: **
        !            33: **     Side Effects:
        !            34: **             increments Errors.
        !            35: **             sets ExitStat.
        !            36: */
        !            37: 
        !            38: # ifdef lint
        !            39: int    sys_nerr;
        !            40: char   *sys_errlist[];
        !            41: # endif lint
        !            42: char   MsgBuf[BUFSIZ*2];       /* text of most recent message */
        !            43: 
        !            44: /*VARARGS1*/
        !            45: syserr(fmt, a, b, c, d, e)
        !            46:        char *fmt;
        !            47: {
        !            48:        register char *p;
        !            49:        int olderrno = errno;
        !            50:        extern char Arpa_PSyserr[];
        !            51:        extern char Arpa_TSyserr[];
        !            52: 
        !            53:        /* format and output the error message */
        !            54:        if (olderrno == 0)
        !            55:                p = Arpa_PSyserr;
        !            56:        else
        !            57:                p = Arpa_TSyserr;
        !            58:        fmtmsg(MsgBuf, (char *) NULL, p, olderrno, fmt, a, b, c, d, e);
        !            59:        puterrmsg(MsgBuf);
        !            60: 
        !            61:        /* determine exit status if not already set */
        !            62:        if (ExitStat == EX_OK)
        !            63:        {
        !            64:                if (olderrno == 0)
        !            65:                        ExitStat = EX_SOFTWARE;
        !            66:                else
        !            67:                        ExitStat = EX_OSERR;
        !            68:        }
        !            69: 
        !            70: # ifdef LOG
        !            71:        if (LogLevel > 0)
        !            72:                syslog(LOG_CRIT, "%s: SYSERR: %s",
        !            73:                        CurEnv->e_id == NULL ? "NOQUEUE" : CurEnv->e_id,
        !            74:                        &MsgBuf[4]);
        !            75: # endif LOG
        !            76:        errno = 0;
        !            77:        if (QuickAbort)
        !            78:                longjmp(TopFrame, 2);
        !            79: }
        !            80: /*
        !            81: **  USRERR -- Signal user error.
        !            82: **
        !            83: **     This is much like syserr except it is for user errors.
        !            84: **
        !            85: **     Parameters:
        !            86: **             fmt, a, b, c, d -- printf strings
        !            87: **
        !            88: **     Returns:
        !            89: **             none
        !            90: **             Through TopFrame if QuickAbort is set.
        !            91: **
        !            92: **     Side Effects:
        !            93: **             increments Errors.
        !            94: */
        !            95: 
        !            96: /*VARARGS1*/
        !            97: usrerr(fmt, a, b, c, d, e)
        !            98:        char *fmt;
        !            99: {
        !           100:        extern char SuprErrs;
        !           101:        extern char Arpa_Usrerr[];
        !           102:        extern int errno;
        !           103: 
        !           104:        if (SuprErrs)
        !           105:                return;
        !           106: 
        !           107:        fmtmsg(MsgBuf, CurEnv->e_to, Arpa_Usrerr, errno, fmt, a, b, c, d, e);
        !           108:        puterrmsg(MsgBuf);
        !           109: 
        !           110:        if (QuickAbort)
        !           111:                longjmp(TopFrame, 1);
        !           112: }
        !           113: /*
        !           114: **  MESSAGE -- print message (not necessarily an error)
        !           115: **
        !           116: **     Parameters:
        !           117: **             num -- the default ARPANET error number (in ascii)
        !           118: **             msg -- the message (printf fmt) -- if it begins
        !           119: **                     with a digit, this number overrides num.
        !           120: **             a, b, c, d, e -- printf arguments
        !           121: **
        !           122: **     Returns:
        !           123: **             none
        !           124: **
        !           125: **     Side Effects:
        !           126: **             none.
        !           127: */
        !           128: 
        !           129: /*VARARGS2*/
        !           130: message(num, msg, a, b, c, d, e)
        !           131:        register char *num;
        !           132:        register char *msg;
        !           133: {
        !           134:        errno = 0;
        !           135:        fmtmsg(MsgBuf, CurEnv->e_to, num, 0, msg, a, b, c, d, e);
        !           136:        putmsg(MsgBuf, FALSE);
        !           137: }
        !           138: /*
        !           139: **  NMESSAGE -- print message (not necessarily an error)
        !           140: **
        !           141: **     Just like "message" except it never puts the to... tag on.
        !           142: **
        !           143: **     Parameters:
        !           144: **             num -- the default ARPANET error number (in ascii)
        !           145: **             msg -- the message (printf fmt) -- if it begins
        !           146: **                     with three digits, this number overrides num.
        !           147: **             a, b, c, d, e -- printf arguments
        !           148: **
        !           149: **     Returns:
        !           150: **             none
        !           151: **
        !           152: **     Side Effects:
        !           153: **             none.
        !           154: */
        !           155: 
        !           156: /*VARARGS2*/
        !           157: nmessage(num, msg, a, b, c, d, e)
        !           158:        register char *num;
        !           159:        register char *msg;
        !           160: {
        !           161:        errno = 0;
        !           162:        fmtmsg(MsgBuf, (char *) NULL, num, 0, msg, a, b, c, d, e);
        !           163:        putmsg(MsgBuf, FALSE);
        !           164: }
        !           165: /*
        !           166: **  PUTMSG -- output error message to transcript and channel
        !           167: **
        !           168: **     Parameters:
        !           169: **             msg -- message to output (in SMTP format).
        !           170: **             holdmsg -- if TRUE, don't output a copy of the message to
        !           171: **                     our output channel.
        !           172: **
        !           173: **     Returns:
        !           174: **             none.
        !           175: **
        !           176: **     Side Effects:
        !           177: **             Outputs msg to the transcript.
        !           178: **             If appropriate, outputs it to the channel.
        !           179: **             Deletes SMTP reply code number as appropriate.
        !           180: */
        !           181: 
        !           182: putmsg(msg, holdmsg)
        !           183:        char *msg;
        !           184:        bool holdmsg;
        !           185: {
        !           186:        /* output to transcript if serious */
        !           187:        if (CurEnv->e_xfp != NULL && (msg[0] == '4' || msg[0] == '5'))
        !           188:                fprintf(CurEnv->e_xfp, "%s\n", msg);
        !           189: 
        !           190:        /* output to channel if appropriate */
        !           191:        if (!holdmsg && (Verbose || msg[0] != '0'))
        !           192:        {
        !           193:                (void) fflush(stdout);
        !           194:                if (OpMode == MD_SMTP || OpMode == MD_ARPAFTP)
        !           195:                        fprintf(OutChannel, "%s\r\n", msg);
        !           196:                else
        !           197:                        fprintf(OutChannel, "%s\n", &msg[4]);
        !           198:                (void) fflush(OutChannel);
        !           199:        }
        !           200: }
        !           201: /*
        !           202: **  PUTERRMSG -- like putmsg, but does special processing for error messages
        !           203: **
        !           204: **     Parameters:
        !           205: **             msg -- the message to output.
        !           206: **
        !           207: **     Returns:
        !           208: **             none.
        !           209: **
        !           210: **     Side Effects:
        !           211: **             Sets the fatal error bit in the envelope as appropriate.
        !           212: */
        !           213: 
        !           214: puterrmsg(msg)
        !           215:        char *msg;
        !           216: {
        !           217:        /* output the message as usual */
        !           218:        putmsg(msg, HoldErrs);
        !           219: 
        !           220:        /* signal the error */
        !           221:        Errors++;
        !           222:        if (msg[0] == '5')
        !           223:                CurEnv->e_flags |= EF_FATALERRS;
        !           224: }
        !           225: /*
        !           226: **  FMTMSG -- format a message into buffer.
        !           227: **
        !           228: **     Parameters:
        !           229: **             eb -- error buffer to get result.
        !           230: **             to -- the recipient tag for this message.
        !           231: **             num -- arpanet error number.
        !           232: **             en -- the error number to display.
        !           233: **             fmt -- format of string.
        !           234: **             a, b, c, d, e -- arguments.
        !           235: **
        !           236: **     Returns:
        !           237: **             none.
        !           238: **
        !           239: **     Side Effects:
        !           240: **             none.
        !           241: */
        !           242: 
        !           243: /*VARARGS5*/
        !           244: static
        !           245: fmtmsg(eb, to, num, eno, fmt, a, b, c, d, e)
        !           246:        register char *eb;
        !           247:        char *to;
        !           248:        char *num;
        !           249:        int eno;
        !           250:        char *fmt;
        !           251: {
        !           252:        char del;
        !           253: 
        !           254:        /* output the reply code */
        !           255:        if (isdigit(fmt[0]) && isdigit(fmt[1]) && isdigit(fmt[2]))
        !           256:        {
        !           257:                num = fmt;
        !           258:                fmt += 4;
        !           259:        }
        !           260:        if (num[3] == '-')
        !           261:                del = '-';
        !           262:        else
        !           263:                del = ' ';
        !           264:        (void) sprintf(eb, "%3.3s%c", num, del);
        !           265:        eb += 4;
        !           266: 
        !           267:        /* output the file name and line number */
        !           268:        if (FileName != NULL)
        !           269:        {
        !           270:                (void) sprintf(eb, "%s: line %d: ", FileName, LineNumber);
        !           271:                eb += strlen(eb);
        !           272:        }
        !           273: 
        !           274:        /* output the "to" person */
        !           275:        if (to != NULL && to[0] != '\0')
        !           276:        {
        !           277:                (void) sprintf(eb, "%s... ", to);
        !           278:                while (*eb != '\0')
        !           279:                        *eb++ &= 0177;
        !           280:        }
        !           281: 
        !           282:        /* output the message */
        !           283:        (void) sprintf(eb, fmt, a, b, c, d, e);
        !           284:        while (*eb != '\0')
        !           285:                *eb++ &= 0177;
        !           286: 
        !           287:        /* output the error code, if any */
        !           288:        if (eno != 0)
        !           289:        {
        !           290:                extern char *errstring();
        !           291: 
        !           292:                (void) sprintf(eb, ": %s", errstring(eno));
        !           293:                eb += strlen(eb);
        !           294:        }
        !           295: }
        !           296: /*
        !           297: **  ERRSTRING -- return string description of error code
        !           298: **
        !           299: **     Parameters:
        !           300: **             errno -- the error number to translate
        !           301: **
        !           302: **     Returns:
        !           303: **             A string description of errno.
        !           304: **
        !           305: **     Side Effects:
        !           306: **             none.
        !           307: */
        !           308: 
        !           309: char *
        !           310: errstring(errno)
        !           311:        int errno;
        !           312: {
        !           313:        extern char *sys_errlist[];
        !           314:        extern int sys_nerr;
        !           315:        static char buf[100];
        !           316: # ifdef SMTP
        !           317:        extern char *SmtpPhase;
        !           318: # endif SMTP
        !           319: 
        !           320: # ifdef DAEMON
        !           321: # ifdef VMUNIX
        !           322:        /*
        !           323:        **  Handle special network error codes.
        !           324:        **
        !           325:        **      These are 4.2/4.3bsd specific; they should be in daemon.c.
        !           326:        */
        !           327: 
        !           328:        switch (errno)
        !           329:        {
        !           330:          case ETIMEDOUT:
        !           331:          case ECONNRESET:
        !           332:                (void) strcpy(buf, sys_errlist[errno]);
        !           333:                if (SmtpPhase != NULL)
        !           334:                {
        !           335:                        (void) strcat(buf, " during ");
        !           336:                        (void) strcat(buf, SmtpPhase);
        !           337:                }
        !           338:                if (CurHostName != NULL)
        !           339:                {
        !           340:                        (void) strcat(buf, " with ");
        !           341:                        (void) strcat(buf, CurHostName);
        !           342:                }
        !           343:                return (buf);
        !           344: 
        !           345:          case EHOSTDOWN:
        !           346:                if (CurHostName == NULL)
        !           347:                        break;
        !           348:                (void) sprintf(buf, "Host %s is down", CurHostName);
        !           349:                return (buf);
        !           350: 
        !           351:          case ECONNREFUSED:
        !           352:                if (CurHostName == NULL)
        !           353:                        break;
        !           354:                (void) sprintf(buf, "Connection refused by %s", CurHostName);
        !           355:                return (buf);
        !           356: 
        !           357:          case (TRY_AGAIN+MAX_ERRNO):
        !           358:                (void) sprintf(buf, "Host Name Lookup Failure");
        !           359:                return (buf);
        !           360:        }
        !           361: # endif VMUNIX
        !           362: # endif DAEMON
        !           363: 
        !           364:        if (errno > 0 && errno < sys_nerr)
        !           365:                return (sys_errlist[errno]);
        !           366: 
        !           367:        (void) sprintf(buf, "Error %d", errno);
        !           368:        return (buf);
        !           369: }

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