[exim.git] / src / src / structs.h

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) University of Cambridge 1995 - 2018 */
/* See the file NOTICE for conditions of use and distribution. */


/* Definitions of various structures. In addition, those that are visible for
the compilation of local_scan() are defined in local_scan.h. These are

  header_line
  optionlist
  recipient_item

For those declared here, we have to pre-declare some because of mutually
recursive definitions in the auths, routers, and transports blocks. */

struct address_item;
struct auth_info;
struct driver_info;
struct director_info;
struct smtp_inblock;
struct smtp_outblock;
struct transport_info;
struct router_info;

/* Growable-string */
typedef struct gstring {
  int	size;		/* Current capacity of string memory */
  int	ptr;		/* Offset at which to append further chars */
  uschar * s;		/* The string memory */
} gstring;

/* Structure for remembering macros for the configuration file */

typedef struct macro_item {
  struct  macro_item * next;
  BOOL     	command_line;
  unsigned	namelen;
  unsigned	replen;
  const uschar * name;
  const uschar * replacement;
} macro_item;

/* Structure for bit tables for debugging and logging */

typedef struct bit_table {
  uschar *name;
  int bit;
} bit_table;

/* Block for holding a uid and gid, possibly unset, and an initgroups flag. */

typedef struct ugid_block {
  uid_t   uid;
  gid_t   gid;
  BOOL    uid_set;
  BOOL    gid_set;
  BOOL    initgroups;
} ugid_block;

typedef enum {	CHUNKING_NOT_OFFERED = -1,
		CHUNKING_OFFERED,
		CHUNKING_ACTIVE,
		CHUNKING_LAST} chunking_state_t;

typedef enum {	TFO_NOT_USED = 0,
		TFO_ATTEMPTED_NODATA,
		TFO_ATTEMPTED_DATA,
		TFO_USED_NODATA,
		TFO_USED_DATA } tfo_state_t;

/* Structure for holding information about a host for use mainly by routers,
but also used when checking lists of hosts and when transporting. Looking up
host addresses is done using this structure. */

typedef enum {DS_UNK=-1, DS_NO, DS_YES} dnssec_status_t;

typedef struct host_item {
  struct host_item *next;
  const uschar *name;             /* Host name */
  const uschar *address;          /* IP address in text form */
  int     port;                   /* port value in host order (if SRV lookup) */
  int     mx;                     /* MX value if found via MX records */
  int     sort_key;               /* MX*1000 plus random "fraction" */
  int     status;                 /* Usable, unusable, or unknown */
  int     why;                    /* Why host is unusable */
  int     last_try;               /* Time of last try if known */
  dnssec_status_t dnssec;
} host_item;

/* Chain of rewrite rules, read from the rewrite config, or parsed from the
rewrite_headers field of a transport. */

typedef struct rewrite_rule {
  struct rewrite_rule *next;
  int     flags;
  uschar *key;
  uschar *replacement;
} rewrite_rule;

/* This structure is used to pass back configuration data from the smtp
transport to the outside world. It is used during callback processing. If ever
another remote transport were implemented, it could use the same structure. */

typedef struct transport_feedback {
  uschar *interface;
  uschar *port;
  uschar *protocol;
  uschar *hosts;
  uschar *helo_data;
  BOOL   hosts_override;
  BOOL   hosts_randomize;
  BOOL   gethostbyname;
  BOOL   qualify_single;
  BOOL   search_parents;
} transport_feedback;

/* Routers, transports, and authenticators have similar data blocks. Each
driver that is compiled into the code is represented by a xxx_info block; the
active drivers are represented by a chain of xxx_instance blocks. To make it
possible to use the same code for reading the configuration files for all
three, the layout of the start of the blocks is kept the same, and represented
by the generic structures driver_info and driver_instance. */

typedef struct driver_instance {
  struct driver_instance *next;
  uschar *name;                   /* Instance name */
  struct driver_info *info;       /* Points to info for this driver */
  void   *options_block;          /* Pointer to private options */
  uschar *driver_name;            /* All start with this generic option */
} driver_instance;

typedef struct driver_info {
  uschar *driver_name;            /* Name of driver */
  optionlist *options;            /* Table of private options names */
  int    *options_count;          /* -> Number of entries in table */
  void   *options_block;          /* Points to default private block */
  int     options_len;            /* Length of same in bytes */
  void  (*init)(                  /* Initialization entry point */
    struct driver_instance *);
} driver_info;


