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