#ifndef _SENDMAIL_H

# define _SENDMAIL_H 1

#ifndef MILTER

# define MILTER 1 /* turn on MILTER by default */

#endif /* MILTER */

#ifdef _DEFINE

# define EXTERN

#else /* _DEFINE */

# define EXTERN extern

#endif /* _DEFINE */

#include <unistd.h>

#include <stddef.h>

#include <stdlib.h>

#include <stdio.h>

#include <ctype.h>

#include <setjmp.h>

#include <string.h>

#include <time.h>

# ifdef EX_OK

# undef EX_OK /* for SVr4.2 SMP */

# endif /* EX_OK */

#include "sendmail/sendmail.h"

#if MONCONTROL

# define SM_PROF(x) moncontrol(x)

#else /* MONCONTROL */

# define SM_PROF(x)

#endif /* MONCONTROL */

#ifdef _DEFINE

# ifndef lint

SM_UNUSED(static char SmailId[]) = "@(#)$Id: sendmail.h,v 8.1068 2009/12/18 17:08:01 ca Exp $";

# endif /* ! lint */

#endif /* _DEFINE */

#include "bf.h"

#include "timers.h"

#include <sm/exc.h>

#include <sm/heap.h>

#include <sm/debug.h>

#include <sm/rpool.h>

#include <sm/io.h>

#include <sm/path.h>

#include <sm/signal.h>

#include <sm/clock.h>

#include <sm/mbdb.h>

#include <sm/errstring.h>

#include <sm/sysexits.h>

#include <sm/shm.h>

#include <sm/misc.h>

#ifdef LOG

# include <syslog.h>

#endif /* LOG */

# if NETINET || NETINET6 || NETUNIX || NETISO || NETNS || NETX25

# include <sys/socket.h>

# endif /* NETINET || NETINET6 || NETUNIX || NETISO || NETNS || NETX25 */

# if NETUNIX

# include <sys/un.h>

# endif /* NETUNIX */

# if NETINET || NETINET6

# include <netinet/in.h>

# endif /* NETINET || NETINET6 */

# if NETINET6

# endif /* NETINET6 */

# if NETISO

# include <netiso/iso.h>

# endif /* NETISO */

# if NETNS

# include <netns/ns.h>

# endif /* NETNS */

# if NETX25

# include <netccitt/x25.h>

# endif /* NETX25 */

# if NAMED_BIND

# include <arpa/nameser.h>

# ifdef NOERROR

# undef NOERROR /* avoid <sys/streams.h> conflict */

# endif /* NOERROR */

# include <resolv.h>

# else /* NAMED_BIND */

# undef SM_SET_H_ERRNO

# define SM_SET_H_ERRNO(err)

# endif /* NAMED_BIND */

# if HESIOD

# include <hesiod.h>

# if !defined(HES_ER_OK) || defined(HESIOD_INTERFACES)

# define HESIOD_INIT /* support for the new interface */

# endif /* !defined(HES_ER_OK) || defined(HESIOD_INTERFACES) */

# endif /* HESIOD */

#if STARTTLS

# include <openssl/ssl.h>

# if !TLS_NO_RSA

# define RSA_KEYLENGTH 512

# endif /* !TLS_NO_RSA */

#endif /* STARTTLS */

#if SASL /* include the sasl include files if we have them */

# if SASL == 2 || SASL >= 20000

# include <sasl/sasl.h>

# include <sasl/saslutil.h>

# else /* SASL == 2 || SASL >= 20000 */

# include <sasl.h>

# include <saslutil.h>

# endif /* SASL == 2 || SASL >= 20000 */

# if defined(SASL_VERSION_MAJOR) && defined(SASL_VERSION_MINOR) && defined(SASL_VERSION_STEP)

# define SASL_VERSION (SASL_VERSION_MAJOR * 10000) + (SASL_VERSION_MINOR * 100) + SASL_VERSION_STEP

# if SASL == 1 || SASL == 2

# undef SASL

# define SASL SASL_VERSION

# else /* SASL == 1 || SASL == 2 */

# if SASL != SASL_VERSION

ERROR README: -DSASL (SASL) does not agree with the version of the CYRUS_SASL library (SASL_VERSION)

ERROR README: see README!

# endif /* SASL != SASL_VERSION */

# endif /* SASL == 1 || SASL == 2 */

# else /* defined(SASL_VERSION_MAJOR) && defined(SASL_VERSION_MINOR) && defined(SASL_VERSION_STEP) */

# if SASL == 1

ERROR README: please set -DSASL to the version of the CYRUS_SASL library

ERROR README: see README!

# endif /* SASL == 1 */

# endif /* defined(SASL_VERSION_MAJOR) && defined(SASL_VERSION_MINOR) && defined(SASL_VERSION_STEP) */

#endif /* SASL */

#ifndef INADDRSZ

# define INADDRSZ 4 /* size of an IPv4 address in bytes */

#endif /* ! INADDRSZ */

#ifndef IN6ADDRSZ

# define IN6ADDRSZ 16 /* size of an IPv6 address in bytes */

#endif /* ! IN6ADDRSZ */

#ifndef INT16SZ

# define INT16SZ 2 /* size of a 16 bit integer in bytes */

#endif /* ! INT16SZ */

#ifndef INT32SZ

# define INT32SZ 4 /* size of a 32 bit integer in bytes */

#endif /* ! INT32SZ */

#ifndef INADDR_LOOPBACK

# define INADDR_LOOPBACK 0x7f000001 /* loopback address */

#endif /* ! INADDR_LOOPBACK */

#ifndef INADDR_NONE

# define INADDR_NONE 0xffffffff

#endif /* ! INADDR_NONE */

# define QF_O_EXTRA 0

typedef enum

{

A_HEAP, /* the storage was allocated by malloc, and the

A_TEMP, /* The storage is temporary, and is only guaranteed

A_PERM /* The storage is 'permanent': this might mean static

} ARGCLASS_T;

typedef struct envelope ENVELOPE;

typedef struct mailer MAILER;

typedef struct queuegrp QUEUEGRP;

struct address

{

char *q_paddr; /* the printname for the address */

char *q_user; /* user name */

char *q_ruser; /* real user name, or NULL if q_user */

char *q_host; /* host name */

struct mailer *q_mailer; /* mailer to use */

unsigned long q_flags; /* status flags, see below */

uid_t q_uid; /* user-id of receiver (if known) */

gid_t q_gid; /* group-id of receiver (if known) */

char *q_home; /* home dir (local mailer only) */

char *q_fullname; /* full name if known */

struct address *q_next; /* chain */

struct address *q_alias; /* address this results from */

char *q_owner; /* owner of q_alias */

struct address *q_tchain; /* temporary use chain */

#if PIPELINING

struct address *q_pchain; /* chain for pipelining */

#endif /* PIPELINING */

char *q_finalrcpt; /* Final-Recipient: DSN header */

char *q_orcpt; /* ORCPT parameter from RCPT TO: line */

char *q_status; /* status code for DSNs */

char *q_rstatus; /* remote status message for DSNs */

time_t q_statdate; /* date of status messages */

char *q_statmta; /* MTA generating q_rstatus */

short q_state; /* address state, see below */

char *q_signature; /* MX-based sorting value */

int q_qgrp; /* index into queue groups */

int q_qdir; /* queue directory inside group */

char *q_message; /* error message */

};

typedef struct address ADDRESS;

#define QGOODUID 0x00000001 /* the q_uid q_gid fields are good */

#define QPRIMARY 0x00000002 /* set from RCPT or argv */

#define QNOTREMOTE 0x00000004 /* address not for remote forwarding */

#define QSELFREF 0x00000008 /* this address references itself */

#define QBOGUSSHELL 0x00000010 /* user has no valid shell listed */

#define QUNSAFEADDR 0x00000020 /* address acquired via unsafe path */

#define QPINGONSUCCESS 0x00000040 /* give return on successful delivery */

#define QPINGONFAILURE 0x00000080 /* give return on failure */

#define QPINGONDELAY 0x00000100 /* give return on message delay */

#define QHASNOTIFY 0x00000200 /* propagate notify parameter */

#define QRELAYED 0x00000400 /* DSN: relayed to non-DSN aware sys */

#define QEXPANDED 0x00000800 /* DSN: undergone list expansion */

#define QDELIVERED 0x00001000 /* DSN: successful final delivery */

#define QDELAYED 0x00002000 /* DSN: message delayed */

#define QALIAS 0x00004000 /* expanded alias */

#define QBYTRACE 0x00008000 /* DeliverBy: trace */

#define QBYNDELAY 0x00010000 /* DeliverBy: notify, delay */

#define QBYNRELAY 0x00020000 /* DeliverBy: notify, relayed */

#define QTHISPASS 0x40000000 /* temp: address set this pass */

#define QRCPTOK 0x80000000 /* recipient() processed address */

#define Q_PINGFLAGS (QPINGONSUCCESS|QPINGONFAILURE|QPINGONDELAY)

#define QS_OK 0 /* address ok (for now)/not yet tried */

#define QS_SENT 1 /* good address, delivery complete */

#define QS_BADADDR 2 /* illegal address */

#define QS_QUEUEUP 3 /* save address in queue */

#define QS_RETRY 4 /* retry delivery for next MX */

