update to pre-4.87 master
[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 - 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_copy(hostname);
296   host[namelen - 1] = 0;
297   host++;
298   if (string_is_ip_address(host, NULL) == 0)
299     {
300     *errstr = string_sprintf("malformed IP address \"%s\"", hostname);
301     return -1;
302     }
303   shost.name = shost.address = host;
304   }
305
306 /* Otherwise check for an unadorned IP address */
307
308 else if (string_is_ip_address(hostname, NULL) != 0)
309   shost.name = shost.address = string_copy(hostname);
310
311 /* Otherwise lookup IP address(es) from the name */
312
313 else
314   {
315   shost.name = string_copy(hostname);
316   if (host_find_byname(&shost, NULL, HOST_FIND_QUALIFY_SINGLE,
317       NULL, FALSE) != HOST_FOUND)
318     {
319     *errstr = string_sprintf("no IP address found for host %s", shost.name);
320     return -1;
321     }
322   }
323
324 /* Try to connect to the server - test each IP till one works */
325
326 for (h = &shost; h != NULL; h = h->next)
327   {
328   fd = (Ustrchr(h->address, ':') != 0)
329     ? (fd6 < 0) ? (fd6 = ip_socket(type, af = AF_INET6)) : fd6
330     : (fd4 < 0) ? (fd4 = ip_socket(type, af = AF_INET )) : fd4;
331
332   if (fd < 0)
333     {
334     *errstr = string_sprintf("failed to create socket: %s", strerror(errno));
335     goto bad;
336     }
337
338   for(port = portlo; port <= porthi; port++)
339     if (ip_connect(fd, af, h->address, port, timeout) == 0)
340       {
341       if (fd != fd6) close(fd6);
342       if (fd != fd4) close(fd4);
343       if (connhost)
344         {
345         h->port = port;
346         *connhost = *h;
347         connhost->next = NULL;
348         }
349       return fd;
350       }
351   }
352
353 *errstr = string_sprintf("failed to connect to any address for %s: %s",
354   hostname, strerror(errno));
355
356 bad:
357   close(fd4); close(fd6); return -1;
358 }
359
360
361 int
362 ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo)
363 {
364 int scan;
365 uschar hostname[256];
366 unsigned int portlow, porthigh;
367
368 /* extract host and port part */
369 scan = sscanf(CS hostport, "%255s %u-%u", hostname, &portlow, &porthigh);
370 if (scan != 3)
371   {
372   if (scan != 2)
373     {
374     *errstr = string_sprintf("invalid socket '%s'", hostport);
375     return -1;
376     }
377   porthigh = portlow;
378   }
379
380 return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
381                           tmo, NULL, errstr);
382 }
383
384 int
385 ip_unixsocket(const uschar * path, uschar ** errstr)
386 {
387 int sock;
388 struct sockaddr_un server;
389
390 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
391   {
392   *errstr = US"can't open UNIX socket.";
393   return -1;
394   }
395
396 server.sun_family = AF_UNIX;
397 Ustrncpy(server.sun_path, path, sizeof(server.sun_path)-1);
398 server.sun_path[sizeof(server.sun_path)-1] = '\0';
399 if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
400   {
401   int err = errno;
402   (void)close(sock);
403   *errstr = string_sprintf("unable to connect to UNIX socket (%s): %s",
404                 path, strerror(err));
405   return -1;
406   }
407 callout_address = string_copy(path);
408 return sock;
409 }
410
411 int
412 ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo)
413 {
414 return *spec == '/'
415   ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo);
416 }
417
418 /*************************************************
419 *         Set keepalive on a socket              *
420 *************************************************/
421
422 /* Can be called for both incoming and outgoing sockets.
423
424 Arguments:
425   sock       the socket
426   address    the remote host address, for failure logging
427   torf       true for outgoing connection, false for incoming
428
429 Returns:     nothing
430 */
431
432 void
433 ip_keepalive(int sock, const uschar *address, BOOL torf)
434 {
435 int fodder = 1;
436 if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
437     (uschar *)(&fodder), sizeof(fodder)) != 0)
438   log_write(0, LOG_MAIN, "setsockopt(SO_KEEPALIVE) on connection %s %s "
439     "failed: %s", torf? "to":"from", address, strerror(errno));
440 }
441
442
443
444 /*************************************************
445 *         Receive from a socket with timeout     *
446 *************************************************/
447
448 /*
449 Arguments:
450   fd          the file descriptor
451   timeout     the timeout, seconds
452 Returns:      TRUE => ready for i/o
453               FALSE => timed out, or other error
454 */
455 BOOL
456 fd_ready(int fd, int timeout)
457 {
458 fd_set select_inset;
459 time_t start_recv = time(NULL);
460 int time_left = timeout;
461 int rc;
462
463 if (time_left <= 0)
464   {
465   errno = ETIMEDOUT;
466   return FALSE;
467   }
468 /* Wait until the socket is ready */
469
470 do
471   {
472   struct timeval tv = { time_left, 0 };
473   FD_ZERO (&select_inset);
474   FD_SET (fd, &select_inset);
475
476   /*DEBUG(D_transport) debug_printf("waiting for data on fd\n");*/
477   rc = select(fd + 1, (SELECT_ARG2_TYPE *)&select_inset, NULL, NULL, &tv);
478
479   /* If some interrupt arrived, just retry. We presume this to be rare,
480   but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
481   select() to exit).
482
483   Aug 2004: Somebody set up a cron job that ran exiwhat every 2 minutes, making
484   the interrupt not at all rare. Since the timeout is typically more than 2
485   minutes, the effect was to block the timeout completely. To prevent this
486   happening again, we do an explicit time test and adjust the timeout
487   accordingly */
488
489   if (rc < 0 && errno == EINTR)
490     {
491     DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
492
493     /* Watch out, 'continue' jumps to the condition, not to the loops top */
494     time_left = timeout - (time(NULL) - start_recv);
495     if (time_left > 0) continue;
496     }
497
498   if (rc <= 0)
499     {
500     errno = ETIMEDOUT;
501     return FALSE;
502     }
503
504   /* Checking the FD_ISSET is not enough, if we're interrupted, the
505   select_inset may still contain the 'input'. */
506   }
507 while (rc < 0 || !FD_ISSET(fd, &select_inset));
508 return TRUE;
509 }
510
511 /* The timeout is implemented using select(), and we loop to cover select()
512 getting interrupted, and the possibility of select() returning with a positive
513 result but no ready descriptor. Is this in fact possible?
514
515 Arguments:
516   sock        the socket
517   buffer      to read into
518   bufsize     the buffer size
519   timeout     the timeout
520
521 Returns:      > 0 => that much data read
522               <= 0 on error or EOF; errno set - zero for EOF
523 */
524
525 int
526 ip_recv(int sock, uschar *buffer, int buffsize, int timeout)
527 {
528 int rc;
529
530 if (!fd_ready(sock, timeout))
531   return -1;
532
533 /* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
534 close down of the connection), set errno to zero; otherwise leave it alone. */
535
536 #ifdef SUPPORT_TLS
537 if (tls_out.active == sock)
538   rc = tls_read(FALSE, buffer, buffsize);
539 else if (tls_in.active == sock)
540   rc = tls_read(TRUE, buffer, buffsize);
541 else
542 #endif
543   rc = recv(sock, buffer, buffsize, 0);
544
545 if (rc > 0) return rc;
546 if (rc == 0) errno = 0;
547 return -1;
548 }
549
550
551
552
553 /*************************************************
554 *    Lookup address family of potential socket   *
555 *************************************************/
556
557 /* Given a file-descriptor, check to see if it's a socket and, if so,
558 return the address family; detects IPv4 vs IPv6.  If not a socket then
559 return -1.
560
561 The value 0 is typically AF_UNSPEC, which should not be seen on a connected
562 fd.  If the return is -1, the errno will be from getsockname(); probably
563 ENOTSOCK or ECONNRESET.
564
565 Arguments:     socket-or-not fd
566 Returns:       address family or -1
567 */
568
569 int
570 ip_get_address_family(int fd)
571 {
572 struct sockaddr_storage ss;
573 socklen_t sslen = sizeof(ss);
574
575 if (getsockname(fd, (struct sockaddr *) &ss, &sslen) < 0)
576   return -1;
577
578 return (int) ss.ss_family;
579 }
580
581
582
583
584 /*************************************************
585 *       Lookup DSCP settings for a socket        *
586 *************************************************/
587
588 struct dscp_name_tableentry {
589   const uschar *name;
590   int value;
591 };
592 /* Keep both of these tables sorted! */
593 static struct dscp_name_tableentry dscp_table[] = {
594 #ifdef IPTOS_DSCP_AF11
595     { CUS"af11", IPTOS_DSCP_AF11 },
596     { CUS"af12", IPTOS_DSCP_AF12 },
597     { CUS"af13", IPTOS_DSCP_AF13 },
598     { CUS"af21", IPTOS_DSCP_AF21 },
599     { CUS"af22", IPTOS_DSCP_AF22 },
600     { CUS"af23", IPTOS_DSCP_AF23 },
601     { CUS"af31", IPTOS_DSCP_AF31 },
602     { CUS"af32", IPTOS_DSCP_AF32 },
603     { CUS"af33", IPTOS_DSCP_AF33 },
604     { CUS"af41", IPTOS_DSCP_AF41 },
605     { CUS"af42", IPTOS_DSCP_AF42 },
606     { CUS"af43", IPTOS_DSCP_AF43 },
607     { CUS"ef", IPTOS_DSCP_EF },
608 #endif
609 #ifdef IPTOS_LOWCOST
610     { CUS"lowcost", IPTOS_LOWCOST },
611 #endif
612     { CUS"lowdelay", IPTOS_LOWDELAY },
613 #ifdef IPTOS_MINCOST
614     { CUS"mincost", IPTOS_MINCOST },
615 #endif
616     { CUS"reliability", IPTOS_RELIABILITY },
617     { CUS"throughput", IPTOS_THROUGHPUT }
618 };
619 static int dscp_table_size =
620   sizeof(dscp_table) / sizeof(struct dscp_name_tableentry);
621
622 /* DSCP values change by protocol family, and so do the options used for
623 setsockopt(); this utility does all the lookups.  It takes an unexpanded
624 option string, expands it, strips off affix whitespace, then checks if it's
625 a number.  If all of what's left is a number, then that's how the option will
626 be parsed and success/failure is a range check.  If it's not all a number,
627 then it must be a supported keyword.
628
629 Arguments:
630   dscp_name   a string, so far unvalidated
631   af          address_family in use
632   level       setsockopt level to use
633   optname     setsockopt name to use
634   dscp_value  value for dscp_name
635
636 Returns: TRUE if okay to setsockopt(), else FALSE
637
638 *level and *optname may be set even if FALSE is returned
639 */
640
641 BOOL
642 dscp_lookup(const uschar *dscp_name, int af,
643     int *level, int *optname, int *dscp_value)
644 {
645 uschar *dscp_lookup, *p;
646 int first, last;
647 long rawlong;
648
649 if (af == AF_INET)
650   {
651   *level = IPPROTO_IP;
652   *optname = IP_TOS;
653   }
654 #if HAVE_IPV6 && defined(IPV6_TCLASS)
655 else if (af == AF_INET6)
656   {
657   *level = IPPROTO_IPV6;
658   *optname = IPV6_TCLASS;
659   }
660 #endif
661 else
662   {
663   DEBUG(D_transport)
664     debug_printf("Unhandled address family %d in dscp_lookup()\n", af);
665   return FALSE;
666   }
667 if (!dscp_name)
668   {
669   DEBUG(D_transport)
670     debug_printf("[empty DSCP]\n");
671   return FALSE;
672   }
673 dscp_lookup = expand_string(US dscp_name);
674 if (dscp_lookup == NULL || *dscp_lookup == '\0')
675   return FALSE;
676
677 p = dscp_lookup + Ustrlen(dscp_lookup) - 1;
678 while (isspace(*p)) *p-- = '\0';
679 while (isspace(*dscp_lookup) && dscp_lookup < p) dscp_lookup++;
680 if (*dscp_lookup == '\0')
681   return FALSE;
682
683 rawlong = Ustrtol(dscp_lookup, &p, 0);
684 if (p != dscp_lookup && *p == '\0')
685   {
686   /* We have six bits available, which will end up shifted to fit in 0xFC mask.
687   RFC 2597 defines the values unshifted. */
688   if (rawlong < 0 || rawlong > 0x3F)
689     {
690     DEBUG(D_transport)
691       debug_printf("DSCP value %ld out of range, ignored.\n", rawlong);
692     return FALSE;
693     }
694   *dscp_value = rawlong << 2;
695   return TRUE;
696   }
697
698 first = 0;
699 last = dscp_table_size;
700 while (last > first)
701   {
702   int middle = (first + last)/2;
703   int c = Ustrcmp(dscp_lookup, dscp_table[middle].name);
704   if (c == 0)
705     {
706     *dscp_value = dscp_table[middle].value;
707     return TRUE;
708     }
709   else if (c > 0)
710     first = middle + 1;
711   else
712     last = middle;
713   }
714 return FALSE;
715 }
716
717 void
718 dscp_list_to_stream(FILE *stream)
719 {
720 int i;
721 for (i=0; i < dscp_table_size; ++i)
722   fprintf(stream, "%s\n", dscp_table[i].name);
723 }
724
725
726 /* End of ip.c */
727 /* vi: aw ai sw=2
728 */