Allow for linefold when generating more than one RFC 2047 encoded-word.
[exim.git] / src / src / retry.c
CommitLineData
3cd34f13 1/* $Cambridge: exim/src/src/retry.c,v 1.8 2006/02/16 16:37:57 ph10 Exp $ */
059ec3d9
PH
2
3/*************************************************
4* Exim - an Internet mail transport agent *
5*************************************************/
6
d7d7b7b9 7/* Copyright (c) University of Cambridge 1995 - 2006 */
059ec3d9
PH
8/* See the file NOTICE for conditions of use and distribution. */
9
10/* Functions concerned with retrying unsuccessful deliveries. */
11
12
13#include "exim.h"
14
15
16
17/*************************************************
18* Check the ultimate address timeout *
19*************************************************/
20
21/* This function tests whether a message has been on the queue longer than
22the maximum retry time for a particular host.
23
24Arguments:
25 host_key the key to look up a host retry rule
26 domain the domain to look up a domain retry rule
27 basic_errno a specific error number, or zero if none
28 more_errno additional data for the error
29 now the time
30
31Returns: TRUE if the ultimate timeout has been reached
32*/
33
34static BOOL
35ultimate_address_timeout(uschar *host_key, uschar *domain, int basic_errno,
36 int more_errno, time_t now)
37{
38BOOL address_timeout = TRUE; /* no rule => timed out */
39
40retry_config *retry =
41 retry_find_config(host_key+2, domain, basic_errno, more_errno);
42
43if (retry != NULL && retry->rules != NULL)
44 {
45 retry_rule *last_rule;
46 for (last_rule = retry->rules;
47 last_rule->next != NULL;
48 last_rule = last_rule->next);
ea49d0e1
PH
49 DEBUG(D_transport|D_retry)
50 debug_printf("now=%d received_time=%d diff=%d timeout=%d\n",
51 (int)now, received_time, (int)(now - received_time),
52 last_rule->timeout);
059ec3d9
PH
53 address_timeout = (now - received_time > last_rule->timeout);
54 }
ea49d0e1
PH
55else
56 {
57 DEBUG(D_transport|D_retry)
58 debug_printf("no retry rule found: assume timed out\n");
59 }
059ec3d9
PH
60
61return address_timeout;
62}
63
64
65
66/*************************************************
67* Set status of a host+address item *
68*************************************************/
69
70/* This function is passed a host_item which contains a host name and an
71IP address string. Its job is to set the status of the address if it is not
72already set (indicated by hstatus_unknown). The possible values are:
73
74 hstatus_usable the address is not listed in the unusable tree, and does
75 not have a retry record, OR the time is past the next
76 try time, OR the message has been on the queue for more
77 than the maximum retry time for a failing host
78
79 hstatus_unusable the address is listed in the unusable tree, or does have
80 a retry record, and the time is not yet at the next retry
81 time.
82
83 hstatus_unusable_expired as above, but also the retry time has expired
84 for this address.
85
86The reason a delivery is permitted when a message has been around for a very
87long time is to allow the ultimate address timeout to operate after a delivery
88failure. Otherwise some messages may stick around without being tried for too
89long.
90
91If a host retry record is retrieved from the hints database, the time of last
92trying is filled into the last_try field of the host block. If a host is
93generally usable, a check is made to see if there is a retry delay on this
94specific message at this host.
95
96If a non-standard port is being used, it is added to the retry key.
97
98Arguments:
99 domain the address domain
100 host pointer to a host item
101 portstring "" for standard port, ":xxxx" for a non-standard port
102 include_ip_address TRUE to include the address in the key - this is
103 usual, but sometimes is not wanted
104 retry_host_key where to put a pointer to the key for the host-specific
105 retry record, if one is read and the host is usable
106 retry_message_key where to put a pointer to the key for the message+host
107 retry record, if one is read and the host is usable
108
109Returns: TRUE if the host has expired but is usable because
110 its retry time has come
111*/
112
113BOOL
114retry_check_address(uschar *domain, host_item *host, uschar *portstring,
115 BOOL include_ip_address, uschar **retry_host_key, uschar **retry_message_key)
116{
117BOOL yield = FALSE;
118time_t now = time(NULL);
119uschar *host_key, *message_key;
120open_db dbblock;
121open_db *dbm_file;
122tree_node *node;
123dbdata_retry *host_retry_record, *message_retry_record;
124
125*retry_host_key = *retry_message_key = NULL;
126
127DEBUG(D_transport|D_retry) debug_printf("checking status of %s\n", host->name);
128
129/* Do nothing if status already set; otherwise initialize status as usable. */
130
131if (host->status != hstatus_unknown) return FALSE;
132host->status = hstatus_usable;
133
134/* Generate the host key for the unusable tree and the retry database. Ensure
135host names are lower cased (that's what %S does). */
136
137host_key = include_ip_address?
138 string_sprintf("T:%S:%s%s", host->name, host->address, portstring) :
139 string_sprintf("T:%S%s", host->name, portstring);
140
141/* Generate the message-specific key */
142
143message_key = string_sprintf("%s:%s", host_key, message_id);
144
145/* Search the tree of unusable IP addresses. This is filled in when deliveries
146fail, because the retry database itself is not updated until the end of all
147deliveries (so as to do it all in one go). The tree records addresses that have
148become unusable during this delivery process (i.e. those that will get put into
149the retry database when it is updated). */
150
151node = tree_search(tree_unusable, host_key);
152if (node != NULL)
153 {
154 DEBUG(D_transport|D_retry) debug_printf("found in tree of unusables\n");
155 host->status = (node->data.val > 255)?
156 hstatus_unusable_expired : hstatus_unusable;
157 host->why = node->data.val & 255;
158 return FALSE;
159 }
160
161/* Open the retry database, giving up if there isn't one. Otherwise, search for
162the retry records, and then close the database again. */
163
164if ((dbm_file = dbfn_open(US"retry", O_RDONLY, &dbblock, FALSE)) == NULL)
165 {
166 DEBUG(D_deliver|D_retry|D_hints_lookup)
167 debug_printf("no retry data available\n");
168 return FALSE;
169 }
170host_retry_record = dbfn_read(dbm_file, host_key);
171message_retry_record = dbfn_read(dbm_file, message_key);
172dbfn_close(dbm_file);
173
174/* Ignore the data if it is too old - too long since it was written */
175
176if (host_retry_record == NULL)
177 {
178 DEBUG(D_transport|D_retry) debug_printf("no host retry record\n");
179 }
180else if (now - host_retry_record->time_stamp > retry_data_expire)
181 {
182 host_retry_record = NULL;
183 DEBUG(D_transport|D_retry) debug_printf("host retry record too old\n");
184 }
185
186if (message_retry_record == NULL)
187 {
188 DEBUG(D_transport|D_retry) debug_printf("no message retry record\n");
189 }
190else if (now - message_retry_record->time_stamp > retry_data_expire)
191 {
192 message_retry_record = NULL;
193 DEBUG(D_transport|D_retry) debug_printf("message retry record too old\n");
194 }
195
196/* If there's a host-specific retry record, check for reaching the retry
197time (or forcing). If not, and the host is not expired, check for the message
198having been around for longer than the maximum retry time for this host or
199address. Allow the delivery if it has. Otherwise set the appropriate unusable
200flag and return FALSE. Otherwise arrange to return TRUE if this is an expired
201host. */
202
203if (host_retry_record != NULL)
204 {
205 *retry_host_key = host_key;
206
207 /* We have not reached the next try time. Check for the ultimate address
208 timeout if the host has not expired. */
209
210 if (now < host_retry_record->next_try && !deliver_force)
211 {
212 DEBUG(D_transport|D_retry)
213 debug_printf("host retry time not reached: checking ultimate address "
214 "timeout\n");
215
216 if (!host_retry_record->expired &&
217 ultimate_address_timeout(host_key, domain,
218 host_retry_record->basic_errno, host_retry_record->more_errno, now))
219 {
220 DEBUG(D_transport|D_retry)
221 debug_printf("on queue longer than maximum retry for "
222 "address - allowing delivery\n");
223 return FALSE;
224 }
225
226 /* We have not hit the ultimate address timeout; host is unusable. */
227
228 host->status = (host_retry_record->expired)?
229 hstatus_unusable_expired : hstatus_unusable;
230 host->why = hwhy_retry;
231 host->last_try = host_retry_record->last_try;
232 return FALSE;
233 }
234
235 /* Host is usable; set return TRUE if expired. */
236
237 yield = host_retry_record->expired;
238 }
239
240/* It's OK to try the host. If there's a message-specific retry record, check
241for reaching its retry time (or forcing). If not, mark the host unusable,
242unless the ultimate address timeout has been reached. */
243
244if (message_retry_record != NULL)
245 {
246 *retry_message_key = message_key;
247 if (now < message_retry_record->next_try && !deliver_force)
248 {
249 DEBUG(D_transport|D_retry)
250 debug_printf("host+message retry time not reached: checking ultimate "
251 "address timeout\n");
252 if (!ultimate_address_timeout(host_key, domain, 0, 0, now))
253 {
254 host->status = hstatus_unusable;
255 host->why = hwhy_retry;
256 }
257 else
258 {
259 DEBUG(D_transport|D_retry)
260 debug_printf("on queue longer than maximum retry for "
261 "address - allowing delivery\n");
262 }
263 return FALSE;
264 }
265 }
266
267return yield;
268}
269
270
271
272
273/*************************************************
274* Add a retry item to an address *
275*************************************************/
276
277/* Retry items are chained onto an address when it is deferred either by router
278or by a transport, or if it succeeds or fails and there was a previous retry
279item that now needs to be deleted. Sometimes there can be both kinds of item:
280for example, if routing was deferred but then succeeded, and delivery then
281deferred. In that case there is a delete item for the routing retry, and an
282updating item for the delivery.
283
284(But note that that is only visible at the outer level, because in remote
285delivery subprocesses, the address starts "clean", with no retry items carried
286in.)
287
288These items are used at the end of a delivery attempt to update the retry
289database. The keys start R: for routing delays and T: for transport delays.
290
291Arguments:
292 addr the address block onto which to hang the item
293 key the retry key
294 flags delete, host, and message flags, copied into the block
295
296Returns: nothing
297*/
298
299void
300retry_add_item(address_item *addr, uschar *key, int flags)
301{
302retry_item *rti = store_get(sizeof(retry_item));
303rti->next = addr->retries;
304addr->retries = rti;
305rti->key = key;
306rti->basic_errno = addr->basic_errno;
307rti->more_errno = addr->more_errno;
308rti->message = addr->message;
309rti->flags = flags;
310
311DEBUG(D_transport|D_retry)
312 {
313 int letter = rti->more_errno & 255;
314 debug_printf("added retry item for %s: errno=%d more_errno=", rti->key,
315 rti->basic_errno);
316 if (letter == 'A' || letter == 'M')
317 debug_printf("%d,%c", (rti->more_errno >> 8) & 255, letter);
318 else
319 debug_printf("%d", rti->more_errno);
320 debug_printf(" flags=%d\n", flags);
321 }
322}
323
324
325
326/*************************************************
327* Find retry configuration data *
328*************************************************/
329
330/* Search the in-store retry information for the first retry item that applies
331to a given destination. If the key contains an @ we are probably handling a
332local delivery and have a complete address to search for; this happens when
333retry_use_local_part is set on a router. Otherwise, the key is likely to be a
334host name for a remote delivery, or a domain name for a local delivery. We
335prepend *@ on the front of it so that it will match a retry item whose address
336item pattern is independent of the local part. The alternate key, if set, is
337always just a domain, so we treat it likewise.
338
339Arguments:
340 key key for which retry info is wanted
341 alternate alternative key, always just a domain
342 basic_errno specific error predicate on the retry rule, or zero
343 more_errno additional data for errno predicate
344
345Returns: pointer to retry rule, or NULL
346*/
347
348retry_config *
349retry_find_config(uschar *key, uschar *alternate, int basic_errno,
350 int more_errno)
351{
ea49d0e1 352int replace = 0;
059ec3d9
PH
353uschar *use_key, *use_alternate;
354uschar *colon = Ustrchr(key, ':');
355retry_config *yield;
356
ea49d0e1
PH
357/* If there's a colon in the key, there are two possibilities:
358
359(1) This is a key for a host, ip address, and possibly port, in the format
360
361 hostname:ip+port
362
363 In this case, we temporarily replace the colon with a zero, to terminate
364 the string after the host name.
365
366(2) This is a key for a pipe, file, or autoreply delivery, in the format
367
368 pipe-or-file-or-auto:x@y
369
370 where x@y is the original address that provoked the delivery. The pipe or
371 file or auto will start with | or / or >, whereas a host name will start
372 with a letter or a digit. In this case we want to use the original address
373 to search for a retry rule. */
059ec3d9
PH
374
375if (colon != NULL)
376 {
ea49d0e1
PH
377 if (isalnum(*key))
378 replace = ':';
379 else
380 key = Ustrrchr(key, ':') + 1; /* Take from the last colon */
059ec3d9 381 }
ea49d0e1
PH
382
383if (replace == 0) colon = key + Ustrlen(key);
059ec3d9
PH
384*colon = 0;
385
386/* Sort out the keys */
387
388use_key = (Ustrchr(key, '@') != NULL)? key : string_sprintf("*@%s", key);
389use_alternate = (alternate == NULL)? NULL : string_sprintf("*@%s", alternate);
390
391/* Scan the configured retry items. */
392
393for (yield = retries; yield != NULL; yield = yield->next)
394 {
395 uschar *plist = yield->pattern;
396 uschar *slist = yield->senders;
397
398 /* If a specific error is set for this item, check that we are handling that
399 specific error, and if so, check any additional error information if
400 required. */
401
402 if (yield->basic_errno != 0)
403 {
404 /* Special code is required for quota errors, as these can either be system
405 quota errors, or Exim's own quota imposition, which has a different error
406 number. Full partitions are also treated in the same way as quota errors.
407 */
408
409 if (yield->basic_errno == ERRNO_EXIMQUOTA)
410 {
411 if ((basic_errno != ERRNO_EXIMQUOTA && basic_errno != errno_quota &&
412 basic_errno != ENOSPC) ||
413 (yield->more_errno != 0 && yield->more_errno > more_errno))
414 continue;
415 }
416
417 /* Handle 4xx responses to RCPT. The code that was received is in the 2nd
418 least significant byte of more_errno (with 400 subtracted). The required
419 value is coded in the 2nd least significant byte of the yield->more_errno
420 field as follows:
421
422 255 => any 4xx code
423 >= 100 => the decade must match the value less 100
424 < 100 => the exact value must match
425 */
426
427 else if (yield->basic_errno == ERRNO_RCPT4XX)
428 {
429 int wanted;
430 if (basic_errno != ERRNO_RCPT4XX) continue;
431 wanted = (yield->more_errno >> 8) & 255;
432 if (wanted != 255)
433 {
434 int evalue = (more_errno >> 8) & 255;
435 if (wanted >= 100)
436 {
437 if ((evalue/10)*10 != wanted - 100) continue;
438 }
439 else if (evalue != wanted) continue;
440 }
441 }
442
443 /* There are some special cases for timeouts */
444
445 else if (yield->basic_errno == ETIMEDOUT)
446 {
447 if (basic_errno != ETIMEDOUT) continue;
448
449 /* Just RTEF_CTOUT in the rule => don't care about 'A'/'M' addresses */
450 if (yield->more_errno == RTEF_CTOUT)
451 {
452 if ((more_errno & RTEF_CTOUT) == 0) continue;
453 }
454
455 else if (yield->more_errno != 0)
456 {
457 int cf_errno = more_errno;
458 if ((yield->more_errno & RTEF_CTOUT) == 0) cf_errno &= ~RTEF_CTOUT;
459 if (yield->more_errno != cf_errno) continue;
460 }
461 }
462
463 /* Default checks for exact match */
464
465 else
466 {
467 if (yield->basic_errno != basic_errno ||
468 (yield->more_errno != 0 && yield->more_errno != more_errno))
469 continue;
470 }
471 }
472
473 /* If the "senders" condition is set, check it. Note that sender_address may
474 be null during -brt checking, in which case we do not use this rule. */
475
476 if (slist != NULL && (sender_address == NULL ||
477 match_address_list(sender_address, TRUE, TRUE, &slist, NULL, -1, 0,
478 NULL) != OK))
479 continue;
480
481 /* Check for a match between the address list item at the start of this retry
482 rule and either the main or alternate keys. */
483
484 if (match_address_list(use_key, TRUE, TRUE, &plist, NULL, -1, UCHAR_MAX+1,
485 NULL) == OK ||
486 (use_alternate != NULL &&
487 match_address_list(use_alternate, TRUE, TRUE, &plist, NULL, -1,
488 UCHAR_MAX+1, NULL) == OK))
489 break;
490 }
491
492*colon = replace;
493return yield;
494}
495
496
497
498
499/*************************************************
500* Update retry database *
501*************************************************/
502
503/* Update the retry data for any directing/routing/transporting that was
504deferred, or delete it for those that succeeded after a previous defer. This is
505done all in one go to minimize opening/closing/locking of the database file.
506
507Note that, because SMTP delivery involves a list of destinations to try, there
508may be defer-type retry information for some of them even when the message was
509successfully delivered. Likewise if it eventually failed.
510
511This function may move addresses from the defer to the failed queue if the
512ultimate retry time has expired.
513
514Arguments:
515 addr_defer queue of deferred addresses
516 addr_failed queue of failed addresses
517 addr_succeed queue of successful addresses
518
519Returns: nothing
520*/
521
522void
523retry_update(address_item **addr_defer, address_item **addr_failed,
524 address_item **addr_succeed)
525{
526open_db dbblock;
527open_db *dbm_file = NULL;
528time_t now = time(NULL);
529int i;
530
531DEBUG(D_retry) debug_printf("Processing retry items\n");
532
533/* Three-times loop to handle succeeded, failed, and deferred addresses.
534Deferred addresses must be handled after failed ones, because some may be moved
535to the failed chain if they have timed out. */
536
537for (i = 0; i < 3; i++)
538 {
539 address_item *endaddr, *addr;
540 address_item *last_first = NULL;
541 address_item **paddr = (i==0)? addr_succeed :
542 (i==1)? addr_failed : addr_defer;
543 address_item **saved_paddr = NULL;
544
545 DEBUG(D_retry) debug_printf("%s addresses:\n", (i == 0)? "Succeeded" :
546 (i == 1)? "Failed" : "Deferred");
547
548 /* Loop for each address on the chain. For deferred addresses, the whole
549 address times out unless one of its retry addresses has a retry rule that
550 hasn't yet timed out. Deferred addresses should not be requesting deletion
551 of retry items, but just in case they do by accident, treat that case
552 as "not timed out".
553
554 As well as handling the addresses themselves, we must also process any
555 retry items for any parent addresses - these are typically "delete" items,
556 because the parent must have succeeded in order to generate the child. */
557
558 while ((endaddr = *paddr) != NULL)
559 {
560 BOOL timed_out = FALSE;
561 retry_item *rti;
562
563 for (addr = endaddr; addr != NULL; addr = addr->parent)
564 {
565 int update_count = 0;
566 int timedout_count = 0;
567
568 DEBUG(D_retry) debug_printf("%s%s\n", addr->address, (addr->retries == NULL)?
569 ": no retry items" : "");
570
571 /* Loop for each retry item. */
572
573 for (rti = addr->retries; rti != NULL; rti = rti->next)
574 {
575 uschar *message;
576 int message_length, message_space, failing_interval, next_try;
577 retry_rule *rule, *final_rule;
578 retry_config *retry;
579 dbdata_retry *retry_record;
580
581 /* Open the retry database if it is not already open; failure to open
582 the file is logged, but otherwise ignored - deferred addresses will
583 get retried at the next opportunity. Not opening earlier than this saves
584 opening if no addresses have retry items - common when none have yet
585 reached their retry next try time. */
586
587 if (dbm_file == NULL)
588 dbm_file = dbfn_open(US"retry", O_RDWR, &dbblock, TRUE);
589
590 if (dbm_file == NULL)
591 {
592 DEBUG(D_deliver|D_retry|D_hints_lookup)
593 debug_printf("retry database not available for updating\n");
594 return;
595 }
596
597 /* If there are no deferred addresses, that is, if this message is
598 completing, and the retry item is for a message-specific SMTP error,
599 force it to be deleted, because there's no point in keeping data for
600 no-longer-existing messages. This situation can occur when a domain has
601 two hosts and a message-specific error occurs for the first of them,
602 but the address gets delivered to the second one. This optimization
603 doesn't succeed in cleaning out all the dead entries, but it helps. */
604
605 if (*addr_defer == NULL && (rti->flags & rf_message) != 0)
606 rti->flags |= rf_delete;
607
608 /* Handle the case of a request to delete the retry info for this
609 destination. */
610
611 if ((rti->flags & rf_delete) != 0)
612 {
613 (void)dbfn_delete(dbm_file, rti->key);
614 DEBUG(D_retry)
615 debug_printf("deleted retry information for %s\n", rti->key);
616 continue;
617 }
618
619 /* Count the number of non-delete retry items. This is so that we
620 can compare it to the count of timed_out ones, to check whether
621 all are timed out. */
622
623 update_count++;
624
625 /* Get the retry information for this destination and error code, if
626 any. If this item is for a remote host with ip address, then pass
627 the domain name as an alternative to search for. If no retry
628 information is found, we can't generate a retry time, so there is
629 no point updating the database. This retry item is timed out. */
630
631 if ((retry = retry_find_config(rti->key + 2,
632 ((rti->flags & rf_host) != 0)? addr->domain : NULL,
633 rti->basic_errno, rti->more_errno)) == NULL)
634 {
635 DEBUG(D_retry) debug_printf("No configured retry item for %s%s%s\n",
636 rti->key,
637 ((rti->flags & rf_host) != 0)? US" or " : US"",
638 ((rti->flags & rf_host) != 0)? addr->domain : US"");
639 if (addr == endaddr) timedout_count++;
640 continue;
641 }
642
643 DEBUG(D_retry)
644 {
645 if ((rti->flags & rf_host) != 0)
ea49d0e1
PH
646 debug_printf("retry for %s (%s) = %s %d %d\n", rti->key,
647 addr->domain, retry->pattern, retry->basic_errno,
648 retry->more_errno);
059ec3d9 649 else
ea49d0e1
PH
650 debug_printf("retry for %s = %s %d %d\n", rti->key, retry->pattern,
651 retry->basic_errno, retry->more_errno);
059ec3d9
PH
652 }
653
654 /* Set up the message for the database retry record. Because DBM
655 records have a maximum data length, we enforce a limit. There isn't
656 much point in keeping a huge message here, anyway. */
657
658 message = (rti->basic_errno > 0)? US strerror(rti->basic_errno) :
659 (rti->message == NULL)?
660 US"unknown error" : string_printing(rti->message);
661 message_length = Ustrlen(message);
662 if (message_length > 150) message_length = 150;
663
664 /* Read a retry record from the database or construct a new one.
665 Ignore an old one if it is too old since it was last updated. */
666
667 retry_record = dbfn_read(dbm_file, rti->key);
668 if (retry_record != NULL &&
669 now - retry_record->time_stamp > retry_data_expire)
670 retry_record = NULL;
671
672 if (retry_record == NULL)
673 {
674 retry_record = store_get(sizeof(dbdata_retry) + message_length);
675 message_space = message_length;
676 retry_record->first_failed = now;
677 retry_record->last_try = now;
678 retry_record->next_try = now;
679 retry_record->expired = FALSE;
680 retry_record->text[0] = 0; /* just in case */
681 }
682 else message_space = Ustrlen(retry_record->text);
683
684 /* Compute how long this destination has been failing */
685
686 failing_interval = now - retry_record->first_failed;
727071f8
PH
687 DEBUG(D_retry) debug_printf("failing_interval=%d message_age=%d\n",
688 failing_interval, message_age);
689
690 /* If the message has been on the queue longer than the recorded time
691 of failure, use the message's age instead. This can happen when some
692 messages can be delivered and others cannot; a successful delivery will
693 reset the first_failed time, and this can lead to a failing message
694 being retried too often. */
695
696 if (message_age > failing_interval) failing_interval = message_age;
059ec3d9
PH
697
698 /* Search for the current retry rule. The cutoff time of the
699 last rule is handled differently to the others. The rule continues
700 to operate for ever (the global maximum interval will eventually
701 limit the gaps) but its cutoff time determines when an individual
702 destination times out. If there are no retry rules, the destination
703 always times out, but we can't compute a retry time. */
704
705 final_rule = NULL;
706 for (rule = retry->rules; rule != NULL; rule = rule->next)
707 {
708 if (failing_interval <= rule->timeout) break;
709 final_rule = rule;
710 }
711
712 /* If there's an un-timed out rule, the destination has not
713 yet timed out, so the address as a whole has not timed out (but we are
714 interested in this only for the end address). Make sure the expired
715 flag is false (can be forced via fixdb from outside, but ensure it is
716 consistent with the rules whenever we go through here). */
717
718 if (rule != NULL)
719 {
720 retry_record->expired = FALSE;
721 }
722
723 /* Otherwise, set the retry timeout expired, and set the final rule
724 as the one from which to compute the next retry time. Subsequent
725 messages will fail immediately until the retry time is reached (unless
726 there are other, still active, retries). */
727
728 else
729 {
730 rule = final_rule;
731 retry_record->expired = TRUE;
732 if (addr == endaddr) timedout_count++;
733 }
734
735 /* There is a special case to consider when some messages get through
736 to a destination and others don't. This can happen locally when a
737 large message pushes a user over quota, and it can happen remotely
738 when a machine is on a dodgy Internet connection. The messages that
739 get through wipe the retry information, causing those that don't to
740 stay on the queue longer than the final retry time. In order to
741 avoid this, we check, using the time of arrival of the message, to
742 see if it has been on the queue for more than the final cutoff time,
743 and if so, cause this retry item to time out, and the retry time to
744 be set to "now" so that any subsequent messages in the same condition
745 also get tried. We search for the last rule onwards from the one that
746 is in use. If there are no retry rules for the item, rule will be null
747 and timedout_count will already have been updated.
748
749 This implements "timeout this rule if EITHER the host (or routing or
750 directing) has been failing for more than the maximum time, OR if the
727071f8
PH
751 message has been on the queue for more than the maximum time."
752
753 February 2006: It is possible that this code is no longer needed
754 following the change to the retry calculation to use the message age if
755 it is larger than the time since first failure. It may be that the
756 expired flag is always set when the other conditions are met. However,
757 this is a small bit of code, and it does no harm to leave it in place,
758 just in case. */
059ec3d9
PH
759
760 if (received_time <= retry_record->first_failed &&
761 addr == endaddr && !retry_record->expired && rule != NULL)
762 {
763 retry_rule *last_rule;
764 for (last_rule = rule;
765 last_rule->next != NULL;
766 last_rule = last_rule->next);
767 if (now - received_time > last_rule->timeout)
768 {
769 DEBUG(D_retry) debug_printf("on queue longer than maximum retry\n");
770 timedout_count++;
771 rule = NULL;
772 }
773 }
774
775 /* Compute the next try time from the rule, subject to the global
776 maximum, and update the retry database. If rule == NULL it means
777 there were no rules at all (and the timeout will be set expired),
778 or we have a message that is older than the final timeout. In this
779 case set the next retry time to now, so that one delivery attempt
780 happens for subsequent messages. */
781
782 if (rule == NULL) next_try = now; else
783 {
784 if (rule->rule == 'F') next_try = now + rule->p1;
6af56900 785 else /* rule = 'G' or 'H' */
059ec3d9
PH
786 {
787 int last_predicted_gap =
788 retry_record->next_try - retry_record->last_try;
789 int last_actual_gap = now - retry_record->last_try;
790 int lastgap = (last_predicted_gap < last_actual_gap)?
791 last_predicted_gap : last_actual_gap;
6af56900
PH
792 int next_gap = (lastgap * rule->p2)/1000;
793 if (rule->rule == 'G')
794 {
795 next_try = now + ((lastgap < rule->p1)? rule->p1 : next_gap);
796 }
797 else /* The 'H' rule */
798 {
799 next_try = now + rule->p1;
800 if (next_gap > rule->p1)
3cd34f13
PH
801 next_try += random_number(next_gap - rule->p1)/2 +
802 (next_gap - rule->p1)/2;
6af56900 803 }
059ec3d9
PH
804 }
805 }
806
807 /* Impose a global retry max */
808
809 if (next_try - now > retry_interval_max)
810 next_try = now + retry_interval_max;
811
812 /* If the new message length is greater than the previous one, we
813 have to copy the record first. */
814
815 if (message_length > message_space)
816 {
817 dbdata_retry *newr = store_get(sizeof(dbdata_retry) + message_length);
818 memcpy(newr, retry_record, sizeof(dbdata_retry));
819 retry_record = newr;
820 }
821
822 /* Set up the retry record; message_length may be less than the string
823 length for very long error strings. */
824
825 retry_record->last_try = now;
826 retry_record->next_try = next_try;
827 retry_record->basic_errno = rti->basic_errno;
828 retry_record->more_errno = rti->more_errno;
829 Ustrncpy(retry_record->text, message, message_length);
830 retry_record->text[message_length] = 0;
831
832 DEBUG(D_retry)
833 {
834 int letter = retry_record->more_errno & 255;
835 debug_printf("Writing retry data for %s\n", rti->key);
836 debug_printf(" first failed=%d last try=%d next try=%d expired=%d\n",
837 (int)retry_record->first_failed, (int)retry_record->last_try,
838 (int)retry_record->next_try, retry_record->expired);
839 debug_printf(" errno=%d more_errno=", retry_record->basic_errno);
840 if (letter == 'A' || letter == 'M')
841 debug_printf("%d,%c", (retry_record->more_errno >> 8) & 255,
842 letter);
843 else
844 debug_printf("%d", retry_record->more_errno);
845 debug_printf(" %s\n", retry_record->text);
846 }
847
848 (void)dbfn_write(dbm_file, rti->key, retry_record,
849 sizeof(dbdata_retry) + message_length);
850 } /* Loop for each retry item */
851
852 /* If all the non-delete retry items are timed out, the address is
853 timed out, provided that we didn't skip any hosts because their retry
854 time was not reached (or because of hosts_max_try). */
855
856 if (update_count > 0 && update_count == timedout_count)
857 {
858 if (!testflag(endaddr, af_retry_skipped))
859 {
860 DEBUG(D_retry) debug_printf("timed out: all retries expired\n");
861 timed_out = TRUE;
862 }
863 else
864 {
865 DEBUG(D_retry)
866 debug_printf("timed out but some hosts were skipped\n");
867 }
868 }
869 } /* Loop for an address and its parents */
870
871 /* If this is a deferred address, and retry processing was requested by
872 means of one or more retry items, and they all timed out, move the address
873 to the failed queue, and restart this loop without updating paddr.
874
875 If there were several addresses batched in the same remote delivery, only
876 the original top one will have host retry items attached to it, but we want
877 to handle all the same. Each will have a pointer back to its "top" address,
878 and they will now precede the item with the retries because addresses are
879 inverted when added to these final queues. We have saved information about
880 them in passing (below) so they can all be cut out at once. */
881
882 if (i == 2) /* Handling defers */
883 {
884 if (endaddr->retries != NULL && timed_out)
885 {
886 if (last_first == endaddr) paddr = saved_paddr;
887 addr = *paddr;
888 *paddr = endaddr->next;
889
890 endaddr->next = *addr_failed;
891 *addr_failed = addr;
892
893 for (;; addr = addr->next)
894 {
895 setflag(addr, af_retry_timedout);
896 addr->message = (addr->message == NULL)? US"retry timeout exceeded" :
897 string_sprintf("%s: retry timeout exceeded", addr->message);
fffffe4c
PH
898 addr->user_message = (addr->user_message == NULL)?
899 US"retry timeout exceeded" :
900 string_sprintf("%s: retry timeout exceeded", addr->user_message);
059ec3d9
PH
901 log_write(0, LOG_MAIN, "** %s%s%s%s: retry timeout exceeded",
902 addr->address,
903 (addr->parent == NULL)? US"" : US" <",
904 (addr->parent == NULL)? US"" : addr->parent->address,
905 (addr->parent == NULL)? US"" : US">");
906
907 if (addr == endaddr) break;
908 }
909
910 continue; /* Restart from changed *paddr */
911 }
912
913 /* This address is to remain on the defer chain. If it has a "first"
914 pointer, save the pointer to it in case we want to fail the set of
915 addresses when we get to the first one. */
916
917 if (endaddr->first != last_first)
918 {
919 last_first = endaddr->first;
920 saved_paddr = paddr;
921 }
922 }
923
924 /* All cases (succeed, fail, defer left on queue) */
925
926 paddr = &(endaddr->next); /* Advance to next address */
927 } /* Loop for all addresses */
928 } /* Loop for succeed, fail, defer */
929
930/* Close and unlock the database */
931
932if (dbm_file != NULL) dbfn_close(dbm_file);
933
934DEBUG(D_retry) debug_printf("end of retry processing\n");
935}
936
937/* End of retry.c */