/* Structure for holding information about the configured transports. Some
of the generally accessible options are set from the configuration file; others
are set by transport initialization, since they can only be set for certain
transports. They need to be generally accessible, however, as they are used by
the main transport code. */

typedef struct transport_instance {
  struct transport_instance *next;
  uschar *name;                   /* Instance name */
  struct transport_info *info;    /* Info for this driver */
  void *options_block;            /* Pointer to private options */
  uschar *driver_name;            /* Must be first */
  int   (*setup)(                 /* Setup entry point */
    struct transport_instance *,
    struct address_item *,
    struct transport_feedback *,  /* For passing back config data */
    uid_t,                        /* The uid that will be used */
    gid_t,                        /* The gid that will be used */
    uschar **);                   /* For an error message */
                                  /**************************************/
  int     batch_max;              /* )                                  */
  uschar *batch_id;               /* )                                  */
  uschar *home_dir;               /* ) Used only for local transports   */
  uschar *current_dir;            /* )                                  */
                                  /**************************************/
  uschar *expand_multi_domain;    /* )                                  */
  BOOL    multi_domain;           /* )                                  */
  BOOL    overrides_hosts;        /* ) Used only for remote transports  */
  int     max_addresses;          /* )                                  */
  int     connection_max_messages;/* )                                  */
                                  /**************************************/
  BOOL    deliver_as_creator;     /* Used only by pipe at present */
  BOOL    disable_logging;        /* For very weird requirements */
  BOOL    initgroups;             /* Initialize groups when setting uid */
  BOOL    uid_set;                /* uid is set */
  BOOL    gid_set;                /* gid is set */
  uid_t   uid;
  gid_t   gid;
  uschar *expand_uid;             /* Variable uid */
  uschar *expand_gid;             /* Variable gid */
  uschar *warn_message;           /* Used only by appendfile at present */
  uschar *shadow;                 /* Name of shadow transport */
  uschar *shadow_condition;       /* Condition for running it */
  uschar *filter_command;         /* For on-the-fly-filtering */
  uschar *add_headers;            /* Add these headers */
  uschar *remove_headers;         /* Remove these headers */
  uschar *return_path;            /* Overriding (rewriting) return path */
  uschar *debug_string;           /* Debugging output */
  uschar *max_parallel;           /* Number of concurrent instances */
  uschar *message_size_limit;     /* Biggest message this transport handles */
  uschar *headers_rewrite;        /* Rules for rewriting headers */
  rewrite_rule *rewrite_rules;    /* Parsed rewriting rules */
  int     rewrite_existflags;     /* Bits showing which headers are rewritten */
  int     filter_timeout;         /* For transport filter timing */
  BOOL    body_only;              /* Deliver only the body */
  BOOL    delivery_date_add;      /* Add Delivery-Date header */
  BOOL    envelope_to_add;        /* Add Envelope-To header */
  BOOL    headers_only;           /* Deliver only the headers */
  BOOL    rcpt_include_affixes;   /* TRUE to retain affixes in RCPT commands */
  BOOL    return_path_add;        /* Add Return-Path header */
  BOOL    return_output;          /* TRUE if output should always be returned */
  BOOL    return_fail_output;     /* ditto, but only on failure */
  BOOL    log_output;             /* Similarly for logging */
  BOOL    log_fail_output;
  BOOL    log_defer_output;
  BOOL    retry_use_local_part;   /* Defaults true for local, false for remote */
#ifndef DISABLE_EVENT
  uschar  *event_action;          /* String to expand on notable events */
#endif
} transport_instance;


/* Structure for holding information about a type of transport. The first six
fields must match driver_info above. */

typedef struct transport_info {
  uschar *driver_name;            /* Driver name */
  optionlist *options;            /* Table of private options names */
  int    *options_count;          /* -> Number of entries in table */
  void   *options_block;          /* Points to default private block */
  int     options_len;            /* Length of same in bytes */
  void (*init)(                   /* Initialization function */
    struct transport_instance *);
/****/
  BOOL (*code)(                   /* Main entry point */
    transport_instance *,
    struct address_item *);
  void (*tidyup)(                 /* Tidyup function */
    struct transport_instance *);
  void  (*closedown)(             /* For closing down a passed channel */
    struct transport_instance *);
  BOOL    local;                  /* TRUE for local transports */
} transport_info;


/* smtp transport datachunk callback */

