Commit | Line | Data |
---|---|---|
8e669ac1 | 1 | /* $Cambridge: exim/src/src/structs.h,v 1.4 2005/02/17 11:58:26 ph10 Exp $ */ |
059ec3d9 PH |
2 | |
3 | /************************************************* | |
4 | * Exim - an Internet mail transport agent * | |
5 | *************************************************/ | |
6 | ||
c988f1f4 | 7 | /* Copyright (c) University of Cambridge 1995 - 2005 */ |
059ec3d9 PH |
8 | /* See the file NOTICE for conditions of use and distribution. */ |
9 | ||
10 | ||
11 | /* Definitions of various structures. In addition, those that are visible for | |
12 | the compilation of local_scan() are defined in local_scan.h. These are | |
13 | ||
14 | header_line | |
15 | optionlist | |
16 | recipient_item | |
17 | ||
18 | For those declared here, we have to pre-declare some because of mutually | |
19 | recursive definitions in the auths, routers, and transports blocks. */ | |
20 | ||
21 | struct address_item; | |
22 | struct auth_info; | |
23 | struct driver_info; | |
24 | struct director_info; | |
25 | struct smtp_inblock; | |
26 | struct smtp_outblock; | |
27 | struct transport_info; | |
28 | struct router_info; | |
29 | ||
30 | /* Structure for remembering macros for the configuration file */ | |
31 | ||
32 | typedef struct macro_item { | |
33 | struct macro_item *next; | |
34 | BOOL command_line; | |
35 | uschar *replacement; | |
36 | uschar name[1]; | |
37 | } macro_item; | |
38 | ||
39 | /* Structure for bit tables for debugging and logging */ | |
40 | ||
41 | typedef struct bit_table { | |
42 | uschar *name; | |
43 | unsigned int bit; | |
44 | } bit_table; | |
45 | ||
46 | /* Block for holding a uid and gid, possibly unset, and an initgroups flag. */ | |
47 | ||
48 | typedef struct ugid_block { | |
49 | uid_t uid; | |
50 | gid_t gid; | |
51 | BOOL uid_set; | |
52 | BOOL gid_set; | |
53 | BOOL initgroups; | |
54 | } ugid_block; | |
55 | ||
56 | /* Structure for holding information about a host for use mainly by routers, | |
57 | but also used when checking lists of hosts and when transporting. Looking up | |
58 | host addresses is done using this structure. */ | |
59 | ||
60 | typedef struct host_item { | |
61 | struct host_item *next; | |
62 | uschar *name; /* Host name */ | |
63 | uschar *address; /* IP address in text form */ | |
64 | int port; /* port value in host order (if SRV lookup) */ | |
65 | int mx; /* MX value if found via MX records */ | |
66 | int sort_key; /* MX*1000 plus random "fraction" */ | |
67 | int status; /* Usable, unusable, or unknown */ | |
68 | int why; /* Why host is unusable */ | |
69 | int last_try; /* Time of last try if known */ | |
70 | BOOL update_waiting; /* Turned off if wait db not to be updated */ | |
71 | } host_item; | |
72 | ||
73 | /* Chain of rewrite rules, read from the rewrite config, or parsed from the | |
74 | rewrite_headers field of a transport. */ | |
75 | ||
76 | typedef struct rewrite_rule { | |
77 | struct rewrite_rule *next; | |
78 | int flags; | |
79 | uschar *key; | |
80 | uschar *replacement; | |
81 | } rewrite_rule; | |
82 | ||
83 | /* This structure is used to pass back configuration data from the smtp | |
84 | transport to the outside world. It is used during callback processing. If ever | |
85 | another remote transport were implemented, it could use the same structure. */ | |
86 | ||
87 | typedef struct transport_feedback { | |
88 | uschar *interface; | |
89 | uschar *port; | |
90 | uschar *protocol; | |
91 | uschar *hosts; | |
92 | BOOL hosts_override; | |
93 | BOOL hosts_randomize; | |
94 | BOOL gethostbyname; | |
95 | BOOL qualify_single; | |
96 | BOOL search_parents; | |
97 | } transport_feedback; | |
98 | ||
99 | /* Routers, transports, and authenticators have similar data blocks. Each | |
100 | driver that is compiled into the code is represented by a xxx_info block; the | |
101 | active drivers are represented by a chain of xxx_instance blocks. To make it | |
102 | possible to use the same code for reading the configuration files for all | |
103 | three, the layout of the start of the blocks is kept the same, and represented | |
104 | by the generic structures driver_info and driver_instance. */ | |
105 | ||
106 | typedef struct driver_instance { | |
107 | struct driver_instance *next; | |
108 | uschar *name; /* Instance name */ | |
109 | struct driver_info *info; /* Points to info for this driver */ | |
110 | void *options_block; /* Pointer to private options */ | |
111 | uschar *driver_name; /* All start with this generic option */ | |
112 | } driver_instance; | |
113 | ||
114 | typedef struct driver_info { | |
115 | uschar *driver_name; /* Name of driver */ | |
116 | optionlist *options; /* Table of private options names */ | |
117 | int *options_count; /* -> Number of entries in table */ | |
118 | void *options_block; /* Points to default private block */ | |
119 | int options_len; /* Length of same in bytes */ | |
120 | void (*init)( /* Initialization entry point */ | |
121 | struct driver_instance *); | |
122 | } driver_info; | |
123 | ||
124 | ||
125 | /* Structure for holding information about the configured transports. Some | |
126 | of the generally accessible options are set from the configuration file; others | |
127 | are set by transport initialization, since they can only be set for certain | |
128 | transports. They need to be generally accessible, however, as they are used by | |
129 | the main transport code. */ | |
130 | ||
131 | typedef struct transport_instance { | |
132 | struct transport_instance *next; | |
133 | uschar *name; /* Instance name */ | |
134 | struct transport_info *info; /* Info for this driver */ | |
135 | void *options_block; /* Pointer to private options */ | |
136 | uschar *driver_name; /* Must be first */ | |
137 | int (*setup)( /* Setup entry point */ | |
138 | struct transport_instance *, | |
139 | struct address_item *, | |
140 | struct transport_feedback *, /* For passing back config data */ | |
141 | uschar **); /* For an error message */ | |
142 | /**************************************/ | |
143 | int batch_max; /* ) */ | |
144 | uschar *batch_id; /* ) */ | |
145 | uschar *home_dir; /* ) Used only for local transports */ | |
146 | uschar *current_dir; /* ) */ | |
147 | /**************************************/ | |
148 | BOOL multi_domain; /* ) */ | |
149 | BOOL overrides_hosts; /* ) Used only for remote transports */ | |
150 | int max_addresses; /* ) */ | |
151 | int connection_max_messages;/* ) */ | |
152 | /**************************************/ | |
153 | BOOL deliver_as_creator; /* Used only by pipe at present */ | |
154 | BOOL disable_logging; /* For very weird requirements */ | |
155 | BOOL initgroups; /* Initialize groups when setting uid */ | |
156 | BOOL uid_set; /* uid is set */ | |
157 | BOOL gid_set; /* gid is set */ | |
158 | uid_t uid; | |
159 | gid_t gid; | |
160 | uschar *expand_uid; /* Variable uid */ | |
161 | uschar *expand_gid; /* Variable gid */ | |
162 | uschar *warn_message; /* Used only by appendfile at present */ | |
163 | uschar *shadow; /* Name of shadow transport */ | |
164 | uschar *shadow_condition; /* Condition for running it */ | |
165 | uschar *filter_command; /* For on-the-fly-filtering */ | |
166 | uschar *add_headers; /* Add these headers */ | |
167 | uschar *remove_headers; /* Remove these headers */ | |
168 | uschar *return_path; /* Overriding (rewriting) return path */ | |
169 | uschar *debug_string; /* Debugging output */ | |
170 | uschar *message_size_limit; /* Biggest message this transport handles */ | |
171 | uschar *headers_rewrite; /* Rules for rewriting headers */ | |
172 | rewrite_rule *rewrite_rules; /* Parsed rewriting rules */ | |
173 | int rewrite_existflags; /* Bits showing which headers are rewritten */ | |
174 | int filter_timeout; /* For transport filter timing */ | |
175 | BOOL body_only; /* Deliver only the body */ | |
176 | BOOL delivery_date_add; /* Add Delivery-Date header */ | |
177 | BOOL envelope_to_add; /* Add Envelope-To header */ | |
178 | BOOL headers_only; /* Deliver only the headers */ | |
179 | BOOL rcpt_include_affixes; /* TRUE to retain affixes in RCPT commands */ | |
180 | BOOL return_path_add; /* Add Return-Path header */ | |
181 | BOOL return_output; /* TRUE if output should always be returned */ | |
182 | BOOL return_fail_output; /* ditto, but only on failure */ | |
183 | BOOL log_output; /* Similarly for logging */ | |
184 | BOOL log_fail_output; | |
185 | BOOL log_defer_output; | |
186 | BOOL retry_use_local_part; /* Defaults true for local, false for remote */ | |
187 | } transport_instance; | |
188 | ||
189 | ||
190 | /* Structure for holding information about a type of transport. The first six | |
191 | fields must match driver_info above. */ | |
192 | ||
193 | typedef struct transport_info { | |
194 | uschar *driver_name; /* Driver name */ | |
195 | optionlist *options; /* Table of private options names */ | |
196 | int *options_count; /* -> Number of entries in table */ | |
197 | void *options_block; /* Points to default private block */ | |
198 | int options_len; /* Length of same in bytes */ | |
199 | void (*init)( /* Initialization function */ | |
200 | struct transport_instance *); | |
201 | /****/ | |
202 | BOOL (*code)( /* Main entry point */ | |
203 | transport_instance *, | |
204 | struct address_item *); | |
205 | void (*tidyup)( /* Tidyup function */ | |
206 | struct transport_instance *); | |
207 | void (*closedown)( /* For closing down a passed channel */ | |
208 | struct transport_instance *); | |
209 | BOOL local; /* TRUE for local transports */ | |
210 | } transport_info; | |
211 | ||
212 | ||
213 | ||
214 | /* Structure for holding information about the configured routers. */ | |
215 | ||
216 | typedef struct router_instance { | |
217 | struct router_instance *next; | |
218 | uschar *name; | |
219 | struct router_info *info; | |
220 | void *options_block; /* Pointer to private options */ | |
221 | uschar *driver_name; /* Must be first */ | |
222 | ||
223 | uschar *address_data; /* Arbitrary data */ | |
8523533c TK |
224 | #ifdef EXPERIMENTAL_BRIGHTMAIL |
225 | uschar *bmi_rule; /* Brightmail AntiSpam rule checking */ | |
8e669ac1 | 226 | #endif |
059ec3d9 PH |
227 | uschar *cannot_route_message; /* Used when routing fails */ |
228 | uschar *condition; /* General condition */ | |
229 | uschar *current_directory; /* For use during delivery */ | |
230 | uschar *debug_string; /* Debugging output */ | |
231 | uschar *domains; /* Specific domains */ | |
232 | uschar *errors_to; /* Errors address */ | |
233 | uschar *expand_gid; /* Expanded gid string */ | |
234 | uschar *expand_uid; /* Expanded uid string */ | |
235 | uschar *expand_more; /* Expanded more string */ | |
236 | uschar *expand_unseen; /* Expanded unseen string */ | |
237 | uschar *extra_headers; /* Additional headers */ | |
238 | uschar *fallback_hosts; /* For remote transports (text list) */ | |
239 | uschar *home_directory; /* For use during delivery */ | |
240 | uschar *ignore_target_hosts; /* Target hosts to ignore */ | |
241 | uschar *local_parts; /* Specific local parts */ | |
242 | uschar *pass_router_name; /* Router for passed address */ | |
243 | uschar *prefix; /* Address prefix */ | |
244 | uschar *redirect_router_name; /* Router for generated address */ | |
245 | uschar *remove_headers; /* Removed headers */ | |
246 | uschar *require_files; /* File checks before router is run */ | |
247 | uschar *router_home_directory; /* For use while routing */ | |
248 | uschar *self; /* Text option for handling self reference */ | |
249 | uschar *senders; /* Specific senders */ | |
250 | uschar *suffix; /* Address suffix */ | |
251 | uschar *translate_ip_address; /* IP address translation fudgery */ | |
252 | uschar *transport_name; /* Transport name */ | |
253 | ||
254 | BOOL address_test; /* Use this router when testing addresses */ | |
8523533c TK |
255 | #ifdef EXPERIMENTAL_BRIGHTMAIL |
256 | BOOL bmi_deliver_alternate; /* TRUE => BMI said that message should be delivered to alternate location */ | |
257 | BOOL bmi_deliver_default; /* TRUE => BMI said that message should be delivered to default location */ | |
258 | BOOL bmi_dont_deliver; /* TRUE => BMI said that message should not be delivered at all */ | |
259 | #endif | |
059ec3d9 PH |
260 | BOOL expn; /* Use this router when processing EXPN */ |
261 | BOOL caseful_local_part; /* TRUE => don't lowercase */ | |
262 | BOOL check_local_user; /* TRUE => check local user */ | |
263 | BOOL disable_logging; /* For very weird requirements */ | |
264 | BOOL fail_verify_recipient; /* Fail verify if recipient match this router */ | |
265 | BOOL fail_verify_sender; /* Fail verify if sender match this router */ | |
266 | BOOL gid_set; /* Flag to indicate gid is set */ | |
267 | BOOL initgroups; /* TRUE if initgroups is required */ | |
268 | BOOL log_as_local; /* TRUE logs as a local delivery */ | |
269 | BOOL more; /* If FALSE, do no more if this one fails */ | |
270 | BOOL pass_on_timeout; /* Treat timeout DEFERs as fails */ | |
271 | BOOL prefix_optional; /* Just what it says */ | |
272 | BOOL repeat_use; /* If FALSE, skip if ancestor used it */ | |
273 | BOOL retry_use_local_part; /* Just what it says */ | |
274 | BOOL same_domain_copy_routing; /* TRUE => copy routing for same domain */ | |
275 | BOOL self_rewrite; /* TRUE to rewrite headers if making local */ | |
276 | BOOL suffix_optional; /* As it says */ | |
277 | BOOL verify_only; /* Skip this router if not verifying */ | |
278 | BOOL verify_recipient; /* Use this router when verifying a recipient*/ | |
279 | BOOL verify_sender; /* Use this router when verifying a sender */ | |
280 | BOOL uid_set; /* Flag to indicate uid is set */ | |
281 | BOOL unseen; /* If TRUE carry on, even after success */ | |
282 | ||
283 | int self_code; /* Encoded version of "self" */ | |
284 | uid_t uid; /* Fixed uid value */ | |
285 | gid_t gid; /* Fixed gid value */ | |
286 | ||
287 | host_item *fallback_hostlist; /* For remote transport (block chain) */ | |
288 | transport_instance *transport; /* Transport block (when found) */ | |
289 | struct router_instance *pass_router; /* Actual router for passed address */ | |
290 | struct router_instance *redirect_router; /* Actual router for generated address */ | |
291 | } router_instance; | |
292 | ||
293 | ||
294 | /* Structure for holding information about a type of router. The first six | |
295 | fields must match driver_info above. */ | |
296 | ||
297 | typedef struct router_info { | |
298 | uschar *driver_name; | |
299 | optionlist *options; /* Table of private options names */ | |
300 | int *options_count; /* -> Number of entries in table */ | |
301 | void *options_block; /* Points to default private block */ | |
302 | int options_len; /* Length of same in bytes */ | |
303 | void (*init)( /* Initialization function */ | |
304 | struct router_instance *); | |
305 | /****/ | |
306 | int (*code)( /* Main entry point */ | |
307 | router_instance *, | |
308 | struct address_item *, | |
309 | struct passwd *, | |
310 | BOOL, | |
311 | struct address_item **, | |
312 | struct address_item **, | |
313 | struct address_item **, | |
314 | struct address_item **); | |
315 | void (*tidyup)( /* Tidyup function */ | |
316 | struct router_instance *); | |
317 | int ri_flags; /* Descriptive flags */ | |
318 | } router_info; | |
319 | ||
320 | ||
321 | /* Structure for holding information about a lookup type. */ | |
322 | ||
323 | typedef struct lookup_info { | |
324 | uschar *name; /* e.g. "lsearch" */ | |
325 | int type; /* query/singlekey/abs-file */ | |
326 | void *(*open)( /* open function */ | |
327 | uschar *, /* file name for those that have one */ | |
328 | uschar **); /* for error message */ | |
329 | BOOL (*check)( /* file checking function */ | |
330 | void *, /* handle */ | |
331 | uschar *, /* file name */ | |
332 | int, /* modemask for file checking */ | |
333 | uid_t *, /* owners for file checking */ | |
334 | gid_t *, /* owngroups for file checking */ | |
335 | uschar **); /* for error messages */ | |
336 | int (*find)( /* find function */ | |
337 | void *, /* handle */ | |
338 | uschar *, /* file name or NULL */ | |
339 | uschar *, /* key or query */ | |
340 | int, /* length of key or query */ | |
341 | uschar **, /* for returning answer */ | |
342 | uschar **, /* for error message */ | |
343 | BOOL *); /* to request cache cleanup */ | |
344 | void (*close)( /* close function */ | |
345 | void *); /* handle */ | |
346 | void (*tidy)(void); /* tidy function */ | |
347 | uschar *(*quote)( /* quoting function */ | |
348 | uschar *, /* string to quote */ | |
349 | uschar *); /* additional data from quote name */ | |
350 | } lookup_info; | |
351 | ||
352 | ||
353 | /* Structure for holding information about the configured authentication | |
354 | mechanisms */ | |
355 | ||
356 | typedef struct auth_instance { | |
357 | struct auth_instance *next; | |
358 | uschar *name; /* Exim instance name */ | |
359 | struct auth_info *info; /* Pointer to driver info block */ | |
360 | void *options_block; /* Pointer to private options */ | |
361 | uschar *driver_name; /* Must be first */ | |
362 | uschar *advertise_condition; /* Are we going to advertise this?*/ | |
363 | uschar *public_name; /* Advertised name */ | |
364 | uschar *set_id; /* String to set as authenticated id */ | |
365 | uschar *mail_auth_condition; /* Condition for AUTH on MAIL command */ | |
366 | uschar *server_debug_string; /* Debugging output */ | |
367 | BOOL client; /* TRUE if client option(s) set */ | |
368 | BOOL server; /* TRUE if server options(s) set */ | |
369 | BOOL advertised; /* Set TRUE when advertised */ | |
370 | } auth_instance; | |
371 | ||
372 | ||
373 | /* Structure for holding information about an authentication mechanism. The | |
374 | first six fields must match driver_info above. */ | |
375 | ||
376 | typedef struct auth_info { | |
377 | uschar *driver_name; /* e.g. "condition" */ | |
378 | optionlist *options; /* Table of private options names */ | |
379 | int *options_count; /* -> Number of entries in table */ | |
380 | void *options_block; /* Points to default private block */ | |
381 | int options_len; /* Length of same in bytes */ | |
382 | void (*init)( /* initialization function */ | |
383 | struct auth_instance *); | |
384 | /****/ | |
385 | int (*servercode)( /* server function */ | |
386 | auth_instance *, /* the instance data */ | |
387 | uschar *); /* rest of AUTH command */ | |
388 | int (*clientcode)( /* client function */ | |
389 | struct auth_instance *, | |
390 | struct smtp_inblock *, /* socket and input buffer */ | |
391 | struct smtp_outblock *, /* socket and output buffer */ | |
392 | int, /* command timeout */ | |
393 | uschar *, /* buffer for reading response */ | |
394 | int); /* sizeof buffer */ | |
395 | } auth_info; | |
396 | ||
397 | ||
398 | /* Structure for holding a single IP address and port; used for the chain of | |
399 | addresses and ports for the local host. Make the char string large enough to | |
400 | hold an IPv6 address. */ | |
401 | ||
402 | typedef struct ip_address_item { | |
403 | struct ip_address_item *next; | |
404 | int port; | |
405 | BOOL v6_include_v4; /* Used in the daemon */ | |
406 | uschar address[46]; | |
407 | } ip_address_item; | |
408 | ||
409 | /* Structure for chaining together arbitrary strings. */ | |
410 | ||
411 | typedef struct string_item { | |
412 | struct string_item *next; | |
413 | uschar *text; | |
414 | } string_item; | |
415 | ||
416 | /* Information about a soft delivery failure, for use when calculating | |
417 | retry information. It's separate from the address block, because there | |
418 | can be a chain of them for SMTP deliveries where multiple IP addresses | |
419 | can be tried. */ | |
420 | ||
421 | typedef struct retry_item { | |
422 | struct retry_item *next; /* for chaining */ | |
423 | uschar *key; /* string identifying host/address/message */ | |
424 | int basic_errno; /* error code for this destination */ | |
425 | int more_errno; /* additional error information */ | |
426 | uschar *message; /* local error message */ | |
427 | int flags; /* see below */ | |
428 | } retry_item; | |
429 | ||
430 | /* Retry data flags */ | |
431 | ||
432 | #define rf_delete 0x0001 /* retry info is to be deleted */ | |
433 | #define rf_host 0x0002 /* retry info is for a remote host */ | |
434 | #define rf_message 0x0004 /* retry info is for a host+message */ | |
435 | ||
436 | /* Information about a constructed message that is to be sent using the | |
437 | autoreply transport. This is pointed to from the address block. */ | |
438 | ||
439 | typedef struct reply_item { | |
440 | uschar *from; /* ) */ | |
441 | uschar *reply_to; /* ) */ | |
442 | uschar *to; /* ) */ | |
443 | uschar *cc; /* ) specific header fields */ | |
444 | uschar *bcc; /* ) */ | |
445 | uschar *subject; /* ) */ | |
446 | uschar *headers; /* misc other headers, concatenated */ | |
447 | uschar *text; /* text string body */ | |
448 | uschar *file; /* file body */ | |
449 | BOOL file_expand; /* expand the body */ | |
450 | int expand_forbid; /* expansion lockout flags */ | |
451 | uschar *logfile; /* file to keep a log in */ | |
452 | uschar *oncelog; /* file to keep records in for once only */ | |
453 | time_t once_repeat; /* time to repeat "once only" */ | |
454 | BOOL return_message; /* send back the original message */ | |
455 | } reply_item; | |
456 | ||
457 | ||
458 | /* The address_item structure contains many fields which are used at various | |
459 | times while delivering a message. Some are used only for remote deliveries; | |
460 | some only for local. A particular set of fields is copied whenever a child | |
461 | address is created. For convenience, we keep those fields in a separate | |
462 | sub-structure so they can be copied in one go. This also means I won't forget | |
463 | to edit the various copying places when new to-be-copied fields are added. */ | |
464 | ||
465 | typedef struct address_item_propagated { | |
466 | uschar *address_data; /* arbitrary data to keep with the address */ | |
467 | uschar *domain_data; /* from "domains" lookup */ | |
468 | uschar *localpart_data; /* from "local_parts" lookup */ | |
469 | uschar *errors_address; /* where to send errors (NULL => sender) */ | |
470 | header_line *extra_headers; /* additional headers */ | |
471 | uschar *remove_headers; /* list of those to remove */ | |
472 | } address_item_propagated; | |
473 | ||
474 | /* Bits for the flags field below */ | |
475 | ||
476 | #define af_allow_file 0x00000001 /* allow file in generated address */ | |
477 | #define af_allow_pipe 0x00000002 /* allow pipe in generated address */ | |
478 | #define af_allow_reply 0x00000004 /* allow autoreply in generated address */ | |
479 | #define af_dr_retry_exists 0x00000008 /* router retry record exists */ | |
480 | #define af_expand_pipe 0x00000010 /* expand pipe arguments */ | |
481 | #define af_file 0x00000020 /* file delivery; always with pfr */ | |
482 | #define af_gid_set 0x00000040 /* gid field is set */ | |
483 | #define af_home_expanded 0x00000080 /* home_dir is already expanded */ | |
484 | #define af_ignore_error 0x00000100 /* ignore delivery error */ | |
485 | #define af_initgroups 0x00000200 /* use initgroups() for local transporting */ | |
486 | #define af_local_host_removed 0x00000400 /* local host was backup */ | |
487 | #define af_lt_retry_exists 0x00000800 /* local transport retry exists */ | |
488 | #define af_pfr 0x00001000 /* pipe or file or reply delivery */ | |
489 | #define af_retry_skipped 0x00002000 /* true if retry caused some skipping */ | |
490 | #define af_retry_timedout 0x00004000 /* true if retry timed out */ | |
491 | #define af_uid_set 0x00008000 /* uid field is set */ | |
492 | #define af_hide_child 0x00010000 /* hide child in bounce/defer msgs */ | |
493 | #define af_sverify_told 0x00020000 /* sender verify failure notified */ | |
494 | #define af_verify_pmfail 0x00040000 /* verify failure was postmaster callout */ | |
495 | #define af_verify_nsfail 0x00080000 /* verify failure was null sender callout */ | |
496 | #define af_homonym 0x00100000 /* an ancestor has same address */ | |
497 | #define af_verify_routed 0x00200000 /* for cached sender verify: routed OK */ | |
498 | #define af_verify_callout 0x00400000 /* for cached sender verify: callout was specified */ | |
499 | #define af_include_affixes 0x00800000 /* delivered with affixes in RCPT */ | |
500 | #define af_cert_verified 0x01000000 /* delivered with verified TLS cert */ | |
501 | ||
502 | /* These flags must be propagated when a child is created */ | |
503 | ||
504 | #define af_propagate (af_ignore_error) | |
505 | ||
506 | /* The main address structure. Note that fields that are to be copied to | |
507 | generated addresses should be put in the address_item_propagated structure (see | |
508 | above) rather than directly into the address_item structure. */ | |
509 | ||
510 | typedef struct address_item { | |
511 | struct address_item *next; /* for chaining addresses */ | |
512 | struct address_item *parent; /* parent address */ | |
513 | struct address_item *first; /* points to first after group delivery */ | |
514 | struct address_item *dupof; /* points to address this is a duplicate of */ | |
515 | ||
516 | router_instance *start_router; /* generated address starts here */ | |
517 | router_instance *router; /* the router that routed */ | |
518 | transport_instance *transport; /* the transport to use */ | |
519 | ||
520 | host_item *host_list; /* host data for the transport */ | |
521 | host_item *host_used; /* host that took delivery or failed hard */ | |
522 | host_item *fallback_hosts; /* to try if delivery defers */ | |
523 | ||
524 | reply_item *reply; /* data for autoreply */ | |
525 | retry_item *retries; /* chain of retry information */ | |
526 | ||
527 | uschar *address; /* address being delivered or routed */ | |
528 | uschar *unique; /* used for disambiguating */ | |
529 | uschar *cc_local_part; /* caseful local part */ | |
530 | uschar *lc_local_part; /* lowercased local part */ | |
531 | uschar *local_part; /* points to cc or lc version */ | |
532 | uschar *prefix; /* stripped prefix of local part */ | |
533 | uschar *suffix; /* stripped suffix of local part */ | |
534 | uschar *domain; /* working domain (lower cased) */ | |
535 | ||
536 | uschar *address_retry_key; /* retry key including full address */ | |
537 | uschar *domain_retry_key; /* retry key for domain only */ | |
538 | ||
539 | uschar *current_dir; /* current directory for transporting */ | |
540 | uschar *home_dir; /* home directory for transporting */ | |
541 | uschar *message; /* error message */ | |
542 | uschar *user_message; /* error message that can be sent over SMTP | |
543 | or quoted in bounce message */ | |
544 | uschar *onetime_parent; /* saved original parent for onetime */ | |
545 | uschar **pipe_expandn; /* numeric expansions for pipe from filter */ | |
546 | uschar *return_filename; /* name of return file */ | |
547 | uschar *self_hostname; /* after self=pass */ | |
548 | uschar *shadow_message; /* info about shadow transporting */ | |
549 | ||
550 | #ifdef SUPPORT_TLS | |
551 | uschar *cipher; /* Cipher used for transport */ | |
552 | uschar *peerdn; /* DN of server's certificate */ | |
553 | #endif | |
554 | ||
555 | uid_t uid; /* uid for transporting */ | |
556 | gid_t gid; /* gid for transporting */ | |
557 | ||
558 | unsigned int flags; /* a row of bits, defined above */ | |
559 | unsigned int domain_cache[(MAX_NAMED_LIST * 2)/32]; | |
560 | unsigned int localpart_cache[(MAX_NAMED_LIST * 2)/32]; | |
561 | int mode; /* mode for local transporting to a file */ | |
562 | int more_errno; /* additional error information */ | |
563 | /* (may need to hold a timestamp) */ | |
564 | ||
565 | short int basic_errno; /* status after failure */ | |
566 | short int child_count; /* number of child addresses */ | |
567 | short int return_file; /* fileno of return data file */ | |
568 | short int special_action; /* ( used when when deferred or failed */ | |
569 | /* ( also */ | |
570 | /* ( contains = or - when successful SMTP delivered */ | |
571 | /* ( also */ | |
572 | /* ( contains verify rc in sender verify cache */ | |
573 | short int transport_return; /* result of delivery attempt */ | |
574 | address_item_propagated p; /* fields that are propagated to children */ | |
575 | } address_item; | |
576 | ||
577 | /* The table of header names consists of items of this type */ | |
578 | ||
579 | typedef struct { | |
580 | uschar *name; | |
581 | int len; | |
582 | BOOL allow_resent; | |
583 | int htype; | |
584 | } header_name; | |
585 | ||
586 | /* Chain of information about errors (e.g. bad addresses) */ | |
587 | ||
588 | typedef struct error_block { | |
589 | struct error_block *next; | |
590 | uschar *text1; | |
591 | uschar *text2; | |
592 | } error_block; | |
593 | ||
594 | /* Chain of file names when processing the queue */ | |
595 | ||
596 | typedef struct queue_filename { | |
597 | struct queue_filename *next; | |
598 | uschar dir_uschar; | |
599 | uschar text[1]; | |
600 | } queue_filename; | |
601 | ||
602 | /* Chain of items of retry information, read from the retry config. */ | |
603 | ||
604 | typedef struct retry_rule { | |
605 | struct retry_rule *next; | |
606 | int rule; | |
607 | int timeout; | |
608 | int p1; | |
609 | int p2; | |
610 | } retry_rule; | |
611 | ||
612 | typedef struct retry_config { | |
613 | struct retry_config *next; | |
614 | uschar *pattern; | |
615 | int basic_errno; | |
616 | int more_errno; | |
617 | uschar *senders; | |
618 | retry_rule *rules; | |
619 | } retry_config; | |
620 | ||
621 | /* Structure for each node in a tree, of which there are various kinds */ | |
622 | ||
623 | typedef struct tree_node { | |
624 | struct tree_node *left; /* pointer to left child */ | |
625 | struct tree_node *right; /* pointer to right child */ | |
626 | union | |
627 | { | |
628 | void *ptr; /* pointer to data */ | |
629 | int val; /* or integer data */ | |
630 | } data; | |
631 | uschar balance; /* balancing factor */ | |
632 | uschar name[1]; /* node name - variable length */ | |
633 | } tree_node; | |
634 | ||
635 | /* Structure for holding the handle and the cached last lookup for searches. | |
636 | This block is pointed to by the tree entry for the file. The file can get | |
637 | closed if too many are opened at once. There is a LRU chain for deciding which | |
638 | to close. */ | |
639 | ||
640 | typedef struct search_cache { | |
641 | void *handle; /* lookup handle, or NULL if closed */ | |
642 | int search_type; /* search type */ | |
643 | tree_node *up; /* LRU up pointer */ | |
644 | tree_node *down; /* LRU down pointer */ | |
645 | tree_node *item_cache; /* tree of cached results */ | |
646 | } search_cache; | |
647 | ||
648 | /* Structure for holding a partially decoded DNS record; the name has been | |
649 | uncompressed, but the data pointer is into the raw data. */ | |
650 | ||
651 | typedef struct { | |
652 | uschar name[DNS_MAXNAME]; /* domain name */ | |
653 | int type; /* record type */ | |
654 | int size; /* size of data */ | |
655 | uschar *data; /* pointer to data */ | |
656 | } dns_record; | |
657 | ||
658 | /* Structure for holding the result of a DNS query. */ | |
659 | ||
660 | typedef struct { | |
661 | int answerlen; /* length of the answer */ | |
662 | uschar answer[MAXPACKET]; /* the answer itself */ | |
663 | } dns_answer; | |
664 | ||
665 | /* Structure for holding the intermediate data while scanning a DNS answer | |
666 | block. */ | |
667 | ||
668 | typedef struct { | |
669 | int rrcount; /* count of RRs in the answer */ | |
670 | uschar *aptr; /* pointer in the answer while scanning */ | |
671 | dns_record srr; /* data from current record in scan */ | |
672 | } dns_scan; | |
673 | ||
674 | /* Structure for holding a chain of IP addresses that are extracted from | |
675 | an A, AAAA, or A6 record. For the first two, there is only ever one address, | |
676 | but the chaining feature of A6 allows for several addresses to be realized from | |
677 | a single initial A6 record. The structure defines the address field of length | |
678 | 1. In use, a suitable sized block is obtained to hold the complete textual | |
679 | address. */ | |
680 | ||
681 | typedef struct dns_address { | |
682 | struct dns_address *next; | |
683 | uschar address[1]; | |
684 | } dns_address; | |
685 | ||
686 | /* Structure used for holding intermediate data during MD5 computations. */ | |
687 | ||
688 | typedef struct md5 { | |
689 | unsigned int length; | |
690 | unsigned int abcd[4]; | |
691 | } | |
692 | md5; | |
693 | ||
694 | /* Structure used for holding intermediate data during SHA-1 computations. */ | |
695 | ||
696 | typedef struct sha1 { | |
697 | unsigned int H[5]; | |
698 | unsigned int length; | |
699 | } | |
700 | sha1; | |
701 | ||
702 | /* Structure used to hold incoming packets of SMTP responses for a specific | |
703 | socket. The packets which may contain multiple lines (and in some cases, | |
704 | multiple responses). */ | |
705 | ||
706 | typedef struct smtp_inblock { | |
707 | int sock; /* the socket */ | |
708 | int buffersize; /* the size of the buffer */ | |
709 | uschar *ptr; /* current position in the buffer */ | |
710 | uschar *ptrend; /* end of data in the buffer */ | |
711 | uschar *buffer; /* the buffer itself */ | |
712 | } smtp_inblock; | |
713 | ||
714 | /* Structure used to hold buffered outgoing packets of SMTP commands for a | |
715 | specific socket. The packets which may contain multiple lines when pipelining | |
716 | is in use. */ | |
717 | ||
718 | typedef struct smtp_outblock { | |
719 | int sock; /* the socket */ | |
720 | int cmd_count; /* count of buffered commands */ | |
721 | int buffersize; /* the size of the buffer */ | |
722 | BOOL authenticating; /* TRUE when authenticating */ | |
723 | uschar *ptr; /* current position in the buffer */ | |
724 | uschar *buffer; /* the buffer itself */ | |
725 | } smtp_outblock; | |
726 | ||
727 | /* Structure to hold information about the source of redirection information */ | |
728 | ||
729 | typedef struct redirect_block { | |
730 | uschar *string; /* file name or string */ | |
731 | uid_t *owners; /* allowed file owners */ | |
732 | gid_t *owngroups; /* allowed file groups */ | |
733 | struct passwd *pw; /* possible owner if not NULL */ | |
734 | int modemask; /* forbidden bits */ | |
735 | BOOL isfile; /* TRUE if string is a file name */ | |
736 | BOOL check_owner; /* TRUE, FALSE, or TRUE_UNSET */ | |
737 | BOOL check_group; /* TRUE, FALSE, or TRUE_UNSET */ | |
738 | } redirect_block; | |
739 | ||
740 | /* Structure for passing arguments to check_host() */ | |
741 | ||
742 | typedef struct check_host_block { | |
743 | uschar *host_name; | |
744 | uschar *host_address; | |
745 | uschar *host_ipv4; | |
746 | BOOL negative; | |
747 | } check_host_block; | |
748 | ||
749 | /* Structure for remembering lookup data when caching the result of | |
750 | a lookup in a named list. */ | |
751 | ||
752 | typedef struct namedlist_cacheblock { | |
753 | struct namedlist_cacheblock *next; | |
754 | uschar *key; | |
755 | uschar *data; | |
756 | } namedlist_cacheblock; | |
757 | ||
758 | /* Structure for holding data for an entry in a named list */ | |
759 | ||
760 | typedef struct namedlist_block { | |
761 | uschar *string; /* the list string */ | |
762 | namedlist_cacheblock *cache_data; /* cached domain_data or localpart_data */ | |
763 | int number; /* the number of the list for caching */ | |
764 | } namedlist_block; | |
765 | ||
766 | /* Structures for Access Control Lists */ | |
767 | ||
768 | typedef struct acl_condition_block { | |
769 | struct acl_condition_block *next; | |
770 | uschar *arg; | |
771 | int type; | |
772 | union { | |
773 | BOOL negated; | |
774 | int varnumber; | |
775 | } u; | |
776 | } acl_condition_block; | |
777 | ||
778 | typedef struct acl_block { | |
779 | struct acl_block *next; | |
780 | acl_condition_block *condition; | |
781 | int verb; | |
782 | } acl_block; | |
783 | ||
784 | /* End of structs.h */ |