#define QS_VERIFIED 5 /* verified, but not expanded */

#define QS_DONTSEND 6 /* don't send to this address */

#define QS_EXPANDED 7 /* expanded */

#define QS_SENDER 8 /* message sender (MeToo) */

#define QS_CLONED 9 /* addr cloned to split envelope */

#define QS_DISCARDED 10 /* rcpt discarded (EF_DISCARD) */

#define QS_REPLACED 11 /* maplocaluser()/UserDB replaced */

#define QS_REMOVED 12 /* removed (removefromlist()) */

#define QS_DUPLICATE 13 /* duplicate suppressed */

#define QS_INCLUDED 14 /* :include: delivery */

#define QS_FATALERR 15 /* fatal error, don't deliver */

#define QS_IS_OK(s) ((s) == QS_OK)

#define QS_IS_SENT(s) ((s) == QS_SENT)

#define QS_IS_BADADDR(s) ((s) == QS_BADADDR)

#define QS_IS_QUEUEUP(s) ((s) == QS_QUEUEUP)

#define QS_IS_RETRY(s) ((s) == QS_RETRY)

#define QS_IS_VERIFIED(s) ((s) == QS_VERIFIED)

#define QS_IS_EXPANDED(s) ((s) == QS_EXPANDED)

#define QS_IS_REMOVED(s) ((s) == QS_REMOVED)

#define QS_IS_UNDELIVERED(s) ((s) == QS_OK || \

(s) == QS_QUEUEUP || \

(s) == QS_RETRY || \

(s) == QS_VERIFIED)

#define QS_IS_UNMARKED(s) ((s) == QS_OK || \

(s) == QS_RETRY)

#define QS_IS_SENDABLE(s) ((s) == QS_OK || \

(s) == QS_QUEUEUP || \

(s) == QS_RETRY)

#define QS_IS_ATTEMPTED(s) ((s) == QS_QUEUEUP || \

(s) == QS_RETRY || \

(s) == QS_SENT || \

(s) == QS_DISCARDED)

#define QS_IS_DEAD(s) ((s) >= QS_DONTSEND)

#define NULLADDR ((ADDRESS *) NULL)

extern ADDRESS NullAddress; /* a null (template) address [main.c] */

extern void cataddr __P((char **, char **, char *, int, int, bool));

extern char *crackaddr __P((char *, ENVELOPE *));

extern bool emptyaddr __P((ADDRESS *));

extern ADDRESS *getctladdr __P((ADDRESS *));

extern int include __P((char *, bool, ADDRESS *, ADDRESS **, int, ENVELOPE *));

extern bool invalidaddr __P((char *, char *, bool));

extern ADDRESS *parseaddr __P((char *, ADDRESS *, int, int, char **,

ENVELOPE *, bool));

extern char **prescan __P((char *, int, char[], int, char **, unsigned char *, bool));

extern void printaddr __P((SM_FILE_T *, ADDRESS *, bool));

extern ADDRESS *recipient __P((ADDRESS *, ADDRESS **, int, ENVELOPE *));

extern char *remotename __P((char *, MAILER *, int, int *, ENVELOPE *));

extern int rewrite __P((char **, int, int, ENVELOPE *, int));

extern bool sameaddr __P((ADDRESS *, ADDRESS *));

extern int sendtolist __P((char *, ADDRESS *, ADDRESS **, int, ENVELOPE *));

#if MILTER

extern int removefromlist __P((char *, ADDRESS **, ENVELOPE *));

#endif /* MILTER */

extern void setsender __P((char *, ENVELOPE *, char **, int, bool));

typedef void esmtp_args_F __P((ADDRESS *, char *, char *, ENVELOPE *));

extern void parse_esmtp_args __P((ENVELOPE *, ADDRESS *, char *, char *,

char *, char *args[], esmtp_args_F));

extern esmtp_args_F mail_esmtp_args;

extern esmtp_args_F rcpt_esmtp_args;

extern void reset_mail_esmtp_args __P((ENVELOPE *));

#define REWRITE(pvp, rs, env) rewrite(pvp, rs, 0, env, MAXATOM)

extern unsigned char ExtTokenTab[256]; /* external strings */

extern unsigned char IntTokenTab[256]; /* internal strings */

struct mailer

{

char *m_name; /* symbolic name of this mailer */

char *m_mailer; /* pathname of the mailer to use */

char *m_mtatype; /* type of this MTA */

char *m_addrtype; /* type for addresses */

char *m_diagtype; /* type for diagnostics */

BITMAP256 m_flags; /* status flags, see below */

short m_mno; /* mailer number internally */

short m_nice; /* niceness to run at (mostly for prog) */

char **m_argv; /* template argument vector */

short m_sh_rwset; /* rewrite set: sender header addresses */

short m_se_rwset; /* rewrite set: sender envelope addresses */

short m_rh_rwset; /* rewrite set: recipient header addresses */

short m_re_rwset; /* rewrite set: recipient envelope addresses */

char *m_eol; /* end of line string */

long m_maxsize; /* size limit on message to this mailer */

int m_linelimit; /* max # characters per line */

int m_maxdeliveries; /* max deliveries per mailer connection */

char *m_execdir; /* directory to chdir to before execv */

char *m_rootdir; /* directory to chroot to before execv */

uid_t m_uid; /* UID to run as */

gid_t m_gid; /* GID to run as */

char *m_defcharset; /* default character set */

time_t m_wait; /* timeout to wait for end */

int m_maxrcpt; /* max recipients per envelope client-side */

short m_qgrp; /* queue group for this mailer */

};

#define M_ESMTP 'a' /* run Extended SMTP */

#define M_ALIASABLE 'A' /* user can be LHS of an alias */

#define M_BLANKEND 'b' /* ensure blank line at end of message */

#define M_STRIPBACKSL 'B' /* strip all leading backslashes from user */

#define M_NOCOMMENT 'c' /* don't include comment part of address */

#define M_CANONICAL 'C' /* make addresses canonical "u@dom" */

#define M_NOBRACKET 'd' /* never angle bracket envelope route-addrs */

/* 'D' CF: include Date: */

#define M_EXPENSIVE 'e' /* it costs to use this mailer.... */

#define M_ESCFROM 'E' /* escape From lines to >From */

#define M_FOPT 'f' /* mailer takes picky -f flag */

/* 'F' CF: include From: or Resent-From: */

#define M_NO_NULL_FROM 'g' /* sender of errors should be $g */

#define M_HST_UPPER 'h' /* preserve host case distinction */

#define M_PREHEAD 'H' /* MAIL11V3: preview headers */

#define M_UDBENVELOPE 'i' /* do udbsender rewriting on envelope */

#define M_INTERNAL 'I' /* SMTP to another sendmail site */

#define M_UDBRECIPIENT 'j' /* do udbsender rewriting on recipient lines */

#define M_NOLOOPCHECK 'k' /* don't check for loops in HELO command */

#define M_CHUNKING 'K' /* CHUNKING: reserved for future use */

#define M_LOCALMAILER 'l' /* delivery is to this host */

#define M_LIMITS 'L' /* must enforce SMTP line limits */

#define M_MUSER 'm' /* can handle multiple users at once */

/* 'M' CF: include Message-Id: */

#define M_NHDR 'n' /* don't insert From line */

#define M_MANYSTATUS 'N' /* MAIL11V3: DATA returns multi-status */

#define M_RUNASRCPT 'o' /* always run mailer as recipient */

#define M_FROMPATH 'p' /* use reverse-path in MAIL FROM: */

/* 'P' CF: include Return-Path: */

#define M_VRFY250 'q' /* VRFY command returns 250 instead of 252 */

#define M_ROPT 'r' /* mailer takes picky -r flag */

#define M_SECURE_PORT 'R' /* try to send on a reserved TCP port */

#define M_STRIPQ 's' /* strip quote chars from user/host */

#define M_SPECIFIC_UID 'S' /* run as specific uid/gid */

#define M_USR_UPPER 'u' /* preserve user case distinction */

#define M_UGLYUUCP 'U' /* this wants an ugly UUCP from line */

#define M_CONTENT_LEN 'v' /* add Content-Length: header (SVr4) */

/* 'V' UIUC: !-relativize all addresses */

#define M_HASPWENT 'w' /* check for /etc/passwd entry */

#define M_NOHOSTSTAT 'W' /* ignore long term host status information */

/* 'x' CF: include Full-Name: */

#define M_XDOT 'X' /* use hidden-dot algorithm */

#define M_LMTP 'z' /* run Local Mail Transport Protocol */

#define M_DIALDELAY 'Z' /* apply dial delay sleeptime */

#define M_NOMX '0' /* turn off MX lookups */

#define M_NONULLS '1' /* don't send null bytes */

#define M_FSMTP '2' /* force SMTP (no ESMTP even if offered) */

#define M_EBCDIC '3' /* extend Q-P encoding for EBCDIC */

#define M_TRYRULESET5 '5' /* use ruleset 5 after local aliasing */

#define M_7BITHDRS '6' /* strip headers to 7 bits even in 8 bit path */

#define M_7BITS '7' /* use 7-bit path */

#define M_8BITS '8' /* force "just send 8" behaviour */

#define M_MAKE8BIT '9' /* convert 7 -> 8 bit if appropriate */

