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