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