#define M_CHECKINCLUDE ':' /* check for :include: files */

#define M_CHECKPROG '|' /* check for |program addresses */

#define M_CHECKFILE '/' /* check for /file addresses */

#define M_CHECKUDB '@' /* user can be user database key */

#define M_CHECKHDIR '~' /* SGI: check for valid home directory */

#define M_HOLD '%' /* Hold delivery until ETRN/-qI/-qR/-qS */

#define M_PLUS '+' /* Reserved: Used in mc for adding new flags */

#define M_MINUS '-' /* Reserved: Used in mc for removing flags */

extern void initerrmailers __P((void));

extern void makemailer __P((char *));

extern void makequeue __P((char *, bool));

extern void runqueueevent __P((int));

#if _FFR_QUEUE_RUN_PARANOIA

extern bool checkqueuerunner __P((void));

#endif /* _FFR_QUEUE_RUN_PARANOIA */

EXTERN MAILER *FileMailer; /* ptr to *file* mailer */

EXTERN MAILER *InclMailer; /* ptr to *include* mailer */

EXTERN MAILER *LocalMailer; /* ptr to local mailer */

EXTERN MAILER *ProgMailer; /* ptr to program mailer */

EXTERN MAILER *Mailer[MAXMAILERS + 1];

struct qpaths_s

{

char *qp_name; /* name of queue dir, relative path */

short qp_subdirs; /* use subdirs? */

short qp_fsysidx; /* file system index of this directory */

# if SM_CONF_SHM

int qp_idx; /* index into array for queue information */

# endif /* SM_CONF_SHM */

};

typedef struct qpaths_s QPATHS;

struct queuegrp

{

char *qg_name; /* symbolic name of this queue group */

/*

char *qg_qdir; /* common component of queue directory */

short qg_index; /* queue number internally, index in Queue[] */

int qg_maxqrun; /* max # of jobs in 1 queuerun */

int qg_numqueues; /* number of queues in this queue */

/*

time_t qg_queueintvl; /* interval for queue runs */

QPATHS *qg_qpaths; /* list of queue directories */

BITMAP256 qg_flags; /* status flags, see below */

short qg_nice; /* niceness for queue run */

int qg_wgrp; /* Assigned to this work group */

int qg_maxlist; /* max items in work queue for this group */

int qg_curnum; /* current number of queue for queue runs */

int qg_maxrcpt; /* max recipients per envelope, 0==no limit */

time_t qg_nextrun; /* time for next queue runs */

#if _FFR_QUEUE_GROUP_SORTORDER

short qg_sortorder; /* how do we sort this queuerun */

#endif /* _FFR_QUEUE_GROUP_SORTORDER */

#if 0

long qg_wkrcptfact; /* multiplier for # recipients -> priority */

long qg_qfactor; /* slope of queue function */

bool qg_doqueuerun; /* XXX flag is it time to do a queuerun */

#endif /* 0 */

};

#define QD_DEFINED ((char) 1) /* queue group has been defined */

#define QD_FORK 'f' /* fork queue runs */

extern void filesys_update __P((void));

#if _FFR_ANY_FREE_FS

extern bool filesys_free __P((long));

#endif /* _FFR_ANY_FREE_FS */

#if SASL

# define SASL_WRONG (-1)

# define SASL_USER 0 /* authorization id (user) */

# define SASL_AUTHID 1 /* authentication id */

# define SASL_PASSWORD 2 /* password fuer authid */

# define SASL_DEFREALM 3 /* realm to use */

# define SASL_MECHLIST 4 /* list of mechanisms to try */

# define SASL_ID_REALM 5 /* authid@defrealm */

# define SASL_MECH 6

# define SASL_ENTRIES 7 /* number of entries in array */

# define SASL_USER_BIT (1 << SASL_USER)

# define SASL_AUTHID_BIT (1 << SASL_AUTHID)

# define SASL_PASSWORD_BIT (1 << SASL_PASSWORD)

# define SASL_DEFREALM_BIT (1 << SASL_DEFREALM)

# define SASL_MECHLIST_BIT (1 << SASL_MECHLIST)

# define SASL_NOT_AUTH 0 /* not authenticated */

# define SASL_PROC_AUTH 1 /* in process of authenticating */

# define SASL_IS_AUTH 2 /* authenticated */

# define SASL_AUTH_AUTH 0x1000 /* use auth= only if authenticated */

# if SASL >= 20101

# define SASL_SEC_MASK SASL_SEC_MAXIMUM /* mask for SASL_SEC_* values: sasl.h */

# else /* SASL >= 20101 */

# define SASL_SEC_MASK 0x0fff /* mask for SASL_SEC_* values: sasl.h */

# if (SASL_SEC_NOPLAINTEXT & SASL_SEC_MASK) == 0 || \

(SASL_SEC_NOACTIVE & SASL_SEC_MASK) == 0 || \

(SASL_SEC_NODICTIONARY & SASL_SEC_MASK) == 0 || \

(SASL_SEC_FORWARD_SECRECY & SASL_SEC_MASK) == 0 || \

(SASL_SEC_NOANONYMOUS & SASL_SEC_MASK) == 0 || \

(SASL_SEC_PASS_CREDENTIALS & SASL_SEC_MASK) == 0

ERROR: change SASL_SEC_MASK_ notify sendmail.org!

# endif /* SASL_SEC_NOPLAINTEXT & SASL_SEC_MASK) == 0 ... */

# endif /* SASL >= 20101 */

# define MAXOUTLEN 8192 /* length of output buffer, should be 2^n */

extern char *intersect __P((char *, char *, SM_RPOOL_T *));

extern char *iteminlist __P((char *, char *, char *));

# if SASL >= 20000

extern int proxy_policy __P((sasl_conn_t *, void *, const char *, unsigned, const char *, unsigned, const char *, unsigned, struct propctx *));

extern int safesaslfile __P((void *, const char *, sasl_verify_type_t));

# else /* SASL >= 20000 */

extern int proxy_policy __P((void *, const char *, const char *, const char **, const char **));

# if SASL > 10515

extern int safesaslfile __P((void *, char *, int));

# else /* SASL > 10515 */

extern int safesaslfile __P((void *, char *));

# endif /* SASL > 10515 */

# endif /* SASL >= 20000 */

extern void stop_sasl_client __P((void));

typedef char *SASL_AI_T[SASL_ENTRIES];

EXTERN char *AuthMechanisms; /* AUTH mechanisms */

EXTERN char *AuthRealm; /* AUTH realm */

EXTERN char *SASLInfo; /* file with AUTH info */

EXTERN int SASLOpts; /* options for SASL */

EXTERN int MaxSLBits; /* max. encryption bits for SASL */

#endif /* SASL */

typedef struct

{

SM_RPOOL_T *mac_rpool; /* resource pool */

BITMAP256 mac_allocated; /* storage has been alloc()? */

char *mac_table[MAXMACROID + 1]; /* macros */

} MACROS_T;

EXTERN MACROS_T GlobalMacros;

#define MCI struct mailer_con_info

{

unsigned long mci_flags; /* flag bits, see below */

short mci_errno; /* error number on last connection */

short mci_herrno; /* h_errno from last DNS lookup */

short mci_exitstat; /* exit status from last connection */

short mci_state; /* SMTP state */

int mci_deliveries; /* delivery attempts for connection */

long mci_maxsize; /* max size this server will accept */

SM_FILE_T *mci_in; /* input side of connection */

SM_FILE_T *mci_out; /* output side of connection */

pid_t mci_pid; /* process id of subordinate proc */

char *mci_phase; /* SMTP phase string */

struct mailer *mci_mailer; /* ptr to the mailer for this conn */

char *mci_host; /* host name */

char *mci_status; /* DSN status to be copied to addrs */

char *mci_rstatus; /* SMTP status to be copied to addrs */

time_t mci_lastuse; /* last usage time */

SM_FILE_T *mci_statfile; /* long term status file */

char *mci_heloname; /* name to use as HELO arg */

long mci_min_by; /* minimum DELIVERBY */

bool mci_retryrcpt; /* tempfail for at least one rcpt */

char *mci_tolist; /* list of valid recipients */

SM_RPOOL_T *mci_rpool; /* resource pool */

#if PIPELINING

int mci_okrcpts; /* number of valid recipients */

ADDRESS *mci_nextaddr; /* next address for pipelined status */

#endif /* PIPELINING */

#if SASL

SASL_AI_T mci_sai; /* authentication info */

bool mci_sasl_auth; /* authenticated? */

int mci_sasl_string_len;

char *mci_sasl_string; /* sasl reply string */

char *mci_saslcap; /* SASL list of mechanisms */

sasl_conn_t *mci_conn; /* SASL connection */

#endif /* SASL */

#if STARTTLS

SSL *mci_ssl; /* SSL connection */

#endif /* STARTTLS */

MACROS_T mci_macro; /* macro definitions */

};

#define MCIF_VALID 0x00000001 /* this entry is valid */

#define MCIF_CACHED 0x00000004 /* currently in open cache */

#define MCIF_ESMTP 0x00000008 /* this host speaks ESMTP */

#define MCIF_EXPN 0x00000010 /* EXPN command supported */

#define MCIF_SIZE 0x00000020 /* SIZE option supported */

#define MCIF_8BITMIME 0x00000040 /* BODY=8BITMIME supported */

