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