#define tc_reap_prev	BIT(0)	/* Flags: reap previous SMTP cmd responses */
#define tc_chunk_last	BIT(1)	/* annotate chunk SMTP cmd as LAST */

struct transport_context;
typedef int (*tpt_chunk_cmd_cb)(struct transport_context *, unsigned, unsigned);

/* Structure for information about a delivery-in-progress */

typedef struct transport_context {
  union {			/* discriminated by option topt_output_string */
    int			  fd;	/* file descriptor to write message to */
    gstring *		  msg;	/* allocated string with written message */
  } u;
  transport_instance	* tblock;		/* transport */
  struct address_item	* addr;
  uschar		* check_string;		/* string replacement */
  uschar		* escape_string;
  int		  	  options;		/* output processing topt_* */

  /* items below only used with option topt_use_bdat */
  tpt_chunk_cmd_cb	  chunk_cb;		/* per-datachunk callback */
  void			* smtp_context;
} transport_ctx;


typedef struct {
  uschar *request;
  uschar *require;
} dnssec_domains;

/* Structure for holding information about the configured routers. */

typedef struct router_instance {
  struct router_instance *next;
  uschar *name;
  struct router_info *info;
  void   *options_block;          /* Pointer to private options */
  uschar *driver_name;            /* Must be first */

  uschar *address_data;           /* Arbitrary data */
#ifdef EXPERIMENTAL_BRIGHTMAIL
  uschar *bmi_rule;               /* Brightmail AntiSpam rule checking */
#endif
  uschar *cannot_route_message;   /* Used when routing fails */
  uschar *condition;              /* General condition */
  uschar *current_directory;      /* For use during delivery */
  uschar *debug_string;           /* Debugging output */
  uschar *domains;                /* Specific domains */
  uschar *errors_to;              /* Errors address */
  uschar *expand_gid;             /* Expanded gid string */
  uschar *expand_uid;             /* Expanded uid string */
  uschar *expand_more;            /* Expanded more string */
  uschar *expand_unseen;          /* Expanded unseen string */
  uschar *extra_headers;          /* Additional headers */
  uschar *fallback_hosts;         /* For remote transports (text list) */
  uschar *home_directory;         /* For use during delivery */
  uschar *ignore_target_hosts;    /* Target hosts to ignore */
  uschar *local_parts;            /* Specific local parts */
  uschar *pass_router_name;       /* Router for passed address */
  uschar *prefix;                 /* Address prefix */
  uschar *redirect_router_name;   /* Router for generated address */
  uschar *remove_headers;         /* Removed headers */
  uschar *require_files;          /* File checks before router is run */
  uschar *router_home_directory;  /* For use while routing */
  uschar *self;                   /* Text option for handling self reference */
  uschar *senders;                /* Specific senders */
  uschar *suffix;                 /* Address suffix */
  uschar *translate_ip_address;   /* IP address translation fudgery */
  uschar *transport_name;         /* Transport name */

  BOOL    address_test;           /* Use this router when testing addresses */
#ifdef EXPERIMENTAL_BRIGHTMAIL
  BOOL    bmi_deliver_alternate;  /* TRUE => BMI said that message should be delivered to alternate location */
  BOOL    bmi_deliver_default;    /* TRUE => BMI said that message should be delivered to default location */
  BOOL    bmi_dont_deliver;       /* TRUE => BMI said that message should not be delivered at all */
#endif
  BOOL    expn;                   /* Use this router when processing EXPN */
  BOOL    caseful_local_part;     /* TRUE => don't lowercase */
  BOOL    check_local_user;       /* TRUE => check local user */
  BOOL    disable_logging;        /* For very weird requirements */
  BOOL    fail_verify_recipient;  /* Fail verify if recipient match this router */
  BOOL    fail_verify_sender;     /* Fail verify if sender match this router */
  BOOL    gid_set;                /* Flag to indicate gid is set */
  BOOL    initgroups;             /* TRUE if initgroups is required */
  BOOL    log_as_local;           /* TRUE logs as a local delivery */
  BOOL    more;                   /* If FALSE, do no more if this one fails */
  BOOL    pass_on_timeout;        /* Treat timeout DEFERs as fails */
  BOOL    prefix_optional;        /* Just what it says */
  BOOL    repeat_use;             /* If FALSE, skip if ancestor used it */
  BOOL    retry_use_local_part;   /* Just what it says */
  BOOL    same_domain_copy_routing; /* TRUE => copy routing for same domain */
  BOOL    self_rewrite;           /* TRUE to rewrite headers if making local */
  BOOL    suffix_optional;        /* As it says */
  BOOL    verify_only;            /* Skip this router if not verifying */
  BOOL    verify_recipient;       /* Use this router when verifying a recipient*/
  BOOL    verify_sender;          /* Use this router when verifying a sender */
  BOOL    uid_set;                /* Flag to indicate uid is set */
  BOOL    unseen;                 /* If TRUE carry on, even after success */
  BOOL    dsn_lasthop;            /* If TRUE, this router is a DSN endpoint */

  int     self_code;              /* Encoded version of "self" */
  uid_t   uid;                    /* Fixed uid value */
  gid_t   gid;                    /* Fixed gid value */

  host_item *fallback_hostlist;   /* For remote transport (block chain) */
  transport_instance *transport;  /* Transport block (when found) */
  struct router_instance *pass_router; /* Actual router for passed address */
  struct router_instance *redirect_router; /* Actual router for generated address */

  dnssec_domains dnssec;
} router_instance;