#define MCIF_7BIT 0x00000080 /* strip this message to 7 bits */

#define MCIF_INHEADER 0x00000200 /* currently outputing header */

#define MCIF_CVT8TO7 0x00000400 /* convert from 8 to 7 bits */

#define MCIF_DSN 0x00000800 /* DSN extension supported */

#define MCIF_8BITOK 0x00001000 /* OK to send 8 bit characters */

#define MCIF_CVT7TO8 0x00002000 /* convert from 7 to 8 bits */

#define MCIF_INMIME 0x00004000 /* currently reading MIME header */

#define MCIF_AUTH 0x00008000 /* AUTH= supported */

#define MCIF_AUTHACT 0x00010000 /* SASL (AUTH) active */

#define MCIF_ENHSTAT 0x00020000 /* ENHANCEDSTATUSCODES supported */

#define MCIF_PIPELINED 0x00040000 /* PIPELINING supported */

#define MCIF_VERB 0x00080000 /* VERB supported */

#if STARTTLS

#define MCIF_TLS 0x00100000 /* STARTTLS supported */

#define MCIF_TLSACT 0x00200000 /* STARTTLS active */

#define MCIF_EXTENS (MCIF_EXPN | MCIF_SIZE | MCIF_8BITMIME | MCIF_DSN | MCIF_8BITOK | MCIF_AUTH | MCIF_ENHSTAT | MCIF_TLS)

#else /* STARTTLS */

#define MCIF_EXTENS (MCIF_EXPN | MCIF_SIZE | MCIF_8BITMIME | MCIF_DSN | MCIF_8BITOK | MCIF_AUTH | MCIF_ENHSTAT)

#endif /* STARTTLS */

#define MCIF_DLVR_BY 0x00400000 /* DELIVERBY */

#if _FFR_IGNORE_EXT_ON_HELO

# define MCIF_HELO 0x00800000 /* we used HELO: ignore extensions */

#endif /* _FFR_IGNORE_EXT_ON_HELO */

#define MCIF_INLONGLINE 0x01000000 /* in the middle of a long line */

#define MCIF_ONLY_EHLO 0x10000000 /* use only EHLO in smtpinit */

#define MCIS_CLOSED 0 /* no traffic on this connection */

#define MCIS_OPENING 1 /* sending initial protocol */

#define MCIS_OPEN 2 /* open, initial protocol sent */

#define MCIS_MAIL 3 /* MAIL command sent */

#define MCIS_RCPT 4 /* RCPT commands being sent */

#define MCIS_DATA 5 /* DATA command sent */

#define MCIS_QUITING 6 /* running quit protocol */

#define MCIS_SSD 7 /* service shutting down */

#define MCIS_ERROR 8 /* I/O error on connection */

extern void mci_cache __P((MCI *));

extern void mci_close __P((MCI *, char *where));

extern void mci_dump __P((SM_FILE_T *, MCI *, bool));

extern void mci_dump_all __P((SM_FILE_T *, bool));

extern void mci_flush __P((bool, MCI *));

extern MCI *mci_get __P((char *, MAILER *));

extern int mci_lock_host __P((MCI *));

extern bool mci_match __P((char *, MAILER *));

extern int mci_print_persistent __P((char *, char *));

extern int mci_purge_persistent __P((char *, char *));

extern MCI **mci_scan __P((MCI *));

extern void mci_setstat __P((MCI *, int, char *, char *));

extern void mci_store_persistent __P((MCI *));

extern int mci_traverse_persistent __P((int (*)(char *, char *), char *));

extern void mci_unlock_host __P((MCI *));

EXTERN int MaxMciCache; /* maximum entries in MCI cache */

EXTERN time_t MciCacheTimeout; /* maximum idle time on connections */

EXTERN time_t MciInfoTimeout; /* how long 'til we retry down hosts */

struct header

{

char *h_field; /* the name of the field */

char *h_value; /* the value of that field */

struct header *h_link; /* the next header */

unsigned char h_macro; /* include header if macro defined */

unsigned long h_flags; /* status bits, see below */

BITMAP256 h_mflags; /* m_flags bits needed */

};

typedef struct header HDR;

struct hdrinfo

{

char *hi_field; /* the name of the field */

unsigned long hi_flags; /* status bits, see below */

char *hi_ruleset; /* validity check ruleset */

};

extern struct hdrinfo HdrInfo[];

#define H_EOH 0x00000001 /* field terminates header */

#define H_RCPT 0x00000002 /* contains recipient addresses */

#define H_DEFAULT 0x00000004 /* if another value is found, drop this */

#define H_RESENT 0x00000008 /* this address is a "Resent-..." address */

#define H_CHECK 0x00000010 /* check h_mflags against m_flags */

#define H_ACHECK 0x00000020 /* ditto, but always (not just default) */

#define H_FORCE 0x00000040 /* force this field, even if default */

#define H_TRACE 0x00000080 /* this field contains trace information */

#define H_FROM 0x00000100 /* this is a from-type field */

#define H_VALID 0x00000200 /* this field has a validated value */

#define H_RECEIPTTO 0x00000400 /* field has return receipt info */

#define H_ERRORSTO 0x00000800 /* field has error address info */

#define H_CTE 0x00001000 /* field is a content-transfer-encoding */

#define H_CTYPE 0x00002000 /* this is a content-type field */

#define H_BCC 0x00004000 /* Bcc: header: strip value or delete */

#define H_ENCODABLE 0x00008000 /* field can be RFC 1522 encoded */

#define H_STRIPCOMM 0x00010000 /* header check: strip comments */

#define H_BINDLATE 0x00020000 /* only expand macros at deliver */

#define H_USER 0x00040000 /* header came from the user/SMTP */

#define CHHDR_DEF 0x0001 /* default header */

#define CHHDR_CHECK 0x0002 /* call ruleset for header */

#define CHHDR_USER 0x0004 /* header from user */

#define CHHDR_QUEUE 0x0008 /* header from queue file */

extern void addheader __P((char *, char *, int, ENVELOPE *, bool));

extern unsigned long chompheader __P((char *, int, HDR **, ENVELOPE *));

extern bool commaize __P((HDR *, char *, bool, MCI *, ENVELOPE *, int));

extern HDR *copyheader __P((HDR *, SM_RPOOL_T *));

extern void eatheader __P((ENVELOPE *, bool, bool));

extern char *hvalue __P((char *, HDR *));

extern void insheader __P((int, char *, char *, int, ENVELOPE *, bool));

extern bool isheader __P((char *));

extern bool putfromline __P((MCI *, ENVELOPE *));

extern void setupheaders __P((void));

#define TIMERS struct sm_timers

{

TIMER ti_overall; /* the whole process */

};

#define PUSHTIMER(l, t) { if (tTd(98, l)) pushtimer(&t); }

#define POPTIMER(l, t) { if (tTd(98, l)) poptimer(&t); }

struct envelope

{

HDR *e_header; /* head of header list */

long e_msgpriority; /* adjusted priority of this message */

time_t e_ctime; /* time message appeared in the queue */

char *e_to; /* (list of) target person(s) */

ADDRESS e_from; /* the person it is from */

char *e_sender; /* e_from.q_paddr w comments stripped */

char **e_fromdomain; /* the domain part of the sender */

ADDRESS *e_sendqueue; /* list of message recipients */

ADDRESS *e_errorqueue; /* the queue for error responses */

/*

long e_msgsize; /* size of the message in bytes */

char *e_msgid; /* message id (for logging) */

unsigned long e_flags; /* flags, see below */

int e_nrcpts; /* number of recipients */

short e_class; /* msg class (priority, junk, etc.) */

short e_hopcount; /* number of times processed */

short e_nsent; /* number of sends since checkpoint */

short e_sendmode; /* message send mode */

short e_errormode; /* error return mode */

short e_timeoutclass; /* message timeout class */

bool (*e_puthdr)__P((MCI *, HDR *, ENVELOPE *, int));

/* function to put header of message */

bool (*e_putbody)__P((MCI *, ENVELOPE *, char *));

/* function to put body of message */

ENVELOPE *e_parent; /* the message this one encloses */

ENVELOPE *e_sibling; /* the next envelope of interest */

char *e_bodytype; /* type of message body */

SM_FILE_T *e_dfp; /* data file */

char *e_id; /* code for this entry in queue */

#if _FFR_SESSID

char *e_sessid; /* session ID for this envelope */

#endif /* _FFR_SESSID */

int e_qgrp; /* queue group (index into queues) */

int e_qdir; /* index into queue directories */

int e_dfqgrp; /* data file queue group index */

int e_dfqdir; /* data file queue directory index */

int e_xfqgrp; /* queue group (index into queues) */

int e_xfqdir; /* index into queue directories (xf) */

SM_FILE_T *e_xfp; /* transcript file */

SM_FILE_T *e_lockfp; /* the lock file for this message */

char *e_message; /* error message; readonly; NULL,

char *e_statmsg; /* stat msg (changes per delivery).

char *e_quarmsg; /* why envelope is quarantined */

char e_qfletter; /* queue file letter on disk */

char *e_msgboundary; /* MIME-style message part boundary */

char *e_origrcpt; /* original recipient (one only) */

char *e_envid; /* envelope id from MAIL FROM: line */

char *e_status; /* DSN status for this message */

time_t e_dtime; /* time of last delivery attempt */

int e_ntries; /* number of delivery attempts */

dev_t e_dfdev; /* data file device (crash recovery) */

ino_t e_dfino; /* data file inode (crash recovery) */

MACROS_T e_macro; /* macro definitions */

MCI *e_mci; /* connection info */

char *e_auth_param; /* readonly; NULL or static storage or

TIMERS e_timers; /* per job timers */

long e_deliver_by; /* deliver by */

int e_dlvr_flag; /* deliver by flag */

SM_RPOOL_T *e_rpool; /* resource pool for this envelope */

unsigned int e_features; /* server features */

#if _FFR_MILTER_ENHSC

#define ENHSC_LEN 11

char e_enhsc[ENHSC_LEN]; /* enhanced status code */

#endif /* _FFR_MILTER_ENHSC */

};

