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