/* Structure for holding information about a type of router. The first six
fields must match driver_info above. */

typedef struct router_info {
  uschar *driver_name;
  optionlist *options;            /* Table of private options names */
  int    *options_count;          /* -> Number of entries in table */
  void   *options_block;          /* Points to default private block */
  int     options_len;            /* Length of same in bytes */
  void (*init)(                   /* Initialization function */
    struct router_instance *);
/****/
  int (*code)(                    /* Main entry point */
    router_instance *,
    struct address_item *,
    struct passwd *,
    int,
    struct address_item **,
    struct address_item **,
    struct address_item **,
    struct address_item **);
  void (*tidyup)(                 /* Tidyup function */
    struct router_instance *);
  int     ri_flags;               /* Descriptive flags */
} router_info;


/* Structure for holding information about a lookup type. */

#include "lookupapi.h"


/* Structure for holding information about the configured authentication
mechanisms */

typedef struct auth_instance {
  struct auth_instance *next;
  uschar *name;                   /* Exim instance name */
  struct auth_info *info;         /* Pointer to driver info block */
  void   *options_block;          /* Pointer to private options */
  uschar *driver_name;            /* Must be first */
  uschar *advertise_condition;    /* Are we going to advertise this?*/
  uschar *client_condition;       /* Should the client try this? */
  uschar *public_name;            /* Advertised name */
  uschar *set_id;                 /* String to set when server as authenticated id */
  uschar *set_client_id;          /* String to set when client as client_authenticated id */
  uschar *mail_auth_condition;    /* Condition for AUTH on MAIL command */
  uschar *server_debug_string;    /* Debugging output */
  uschar *server_condition;       /* Authorization condition */
  BOOL    client;                 /* TRUE if client option(s) set */
  BOOL    server;                 /* TRUE if server options(s) set */
  BOOL    advertised;             /* Set TRUE when advertised */
} auth_instance;


/* Structure for holding information about an authentication mechanism. The
first six fields must match driver_info above. */

typedef struct auth_info {
  uschar *driver_name;            /* e.g. "condition" */
  optionlist *options;            /* Table of private options names */
  int    *options_count;          /* -> Number of entries in table */
  void   *options_block;          /* Points to default private block */
  int     options_len;            /* Length of same in bytes */
  void (*init)(                   /* initialization function */
    struct auth_instance *);
/****/
  int (*servercode)(              /* server function */
    auth_instance *,              /* the instance data */
    uschar *);                    /* rest of AUTH command */
  int (*clientcode)(              /* client function */
    struct auth_instance *,
    void *,			  /* smtp conn, with socket, output and input buffers */
    int,                          /* command timeout */
    uschar *,                     /* buffer for reading response */
    int);                         /* sizeof buffer */
  void (*version_report)(         /* diagnostic version reporting */
    FILE *);                      /* I/O stream to print to */
} auth_info;


/* Structure for holding a single IP address and port; used for the chain of
addresses and ports for the local host. Make the char string large enough to
hold an IPv6 address. */

typedef struct ip_address_item {
  struct ip_address_item *next;
  int    port;
  BOOL   v6_include_v4;            /* Used in the daemon */
  uschar address[46];
  uschar * log;			   /* portion of "listening on" log line */
} ip_address_item;

/* Structure for chaining together arbitrary strings. */

typedef struct string_item {
  struct string_item *next;
  uschar *text;
} string_item;