#define EF_OLDSTYLE 0x00000001L /* use spaces (not commas) in hdrs */

#define EF_INQUEUE 0x00000002L /* this message is fully queued */

#define EF_NO_BODY_RETN 0x00000004L /* omit message body on error */

#define EF_CLRQUEUE 0x00000008L /* disk copy is no longer needed */

#define EF_SENDRECEIPT 0x00000010L /* send a return receipt */

#define EF_FATALERRS 0x00000020L /* fatal errors occurred */

#define EF_DELETE_BCC 0x00000040L /* delete Bcc: headers entirely */

#define EF_RESPONSE 0x00000080L /* this is an error or return receipt */

#define EF_RESENT 0x00000100L /* this message is being forwarded */

#define EF_VRFYONLY 0x00000200L /* verify only (don't expand aliases) */

#define EF_WARNING 0x00000400L /* warning message has been sent */

#define EF_QUEUERUN 0x00000800L /* this envelope is from queue */

#define EF_GLOBALERRS 0x00001000L /* treat errors as global */

#define EF_PM_NOTIFY 0x00002000L /* send return mail to postmaster */

#define EF_METOO 0x00004000L /* send to me too */

#define EF_LOGSENDER 0x00008000L /* need to log the sender */

#define EF_NORECEIPT 0x00010000L /* suppress all return-receipts */

#define EF_HAS8BIT 0x00020000L /* at least one 8-bit char in body */

#define EF_NL_NOT_EOL 0x00040000L /* don't accept raw NL as EOLine */

#define EF_CRLF_NOT_EOL 0x00080000L /* don't accept CR-LF as EOLine */

#define EF_RET_PARAM 0x00100000L /* RCPT command had RET argument */

#define EF_HAS_DF 0x00200000L /* set when data file is instantiated */

#define EF_IS_MIME 0x00400000L /* really is a MIME message */

#define EF_DONT_MIME 0x00800000L /* never MIME this message */

#define EF_DISCARD 0x01000000L /* discard the message */

#define EF_TOOBIG 0x02000000L /* message is too big */

#define EF_SPLIT 0x04000000L /* envelope has been split */

#define EF_UNSAFE 0x08000000L /* unsafe: read from untrusted source */

#define EF_TOODEEP 0x10000000L /* message is nested too deep */

#define DLVR_NOTIFY 0x01

#define DLVR_RETURN 0x02

#define DLVR_TRACE 0x10

#define IS_DLVR_NOTIFY(e) (((e)->e_dlvr_flag & DLVR_NOTIFY) != 0)

#define IS_DLVR_RETURN(e) (((e)->e_dlvr_flag & DLVR_RETURN) != 0)

#define IS_DLVR_TRACE(e) (((e)->e_dlvr_flag & DLVR_TRACE) != 0)

#define IS_DLVR_BY(e) ((e)->e_dlvr_flag != 0)

#define BODYTYPE_NONE (0)

#define BODYTYPE_7BIT (1)

#define BODYTYPE_8BITMIME (2)

#define BODYTYPE_ILLEGAL (-1)

#define BODYTYPE_VALID(b) ((b) == BODYTYPE_7BIT || (b) == BODYTYPE_8BITMIME)

extern ENVELOPE BlankEnvelope;

extern void clearenvelope __P((ENVELOPE *, bool, SM_RPOOL_T *));

extern int dropenvelope __P((ENVELOPE *, bool, bool));

extern ENVELOPE *newenvelope __P((ENVELOPE *, ENVELOPE *, SM_RPOOL_T *));

extern void clrsessenvelope __P((ENVELOPE *));

extern void printenvflags __P((ENVELOPE *));

extern bool putbody __P((MCI *, ENVELOPE *, char *));

extern bool putheader __P((MCI *, HDR *, ENVELOPE *, int));

struct priority

{

char *pri_name; /* external name of priority */

int pri_val; /* internal value for same */

};

EXTERN int NumPriorities; /* pointer into Priorities */

EXTERN struct priority Priorities[MAXPRIORITIES];

struct rewrite

{

char **r_lhs; /* pattern match */

char **r_rhs; /* substitution value */

struct rewrite *r_next;/* next in chain */

int r_line; /* rule line in sendmail.cf */

};

#define MATCHZANY ((unsigned char)0220) /* match zero or more tokens */

#define MATCHANY ((unsigned char)0221) /* match one or more tokens */

#define MATCHONE ((unsigned char)0222) /* match exactly one token */

#define MATCHCLASS ((unsigned char)0223) /* match one token in a class */

#define MATCHNCLASS ((unsigned char)0224) /* match tokens not in class */

#define MATCHREPL ((unsigned char)0225) /* RHS replacement for above */

#define CANONNET ((unsigned char)0226) /* canonical net, next token */

#define CANONHOST ((unsigned char)0227) /* canonical host, next token */

#define CANONUSER ((unsigned char)0230) /* canonical user, next N tokens */

#define CALLSUBR ((unsigned char)0231) /* call another rewriting set */

#define CONDIF ((unsigned char)0232) /* conditional if-then */

#define CONDELSE ((unsigned char)0233) /* conditional else */

#define CONDFI ((unsigned char)0234) /* conditional fi */

#define HOSTBEGIN ((unsigned char)0235) /* hostname lookup begin */

#define HOSTEND ((unsigned char)0236) /* hostname lookup end */

#define LOOKUPBEGIN ((unsigned char)0205) /* generalized lookup begin */

#define LOOKUPEND ((unsigned char)0206) /* generalized lookup end */

#define MACROEXPAND ((unsigned char)0201) /* macro expansion */

#define MACRODEXPAND ((unsigned char)0202) /* deferred macro expansion */

#define MATCHZERO CANONHOST

#define MAXMATCH 9 /* max params per rewrite */

#define MAX_MAP_ARGS 10 /* max arguments for map */

struct metamac

{

char metaname; /* external code (after $) */

unsigned char metaval; /* internal code (as above) */

};

#define MID_OPMODE 0202 /* operation mode */

#if SM_HEAP_CHECK

extern void

macdefine_tagged __P((

MACROS_T *_mac,

ARGCLASS_T _vclass,

int _id,

char *_value,

char *_file,

int _line,

int _group));

# define macdefine(mac,c,id,v) \

macdefine_tagged(mac,c,id,v,__FILE__,__LINE__,sm_heap_group())

#else /* SM_HEAP_CHECK */

extern void

macdefine __P((

MACROS_T *_mac,

ARGCLASS_T _vclass,

int _id,

char *_value));

# define macdefine_tagged(mac,c,id,v,file,line,grp) macdefine(mac,c,id,v)

#endif /* SM_HEAP_CHECK */

extern void macset __P((MACROS_T *, int, char *));

#define macget(mac, i) (mac)->mac_table[i]

extern void expand __P((char *, char *, size_t, ENVELOPE *));

extern int macid_parse __P((char *, char **));

#define macid(name) macid_parse(name, NULL)

extern char *macname __P((int));

extern char *macvalue __P((int, ENVELOPE *));

extern int rscheck __P((char *, char *, char *, ENVELOPE *, int, int, char *, char *, ADDRESS *));

extern int rscap __P((char *, char *, char *, ENVELOPE *, char ***, char *, int));

extern void setclass __P((int, char *));

extern int strtorwset __P((char *, char **, int));

extern char *translate_dollars __P((char *, char *, int *));

extern bool wordinclass __P((char *, int));

#define NAMECANON struct _namecanon

{

short nc_errno; /* cached errno */

short nc_herrno; /* cached h_errno */

short nc_stat; /* cached exit status code */

short nc_flags; /* flag bits */

char *nc_cname; /* the canonical name */

time_t nc_exp; /* entry expires at */

};

#define NCF_VALID 0x0001 /* entry valid */

struct hostsig_t

{

char *hs_sig; /* hostsignature */

time_t hs_exp; /* entry expires at */

};

typedef struct hostsig_t HOSTSIG_T;

extern bool getcanonname __P((char *, int, bool, int *));

extern int getmxrr __P((char *, char **, unsigned short *, bool, int *, bool, int *));

extern char *hostsignature __P((MAILER *, char *));

extern int getfallbackmxrr __P((char *));

#define MAPCLASS struct _mapclass

#define MAP struct _map

#define MAXMAPACTIONS 5 /* size of map_actions array */

