84bbeb939144ce5a9b27a96a63b5c7e8853678c1
[exim.git] / src / src / transports / lmtp.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8
9 #include "../exim.h"
10 #include "lmtp.h"
11
12 #define PENDING_OK 256
13
14
15 /* Options specific to the lmtp transport. They must be in alphabetic
16 order (note that "_" comes before the lower case letters). Those starting
17 with "*" are not settable by the user but are used by the option-reading
18 software for alternative value types. Some options are stored in the transport
19 instance block so as to be publicly visible; these are flagged with opt_public.
20 */
21
22 optionlist lmtp_transport_options[] = {
23   { "batch_id",          opt_stringptr | opt_public,
24       (void *)offsetof(transport_instance, batch_id) },
25   { "batch_max",         opt_int | opt_public,
26       (void *)offsetof(transport_instance, batch_max) },
27   { "command",           opt_stringptr,
28       (void *)offsetof(lmtp_transport_options_block, cmd) },
29   { "ignore_quota",      opt_bool,
30       (void *)offsetof(lmtp_transport_options_block, ignore_quota) },
31   { "socket",            opt_stringptr,
32       (void *)offsetof(lmtp_transport_options_block, skt) },
33   { "timeout",           opt_time,
34       (void *)offsetof(lmtp_transport_options_block, timeout) }
35 };
36
37 /* Size of the options list. An extern variable has to be used so that its
38 address can appear in the tables drtables.c. */
39
40 int lmtp_transport_options_count =
41   sizeof(lmtp_transport_options)/sizeof(optionlist);
42
43 /* Default private options block for the lmtp transport. */
44
45 lmtp_transport_options_block lmtp_transport_option_defaults = {
46   NULL,           /* cmd */
47   NULL,           /* skt */
48   5*60,           /* timeout */
49   0,              /* options */
50   FALSE           /* ignore_quota */
51 };
52
53
54
55 /*************************************************
56 *          Initialization entry point            *
57 *************************************************/
58
59 /* Called for each instance, after its options have been read, to
60 enable consistency checks to be done, or anything else that needs
61 to be set up. */
62
63 void
64 lmtp_transport_init(transport_instance *tblock)
65 {
66 lmtp_transport_options_block *ob =
67   (lmtp_transport_options_block *)(tblock->options_block);
68
69 /* Either the command field or the socket field must be set */
70
71 if ((ob->cmd == NULL) == (ob->skt == NULL))
72   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
73     "one (and only one) of command or socket must be set for the %s transport",
74     tblock->name);
75
76 /* If a fixed uid field is set, then a gid field must also be set. */
77
78 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
79   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
80     "user set without group for the %s transport", tblock->name);
81
82 /* Set up the bitwise options for transport_write_message from the various
83 driver options. Only one of body_only and headers_only can be set. */
84
85 ob->options |=
86   (tblock->body_only? topt_no_headers : 0) |
87   (tblock->headers_only? topt_no_body : 0) |
88   (tblock->return_path_add? topt_add_return_path : 0) |
89   (tblock->delivery_date_add? topt_add_delivery_date : 0) |
90   (tblock->envelope_to_add? topt_add_envelope_to : 0) |
91   topt_use_crlf | topt_end_dot;
92 }
93
94
95 /*************************************************
96 *          Check an LMTP response                *
97 *************************************************/
98
99 /* This function is given an errno code and the LMTP response buffer to
100 analyse. It sets an appropriate message and puts the first digit of the
101 response code into the yield variable. If no response was actually read, a
102 suitable digit is chosen.
103
104 Arguments:
105   errno_value  pointer to the errno value
106   more_errno   from the top address for use with ERRNO_FILTER_FAIL
107   buffer       the LMTP response buffer
108   yield        where to put a one-digit LMTP response code
109   message      where to put an errror message
110
111 Returns:       TRUE if a "QUIT" command should be sent, else FALSE
112 */
113
114 static BOOL check_response(int *errno_value, int more_errno, uschar *buffer,
115   int *yield, uschar **message)
116 {
117 *yield = '4';    /* Default setting is to give a temporary error */
118
119 /* Handle response timeout */
120
121 if (*errno_value == ETIMEDOUT)
122   {
123   *message = string_sprintf("LMTP timeout after %s", big_buffer);
124   if (transport_count > 0)
125     *message = string_sprintf("%s (%d bytes written)", *message,
126       transport_count);
127   *errno_value = 0;
128   return FALSE;
129   }
130
131 /* Handle malformed LMTP response */
132
133 if (*errno_value == ERRNO_SMTPFORMAT)
134   {
135   *message = string_sprintf("Malformed LMTP response after %s: %s",
136     big_buffer, string_printing(buffer));
137   return FALSE;
138   }
139
140 /* Handle a failed filter process error; can't send QUIT as we mustn't
141 end the DATA. */
142
143 if (*errno_value == ERRNO_FILTER_FAIL)
144   {
145   *message = string_sprintf("transport filter process failed (%d)%s",
146     more_errno,
147     (more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
148   return FALSE;
149   }
150
151 /* Handle a failed add_headers expansion; can't send QUIT as we mustn't
152 end the DATA. */
153
154 if (*errno_value == ERRNO_CHHEADER_FAIL)
155   {
156   *message =
157     string_sprintf("failed to expand headers_add or headers_remove: %s",
158       expand_string_message);
159   return FALSE;
160   }
161
162 /* Handle failure to write a complete data block */
163
164 if (*errno_value == ERRNO_WRITEINCOMPLETE)
165   {
166   *message = string_sprintf("failed to write a data block");
167   return FALSE;
168   }
169
170 /* Handle error responses from the remote process. */
171
172 if (buffer[0] != 0)
173   {
174   uschar *s = string_printing(buffer);
175   *message = string_sprintf("LMTP error after %s: %s", big_buffer, s);
176   *yield = buffer[0];
177   return TRUE;
178   }
179
180 /* No data was read. If there is no errno, this must be the EOF (i.e.
181 connection closed) case, which causes deferral. Otherwise, leave the errno
182 value to be interpreted. In all cases, we have to assume the connection is now
183 dead. */
184
185 if (*errno_value == 0)
186   {
187   *errno_value = ERRNO_SMTPCLOSED;
188   *message = string_sprintf("LMTP connection closed after %s", big_buffer);
189   }
190
191 return FALSE;
192 }
193
194
195
196 /*************************************************
197 *             Write LMTP command                 *
198 *************************************************/
199
200 /* The formatted command is left in big_buffer so that it can be reflected in
201 any error message.
202
203 Arguments:
204   fd         the fd to write to
205   format     a format, starting with one of
206              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
207   ...        data for the format
208
209 Returns:     TRUE if successful, FALSE if not, with errno set
210 */
211
212 static BOOL
213 lmtp_write_command(int fd, const char *format, ...)
214 {
215 int count, rc;
216 va_list ap;
217 va_start(ap, format);
218 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
219   {
220   errno = ERRNO_SMTPFORMAT;
221   return FALSE;
222   }
223 va_end(ap);
224 count = Ustrlen(big_buffer);
225 DEBUG(D_transport|D_v) debug_printf("  LMTP>> %s", big_buffer);
226 rc = write(fd, big_buffer, count);
227 big_buffer[count-2] = 0;     /* remove \r\n for debug and error message */
228 if (rc > 0) return TRUE;
229 DEBUG(D_transport) debug_printf("write failed: %s\n", strerror(errno));
230 return FALSE;
231 }
232
233
234
235
236 /*************************************************
237 *              Read LMTP response                *
238 *************************************************/
239
240 /* This function reads an LMTP response with a timeout, and returns the
241 response in the given buffer. It also analyzes the first digit of the reply
242 code and returns FALSE if it is not acceptable.
243
244 FALSE is also returned after a reading error. In this case buffer[0] will be
245 zero, and the error code will be in errno.
246
247 Arguments:
248   f         a file to read from
249   buffer    where to put the response
250   size      the size of the buffer
251   okdigit   the expected first digit of the response
252   timeout   the timeout to use
253
254 Returns:    TRUE if a valid, non-error response was received; else FALSE
255 */
256
257 static BOOL
258 lmtp_read_response(FILE *f, uschar *buffer, int size, int okdigit, int timeout)
259 {
260 int count;
261 uschar *ptr = buffer;
262 uschar *readptr = buffer;
263
264 /* Ensure errno starts out zero */
265
266 errno = 0;
267
268 /* Loop for handling LMTP responses that do not all come in one line. */
269
270 for (;;)
271   {
272   /* If buffer is too full, something has gone wrong. */
273
274   if (size < 10)
275     {
276     *readptr = 0;
277     errno = ERRNO_SMTPFORMAT;
278     return FALSE;
279     }
280
281   /* Loop to cover the read getting interrupted. */
282
283   for (;;)
284     {
285     char *rc;
286     int save_errno;
287
288     *readptr = 0;           /* In case nothing gets read */
289     sigalrm_seen = FALSE;
290     alarm(timeout);
291     rc = Ufgets(readptr, size-1, f);
292     save_errno = errno;
293     alarm(0);
294     errno = save_errno;
295
296     if (rc != NULL) break;  /* A line has been read */
297
298     /* Handle timeout; must do this first because it uses EINTR */
299
300     if (sigalrm_seen) errno = ETIMEDOUT;
301
302     /* If some other interrupt arrived, just retry. We presume this to be rare,
303     but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
304     read() to exit). */
305
306     else if (errno == EINTR)
307       {
308       DEBUG(D_transport) debug_printf("EINTR while reading LMTP response\n");
309       continue;
310       }
311
312     /* Handle other errors, including EOF; ensure buffer is completely empty. */
313
314     buffer[0] = 0;
315     return FALSE;
316     }
317
318   /* Adjust size in case we have to read another line, and adjust the
319   count to be the length of the line we are about to inspect. */
320
321   count = Ustrlen(readptr);
322   size -= count;
323   count += readptr - ptr;
324
325   /* See if the final two characters in the buffer are \r\n. If not, we
326   have to read some more. At least, that is what we should do on a strict
327   interpretation of the RFC. But accept LF as well, as we do for SMTP. */
328
329   if (ptr[count-1] != '\n')
330     {
331     DEBUG(D_transport)
332       {
333       int i;
334       debug_printf("LMTP input line incomplete in one buffer:\n  ");
335       for (i = 0; i < count; i++)
336         {
337         int c = (ptr[i]);
338         if (mac_isprint(c)) debug_printf("%c", c); else debug_printf("<%d>", c);
339         }
340       debug_printf("\n");
341       }
342     readptr = ptr + count;
343     continue;
344     }
345
346   /* Remove any whitespace at the end of the buffer. This gets rid of CR, LF
347   etc. at the end. Show it, if debugging, formatting multi-line responses. */
348
349   while (count > 0 && isspace(ptr[count-1])) count--;
350   ptr[count] = 0;
351
352   DEBUG(D_transport|D_v)
353     {
354     uschar *s = ptr;
355     uschar *t = ptr;
356     while (*t != 0)
357       {
358       while (*t != 0 && *t != '\n') t++;
359       debug_printf("  %s %*s\n", (s == ptr)? "LMTP<<" : "      ",
360         (int)(t-s), s);
361       if (*t == 0) break;
362       s = t = t + 1;
363       }
364     }
365
366   /* Check the format of the response: it must start with three digits; if
367   these are followed by a space or end of line, the response is complete. If
368   they are followed by '-' this is a multi-line response and we must look for
369   another line until the final line is reached. The only use made of multi-line
370   responses is to pass them back as error messages. We therefore just
371   concatenate them all within the buffer, which should be large enough to
372   accept any reasonable number of lines. A multiline response may already
373   have been read in one go - hence the loop here. */
374
375   for(;;)
376     {
377     uschar *p;
378     if (count < 3 ||
379        !isdigit(ptr[0]) ||
380        !isdigit(ptr[1]) ||
381        !isdigit(ptr[2]) ||
382        (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
383       {
384       errno = ERRNO_SMTPFORMAT;    /* format error */
385       return FALSE;
386       }
387
388     /* If a single-line response, exit the loop */
389
390     if (ptr[3] != '-') break;
391
392     /* For a multi-line response see if the next line is already read, and if
393     so, stay in this loop to check it. */
394
395     p = ptr + 3;
396     while (*(++p) != 0)
397       {
398       if (*p == '\n')
399         {
400         ptr = ++p;
401         break;
402         }
403       }
404     if (*p == 0) break;   /* No more lines to check */
405     }
406
407   /* End of response. If the last of the lines we are looking at is the final
408   line, we are done. Otherwise more data has to be read. */
409
410   if (ptr[3] != '-') break;
411
412   /* Move the reading pointer upwards in the buffer and insert \n in case this
413   is an error message that subsequently gets printed. Set the scanning pointer
414   to the reading pointer position. */
415
416   ptr += count;
417   *ptr++ = '\n';
418   size--;
419   readptr = ptr;
420   }
421
422 /* Return a value that depends on the LMTP return code. Ensure that errno is
423 zero, because the caller of this function looks at errno when FALSE is
424 returned, to distinguish between an unexpected return code and other errors
425 such as timeouts, lost connections, etc. */
426
427 errno = 0;
428 return buffer[0] == okdigit;
429 }
430
431
432
433
434
435
436 /*************************************************
437 *              Main entry point                  *
438 *************************************************/
439
440 /* See local README for interface details. For setup-errors, this transport
441 returns FALSE, indicating that the first address has the status for all; in
442 normal cases it returns TRUE, indicating that each address has its own status
443 set. */
444
445 BOOL
446 lmtp_transport_entry(
447   transport_instance *tblock,      /* data for this instantiation */
448   address_item *addrlist)          /* address(es) we are working on */
449 {
450 pid_t pid = 0;
451 FILE *out;
452 lmtp_transport_options_block *ob =
453   (lmtp_transport_options_block *)(tblock->options_block);
454 struct sockaddr_un sockun;         /* don't call this "sun" ! */
455 int timeout = ob->timeout;
456 int fd_in = -1, fd_out = -1;
457 int code, save_errno;
458 BOOL send_data;
459 BOOL yield = FALSE;
460 address_item *addr;
461 uschar *igquotstr = US"";
462 uschar *sockname = NULL;
463 uschar **argv;
464 uschar buffer[256];
465
466 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
467
468 /* Initialization ensures that either a command or a socket is specified, but
469 not both. When a command is specified, call the common function for creating an
470 argument list and expanding the items. */
471
472 if (ob->cmd != NULL)
473   {
474   DEBUG(D_transport) debug_printf("using command %s\n", ob->cmd);
475   sprintf(CS buffer, "%.50s transport", tblock->name);
476   if (!transport_set_up_command(&argv, ob->cmd, TRUE, PANIC, addrlist, buffer,
477        NULL))
478     return FALSE;
479   }
480
481 /* When a socket is specified, expand the string and create a socket. */
482
483 else
484   {
485   DEBUG(D_transport) debug_printf("using socket %s\n", ob->skt);
486   sockname = expand_string(ob->skt);
487   if (sockname == NULL)
488     {
489     addrlist->message = string_sprintf("Expansion of \"%s\" (socket setting "
490       "for %s transport) failed: %s", ob->skt, tblock->name,
491       expand_string_message);
492     return FALSE;
493     }
494   if ((fd_in = fd_out = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
495     {
496     addrlist->message = string_sprintf(
497       "Failed to create socket %s for %s transport: %s",
498         ob->skt, tblock->name, strerror(errno));
499     return FALSE;
500     }
501   }
502
503 /* If the -N option is set, can't do any more. Presume all has gone well. */
504
505 if (dont_deliver)
506   {
507   DEBUG(D_transport)
508     debug_printf("*** delivery by %s transport bypassed by -N option",
509       tblock->name);
510   addrlist->transport_return = OK;
511   return FALSE;
512   }
513
514 /* As this is a local transport, we are already running with the required
515 uid/gid and current directory. Request that the new process be a process group
516 leader, so we can kill it and all its children on an error. */
517
518 if (ob->cmd != NULL)
519   {
520   if ((pid = child_open(argv, NULL, 0, &fd_in, &fd_out, TRUE)) < 0)
521     {
522     addrlist->message = string_sprintf(
523       "Failed to create child process for %s transport: %s", tblock->name,
524         strerror(errno));
525     return FALSE;
526     }
527   }
528
529 /* For a socket, try to make the connection */
530
531 else
532   {
533   sockun.sun_family = AF_UNIX;
534   sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1), sockname);
535   if(connect(fd_out, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
536     {
537     addrlist->message = string_sprintf(
538       "Failed to connect to socket %s for %s transport: %s",
539         sockun.sun_path, tblock->name, strerror(errno));
540     return FALSE;
541     }
542   }
543
544 /* Make the output we are going to read into a file. */
545
546 out = fdopen(fd_out, "rb");
547
548 /* Now we must implement the LMTP protocol. It is like SMTP, except that after
549 the end of the message, a return code for every accepted RCPT TO is sent. This
550 allows for message+recipient checks after the message has been received. */
551
552 /* First thing is to wait for an initial greeting. */
553
554 Ustrcpy(big_buffer, "initial connection");
555 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
556   timeout)) goto RESPONSE_FAILED;
557
558 /* Next, we send a LHLO command, and expect a positive response */
559
560 if (!lmtp_write_command(fd_in, "%s %s\r\n", "LHLO",
561   primary_hostname)) goto WRITE_FAILED;
562
563 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
564      timeout)) goto RESPONSE_FAILED;
565
566 /* If the ignore_quota option is set, note whether the server supports the
567 IGNOREQUOTA option, and if so, set an appropriate addition for RCPT. */
568
569 if (ob->ignore_quota)
570   igquotstr = (pcre_exec(regex_IGNOREQUOTA, NULL, CS buffer,
571     Ustrlen(CS buffer), 0, PCRE_EOPT, NULL, 0) >= 0)? US" IGNOREQUOTA" : US"";
572
573 /* Now the envelope sender */
574
575 if (!lmtp_write_command(fd_in, "MAIL FROM:<%s>\r\n", return_path))
576   goto WRITE_FAILED;
577
578 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
579   {
580   if (errno == 0 && buffer[0] == '4')
581     {
582     errno = ERRNO_MAIL4XX;
583     addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
584     }
585   goto RESPONSE_FAILED;
586   }
587
588 /* Next, we hand over all the recipients. Some may be permanently or
589 temporarily rejected; others may be accepted, for now. */
590
591 send_data = FALSE;
592 for (addr = addrlist; addr != NULL; addr = addr->next)
593   {
594   if (!lmtp_write_command(fd_in, "RCPT TO:<%s>%s\r\n",
595        transport_rcpt_address(addr, tblock->rcpt_include_affixes), igquotstr))
596     goto WRITE_FAILED;
597   if (lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
598     {
599     send_data = TRUE;
600     addr->transport_return = PENDING_OK;
601     }
602   else
603     {
604     if (errno != 0 || buffer[0] == 0) goto RESPONSE_FAILED;
605     addr->message = string_sprintf("LMTP error after %s: %s", big_buffer,
606       string_printing(buffer));
607     setflag(addr, af_pass_message);   /* Allow message to go to user */
608     if (buffer[0] == '5') addr->transport_return = FAIL; else
609       {
610       addr->basic_errno = ERRNO_RCPT4XX;
611       addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
612       }
613     }
614   }
615
616 /* Now send the text of the message if there were any good recipients. */
617
618 if (send_data)
619   {
620   BOOL ok;
621
622   if (!lmtp_write_command(fd_in, "DATA\r\n")) goto WRITE_FAILED;
623   if (!lmtp_read_response(out, buffer, sizeof(buffer), '3', timeout))
624     {
625     if (errno == 0 && buffer[0] == '4')
626       {
627       errno = ERRNO_DATA4XX;
628       addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
629       }
630     goto RESPONSE_FAILED;
631     }
632
633   sigalrm_seen = FALSE;
634   transport_write_timeout = timeout;
635   Ustrcpy(big_buffer, "sending data block");   /* For error messages */
636   DEBUG(D_transport|D_v)
637     debug_printf("  LMTP>> writing message and terminating \".\"\n");
638
639   transport_count = 0;
640   ok = transport_write_message(addrlist, fd_in, ob->options, 0,
641         tblock->add_headers, tblock->remove_headers, US".", US"..",
642         tblock->rewrite_rules, tblock->rewrite_existflags);
643
644   /* Failure can either be some kind of I/O disaster (including timeout),
645   or the failure of a transport filter or the expansion of added headers. */
646
647   if (!ok)
648     {
649     buffer[0] = 0;              /* There hasn't been a response */
650     goto RESPONSE_FAILED;
651     }
652
653   Ustrcpy(big_buffer, "end of data");   /* For error messages */
654
655   /* We now expect a response for every address that was accepted above,
656   in the same order. For those that get a response, their status is fixed;
657   any that are accepted have been handed over, even if later responses crash -
658   at least, that's how I read RFC 2033. */
659
660   for (addr = addrlist; addr != NULL; addr = addr->next)
661     {
662     if (addr->transport_return != PENDING_OK) continue;
663
664     if (lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
665       {
666       addr->transport_return = OK;
667       if ((log_extra_selector & LX_smtp_confirmation) != 0)
668         {
669         uschar *s = string_printing(buffer);
670         addr->message = (s == buffer)? (uschar *)string_copy(s) : s;
671         }
672       }
673     /* If the response has failed badly, use it for all the remaining pending
674     addresses and give up. */
675
676     else if (errno != 0 || buffer[0] == 0)
677       {
678       address_item *a;
679       save_errno = errno;
680       check_response(&save_errno, addr->more_errno, buffer, &code,
681         &(addr->message));
682       addr->transport_return = (code == '5')? FAIL : DEFER;
683       for (a = addr->next; a != NULL; a = a->next)
684         {
685         if (a->transport_return != PENDING_OK) continue;
686         a->basic_errno = addr->basic_errno;
687         a->message = addr->message;
688         a->transport_return = addr->transport_return;
689         }
690       break;
691       }
692
693     /* Otherwise, it's an LMTP error code return for one address */
694
695     else
696       {
697       if (buffer[0] == '4')
698         {
699         addr->basic_errno = ERRNO_DATA4XX;
700         addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
701         }
702       addr->message = string_sprintf("LMTP error after %s: %s", big_buffer,
703         string_printing(buffer));
704       addr->transport_return = (buffer[0] == '5')? FAIL : DEFER;
705       setflag(addr, af_pass_message);   /* Allow message to go to user */
706       }
707     }
708   }
709
710 /* The message transaction has completed successfully - this doesn't mean that
711 all the addresses have necessarily been transferred, but each has its status
712 set, so we change the yield to TRUE. */
713
714 yield = TRUE;
715 (void) lmtp_write_command(fd_in, "QUIT\r\n");
716 (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
717
718 goto RETURN;
719
720
721 /* Come here if any call to read_response, other than a response after the data
722 phase, failed. Put the error in the top address - this will be replicated
723 because the yield is still FALSE. (But omit ETIMEDOUT, as there will already be
724 a suitable message.) Analyse the error, and if if isn't too bad, send a QUIT
725 command. Wait for the response with a short timeout, so we don't wind up this
726 process before the far end has had time to read the QUIT. */
727
728 RESPONSE_FAILED:
729
730 save_errno = errno;
731 if (errno != ETIMEDOUT && errno != 0) addrlist->basic_errno = errno;
732 addrlist->message = NULL;
733
734 if (check_response(&save_errno, addrlist->more_errno,
735     buffer, &code, &(addrlist->message)))
736   {
737   (void) lmtp_write_command(fd_in, "QUIT\r\n");
738   (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
739   }
740
741 addrlist->transport_return = (code == '5')? FAIL : DEFER;
742 if (code == '4' && save_errno > 0)
743   addrlist->message = string_sprintf("%s: %s", addrlist->message,
744     strerror(save_errno));
745 goto KILL_AND_RETURN;
746
747 /* Come here if there are errors during writing of a command or the message
748 itself. This error will be applied to all the addresses. */
749
750 WRITE_FAILED:
751
752 addrlist->transport_return = PANIC;
753 addrlist->basic_errno = errno;
754 if (errno == ERRNO_CHHEADER_FAIL)
755   addrlist->message =
756     string_sprintf("Failed to expand headers_add or headers_remove: %s",
757       expand_string_message);
758 else if (errno == ERRNO_FILTER_FAIL)
759   addrlist->message = string_sprintf("Filter process failure");
760 else if (errno == ERRNO_WRITEINCOMPLETE)
761   addrlist->message = string_sprintf("Failed repeatedly to write data");
762 else if (errno == ERRNO_SMTPFORMAT)
763   addrlist->message = US"overlong LMTP command generated";
764 else
765   addrlist->message = string_sprintf("Error %d", errno);
766
767 /* Come here after errors. Kill off the process. */
768
769 KILL_AND_RETURN:
770
771 if (pid > 0) killpg(pid, SIGKILL);
772
773 /* Come here from all paths after the subprocess is created. Wait for the
774 process, but with a timeout. */
775
776 RETURN:
777
778 (void)child_close(pid, timeout);
779
780 if (fd_in >= 0) (void)close(fd_in);
781 if (fd_out >= 0) (void)fclose(out);
782
783 DEBUG(D_transport)
784   debug_printf("%s transport yields %d\n", tblock->name, yield);
785
786 return yield;
787 }
788
789 /* End of transport/lmtp.c */