/* Information about a soft delivery failure, for use when calculating
retry information. It's separate from the address block, because there
can be a chain of them for SMTP deliveries where multiple IP addresses
can be tried. */

typedef struct retry_item {
  struct retry_item *next;        /* for chaining */
  uschar *key;                    /* string identifying host/address/message */
  int     basic_errno;            /* error code for this destination */
  int     more_errno;             /* additional error information */
  uschar *message;                /* local error message */
  int     flags;                  /* see below */
} retry_item;

/* Retry data flags */

#define rf_delete   0x0001        /* retry info is to be deleted */
#define rf_host     0x0002        /* retry info is for a remote host */
#define rf_message  0x0004        /* retry info is for a host+message */

/* Information about a constructed message that is to be sent using the
autoreply transport. This is pointed to from the address block. */

typedef struct reply_item {
  uschar *from;                   /* ) */
  uschar *reply_to;               /* ) */
  uschar *to;                     /* ) */
  uschar *cc;                     /* ) specific header fields */
  uschar *bcc;                    /* ) */
  uschar *subject;                /* ) */
  uschar *headers;                /* misc other headers, concatenated */
  uschar *text;                   /* text string body */
  uschar *file;                   /* file body */
  BOOL    file_expand;            /* expand the body */
  int     expand_forbid;          /* expansion lockout flags */
  uschar *logfile;                /* file to keep a log in */
  uschar *oncelog;                /* file to keep records in for once only */
  time_t  once_repeat;            /* time to repeat "once only" */
  BOOL    return_message;         /* send back the original message */
} reply_item;


/* The address_item structure contains many fields which are used at various
times while delivering a message. Some are used only for remote deliveries;
some only for local. A particular set of fields is copied whenever a child
address is created. For convenience, we keep those fields in a separate
sub-structure so they can be copied in one go. This also means I won't forget
to edit the various copying places when new to-be-copied fields are added. */

typedef struct address_item_propagated {
  uschar *address_data;           /* arbitrary data to keep with the address */
  uschar *domain_data;            /* from "domains" lookup */
  uschar *localpart_data;         /* from "local_parts" lookup */
  uschar *errors_address;         /* where to send errors (NULL => sender) */
  header_line *extra_headers;     /* additional headers */
  uschar *remove_headers;         /* list of those to remove */

  #ifdef EXPERIMENTAL_SRS
  uschar *srs_sender;             /* Change return path when delivering */
  #endif
  BOOL    ignore_error:1;	  /* ignore delivery error */
  #ifdef SUPPORT_I18N
  BOOL    utf8_msg:1;		  /* requires SMTPUTF8 processing */
  BOOL	  utf8_downcvt:1;	  /* mandatory downconvert on delivery */
  BOOL	  utf8_downcvt_maybe:1;	  /* optional downconvert on delivery */
  #endif
} address_item_propagated;


/* The main address structure. Note that fields that are to be copied to
generated addresses should be put in the address_item_propagated structure (see
above) rather than directly into the address_item structure. */

