src/src/transports/lmtp.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   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
  44 #ifdef MACRO_PREDEF
  45
  46 /* Dummy values */
  47 lmtp_transport_options_block lmtp_transport_option_defaults = {0};
  48 void lmtp_transport_init(transport_instance *tblock) {}
  49 BOOL lmtp_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
  50
  51 #else   /*!MACRO_PREDEF*/
  52
  53
  54 /* Default private options block for the lmtp transport. */
  55
  56 lmtp_transport_options_block lmtp_transport_option_defaults = {
  57   NULL,           /* cmd */
  58   NULL,           /* skt */
  59   5*60,           /* timeout */
  60   0,              /* options */
  61   FALSE           /* ignore_quota */
  62 };
  63
  64
  65
  66 /*************************************************
  67 *          Initialization entry point            *
  68 *************************************************/
  69
  70 /* Called for each instance, after its options have been read, to
  71 enable consistency checks to be done, or anything else that needs
  72 to be set up. */
  73
  74 void
  75 lmtp_transport_init(transport_instance *tblock)
  76 {
  77 lmtp_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
  82 if ((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
  89 if (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
  94 driver options. Only one of body_only and headers_only can be set. */
  95
  96 ob->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
 111 analyse. It sets an appropriate message and puts the first digit of the
 112 response code into the yield variable. If no response was actually read, a
 113 suitable digit is chosen.
 114
 115 Arguments:
 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
 120   message      where to put an error message
 121
 122 Returns:       TRUE if a "QUIT" command should be sent, else FALSE
 123 */
 124
 125 static 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
 132 if (*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
 144 if (*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
 152 end the DATA. */
 153
 154 if (*errno_value == ERRNO_FILTER_FAIL)
 155   {
 156   *message = string_sprintf("transport filter process failed (%d)%s",
 157     more_errno,
 158     (more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
 159   return FALSE;
 160   }
 161
 162 /* Handle a failed add_headers expansion; can't send QUIT as we mustn't
 163 end the DATA. */
 164
 165 if (*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
 175 if (*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
 183 if (buffer[0] != 0)
 184   {
 185   const uschar *s = string_printing(buffer);
 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.
 192 connection closed) case, which causes deferral. Otherwise, leave the errno
 193 value to be interpreted. In all cases, we have to assume the connection is now
 194 dead. */
 195
 196 if (*errno_value == 0)
 197   {
 198   *errno_value = ERRNO_SMTPCLOSED;
 199   *message = string_sprintf("LMTP connection closed after %s", big_buffer);
 200   }
 201
 202 return 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
 212 any error message.
 213
 214 Arguments:
 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
 220 Returns:     TRUE if successful, FALSE if not, with errno set
 221 */
 222
 223 static BOOL
 224 lmtp_write_command(int fd, const char *format, ...)
 225 {
 226 int count, rc;
 227 va_list ap;
 228 va_start(ap, format);
 229 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
 230   {
 231   va_end(ap);
 232   errno = ERRNO_SMTPFORMAT;
 233   return FALSE;
 234   }
 235 va_end(ap);
 236 count = Ustrlen(big_buffer);
 237 DEBUG(D_transport|D_v) debug_printf("  LMTP>> %s", big_buffer);
 238 rc = write(fd, big_buffer, count);
 239 big_buffer[count-2] = 0;     /* remove \r\n for debug and error message */
 240 if (rc > 0) return TRUE;
 241 DEBUG(D_transport) debug_printf("write failed: %s\n", strerror(errno));
 242 return 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
 253 response in the given buffer. It also analyzes the first digit of the reply
 254 code and returns FALSE if it is not acceptable.
 255
 256 FALSE is also returned after a reading error. In this case buffer[0] will be
 257 zero, and the error code will be in errno.
 258
 259 Arguments:
 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
 266 Returns:    TRUE if a valid, non-error response was received; else FALSE
 267 */
 268
 269 static BOOL
 270 lmtp_read_response(FILE *f, uschar *buffer, int size, int okdigit, int timeout)
 271 {
 272 int count;
 273 uschar *ptr = buffer;
 274 uschar *readptr = buffer;
 275
 276 /* Ensure errno starts out zero */
 277
 278 errno = 0;
 279
 280 /* Loop for handling LMTP responses that do not all come in one line. */
 281
 282 for (;;)
 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_CLR(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
 435 zero, because the caller of this function looks at errno when FALSE is
 436 returned, to distinguish between an unexpected return code and other errors
 437 such as timeouts, lost connections, etc. */
 438
 439 errno = 0;
 440 return 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
 453 returns FALSE, indicating that the first address has the status for all; in
 454 normal cases it returns TRUE, indicating that each address has its own status
 455 set. */
 456
 457 BOOL
 458 lmtp_transport_entry(
 459   transport_instance *tblock,      /* data for this instantiation */
 460   address_item *addrlist)          /* address(es) we are working on */
 461 {
 462 pid_t pid = 0;
 463 FILE *out;
 464 lmtp_transport_options_block *ob =
 465   (lmtp_transport_options_block *)(tblock->options_block);
 466 struct sockaddr_un sockun;         /* don't call this "sun" ! */
 467 int timeout = ob->timeout;
 468 int fd_in = -1, fd_out = -1;
 469 int code, save_errno;
 470 BOOL send_data;
 471 BOOL yield = FALSE;
 472 address_item *addr;
 473 uschar *igquotstr = US"";
 474 uschar *sockname = NULL;
 475 const uschar **argv;
 476 uschar buffer[256];
 477
 478 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
 479
 480 /* Initialization ensures that either a command or a socket is specified, but
 481 not both. When a command is specified, call the common function for creating an
 482 argument list and expanding the items. */
 483
 484 if (ob->cmd)
 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;
 491
 492   /* If the -N option is set, can't do any more. Presume all has gone well. */
 493   if (f.dont_deliver)
 494     goto MINUS_N;
 495
 496 /* As this is a local transport, we are already running with the required
 497 uid/gid and current directory. Request that the new process be a process group
 498 leader, 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     }
 507   }
 508
 509 /* When a socket is specified, expand the string and create a socket. */
 510
 511 else
 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     }
 529
 530   /* If the -N option is set, can't do any more. Presume all has gone well. */
 531   if (f.dont_deliver)
 532     goto MINUS_N;
 533
 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
 545
 546 /* Make the output we are going to read into a file. */
 547
 548 out = fdopen(fd_out, "rb");
 549
 550 /* Now we must implement the LMTP protocol. It is like SMTP, except that after
 551 the end of the message, a return code for every accepted RCPT TO is sent. This
 552 allows for message+recipient checks after the message has been received. */
 553
 554 /* First thing is to wait for an initial greeting. */
 555
 556 Ustrcpy(big_buffer, "initial connection");
 557 if (!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
 562 if (!lmtp_write_command(fd_in, "%s %s\r\n", "LHLO",
 563   primary_hostname)) goto WRITE_FAILED;
 564
 565 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
 566      timeout)) goto RESPONSE_FAILED;
 567
 568 /* If the ignore_quota option is set, note whether the server supports the
 569 IGNOREQUOTA option, and if so, set an appropriate addition for RCPT. */
 570
 571 if (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
 575 /* Now the envelope sender */
 576
 577 if (!lmtp_write_command(fd_in, "MAIL FROM:<%s>\r\n", return_path))
 578   goto WRITE_FAILED;
 579
 580 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 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     }
 587   goto RESPONSE_FAILED;
 588   }
 589
 590 /* Next, we hand over all the recipients. Some may be permanently or
 591 temporarily rejected; others may be accepted, for now. */
 592
 593 send_data = FALSE;
 594 for (addr = addrlist; addr != NULL; addr = addr->next)
 595   {
 596   if (!lmtp_write_command(fd_in, "RCPT TO:<%s>%s\r\n",
 597        transport_rcpt_address(addr, tblock->rcpt_include_affixes), igquotstr))
 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));
 609     setflag(addr, af_pass_message);   /* Allow message to go to user */
 610     if (buffer[0] == '5') addr->transport_return = FAIL; else
 611       {
 612       addr->basic_errno = ERRNO_RCPT4XX;
 613       addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 614       }
 615     }
 616   }
 617
 618 /* Now send the text of the message if there were any good recipients. */
 619
 620 if (send_data)
 621   {
 622   BOOL ok;
 623   transport_ctx tctx = {
 624     {fd_in},
 625     tblock,
 626     addrlist,
 627     US".", US"..",
 628     ob->options
 629   };
 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))
 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       }
 639     goto RESPONSE_FAILED;
 640     }
 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;
 649   ok = transport_write_message(&tctx, 0);
 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))
 672       {
 673       addr->transport_return = OK;
 674       if (LOGGING(smtp_confirmation))
 675         {
 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)? US string_copy(s) : US s;
 679         }
 680       }
 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       {
 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         }
 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;
 713       setflag(addr, af_pass_message);   /* Allow message to go to user */
 714       }
 715     }
 716   }
 717
 718 /* The message transaction has completed successfully - this doesn't mean that
 719 all the addresses have necessarily been transferred, but each has its status
 720 set, so we change the yield to TRUE. */
 721
 722 yield = TRUE;
 723 (void) lmtp_write_command(fd_in, "QUIT\r\n");
 724 (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
 725
 726 goto RETURN;
 727
 728
 729 /* Come here if any call to read_response, other than a response after the data
 730 phase, failed. Put the error in the top address - this will be replicated
 731 because the yield is still FALSE. (But omit ETIMEDOUT, as there will already be
 732 a suitable message.) Analyse the error, and if if isn't too bad, send a QUIT
 733 command. Wait for the response with a short timeout, so we don't wind up this
 734 process before the far end has had time to read the QUIT. */
 735
 736 RESPONSE_FAILED:
 737
 738 save_errno = errno;
 739 if (errno != ETIMEDOUT && errno != 0) addrlist->basic_errno = errno;
 740 addrlist->message = NULL;
 741
 742 if (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
 749 addrlist->transport_return = (code == '5')? FAIL : DEFER;
 750 if (code == '4' && save_errno > 0)
 751   addrlist->message = string_sprintf("%s: %s", addrlist->message,
 752     strerror(save_errno));
 753 goto KILL_AND_RETURN;
 754
 755 /* Come here if there are errors during writing of a command or the message
 756 itself. This error will be applied to all the addresses. */
 757
 758 WRITE_FAILED:
 759
 760 addrlist->transport_return = PANIC;
 761 addrlist->basic_errno = errno;
 762 if (errno == ERRNO_CHHEADER_FAIL)
 763   addrlist->message =
 764     string_sprintf("Failed to expand headers_add or headers_remove: %s",
 765       expand_string_message);
 766 else if (errno == ERRNO_FILTER_FAIL)
 767   addrlist->message = string_sprintf("Filter process failure");
 768 else if (errno == ERRNO_WRITEINCOMPLETE)
 769   addrlist->message = string_sprintf("Failed repeatedly to write data");
 770 else if (errno == ERRNO_SMTPFORMAT)
 771   addrlist->message = US"overlong LMTP command generated";
 772 else
 773   addrlist->message = string_sprintf("Error %d", errno);
 774
 775 /* Come here after errors. Kill off the process. */
 776
 777 KILL_AND_RETURN:
 778
 779 if (pid > 0) killpg(pid, SIGKILL);
 780
 781 /* Come here from all paths after the subprocess is created. Wait for the
 782 process, but with a timeout. */
 783
 784 RETURN:
 785
 786 (void)child_close(pid, timeout);
 787
 788 if (fd_in >= 0) (void)close(fd_in);
 789 if (fd_out >= 0) (void)fclose(out);
 790
 791 DEBUG(D_transport)
 792   debug_printf("%s transport yields %d\n", tblock->name, yield);
 793
 794 return yield;
 795
 796
 797 MINUS_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;
 803 }
 804
 805 #endif  /*!MACRO_PREDEF*/
 806 /* End of transport/lmtp.c */