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 gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
 227 int rc;
 228 va_list ap;
 229
 230 va_start(ap, format);
 231 if (!string_vformat(&gs, FALSE, CS format, ap))
 232   {
 233   va_end(ap);
 234   errno = ERRNO_SMTPFORMAT;
 235   return FALSE;
 236   }
 237 va_end(ap);
 238 DEBUG(D_transport|D_v) debug_printf("  LMTP>> %s", string_from_gstring(&gs));
 239 rc = write(fd, gs.s, gs.ptr);
 240 gs.ptr -= 2; string_from_gstring(&gs); /* remove \r\n for debug and error message */
 241 if (rc > 0) return TRUE;
 242 DEBUG(D_transport) debug_printf("write failed: %s\n", strerror(errno));
 243 return FALSE;
 244 }
 245
 246
 247
 248
 249 /*************************************************
 250 *              Read LMTP response                *
 251 *************************************************/
 252
 253 /* This function reads an LMTP response with a timeout, and returns the
 254 response in the given buffer. It also analyzes the first digit of the reply
 255 code and returns FALSE if it is not acceptable.
 256
 257 FALSE is also returned after a reading error. In this case buffer[0] will be
 258 zero, and the error code will be in errno.
 259
 260 Arguments:
 261   f         a file to read from
 262   buffer    where to put the response
 263   size      the size of the buffer
 264   okdigit   the expected first digit of the response
 265   timeout   the timeout to use
 266
 267 Returns:    TRUE if a valid, non-error response was received; else FALSE
 268 */
 269
 270 static BOOL
 271 lmtp_read_response(FILE *f, uschar *buffer, int size, int okdigit, int timeout)
 272 {
 273 int count;
 274 uschar *ptr = buffer;
 275 uschar *readptr = buffer;
 276
 277 /* Ensure errno starts out zero */
 278
 279 errno = 0;
 280
 281 /* Loop for handling LMTP responses that do not all come in one line. */
 282
 283 for (;;)
 284   {
 285   /* If buffer is too full, something has gone wrong. */
 286
 287   if (size < 10)
 288     {
 289     *readptr = 0;
 290     errno = ERRNO_SMTPFORMAT;
 291     return FALSE;
 292     }
 293
 294   /* Loop to cover the read getting interrupted. */
 295
 296   for (;;)
 297     {
 298     char *rc;
 299     int save_errno;
 300
 301     *readptr = 0;           /* In case nothing gets read */
 302     sigalrm_seen = FALSE;
 303     ALARM(timeout);
 304     rc = Ufgets(readptr, size-1, f);
 305     save_errno = errno;
 306     ALARM_CLR(0);
 307     errno = save_errno;
 308
 309     if (rc != NULL) break;  /* A line has been read */
 310
 311     /* Handle timeout; must do this first because it uses EINTR */
 312
 313     if (sigalrm_seen) errno = ETIMEDOUT;
 314
 315     /* If some other interrupt arrived, just retry. We presume this to be rare,
 316     but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
 317     read() to exit). */
 318
 319     else if (errno == EINTR)
 320       {
 321       DEBUG(D_transport) debug_printf("EINTR while reading LMTP response\n");
 322       continue;
 323       }
 324
 325     /* Handle other errors, including EOF; ensure buffer is completely empty. */
 326
 327     buffer[0] = 0;
 328     return FALSE;
 329     }
 330
 331   /* Adjust size in case we have to read another line, and adjust the
 332   count to be the length of the line we are about to inspect. */
 333
 334   count = Ustrlen(readptr);
 335   size -= count;
 336   count += readptr - ptr;
 337
 338   /* See if the final two characters in the buffer are \r\n. If not, we
 339   have to read some more. At least, that is what we should do on a strict
 340   interpretation of the RFC. But accept LF as well, as we do for SMTP. */
 341
 342   if (ptr[count-1] != '\n')
 343     {
 344     DEBUG(D_transport)
 345       {
 346       int i;
 347       debug_printf("LMTP input line incomplete in one buffer:\n  ");
 348       for (i = 0; i < count; i++)
 349         {
 350         int c = (ptr[i]);
 351         if (mac_isprint(c)) debug_printf("%c", c); else debug_printf("<%d>", c);
 352         }
 353       debug_printf("\n");
 354       }
 355     readptr = ptr + count;
 356     continue;
 357     }
 358
 359   /* Remove any whitespace at the end of the buffer. This gets rid of CR, LF
 360   etc. at the end. Show it, if debugging, formatting multi-line responses. */
 361
 362   while (count > 0 && isspace(ptr[count-1])) count--;
 363   ptr[count] = 0;
 364
 365   DEBUG(D_transport|D_v)
 366     {
 367     uschar *s = ptr;
 368     uschar *t = ptr;
 369     while (*t != 0)
 370       {
 371       while (*t != 0 && *t != '\n') t++;
 372       debug_printf("  %s %*s\n", (s == ptr)? "LMTP<<" : "      ",
 373         (int)(t-s), s);
 374       if (*t == 0) break;
 375       s = t = t + 1;
 376       }
 377     }
 378
 379   /* Check the format of the response: it must start with three digits; if
 380   these are followed by a space or end of line, the response is complete. If
 381   they are followed by '-' this is a multi-line response and we must look for
 382   another line until the final line is reached. The only use made of multi-line
 383   responses is to pass them back as error messages. We therefore just
 384   concatenate them all within the buffer, which should be large enough to
 385   accept any reasonable number of lines. A multiline response may already
 386   have been read in one go - hence the loop here. */
 387
 388   for(;;)
 389     {
 390     uschar *p;
 391     if (count < 3 ||
 392        !isdigit(ptr[0]) ||
 393        !isdigit(ptr[1]) ||
 394        !isdigit(ptr[2]) ||
 395        (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
 396       {
 397       errno = ERRNO_SMTPFORMAT;    /* format error */
 398       return FALSE;
 399       }
 400
 401     /* If a single-line response, exit the loop */
 402
 403     if (ptr[3] != '-') break;
 404
 405     /* For a multi-line response see if the next line is already read, and if
 406     so, stay in this loop to check it. */
 407
 408     p = ptr + 3;
 409     while (*(++p) != 0)
 410       {
 411       if (*p == '\n')
 412         {
 413         ptr = ++p;
 414         break;
 415         }
 416       }
 417     if (*p == 0) break;   /* No more lines to check */
 418     }
 419
 420   /* End of response. If the last of the lines we are looking at is the final
 421   line, we are done. Otherwise more data has to be read. */
 422
 423   if (ptr[3] != '-') break;
 424
 425   /* Move the reading pointer upwards in the buffer and insert \n in case this
 426   is an error message that subsequently gets printed. Set the scanning pointer
 427   to the reading pointer position. */
 428
 429   ptr += count;
 430   *ptr++ = '\n';
 431   size--;
 432   readptr = ptr;
 433   }
 434
 435 /* Return a value that depends on the LMTP return code. Ensure that errno is
 436 zero, because the caller of this function looks at errno when FALSE is
 437 returned, to distinguish between an unexpected return code and other errors
 438 such as timeouts, lost connections, etc. */
 439
 440 errno = 0;
 441 return buffer[0] == okdigit;
 442 }
 443
 444
 445
 446
 447
 448
 449 /*************************************************
 450 *              Main entry point                  *
 451 *************************************************/
 452
 453 /* See local README for interface details. For setup-errors, this transport
 454 returns FALSE, indicating that the first address has the status for all; in
 455 normal cases it returns TRUE, indicating that each address has its own status
 456 set. */
 457
 458 BOOL
 459 lmtp_transport_entry(
 460   transport_instance *tblock,      /* data for this instantiation */
 461   address_item *addrlist)          /* address(es) we are working on */
 462 {
 463 pid_t pid = 0;
 464 FILE *out;
 465 lmtp_transport_options_block *ob =
 466   (lmtp_transport_options_block *)(tblock->options_block);
 467 struct sockaddr_un sockun;         /* don't call this "sun" ! */
 468 int timeout = ob->timeout;
 469 int fd_in = -1, fd_out = -1;
 470 int code, save_errno;
 471 BOOL send_data;
 472 BOOL yield = FALSE;
 473 address_item *addr;
 474 uschar *igquotstr = US"";
 475 uschar *sockname = NULL;
 476 const uschar **argv;
 477 uschar buffer[256];
 478
 479 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
 480
 481 /* Initialization ensures that either a command or a socket is specified, but
 482 not both. When a command is specified, call the common function for creating an
 483 argument list and expanding the items. */
 484
 485 if (ob->cmd)
 486   {
 487   DEBUG(D_transport) debug_printf("using command %s\n", ob->cmd);
 488   sprintf(CS buffer, "%.50s transport", tblock->name);
 489   if (!transport_set_up_command(&argv, ob->cmd, TRUE, PANIC, addrlist, buffer,
 490        NULL))
 491     return FALSE;
 492
 493   /* If the -N option is set, can't do any more. Presume all has gone well. */
 494   if (f.dont_deliver)
 495     goto MINUS_N;
 496
 497 /* As this is a local transport, we are already running with the required
 498 uid/gid and current directory. Request that the new process be a process group
 499 leader, so we can kill it and all its children on an error. */
 500
 501   if ((pid = child_open(USS argv, NULL, 0, &fd_in, &fd_out, TRUE)) < 0)
 502     {
 503     addrlist->message = string_sprintf(
 504       "Failed to create child process for %s transport: %s", tblock->name,
 505         strerror(errno));
 506     return FALSE;
 507     }
 508   }
 509
 510 /* When a socket is specified, expand the string and create a socket. */
 511
 512 else
 513   {
 514   DEBUG(D_transport) debug_printf("using socket %s\n", ob->skt);
 515   sockname = expand_string(ob->skt);
 516   if (sockname == NULL)
 517     {
 518     addrlist->message = string_sprintf("Expansion of \"%s\" (socket setting "
 519       "for %s transport) failed: %s", ob->skt, tblock->name,
 520       expand_string_message);
 521     return FALSE;
 522     }
 523   if ((fd_in = fd_out = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
 524     {
 525     addrlist->message = string_sprintf(
 526       "Failed to create socket %s for %s transport: %s",
 527         ob->skt, tblock->name, strerror(errno));
 528     return FALSE;
 529     }
 530
 531   /* If the -N option is set, can't do any more. Presume all has gone well. */
 532   if (f.dont_deliver)
 533     goto MINUS_N;
 534
 535   sockun.sun_family = AF_UNIX;
 536   sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1), sockname);
 537   if(connect(fd_out, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
 538     {
 539     addrlist->message = string_sprintf(
 540       "Failed to connect to socket %s for %s transport: %s",
 541         sockun.sun_path, tblock->name, strerror(errno));
 542     return FALSE;
 543     }
 544   }
 545
 546
 547 /* Make the output we are going to read into a file. */
 548
 549 out = fdopen(fd_out, "rb");
 550
 551 /* Now we must implement the LMTP protocol. It is like SMTP, except that after
 552 the end of the message, a return code for every accepted RCPT TO is sent. This
 553 allows for message+recipient checks after the message has been received. */
 554
 555 /* First thing is to wait for an initial greeting. */
 556
 557 Ustrcpy(big_buffer, "initial connection");
 558 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
 559   timeout)) goto RESPONSE_FAILED;
 560
 561 /* Next, we send a LHLO command, and expect a positive response */
 562
 563 if (!lmtp_write_command(fd_in, "%s %s\r\n", "LHLO",
 564   primary_hostname)) goto WRITE_FAILED;
 565
 566 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
 567      timeout)) goto RESPONSE_FAILED;
 568
 569 /* If the ignore_quota option is set, note whether the server supports the
 570 IGNOREQUOTA option, and if so, set an appropriate addition for RCPT. */
 571
 572 if (ob->ignore_quota)
 573   igquotstr = (pcre_exec(regex_IGNOREQUOTA, NULL, CS buffer,
 574     Ustrlen(CS buffer), 0, PCRE_EOPT, NULL, 0) >= 0)? US" IGNOREQUOTA" : US"";
 575
 576 /* Now the envelope sender */
 577
 578 if (!lmtp_write_command(fd_in, "MAIL FROM:<%s>\r\n", return_path))
 579   goto WRITE_FAILED;
 580
 581 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 582   {
 583   if (errno == 0 && buffer[0] == '4')
 584     {
 585     errno = ERRNO_MAIL4XX;
 586     addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 587     }
 588   goto RESPONSE_FAILED;
 589   }
 590
 591 /* Next, we hand over all the recipients. Some may be permanently or
 592 temporarily rejected; others may be accepted, for now. */
 593
 594 send_data = FALSE;
 595 for (addr = addrlist; addr != NULL; addr = addr->next)
 596   {
 597   if (!lmtp_write_command(fd_in, "RCPT TO:<%s>%s\r\n",
 598        transport_rcpt_address(addr, tblock->rcpt_include_affixes), igquotstr))
 599     goto WRITE_FAILED;
 600   if (lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 601     {
 602     send_data = TRUE;
 603     addr->transport_return = PENDING_OK;
 604     }
 605   else
 606     {
 607     if (errno != 0 || buffer[0] == 0) goto RESPONSE_FAILED;
 608     addr->message = string_sprintf("LMTP error after %s: %s", big_buffer,
 609       string_printing(buffer));
 610     setflag(addr, af_pass_message);   /* Allow message to go to user */
 611     if (buffer[0] == '5') addr->transport_return = FAIL; else
 612       {
 613       addr->basic_errno = ERRNO_RCPT4XX;
 614       addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 615       }
 616     }
 617   }
 618
 619 /* Now send the text of the message if there were any good recipients. */
 620
 621 if (send_data)
 622   {
 623   BOOL ok;
 624   transport_ctx tctx = {
 625     {fd_in},
 626     tblock,
 627     addrlist,
 628     US".", US"..",
 629     ob->options
 630   };
 631
 632   if (!lmtp_write_command(fd_in, "DATA\r\n")) goto WRITE_FAILED;
 633   if (!lmtp_read_response(out, buffer, sizeof(buffer), '3', timeout))
 634     {
 635     if (errno == 0 && buffer[0] == '4')
 636       {
 637       errno = ERRNO_DATA4XX;
 638       addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 639       }
 640     goto RESPONSE_FAILED;
 641     }
 642
 643   sigalrm_seen = FALSE;
 644   transport_write_timeout = timeout;
 645   Ustrcpy(big_buffer, "sending data block");   /* For error messages */
 646   DEBUG(D_transport|D_v)
 647     debug_printf("  LMTP>> writing message and terminating \".\"\n");
 648
 649   transport_count = 0;
 650   ok = transport_write_message(&tctx, 0);
 651
 652   /* Failure can either be some kind of I/O disaster (including timeout),
 653   or the failure of a transport filter or the expansion of added headers. */
 654
 655   if (!ok)
 656     {
 657     buffer[0] = 0;              /* There hasn't been a response */
 658     goto RESPONSE_FAILED;
 659     }
 660
 661   Ustrcpy(big_buffer, "end of data");   /* For error messages */
 662
 663   /* We now expect a response for every address that was accepted above,
 664   in the same order. For those that get a response, their status is fixed;
 665   any that are accepted have been handed over, even if later responses crash -
 666   at least, that's how I read RFC 2033. */
 667
 668   for (addr = addrlist; addr != NULL; addr = addr->next)
 669     {
 670     if (addr->transport_return != PENDING_OK) continue;
 671
 672     if (lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 673       {
 674       addr->transport_return = OK;
 675       if (LOGGING(smtp_confirmation))
 676         {
 677         const uschar *s = string_printing(buffer);
 678         /* de-const safe here as string_printing known to have alloc'n'copied */
 679         addr->message = (s == buffer)? US string_copy(s) : US s;
 680         }
 681       }
 682     /* If the response has failed badly, use it for all the remaining pending
 683     addresses and give up. */
 684
 685     else if (errno != 0 || buffer[0] == 0)
 686       {
 687       address_item *a;
 688       save_errno = errno;
 689       check_response(&save_errno, addr->more_errno, buffer, &code,
 690         &(addr->message));
 691       addr->transport_return = (code == '5')? FAIL : DEFER;
 692       for (a = addr->next; a != NULL; a = a->next)
 693         {
 694         if (a->transport_return != PENDING_OK) continue;
 695         a->basic_errno = addr->basic_errno;
 696         a->message = addr->message;
 697         a->transport_return = addr->transport_return;
 698         }
 699       break;
 700       }
 701
 702     /* Otherwise, it's an LMTP error code return for one address */
 703
 704     else
 705       {
 706       if (buffer[0] == '4')
 707         {
 708         addr->basic_errno = ERRNO_DATA4XX;
 709         addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 710         }
 711       addr->message = string_sprintf("LMTP error after %s: %s", big_buffer,
 712         string_printing(buffer));
 713       addr->transport_return = (buffer[0] == '5')? FAIL : DEFER;
 714       setflag(addr, af_pass_message);   /* Allow message to go to user */
 715       }
 716     }
 717   }
 718
 719 /* The message transaction has completed successfully - this doesn't mean that
 720 all the addresses have necessarily been transferred, but each has its status
 721 set, so we change the yield to TRUE. */
 722
 723 yield = TRUE;
 724 (void) lmtp_write_command(fd_in, "QUIT\r\n");
 725 (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
 726
 727 goto RETURN;
 728
 729
 730 /* Come here if any call to read_response, other than a response after the data
 731 phase, failed. Put the error in the top address - this will be replicated
 732 because the yield is still FALSE. (But omit ETIMEDOUT, as there will already be
 733 a suitable message.) Analyse the error, and if if isn't too bad, send a QUIT
 734 command. Wait for the response with a short timeout, so we don't wind up this
 735 process before the far end has had time to read the QUIT. */
 736
 737 RESPONSE_FAILED:
 738
 739 save_errno = errno;
 740 if (errno != ETIMEDOUT && errno != 0) addrlist->basic_errno = errno;
 741 addrlist->message = NULL;
 742
 743 if (check_response(&save_errno, addrlist->more_errno,
 744     buffer, &code, &(addrlist->message)))
 745   {
 746   (void) lmtp_write_command(fd_in, "QUIT\r\n");
 747   (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
 748   }
 749
 750 addrlist->transport_return = (code == '5')? FAIL : DEFER;
 751 if (code == '4' && save_errno > 0)
 752   addrlist->message = string_sprintf("%s: %s", addrlist->message,
 753     strerror(save_errno));
 754 goto KILL_AND_RETURN;
 755
 756 /* Come here if there are errors during writing of a command or the message
 757 itself. This error will be applied to all the addresses. */
 758
 759 WRITE_FAILED:
 760
 761 addrlist->transport_return = PANIC;
 762 addrlist->basic_errno = errno;
 763 if (errno == ERRNO_CHHEADER_FAIL)
 764   addrlist->message =
 765     string_sprintf("Failed to expand headers_add or headers_remove: %s",
 766       expand_string_message);
 767 else if (errno == ERRNO_FILTER_FAIL)
 768   addrlist->message = string_sprintf("Filter process failure");
 769 else if (errno == ERRNO_WRITEINCOMPLETE)
 770   addrlist->message = string_sprintf("Failed repeatedly to write data");
 771 else if (errno == ERRNO_SMTPFORMAT)
 772   addrlist->message = US"overlong LMTP command generated";
 773 else
 774   addrlist->message = string_sprintf("Error %d", errno);
 775
 776 /* Come here after errors. Kill off the process. */
 777
 778 KILL_AND_RETURN:
 779
 780 if (pid > 0) killpg(pid, SIGKILL);
 781
 782 /* Come here from all paths after the subprocess is created. Wait for the
 783 process, but with a timeout. */
 784
 785 RETURN:
 786
 787 (void)child_close(pid, timeout);
 788
 789 if (fd_in >= 0) (void)close(fd_in);
 790 if (fd_out >= 0) (void)fclose(out);
 791
 792 DEBUG(D_transport)
 793   debug_printf("%s transport yields %d\n", tblock->name, yield);
 794
 795 return yield;
 796
 797
 798 MINUS_N:
 799   DEBUG(D_transport)
 800     debug_printf("*** delivery by %s transport bypassed by -N option",
 801       tblock->name);
 802   addrlist->transport_return = OK;
 803   return FALSE;
 804 }
 805
 806 #endif  /*!MACRO_PREDEF*/
 807 /* End of transport/lmtp.c */