src/src/transports/lmtp.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2015 */
   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   const 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 const 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)
 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   /* If the -N option is set, can't do any more. Presume all has gone well. */
 481   if (dont_deliver)
 482     goto MINUS_N;
 483
 484 /* As this is a local transport, we are already running with the required
 485 uid/gid and current directory. Request that the new process be a process group
 486 leader, so we can kill it and all its children on an error. */
 487
 488   if ((pid = child_open(USS argv, NULL, 0, &fd_in, &fd_out, TRUE)) < 0)
 489     {
 490     addrlist->message = string_sprintf(
 491       "Failed to create child process for %s transport: %s", tblock->name,
 492         strerror(errno));
 493     return FALSE;
 494     }
 495   }
 496
 497 /* When a socket is specified, expand the string and create a socket. */
 498
 499 else
 500   {
 501   DEBUG(D_transport) debug_printf("using socket %s\n", ob->skt);
 502   sockname = expand_string(ob->skt);
 503   if (sockname == NULL)
 504     {
 505     addrlist->message = string_sprintf("Expansion of \"%s\" (socket setting "
 506       "for %s transport) failed: %s", ob->skt, tblock->name,
 507       expand_string_message);
 508     return FALSE;
 509     }
 510   if ((fd_in = fd_out = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
 511     {
 512     addrlist->message = string_sprintf(
 513       "Failed to create socket %s for %s transport: %s",
 514         ob->skt, tblock->name, strerror(errno));
 515     return FALSE;
 516     }
 517
 518   /* If the -N option is set, can't do any more. Presume all has gone well. */
 519   if (dont_deliver)
 520     goto MINUS_N;
 521
 522   sockun.sun_family = AF_UNIX;
 523   sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1), sockname);
 524   if(connect(fd_out, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
 525     {
 526     addrlist->message = string_sprintf(
 527       "Failed to connect to socket %s for %s transport: %s",
 528         sockun.sun_path, tblock->name, strerror(errno));
 529     return FALSE;
 530     }
 531   }
 532
 533
 534 /* Make the output we are going to read into a file. */
 535
 536 out = fdopen(fd_out, "rb");
 537
 538 /* Now we must implement the LMTP protocol. It is like SMTP, except that after
 539 the end of the message, a return code for every accepted RCPT TO is sent. This
 540 allows for message+recipient checks after the message has been received. */
 541
 542 /* First thing is to wait for an initial greeting. */
 543
 544 Ustrcpy(big_buffer, "initial connection");
 545 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
 546   timeout)) goto RESPONSE_FAILED;
 547
 548 /* Next, we send a LHLO command, and expect a positive response */
 549
 550 if (!lmtp_write_command(fd_in, "%s %s\r\n", "LHLO",
 551   primary_hostname)) goto WRITE_FAILED;
 552
 553 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2',
 554      timeout)) goto RESPONSE_FAILED;
 555
 556 /* If the ignore_quota option is set, note whether the server supports the
 557 IGNOREQUOTA option, and if so, set an appropriate addition for RCPT. */
 558
 559 if (ob->ignore_quota)
 560   igquotstr = (pcre_exec(regex_IGNOREQUOTA, NULL, CS buffer,
 561     Ustrlen(CS buffer), 0, PCRE_EOPT, NULL, 0) >= 0)? US" IGNOREQUOTA" : US"";
 562
 563 /* Now the envelope sender */
 564
 565 if (!lmtp_write_command(fd_in, "MAIL FROM:<%s>\r\n", return_path))
 566   goto WRITE_FAILED;
 567
 568 if (!lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 569   {
 570   if (errno == 0 && buffer[0] == '4')
 571     {
 572     errno = ERRNO_MAIL4XX;
 573     addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 574     }
 575   goto RESPONSE_FAILED;
 576   }
 577
 578 /* Next, we hand over all the recipients. Some may be permanently or
 579 temporarily rejected; others may be accepted, for now. */
 580
 581 send_data = FALSE;
 582 for (addr = addrlist; addr != NULL; addr = addr->next)
 583   {
 584   if (!lmtp_write_command(fd_in, "RCPT TO:<%s>%s\r\n",
 585        transport_rcpt_address(addr, tblock->rcpt_include_affixes), igquotstr))
 586     goto WRITE_FAILED;
 587   if (lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 588     {
 589     send_data = TRUE;
 590     addr->transport_return = PENDING_OK;
 591     }
 592   else
 593     {
 594     if (errno != 0 || buffer[0] == 0) goto RESPONSE_FAILED;
 595     addr->message = string_sprintf("LMTP error after %s: %s", big_buffer,
 596       string_printing(buffer));
 597     setflag(addr, af_pass_message);   /* Allow message to go to user */
 598     if (buffer[0] == '5') addr->transport_return = FAIL; else
 599       {
 600       addr->basic_errno = ERRNO_RCPT4XX;
 601       addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 602       }
 603     }
 604   }
 605
 606 /* Now send the text of the message if there were any good recipients. */
 607
 608 if (send_data)
 609   {
 610   BOOL ok;
 611
 612   if (!lmtp_write_command(fd_in, "DATA\r\n")) goto WRITE_FAILED;
 613   if (!lmtp_read_response(out, buffer, sizeof(buffer), '3', timeout))
 614     {
 615     if (errno == 0 && buffer[0] == '4')
 616       {
 617       errno = ERRNO_DATA4XX;
 618       addrlist->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 619       }
 620     goto RESPONSE_FAILED;
 621     }
 622
 623   sigalrm_seen = FALSE;
 624   transport_write_timeout = timeout;
 625   Ustrcpy(big_buffer, "sending data block");   /* For error messages */
 626   DEBUG(D_transport|D_v)
 627     debug_printf("  LMTP>> writing message and terminating \".\"\n");
 628
 629   transport_count = 0;
 630   ok = transport_write_message(addrlist, fd_in, ob->options, 0,
 631         tblock->add_headers, tblock->remove_headers, US".", US"..",
 632         tblock->rewrite_rules, tblock->rewrite_existflags);
 633
 634   /* Failure can either be some kind of I/O disaster (including timeout),
 635   or the failure of a transport filter or the expansion of added headers. */
 636
 637   if (!ok)
 638     {
 639     buffer[0] = 0;              /* There hasn't been a response */
 640     goto RESPONSE_FAILED;
 641     }
 642
 643   Ustrcpy(big_buffer, "end of data");   /* For error messages */
 644
 645   /* We now expect a response for every address that was accepted above,
 646   in the same order. For those that get a response, their status is fixed;
 647   any that are accepted have been handed over, even if later responses crash -
 648   at least, that's how I read RFC 2033. */
 649
 650   for (addr = addrlist; addr != NULL; addr = addr->next)
 651     {
 652     if (addr->transport_return != PENDING_OK) continue;
 653
 654     if (lmtp_read_response(out, buffer, sizeof(buffer), '2', timeout))
 655       {
 656       addr->transport_return = OK;
 657       if (LOGGING(smtp_confirmation))
 658         {
 659         const uschar *s = string_printing(buffer);
 660         /* de-const safe here as string_printing known to have alloc'n'copied */
 661         addr->message = (s == buffer)? (uschar *)string_copy(s) : US s;
 662         }
 663       }
 664     /* If the response has failed badly, use it for all the remaining pending
 665     addresses and give up. */
 666
 667     else if (errno != 0 || buffer[0] == 0)
 668       {
 669       address_item *a;
 670       save_errno = errno;
 671       check_response(&save_errno, addr->more_errno, buffer, &code,
 672         &(addr->message));
 673       addr->transport_return = (code == '5')? FAIL : DEFER;
 674       for (a = addr->next; a != NULL; a = a->next)
 675         {
 676         if (a->transport_return != PENDING_OK) continue;
 677         a->basic_errno = addr->basic_errno;
 678         a->message = addr->message;
 679         a->transport_return = addr->transport_return;
 680         }
 681       break;
 682       }
 683
 684     /* Otherwise, it's an LMTP error code return for one address */
 685
 686     else
 687       {
 688       if (buffer[0] == '4')
 689         {
 690         addr->basic_errno = ERRNO_DATA4XX;
 691         addr->more_errno |= ((buffer[1] - '0')*10 + buffer[2] - '0') << 8;
 692         }
 693       addr->message = string_sprintf("LMTP error after %s: %s", big_buffer,
 694         string_printing(buffer));
 695       addr->transport_return = (buffer[0] == '5')? FAIL : DEFER;
 696       setflag(addr, af_pass_message);   /* Allow message to go to user */
 697       }
 698     }
 699   }
 700
 701 /* The message transaction has completed successfully - this doesn't mean that
 702 all the addresses have necessarily been transferred, but each has its status
 703 set, so we change the yield to TRUE. */
 704
 705 yield = TRUE;
 706 (void) lmtp_write_command(fd_in, "QUIT\r\n");
 707 (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
 708
 709 goto RETURN;
 710
 711
 712 /* Come here if any call to read_response, other than a response after the data
 713 phase, failed. Put the error in the top address - this will be replicated
 714 because the yield is still FALSE. (But omit ETIMEDOUT, as there will already be
 715 a suitable message.) Analyse the error, and if if isn't too bad, send a QUIT
 716 command. Wait for the response with a short timeout, so we don't wind up this
 717 process before the far end has had time to read the QUIT. */
 718
 719 RESPONSE_FAILED:
 720
 721 save_errno = errno;
 722 if (errno != ETIMEDOUT && errno != 0) addrlist->basic_errno = errno;
 723 addrlist->message = NULL;
 724
 725 if (check_response(&save_errno, addrlist->more_errno,
 726     buffer, &code, &(addrlist->message)))
 727   {
 728   (void) lmtp_write_command(fd_in, "QUIT\r\n");
 729   (void) lmtp_read_response(out, buffer, sizeof(buffer), '2', 1);
 730   }
 731
 732 addrlist->transport_return = (code == '5')? FAIL : DEFER;
 733 if (code == '4' && save_errno > 0)
 734   addrlist->message = string_sprintf("%s: %s", addrlist->message,
 735     strerror(save_errno));
 736 goto KILL_AND_RETURN;
 737
 738 /* Come here if there are errors during writing of a command or the message
 739 itself. This error will be applied to all the addresses. */
 740
 741 WRITE_FAILED:
 742
 743 addrlist->transport_return = PANIC;
 744 addrlist->basic_errno = errno;
 745 if (errno == ERRNO_CHHEADER_FAIL)
 746   addrlist->message =
 747     string_sprintf("Failed to expand headers_add or headers_remove: %s",
 748       expand_string_message);
 749 else if (errno == ERRNO_FILTER_FAIL)
 750   addrlist->message = string_sprintf("Filter process failure");
 751 else if (errno == ERRNO_WRITEINCOMPLETE)
 752   addrlist->message = string_sprintf("Failed repeatedly to write data");
 753 else if (errno == ERRNO_SMTPFORMAT)
 754   addrlist->message = US"overlong LMTP command generated";
 755 else
 756   addrlist->message = string_sprintf("Error %d", errno);
 757
 758 /* Come here after errors. Kill off the process. */
 759
 760 KILL_AND_RETURN:
 761
 762 if (pid > 0) killpg(pid, SIGKILL);
 763
 764 /* Come here from all paths after the subprocess is created. Wait for the
 765 process, but with a timeout. */
 766
 767 RETURN:
 768
 769 (void)child_close(pid, timeout);
 770
 771 if (fd_in >= 0) (void)close(fd_in);
 772 if (fd_out >= 0) (void)fclose(out);
 773
 774 DEBUG(D_transport)
 775   debug_printf("%s transport yields %d\n", tblock->name, yield);
 776
 777 return yield;
 778
 779
 780 MINUS_N:
 781   DEBUG(D_transport)
 782     debug_printf("*** delivery by %s transport bypassed by -N option",
 783       tblock->name);
 784   addrlist->transport_return = OK;
 785   return FALSE;
 786 }
 787
 788 /* End of transport/lmtp.c */