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