{

MAPCLASS *map_class; /* the class of this map */

MAPCLASS *map_orgclass; /* the original class of this map */

char *map_mname; /* name of this map */

long map_mflags; /* flags, see below */

char *map_file; /* the (nominal) filename */

ARBPTR_T map_db1; /* the open database ptr */

ARBPTR_T map_db2; /* an "extra" database pointer */

char *map_keycolnm; /* key column name */

char *map_valcolnm; /* value column name */

unsigned char map_keycolno; /* key column number */

unsigned char map_valcolno; /* value column number */

char map_coldelim; /* column delimiter */

char map_spacesub; /* spacesub */

char *map_app; /* to append to successful matches */

char *map_tapp; /* to append to "tempfail" matches */

char *map_domain; /* the (nominal) NIS domain */

char *map_rebuild; /* program to run to do auto-rebuild */

time_t map_mtime; /* last database modification time */

time_t map_timeout; /* timeout for map accesses */

int map_retry; /* # of retries for map accesses */

pid_t map_pid; /* PID of process which opened map */

int map_lockfd; /* auxiliary lock file descriptor */

short map_specificity; /* specificity of aliases */

MAP *map_stack[MAXMAPSTACK]; /* list for stacked maps */

short map_return[MAXMAPACTIONS]; /* return bitmaps for stacked maps */

};

#define MF_VALID 0x00000001 /* this entry is valid */

#define MF_INCLNULL 0x00000002 /* include null byte in key */

#define MF_OPTIONAL 0x00000004 /* don't complain if map not found */

#define MF_NOFOLDCASE 0x00000008 /* don't fold case in keys */

#define MF_MATCHONLY 0x00000010 /* don't use the map value */

#define MF_OPEN 0x00000020 /* this entry is open */

#define MF_WRITABLE 0x00000040 /* open for writing */

#define MF_ALIAS 0x00000080 /* this is an alias file */

#define MF_TRY0NULL 0x00000100 /* try with no null byte */

#define MF_TRY1NULL 0x00000200 /* try with the null byte */

#define MF_LOCKED 0x00000400 /* this map is currently locked */

#define MF_ALIASWAIT 0x00000800 /* alias map in aliaswait state */

#define MF_IMPL_HASH 0x00001000 /* implicit: underlying hash database */

#define MF_IMPL_NDBM 0x00002000 /* implicit: underlying NDBM database */

#define MF_APPEND 0x00008000 /* append new entry on rebuild */

#define MF_KEEPQUOTES 0x00010000 /* don't dequote key before lookup */

#define MF_NODEFER 0x00020000 /* don't defer if map lookup fails */

#define MF_REGEX_NOT 0x00040000 /* regular expression negation */

#define MF_DEFER 0x00080000 /* don't lookup map in defer mode */

#define MF_SINGLEMATCH 0x00100000 /* successful only if match one key */

#define MF_SINGLEDN 0x00200000 /* only one match, but multi values */

#define MF_FILECLASS 0x00400000 /* this is a file class map */

#define MF_OPENBOGUS 0x00800000 /* open failed, don't call map_close */

#define MF_CLOSING 0x01000000 /* map is being closed */

#define DYNOPENMAP(map) if (!bitset(MF_OPEN, (map)->map_mflags)) \

{ \

if (!openmap(map)) \

return NULL; \

}

#define MA_NOTFOUND 0 /* member map returned "not found" */

#define MA_UNAVAIL 1 /* member map is not available */

#define MA_TRYAGAIN 2 /* member map returns temp failure */

#define BIT_IS_MTP 0x01 /* temp.failure occurred */

#define BIT_ASK_MTP 0x02 /* do we care about MapTempFail? */

#define RESET_MAPTEMPFAIL MapTempFail = 0

#define INIT_MAPTEMPFAIL MapTempFail = BIT_ASK_MTP

#define SET_MAPTEMPFAIL MapTempFail |= BIT_IS_MTP

#define IS_MAPTEMPFAIL bitset(BIT_IS_MTP, MapTempFail)

#define ASK_MAPTEMPFAIL bitset(BIT_ASK_MTP, MapTempFail)

{

char *map_cname; /* name of this map class */

char *map_ext; /* extension for database file */

short map_cflags; /* flag bits, see below */

bool (*map_parse)__P((MAP *, char *));

/* argument parsing function */

char *(*map_lookup)__P((MAP *, char *, char **, int *));

/* lookup function */

void (*map_store)__P((MAP *, char *, char *));

/* store function */

bool (*map_open)__P((MAP *, int));

/* open function */

void (*map_close)__P((MAP *));

/* close function */

};

#define MCF_ALIASOK 0x0001 /* can be used for aliases */

#define MCF_ALIASONLY 0x0002 /* usable only for aliases */

#define MCF_REBUILDABLE 0x0004 /* can rebuild alias files */

#define MCF_OPTFILE 0x0008 /* file name is optional */

#define MCF_NOTPERSIST 0x0010 /* don't keep map open all the time */

extern void closemaps __P((bool));

extern bool impl_map_open __P((MAP *, int));

extern void initmaps __P((void));

extern MAP *makemapentry __P((char *));

extern void maplocaluser __P((ADDRESS *, ADDRESS **, int, ENVELOPE *));

extern char *map_rewrite __P((MAP *, const char *, size_t, char **));

#if NETINFO

extern char *ni_propval __P((char *, char *, char *, char *, int));

#endif /* NETINFO */

extern bool openmap __P((MAP *));

extern int udbexpand __P((ADDRESS *, ADDRESS **, int, ENVELOPE *));

#if USERDB

extern void _udbx_close __P((void));

extern char *udbsender __P((char *, SM_RPOOL_T *));

#endif /* USERDB */

#if LDAPMAP

struct lamvalues

{

char *lam_name; /* name of LDAP auth method */

int lam_code; /* numeric code */

};

struct ladvalues

{

char *lad_name; /* name of LDAP alias dereferencing method */

int lad_code; /* numeric code */

};

struct lssvalues

{

char *lss_name; /* name of LDAP search scope */

int lss_code; /* numeric code */

};

extern bool ldapmap_parseargs __P((MAP *, char *));

extern void ldapmap_set_defaults __P((char *));

#endif /* LDAPMAP */

#if PH_MAP

# include <phclient.h>

struct ph_map_struct

{

char *ph_servers; /* list of ph servers */

char *ph_field_list; /* list of fields to search for match */

PH *ph; /* PH server handle */

int ph_fastclose; /* send "quit" command on close */

time_t ph_timeout; /* timeout interval */

};

typedef struct ph_map_struct PH_MAP_STRUCT;

#endif /* PH_MAP */

#if NETINET || NETINET6 || NETUNIX || NETISO || NETNS || NETX25

union bigsockaddr

{

struct sockaddr sa; /* general version */

# if NETUNIX

struct sockaddr_un sunix; /* UNIX family */

# endif /* NETUNIX */

# if NETINET

struct sockaddr_in sin; /* INET family */

# endif /* NETINET */

# if NETINET6

struct sockaddr_in6 sin6; /* INET/IPv6 */

# endif /* NETINET6 */

# if NETISO

struct sockaddr_iso siso; /* ISO family */

# endif /* NETISO */

# if NETNS

struct sockaddr_ns sns; /* XNS family */

# endif /* NETNS */

# if NETX25

struct sockaddr_x25 sx25; /* X.25 family */

# endif /* NETX25 */

};

# define SOCKADDR union bigsockaddr

extern char *anynet_ntoa __P((SOCKADDR *));

# if NETINET6

extern char *anynet_ntop __P((struct in6_addr *, char *, size_t));

extern int anynet_pton __P((int, const char *, void *));

# endif /* NETINET6 */

extern char *hostnamebyanyaddr __P((SOCKADDR *));

extern char *validate_connection __P((SOCKADDR *, char *, ENVELOPE *));

# if SASL >= 20000

extern bool iptostring __P((SOCKADDR *, SOCKADDR_LEN_T, char *, unsigned));

# endif /* SASL >= 20000 */

#endif /* NETINET || NETINET6 || NETUNIX || NETISO || NETNS || NETX25 */

#define NO_PID ((pid_t) 0)

#ifndef PROC_LIST_SEG

# define PROC_LIST_SEG 32 /* number of pids to alloc at a time */

#endif /* ! PROC_LIST_SEG */

#define PROC_NONE 0

#define PROC_DAEMON 1

#define PROC_DAEMON_CHILD 2

#define PROC_QUEUE 3

#define PROC_QUEUE_CHILD 3

#define PROC_CONTROL 4

#define PROC_CONTROL_CHILD 5

extern void proc_list_add __P((pid_t, char *, int, int, int, SOCKADDR *));

extern void proc_list_clear __P((void));

extern void proc_list_display __P((SM_FILE_T *, char *));

extern void proc_list_drop __P((pid_t, int, int *));

extern void proc_list_probe __P((void));

extern void proc_list_set __P((pid_t, char *));

extern void proc_list_signal __P((int, int));

struct symtab

