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