4960e3b292a4d4a09054da569e1d42bf1b58ff72
[users/heiko/exim.git] / src / src / ip.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 /* Functions for doing things with sockets. With the advent of IPv6 this has
9 got messier, so that it's worth pulling out the code into separate functions
10 that other parts of Exim can call, expecially as there are now several
11 different places in the code where sockets are used. */
12
13
14 #include "exim.h"
15
16
17 /*************************************************
18 *             Create a socket                    *
19 *************************************************/
20
21 /* Socket creation happens in a number of places so it's packaged here for
22 convenience.
23
24 Arguments:
25   type       SOCK_DGRAM or SOCK_STREAM
26   af         AF_INET or AF_INET6
27
28 Returns:     socket number or -1 on failure
29 */
30
31 int
32 ip_socket(int type, int af)
33 {
34 int sock = socket(af, type, 0);
35 if (sock < 0)
36   log_write(0, LOG_MAIN, "IPv%c socket creation failed: %s",
37     (af == AF_INET6)? '6':'4', strerror(errno));
38 return sock;
39 }
40
41
42
43
44 #if HAVE_IPV6
45 /*************************************************
46 *      Convert printing address to numeric       *
47 *************************************************/
48
49 /* This function converts the textual form of an IP address into a numeric form
50 in an appropriate structure in an IPv6 environment. The getaddrinfo() function
51 can (apparently) handle more complicated addresses (e.g. those containing
52 scopes) than inet_pton() in some environments. We use hints to tell it that the
53 input must be a numeric address.
54
55 However, apparently some operating systems (or libraries) don't support
56 getaddrinfo(), so there is a build-time option to revert to inet_pton() (which
57 does not support scopes).
58
59 Arguments:
60   address     textual form of the address
61   addr        where to copy back the answer
62
63 Returns:      nothing - failure provokes a panic-die
64 */
65
66 static void
67 ip_addrinfo(const uschar *address, struct sockaddr_in6 *saddr)
68 {
69 #ifdef IPV6_USE_INET_PTON
70
71   if (inet_pton(AF_INET6, CCS address, &saddr->sin6_addr) != 1)
72     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
73       "IP address", address);
74   saddr->sin6_family = AF_INET6;
75
76 #else
77
78   int rc;
79   struct addrinfo hints, *res;
80   memset(&hints, 0, sizeof(hints));
81   hints.ai_family = AF_INET6;
82   hints.ai_socktype = SOCK_STREAM;
83   hints.ai_flags = AI_NUMERICHOST;
84   if ((rc = getaddrinfo(CCS address, NULL, &hints, &res)) != 0 || res == NULL)
85     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
86       "IP address: %s", address,
87       (rc == 0)? "NULL result returned" : gai_strerror(rc));
88   memcpy(saddr, res->ai_addr, res->ai_addrlen);
89   freeaddrinfo(res);
90
91 #endif
92 }
93 #endif  /* HAVE_IPV6 */
94
95
96 /*************************************************
97 *         Bind socket to interface and port      *
98 *************************************************/
99
100 int
101 ip_addr(void * sin_, int af, const uschar * address, int port)
102 {
103 union sockaddr_46 * sin = sin_;
104 memset(sin, 0, sizeof(*sin));
105
106 /* Setup code when using an IPv6 socket. The wildcard address is ":", to
107 ensure an IPv6 socket is used. */
108
109 #if HAVE_IPV6
110 if (af == AF_INET6)
111   {
112   if (address[0] == ':' && address[1] == 0)
113     {
114     sin->v6.sin6_family = AF_INET6;
115     sin->v6.sin6_addr = in6addr_any;
116     }
117   else
118     ip_addrinfo(address, &sin->v6);  /* Panic-dies on error */
119   sin->v6.sin6_port = htons(port);
120   return sizeof(sin->v6);
121   }
122 else
123 #else     /* HAVE_IPv6 */
124 af = af;  /* Avoid compiler warning */
125 #endif    /* HAVE_IPV6 */
126
127 /* Setup code when using IPv4 socket. The wildcard address is "". */
128
129   {
130   sin->v4.sin_family = AF_INET;
131   sin->v4.sin_port = htons(port);
132   sin->v4.sin_addr.s_addr = address[0] == 0
133     ? (S_ADDR_TYPE)INADDR_ANY
134     : (S_ADDR_TYPE)inet_addr(CS address);
135   return sizeof(sin->v4);
136   }
137 }
138
139
140
141 /* This function binds a socket to a local interface address and port. For a
142 wildcard IPv6 bind, the address is ":".
143
144 Arguments:
145   sock           the socket
146   af             AF_INET or AF_INET6 - the socket type
147   address        the IP address, in text form
148   port           the IP port (host order)
149
150 Returns:         the result of bind()
151 */
152
153 int
154 ip_bind(int sock, int af, uschar *address, int port)
155 {
156 union sockaddr_46 sin;
157 int s_len = ip_addr(&sin, af, address, port);
158 return bind(sock, (struct sockaddr *)&sin, s_len);
159 }
160
161
162
163 /*************************************************
164 *        Connect socket to remote host           *
165 *************************************************/
166
167 /* This function connects a socket to a remote address and port. The socket may
168 or may not have previously been bound to a local interface. The socket is not
169 closed, even in cases of error. It is expected that the calling function, which
170 created the socket, will be the one that closes it.
171
172 Arguments:
173   sock        the socket
174   af          AF_INET6 or AF_INET for the socket type
175   address     the remote address, in text form
176   port        the remote port
177   timeout     a timeout (zero for indefinite timeout)
178
179 Returns:      0 on success; -1 on failure, with errno set
180 */
181
182 int
183 ip_connect(int sock, int af, const uschar *address, int port, int timeout)
184 {
185 struct sockaddr_in s_in4;
186 struct sockaddr *s_ptr;
187 int s_len, rc, save_errno;
188
189 /* For an IPv6 address, use an IPv6 sockaddr structure. */
190
191 #if HAVE_IPV6
192 struct sockaddr_in6 s_in6;
193 if (af == AF_INET6)
194   {
195   memset(&s_in6, 0, sizeof(s_in6));
196   ip_addrinfo(address, &s_in6);   /* Panic-dies on error */
197   s_in6.sin6_port = htons(port);
198   s_ptr = (struct sockaddr *)&s_in6;
199   s_len = sizeof(s_in6);
200   }
201 else
202 #else     /* HAVE_IPV6 */
203 af = af;  /* Avoid compiler warning */
204 #endif    /* HAVE_IPV6 */
205
206 /* For an IPv4 address, use an IPv4 sockaddr structure, even on a system with
207 IPv6 support. */
208
209   {
210   memset(&s_in4, 0, sizeof(s_in4));
211   s_in4.sin_family = AF_INET;
212   s_in4.sin_port = htons(port);
213   s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(CCS address);
214   s_ptr = (struct sockaddr *)&s_in4;
215   s_len = sizeof(s_in4);
216   }
217
218 /* If no connection timeout is set, just call connect() without setting a
219 timer, thereby allowing the inbuilt OS timeout to operate. */
220
221 sigalrm_seen = FALSE;
222 if (timeout > 0) alarm(timeout);
223 rc = connect(sock, s_ptr, s_len);
224 save_errno = errno;
225 alarm(0);
226
227 /* There is a testing facility for simulating a connection timeout, as I
228 can't think of any other way of doing this. It converts a connection refused
229 into a timeout if the timeout is set to 999999. */
230
231 if (running_in_test_harness  && save_errno == ECONNREFUSED && timeout == 999999)
232   {
233   rc = -1;
234   save_errno = EINTR;
235   sigalrm_seen = TRUE;
236   }
237
238 /* Success */
239
240 if (rc >= 0)
241   {
242   callout_address = string_sprintf("[%s]:%d", address, port);
243   return 0;
244   }
245
246 /* A failure whose error code is "Interrupted system call" is in fact
247 an externally applied timeout if the signal handler has been run. */
248
249 errno = save_errno == EINTR && sigalrm_seen ? ETIMEDOUT : save_errno;
250 return -1;
251 }
252
253
254
255 /*************************************************
256 *    Create connected socket to remote host      *
257 *************************************************/
258
259 /* Create a socket and connect to host (name or number, ipv6 ok)
260    at one of port-range.
261
262 Arguments:
263   type          SOCK_DGRAM or SOCK_STREAM
264   af            AF_INET6 or AF_INET for the socket type
265   address       the remote address, in text form
266   portlo,porthi the remote port range
267   timeout       a timeout
268   connhost      if not NULL, host_item filled in with connection details
269   errstr        pointer for allocated string on error
270
271 Return:
272   socket fd, or -1 on failure (having allocated an error string)
273 */
274 int
275 ip_connectedsocket(int type, const uschar * hostname, int portlo, int porthi,
276         int timeout, host_item * connhost, uschar ** errstr)
277 {
278 int namelen, port;
279 host_item shost;
280 host_item *h;
281 int af = 0, fd, fd4 = -1, fd6 = -1;
282
283 shost.next = NULL;
284 shost.address = NULL;
285 shost.port = portlo;
286 shost.mx = -1;
287
288 namelen = Ustrlen(hostname);
289
290 /* Anything enclosed in [] must be an IP address. */
291
292 if (hostname[0] == '[' &&
293     hostname[namelen - 1] == ']')
294   {
295   uschar * host = string_copyn(hostname+1, namelen-2);
296 debug_printf("%s: 1\n", __FUNCTION__);
297   if (string_is_ip_address(host, NULL) == 0)
298     {
299     *errstr = string_sprintf("malformed IP address \"%s\"", hostname);
300     return -1;
301     }
302   shost.name = shost.address = host;
303   }
304
305 /* Otherwise check for an unadorned IP address */
306
307 else if (string_is_ip_address(hostname, NULL) != 0)
308   {
309 debug_printf("%s: 2\n", __FUNCTION__);
310   shost.name = shost.address = string_copyn(hostname, namelen);
311   }
312
313 /* Otherwise lookup IP address(es) from the name */
314
315 else
316   {
317 debug_printf("%s: 3\n", __FUNCTION__);
318   shost.name = string_copyn(hostname, namelen);
319   if (host_find_byname(&shost, NULL, HOST_FIND_QUALIFY_SINGLE,
320       NULL, FALSE) != HOST_FOUND)
321     {
322     *errstr = string_sprintf("no IP address found for host %s", shost.name);
323     return -1;
324     }
325   }
326
327 /* Try to connect to the server - test each IP till one works */
328
329 for (h = &shost; h; h = h->next)
330   {
331 debug_printf("%s: 4 '%s'\n", __FUNCTION__, h->address);
332   fd = Ustrchr(h->address, ':') != 0
333     ? fd6 < 0 ? (fd6 = ip_socket(type, af = AF_INET6)) : fd6
334     : fd4 < 0 ? (fd4 = ip_socket(type, af = AF_INET )) : fd4;
335
336   if (fd < 0)
337     {
338     *errstr = string_sprintf("failed to create socket: %s", strerror(errno));
339     goto bad;
340     }
341
342   for(port = portlo; port <= porthi; port++)
343     if (ip_connect(fd, af, h->address, port, timeout) == 0)
344       {
345       if (fd != fd6) close(fd6);
346       if (fd != fd4) close(fd4);
347       if (connhost)
348         {
349         h->port = port;
350         *connhost = *h;
351         connhost->next = NULL;
352         }
353       return fd;
354       }
355   }
356
357 *errstr = string_sprintf("failed to connect to any address for %s: %s",
358   hostname, strerror(errno));
359
360 bad:
361   close(fd4); close(fd6); return -1;
362 }
363
364
365 int
366 ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo)
367 {
368 int scan;
369 uschar hostname[256];
370 unsigned int portlow, porthigh;
371
372 /* extract host and port part */
373 scan = sscanf(CS hostport, "%255s %u-%u", hostname, &portlow, &porthigh);
374 if (scan != 3)
375   {
376   if (scan != 2)
377     {
378     *errstr = string_sprintf("invalid socket '%s'", hostport);
379     return -1;
380     }
381   porthigh = portlow;
382   }
383
384 return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
385                           tmo, NULL, errstr);
386 }
387
388 int
389 ip_unixsocket(const uschar * path, uschar ** errstr)
390 {
391 int sock;
392 struct sockaddr_un server;
393
394 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
395   {
396   *errstr = US"can't open UNIX socket.";
397   return -1;
398   }
399
400 server.sun_family = AF_UNIX;
401 Ustrncpy(server.sun_path, path, sizeof(server.sun_path)-1);
402 server.sun_path[sizeof(server.sun_path)-1] = '\0';
403 if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
404   {
405   int err = errno;
406   (void)close(sock);
407   *errstr = string_sprintf("unable to connect to UNIX socket (%s): %s",
408                 path, strerror(err));
409   return -1;
410   }
411 callout_address = string_copy(path);
412 return sock;
413 }
414
415 int
416 ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo)
417 {
418 return *spec == '/'
419   ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo);
420 }
421
422 /*************************************************
423 *         Set keepalive on a socket              *
424 *************************************************/
425
426 /* Can be called for both incoming and outgoing sockets.
427
428 Arguments:
429   sock       the socket
430   address    the remote host address, for failure logging
431   torf       true for outgoing connection, false for incoming
432
433 Returns:     nothing
434 */
435
436 void
437 ip_keepalive(int sock, const uschar *address, BOOL torf)
438 {
439 int fodder = 1;
440 if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
441     (uschar *)(&fodder), sizeof(fodder)) != 0)
442   log_write(0, LOG_MAIN, "setsockopt(SO_KEEPALIVE) on connection %s %s "
443     "failed: %s", torf? "to":"from", address, strerror(errno));
444 }
445
446
447
448 /*************************************************
449 *         Receive from a socket with timeout     *
450 *************************************************/
451
452 /*
453 Arguments:
454   fd          the file descriptor
455   timeout     the timeout, seconds
456 Returns:      TRUE => ready for i/o
457               FALSE => timed out, or other error
458 */
459 BOOL
460 fd_ready(int fd, int timeout)
461 {
462 fd_set select_inset;
463 time_t start_recv = time(NULL);
464 int time_left = timeout;
465 int rc;
466
467 if (time_left <= 0)
468   {
469   errno = ETIMEDOUT;
470   return FALSE;
471   }
472 /* Wait until the socket is ready */
473
474 do
475   {
476   struct timeval tv = { time_left, 0 };
477   FD_ZERO (&select_inset);
478   FD_SET (fd, &select_inset);
479
480   /*DEBUG(D_transport) debug_printf("waiting for data on fd\n");*/
481   rc = select(fd + 1, (SELECT_ARG2_TYPE *)&select_inset, NULL, NULL, &tv);
482
483   /* If some interrupt arrived, just retry. We presume this to be rare,
484   but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
485   select() to exit).
486
487   Aug 2004: Somebody set up a cron job that ran exiwhat every 2 minutes, making
488   the interrupt not at all rare. Since the timeout is typically more than 2
489   minutes, the effect was to block the timeout completely. To prevent this
490   happening again, we do an explicit time test and adjust the timeout
491   accordingly */
492
493   if (rc < 0 && errno == EINTR)
494     {
495     DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
496
497     /* Watch out, 'continue' jumps to the condition, not to the loops top */
498     time_left = timeout - (time(NULL) - start_recv);
499     if (time_left > 0) continue;
500     }
501
502   if (rc <= 0)
503     {
504     errno = ETIMEDOUT;
505     return FALSE;
506     }
507
508   /* Checking the FD_ISSET is not enough, if we're interrupted, the
509   select_inset may still contain the 'input'. */
510   }
511 while (rc < 0 || !FD_ISSET(fd, &select_inset));
512 return TRUE;
513 }
514
515 /* The timeout is implemented using select(), and we loop to cover select()
516 getting interrupted, and the possibility of select() returning with a positive
517 result but no ready descriptor. Is this in fact possible?
518
519 Arguments:
520   sock        the socket
521   buffer      to read into
522   bufsize     the buffer size
523   timeout     the timeout
524
525 Returns:      > 0 => that much data read
526               <= 0 on error or EOF; errno set - zero for EOF
527 */
528
529 int
530 ip_recv(int sock, uschar *buffer, int buffsize, int timeout)
531 {
532 int rc;
533
534 if (!fd_ready(sock, timeout))
535   return -1;
536
537 /* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
538 close down of the connection), set errno to zero; otherwise leave it alone. */
539
540 #ifdef SUPPORT_TLS
541 if (tls_out.active == sock)
542   rc = tls_read(FALSE, buffer, buffsize);
543 else if (tls_in.active == sock)
544   rc = tls_read(TRUE, buffer, buffsize);
545 else
546 #endif
547   rc = recv(sock, buffer, buffsize, 0);
548
549 if (rc > 0) return rc;
550 if (rc == 0) errno = 0;
551 return -1;
552 }
553
554
555
556
557 /*************************************************
558 *    Lookup address family of potential socket   *
559 *************************************************/
560
561 /* Given a file-descriptor, check to see if it's a socket and, if so,
562 return the address family; detects IPv4 vs IPv6.  If not a socket then
563 return -1.
564
565 The value 0 is typically AF_UNSPEC, which should not be seen on a connected
566 fd.  If the return is -1, the errno will be from getsockname(); probably
567 ENOTSOCK or ECONNRESET.
568
569 Arguments:     socket-or-not fd
570 Returns:       address family or -1
571 */
572
573 int
574 ip_get_address_family(int fd)
575 {
576 struct sockaddr_storage ss;
577 socklen_t sslen = sizeof(ss);
578
579 if (getsockname(fd, (struct sockaddr *) &ss, &sslen) < 0)
580   return -1;
581
582 return (int) ss.ss_family;
583 }
584
585
586
587
588 /*************************************************
589 *       Lookup DSCP settings for a socket        *
590 *************************************************/
591
592 struct dscp_name_tableentry {
593   const uschar *name;
594   int value;
595 };
596 /* Keep both of these tables sorted! */
597 static struct dscp_name_tableentry dscp_table[] = {
598 #ifdef IPTOS_DSCP_AF11
599     { CUS"af11", IPTOS_DSCP_AF11 },
600     { CUS"af12", IPTOS_DSCP_AF12 },
601     { CUS"af13", IPTOS_DSCP_AF13 },
602     { CUS"af21", IPTOS_DSCP_AF21 },
603     { CUS"af22", IPTOS_DSCP_AF22 },
604     { CUS"af23", IPTOS_DSCP_AF23 },
605     { CUS"af31", IPTOS_DSCP_AF31 },
606     { CUS"af32", IPTOS_DSCP_AF32 },
607     { CUS"af33", IPTOS_DSCP_AF33 },
608     { CUS"af41", IPTOS_DSCP_AF41 },
609     { CUS"af42", IPTOS_DSCP_AF42 },
610     { CUS"af43", IPTOS_DSCP_AF43 },
611     { CUS"ef", IPTOS_DSCP_EF },
612 #endif
613 #ifdef IPTOS_LOWCOST
614     { CUS"lowcost", IPTOS_LOWCOST },
615 #endif
616     { CUS"lowdelay", IPTOS_LOWDELAY },
617 #ifdef IPTOS_MINCOST
618     { CUS"mincost", IPTOS_MINCOST },
619 #endif
620     { CUS"reliability", IPTOS_RELIABILITY },
621     { CUS"throughput", IPTOS_THROUGHPUT }
622 };
623 static int dscp_table_size =
624   sizeof(dscp_table) / sizeof(struct dscp_name_tableentry);
625
626 /* DSCP values change by protocol family, and so do the options used for
627 setsockopt(); this utility does all the lookups.  It takes an unexpanded
628 option string, expands it, strips off affix whitespace, then checks if it's
629 a number.  If all of what's left is a number, then that's how the option will
630 be parsed and success/failure is a range check.  If it's not all a number,
631 then it must be a supported keyword.
632
633 Arguments:
634   dscp_name   a string, so far unvalidated
635   af          address_family in use
636   level       setsockopt level to use
637   optname     setsockopt name to use
638   dscp_value  value for dscp_name
639
640 Returns: TRUE if okay to setsockopt(), else FALSE
641
642 *level and *optname may be set even if FALSE is returned
643 */
644
645 BOOL
646 dscp_lookup(const uschar *dscp_name, int af,
647     int *level, int *optname, int *dscp_value)
648 {
649 uschar *dscp_lookup, *p;
650 int first, last;
651 long rawlong;
652
653 if (af == AF_INET)
654   {
655   *level = IPPROTO_IP;
656   *optname = IP_TOS;
657   }
658 #if HAVE_IPV6 && defined(IPV6_TCLASS)
659 else if (af == AF_INET6)
660   {
661   *level = IPPROTO_IPV6;
662   *optname = IPV6_TCLASS;
663   }
664 #endif
665 else
666   {
667   DEBUG(D_transport)
668     debug_printf("Unhandled address family %d in dscp_lookup()\n", af);
669   return FALSE;
670   }
671 if (!dscp_name)
672   {
673   DEBUG(D_transport)
674     debug_printf("[empty DSCP]\n");
675   return FALSE;
676   }
677 dscp_lookup = expand_string(US dscp_name);
678 if (dscp_lookup == NULL || *dscp_lookup == '\0')
679   return FALSE;
680
681 p = dscp_lookup + Ustrlen(dscp_lookup) - 1;
682 while (isspace(*p)) *p-- = '\0';
683 while (isspace(*dscp_lookup) && dscp_lookup < p) dscp_lookup++;
684 if (*dscp_lookup == '\0')
685   return FALSE;
686
687 rawlong = Ustrtol(dscp_lookup, &p, 0);
688 if (p != dscp_lookup && *p == '\0')
689   {
690   /* We have six bits available, which will end up shifted to fit in 0xFC mask.
691   RFC 2597 defines the values unshifted. */
692   if (rawlong < 0 || rawlong > 0x3F)
693     {
694     DEBUG(D_transport)
695       debug_printf("DSCP value %ld out of range, ignored.\n", rawlong);
696     return FALSE;
697     }
698   *dscp_value = rawlong << 2;
699   return TRUE;
700   }
701
702 first = 0;
703 last = dscp_table_size;
704 while (last > first)
705   {
706   int middle = (first + last)/2;
707   int c = Ustrcmp(dscp_lookup, dscp_table[middle].name);
708   if (c == 0)
709     {
710     *dscp_value = dscp_table[middle].value;
711     return TRUE;
712     }
713   else if (c > 0)
714     first = middle + 1;
715   else
716     last = middle;
717   }
718 return FALSE;
719 }
720
721 void
722 dscp_list_to_stream(FILE *stream)
723 {
724 int i;
725 for (i=0; i < dscp_table_size; ++i)
726   fprintf(stream, "%s\n", dscp_table[i].name);
727 }
728
729
730 /* End of ip.c */
731 /* vi: aw ai sw=2
732 */