typedef struct address_item {
  struct address_item *next;      /* for chaining addresses */
  struct address_item *parent;    /* parent address */
  struct address_item *first;     /* points to first after group delivery */
  struct address_item *dupof;     /* points to address this is a duplicate of */

  router_instance *start_router;  /* generated address starts here */
  router_instance *router;        /* the router that routed */
  transport_instance *transport;  /* the transport to use */

  host_item *host_list;           /* host data for the transport */
  host_item *host_used;           /* host that took delivery or failed hard */
  host_item *fallback_hosts;      /* to try if delivery defers */

  reply_item *reply;              /* data for autoreply */
  retry_item *retries;            /* chain of retry information */

  uschar *address;                /* address being delivered or routed */
  uschar *unique;                 /* used for disambiguating */
  uschar *cc_local_part;          /* caseful local part */
  uschar *lc_local_part;          /* lowercased local part */
  uschar *local_part;             /* points to cc or lc version */
  uschar *prefix;                 /* stripped prefix of local part */
  uschar *suffix;                 /* stripped suffix of local part */
  const uschar *domain;           /* working domain (lower cased) */

  uschar *address_retry_key;      /* retry key including full address */
  uschar *domain_retry_key;       /* retry key for domain only */

  uschar *current_dir;            /* current directory for transporting */
  uschar *home_dir;               /* home directory for transporting */
  uschar *message;                /* error message */
  uschar *user_message;           /* error message that can be sent over SMTP
                                     or quoted in bounce message */
  uschar *onetime_parent;         /* saved original parent for onetime */
  uschar **pipe_expandn;          /* numeric expansions for pipe from filter */
  uschar *return_filename;        /* name of return file */
  uschar *self_hostname;          /* after self=pass */
  uschar *shadow_message;         /* info about shadow transporting */

#ifdef SUPPORT_TLS
  uschar *cipher;                 /* Cipher used for transport */
  void   *ourcert;                /* Certificate offered to peer, binary */
  void   *peercert;               /* Certificate from peer, binary */
  uschar *peerdn;                 /* DN of server's certificate */
  int    ocsp;			  /* OCSP status of peer cert */
#endif

#ifdef EXPERIMENTAL_DSN_INFO
  const uschar *smtp_greeting;	  /* peer self-identification */
  const uschar *helo_response;	  /* peer message */
#endif

  uschar *authenticator;	  /* auth driver name used by transport */
  uschar *auth_id;		  /* auth "login" name used by transport */
  uschar *auth_sndr;		  /* AUTH arg to SMTP MAIL, used by transport */

  uschar *dsn_orcpt;              /* DSN orcpt value */
  int     dsn_flags;              /* DSN flags */
  int     dsn_aware;              /* DSN aware flag */

  uid_t   uid;                    /* uid for transporting */
  gid_t   gid;                    /* gid for transporting */

  				  /* flags */
  struct {
    BOOL af_allow_file:1;		/* allow file in generated address */
    BOOL af_allow_pipe:1;		/* allow pipe in generated address */
    BOOL af_allow_reply:1;		/* allow autoreply in generated address */
    BOOL af_dr_retry_exists:1;		/* router retry record exists */
    BOOL af_expand_pipe:1;		/* expand pipe arguments */
    BOOL af_file:1;			/* file delivery; always with pfr */
    BOOL af_gid_set:1;			/* gid field is set */
    BOOL af_home_expanded:1;		/* home_dir is already expanded */
    BOOL af_initgroups:1;		/* use initgroups() for local transporting */
    BOOL af_local_host_removed:1;	/* local host was backup */
    BOOL af_lt_retry_exists:1;		/* local transport retry exists */
    BOOL af_pfr:1;			/* pipe or file or reply delivery */
    BOOL af_retry_skipped:1;		/* true if retry caused some skipping */
    BOOL af_retry_timedout:1;		/* true if retry timed out */
    BOOL af_uid_set:1;			/* uid field is set */
    BOOL af_hide_child:1;		/* hide child in bounce/defer msgs */
    BOOL af_sverify_told:1;		/* sender verify failure notified */
    BOOL af_verify_pmfail:1;		/* verify failure was postmaster callout */
    BOOL af_verify_nsfail:1;		/* verify failure was null sender callout */
    BOOL af_homonym:1;			/* an ancestor has same address */
    BOOL af_verify_routed:1;		/* for cached sender verify: routed OK */
    BOOL af_verify_callout:1;		/* for cached sender verify: callout was specified */
    BOOL af_include_affixes:1;		/* delivered with affixes in RCPT */
    BOOL af_cert_verified:1;		/* delivered with verified TLS cert */
    BOOL af_pass_message:1;		/* pass message in bounces */
    BOOL af_bad_reply:1;		/* filter could not generate autoreply */
    BOOL af_tcp_fastopen_conn:1;	/* delivery connection used TCP Fast Open */
    BOOL af_tcp_fastopen:1;		/* delivery usefully used TCP Fast Open */
    BOOL af_tcp_fastopen_data:1;	/* delivery sent SMTP commands on TCP Fast Open */
    BOOL af_pipelining:1;		/* delivery used (traditional) pipelining */
#ifdef EXPERIMENTAL_PIPE_CONNECT
    BOOL af_early_pipe:1;		/* delivery used connect-time pipelining */
#endif
#ifndef DISABLE_PRDR
    BOOL af_prdr_used:1;		/* delivery used SMTP PRDR */
#endif
    BOOL af_chunking_used:1;		/* delivery used SMTP CHUNKING */
    BOOL af_force_command:1;		/* force_command in pipe transport */
#ifdef SUPPORT_DANE
    BOOL af_dane_verified:1;		/* TLS cert verify done with DANE */
#endif
#ifdef SUPPORT_I18N
    BOOL af_utf8_downcvt:1;		/* downconvert was done for delivery */
#endif
#ifdef EXPERIMENTAL_TLS_RESUME
    BOOL af_tls_resume:1;		/* TLS used a resumed session */
#endif
  } flags;

  unsigned int domain_cache[(MAX_NAMED_LIST * 2)/32];
  unsigned int localpart_cache[(MAX_NAMED_LIST * 2)/32];
  int     mode;                   /* mode for local transporting to a file */
  int     more_errno;             /* additional error information */
                                  /* (may need to hold a timestamp) */
  unsigned int delivery_usec;	  /* subsecond part of delivery time */

  short int basic_errno;          /* status after failure */
  unsigned short child_count;     /* number of child addresses */
  short int return_file;          /* fileno of return data file */
  short int special_action;       /* ( used when when deferred or failed */
                                  /* (  also  */
                                  /* ( contains = or - when successful SMTP delivered */
                                  /* (  also  */
                                  /* ( contains verify rc in sender verify cache */
  short int transport_return;     /* result of delivery attempt */
  address_item_propagated prop;   /* fields that are propagated to children */
} address_item;

