src/src/structs.h

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2024 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10 #ifndef STRUCTS_H
  11 #define STRUCTS_H
  12
  13 /* Definitions of various structures. In addition, those that are visible for
  14 the compilation of local_scan() are defined in local_scan.h. These are
  15
  16   header_line
  17   optionlist
  18   recipient_item
  19
  20 For those declared here, we have to pre-declare some because of mutually
  21 recursive definitions in the auths, routers, and transports blocks. */
  22
  23 struct address_item;
  24 struct auth_info;
  25 struct driver_info;
  26 struct director_info;
  27 struct smtp_inblock;
  28 struct smtp_outblock;
  29 struct transport_info;
  30 struct router_info;
  31
  32 /* Growable-string */
  33 typedef struct gstring {
  34   int   size;           /* Current capacity of string memory */
  35   int   ptr;            /* Offset at which to append further chars */
  36   uschar * s;           /* The string memory */
  37 } gstring;
  38
  39 /* Structure for remembering macros for the configuration file */
  40
  41 typedef struct macro_item {
  42   struct  macro_item * next;
  43   BOOL          command_line;
  44   unsigned      namelen;
  45   unsigned      replen;
  46   const uschar * name;
  47   const uschar * replacement;
  48 } macro_item;
  49
  50 /* Structure for bit tables for debugging and logging */
  51
  52 typedef struct bit_table {
  53   uschar *name;
  54   int bit;
  55 } bit_table;
  56
  57 /* Block for holding a uid and gid, possibly unset, and an initgroups flag. */
  58
  59 typedef struct ugid_block {
  60   uid_t   uid;
  61   gid_t   gid;
  62   BOOL    uid_set;
  63   BOOL    gid_set;
  64   BOOL    initgroups;
  65 } ugid_block;
  66
  67 typedef enum {  CHUNKING_NOT_OFFERED = -1,
  68                 CHUNKING_OFFERED,
  69                 CHUNKING_ACTIVE,
  70                 CHUNKING_LAST} chunking_state_t;
  71
  72 typedef enum {  TFO_NOT_USED = 0,
  73                 TFO_ATTEMPTED_NODATA,
  74                 TFO_ATTEMPTED_DATA,
  75                 TFO_USED_NODATA,
  76                 TFO_USED_DATA } tfo_state_t;
  77
  78 /* Structure for holding information about a host for use mainly by routers,
  79 but also used when checking lists of hosts and when transporting. Looking up
  80 host addresses is done using this structure. */
  81
  82 typedef enum {DS_UNK=-1, DS_NO, DS_YES} dnssec_status_t;
  83
  84 typedef struct host_item {
  85   struct host_item *next;
  86   const uschar *name;           /* Host name */
  87 #ifndef DISABLE_TLS
  88   const uschar *certname;       /* Name used for certificate checks */
  89 #endif
  90   const uschar *address;        /* IP address in text form */
  91   int     port;                 /* port value in host order (if SRV lookup) */
  92   int     mx;                   /* MX value if found via MX records */
  93   int     sort_key;             /* MX*1000 plus random "fraction" */
  94   int     status;               /* Usable, unusable, or unknown */
  95   int     why;                  /* Why host is unusable */
  96   int     last_try;             /* Time of last try if known */
  97   dnssec_status_t dnssec;
  98 } host_item;
  99
 100 /* Chain of rewrite rules, read from the rewrite config, or parsed from the
 101 rewrite_headers field of a transport. */
 102
 103 typedef struct rewrite_rule {
 104   struct rewrite_rule *next;
 105   int     flags;
 106   uschar *key;
 107   uschar *replacement;
 108 } rewrite_rule;
 109
 110 /* This structure is used to pass back configuration data from the smtp
 111 transport to the outside world. It is used during callback processing. If ever
 112 another remote transport were implemented, it could use the same structure. */
 113
 114 typedef struct transport_feedback {
 115   uschar *interface;
 116   uschar *port;
 117   uschar *protocol;
 118   uschar *hosts;
 119   uschar *helo_data;
 120   BOOL   hosts_override;
 121   BOOL   hosts_randomize;
 122   BOOL   gethostbyname;
 123   BOOL   qualify_single;
 124   BOOL   search_parents;
 125 } transport_feedback;
 126
 127 /* Routers, transports, and authenticators have similar data blocks. Each
 128 driver that is compiled into the code is represented by a xxx_info block; the
 129 active drivers are represented by a chain of xxx_instance blocks. To make it
 130 possible to use the same code for reading the configuration files for all
 131 three, the layout of the start of the blocks is kept the same, and represented
 132 by the generic structures driver_info and driver_instance. */
 133
 134 typedef struct driver_instance {
 135   void   *next;
 136   uschar *name;                   /* Instance name */
 137   void   *info;                   /* Points to info for this driver */
 138   void   *options_block;          /* Pointer to private options */
 139
 140   uschar *driver_name;            /* All start with this generic option */
 141   const uschar *srcfile;          /* and config source info for errors */
 142   int     srcline;
 143 } driver_instance;
 144
 145 typedef struct driver_info {
 146   struct driver_info * next;
 147   uschar *driver_name;            /* Name of driver */
 148
 149   optionlist *options;            /* Table of private options names */
 150   int    *options_count;          /* -> Number of entries in table */
 151   void   *options_block;          /* Points to default private block */
 152   int     options_len;            /* Length of same in bytes */
 153   void  (*init)(                  /* Initialization entry point */
 154           struct driver_instance *);
 155   uint    dyn_magic;              /* Magic num if dynamic, else zero */
 156 } driver_info;
 157
 158 /* Values for dyn_magic.  Encode types and api version. */
 159 #define ROUTER_MAGIC    0x52544d31      /* RTM1 */
 160 #define TRANSPORT_MAGIC 0x54504d31      /* TPM1 */
 161 #define AUTH_MAGIC      0x65554d31      /* AUM1 */
 162
 163 typedef struct {
 164   uint          magic;
 165   uschar *      class;
 166 } driver_magics;
 167
 168
 169 /* Structure for holding information about the configured transports. Some
 170 of the generally accessible options are set from the configuration file; others
 171 are set by transport initialization, since they can only be set for certain
 172 transports. They need to be generally accessible, however, as they are used by
 173 the main transport code. */
 174
 175 typedef struct transport_instance {
 176   driver_instance drinst;
 177
 178   int   (*setup)(                 /* Setup entry point */
 179     struct transport_instance *,
 180     struct address_item *,
 181     struct transport_feedback *,  /* For passing back config data */
 182     uid_t,                        /* The uid that will be used */
 183     gid_t,                        /* The gid that will be used */
 184     uschar **);                   /* For an error message */
 185                                   /**************************************/
 186   int     batch_max;              /* )                                  */
 187   uschar *batch_id;               /* )                                  */
 188   uschar *home_dir;               /* ) Used only for local transports   */
 189   uschar *current_dir;            /* )                                  */
 190                                   /**************************************/
 191   uschar *expand_multi_domain;    /* )                                  */
 192   BOOL    multi_domain;           /* )                                  */
 193   BOOL    overrides_hosts;        /* ) Used only for remote transports  */
 194   uschar *max_addresses;          /* )                                  */
 195   int     connection_max_messages;/* )                                  */
 196                                   /**************************************/
 197   BOOL    deliver_as_creator;     /* Used only by pipe at present */
 198   BOOL    disable_logging;        /* For very weird requirements */
 199   BOOL    initgroups;             /* Initialize groups when setting uid */
 200   BOOL    uid_set;                /* uid is set */
 201   BOOL    gid_set;                /* gid is set */
 202   uid_t   uid;
 203   gid_t   gid;
 204   uschar *expand_uid;             /* Variable uid */
 205   uschar *expand_gid;             /* Variable gid */
 206   uschar *warn_message;           /* Used only by appendfile at present */
 207   uschar *shadow;                 /* Name of shadow transport */
 208   uschar *shadow_condition;       /* Condition for running it */
 209   uschar *filter_command;         /* For on-the-fly-filtering */
 210   uschar *add_headers;            /* Add these headers */
 211   uschar *remove_headers;         /* Remove these headers */
 212   uschar *return_path;            /* Overriding (rewriting) return path */
 213   uschar *debug_string;           /* Debugging output */
 214   uschar *max_parallel;           /* Number of concurrent instances */
 215   uschar *message_size_limit;     /* Biggest message this transport handles */
 216   uschar *headers_rewrite;        /* Rules for rewriting headers */
 217   rewrite_rule *rewrite_rules;    /* Parsed rewriting rules */
 218   int     rewrite_existflags;     /* Bits showing which headers are rewritten */
 219   int     filter_timeout;         /* For transport filter timing */
 220   BOOL    body_only;              /* Deliver only the body */
 221   BOOL    delivery_date_add;      /* Add Delivery-Date header */
 222   BOOL    envelope_to_add;        /* Add Envelope-To header */
 223   BOOL    headers_only;           /* Deliver only the headers */
 224   BOOL    rcpt_include_affixes;   /* TRUE to retain affixes in RCPT commands */
 225   BOOL    return_path_add;        /* Add Return-Path header */
 226   BOOL    return_output;          /* TRUE if output should always be returned */
 227   BOOL    return_fail_output;     /* ditto, but only on failure */
 228   BOOL    log_output;             /* Similarly for logging */
 229   BOOL    log_fail_output;
 230   BOOL    log_defer_output;
 231   BOOL    retry_use_local_part;   /* Defaults true for local, false for remote */
 232 #ifndef DISABLE_EVENT
 233   uschar  *event_action;          /* String to expand on notable events */
 234 #endif
 235 } transport_instance;
 236
 237
 238 /* Structure for holding information about a type of transport.  The first
 239 element must be a struct driver_info, to match auths and routers. */
 240
 241 typedef struct transport_info {
 242   driver_info drinfo;
 243
 244   BOOL (*code)(                   /* Main entry point */
 245     transport_instance *,
 246     struct address_item *);
 247   void (*tidyup)(                 /* Tidyup function */
 248     struct transport_instance *);
 249   void  (*closedown)(             /* For closing down a passed channel */
 250     struct transport_instance *);
 251   BOOL    local;                  /* TRUE for local transports */
 252 } transport_info;
 253
 254
 255 /* smtp transport datachunk callback */
 256
 257 #define tc_reap_prev    BIT(0)  /* Flags: reap previous SMTP cmd responses */
 258 #define tc_chunk_last   BIT(1)  /* annotate chunk SMTP cmd as LAST */
 259
 260 struct transport_context;
 261 typedef int (*tpt_chunk_cmd_cb)(struct transport_context *, unsigned, unsigned);
 262
 263 /* Structure for information about a delivery-in-progress */
 264
 265 typedef struct transport_context {
 266   union {                       /* discriminated by option topt_output_string */
 267     int                   fd;   /* file descriptor to write message to */
 268     gstring *             msg;  /* allocated string with written message */
 269   } u;
 270   transport_instance    * tblock;               /* transport */
 271   struct address_item   * addr;
 272   uschar                * check_string;         /* string replacement */
 273   uschar                * escape_string;
 274   int                     options;              /* output processing topt_* */
 275
 276   /* items below only used with option topt_use_bdat */
 277   tpt_chunk_cmd_cb        chunk_cb;             /* per-datachunk callback */
 278   void                  * smtp_context;
 279 } transport_ctx;
 280
 281
 282
 283 typedef struct {
 284   uschar *request;
 285   uschar *require;
 286 } dnssec_domains;
 287
 288 /* Structure for holding information about the configured routers. */
 289
 290 typedef struct router_instance {
 291   driver_instance drinst;
 292
 293   uschar *address_data;           /* Arbitrary data */
 294 #ifdef EXPERIMENTAL_BRIGHTMAIL
 295   uschar *bmi_rule;               /* Brightmail AntiSpam rule checking */
 296 #endif
 297   uschar *cannot_route_message;   /* Used when routing fails */
 298   uschar *condition;              /* General condition */
 299   uschar *current_directory;      /* For use during delivery */
 300   uschar *debug_string;           /* Debugging output */
 301   uschar *domains;                /* Specific domains */
 302   uschar *errors_to;              /* Errors address */
 303   uschar *expand_gid;             /* Expanded gid string */
 304   uschar *expand_uid;             /* Expanded uid string */
 305   uschar *expand_more;            /* Expanded more string */
 306   uschar *expand_unseen;          /* Expanded unseen string */
 307   uschar *extra_headers;          /* Additional headers */
 308   uschar *fallback_hosts;         /* For remote transports (text list) */
 309   uschar *home_directory;         /* For use during delivery */
 310   uschar *ignore_target_hosts;    /* Target hosts to ignore */
 311   uschar *local_parts;            /* Specific local parts */
 312   uschar *pass_router_name;       /* Router for passed address */
 313   uschar *prefix;                 /* Address prefix */
 314   uschar *redirect_router_name;   /* Router for generated address */
 315   uschar *remove_headers;         /* Removed headers */
 316   uschar *require_files;          /* File checks before router is run */
 317   uschar *router_home_directory;  /* For use while routing */
 318   uschar *self;                   /* Text option for handling self reference */
 319   uschar *senders;                /* Specific senders */
 320   uschar *suffix;                 /* Address suffix */
 321   uschar *translate_ip_address;   /* IP address translation fudgery */
 322   uschar *transport_name;         /* Transport name */
 323
 324   BOOL    address_test;           /* Use this router when testing addresses */
 325 #ifdef EXPERIMENTAL_BRIGHTMAIL
 326   BOOL    bmi_deliver_alternate;  /* TRUE => BMI said that message should be delivered to alternate location */
 327   BOOL    bmi_deliver_default;    /* TRUE => BMI said that message should be delivered to default location */
 328   BOOL    bmi_dont_deliver;       /* TRUE => BMI said that message should not be delivered at all */
 329 #endif
 330   BOOL    expn;                   /* Use this router when processing EXPN */
 331   BOOL    caseful_local_part;     /* TRUE => don't lowercase */
 332   BOOL    check_local_user;       /* TRUE => check local user */
 333   BOOL    disable_logging;        /* For very weird requirements */
 334   BOOL    fail_verify_recipient;  /* Fail verify if recipient match this router */
 335   BOOL    fail_verify_sender;     /* Fail verify if sender match this router */
 336   BOOL    gid_set;                /* Flag to indicate gid is set */
 337   BOOL    initgroups;             /* TRUE if initgroups is required */
 338   BOOL    log_as_local;           /* TRUE logs as a local delivery */
 339   BOOL    more;                   /* If FALSE, do no more if this one fails */
 340   BOOL    pass_on_timeout;        /* Treat timeout DEFERs as fails */
 341   BOOL    prefix_optional;        /* Just what it says */
 342   BOOL    repeat_use;             /* If FALSE, skip if ancestor used it */
 343   BOOL    retry_use_local_part;   /* Just what it says */
 344   BOOL    same_domain_copy_routing; /* TRUE => copy routing for same domain */
 345   BOOL    self_rewrite;           /* TRUE to rewrite headers if making local */
 346   uschar *set;                    /* Variable = value to set; list */
 347   BOOL    suffix_optional;        /* As it says */
 348   BOOL    verify_only;            /* Skip this router if not verifying */
 349   BOOL    verify_recipient;       /* Use this router when verifying a recipient*/
 350   BOOL    verify_sender;          /* Use this router when verifying a sender */
 351   BOOL    uid_set;                /* Flag to indicate uid is set */
 352   BOOL    unseen;                 /* If TRUE carry on, even after success */
 353   BOOL    dsn_lasthop;            /* If TRUE, this router is a DSN endpoint */
 354
 355   int     self_code;              /* Encoded version of "self" */
 356   uid_t   uid;                    /* Fixed uid value */
 357   gid_t   gid;                    /* Fixed gid value */
 358
 359   host_item *fallback_hostlist;   /* For remote transport (block chain) */
 360   transport_instance *transport;  /* Transport block (when found) */
 361   struct router_instance *pass_router; /* Actual router for passed address */
 362   struct router_instance *redirect_router; /* Actual router for generated address */
 363
 364   dnssec_domains dnssec;
 365 } router_instance;
 366
 367
 368 /* Structure for holding information about a type of router.  The first element
 369 must be a struct driver_info, to match auths and transports. */
 370
 371 typedef struct router_info {
 372   driver_info drinfo;
 373
 374   int (*code)(                    /* Main entry point */
 375     router_instance *,
 376     struct address_item *,
 377     struct passwd *,
 378     int,
 379     struct address_item **,
 380     struct address_item **,
 381     struct address_item **,
 382     struct address_item **);
 383   void (*tidyup)(                 /* Tidyup function */
 384     struct router_instance *);
 385   int     ri_flags;               /* Descriptive flags */
 386 } router_info;
 387
 388
 389 /* Structure for holding information about a lookup type. */
 390
 391 #include "lookupapi.h"
 392
 393
 394 /* Structure for holding information about the configured authentication
 395 mechanisms */
 396
 397 typedef struct auth_instance {
 398   driver_instance drinst;
 399
 400   uschar *advertise_condition;    /* Are we going to advertise this?*/
 401   uschar *client_condition;       /* Should the client try this? */
 402   uschar *public_name;            /* Advertised name */
 403   uschar *set_id;                 /* String to set when server as authenticated id */
 404   uschar *set_client_id;          /* String to set when client as client_authenticated id */
 405   uschar *mail_auth_condition;    /* Condition for AUTH on MAIL command */
 406   uschar *server_debug_string;    /* Debugging output */
 407   uschar *server_condition;       /* Authorization condition */
 408   BOOL    client;                 /* TRUE if client option(s) set */
 409   BOOL    server;                 /* TRUE if server options(s) set */
 410   BOOL    advertised;             /* Set TRUE when advertised */
 411 } auth_instance;
 412
 413
 414 /* Structure for holding information about an authentication mechanism. The
 415 first element must be a struct driver_info, to match routers and transports. */
 416
 417 typedef struct auth_info {
 418   driver_info drinfo;
 419
 420   int (*servercode)(              /* server function */
 421     auth_instance *,              /* the instance data */
 422     uschar *);                    /* rest of AUTH command */
 423   int (*clientcode)(              /* client function */
 424     struct auth_instance *,
 425     void *,                       /* smtp conn, with socket, output and input buffers */
 426     int,                          /* command timeout */
 427     uschar *,                     /* buffer for reading response */
 428     int);                         /* sizeof buffer */
 429   gstring * (*version_report)(    /* diagnostic version reporting */
 430     gstring *);                   /* string to append to */
 431   void (*macros_create)(void);    /* feature-macro creation */
 432 } auth_info;
 433
 434
 435 /* Structure for holding a single IP address and port; used for the chain of
 436 addresses and ports for the local host. Make the char string large enough to
 437 hold an IPv6 address. */
 438
 439 typedef struct ip_address_item {
 440   struct ip_address_item *next;
 441   int    port;
 442   BOOL   v6_include_v4;            /* Used in the daemon */
 443   uschar address[46];
 444   uschar * log;                    /* portion of "listening on" log line */
 445 } ip_address_item;
 446
 447 /* Structure for chaining together arbitrary strings. */
 448
 449 typedef struct string_item {
 450   struct string_item *  next;
 451   uschar *              text;
 452 } string_item;
 453
 454 /* Information about a soft delivery failure, for use when calculating
 455 retry information. It's separate from the address block, because there
 456 can be a chain of them for SMTP deliveries where multiple IP addresses
 457 can be tried. */
 458
 459 typedef struct retry_item {
 460   struct retry_item *next;        /* for chaining */
 461   const uschar *key;              /* string identifying host/address/message */
 462   int     basic_errno;            /* error code for this destination */
 463   int     more_errno;             /* additional error information */
 464   uschar *message;                /* local error message */
 465   int     flags;                  /* see below */
 466 } retry_item;
 467
 468 /* Retry data flags */
 469
 470 #define rf_delete   0x0001        /* retry info is to be deleted */
 471 #define rf_host     0x0002        /* retry info is for a remote host */
 472 #define rf_message  0x0004        /* retry info is for a host+message */
 473
 474 /* Information about a constructed message that is to be sent using the
 475 autoreply transport. This is pointed to from the address block. */
 476
 477 typedef struct reply_item {
 478   uschar *from;                   /* ) */
 479   uschar *reply_to;               /* ) */
 480   uschar *to;                     /* ) */
 481   uschar *cc;                     /* ) specific header fields */
 482   uschar *bcc;                    /* ) */
 483   uschar *subject;                /* ) */
 484   uschar *headers;                /* misc other headers, concatenated */
 485   uschar *text;                   /* text string body */
 486   uschar *file;                   /* file body */
 487   BOOL    file_expand;            /* expand the body */
 488   int     expand_forbid;          /* expansion lockout flags */
 489   uschar *logfile;                /* file to keep a log in */
 490   uschar *oncelog;                /* file to keep records in for once only */
 491   time_t  once_repeat;            /* time to repeat "once only" */
 492   BOOL    return_message;         /* send back the original message */
 493 } reply_item;
 494
 495
 496 /* The address_item structure contains many fields which are used at various
 497 times while delivering a message. Some are used only for remote deliveries;
 498 some only for local. A particular set of fields is copied whenever a child
 499 address is created. For convenience, we keep those fields in a separate
 500 sub-structure so they can be copied in one go. This also means I won't forget
 501 to edit the various copying places when new to-be-copied fields are added. */
 502
 503 typedef struct address_item_propagated {
 504   uschar *address_data;           /* arbitrary data to keep with the address */
 505   uschar *domain_data;            /* from "domains" lookup */
 506   uschar *localpart_data;         /* from "local_parts" lookup */
 507   const uschar *errors_address;         /* where to send errors (NULL => sender) */
 508   header_line *extra_headers;     /* additional headers */
 509   uschar *remove_headers;         /* list of those to remove */
 510   void   *variables;              /* router-vasriables */
 511
 512   BOOL    ignore_error:1;         /* ignore delivery error */
 513 #ifdef SUPPORT_I18N
 514   BOOL    utf8_msg:1;             /* requires SMTPUTF8 processing */
 515   BOOL    utf8_downcvt:1;         /* mandatory downconvert on delivery */
 516   BOOL    utf8_downcvt_maybe:1;   /* optional downconvert on delivery */
 517 #endif
 518 } address_item_propagated;
 519
 520
 521 /* The main address structure. Note that fields that are to be copied to
 522 generated addresses should be put in the address_item_propagated structure (see
 523 above) rather than directly into the address_item structure. */
 524
 525 typedef struct address_item {
 526   struct address_item *next;      /* for chaining addresses */
 527   struct address_item *parent;    /* parent address */
 528   struct address_item *first;     /* points to first after group delivery */
 529   struct address_item *dupof;     /* points to address this is a duplicate of */
 530
 531   router_instance *start_router;  /* generated address starts here */
 532   router_instance *router;        /* the router that routed */
 533   transport_instance *transport;  /* the transport to use */
 534
 535   host_item *host_list;           /* host data for the transport */
 536   host_item *host_used;           /* host that took delivery or failed hard */
 537   host_item *fallback_hosts;      /* to try if delivery defers */
 538
 539   reply_item *reply;              /* data for autoreply */
 540   retry_item *retries;            /* chain of retry information */
 541
 542   const uschar *address;                /* address being delivered or routed */
 543   uschar *unique;                 /* used for disambiguating */
 544   const uschar *cc_local_part;    /* caseful local part */
 545   const uschar *lc_local_part;    /* lowercased local part */
 546   const uschar *local_part;       /* points to cc or lc version */
 547   const uschar *prefix;           /* stripped prefix of local part */
 548   const uschar *prefix_v;         /*  variable part of above */
 549   const uschar *suffix;           /* stripped suffix of local part */
 550   const uschar *suffix_v;         /*  variable part of above */
 551   const uschar *domain;           /* working domain (lower cased) */
 552
 553   uschar *address_retry_key;      /* retry key including full address */
 554   uschar *domain_retry_key;       /* retry key for domain only */
 555
 556   uschar *current_dir;            /* current directory for transporting */
 557   uschar *home_dir;               /* home directory for transporting */
 558   uschar *message;                /* error message */
 559   uschar *user_message;           /* error message that can be sent over SMTP
 560                                      or quoted in bounce message */
 561   const uschar *onetime_parent;         /* saved original parent for onetime */
 562   uschar **pipe_expandn;          /* numeric expansions for pipe from filter */
 563   uschar *return_filename;        /* name of return file */
 564   uschar *self_hostname;          /* after self=pass */
 565   uschar *shadow_message;         /* info about shadow transporting */
 566
 567   uid_t   uid;                    /* uid for transporting */
 568   gid_t   gid;                    /* gid for transporting */
 569
 570 #ifndef DISABLE_TLS
 571   const uschar *tlsver;           /* version used for transport */
 572   uschar *cipher;                 /* Cipher used for transport */
 573   void   *ourcert;                /* Certificate offered to peer, binary */
 574   void   *peercert;               /* Certificate from peer, binary */
 575   uschar *peerdn;                 /* DN of server's certificate */
 576   int    ocsp;                    /* OCSP status of peer cert */
 577 #endif
 578
 579 #ifdef EXPERIMENTAL_DSN_INFO
 580   const uschar *smtp_greeting;    /* peer self-identification */
 581   const uschar *helo_response;    /* peer message */
 582 #endif
 583
 584   uschar *authenticator;          /* auth driver name used by transport */
 585   uschar *auth_id;                /* auth "login" name used by transport */
 586   uschar *auth_sndr;              /* AUTH arg to SMTP MAIL, used by transport */
 587
 588   uschar *dsn_orcpt;              /* DSN orcpt value */
 589   int     dsn_flags;              /* DSN flags */
 590   int     dsn_aware;              /* DSN aware flag */
 591
 592 #ifndef DISABLE_DKIM
 593   const uschar * dkim_used;       /* DKIM info, or NULL */
 594 #endif
 595                                   /* flags */
 596   struct {
 597     BOOL af_allow_file:1;               /* allow file in generated address */
 598     BOOL af_allow_pipe:1;               /* allow pipe in generated address */
 599     BOOL af_allow_reply:1;              /* allow autoreply in generated address */
 600     BOOL af_dr_retry_exists:1;          /* router retry record exists */
 601     BOOL af_expand_pipe:1;              /* expand pipe arguments */
 602     BOOL af_file:1;                     /* file delivery; always with pfr */
 603     BOOL af_gid_set:1;                  /* gid field is set */
 604     BOOL af_home_expanded:1;            /* home_dir is already expanded */
 605     BOOL af_initgroups:1;               /* use initgroups() for local transporting */
 606     BOOL af_local_host_removed:1;       /* local host was backup */
 607     BOOL af_lt_retry_exists:1;          /* local transport retry exists */
 608     BOOL af_pfr:1;                      /* pipe or file or reply delivery */
 609     BOOL af_retry_skipped:1;            /* true if retry caused some skipping */
 610     BOOL af_retry_timedout:1;           /* true if retry timed out */
 611     BOOL af_uid_set:1;                  /* uid field is set */
 612     BOOL af_hide_child:1;               /* hide child in bounce/defer msgs */
 613     BOOL af_sverify_told:1;             /* sender verify failure notified */
 614     BOOL af_verify_pmfail:1;            /* verify failure was postmaster callout */
 615     BOOL af_verify_nsfail:1;            /* verify failure was null sender callout */
 616     BOOL af_homonym:1;                  /* an ancestor has same address */
 617     BOOL af_verify_routed:1;            /* for cached sender verify: routed OK */
 618     BOOL af_verify_callout:1;           /* for cached sender verify: callout was specified */
 619     BOOL af_include_affixes:1;          /* delivered with affixes in RCPT */
 620     BOOL af_new_conn:1;                 /* delivered on an fresh TCP conn */
 621     BOOL af_cont_conn:1;                /* delivered (with new MAIL cmd) on an existing TCP conn */
 622     BOOL af_cert_verified:1;            /* delivered with verified TLS cert */
 623     BOOL af_pass_message:1;             /* pass message in bounces */
 624     BOOL af_bad_reply:1;                /* filter could not generate autoreply */
 625     BOOL af_tcp_fastopen_conn:1;        /* delivery connection used TCP Fast Open */
 626     BOOL af_tcp_fastopen:1;             /* delivery usefully used TCP Fast Open */
 627     BOOL af_tcp_fastopen_data:1;        /* delivery sent SMTP commands on TCP Fast Open */
 628     BOOL af_pipelining:1;               /* delivery used (traditional) pipelining */
 629 #ifndef DISABLE_PIPE_CONNECT
 630     BOOL af_early_pipe:1;               /* delivery used connect-time pipelining */
 631 #endif
 632 #ifndef DISABLE_PRDR
 633     BOOL af_prdr_used:1;                /* delivery used SMTP PRDR */
 634 #endif
 635     BOOL af_chunking_used:1;            /* delivery used SMTP CHUNKING */
 636     BOOL af_force_command:1;            /* force_command in pipe transport */
 637 #ifdef SUPPORT_DANE
 638     BOOL af_dane_verified:1;            /* TLS cert verify done with DANE */
 639 #endif
 640 #ifdef SUPPORT_I18N
 641     BOOL af_utf8_downcvt:1;             /* downconvert was done for delivery */
 642 #endif
 643 #ifndef DISABLE_TLS_RESUME
 644     BOOL af_tls_resume:1;               /* TLS used a resumed session */
 645 #endif
 646   } flags;
 647
 648   unsigned int domain_cache[(MAX_NAMED_LIST * 2)/32];
 649   unsigned int localpart_cache[(MAX_NAMED_LIST * 2)/32];
 650   int     mode;                   /* mode for local transporting to a file */
 651   int     basic_errno;            /* status after failure */
 652   int     more_errno;             /* additional error information */
 653   struct timeval delivery_time;   /* time taken to do delivery/attempt */
 654
 655   unsigned short child_count;     /* number of child addresses */
 656   short int return_file;          /* fileno of return data file */
 657   short int special_action;       /* ( used when when deferred or failed */
 658                                   /* (  also  */
 659                                   /* ( contains = or - when successful SMTP delivered */
 660                                   /* (  also  */
 661                                   /* ( contains verify rc in sender verify cache */
 662   short int transport_return;     /* result of delivery attempt */
 663   address_item_propagated prop;   /* fields that are propagated to children */
 664 } address_item;
 665
 666 /* The table of header names consists of items of this type */
 667
 668 typedef struct {
 669   uschar *name;
 670   int     len;
 671   BOOL    allow_resent;
 672   int     htype;
 673 } header_name;
 674
 675 /* Chain of information about errors (e.g. bad addresses) */
 676
 677 typedef struct error_block {
 678   struct error_block *next;
 679   const uschar *text1;
 680   uschar *text2;
 681 } error_block;
 682
 683 /* Chain of file names when processing the queue */
 684
 685 typedef struct queue_filename {
 686   struct queue_filename *next;
 687   uschar dir_uschar;
 688   uschar text[1];
 689 } queue_filename;
 690
 691 /* Chain of items of retry information, read from the retry config. */
 692
 693 typedef struct retry_rule {
 694   struct retry_rule *next;
 695   int    rule;
 696   int    timeout;
 697   int    p1;
 698   int    p2;
 699 } retry_rule;
 700
 701 typedef struct retry_config {
 702   struct retry_config *next;
 703   uschar *pattern;
 704   int     basic_errno;
 705   int     more_errno;
 706   uschar *senders;
 707   retry_rule *rules;
 708 } retry_config;
 709
 710 /* Structure for each node in a tree, of which there are various kinds */
 711
 712 typedef struct tree_node {
 713   struct tree_node *left;         /* pointer to left child */
 714   struct tree_node *right;        /* pointer to right child */
 715   union
 716     {
 717     void  *ptr;                   /* pointer to data */
 718     int val;                      /* or integer data */
 719     } data;
 720   uschar  balance;                /* balancing factor */
 721   uschar  name[1];                /* node name - variable length */
 722 } tree_node;
 723
 724 /* Structure for holding time-limited data such as DNS returns.
 725 We use this rather than extending tree_node to avoid wasting
 726 space for most tree use (variables...) at the cost of complexity
 727 for the lookups cache.
 728 We also store any options used for the lookup. */
 729
 730 typedef struct expiring_data {
 731   time_t        expiry;         /* if nonzero, data invalid after this time */
 732   const uschar * opts;          /* options, or NULL */
 733   union
 734     {
 735     void  *     ptr;            /* pointer to data */
 736     int         val;            /* or integer data */
 737     } data;
 738 } expiring_data;
 739
 740 /* Structure for holding the handle and the cached last lookup for searches.
 741 This block is pointed to by the tree entry for the file. The file can get
 742 closed if too many are opened at once. There is a LRU chain for deciding which
 743 to close. */
 744
 745 typedef struct search_cache {
 746   void   *handle;                 /* lookup handle, or NULL if closed */
 747   const lookup_info * li;         /* info struct for search type */
 748   tree_node *up;                  /* LRU up pointer */
 749   tree_node *down;                /* LRU down pointer */
 750   tree_node *item_cache;          /* tree of cached results */
 751 } search_cache;
 752
 753 /* Structure for holding a partially decoded DNS record; the name has been
 754 uncompressed, but the data pointer is into the raw data. */
 755
 756 typedef struct {
 757   uschar        name[DNS_MAXNAME];      /* domain name */
 758   int           type;                   /* record type */
 759   unsigned short ttl;                   /* time-to-live, seconds */
 760   int           size;                   /* size of data */
 761   const uschar *data;                   /* pointer to data */
 762 } dns_record;
 763
 764 /* Structure for holding the result of a DNS query.  A touch over
 765 64k big, so take care to release as soon as possible. */
 766
 767 typedef struct {
 768   int     answerlen;              /* length of the answer */
 769   uschar  answer[NS_MAXMSG];      /* the answer itself */
 770 } dns_answer;
 771
 772 /* Structure for holding the intermediate data while scanning a DNS answer
 773 block. */
 774
 775 typedef struct {
 776   int            rrcount;         /* count of RRs in the answer */
 777   const uschar *aptr;             /* pointer in the answer while scanning */
 778   dns_record     srr;             /* data from current record in scan */
 779 } dns_scan;
 780
 781 /* Structure for holding a chain of IP addresses that are extracted from
 782 an A, AAAA, or A6 record. For the first two, there is only ever one address,
 783 but the chaining feature of A6 allows for several addresses to be realized from
 784 a single initial A6 record. The structure defines the address field of length
 785 1. In use, a suitable sized block is obtained to hold the complete textual
 786 address. */
 787
 788 typedef struct dns_address {
 789   struct dns_address *next;
 790   uschar  address[1];
 791 } dns_address;
 792
 793 /* Structure used for holding intermediate data during MD5 computations. */
 794
 795 typedef struct md5 {
 796   unsigned int length;
 797   unsigned int abcd[4];
 798   }
 799 md5;
 800
 801 /* Structure used for holding intermediate data during SHA-1 computations. */
 802
 803 typedef struct sha1 {
 804   unsigned int H[5];
 805   unsigned int length;
 806 } sha1;
 807
 808 /* Information for making an smtp connection */
 809 typedef struct {
 810   transport_instance *  tblock;
 811   void *                ob;     /* smtp_transport_options_block * */
 812   host_item *           host;
 813   int                   host_af;
 814   uschar *              interface;
 815
 816   int                   sock;   /* used for a bound but not connected socket */
 817   uschar *              sending_ip_address;     /* used for TLS resumption */
 818   const uschar *        host_lbserver;          /* ditto, for server-behind LB */
 819   BOOL                  have_lbserver:1;        /* host_lbserver is valid */
 820
 821 #ifdef SUPPORT_DANE
 822   BOOL dane:1;                  /* connection must do dane */
 823   dns_answer            tlsa_dnsa;      /* strictly, this should use tainted mem */
 824 #endif
 825 } smtp_connect_args;
 826
 827 /* A client-initiated connection. If TLS, the second element is non-NULL */
 828 typedef struct {
 829   int   sock;
 830   void * tls_ctx;
 831 } client_conn_ctx;
 832
 833
 834 /* Structure used to hold incoming packets of SMTP responses for a specific
 835 socket. The packets which may contain multiple lines (and in some cases,
 836 multiple responses). */
 837
 838 typedef struct smtp_inblock {
 839   client_conn_ctx * cctx;         /* the connection */
 840   int     buffersize;             /* the size of the buffer */
 841   uschar *ptr;                    /* current position in the buffer */
 842   uschar *ptrend;                 /* end of data in the buffer */
 843   uschar *buffer;                 /* the buffer itself */
 844 } smtp_inblock;
 845
 846 /* Structure used to hold buffered outgoing packets of SMTP commands for a
 847 specific socket. The packets which may contain multiple lines when pipelining
 848 is in use. */
 849
 850 typedef struct smtp_outblock {
 851   client_conn_ctx * cctx;         /* the connection */
 852   int     cmd_count;              /* count of buffered commands */
 853   int     buffersize;             /* the size of the buffer */
 854   BOOL    authenticating;         /* TRUE when authenticating */
 855   uschar *ptr;                    /* current position in the buffer */
 856   uschar *buffer;                 /* the buffer itself */
 857
 858   smtp_connect_args * conn_args;  /* to make connection, if not yet made */
 859 } smtp_outblock;
 860
 861 /* Structure to hold information about the source of redirection information */
 862
 863 typedef struct redirect_block {
 864   uschar *string;                 /* file name or string */
 865   uid_t  *owners;                 /* allowed file owners */
 866   gid_t  *owngroups;              /* allowed file groups */
 867   struct passwd *pw;              /* possible owner if not NULL */
 868   int     modemask;               /* forbidden bits */
 869   BOOL    isfile;                 /* TRUE if string is a file name */
 870   BOOL    check_owner;            /* TRUE, FALSE, or TRUE_UNSET */
 871   BOOL    check_group;            /* TRUE, FALSE, or TRUE_UNSET */
 872 } redirect_block;
 873
 874 /* Sieve control data */
 875
 876 typedef struct sieve_block {
 877   const uschar * inbox;
 878   const uschar * enotify_mailto_owner;
 879   const uschar * subaddress;
 880   const uschar * useraddress;
 881   const uschar * vacation_dir;
 882 } sieve_block;
 883
 884 /* Structure for passing arguments to check_host() */
 885
 886 typedef struct check_host_block {
 887   const uschar *host_name;
 888   const uschar *host_address;
 889   const uschar *host_ipv4;
 890   mcs_flags     flags;
 891 } check_host_block;
 892
 893 /* Structure for remembering lookup data when caching the result of
 894 a lookup in a named list. */
 895
 896 typedef struct namedlist_cacheblock {
 897   struct namedlist_cacheblock *next;
 898   uschar *key;
 899   uschar *data;
 900 } namedlist_cacheblock;
 901
 902 /* Structure for holding data for an entry in a named list */
 903
 904 typedef struct namedlist_block {
 905   const uschar *string;                 /* the list string */
 906   namedlist_cacheblock *cache_data;     /* cached domain_data or localpart_data */
 907   short         number;                 /* the number of the list for caching */
 908   BOOL          hide;                   /* -bP does not display value */
 909 } namedlist_block;
 910
 911 /* Structures for Access Control Lists */
 912
 913 typedef struct acl_condition_block {
 914   struct acl_condition_block *  next;
 915   uschar *                      arg;
 916   int                           type;
 917   union {
 918     BOOL        negated;
 919     uschar *    varname;
 920   } u;
 921 } acl_condition_block;
 922
 923 typedef struct acl_block {
 924   struct acl_block *    next;
 925   acl_condition_block * condition;
 926   int                   verb;
 927   int                   srcline;
 928   const uschar *        srcfile;
 929 } acl_block;
 930
 931 /* smtp transport calc outbound_ip */
 932 typedef BOOL (*oicf) (uschar *message_id, void *data);
 933
 934 /* DKIM information for transport */
 935 struct ob_dkim {
 936   uschar *dkim_domain;
 937   uschar *dkim_identity;
 938   uschar *dkim_private_key;
 939   uschar *dkim_selector;
 940   uschar *dkim_canon;
 941   uschar *dkim_sign_headers;
 942   uschar *dkim_strict;
 943   uschar *dkim_hash;
 944   uschar *dkim_timestamps;
 945   BOOL    dot_stuffed;
 946   BOOL    force_bodyhash;
 947 #ifdef EXPERIMENTAL_ARC
 948   uschar *arc_signspec;
 949 #endif
 950 };
 951
 952
 953 /* per-queue-runner info */
 954 typedef struct qrunner {
 955   struct qrunner * next;        /* list sorted by next tick */
 956
 957   uschar *      name;           /* NULL for the default queue */
 958   unsigned      interval;       /* tick rate, seconds. Zero for a one-time run */
 959   time_t        next_tick;      /* next run should, or should have, start(ed) */
 960   unsigned      run_max;        /* concurrent queue runner limit */
 961   unsigned      run_count;      /* current runners */
 962
 963   BOOL queue_run_force :1;
 964   BOOL deliver_force_thaw :1;
 965   BOOL queue_run_first_delivery :1;
 966   BOOL queue_run_local :1;
 967   BOOL queue_2stage :1;
 968 } qrunner;
 969
 970
 971 /* Types of variable table entry */
 972
 973 enum vtypes {
 974   vtype_int,            /* value is address of int */
 975   vtype_filter_int,     /* ditto, but recognized only when filtering */
 976   vtype_ino,            /* value is address of ino_t (not always an int) */
 977   vtype_uid,            /* value is address of uid_t (not always an int) */
 978   vtype_gid,            /* value is address of gid_t (not always an int) */
 979   vtype_bool,           /* value is address of bool */
 980   vtype_stringptr,      /* value is address of pointer to string */
 981   vtype_msgbody,        /* as stringptr, but read when first required */
 982   vtype_msgbody_end,    /* ditto, the end of the message */
 983   vtype_msgheaders,     /* the message's headers, processed */
 984   vtype_msgheaders_raw, /* the message's headers, unprocessed */
 985   vtype_localpart,      /* extract local part from string */
 986   vtype_domain,         /* extract domain from string */
 987   vtype_string_func,    /* value is string returned by given function */
 988   vtype_todbsdin,       /* value not used; generate BSD inbox tod */
 989   vtype_tode,           /* value not used; generate tod in epoch format */
 990   vtype_todel,          /* value not used; generate tod in epoch/usec format */
 991   vtype_todf,           /* value not used; generate full tod */
 992   vtype_todl,           /* value not used; generate log tod */
 993   vtype_todlf,          /* value not used; generate log file datestamp tod */
 994   vtype_todzone,        /* value not used; generate time zone only */
 995   vtype_todzulu,        /* value not used; generate zulu tod */
 996   vtype_reply,          /* value not used; get reply from headers */
 997   vtype_pid,            /* value not used; result is pid */
 998   vtype_host_lookup,    /* value not used; get host name */
 999   vtype_load_avg,       /* value not used; result is int from os_getloadavg */
1000   vtype_pspace,         /* partition space; value is T/F for spool/log */
1001   vtype_pinodes,        /* partition inodes; value is T/F for spool/log */
1002   vtype_cert,           /* SSL certificate */
1003 #ifndef DISABLE_DKIM
1004   vtype_dkim,           /* Lookup of value in DKIM signature */
1005 #endif
1006   vtype_module,         /* variable lives in a module; value is module name */
1007 };
1008
1009 /* Type for main variable table */
1010
1011 typedef struct {
1012   const char *name;
1013   enum vtypes type;
1014   void       *value;
1015 } var_entry;
1016
1017
1018
1019 /* dynamic-load module info */
1020
1021 typedef struct misc_module_info {
1022   struct misc_module_info * next;
1023
1024   const uschar * name;
1025   unsigned      dyn_magic;
1026   BOOL          (*init)(void *);        /* arg is the misc_module_info ptr */
1027   gstring *     (*lib_vers_report)(gstring *);  /* underlying library */
1028   int           (*conn_init)(const uschar *, const uschar *);
1029   void          (*smtp_reset)(void);
1030   int           (*msg_init)(void);
1031   gstring *     (*authres)(gstring *);
1032
1033   void *        options;
1034   unsigned      options_count;
1035   void *        functions;
1036   unsigned      functions_count;
1037   void *        variables;
1038   unsigned      variables_count;
1039 } misc_module_info;
1040
1041 #define MISC_MODULE_MAGIC       0x4d4d4d31      /* MMM1 */
1042
1043 #endif  /* whole file */
1044 /* End of structs.h */