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