/* The table of header names consists of items of this type */

typedef struct {
  uschar *name;
  int     len;
  BOOL    allow_resent;
  int     htype;
} header_name;

/* Chain of information about errors (e.g. bad addresses) */

typedef struct error_block {
  struct error_block *next;
  const uschar *text1;
  uschar *text2;
} error_block;

/* Chain of file names when processing the queue */

typedef struct queue_filename {
  struct queue_filename *next;
  uschar dir_uschar;
  uschar text[1];
} queue_filename;

/* Chain of items of retry information, read from the retry config. */

typedef struct retry_rule {
  struct retry_rule *next;
  int    rule;
  int    timeout;
  int    p1;
  int    p2;
} retry_rule;

typedef struct retry_config {
  struct retry_config *next;
  uschar *pattern;
  int     basic_errno;
  int     more_errno;
  uschar *senders;
  retry_rule *rules;
} retry_config;

/* Structure for each node in a tree, of which there are various kinds */

typedef struct tree_node {
  struct tree_node *left;         /* pointer to left child */
  struct tree_node *right;        /* pointer to right child */
  union
    {
    void  *ptr;                   /* pointer to data */
    int val;                      /* or integer data */
    } data;
  uschar  balance;                /* balancing factor */
  uschar  name[1];                /* node name - variable length */
} tree_node;

/* Structure for holding time-limited data such as DNS returns.
We use this rather than extending tree_node to avoid wasting
space for most tree use (variables...) at the cost of complexity
for the lookups cache */

typedef struct expiring_data {
  time_t expiry;		  /* if nonzero, data invalid after this time */
  void   *ptr;			  /* pointer to data */
} expiring_data;

/* Structure for holding the handle and the cached last lookup for searches.
This block is pointed to by the tree entry for the file. The file can get
closed if too many are opened at once. There is a LRU chain for deciding which
to close. */

typedef struct search_cache {
  void   *handle;                 /* lookup handle, or NULL if closed */
  int search_type;                /* search type */
  tree_node *up;                  /* LRU up pointer */
  tree_node *down;                /* LRU down pointer */
  tree_node *item_cache;          /* tree of cached results */
} search_cache;

/* Structure for holding a partially decoded DNS record; the name has been
uncompressed, but the data pointer is into the raw data. */

typedef struct {
  uschar        name[DNS_MAXNAME];      /* domain name */
  int           type;                   /* record type */
  unsigned short ttl;		        /* time-to-live, seconds */
  int           size;                   /* size of data */
  const uschar *data;                   /* pointer to data */
} dns_record;

/* Structure for holding the result of a DNS query.  A touch over
64k big, so take care to release as soon as possible. */

typedef struct {
  int     answerlen;              /* length of the answer */
  uschar  answer[NS_MAXMSG];      /* the answer itself */
} dns_answer;

/* Structure for holding the intermediate data while scanning a DNS answer
block. */

typedef struct {
  int            rrcount;         /* count of RRs in the answer */
  const uschar *aptr;             /* pointer in the answer while scanning */
  dns_record     srr;             /* data from current record in scan */
} dns_scan;

/* Structure for holding a chain of IP addresses that are extracted from
an A, AAAA, or A6 record. For the first two, there is only ever one address,
but the chaining feature of A6 allows for several addresses to be realized from
a single initial A6 record. The structure defines the address field of length
1. In use, a suitable sized block is obtained to hold the complete textual
address. */

typedef struct dns_address {
  struct dns_address *next;
  uschar  address[1];
} dns_address;

