6b079c16f25920cc69a966861db8423359a1b67d
[exim.git] / src / src / smtp_out.c
1 /* $Cambridge: exim/src/src/smtp_out.c,v 1.7 2006/02/07 11:19:00 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* A number of functions for driving outgoing SMTP calls. */
11
12
13 #include "exim.h"
14
15
16
17 /*************************************************
18 *           Find an outgoing interface           *
19 *************************************************/
20
21 /* This function is called from the smtp transport and also from the callout
22 code in verify.c. Its job is to expand a string to get a list of interfaces,
23 and choose a suitable one (IPv4 or IPv6) for the outgoing address.
24
25 Arguments:
26   istring    string interface setting, may be NULL, meaning "any", in
27                which case the function does nothing
28   host_af    AF_INET or AF_INET6 for the outgoing IP address
29   addr       the mail address being handled (for setting errors)
30   changed    if not NULL, set TRUE if expansion actually changed istring
31   interface  point this to the interface
32   msg        to add to any error message
33
34 Returns:     TRUE on success, FALSE on failure, with error message
35                set in addr and transport_return set to PANIC
36 */
37
38 BOOL
39 smtp_get_interface(uschar *istring, int host_af, address_item *addr,
40   BOOL *changed, uschar **interface, uschar *msg)
41 {
42 uschar *expint;
43 uschar *iface;
44 int sep = 0;
45
46 if (istring == NULL) return TRUE;
47
48 expint = expand_string(istring);
49 if (expint == NULL)
50   {
51   if (expand_string_forcedfail) return TRUE;
52   addr->transport_return = PANIC;
53   addr->message = string_sprintf("failed to expand \"interface\" "
54       "option for %s: %s", msg, expand_string_message);
55   return FALSE;
56   }
57
58 if (changed != NULL) *changed = expint != istring;
59
60 while (isspace(*expint)) expint++;
61 if (*expint == 0) return TRUE;
62
63 while ((iface = string_nextinlist(&expint, &sep, big_buffer,
64           big_buffer_size)) != NULL)
65   {
66   if (string_is_ip_address(iface, NULL) == 0)
67     {
68     addr->transport_return = PANIC;
69     addr->message = string_sprintf("\"%s\" is not a valid IP "
70       "address for the \"interface\" option for %s",
71       iface, msg);
72     return FALSE;
73     }
74
75   if (((Ustrchr(iface, ':') == NULL)? AF_INET:AF_INET6) == host_af)
76     break;
77   }
78
79 if (iface != NULL) *interface = string_copy(iface);
80 return TRUE;
81 }
82
83
84
85 /*************************************************
86 *           Find an outgoing port                *
87 *************************************************/
88
89 /* This function is called from the smtp transport and also from the callout
90 code in verify.c. Its job is to find a port number. Note that getservbyname()
91 produces the number in network byte order.
92
93 Arguments:
94   rstring     raw (unexpanded) string representation of the port
95   addr        the mail address being handled (for setting errors)
96   port        stick the port in here
97   msg         for adding to error message
98
99 Returns:      TRUE on success, FALSE on failure, with error message set
100                 in addr, and transport_return set to PANIC
101 */
102
103 BOOL
104 smtp_get_port(uschar *rstring, address_item *addr, int *port, uschar *msg)
105 {
106 uschar *pstring = expand_string(rstring);
107
108 if (pstring == NULL)
109   {
110   addr->transport_return = PANIC;
111   addr->message = string_sprintf("failed to expand \"%s\" (\"port\" option) "
112     "for %s: %s", rstring, msg, expand_string_message);
113   return FALSE;
114   }
115
116 if (isdigit(*pstring))
117   {
118   uschar *end;
119   *port = Ustrtol(pstring, &end, 0);
120   if (end != pstring + Ustrlen(pstring))
121     {
122     addr->transport_return = PANIC;
123     addr->message = string_sprintf("invalid port number for %s: %s", msg,
124       pstring);
125     return FALSE;
126     }
127   }
128
129 else
130   {
131   struct servent *smtp_service = getservbyname(CS pstring, "tcp");
132   if (smtp_service == NULL)
133     {
134     addr->transport_return = PANIC;
135     addr->message = string_sprintf("TCP port \"%s\" is not defined for %s",
136       pstring, msg);
137     return FALSE;
138     }
139   *port = ntohs(smtp_service->s_port);
140   }
141
142 return TRUE;
143 }
144
145
146
147
148 /*************************************************
149 *           Connect to remote host               *
150 *************************************************/
151
152 /* Create a socket, and connect it to a remote host. IPv6 addresses are
153 detected by checking for a colon in the address. AF_INET6 is defined even on
154 non-IPv6 systems, to enable the code to be less messy. However, on such systems
155 host->address will always be an IPv4 address.
156
157 The port field in the host item is used if it is set (usually router from SRV
158 records or elsewhere). In other cases, the default passed as an argument is
159 used, and the host item is updated with its value.
160
161 Arguments:
162   host        host item containing name and address (and sometimes port)
163   host_af     AF_INET or AF_INET6
164   port        default remote port to connect to, in host byte order, for those
165                 hosts whose port setting is PORT_NONE
166   interface   outgoing interface address or NULL
167   timeout     timeout value or 0
168   keepalive   TRUE to use keepalive
169
170 Returns:      connected socket number, or -1 with errno set
171 */
172
173 int
174 smtp_connect(host_item *host, int host_af, int port, uschar *interface,
175   int timeout, BOOL keepalive)
176 {
177 int on = 1;
178 int save_errno = 0;
179 int sock;
180
181 if (host->port != PORT_NONE)
182   {
183   HDEBUG(D_transport|D_acl|D_v)
184     debug_printf("Transport port=%d replaced by host-specific port=%d\n", port,
185       host->port);
186   port = host->port;
187   }
188 else host->port = port;    /* Set the port actually used */
189
190 HDEBUG(D_transport|D_acl|D_v)
191   {
192   if (interface == NULL)
193     debug_printf("Connecting to %s [%s]:%d ... ",host->name,host->address,port);
194   else
195     debug_printf("Connecting to %s [%s]:%d from %s ... ", host->name,
196       host->address, port, interface);
197   }
198
199 /* Create the socket */
200
201 if ((sock = ip_socket(SOCK_STREAM, host_af)) < 0) return -1;
202
203 /* Set TCP_NODELAY; Exim does its own buffering. */
204
205 setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (uschar *)(&on), sizeof(on));
206
207 /* Bind to a specific interface if requested. Caller must ensure the interface
208 is the same type (IPv4 or IPv6) as the outgoing address. */
209
210 if (interface != NULL && ip_bind(sock, host_af, interface, 0) < 0)
211   {
212   save_errno = errno;
213   HDEBUG(D_transport|D_acl|D_v)
214     debug_printf("unable to bind outgoing SMTP call to %s: %s", interface,
215     strerror(errno));
216   }
217
218 /* Connect to the remote host, and add keepalive to the socket before returning
219 it, if requested. */
220
221 else if (ip_connect(sock, host_af, host->address, port, timeout) < 0)
222   save_errno = errno;
223
224 /* Either bind() or connect() failed */
225
226 if (save_errno != 0)
227   {
228   HDEBUG(D_transport|D_acl|D_v)
229     {
230     debug_printf("failed: %s", CUstrerror(save_errno));
231     if (save_errno == ETIMEDOUT)
232       debug_printf(" (timeout=%s)", readconf_printtime(timeout));
233     debug_printf("\n");
234     }
235   (void)close(sock);
236   errno = save_errno;
237   return -1;
238   }
239
240 /* Both bind() and connect() succeeded */
241
242 else
243   {
244   HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
245   if (keepalive) ip_keepalive(sock, host->address, TRUE);
246   return sock;
247   }
248 }
249
250
251 /*************************************************
252 *        Flush outgoing command buffer           *
253 *************************************************/
254
255 /* This function is called only from smtp_write_command() below. It flushes
256 the buffer of outgoing commands. There is more than one in the buffer only when
257 pipelining.
258
259 Argument:
260   outblock   the SMTP output block
261
262 Returns:     TRUE if OK, FALSE on error, with errno set
263 */
264
265 static BOOL
266 flush_buffer(smtp_outblock *outblock)
267 {
268 int rc;
269
270 #ifdef SUPPORT_TLS
271 if (tls_active == outblock->sock)
272   rc = tls_write(outblock->buffer, outblock->ptr - outblock->buffer);
273 else
274 #endif
275
276 rc = send(outblock->sock, outblock->buffer, outblock->ptr - outblock->buffer, 0);
277 if (rc <= 0)
278   {
279   HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
280   return FALSE;
281   }
282
283 outblock->ptr = outblock->buffer;
284 outblock->cmd_count = 0;
285 return TRUE;
286 }
287
288
289
290 /*************************************************
291 *             Write SMTP command                 *
292 *************************************************/
293
294 /* The formatted command is left in big_buffer so that it can be reflected in
295 any error message.
296
297 Arguments:
298   outblock   contains buffer for pipelining, and socket
299   noflush    if TRUE, save the command in the output buffer, for pipelining
300   format     a format, starting with one of
301              of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
302   ...        data for the format
303
304 Returns:     0 if command added to pipelining buffer, with nothing transmitted
305             +n if n commands transmitted (may still have buffered the new one)
306             -1 on error, with errno set
307 */
308
309 int
310 smtp_write_command(smtp_outblock *outblock, BOOL noflush, char *format, ...)
311 {
312 int count;
313 int rc = 0;
314 va_list ap;
315
316 va_start(ap, format);
317 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
318   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
319     "SMTP");
320 va_end(ap);
321 count = Ustrlen(big_buffer);
322
323 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
324   {
325   rc = outblock->cmd_count;                 /* flush resets */
326   if (!flush_buffer(outblock)) return -1;
327   }
328
329 Ustrncpy(CS outblock->ptr, big_buffer, count);
330 outblock->ptr += count;
331 outblock->cmd_count++;
332 count -= 2;
333 big_buffer[count] = 0;     /* remove \r\n for error message */
334
335 /* We want to hide the actual data sent in AUTH transactions from reflections
336 and logs. While authenticating, a flag is set in the outblock to enable this.
337 The AUTH command itself gets any data flattened. Other lines are flattened
338 completely. */
339
340 if (outblock->authenticating)
341   {
342   uschar *p = big_buffer;
343   if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
344     {
345     p += 5;
346     while (isspace(*p)) p++;
347     while (!isspace(*p)) p++;
348     while (isspace(*p)) p++;
349     }
350   while (*p != 0) *p++ = '*';
351   }
352
353 HDEBUG(D_transport|D_acl|D_v) debug_printf("  SMTP>> %s\n", big_buffer);
354
355 if (!noflush)
356   {
357   rc += outblock->cmd_count;                /* flush resets */
358   if (!flush_buffer(outblock)) return -1;
359   }
360
361 return rc;
362 }
363
364
365
366 /*************************************************
367 *          Read one line of SMTP response        *
368 *************************************************/
369
370 /* This function reads one line of SMTP response from the server host. This may
371 not be a complete response - it could be just part of a multiline response. We
372 have to use a buffer for incoming packets, because when pipelining or using
373 LMTP, there may well be more than one response in a single packet. This
374 function is called only from the one that follows.
375
376 Arguments:
377   inblock   the SMTP input block (contains holding buffer, socket, etc.)
378   buffer    where to put the line
379   size      space available for the line
380   timeout   the timeout to use when reading a packet
381
382 Returns:    length of a line that has been put in the buffer
383             -1 otherwise, with errno set
384 */
385
386 static int
387 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
388 {
389 uschar *p = buffer;
390 uschar *ptr = inblock->ptr;
391 uschar *ptrend = inblock->ptrend;
392 int sock = inblock->sock;
393
394 /* Loop for reading multiple packets or reading another packet after emptying
395 a previously-read one. */
396
397 for (;;)
398   {
399   int rc;
400
401   /* If there is data in the input buffer left over from last time, copy
402   characters from it until the end of a line, at which point we can return,
403   having removed any whitespace (which will include CR) at the end of the line.
404   The rules for SMTP say that lines end in CRLF, but there are have been cases
405   of hosts using just LF, and other MTAs are reported to handle this, so we
406   just look for LF. If we run out of characters before the end of a line,
407   carry on to read the next incoming packet. */
408
409   while (ptr < ptrend)
410     {
411     int c = *ptr++;
412     if (c == '\n')
413       {
414       while (p > buffer && isspace(p[-1])) p--;
415       *p = 0;
416       inblock->ptr = ptr;
417       return p - buffer;
418       }
419     *p++ = c;
420     if (--size < 4)
421       {
422       *p = 0;                     /* Leave malformed line for error message */
423       errno = ERRNO_SMTPFORMAT;
424       return -1;
425       }
426     }
427
428   /* Need to read a new input packet. */
429
430   rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
431   if (rc <= 0) break;
432
433   /* Another block of data has been successfully read. Set up the pointers
434   and let the loop continue. */
435
436   ptrend = inblock->ptrend = inblock->buffer + rc;
437   ptr = inblock->buffer;
438   DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
439   }
440
441 /* Get here if there has been some kind of recv() error; errno is set, but we
442 ensure that the result buffer is empty before returning. */
443
444 *buffer = 0;
445 return -1;
446 }
447
448
449
450
451
452 /*************************************************
453 *              Read SMTP response                *
454 *************************************************/
455
456 /* This function reads an SMTP response with a timeout, and returns the
457 response in the given buffer, as a string. A multiline response will contain
458 newline characters between the lines. The function also analyzes the first
459 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
460 also returned after a reading error. In this case buffer[0] will be zero, and
461 the error code will be in errno.
462
463 Arguments:
464   inblock   the SMTP input block (contains holding buffer, socket, etc.)
465   buffer    where to put the response
466   size      the size of the buffer
467   okdigit   the expected first digit of the response
468   timeout   the timeout to use
469
470 Returns:    TRUE if a valid, non-error response was received; else FALSE
471 */
472
473 BOOL
474 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
475    int timeout)
476 {
477 uschar *ptr = buffer;
478 int count;
479
480 errno = 0;  /* Ensure errno starts out zero */
481
482 /* This is a loop to read and concatentate the lines that make up a multi-line
483 response. */
484
485 for (;;)
486   {
487   if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
488     return FALSE;
489
490   HDEBUG(D_transport|D_acl|D_v)
491     debug_printf("  %s %s\n", (ptr == buffer)? "SMTP<<" : "      ", ptr);
492
493   /* Check the format of the response: it must start with three digits; if
494   these are followed by a space or end of line, the response is complete. If
495   they are followed by '-' this is a multi-line response and we must look for
496   another line until the final line is reached. The only use made of multi-line
497   responses is to pass them back as error messages. We therefore just
498   concatenate them all within the buffer, which should be large enough to
499   accept any reasonable number of lines. */
500
501   if (count < 3 ||
502      !isdigit(ptr[0]) ||
503      !isdigit(ptr[1]) ||
504      !isdigit(ptr[2]) ||
505      (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
506     {
507     errno = ERRNO_SMTPFORMAT;    /* format error */
508     return FALSE;
509     }
510
511   /* If the line we have just read is a terminal line, line, we are done.
512   Otherwise more data has to be read. */
513
514   if (ptr[3] != '-') break;
515
516   /* Move the reading pointer upwards in the buffer and insert \n between the
517   components of a multiline response. Space is left for this by read_response_
518   line(). */
519
520   ptr += count;
521   *ptr++ = '\n';
522   size -= count + 1;
523   }
524
525 /* Return a value that depends on the SMTP return code. On some systems a
526 non-zero value of errno has been seen at this point, so ensure it is zero,
527 because the caller of this function looks at errno when FALSE is returned, to
528 distinguish between an unexpected return code and other errors such as
529 timeouts, lost connections, etc. */
530
531 errno = 0;
532 return buffer[0] == okdigit;
533 }
534
535 /* End of smtp_out.c */