484735032b12bbbf88d0067d996dcf79aa921a79
[exim.git] / src / src / smtp_out.c
1 /* $Cambridge: exim/src/src/smtp_out.c,v 1.10 2009/11/16 19:50:37 nm4 Exp $ */
2
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
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 union sockaddr_46 interface_sock;
245 EXIM_SOCKLEN_T size = sizeof(interface_sock);
246 HDEBUG(D_transport|D_acl|D_v) debug_printf("connected\n");
247 if (getsockname(sock, (struct sockaddr *)(&interface_sock), &size) == 0)
248 sending_ip_address = host_ntoa(-1, &interface_sock, NULL, &sending_port);
249 else
250 {
251 log_write(0, LOG_MAIN | ((errno == ECONNRESET)? 0 : LOG_PANIC),
252 "getsockname() failed: %s", strerror(errno));
253 close(sock);
254 return -1;
255 }
256 if (keepalive) ip_keepalive(sock, host->address, TRUE);
257 return sock;
258 }
259 }
260
261
262 /*************************************************
263 * Flush outgoing command buffer *
264 *************************************************/
265
266 /* This function is called only from smtp_write_command() below. It flushes
267 the buffer of outgoing commands. There is more than one in the buffer only when
268 pipelining.
269
270 Argument:
271 outblock the SMTP output block
272
273 Returns: TRUE if OK, FALSE on error, with errno set
274 */
275
276 static BOOL
277 flush_buffer(smtp_outblock *outblock)
278 {
279 int rc;
280
281 #ifdef SUPPORT_TLS
282 if (tls_active == outblock->sock)
283 rc = tls_write(outblock->buffer, outblock->ptr - outblock->buffer);
284 else
285 #endif
286
287 rc = send(outblock->sock, outblock->buffer, outblock->ptr - outblock->buffer, 0);
288 if (rc <= 0)
289 {
290 HDEBUG(D_transport|D_acl) debug_printf("send failed: %s\n", strerror(errno));
291 return FALSE;
292 }
293
294 outblock->ptr = outblock->buffer;
295 outblock->cmd_count = 0;
296 return TRUE;
297 }
298
299
300
301 /*************************************************
302 * Write SMTP command *
303 *************************************************/
304
305 /* The formatted command is left in big_buffer so that it can be reflected in
306 any error message.
307
308 Arguments:
309 outblock contains buffer for pipelining, and socket
310 noflush if TRUE, save the command in the output buffer, for pipelining
311 format a format, starting with one of
312 of HELO, MAIL FROM, RCPT TO, DATA, ".", or QUIT.
313 ... data for the format
314
315 Returns: 0 if command added to pipelining buffer, with nothing transmitted
316 +n if n commands transmitted (may still have buffered the new one)
317 -1 on error, with errno set
318 */
319
320 int
321 smtp_write_command(smtp_outblock *outblock, BOOL noflush, char *format, ...)
322 {
323 int count;
324 int rc = 0;
325 va_list ap;
326
327 va_start(ap, format);
328 if (!string_vformat(big_buffer, big_buffer_size, CS format, ap))
329 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong write_command in outgoing "
330 "SMTP");
331 va_end(ap);
332 count = Ustrlen(big_buffer);
333
334 if (count > outblock->buffersize - (outblock->ptr - outblock->buffer))
335 {
336 rc = outblock->cmd_count; /* flush resets */
337 if (!flush_buffer(outblock)) return -1;
338 }
339
340 Ustrncpy(CS outblock->ptr, big_buffer, count);
341 outblock->ptr += count;
342 outblock->cmd_count++;
343 count -= 2;
344 big_buffer[count] = 0; /* remove \r\n for error message */
345
346 /* We want to hide the actual data sent in AUTH transactions from reflections
347 and logs. While authenticating, a flag is set in the outblock to enable this.
348 The AUTH command itself gets any data flattened. Other lines are flattened
349 completely. */
350
351 if (outblock->authenticating)
352 {
353 uschar *p = big_buffer;
354 if (Ustrncmp(big_buffer, "AUTH ", 5) == 0)
355 {
356 p += 5;
357 while (isspace(*p)) p++;
358 while (!isspace(*p)) p++;
359 while (isspace(*p)) p++;
360 }
361 while (*p != 0) *p++ = '*';
362 }
363
364 HDEBUG(D_transport|D_acl|D_v) debug_printf(" SMTP>> %s\n", big_buffer);
365
366 if (!noflush)
367 {
368 rc += outblock->cmd_count; /* flush resets */
369 if (!flush_buffer(outblock)) return -1;
370 }
371
372 return rc;
373 }
374
375
376
377 /*************************************************
378 * Read one line of SMTP response *
379 *************************************************/
380
381 /* This function reads one line of SMTP response from the server host. This may
382 not be a complete response - it could be just part of a multiline response. We
383 have to use a buffer for incoming packets, because when pipelining or using
384 LMTP, there may well be more than one response in a single packet. This
385 function is called only from the one that follows.
386
387 Arguments:
388 inblock the SMTP input block (contains holding buffer, socket, etc.)
389 buffer where to put the line
390 size space available for the line
391 timeout the timeout to use when reading a packet
392
393 Returns: length of a line that has been put in the buffer
394 -1 otherwise, with errno set
395 */
396
397 static int
398 read_response_line(smtp_inblock *inblock, uschar *buffer, int size, int timeout)
399 {
400 uschar *p = buffer;
401 uschar *ptr = inblock->ptr;
402 uschar *ptrend = inblock->ptrend;
403 int sock = inblock->sock;
404
405 /* Loop for reading multiple packets or reading another packet after emptying
406 a previously-read one. */
407
408 for (;;)
409 {
410 int rc;
411
412 /* If there is data in the input buffer left over from last time, copy
413 characters from it until the end of a line, at which point we can return,
414 having removed any whitespace (which will include CR) at the end of the line.
415 The rules for SMTP say that lines end in CRLF, but there are have been cases
416 of hosts using just LF, and other MTAs are reported to handle this, so we
417 just look for LF. If we run out of characters before the end of a line,
418 carry on to read the next incoming packet. */
419
420 while (ptr < ptrend)
421 {
422 int c = *ptr++;
423 if (c == '\n')
424 {
425 while (p > buffer && isspace(p[-1])) p--;
426 *p = 0;
427 inblock->ptr = ptr;
428 return p - buffer;
429 }
430 *p++ = c;
431 if (--size < 4)
432 {
433 *p = 0; /* Leave malformed line for error message */
434 errno = ERRNO_SMTPFORMAT;
435 return -1;
436 }
437 }
438
439 /* Need to read a new input packet. */
440
441 rc = ip_recv(sock, inblock->buffer, inblock->buffersize, timeout);
442 if (rc <= 0) break;
443
444 /* Another block of data has been successfully read. Set up the pointers
445 and let the loop continue. */
446
447 ptrend = inblock->ptrend = inblock->buffer + rc;
448 ptr = inblock->buffer;
449 DEBUG(D_transport|D_acl) debug_printf("read response data: size=%d\n", rc);
450 }
451
452 /* Get here if there has been some kind of recv() error; errno is set, but we
453 ensure that the result buffer is empty before returning. */
454
455 *buffer = 0;
456 return -1;
457 }
458
459
460
461
462
463 /*************************************************
464 * Read SMTP response *
465 *************************************************/
466
467 /* This function reads an SMTP response with a timeout, and returns the
468 response in the given buffer, as a string. A multiline response will contain
469 newline characters between the lines. The function also analyzes the first
470 digit of the reply code and returns FALSE if it is not acceptable. FALSE is
471 also returned after a reading error. In this case buffer[0] will be zero, and
472 the error code will be in errno.
473
474 Arguments:
475 inblock the SMTP input block (contains holding buffer, socket, etc.)
476 buffer where to put the response
477 size the size of the buffer
478 okdigit the expected first digit of the response
479 timeout the timeout to use
480
481 Returns: TRUE if a valid, non-error response was received; else FALSE
482 */
483
484 BOOL
485 smtp_read_response(smtp_inblock *inblock, uschar *buffer, int size, int okdigit,
486 int timeout)
487 {
488 uschar *ptr = buffer;
489 int count;
490
491 errno = 0; /* Ensure errno starts out zero */
492
493 /* This is a loop to read and concatentate the lines that make up a multi-line
494 response. */
495
496 for (;;)
497 {
498 if ((count = read_response_line(inblock, ptr, size, timeout)) < 0)
499 return FALSE;
500
501 HDEBUG(D_transport|D_acl|D_v)
502 debug_printf(" %s %s\n", (ptr == buffer)? "SMTP<<" : " ", ptr);
503
504 /* Check the format of the response: it must start with three digits; if
505 these are followed by a space or end of line, the response is complete. If
506 they are followed by '-' this is a multi-line response and we must look for
507 another line until the final line is reached. The only use made of multi-line
508 responses is to pass them back as error messages. We therefore just
509 concatenate them all within the buffer, which should be large enough to
510 accept any reasonable number of lines. */
511
512 if (count < 3 ||
513 !isdigit(ptr[0]) ||
514 !isdigit(ptr[1]) ||
515 !isdigit(ptr[2]) ||
516 (ptr[3] != '-' && ptr[3] != ' ' && ptr[3] != 0))
517 {
518 errno = ERRNO_SMTPFORMAT; /* format error */
519 return FALSE;
520 }
521
522 /* If the line we have just read is a terminal line, line, we are done.
523 Otherwise more data has to be read. */
524
525 if (ptr[3] != '-') break;
526
527 /* Move the reading pointer upwards in the buffer and insert \n between the
528 components of a multiline response. Space is left for this by read_response_
529 line(). */
530
531 ptr += count;
532 *ptr++ = '\n';
533 size -= count + 1;
534 }
535
536 /* Return a value that depends on the SMTP return code. On some systems a
537 non-zero value of errno has been seen at this point, so ensure it is zero,
538 because the caller of this function looks at errno when FALSE is returned, to
539 distinguish between an unexpected return code and other errors such as
540 timeouts, lost connections, etc. */
541
542 errno = 0;
543 return buffer[0] == okdigit;
544 }
545
546 /* End of smtp_out.c */