/* Structure used for holding intermediate data during MD5 computations. */

typedef struct md5 {
  unsigned int length;
  unsigned int abcd[4];
  }
md5;

/* Structure used for holding intermediate data during SHA-1 computations. */

typedef struct sha1 {
  unsigned int H[5];
  unsigned int length;
} sha1;

/* Information for making an smtp connection */
typedef struct {
  transport_instance *  tblock;
  void *		ob;	/* smtp_transport_options_block * */
  host_item *           host;
  int                   host_af;
  uschar *              interface;

#if defined(SUPPORT_TLS) && defined(SUPPORT_DANE)
  BOOL dane:1;			/* connection must do dane */
  dns_answer		tlsa_dnsa;
#endif
} smtp_connect_args;

/* A client-initiated connection. If TLS, the second element is non-NULL */
typedef struct {
  int	sock;
  void * tls_ctx;
} client_conn_ctx;


/* Structure used to hold incoming packets of SMTP responses for a specific
socket. The packets which may contain multiple lines (and in some cases,
multiple responses). */

typedef struct smtp_inblock {
  client_conn_ctx * cctx;	  /* the connection */
  int     buffersize;             /* the size of the buffer */
  uschar *ptr;                    /* current position in the buffer */
  uschar *ptrend;                 /* end of data in the buffer */
  uschar *buffer;                 /* the buffer itself */
} smtp_inblock;

/* Structure used to hold buffered outgoing packets of SMTP commands for a
specific socket. The packets which may contain multiple lines when pipelining
is in use. */

typedef struct smtp_outblock {
  client_conn_ctx * cctx;	  /* the connection */
  int     cmd_count;              /* count of buffered commands */
  int     buffersize;             /* the size of the buffer */
  BOOL    authenticating;         /* TRUE when authenticating */
  uschar *ptr;                    /* current position in the buffer */
  uschar *buffer;                 /* the buffer itself */

  smtp_connect_args * conn_args;  /* to make connection, if not yet made */
} smtp_outblock;

/* Structure to hold information about the source of redirection information */

typedef struct redirect_block {
  uschar *string;                 /* file name or string */
  uid_t  *owners;                 /* allowed file owners */
  gid_t  *owngroups;              /* allowed file groups */
  struct passwd *pw;              /* possible owner if not NULL */
  int     modemask;               /* forbidden bits */
  BOOL    isfile;                 /* TRUE if string is a file name */
  BOOL    check_owner;            /* TRUE, FALSE, or TRUE_UNSET */
  BOOL    check_group;            /* TRUE, FALSE, or TRUE_UNSET */
} redirect_block;

/* Structure for passing arguments to check_host() */

typedef struct check_host_block {
  const uschar *host_name;
  const uschar *host_address;
  const uschar *host_ipv4;
  BOOL   negative;
} check_host_block;

/* Structure for remembering lookup data when caching the result of
a lookup in a named list. */

typedef struct namedlist_cacheblock {
  struct namedlist_cacheblock *next;
  uschar *key;
  uschar *data;
} namedlist_cacheblock;

/* Structure for holding data for an entry in a named list */

typedef struct namedlist_block {
  const uschar *string;              /* the list string */
  namedlist_cacheblock *cache_data;  /* cached domain_data or localpart_data */
  int number;                        /* the number of the list for caching */
} namedlist_block;

/* Structures for Access Control Lists */

typedef struct acl_condition_block {
  struct acl_condition_block *	next;
  uschar *			arg;
  int				type;
  union {
    BOOL	negated;
    uschar *	varname;
  } u;
} acl_condition_block;

typedef struct acl_block {
  struct acl_block *	next;
  acl_condition_block *	condition;
  int			verb;
  int			srcline;
  const uschar *	srcfile;
} acl_block;

/* smtp transport calc outbound_ip */
typedef BOOL (*oicf) (uschar *message_id, void *data);

/* DKIM information for transport */
struct ob_dkim {
  uschar *dkim_domain;
  uschar *dkim_identity;
  uschar *dkim_private_key;
  uschar *dkim_selector;
  uschar *dkim_canon;
  uschar *dkim_sign_headers;
  uschar *dkim_strict;
  uschar *dkim_hash;
  uschar *dkim_timestamps;
  BOOL    dot_stuffed;
  BOOL    force_bodyhash;
#ifdef EXPERIMENTAL_ARC
  uschar *arc_signspec;
#endif
};

/* End of structs.h */