55ffd5c6fe1fdd51d47e70756dc0919ee5007853
[exim.git] / src / src / retry.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2009 */
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
20 the maximum retry time for a particular host or address.
21
22 Arguments:
23   retry_key     the key to look up a retry rule
24   domain        the domain to look up a domain retry rule
25   retry_record  contains error information for finding rule
26   now           the time
27
28 Returns:        TRUE if the ultimate timeout has been reached
29 */
30
31 BOOL
32 retry_ultimate_address_timeout(uschar *retry_key, uschar *domain,
33   dbdata_retry *retry_record, time_t now)
34 {
35 BOOL address_timeout;
36
37 DEBUG(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   }
44
45 retry_config *retry =
46   retry_find_config(retry_key+2, domain,
47     retry_record->basic_errno, retry_record->more_errno);
48
49 if (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);
55   DEBUG(D_retry)
56     debug_printf("  received_time=%d diff=%d timeout=%d\n",
57       received_time, (int)(now - received_time), last_rule->timeout);
58   address_timeout = (now - received_time > last_rule->timeout);
59   }
60 else
61   {
62   DEBUG(D_retry)
63     debug_printf("no retry rule found: assume timed out\n");
64   address_timeout = TRUE;
65   }
66
67 DEBUG(D_retry)
68   if (address_timeout)
69     debug_printf("on queue longer than maximum retry for address - "
70       "allowing delivery\n");
71
72 return 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
82 IP address string. Its job is to set the status of the address if it is not
83 already 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
97 The reason a delivery is permitted when a message has been around for a very
98 long time is to allow the ultimate address timeout to operate after a delivery
99 failure. Otherwise some messages may stick around without being tried for too
100 long.
101
102 If a host retry record is retrieved from the hints database, the time of last
103 trying is filled into the last_try field of the host block. If a host is
104 generally usable, a check is made to see if there is a retry delay on this
105 specific message at this host.
106
107 If a non-standard port is being used, it is added to the retry key.
108
109 Arguments:
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
120 Returns:    TRUE if the host has expired but is usable because
121              its retry time has come
122 */
123
124 BOOL
125 retry_check_address(uschar *domain, host_item *host, uschar *portstring,
126   BOOL include_ip_address, uschar **retry_host_key, uschar **retry_message_key)
127 {
128 BOOL yield = FALSE;
129 time_t now = time(NULL);
130 uschar *host_key, *message_key;
131 open_db dbblock;
132 open_db *dbm_file;
133 tree_node *node;
134 dbdata_retry *host_retry_record, *message_retry_record;
135
136 *retry_host_key = *retry_message_key = NULL;
137
138 DEBUG(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
142 if (host->status != hstatus_unknown) return FALSE;
143 host->status = hstatus_usable;
144
145 /* Generate the host key for the unusable tree and the retry database. Ensure
146 host names are lower cased (that's what %S does). */
147
148 host_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
154 message_key = string_sprintf("%s:%s", host_key, message_id);
155
156 /* Search the tree of unusable IP addresses. This is filled in when deliveries
157 fail, because the retry database itself is not updated until the end of all
158 deliveries (so as to do it all in one go). The tree records addresses that have
159 become unusable during this delivery process (i.e. those that will get put into
160 the retry database when it is updated). */
161
162 node = tree_search(tree_unusable, host_key);
163 if (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
173 the retry records, and then close the database again. */
174
175 if ((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   }
181 host_retry_record = dbfn_read(dbm_file, host_key);
182 message_retry_record = dbfn_read(dbm_file, message_key);
183 dbfn_close(dbm_file);
184
185 /* Ignore the data if it is too old - too long since it was written */
186
187 if (host_retry_record == NULL)
188   {
189   DEBUG(D_transport|D_retry) debug_printf("no host retry record\n");
190   }
191 else 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
197 if (message_retry_record == NULL)
198   {
199   DEBUG(D_transport|D_retry) debug_printf("no message retry record\n");
200   }
201 else 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
208 time (or forcing). If not, and the host is not expired, check for the message
209 having been around for longer than the maximum retry time for this host or
210 address. Allow the delivery if it has. Otherwise set the appropriate unusable
211 flag and return FALSE. Otherwise arrange to return TRUE if this is an expired
212 host. */
213
214 if (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     {
223     if (!host_retry_record->expired &&
224         retry_ultimate_address_timeout(host_key, domain,
225           host_retry_record, now))
226       return FALSE;
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
243 for reaching its retry time (or forcing). If not, mark the host unusable,
244 unless the ultimate address timeout has been reached. */
245
246 if (message_retry_record != NULL)
247   {
248   *retry_message_key = message_key;
249   if (now < message_retry_record->next_try && !deliver_force)
250     {
251     if (!retry_ultimate_address_timeout(host_key, domain,
252         message_retry_record, now))
253       {
254       host->status = hstatus_unusable;
255       host->why = hwhy_retry;
256       }
257     return FALSE;
258     }
259   }
260
261 return 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
272 or by a transport, or if it succeeds or fails and there was a previous retry
273 item that now needs to be deleted. Sometimes there can be both kinds of item:
274 for example, if routing was deferred but then succeeded, and delivery then
275 deferred. In that case there is a delete item for the routing retry, and an
276 updating item for the delivery.
277
278 (But note that that is only visible at the outer level, because in remote
279 delivery subprocesses, the address starts "clean", with no retry items carried
280 in.)
281
282 These items are used at the end of a delivery attempt to update the retry
283 database. The keys start R: for routing delays and T: for transport delays.
284
285 Arguments:
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
290 Returns:  nothing
291 */
292
293 void
294 retry_add_item(address_item *addr, uschar *key, int flags)
295 {
296 retry_item *rti = store_get(sizeof(retry_item));
297 host_item * host = addr->host_used;
298 rti->next = addr->retries;
299 addr->retries = rti;
300 rti->key = key;
301 rti->basic_errno = addr->basic_errno;
302 rti->more_errno = addr->more_errno;
303 rti->message = host
304   ? string_sprintf("H=%s [%s]: %s", host->name, host->address, addr->message)
305   : addr->message;
306 rti->flags = flags;
307
308 DEBUG(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
328 to a given destination. If the key contains an @ we are probably handling a
329 local delivery and have a complete address to search for; this happens when
330 retry_use_local_part is set on a router. Otherwise, the key is likely to be a
331 host name for a remote delivery, or a domain name for a local delivery. We
332 prepend *@ on the front of it so that it will match a retry item whose address
333 item pattern is independent of the local part. The alternate key, if set, is
334 always just a domain, so we treat it likewise.
335
336 Arguments:
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
342 Returns:       pointer to retry rule, or NULL
343 */
344
345 retry_config *
346 retry_find_config(uschar *key, uschar *alternate, int basic_errno,
347   int more_errno)
348 {
349 int replace = 0;
350 uschar *use_key, *use_alternate;
351 uschar *colon = Ustrchr(key, ':');
352 retry_config *yield;
353
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. */
371
372 if (colon != NULL)
373   {
374   if (isalnum(*key))
375     replace = ':';
376   else
377     key = Ustrrchr(key, ':') + 1;   /* Take from the last colon */
378   }
379
380 if (replace == 0) colon = key + Ustrlen(key);
381 *colon = 0;
382
383 /* Sort out the keys */
384
385 use_key = (Ustrchr(key, '@') != NULL)? key : string_sprintf("*@%s", key);
386 use_alternate = (alternate == NULL)? NULL : string_sprintf("*@%s", alternate);
387
388 /* Scan the configured retry items. */
389
390 for (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
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:
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
433     else if (yield->basic_errno == ERRNO_MAIL4XX ||
434              yield->basic_errno == ERRNO_RCPT4XX ||
435              yield->basic_errno == ERRNO_DATA4XX)
436       {
437       int wanted;
438       if (basic_errno != yield->basic_errno) continue;
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;
501 return 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
512 deferred, or delete it for those that succeeded after a previous defer. This is
513 done all in one go to minimize opening/closing/locking of the database file.
514
515 Note that, because SMTP delivery involves a list of destinations to try, there
516 may be defer-type retry information for some of them even when the message was
517 successfully delivered. Likewise if it eventually failed.
518
519 This function may move addresses from the defer to the failed queue if the
520 ultimate retry time has expired.
521
522 Arguments:
523   addr_defer    queue of deferred addresses
524   addr_failed   queue of failed addresses
525   addr_succeed  queue of successful addresses
526
527 Returns:        nothing
528 */
529
530 void
531 retry_update(address_item **addr_defer, address_item **addr_failed,
532   address_item **addr_succeed)
533 {
534 open_db dbblock;
535 open_db *dbm_file = NULL;
536 time_t now = time(NULL);
537 int i;
538
539 DEBUG(D_retry) debug_printf("Processing retry items\n");
540
541 /* Three-times loop to handle succeeded, failed, and deferred addresses.
542 Deferred addresses must be handled after failed ones, because some may be moved
543 to the failed chain if they have timed out. */
544
545 for (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)
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);
657           else
658             debug_printf("retry for %s = %s %d %d\n", rti->key, retry->pattern,
659               retry->basic_errno, retry->more_errno);
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;
695         DEBUG(D_retry) debug_printf("failing_interval=%d message_age=%d\n",
696           failing_interval, message_age);
697
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. */
703
704         if ((rti->flags & rf_host) == 0 && message_age > failing_interval)
705           failing_interval = message_age;
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
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. */
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;
794           else  /* rule = 'G' or 'H' */
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;
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)
810                 next_try += random_number(next_gap - rule->p1)/2 +
811                   (next_gap - rule->p1)/2;
812               }
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);
907           addr->user_message = (addr->user_message == NULL)?
908             US"retry timeout exceeded" :
909             string_sprintf("%s: retry timeout exceeded", addr->user_message);
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
941 if (dbm_file != NULL) dbfn_close(dbm_file);
942
943 DEBUG(D_retry) debug_printf("end of retry processing\n");
944 }
945
946 /* End of retry.c */