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