{

char *s_name; /* name to be entered */

short s_symtype; /* general type (see below) */

struct symtab *s_next; /* pointer to next in chain */

union

{

BITMAP256 sv_class; /* bit-map of word classes */

ADDRESS *sv_addr; /* pointer to address header */

MAILER *sv_mailer; /* pointer to mailer */

char *sv_alias; /* alias */

MAPCLASS sv_mapclass; /* mapping function class */

MAP sv_map; /* mapping function */

HOSTSIG_T sv_hostsig; /* host signature */

MCI sv_mci; /* mailer connection info */

NAMECANON sv_namecanon; /* canonical name cache */

int sv_macro; /* macro name => id mapping */

int sv_ruleset; /* ruleset index */

struct hdrinfo sv_header; /* header metainfo */

char *sv_service[MAXMAPSTACK]; /* service switch */

#if LDAPMAP

MAP *sv_lmap; /* Maps for LDAP connection */

#endif /* LDAPMAP */

#if SOCKETMAP

MAP *sv_socketmap; /* Maps for SOCKET connection */

#endif /* SOCKETMAP */

#if MILTER

struct milter *sv_milter; /* milter filter name */

#endif /* MILTER */

QUEUEGRP *sv_queue; /* pointer to queue */

} s_value;

};

typedef struct symtab STAB;

#define ST_UNDEF 0 /* undefined type */

#define ST_CLASS 1 /* class map */

#define ST_ADDRESS 2 /* an address in parsed format */

#define ST_MAILER 3 /* a mailer header */

#define ST_ALIAS 4 /* an alias */

#define ST_MAPCLASS 5 /* mapping function class */

#define ST_MAP 6 /* mapping function */

#define ST_HOSTSIG 7 /* host signature */

#define ST_NAMECANON 8 /* cached canonical name */

#define ST_MACRO 9 /* macro name to id mapping */

#define ST_RULESET 10 /* ruleset index */

#define ST_SERVICE 11 /* service switch entry */

#define ST_HEADER 12 /* special header flags */

#if LDAPMAP

# define ST_LMAP 13 /* List head of maps for LDAP connection */

#endif /* LDAPMAP */

#if MILTER

# define ST_MILTER 14 /* milter filter */

#endif /* MILTER */

#define ST_QUEUE 15 /* a queue entry */

#if SOCKETMAP

# define ST_SOCKETMAP 16 /* List head of maps for SOCKET connection */

#endif /* SOCKETMAP */

#define ST_MCI 17 /* mailer connection info (offset) */

#define s_class s_value.sv_class

#define s_address s_value.sv_addr

#define s_mailer s_value.sv_mailer

#define s_alias s_value.sv_alias

#define s_mci s_value.sv_mci

#define s_mapclass s_value.sv_mapclass

#define s_hostsig s_value.sv_hostsig

#define s_map s_value.sv_map

#define s_namecanon s_value.sv_namecanon

#define s_macro s_value.sv_macro

#define s_ruleset s_value.sv_ruleset

#define s_service s_value.sv_service

#define s_header s_value.sv_header

#if LDAPMAP

# define s_lmap s_value.sv_lmap

#endif /* LDAPMAP */

#if SOCKETMAP

# define s_socketmap s_value.sv_socketmap

#endif /* SOCKETMAP */

#if MILTER

# define s_milter s_value.sv_milter

#endif /* MILTER */

#define s_quegrp s_value.sv_queue

#define ST_FIND 0 /* find entry */

#define ST_ENTER 1 /* enter if not there */

extern STAB *stab __P((char *, int, int));

extern void stabapply __P((void (*)(STAB *, int), int));

#define MD_DELIVER 'm' /* be a mail sender */

#define MD_SMTP 's' /* run SMTP on standard input */

#define MD_ARPAFTP 'a' /* obsolete ARPANET mode (Grey Book) */

#define MD_DAEMON 'd' /* run as a daemon */

#define MD_FGDAEMON 'D' /* run daemon in foreground */

#define MD_LOCAL 'l' /* like daemon, but localhost only */

#define MD_VERIFY 'v' /* verify: don't collect or deliver */

#define MD_TEST 't' /* test mode: resolve addrs only */

#define MD_INITALIAS 'i' /* initialize alias database */

#define MD_PRINT 'p' /* print the queue */

#define MD_PRINTNQE 'P' /* print number of entries in queue */

#define MD_FREEZE 'z' /* freeze the configuration file */

#define MD_HOSTSTAT 'h' /* print persistent host stat info */

#define MD_PURGESTAT 'H' /* purge persistent host stat info */

#define MD_QUEUERUN 'q' /* queue run */

#define MD_CHECKCONFIG 'C' /* check configuration file */

#if _FFR_LOCAL_DAEMON

EXTERN bool LocalDaemon;

#else /* _FFR_LOCAL_DAEMON */

# define LocalDaemon false

#endif /* _FFR_LOCAL_DAEMON */

#define SM_DELIVER 'i' /* interactive delivery */

#define SM_FORK 'b' /* deliver in background */

#if _FFR_DM_ONE

#define SM_DM_ONE 'o' /* deliver first TA in background, then queue */

#endif /* _FFR_DM_ONE */

#define SM_QUEUE 'q' /* queue, don't deliver */

#define SM_DEFER 'd' /* defer map lookups as well as queue */

#define SM_VERIFY 'v' /* verify only (used internally) */

#define DM_NOTSET (-1) /* DeliveryMode (per daemon) option not set */

#define WILL_BE_QUEUED(m) ((m) == SM_QUEUE || (m) == SM_DEFER)

#define SM_DEFAULT '\0' /* unspecified, use SendMode */

extern void set_delivery_mode __P((int, ENVELOPE *));

#define EM_PRINT 'p' /* print errors */

#define EM_MAIL 'm' /* mail back errors */

#define EM_WRITE 'w' /* write back errors */

#define EM_BERKNET 'e' /* special berknet processing */

#define EM_QUIET 'q' /* don't print messages (stat only) */

#define MM_CVTMIME 0x0001 /* convert 8 to 7 bit MIME */

#define MM_PASS8BIT 0x0002 /* just send 8 bit data blind */

#define MM_MIME8BIT 0x0004 /* convert 8-bit data to MIME */

#define NRA_NO_ACTION 0 /* just leave it as is */

#define NRA_ADD_TO 1 /* add To: header */

#define NRA_ADD_APPARENTLY_TO 2 /* add Apparently-To: header */

#define NRA_ADD_BCC 3 /* add empty Bcc: header */

#define NRA_ADD_TO_UNDISCLOSED 4 /* add To: undisclosed:; header */

#define PXLF_NOTHINGSPECIAL 0 /* no special mapping */

#define PXLF_MAPFROM 0x0001 /* map From_ to >From_ */

#define PXLF_STRIP8BIT 0x0002 /* strip 8th bit */

#define PXLF_HEADER 0x0004 /* map newlines in headers */

#define PXLF_NOADDEOL 0x0008 /* if EOL not present, don't add one */

#define PXLF_STRIPMQUOTE 0x0010 /* strip METAQUOTEs */

#define PRIV_PUBLIC 0 /* what have I got to hide? */

#define PRIV_NEEDMAILHELO 0x00000001 /* insist on HELO for MAIL */

#define PRIV_NEEDEXPNHELO 0x00000002 /* insist on HELO for EXPN */

#define PRIV_NEEDVRFYHELO 0x00000004 /* insist on HELO for VRFY */

#define PRIV_NOEXPN 0x00000008 /* disallow EXPN command */

#define PRIV_NOVRFY 0x00000010 /* disallow VRFY command */

#define PRIV_AUTHWARNINGS 0x00000020 /* flag possible auth probs */

#define PRIV_NOVERB 0x00000040 /* disallow VERB command */

#define PRIV_RESTRICTMAILQ 0x00010000 /* restrict mailq command */

#define PRIV_RESTRICTQRUN 0x00020000 /* restrict queue run */

#define PRIV_RESTRICTEXPAND 0x00040000 /* restrict alias/forward expansion */

#define PRIV_NOETRN 0x00080000 /* disallow ETRN command */

#define PRIV_NOBODYRETN 0x00100000 /* do not return bodies on bounces */

#define PRIV_NORECEIPTS 0x00200000 /* disallow return receipts */

#define PRIV_NOACTUALRECIPIENT 0x00400000 /* no X-Actual-Recipient in DSNs */

#define PRIV_GOAWAY 0x0000ffff

struct prival

{

char *pv_name; /* name of privacy flag */

unsigned long pv_flag; /* numeric level */

};

EXTERN unsigned long PrivacyFlags; /* privacy flags */

#define RF_SENDERADDR 0x001 /* this is a sender address */

#define RF_HEADERADDR 0x002 /* this is a header address */

#define RF_CANONICAL 0x004 /* strip comment information */

#define RF_ADDDOMAIN 0x008 /* OK to do domain extension */

#define RF_COPYPARSE 0x010 /* copy parsed user & host */

#define RF_COPYPADDR 0x020 /* copy print address */

#define RF_COPYALL (RF_COPYPARSE|RF_COPYPADDR)

#define RF_COPYNONE 0

#define RF_RM_ADDR 0x040 /* address to be removed */

#define RSF_RMCOMM 0x0001 /* strip comments */

#define RSF_UNSTRUCTURED 0x0002 /* unstructured, ignore syntax errors */

#define RSF_COUNT 0x0004 /* count rejections (statistics)? */

#define M87F_OUTER 0 /* outer context */

#define M87F_NO8BIT 0x0001 /* can't have 8-bit in this section */

#define M87F_DIGEST 0x0002 /* processing multipart/digest */

