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