1N/A/*
1N/A * Copyright (c) 1998-2003, 2006 Sendmail, Inc. and its suppliers.
1N/A * All rights reserved.
1N/A * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
1N/A * Copyright (c) 1988, 1993
1N/A * The Regents of the University of California. All rights reserved.
1N/A *
1N/A * By using this file, you agree to the terms and conditions set
1N/A * forth in the LICENSE file which can be found at the top level of
1N/A * the sendmail distribution.
1N/A *
1N/A */
1N/A
1N/A#include <sendmail.h>
1N/A
1N/ASM_RCSID("@(#)$Id: envelope.c,v 8.310 2009/12/18 17:08:01 ca Exp $")
1N/A
1N/A/*
1N/A** CLRSESSENVELOPE -- clear session oriented data in an envelope
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope to clear.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A*/
1N/A
1N/Avoid
1N/Aclrsessenvelope(e)
1N/A ENVELOPE *e;
1N/A{
1N/A#if SASL
1N/A macdefine(&e->e_macro, A_PERM, macid("{auth_type}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{auth_authen}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{auth_author}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{auth_ssf}"), "");
1N/A#endif /* SASL */
1N/A#if STARTTLS
1N/A macdefine(&e->e_macro, A_PERM, macid("{cert_issuer}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{cert_subject}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{cipher_bits}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{cipher}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{tls_version}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{verify}"), "");
1N/A# if _FFR_TLS_1
1N/A macdefine(&e->e_macro, A_PERM, macid("{alg_bits}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{cn_issuer}"), "");
1N/A macdefine(&e->e_macro, A_PERM, macid("{cn_subject}"), "");
1N/A# endif /* _FFR_TLS_1 */
1N/A#endif /* STARTTLS */
1N/A}
1N/A
1N/A/*
1N/A** NEWENVELOPE -- fill in a new envelope
1N/A**
1N/A** Supports inheritance.
1N/A**
1N/A** Parameters:
1N/A** e -- the new envelope to fill in.
1N/A** parent -- the envelope to be the parent of e.
1N/A** rpool -- either NULL, or a pointer to a resource pool
1N/A** from which envelope memory is allocated, and
1N/A** to which envelope resources are attached.
1N/A**
1N/A** Returns:
1N/A** e.
1N/A**
1N/A** Side Effects:
1N/A** none.
1N/A*/
1N/A
1N/AENVELOPE *
1N/Anewenvelope(e, parent, rpool)
1N/A register ENVELOPE *e;
1N/A register ENVELOPE *parent;
1N/A SM_RPOOL_T *rpool;
1N/A{
1N/A int sendmode;
1N/A
1N/A /*
1N/A ** This code used to read:
1N/A ** if (e == parent && e->e_parent != NULL)
1N/A ** parent = e->e_parent;
1N/A ** So if e == parent && e->e_parent == NULL then we would
1N/A ** set e->e_parent = e, which creates a loop in the e_parent chain.
1N/A ** This meant macvalue() could go into an infinite loop.
1N/A */
1N/A
1N/A if (parent != NULL)
1N/A sendmode = parent->e_sendmode;
1N/A else
1N/A sendmode = DM_NOTSET;
1N/A
1N/A if (e == parent)
1N/A parent = e->e_parent;
1N/A clearenvelope(e, true, rpool);
1N/A if (e == CurEnv)
1N/A memmove((char *) &e->e_from,
1N/A (char *) &NullAddress,
1N/A sizeof(e->e_from));
1N/A else
1N/A memmove((char *) &e->e_from,
1N/A (char *) &CurEnv->e_from,
1N/A sizeof(e->e_from));
1N/A e->e_parent = parent;
1N/A assign_queueid(e);
1N/A e->e_ctime = curtime();
1N/A#if _FFR_SESSID
1N/A e->e_sessid = e->e_id;
1N/A#endif /* _FFR_SESSID */
1N/A if (parent != NULL)
1N/A {
1N/A e->e_msgpriority = parent->e_msgsize;
1N/A#if _FFR_SESSID
1N/A if (parent->e_sessid != NULL)
1N/A e->e_sessid = sm_rpool_strdup_x(rpool,
1N/A parent->e_sessid);
1N/A#endif /* _FFR_SESSID */
1N/A
1N/A if (parent->e_quarmsg == NULL)
1N/A {
1N/A e->e_quarmsg = NULL;
1N/A macdefine(&e->e_macro, A_PERM,
1N/A macid("{quarantine}"), "");
1N/A }
1N/A else
1N/A {
1N/A e->e_quarmsg = sm_rpool_strdup_x(rpool,
1N/A parent->e_quarmsg);
1N/A macdefine(&e->e_macro, A_PERM,
1N/A macid("{quarantine}"), e->e_quarmsg);
1N/A }
1N/A }
1N/A e->e_puthdr = putheader;
1N/A e->e_putbody = putbody;
1N/A if (CurEnv->e_xfp != NULL)
1N/A (void) sm_io_flush(CurEnv->e_xfp, SM_TIME_DEFAULT);
1N/A if (sendmode != DM_NOTSET)
1N/A set_delivery_mode(sendmode, e);
1N/A
1N/A return e;
1N/A}
1N/A
1N/A/* values for msg_timeout, see also IS_* below for usage (bit layout) */
1N/A#define MSG_T_O 0x01 /* normal timeout */
1N/A#define MSG_T_O_NOW 0x02 /* NOW timeout */
1N/A#define MSG_NOT_BY 0x04 /* Deliver-By time exceeded, mode R */
1N/A#define MSG_WARN 0x10 /* normal queue warning */
1N/A#define MSG_WARN_BY 0x20 /* Deliver-By time exceeded, mode N */
1N/A
1N/A#define IS_MSG_ERR(x) (((x) & 0x0f) != 0) /* return an error */
1N/A
1N/A/* immediate return */
1N/A#define IS_IMM_RET(x) (((x) & (MSG_T_O_NOW|MSG_NOT_BY)) != 0)
1N/A#define IS_MSG_WARN(x) (((x) & 0xf0) != 0) /* return a warning */
1N/A
1N/A/*
1N/A** DROPENVELOPE -- deallocate an envelope.
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope to deallocate.
1N/A** fulldrop -- if set, do return receipts.
1N/A** split -- if true, split by recipient if message is queued up
1N/A**
1N/A** Returns:
1N/A** EX_* status (currently: 0: success, EX_IOERR on panic)
1N/A**
1N/A** Side Effects:
1N/A** housekeeping necessary to dispose of an envelope.
1N/A** Unlocks this queue file.
1N/A*/
1N/A
1N/Aint
1N/Adropenvelope(e, fulldrop, split)
1N/A register ENVELOPE *e;
1N/A bool fulldrop;
1N/A bool split;
1N/A{
1N/A bool panic = false;
1N/A bool queueit = false;
1N/A int msg_timeout = 0;
1N/A bool failure_return = false;
1N/A bool delay_return = false;
1N/A bool success_return = false;
1N/A bool pmnotify = bitset(EF_PM_NOTIFY, e->e_flags);
1N/A bool done = false;
1N/A register ADDRESS *q;
1N/A char *id = e->e_id;
1N/A time_t now;
1N/A char buf[MAXLINE];
1N/A
1N/A if (tTd(50, 1))
1N/A {
1N/A sm_dprintf("dropenvelope %p: id=", e);
1N/A xputs(sm_debug_file(), e->e_id);
1N/A sm_dprintf(", flags=");
1N/A printenvflags(e);
1N/A if (tTd(50, 10))
1N/A {
1N/A sm_dprintf("sendq=");
1N/A printaddr(sm_debug_file(), e->e_sendqueue, true);
1N/A }
1N/A }
1N/A
1N/A if (LogLevel > 84)
1N/A sm_syslog(LOG_DEBUG, id,
1N/A "dropenvelope, e_flags=0x%lx, OpMode=%c, pid=%d",
1N/A e->e_flags, OpMode, (int) CurrentPid);
1N/A
1N/A /* we must have an id to remove disk files */
1N/A if (id == NULL)
1N/A return EX_OK;
1N/A
1N/A /* if verify-only mode, we can skip most of this */
1N/A if (OpMode == MD_VERIFY)
1N/A goto simpledrop;
1N/A
1N/A if (tTd(92, 2))
1N/A sm_dprintf("dropenvelope: e_id=%s, EF_LOGSENDER=%d, LogLevel=%d\n",
1N/A e->e_id, bitset(EF_LOGSENDER, e->e_flags), LogLevel);
1N/A if (LogLevel > 4 && bitset(EF_LOGSENDER, e->e_flags))
1N/A logsender(e, NULL);
1N/A e->e_flags &= ~EF_LOGSENDER;
1N/A
1N/A /* post statistics */
1N/A poststats(StatFile);
1N/A
1N/A /*
1N/A ** Extract state information from dregs of send list.
1N/A */
1N/A
1N/A now = curtime();
1N/A if (now >= e->e_ctime + TimeOuts.to_q_return[e->e_timeoutclass])
1N/A msg_timeout = MSG_T_O;
1N/A if (IS_DLVR_RETURN(e) && e->e_deliver_by > 0 &&
1N/A now >= e->e_ctime + e->e_deliver_by &&
1N/A !bitset(EF_RESPONSE, e->e_flags))
1N/A {
1N/A msg_timeout = MSG_NOT_BY;
1N/A e->e_flags |= EF_FATALERRS|EF_CLRQUEUE;
1N/A }
1N/A else if (TimeOuts.to_q_return[e->e_timeoutclass] == NOW &&
1N/A !bitset(EF_RESPONSE, e->e_flags))
1N/A {
1N/A msg_timeout = MSG_T_O_NOW;
1N/A e->e_flags |= EF_FATALERRS|EF_CLRQUEUE;
1N/A }
1N/A
1N/A e->e_flags &= ~EF_QUEUERUN;
1N/A for (q = e->e_sendqueue; q != NULL; q = q->q_next)
1N/A {
1N/A if (QS_IS_UNDELIVERED(q->q_state))
1N/A queueit = true;
1N/A
1N/A /* see if a notification is needed */
1N/A if (bitset(QPINGONFAILURE, q->q_flags) &&
1N/A ((IS_MSG_ERR(msg_timeout) &&
1N/A QS_IS_UNDELIVERED(q->q_state)) ||
1N/A QS_IS_BADADDR(q->q_state) ||
1N/A IS_IMM_RET(msg_timeout)))
1N/A {
1N/A failure_return = true;
1N/A if (!done && q->q_owner == NULL &&
1N/A !emptyaddr(&e->e_from))
1N/A {
1N/A (void) sendtolist(e->e_from.q_paddr, NULLADDR,
1N/A &e->e_errorqueue, 0, e);
1N/A done = true;
1N/A }
1N/A }
1N/A else if ((bitset(QPINGONSUCCESS, q->q_flags) &&
1N/A ((QS_IS_SENT(q->q_state) &&
1N/A bitnset(M_LOCALMAILER, q->q_mailer->m_flags)) ||
1N/A bitset(QRELAYED|QEXPANDED|QDELIVERED, q->q_flags))) ||
1N/A bitset(QBYTRACE, q->q_flags) ||
1N/A bitset(QBYNRELAY, q->q_flags))
1N/A {
1N/A success_return = true;
1N/A }
1N/A }
1N/A
1N/A if (e->e_class < 0)
1N/A e->e_flags |= EF_NO_BODY_RETN;
1N/A
1N/A /*
1N/A ** See if the message timed out.
1N/A */
1N/A
1N/A if (!queueit)
1N/A /* EMPTY */
1N/A /* nothing to do */ ;
1N/A else if (IS_MSG_ERR(msg_timeout))
1N/A {
1N/A if (failure_return)
1N/A {
1N/A if (msg_timeout == MSG_NOT_BY)
1N/A {
1N/A (void) sm_snprintf(buf, sizeof(buf),
1N/A "delivery time expired %lds",
1N/A e->e_deliver_by);
1N/A }
1N/A else
1N/A {
1N/A (void) sm_snprintf(buf, sizeof(buf),
1N/A "Cannot send message for %s",
1N/A pintvl(TimeOuts.to_q_return[e->e_timeoutclass],
1N/A false));
1N/A }
1N/A
1N/A /* don't free, allocated from e_rpool */
1N/A e->e_message = sm_rpool_strdup_x(e->e_rpool, buf);
1N/A message(buf);
1N/A e->e_flags |= EF_CLRQUEUE;
1N/A }
1N/A if (msg_timeout == MSG_NOT_BY)
1N/A {
1N/A (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
1N/A "Delivery time (%lds) expired\n",
1N/A e->e_deliver_by);
1N/A }
1N/A else
1N/A (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
1N/A "Message could not be delivered for %s\n",
1N/A pintvl(TimeOuts.to_q_return[e->e_timeoutclass],
1N/A false));
1N/A (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
1N/A "Message will be deleted from queue\n");
1N/A for (q = e->e_sendqueue; q != NULL; q = q->q_next)
1N/A {
1N/A if (QS_IS_UNDELIVERED(q->q_state))
1N/A {
1N/A q->q_state = QS_BADADDR;
1N/A if (msg_timeout == MSG_NOT_BY)
1N/A q->q_status = "5.4.7";
1N/A else
1N/A q->q_status = "4.4.7";
1N/A }
1N/A }
1N/A }
1N/A else
1N/A {
1N/A if (TimeOuts.to_q_warning[e->e_timeoutclass] > 0 &&
1N/A now >= e->e_ctime +
1N/A TimeOuts.to_q_warning[e->e_timeoutclass])
1N/A msg_timeout = MSG_WARN;
1N/A else if (IS_DLVR_NOTIFY(e) &&
1N/A e->e_deliver_by > 0 &&
1N/A now >= e->e_ctime + e->e_deliver_by)
1N/A msg_timeout = MSG_WARN_BY;
1N/A
1N/A if (IS_MSG_WARN(msg_timeout))
1N/A {
1N/A if (!bitset(EF_WARNING|EF_RESPONSE, e->e_flags) &&
1N/A e->e_class >= 0 &&
1N/A e->e_from.q_paddr != NULL &&
1N/A strcmp(e->e_from.q_paddr, "<>") != 0 &&
1N/A sm_strncasecmp(e->e_from.q_paddr, "owner-", 6) != 0 &&
1N/A (strlen(e->e_from.q_paddr) <= 8 ||
1N/A sm_strcasecmp(&e->e_from.q_paddr[strlen(e->e_from.q_paddr) - 8],
1N/A "-request") != 0))
1N/A {
1N/A for (q = e->e_sendqueue; q != NULL;
1N/A q = q->q_next)
1N/A {
1N/A if (QS_IS_UNDELIVERED(q->q_state)
1N/A#if _FFR_NODELAYDSN_ON_HOLD
1N/A && !bitnset(M_HOLD,
1N/A q->q_mailer->m_flags)
1N/A#endif /* _FFR_NODELAYDSN_ON_HOLD */
1N/A )
1N/A {
1N/A if (msg_timeout ==
1N/A MSG_WARN_BY &&
1N/A (bitset(QPINGONDELAY,
1N/A q->q_flags) ||
1N/A !bitset(QHASNOTIFY,
1N/A q->q_flags))
1N/A )
1N/A {
1N/A q->q_flags |= QBYNDELAY;
1N/A delay_return = true;
1N/A }
1N/A if (bitset(QPINGONDELAY,
1N/A q->q_flags))
1N/A {
1N/A q->q_flags |= QDELAYED;
1N/A delay_return = true;
1N/A }
1N/A }
1N/A }
1N/A }
1N/A if (delay_return)
1N/A {
1N/A if (msg_timeout == MSG_WARN_BY)
1N/A {
1N/A (void) sm_snprintf(buf, sizeof(buf),
1N/A "Warning: Delivery time (%lds) exceeded",
1N/A e->e_deliver_by);
1N/A }
1N/A else
1N/A (void) sm_snprintf(buf, sizeof(buf),
1N/A "Warning: could not send message for past %s",
1N/A pintvl(TimeOuts.to_q_warning[e->e_timeoutclass],
1N/A false));
1N/A
1N/A /* don't free, allocated from e_rpool */
1N/A e->e_message = sm_rpool_strdup_x(e->e_rpool,
1N/A buf);
1N/A message(buf);
1N/A e->e_flags |= EF_WARNING;
1N/A }
1N/A if (msg_timeout == MSG_WARN_BY)
1N/A {
1N/A (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
1N/A "Warning: Delivery time (%lds) exceeded\n",
1N/A e->e_deliver_by);
1N/A }
1N/A else
1N/A (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
1N/A "Warning: message still undelivered after %s\n",
1N/A pintvl(TimeOuts.to_q_warning[e->e_timeoutclass],
1N/A false));
1N/A (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
1N/A "Will keep trying until message is %s old\n",
1N/A pintvl(TimeOuts.to_q_return[e->e_timeoutclass],
1N/A false));
1N/A }
1N/A }
1N/A
1N/A if (tTd(50, 2))
1N/A sm_dprintf("failure_return=%d delay_return=%d success_return=%d queueit=%d\n",
1N/A failure_return, delay_return, success_return, queueit);
1N/A
1N/A /*
1N/A ** If we had some fatal error, but no addresses are marked as
1N/A ** bad, mark them _all_ as bad.
1N/A */
1N/A
1N/A if (bitset(EF_FATALERRS, e->e_flags) && !failure_return)
1N/A {
1N/A for (q = e->e_sendqueue; q != NULL; q = q->q_next)
1N/A {
1N/A if ((QS_IS_OK(q->q_state) ||
1N/A QS_IS_VERIFIED(q->q_state)) &&
1N/A bitset(QPINGONFAILURE, q->q_flags))
1N/A {
1N/A failure_return = true;
1N/A q->q_state = QS_BADADDR;
1N/A }
1N/A }
1N/A }
1N/A
1N/A /*
1N/A ** Send back return receipts as requested.
1N/A */
1N/A
1N/A if (success_return && !failure_return && !delay_return && fulldrop &&
1N/A !bitset(PRIV_NORECEIPTS, PrivacyFlags) &&
1N/A strcmp(e->e_from.q_paddr, "<>") != 0)
1N/A {
1N/A auto ADDRESS *rlist = NULL;
1N/A
1N/A if (tTd(50, 8))
1N/A sm_dprintf("dropenvelope(%s): sending return receipt\n",
1N/A id);
1N/A e->e_flags |= EF_SENDRECEIPT;
1N/A (void) sendtolist(e->e_from.q_paddr, NULLADDR, &rlist, 0, e);
1N/A (void) returntosender("Return receipt", rlist, RTSF_NO_BODY, e);
1N/A }
1N/A e->e_flags &= ~EF_SENDRECEIPT;
1N/A
1N/A /*
1N/A ** Arrange to send error messages if there are fatal errors.
1N/A */
1N/A
1N/A if ((failure_return || delay_return) && e->e_errormode != EM_QUIET)
1N/A {
1N/A if (tTd(50, 8))
1N/A sm_dprintf("dropenvelope(%s): saving mail\n", id);
1N/A panic = savemail(e, !bitset(EF_NO_BODY_RETN, e->e_flags));
1N/A }
1N/A
1N/A /*
1N/A ** Arrange to send warning messages to postmaster as requested.
1N/A */
1N/A
1N/A if ((failure_return || pmnotify) &&
1N/A PostMasterCopy != NULL &&
1N/A !bitset(EF_RESPONSE, e->e_flags) &&
1N/A e->e_class >= 0)
1N/A {
1N/A auto ADDRESS *rlist = NULL;
1N/A char pcopy[MAXNAME];
1N/A
1N/A if (failure_return)
1N/A {
1N/A expand(PostMasterCopy, pcopy, sizeof(pcopy), e);
1N/A
1N/A if (tTd(50, 8))
1N/A sm_dprintf("dropenvelope(%s): sending postmaster copy to %s\n",
1N/A id, pcopy);
1N/A (void) sendtolist(pcopy, NULLADDR, &rlist, 0, e);
1N/A }
1N/A if (pmnotify)
1N/A (void) sendtolist("postmaster", NULLADDR,
1N/A &rlist, 0, e);
1N/A (void) returntosender(e->e_message, rlist,
1N/A RTSF_PM_BOUNCE|RTSF_NO_BODY, e);
1N/A }
1N/A
1N/A /*
1N/A ** Instantiate or deinstantiate the queue.
1N/A */
1N/A
1N/Asimpledrop:
1N/A if (tTd(50, 8))
1N/A sm_dprintf("dropenvelope(%s): at simpledrop, queueit=%d\n",
1N/A id, queueit);
1N/A if (!queueit || bitset(EF_CLRQUEUE, e->e_flags))
1N/A {
1N/A if (tTd(50, 1))
1N/A {
1N/A sm_dprintf("\n===== Dropping queue files for %s... queueit=%d, e_flags=",
1N/A e->e_id, queueit);
1N/A printenvflags(e);
1N/A }
1N/A if (!panic)
1N/A {
1N/A if (e->e_dfp != NULL)
1N/A {
1N/A (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1N/A e->e_dfp = NULL;
1N/A }
1N/A (void) xunlink(queuename(e, DATAFL_LETTER));
1N/A }
1N/A if (panic && QueueMode == QM_LOST)
1N/A {
1N/A /*
1N/A ** leave the Qf file behind as
1N/A ** the delivery attempt failed.
1N/A */
1N/A
1N/A /* EMPTY */
1N/A }
1N/A else
1N/A if (xunlink(queuename(e, ANYQFL_LETTER)) == 0)
1N/A {
1N/A /* add to available space in filesystem */
1N/A updfs(e, -1, panic ? 0 : -1, "dropenvelope");
1N/A }
1N/A
1N/A if (e->e_ntries > 0 && LogLevel > 9)
1N/A sm_syslog(LOG_INFO, id, "done; delay=%s, ntries=%d",
1N/A pintvl(curtime() - e->e_ctime, true),
1N/A e->e_ntries);
1N/A }
1N/A else if (queueit || !bitset(EF_INQUEUE, e->e_flags))
1N/A {
1N/A if (!split)
1N/A queueup(e, false, true);
1N/A else
1N/A {
1N/A ENVELOPE *oldsib;
1N/A ENVELOPE *ee;
1N/A
1N/A /*
1N/A ** Save old sibling and set it to NULL to avoid
1N/A ** queueing up the same envelopes again.
1N/A ** This requires that envelopes in that list have
1N/A ** been take care of before (or at some other place).
1N/A */
1N/A
1N/A oldsib = e->e_sibling;
1N/A e->e_sibling = NULL;
1N/A if (!split_by_recipient(e) &&
1N/A bitset(EF_FATALERRS, e->e_flags))
1N/A {
1N/A syserr("!dropenvelope(%s): cannot commit data file %s, uid=%d",
1N/A e->e_id, queuename(e, DATAFL_LETTER),
1N/A (int) geteuid());
1N/A }
1N/A for (ee = e->e_sibling; ee != NULL; ee = ee->e_sibling)
1N/A queueup(ee, false, true);
1N/A queueup(e, false, true);
1N/A
1N/A /* clean up */
1N/A for (ee = e->e_sibling; ee != NULL; ee = ee->e_sibling)
1N/A {
1N/A /* now unlock the job */
1N/A if (tTd(50, 8))
1N/A sm_dprintf("dropenvelope(%s): unlocking job\n",
1N/A ee->e_id);
1N/A closexscript(ee);
1N/A unlockqueue(ee);
1N/A
1N/A /* this envelope is marked unused */
1N/A if (ee->e_dfp != NULL)
1N/A {
1N/A (void) sm_io_close(ee->e_dfp,
1N/A SM_TIME_DEFAULT);
1N/A ee->e_dfp = NULL;
1N/A }
1N/A ee->e_id = NULL;
1N/A ee->e_flags &= ~EF_HAS_DF;
1N/A }
1N/A e->e_sibling = oldsib;
1N/A }
1N/A }
1N/A
1N/A /* now unlock the job */
1N/A if (tTd(50, 8))
1N/A sm_dprintf("dropenvelope(%s): unlocking job\n", id);
1N/A closexscript(e);
1N/A unlockqueue(e);
1N/A
1N/A /* make sure that this envelope is marked unused */
1N/A if (e->e_dfp != NULL)
1N/A {
1N/A (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1N/A e->e_dfp = NULL;
1N/A }
1N/A e->e_id = NULL;
1N/A e->e_flags &= ~EF_HAS_DF;
1N/A if (panic)
1N/A return EX_IOERR;
1N/A return EX_OK;
1N/A}
1N/A
1N/A/*
1N/A** CLEARENVELOPE -- clear an envelope without unlocking
1N/A**
1N/A** This is normally used by a child process to get a clean
1N/A** envelope without disturbing the parent.
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope to clear.
1N/A** fullclear - if set, the current envelope is total
1N/A** garbage and should be ignored; otherwise,
1N/A** release any resources it may indicate.
1N/A** rpool -- either NULL, or a pointer to a resource pool
1N/A** from which envelope memory is allocated, and
1N/A** to which envelope resources are attached.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A**
1N/A** Side Effects:
1N/A** Closes files associated with the envelope.
1N/A** Marks the envelope as unallocated.
1N/A*/
1N/A
1N/Avoid
1N/Aclearenvelope(e, fullclear, rpool)
1N/A register ENVELOPE *e;
1N/A bool fullclear;
1N/A SM_RPOOL_T *rpool;
1N/A{
1N/A register HDR *bh;
1N/A register HDR **nhp;
1N/A extern ENVELOPE BlankEnvelope;
1N/A char **p;
1N/A
1N/A if (!fullclear)
1N/A {
1N/A /* clear out any file information */
1N/A if (e->e_xfp != NULL)
1N/A (void) sm_io_close(e->e_xfp, SM_TIME_DEFAULT);
1N/A if (e->e_dfp != NULL)
1N/A (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
1N/A e->e_xfp = e->e_dfp = NULL;
1N/A }
1N/A
1N/A /*
1N/A ** Copy BlankEnvelope into *e.
1N/A ** It is not safe to simply copy pointers to strings;
1N/A ** the strings themselves must be copied (or set to NULL).
1N/A ** The problem is that when we assign a new string value to
1N/A ** a member of BlankEnvelope, we free the old string.
1N/A ** We did not need to do this copying in sendmail 8.11 :-(
1N/A ** and it is a potential performance hit. Reference counted
1N/A ** strings are one way out.
1N/A */
1N/A
1N/A *e = BlankEnvelope;
1N/A e->e_message = NULL;
1N/A e->e_qfletter = '\0';
1N/A e->e_quarmsg = NULL;
1N/A macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), "");
1N/A
1N/A /*
1N/A ** Copy the macro table.
1N/A ** We might be able to avoid this by zeroing the macro table
1N/A ** and always searching BlankEnvelope.e_macro after e->e_macro
1N/A ** in macvalue().
1N/A */
1N/A
1N/A for (p = &e->e_macro.mac_table[0];
1N/A p <= &e->e_macro.mac_table[MAXMACROID];
1N/A ++p)
1N/A {
1N/A if (*p != NULL)
1N/A *p = sm_rpool_strdup_x(rpool, *p);
1N/A }
1N/A
1N/A /*
1N/A ** XXX There are many strings in the envelope structure
1N/A ** XXX that we are not attempting to copy here.
1N/A ** XXX Investigate this further.
1N/A */
1N/A
1N/A e->e_rpool = rpool;
1N/A e->e_macro.mac_rpool = rpool;
1N/A if (Verbose)
1N/A set_delivery_mode(SM_DELIVER, e);
1N/A bh = BlankEnvelope.e_header;
1N/A nhp = &e->e_header;
1N/A while (bh != NULL)
1N/A {
1N/A *nhp = (HDR *) sm_rpool_malloc_x(rpool, sizeof(*bh));
1N/A memmove((char *) *nhp, (char *) bh, sizeof(*bh));
1N/A bh = bh->h_link;
1N/A nhp = &(*nhp)->h_link;
1N/A }
1N/A#if _FFR_MILTER_ENHSC
1N/A e->e_enhsc[0] = '\0';
1N/A#endif /* _FFR_MILTER_ENHSC */
1N/A}
1N/A/*
1N/A** INITSYS -- initialize instantiation of system
1N/A**
1N/A** In Daemon mode, this is done in the child.
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope to use.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A**
1N/A** Side Effects:
1N/A** Initializes the system macros, some global variables,
1N/A** etc. In particular, the current time in various
1N/A** forms is set.
1N/A*/
1N/A
1N/Avoid
1N/Ainitsys(e)
1N/A register ENVELOPE *e;
1N/A{
1N/A char buf[10];
1N/A#ifdef TTYNAME
1N/A static char ybuf[60]; /* holds tty id */
1N/A register char *p;
1N/A extern char *ttyname();
1N/A#endif /* TTYNAME */
1N/A
1N/A /*
1N/A ** Give this envelope a reality.
1N/A ** I.e., an id, a transcript, and a creation time.
1N/A ** We don't select the queue until all of the recipients are known.
1N/A */
1N/A
1N/A openxscript(e);
1N/A e->e_ctime = curtime();
1N/A e->e_qfletter = '\0';
1N/A
1N/A /*
1N/A ** Set OutChannel to something useful if stdout isn't it.
1N/A ** This arranges that any extra stuff the mailer produces
1N/A ** gets sent back to the user on error (because it is
1N/A ** tucked away in the transcript).
1N/A */
1N/A
1N/A if (OpMode == MD_DAEMON && bitset(EF_QUEUERUN, e->e_flags) &&
1N/A e->e_xfp != NULL)
1N/A OutChannel = e->e_xfp;
1N/A
1N/A /*
1N/A ** Set up some basic system macros.
1N/A */
1N/A
1N/A /* process id */
1N/A (void) sm_snprintf(buf, sizeof(buf), "%d", (int) CurrentPid);
1N/A macdefine(&e->e_macro, A_TEMP, 'p', buf);
1N/A
1N/A /* hop count */
1N/A (void) sm_snprintf(buf, sizeof(buf), "%d", e->e_hopcount);
1N/A macdefine(&e->e_macro, A_TEMP, 'c', buf);
1N/A
1N/A /* time as integer, unix time, arpa time */
1N/A settime(e);
1N/A
1N/A /* Load average */
1N/A sm_getla();
1N/A
1N/A#ifdef TTYNAME
1N/A /* tty name */
1N/A if (macvalue('y', e) == NULL)
1N/A {
1N/A p = ttyname(2);
1N/A if (p != NULL)
1N/A {
1N/A if (strrchr(p, '/') != NULL)
1N/A p = strrchr(p, '/') + 1;
1N/A (void) sm_strlcpy(ybuf, sizeof(ybuf), p);
1N/A macdefine(&e->e_macro, A_PERM, 'y', ybuf);
1N/A }
1N/A }
1N/A#endif /* TTYNAME */
1N/A}
1N/A/*
1N/A** SETTIME -- set the current time.
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope in which the macros should be set.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A**
1N/A** Side Effects:
1N/A** Sets the various time macros -- $a, $b, $d, $t.
1N/A*/
1N/A
1N/Avoid
1N/Asettime(e)
1N/A register ENVELOPE *e;
1N/A{
1N/A register char *p;
1N/A auto time_t now;
1N/A char buf[30];
1N/A register struct tm *tm;
1N/A
1N/A now = curtime();
1N/A (void) sm_snprintf(buf, sizeof(buf), "%ld", (long) now);
1N/A macdefine(&e->e_macro, A_TEMP, macid("{time}"), buf);
1N/A tm = gmtime(&now);
1N/A (void) sm_snprintf(buf, sizeof(buf), "%04d%02d%02d%02d%02d",
1N/A tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1N/A tm->tm_hour, tm->tm_min);
1N/A macdefine(&e->e_macro, A_TEMP, 't', buf);
1N/A (void) sm_strlcpy(buf, ctime(&now), sizeof(buf));
1N/A p = strchr(buf, '\n');
1N/A if (p != NULL)
1N/A *p = '\0';
1N/A macdefine(&e->e_macro, A_TEMP, 'd', buf);
1N/A macdefine(&e->e_macro, A_TEMP, 'b', arpadate(buf));
1N/A if (macvalue('a', e) == NULL)
1N/A macdefine(&e->e_macro, A_PERM, 'a', macvalue('b', e));
1N/A}
1N/A/*
1N/A** OPENXSCRIPT -- Open transcript file
1N/A**
1N/A** Creates a transcript file for possible eventual mailing or
1N/A** sending back.
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope to create the transcript in/for.
1N/A**
1N/A** Returns:
1N/A** none
1N/A**
1N/A** Side Effects:
1N/A** Creates the transcript file.
1N/A*/
1N/A
1N/A#ifndef O_APPEND
1N/A# define O_APPEND 0
1N/A#endif /* ! O_APPEND */
1N/A
1N/Avoid
1N/Aopenxscript(e)
1N/A register ENVELOPE *e;
1N/A{
1N/A register char *p;
1N/A
1N/A if (e->e_xfp != NULL)
1N/A return;
1N/A
1N/A#if 0
1N/A if (e->e_lockfp == NULL && bitset(EF_INQUEUE, e->e_flags))
1N/A syserr("openxscript: job not locked");
1N/A#endif /* 0 */
1N/A
1N/A p = queuename(e, XSCRPT_LETTER);
1N/A e->e_xfp = bfopen(p, FileMode, XscriptFileBufferSize,
1N/A SFF_NOTEXCL|SFF_OPENASROOT);
1N/A
1N/A if (e->e_xfp == NULL)
1N/A {
1N/A syserr("Can't create transcript file %s", p);
1N/A e->e_xfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT,
1N/A SM_PATH_DEVNULL, SM_IO_RDWR, NULL);
1N/A if (e->e_xfp == NULL)
1N/A syserr("!Can't open %s", SM_PATH_DEVNULL);
1N/A }
1N/A (void) sm_io_setvbuf(e->e_xfp, SM_TIME_DEFAULT, NULL, SM_IO_LBF, 0);
1N/A if (tTd(46, 9))
1N/A {
1N/A sm_dprintf("openxscript(%s):\n ", p);
1N/A dumpfd(sm_io_getinfo(e->e_xfp, SM_IO_WHAT_FD, NULL), true,
1N/A false);
1N/A }
1N/A}
1N/A/*
1N/A** CLOSEXSCRIPT -- close the transcript file.
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope containing the transcript to close.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A**
1N/A** Side Effects:
1N/A** none.
1N/A*/
1N/A
1N/Avoid
1N/Aclosexscript(e)
1N/A register ENVELOPE *e;
1N/A{
1N/A if (e->e_xfp == NULL)
1N/A return;
1N/A#if 0
1N/A if (e->e_lockfp == NULL)
1N/A syserr("closexscript: job not locked");
1N/A#endif /* 0 */
1N/A (void) sm_io_close(e->e_xfp, SM_TIME_DEFAULT);
1N/A e->e_xfp = NULL;
1N/A}
1N/A/*
1N/A** SETSENDER -- set the person who this message is from
1N/A**
1N/A** Under certain circumstances allow the user to say who
1N/A** s/he is (using -f or -r). These are:
1N/A** 1. The user's uid is zero (root).
1N/A** 2. The user's login name is in an approved list (typically
1N/A** from a network server).
1N/A** 3. The address the user is trying to claim has a
1N/A** "!" character in it (since #2 doesn't do it for
1N/A** us if we are dialing out for UUCP).
1N/A** A better check to replace #3 would be if the
1N/A** effective uid is "UUCP" -- this would require me
1N/A** to rewrite getpwent to "grab" uucp as it went by,
1N/A** make getname more nasty, do another passwd file
1N/A** scan, or compile the UID of "UUCP" into the code,
1N/A** all of which are reprehensible.
1N/A**
1N/A** Assuming all of these fail, we figure out something
1N/A** ourselves.
1N/A**
1N/A** Parameters:
1N/A** from -- the person we would like to believe this message
1N/A** is from, as specified on the command line.
1N/A** e -- the envelope in which we would like the sender set.
1N/A** delimptr -- if non-NULL, set to the location of the
1N/A** trailing delimiter.
1N/A** delimchar -- the character that will delimit the sender
1N/A** address.
1N/A** internal -- set if this address is coming from an internal
1N/A** source such as an owner alias.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A**
1N/A** Side Effects:
1N/A** sets sendmail's notion of who the from person is.
1N/A*/
1N/A
1N/Avoid
1N/Asetsender(from, e, delimptr, delimchar, internal)
1N/A char *from;
1N/A register ENVELOPE *e;
1N/A char **delimptr;
1N/A int delimchar;
1N/A bool internal;
1N/A{
1N/A register char **pvp;
1N/A char *realname = NULL;
1N/A char *bp;
1N/A char buf[MAXNAME + 2];
1N/A char pvpbuf[PSBUFSIZE];
1N/A extern char *FullName;
1N/A
1N/A if (tTd(45, 1))
1N/A sm_dprintf("setsender(%s)\n", from == NULL ? "" : from);
1N/A
1N/A /* may be set from earlier calls */
1N/A macdefine(&e->e_macro, A_PERM, 'x', "");
1N/A
1N/A /*
1N/A ** Figure out the real user executing us.
1N/A ** Username can return errno != 0 on non-errors.
1N/A */
1N/A
1N/A if (bitset(EF_QUEUERUN, e->e_flags) || OpMode == MD_SMTP ||
1N/A OpMode == MD_ARPAFTP || OpMode == MD_DAEMON)
1N/A realname = from;
1N/A if (realname == NULL || realname[0] == '\0')
1N/A realname = username();
1N/A
1N/A if (ConfigLevel < 2)
1N/A SuprErrs = true;
1N/A
1N/A macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), "e s");
1N/A
1N/A /* preset state for then clause in case from == NULL */
1N/A e->e_from.q_state = QS_BADADDR;
1N/A e->e_from.q_flags = 0;
1N/A if (from == NULL ||
1N/A parseaddr(from, &e->e_from, RF_COPYALL|RF_SENDERADDR,
1N/A delimchar, delimptr, e, false) == NULL ||
1N/A QS_IS_BADADDR(e->e_from.q_state) ||
1N/A e->e_from.q_mailer == ProgMailer ||
1N/A e->e_from.q_mailer == FileMailer ||
1N/A e->e_from.q_mailer == InclMailer)
1N/A {
1N/A /* log garbage addresses for traceback */
1N/A if (from != NULL && LogLevel > 2)
1N/A {
1N/A char *p;
1N/A char ebuf[MAXNAME * 2 + 2];
1N/A
1N/A p = macvalue('_', e);
1N/A if (p == NULL)
1N/A {
1N/A char *host = RealHostName;
1N/A
1N/A if (host == NULL)
1N/A host = MyHostName;
1N/A (void) sm_snprintf(ebuf, sizeof(ebuf),
1N/A "%.*s@%.*s", MAXNAME,
1N/A realname, MAXNAME, host);
1N/A p = ebuf;
1N/A }
1N/A sm_syslog(LOG_NOTICE, e->e_id,
1N/A "setsender: %s: invalid or unparsable, received from %s",
1N/A shortenstring(from, 83), p);
1N/A }
1N/A if (from != NULL)
1N/A {
1N/A if (!QS_IS_BADADDR(e->e_from.q_state))
1N/A {
1N/A /* it was a bogus mailer in the from addr */
1N/A e->e_status = "5.1.7";
1N/A usrerrenh(e->e_status,
1N/A "553 Invalid sender address");
1N/A }
1N/A SuprErrs = true;
1N/A }
1N/A if (from == realname ||
1N/A parseaddr(from = realname,
1N/A &e->e_from, RF_COPYALL|RF_SENDERADDR, ' ',
1N/A NULL, e, false) == NULL)
1N/A {
1N/A char nbuf[100];
1N/A
1N/A SuprErrs = true;
1N/A expand("\201n", nbuf, sizeof(nbuf), e);
1N/A from = sm_rpool_strdup_x(e->e_rpool, nbuf);
1N/A if (parseaddr(from, &e->e_from, RF_COPYALL, ' ',
1N/A NULL, e, false) == NULL &&
1N/A parseaddr(from = "postmaster", &e->e_from,
1N/A RF_COPYALL, ' ', NULL, e, false) == NULL)
1N/A syserr("553 5.3.0 setsender: can't even parse postmaster!");
1N/A }
1N/A }
1N/A else
1N/A FromFlag = true;
1N/A e->e_from.q_state = QS_SENDER;
1N/A if (tTd(45, 5))
1N/A {
1N/A sm_dprintf("setsender: QS_SENDER ");
1N/A printaddr(sm_debug_file(), &e->e_from, false);
1N/A }
1N/A SuprErrs = false;
1N/A
1N/A#if USERDB
1N/A if (bitnset(M_CHECKUDB, e->e_from.q_mailer->m_flags))
1N/A {
1N/A register char *p;
1N/A
1N/A p = udbsender(e->e_from.q_user, e->e_rpool);
1N/A if (p != NULL)
1N/A from = p;
1N/A }
1N/A#endif /* USERDB */
1N/A
1N/A if (bitnset(M_HASPWENT, e->e_from.q_mailer->m_flags))
1N/A {
1N/A SM_MBDB_T user;
1N/A
1N/A if (!internal)
1N/A {
1N/A /* if the user already given fullname don't redefine */
1N/A if (FullName == NULL)
1N/A FullName = macvalue('x', e);
1N/A if (FullName != NULL)
1N/A {
1N/A if (FullName[0] == '\0')
1N/A FullName = NULL;
1N/A else
1N/A FullName = newstr(FullName);
1N/A }
1N/A }
1N/A
1N/A if (e->e_from.q_user[0] != '\0' &&
1N/A sm_mbdb_lookup(e->e_from.q_user, &user) == EX_OK)
1N/A {
1N/A /*
1N/A ** Process passwd file entry.
1N/A */
1N/A
1N/A /* extract home directory */
1N/A if (*user.mbdb_homedir == '\0')
1N/A e->e_from.q_home = NULL;
1N/A else if (strcmp(user.mbdb_homedir, "/") == 0)
1N/A e->e_from.q_home = "";
1N/A else
1N/A e->e_from.q_home = sm_rpool_strdup_x(e->e_rpool,
1N/A user.mbdb_homedir);
1N/A macdefine(&e->e_macro, A_PERM, 'z', e->e_from.q_home);
1N/A
1N/A /* extract user and group id */
1N/A if (user.mbdb_uid != SM_NO_UID)
1N/A {
1N/A e->e_from.q_uid = user.mbdb_uid;
1N/A e->e_from.q_gid = user.mbdb_gid;
1N/A e->e_from.q_flags |= QGOODUID;
1N/A }
1N/A
1N/A /* extract full name from passwd file */
1N/A if (FullName == NULL && !internal &&
1N/A user.mbdb_fullname[0] != '\0' &&
1N/A strcmp(user.mbdb_name, e->e_from.q_user) == 0)
1N/A {
1N/A FullName = newstr(user.mbdb_fullname);
1N/A }
1N/A }
1N/A else
1N/A {
1N/A e->e_from.q_home = NULL;
1N/A }
1N/A if (FullName != NULL && !internal)
1N/A macdefine(&e->e_macro, A_TEMP, 'x', FullName);
1N/A }
1N/A else if (!internal && OpMode != MD_DAEMON && OpMode != MD_SMTP)
1N/A {
1N/A if (e->e_from.q_home == NULL)
1N/A {
1N/A e->e_from.q_home = getenv("HOME");
1N/A if (e->e_from.q_home != NULL)
1N/A {
1N/A if (*e->e_from.q_home == '\0')
1N/A e->e_from.q_home = NULL;
1N/A else if (strcmp(e->e_from.q_home, "/") == 0)
1N/A e->e_from.q_home++;
1N/A }
1N/A }
1N/A e->e_from.q_uid = RealUid;
1N/A e->e_from.q_gid = RealGid;
1N/A e->e_from.q_flags |= QGOODUID;
1N/A }
1N/A
1N/A /*
1N/A ** Rewrite the from person to dispose of possible implicit
1N/A ** links in the net.
1N/A */
1N/A
1N/A pvp = prescan(from, delimchar, pvpbuf, sizeof(pvpbuf), NULL,
1N/A IntTokenTab, false);
1N/A if (pvp == NULL)
1N/A {
1N/A /* don't need to give error -- prescan did that already */
1N/A if (LogLevel > 2)
1N/A sm_syslog(LOG_NOTICE, e->e_id,
1N/A "cannot prescan from (%s)",
1N/A shortenstring(from, MAXSHORTSTR));
1N/A finis(true, true, ExitStat);
1N/A }
1N/A (void) REWRITE(pvp, 3, e);
1N/A (void) REWRITE(pvp, 1, e);
1N/A (void) REWRITE(pvp, 4, e);
1N/A macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), NULL);
1N/A bp = buf + 1;
1N/A cataddr(pvp, NULL, bp, sizeof(buf) - 2, '\0', false);
1N/A if (*bp == '@' && !bitnset(M_NOBRACKET, e->e_from.q_mailer->m_flags))
1N/A {
1N/A /* heuristic: route-addr: add angle brackets */
1N/A (void) sm_strlcat(bp, ">", sizeof(buf) - 1);
1N/A *--bp = '<';
1N/A }
1N/A e->e_sender = sm_rpool_strdup_x(e->e_rpool, bp);
1N/A macdefine(&e->e_macro, A_PERM, 'f', e->e_sender);
1N/A
1N/A /* save the domain spec if this mailer wants it */
1N/A if (e->e_from.q_mailer != NULL &&
1N/A bitnset(M_CANONICAL, e->e_from.q_mailer->m_flags))
1N/A {
1N/A char **lastat;
1N/A
1N/A /* get rid of any pesky angle brackets */
1N/A macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), "e s");
1N/A (void) REWRITE(pvp, 3, e);
1N/A (void) REWRITE(pvp, 1, e);
1N/A (void) REWRITE(pvp, 4, e);
1N/A macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), NULL);
1N/A
1N/A /* strip off to the last "@" sign */
1N/A for (lastat = NULL; *pvp != NULL; pvp++)
1N/A {
1N/A if (strcmp(*pvp, "@") == 0)
1N/A lastat = pvp;
1N/A }
1N/A if (lastat != NULL)
1N/A {
1N/A e->e_fromdomain = copyplist(lastat, true, e->e_rpool);
1N/A if (tTd(45, 3))
1N/A {
1N/A sm_dprintf("Saving from domain: ");
1N/A printav(sm_debug_file(), e->e_fromdomain);
1N/A }
1N/A }
1N/A }
1N/A}
1N/A/*
1N/A** PRINTENVFLAGS -- print envelope flags for debugging
1N/A**
1N/A** Parameters:
1N/A** e -- the envelope with the flags to be printed.
1N/A**
1N/A** Returns:
1N/A** none.
1N/A*/
1N/A
1N/Astruct eflags
1N/A{
1N/A char *ef_name;
1N/A unsigned long ef_bit;
1N/A};
1N/A
1N/Astatic struct eflags EnvelopeFlags[] =
1N/A{
1N/A { "OLDSTYLE", EF_OLDSTYLE },
1N/A { "INQUEUE", EF_INQUEUE },
1N/A { "NO_BODY_RETN", EF_NO_BODY_RETN },
1N/A { "CLRQUEUE", EF_CLRQUEUE },
1N/A { "SENDRECEIPT", EF_SENDRECEIPT },
1N/A { "FATALERRS", EF_FATALERRS },
1N/A { "DELETE_BCC", EF_DELETE_BCC },
1N/A { "RESPONSE", EF_RESPONSE },
1N/A { "RESENT", EF_RESENT },
1N/A { "VRFYONLY", EF_VRFYONLY },
1N/A { "WARNING", EF_WARNING },
1N/A { "QUEUERUN", EF_QUEUERUN },
1N/A { "GLOBALERRS", EF_GLOBALERRS },
1N/A { "PM_NOTIFY", EF_PM_NOTIFY },
1N/A { "METOO", EF_METOO },
1N/A { "LOGSENDER", EF_LOGSENDER },
1N/A { "NORECEIPT", EF_NORECEIPT },
1N/A { "HAS8BIT", EF_HAS8BIT },
1N/A { "NL_NOT_EOL", EF_NL_NOT_EOL },
1N/A { "CRLF_NOT_EOL", EF_CRLF_NOT_EOL },
1N/A { "RET_PARAM", EF_RET_PARAM },
1N/A { "HAS_DF", EF_HAS_DF },
1N/A { "IS_MIME", EF_IS_MIME },
1N/A { "DONT_MIME", EF_DONT_MIME },
1N/A { "DISCARD", EF_DISCARD },
1N/A { "TOOBIG", EF_TOOBIG },
1N/A { "SPLIT", EF_SPLIT },
1N/A { "UNSAFE", EF_UNSAFE },
1N/A { NULL, 0 }
1N/A};
1N/A
1N/Avoid
1N/Aprintenvflags(e)
1N/A register ENVELOPE *e;
1N/A{
1N/A register struct eflags *ef;
1N/A bool first = true;
1N/A
1N/A sm_dprintf("%lx", e->e_flags);
1N/A for (ef = EnvelopeFlags; ef->ef_name != NULL; ef++)
1N/A {
1N/A if (!bitset(ef->ef_bit, e->e_flags))
1N/A continue;
1N/A if (first)
1N/A sm_dprintf("<%s", ef->ef_name);
1N/A else
1N/A sm_dprintf(",%s", ef->ef_name);
1N/A first = false;
1N/A }
1N/A if (!first)
1N/A sm_dprintf(">\n");
1N/A}