#define M87F_NO8TO7 0x0004 /* don't do 8->7 bit conversions */

extern bool mime7to8 __P((MCI *, HDR *, ENVELOPE *));

extern int mime8to7 __P((MCI *, HDR *, ENVELOPE *, char **, int, int));

#define RTSF_NO_BODY 0 /* send headers only */

#define RTSF_SEND_BODY 0x0001 /* include body of message in return */

#define RTSF_PM_BOUNCE 0x0002 /* this is a postmaster bounce */

extern int returntosender __P((char *, ADDRESS *, int, ENVELOPE *));

typedef SM_INT32 mi_int32;

#if MILTER

# define SMFTO_WRITE 0 /* Timeout for sending information */

# define SMFTO_READ 1 /* Timeout waiting for a response */

# define SMFTO_EOM 2 /* Timeout for ACK/NAK to EOM */

# define SMFTO_CONNECT 3 /* Timeout for connect() */

# define SMFTO_NUM_TO 4 /* Total number of timeouts */

struct milter

{

char *mf_name; /* filter name */

BITMAP256 mf_flags; /* MTA flags */

mi_int32 mf_fvers; /* filter version */

mi_int32 mf_fflags; /* filter flags */

mi_int32 mf_pflags; /* protocol flags */

char *mf_conn; /* connection info */

int mf_sock; /* connected socket */

char mf_state; /* state of filter */

time_t mf_timeout[SMFTO_NUM_TO]; /* timeouts */

#if _FFR_MILTER_CHECK

/* for testing only */

mi_int32 mf_mta_prot_version;

mi_int32 mf_mta_prot_flags;

mi_int32 mf_mta_actions;

#endif /* _FFR_MILTER_CHECK */

};

struct milters

{

mi_int32 mis_flags; /* filter flags */

};

typedef struct milters milters_T;

#define MIS_FL_NONE 0x00000000 /* no requirements... */

#define MIS_FL_DEL_RCPT 0x00000001 /* can delete rcpt */

#define MIS_FL_REJ_RCPT 0x00000002 /* can reject rcpt */

# define SMF_REJECT 'R' /* Reject connection on filter fail */

# define SMF_TEMPFAIL 'T' /* tempfail connection on failure */

# define SMF_TEMPDROP '4' /* 421 connection on failure */

EXTERN struct milter *InputFilters[MAXFILTERS];

EXTERN char *InputFilterList;

EXTERN int MilterLogLevel;

extern void setup_daemon_milters __P((void));

#endif /* MILTER */

#define VENDOR_BERKELEY 1 /* Berkeley-native configuration file */

#define VENDOR_SUN 2 /* Sun-native configuration file */

#define VENDOR_HP 3 /* Hewlett-Packard specific config syntax */

#define VENDOR_IBM 4 /* IBM specific config syntax */

#define VENDOR_SENDMAIL 5 /* Sendmail, Inc. specific config syntax */

#define VENDOR_DEC 6 /* Compaq, DEC, Digital */

extern void vendor_daemon_setup __P((ENVELOPE *));

extern void vendor_set_uid __P((UID_T));

struct termescape

{

char *te_rv_on; /* turn reverse-video on */

char *te_under_on; /* turn underlining on */

char *te_normal; /* revert to normal output */

};

#define D_AUTHREQ 'a' /* authentication required */

#define D_BINDIF 'b' /* use if_addr for outgoing connection */

#define D_CANONREQ 'c' /* canonification required (cf) */

#define D_IFNHELO 'h' /* use if name for HELO */

#define D_FQMAIL 'f' /* fq sender address required (cf) */

#define D_FQRCPT 'r' /* fq recipient address required (cf) */

#define D_SMTPS 's' /* SMTP over SSL (smtps) */

#define D_UNQUALOK 'u' /* unqualified address is ok (cf) */

#define D_NOAUTH 'A' /* no AUTH */

#define D_NOCANON 'C' /* no canonification (cf) */

#define D_NOETRN 'E' /* no ETRN (MSA) */

#define D_NOTLS 'S' /* don't use STARTTLS */

#define D_ETRNONLY ((char)0x01) /* allow only ETRN (disk low) */

#define D_OPTIONAL 'O' /* optional socket */

#define D_DISABLE ((char)0x02) /* optional socket disabled */

#define D_ISSET ((char)0x03) /* this client struct is set */

#if STARTTLS

#define TLS_I_NONE 0x00000000 /* no requirements... */

#define TLS_I_CERT_EX 0x00000001 /* cert must exist */

#define TLS_I_CERT_UNR 0x00000002 /* cert must be g/o unreadable */

#define TLS_I_KEY_EX 0x00000004 /* key must exist */

#define TLS_I_KEY_UNR 0x00000008 /* key must be g/o unreadable */

#define TLS_I_CERTP_EX 0x00000010 /* CA cert path must exist */

#define TLS_I_CERTP_UNR 0x00000020 /* CA cert path must be g/o unreadable */

#define TLS_I_CERTF_EX 0x00000040 /* CA cert file must exist */

#define TLS_I_CERTF_UNR 0x00000080 /* CA cert file must be g/o unreadable */

#define TLS_I_RSA_TMP 0x00000100 /* RSA TMP must be generated */

#define TLS_I_USE_KEY 0x00000200 /* private key must usable */

#define TLS_I_USE_CERT 0x00000400 /* certificate must be usable */

#define TLS_I_VRFY_PATH 0x00000800 /* load verify path must succeed */

#define TLS_I_VRFY_LOC 0x00001000 /* load verify default must succeed */

#define TLS_I_CACHE 0x00002000 /* require cache */

#define TLS_I_TRY_DH 0x00004000 /* try DH certificate */

#define TLS_I_REQ_DH 0x00008000 /* require DH certificate */

#define TLS_I_DHPAR_EX 0x00010000 /* require DH parameters */

#define TLS_I_DHPAR_UNR 0x00020000 /* DH param. must be g/o unreadable */

#define TLS_I_DH512 0x00040000 /* generate 512bit DH param */

#define TLS_I_DH1024 0x00080000 /* generate 1024bit DH param */

#define TLS_I_DH2048 0x00100000 /* generate 2048bit DH param */

#define TLS_I_NO_VRFY 0x00200000 /* do not require authentication */

#define TLS_I_KEY_OUNR 0x00400000 /* Key must be other unreadable */

#define TLS_I_CRLF_EX 0x00800000 /* CRL file must exist */

#define TLS_I_CRLF_UNR 0x01000000 /* CRL file must be g/o unreadable */

#define TLS_I_SRV_CERT (TLS_I_CERT_EX | TLS_I_KEY_EX | \

TLS_I_KEY_UNR | TLS_I_KEY_OUNR | \

TLS_I_CERTP_EX | TLS_I_CERTF_EX | \

TLS_I_USE_KEY | TLS_I_USE_CERT | TLS_I_CACHE)

#define TLS_I_SRV (TLS_I_SRV_CERT | TLS_I_RSA_TMP | TLS_I_VRFY_PATH | \

TLS_I_VRFY_LOC | TLS_I_TRY_DH | TLS_I_DH512 | \

TLS_I_CACHE)

#define TLS_I_CLT (TLS_I_KEY_UNR | TLS_I_KEY_OUNR)

#define TLS_AUTH_OK 0

#define TLS_AUTH_NO 1

#define TLS_AUTH_FAIL (-1)

extern bool init_tls_library __P((void));

extern bool inittls __P((SSL_CTX **, unsigned long, long, bool, char *, char *, char *, char *, char *));

extern bool initclttls __P((bool));

extern void setclttls __P((bool));

extern bool initsrvtls __P((bool));

extern int tls_get_info __P((SSL *, bool, char *, MACROS_T *, bool));

extern int endtls __P((SSL *, char *));

extern void tlslogerr __P((const char *));

EXTERN char *CACertPath; /* path to CA certificates (dir. with hashes) */

EXTERN char *CACertFile; /* file with CA certificate */

EXTERN char *CltCertFile; /* file with client certificate */

EXTERN char *CltKeyFile; /* file with client private key */

# if _FFR_TLS_1

EXTERN char *CipherList; /* list of ciphers */

EXTERN char *DHParams5; /* file with DH parameters (512) */

# endif /* _FFR_TLS_1 */

EXTERN char *DHParams; /* file with DH parameters */

EXTERN char *RandFile; /* source of random data */

EXTERN char *SrvCertFile; /* file with server certificate */

EXTERN char *SrvKeyFile; /* file with server private key */

EXTERN char *CRLFile; /* file CRLs */

#if _FFR_CRLPATH

EXTERN char *CRLPath; /* path to CRLs (dir. with hashes) */

#endif /* _FFR_CRLPATH */

EXTERN unsigned long TLS_Srv_Opts; /* TLS server options */

EXTERN long Srv_SSL_Options, Clt_SSL_Options; /* SSL options */

#endif /* STARTTLS */

#define ANYQFL_LETTER '?'

#define QUARQF_LETTER 'h'

#define DATAFL_LETTER 'd'

#define XSCRPT_LETTER 'x'

#define NORMQF_LETTER 'q'

#define NEWQFL_LETTER 't'

# define TEMPQF_LETTER 'T'

# define LOSEQF_LETTER 'Q'