FreeBSD: better support for TFO
[exim.git] / src / src / ip.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
f9ba5e22 5/* Copyright (c) University of Cambridge 1995 - 2018 */
059ec3d9
PH
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
9got messier, so that it's worth pulling out the code into separate functions
4c04137d 10that other parts of Exim can call, especially as there are now several
059ec3d9
PH
11different places in the code where sockets are used. */
12
13
14#include "exim.h"
15
16
73a10da9
JH
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
059ec3d9
PH
23/*************************************************
24* Create a socket *
25*************************************************/
26
27/* Socket creation happens in a number of places so it's packaged here for
28convenience.
29
30Arguments:
31 type SOCK_DGRAM or SOCK_STREAM
32 af AF_INET or AF_INET6
33
34Returns: socket number or -1 on failure
35*/
36
37int
38ip_socket(int type, int af)
39{
40int sock = socket(af, type, 0);
41if (sock < 0)
42 log_write(0, LOG_MAIN, "IPv%c socket creation failed: %s",
43 (af == AF_INET6)? '6':'4', strerror(errno));
44return 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
56in an appropriate structure in an IPv6 environment. The getaddrinfo() function
57can (apparently) handle more complicated addresses (e.g. those containing
58scopes) than inet_pton() in some environments. We use hints to tell it that the
59input must be a numeric address.
60
61However, apparently some operating systems (or libraries) don't support
62getaddrinfo(), so there is a build-time option to revert to inet_pton() (which
63does not support scopes).
64
65Arguments:
66 address textual form of the address
67 addr where to copy back the answer
68
69Returns: nothing - failure provokes a panic-die
70*/
71
72static void
a56cc2b8 73ip_addrinfo(const uschar *address, struct sockaddr_in6 *saddr)
059ec3d9
PH
74{
75#ifdef IPV6_USE_INET_PTON
76
a56cc2b8 77 if (inet_pton(AF_INET6, CCS address, &saddr->sin6_addr) != 1)
059ec3d9
PH
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;
a56cc2b8 90 if ((rc = getaddrinfo(CCS address, NULL, &hints, &res)) != 0 || res == NULL)
059ec3d9
PH
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
059ec3d9 106int
7eb6c37c 107ip_addr(void * sin_, int af, const uschar * address, int port)
059ec3d9 108{
7eb6c37c 109union sockaddr_46 * sin = sin_;
69cbeaec 110memset(sin, 0, sizeof(*sin));
059ec3d9
PH
111
112/* Setup code when using an IPv6 socket. The wildcard address is ":", to
113ensure an IPv6 socket is used. */
114
115#if HAVE_IPV6
116if (af == AF_INET6)
117 {
118 if (address[0] == ':' && address[1] == 0)
119 {
7eb6c37c
JH
120 sin->v6.sin6_family = AF_INET6;
121 sin->v6.sin6_addr = in6addr_any;
059ec3d9
PH
122 }
123 else
7eb6c37c
JH
124 ip_addrinfo(address, &sin->v6); /* Panic-dies on error */
125 sin->v6.sin6_port = htons(port);
126 return sizeof(sin->v6);
059ec3d9
PH
127 }
128else
129#else /* HAVE_IPv6 */
130af = af; /* Avoid compiler warning */
131#endif /* HAVE_IPV6 */
132
133/* Setup code when using IPv4 socket. The wildcard address is "". */
134
135 {
7eb6c37c
JH
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);
059ec3d9 142 }
7eb6c37c 143}
059ec3d9 144
059ec3d9 145
7eb6c37c
JH
146
147/* This function binds a socket to a local interface address and port. For a
148wildcard IPv6 bind, the address is ":".
149
150Arguments:
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
156Returns: the result of bind()
157*/
158
159int
160ip_bind(int sock, int af, uschar *address, int port)
161{
162union sockaddr_46 sin;
163int s_len = ip_addr(&sin, af, address, port);
059ec3d9
PH
164return 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
d515a917
PH
174or may not have previously been bound to a local interface. The socket is not
175closed, even in cases of error. It is expected that the calling function, which
176created the socket, will be the one that closes it.
059ec3d9
PH
177
178Arguments:
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
b1f8e4f8 183 timeout a timeout (zero for indefinite timeout)
10ac8d7f 184 fastopen_blob non-null iff TCP_FASTOPEN can be used; may indicate early-data to
b536a578 185 be sent in SYN segment. Any such data must be idempotent.
059ec3d9
PH
186
187Returns: 0 on success; -1 on failure, with errno set
188*/
189
190int
fb05276a 191ip_connect(int sock, int af, const uschar *address, int port, int timeout,
10ac8d7f 192 const blob * fastopen_blob)
059ec3d9
PH
193{
194struct sockaddr_in s_in4;
195struct sockaddr *s_ptr;
196int s_len, rc, save_errno;
197
198/* For an IPv6 address, use an IPv6 sockaddr structure. */
199
200#if HAVE_IPV6
201struct sockaddr_in6 s_in6;
202if (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 }
210else
211#else /* HAVE_IPV6 */
212af = af; /* Avoid compiler warning */
213#endif /* HAVE_IPV6 */
214
215/* For an IPv4 address, use an IPv4 sockaddr structure, even on a system with
216IPv6 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);
a56cc2b8 222 s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(CCS address);
059ec3d9
PH
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
228timer, thereby allowing the inbuilt OS timeout to operate. */
229
af483912 230callout_address = string_sprintf("[%s]:%d", address, port);
059ec3d9 231sigalrm_seen = FALSE;
c2a1bba0 232if (timeout > 0) ALARM(timeout);
fb05276a 233
73a10da9 234#ifdef EXIM_SUPPORT_TFO
fb05276a
JH
235/* TCP Fast Open, if the system has a cookie from a previous call to
236this peer, can send data in the SYN packet. The peer can send data
237before it gets our ACK of its SYN,ACK - the latter is useful for
ac0dcd3f 238the SMTP banner. Other (than SMTP) cases of TCP connections can
b536a578 239possibly use the data-on-syn, so support that too. */
fb05276a 240
8768d548 241if (fastopen_blob && f.tcp_fastopen_ok)
fb05276a 242 {
b536a578 243# ifdef MSG_FASTOPEN
73a10da9 244 /* This is a Linux implementation. */
b536a578 245
10ac8d7f 246 if ((rc = sendto(sock, fastopen_blob->data, fastopen_blob->len,
ac0dcd3f 247 MSG_FASTOPEN | MSG_DONTWAIT, s_ptr, s_len)) >= 0)
1ccd5f67 248 /* seen for with-data, experimental TFO option, with-cookie case */
8255135b 249 /* seen for with-data, proper TFO opt, with-cookie case */
ac0dcd3f 250 {
10ac8d7f 251 DEBUG(D_transport|D_v)
adb21834 252 debug_printf(" TFO mode connection attempt to %s, %lu data\n",
4aa2e44b 253 address, (unsigned long)fastopen_blob->len);
afdb5e9c 254 /*XXX also seen on successful TFO, sigh */
ee8b8090 255 tcp_out_fastopen = fastopen_blob->len > 0 ? TFO_ATTEMPTED_DATA : TFO_ATTEMPTED_NODATA;
ac0dcd3f 256 }
8255135b 257 else if (errno == EINPROGRESS) /* expected if we had no cookie for peer */
1ccd5f67
JH
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 */
8255135b 260 /* seen for with-data, proper TFO opt, cookie-req */
1ccd5f67
JH
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 */
adb21834 264 DEBUG(D_transport|D_v) debug_printf(" TFO mode sendto, %s data: EINPROGRESS\n",
10ac8d7f
JH
265 fastopen_blob->len > 0 ? "with" : "no");
266 if (!fastopen_blob->data)
a2673768 267 {
ee8b8090 268 tcp_out_fastopen = TFO_ATTEMPTED_NODATA; /* we tried; unknown if useful yet */
ac0dcd3f 269 rc = 0;
a2673768 270 }
8255135b 271 else
10ac8d7f 272 rc = send(sock, fastopen_blob->data, fastopen_blob->len, 0);
ac0dcd3f
JH
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 }
73a10da9
JH
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)
b536a578
JH
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)
adb21834 312 debug_printf(" TFO mode connection attempt to %s, %lu data\n",
b536a578 313 address, (unsigned long)fastopen_blob->len);
068f180d 314 tcp_out_fastopen = fastopen_blob->len > 0 ? TFO_ATTEMPTED_DATA : TFO_ATTEMPTED_NODATA;
b536a578
JH
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 {
adb21834 322 DEBUG(D_transport|D_v) debug_printf(" TFO mode connectx, %s data: EINPROGRESS\n",
b536a578
JH
323 fastopen_blob->len > 0 ? "with" : "no");
324 if (!fastopen_blob->data)
325 {
7434882d 326 tcp_out_fastopen = TFO_ATTEMPTED_NODATA; /* we tried; unknown if useful yet */
b536a578
JH
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
fb05276a
JH
333 }
334else
73a10da9 335#endif /*EXIM_SUPPORT_TFO*/
0ab63f3d 336 {
73a10da9 337#if defined(EXIM_SUPPORT_TFO) && !defined(EXIM_TFO_CONNECTX)
0ab63f3d 338legacy_connect:
dca6d121
JH
339#endif
340
10ac8d7f 341 DEBUG(D_transport|D_v) if (fastopen_blob)
adb21834 342 debug_printf(" non-TFO mode connection attempt to %s, %lu data\n",
4aa2e44b 343 address, (unsigned long)fastopen_blob->len);
0ab63f3d 344 if ((rc = connect(sock, s_ptr, s_len)) >= 0)
10ac8d7f
JH
345 if ( fastopen_blob && fastopen_blob->data && fastopen_blob->len
346 && send(sock, fastopen_blob->data, fastopen_blob->len, 0) < 0)
0ab63f3d
JH
347 rc = -1;
348 }
fb05276a 349
059ec3d9 350save_errno = errno;
c2a1bba0 351ALARM_CLR(0);
059ec3d9
PH
352
353/* There is a testing facility for simulating a connection timeout, as I
354can't think of any other way of doing this. It converts a connection refused
75e0e026 355into a timeout if the timeout is set to 999999. */
059ec3d9 356
8768d548 357if (f.running_in_test_harness && save_errno == ECONNREFUSED && timeout == 999999)
059ec3d9 358 {
a39bd74d
JB
359 rc = -1;
360 save_errno = EINTR;
361 sigalrm_seen = TRUE;
059ec3d9
PH
362 }
363
364/* Success */
365
055e2cb4 366if (rc >= 0)
055e2cb4 367 return 0;
059ec3d9
PH
368
369/* A failure whose error code is "Interrupted system call" is in fact
370an externally applied timeout if the signal handler has been run. */
371
a39bd74d 372errno = save_errno == EINTR && sigalrm_seen ? ETIMEDOUT : save_errno;
059ec3d9
PH
373return -1;
374}
375
376
a6d4c44e
TF
377
378/*************************************************
379* Create connected socket to remote host *
380*************************************************/
381
b1f8e4f8
JH
382/* Create a socket and connect to host (name or number, ipv6 ok)
383 at one of port-range.
a6d4c44e 384
b1f8e4f8
JH
385Arguments:
386 type SOCK_DGRAM or SOCK_STREAM
387 af AF_INET6 or AF_INET for the socket type
afdb5e9c 388 hostname host name, or ip address (as text)
b1f8e4f8
JH
389 portlo,porthi the remote port range
390 timeout a timeout
4a5cbaff 391 connhost if not NULL, host_item to be filled in with connection details
b1f8e4f8 392 errstr pointer for allocated string on error
10ac8d7f 393 fastopen_blob with SOCK_STREAM, if non-null, request TCP Fast Open.
b536a578 394 Additionally, optional idempotent early-data to send
b1f8e4f8
JH
395
396Return:
397 socket fd, or -1 on failure (having allocated an error string)
398*/
399int
400ip_connectedsocket(int type, const uschar * hostname, int portlo, int porthi,
10ac8d7f 401 int timeout, host_item * connhost, uschar ** errstr, const blob * fastopen_blob)
b1f8e4f8 402{
d7978c0f 403int namelen;
b1f8e4f8 404host_item shost;
b1f8e4f8
JH
405int af = 0, fd, fd4 = -1, fd6 = -1;
406
407shost.next = NULL;
408shost.address = NULL;
409shost.port = portlo;
410shost.mx = -1;
411
412namelen = Ustrlen(hostname);
413
414/* Anything enclosed in [] must be an IP address. */
415
416if (hostname[0] == '[' &&
417 hostname[namelen - 1] == ']')
418 {
af483912 419 uschar * host = string_copyn(hostname+1, namelen-2);
b1f8e4f8
JH
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
430else if (string_is_ip_address(hostname, NULL) != 0)
af483912 431 shost.name = shost.address = string_copyn(hostname, namelen);
b1f8e4f8
JH
432
433/* Otherwise lookup IP address(es) from the name */
434
435else
436 {
af483912 437 shost.name = string_copyn(hostname, namelen);
1f155f8e
JH
438 if (host_find_byname(&shost, NULL, HOST_FIND_QUALIFY_SINGLE,
439 NULL, FALSE) != HOST_FOUND)
b1f8e4f8
JH
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
d7978c0f 448for (host_item * h = &shost; h; h = h->next)
b1f8e4f8 449 {
af483912
JH
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;
b1f8e4f8
JH
453
454 if (fd < 0)
455 {
456 *errstr = string_sprintf("failed to create socket: %s", strerror(errno));
457 goto bad;
458 }
459
d7978c0f 460 for (int port = portlo; port <= porthi; port++)
10ac8d7f 461 if (ip_connect(fd, af, h->address, port, timeout, fastopen_blob) == 0)
b1f8e4f8
JH
462 {
463 if (fd != fd6) close(fd6);
464 if (fd != fd4) close(fd4);
8a512ed5
JH
465 if (connhost)
466 {
b1f8e4f8
JH
467 h->port = port;
468 *connhost = *h;
469 connhost->next = NULL;
470 }
471 return fd;
472 }
473 }
474
a9764ac5
JH
475*errstr = string_sprintf("failed to connect to any address for %s: %s",
476 hostname, strerror(errno));
b1f8e4f8
JH
477
478bad:
479 close(fd4); close(fd6); return -1;
480}
481
059ec3d9 482
4a5cbaff 483/*XXX TFO? */
3e60dd41
JH
484int
485ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo)
486{
a39bd74d
JB
487int scan;
488uschar hostname[256];
489unsigned int portlow, porthigh;
490
491/* extract host and port part */
492scan = sscanf(CS hostport, "%255s %u-%u", hostname, &portlow, &porthigh);
493if (scan != 3)
494 {
495 if (scan != 2)
496 {
497 *errstr = string_sprintf("invalid socket '%s'", hostport);
498 return -1;
3e60dd41 499 }
a39bd74d 500 porthigh = portlow;
3e60dd41
JH
501 }
502
a39bd74d 503return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
4a5cbaff 504 tmo, NULL, errstr, NULL);
3e60dd41
JH
505}
506
507int
508ip_unixsocket(const uschar * path, uschar ** errstr)
509{
a39bd74d
JB
510int sock;
511struct sockaddr_un server;
3e60dd41 512
a39bd74d
JB
513if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
514 {
515 *errstr = US"can't open UNIX socket.";
516 return -1;
3e60dd41
JH
517 }
518
af483912 519callout_address = string_copy(path);
a39bd74d 520server.sun_family = AF_UNIX;
f3ebb786 521Ustrncpy(US server.sun_path, path, sizeof(server.sun_path)-1);
a39bd74d
JB
522server.sun_path[sizeof(server.sun_path)-1] = '\0';
523if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
524 {
525 int err = errno;
526 (void)close(sock);
527 *errstr = string_sprintf("unable to connect to UNIX socket (%s): %s",
528 path, strerror(err));
529 return -1;
530 }
531return sock;
3e60dd41
JH
532}
533
534int
535ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo)
536{
a39bd74d
JB
537return *spec == '/'
538 ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo);
3e60dd41
JH
539}
540
059ec3d9
PH
541/*************************************************
542* Set keepalive on a socket *
543*************************************************/
544
545/* Can be called for both incoming and outgoing sockets.
546
547Arguments:
548 sock the socket
549 address the remote host address, for failure logging
550 torf true for outgoing connection, false for incoming
551
552Returns: nothing
553*/
554
555void
55414b25 556ip_keepalive(int sock, const uschar *address, BOOL torf)
059ec3d9
PH
557{
558int fodder = 1;
559if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
5903c6ff 560 US (&fodder), sizeof(fodder)) != 0)
059ec3d9
PH
561 log_write(0, LOG_MAIN, "setsockopt(SO_KEEPALIVE) on connection %s %s "
562 "failed: %s", torf? "to":"from", address, strerror(errno));
563}
564
565
566
567/*************************************************
568* Receive from a socket with timeout *
569*************************************************/
570
4e71661f 571/*
059ec3d9 572Arguments:
4e71661f 573 fd the file descriptor
0a5441fc 574 timelimit the timeout endpoint, seconds-since-epoch
4e71661f
JH
575Returns: TRUE => ready for i/o
576 FALSE => timed out, or other error
059ec3d9 577*/
4e71661f 578BOOL
0a5441fc 579fd_ready(int fd, time_t timelimit)
059ec3d9
PH
580{
581fd_set select_inset;
0a5441fc 582int time_left = timelimit - time(NULL);
059ec3d9
PH
583int rc;
584
85ff3cf9 585if (time_left <= 0)
4e71661f
JH
586 {
587 errno = ETIMEDOUT;
588 return FALSE;
589 }
059ec3d9
PH
590/* Wait until the socket is ready */
591
a39bd74d 592do
059ec3d9 593 {
f2ed27cf 594 struct timeval tv = { .tv_sec = time_left, .tv_usec = 0 };
059ec3d9 595 FD_ZERO (&select_inset);
4e71661f 596 FD_SET (fd, &select_inset);
059ec3d9 597
0f0c8159 598 /*DEBUG(D_transport) debug_printf("waiting for data on fd\n");*/
4e71661f 599 rc = select(fd + 1, (SELECT_ARG2_TYPE *)&select_inset, NULL, NULL, &tv);
059ec3d9
PH
600
601 /* If some interrupt arrived, just retry. We presume this to be rare,
602 but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
603 select() to exit).
604
605 Aug 2004: Somebody set up a cron job that ran exiwhat every 2 minutes, making
606 the interrupt not at all rare. Since the timeout is typically more than 2
607 minutes, the effect was to block the timeout completely. To prevent this
c528cec4
HSHR
608 happening again, we do an explicit time test and adjust the timeout
609 accordingly */
059ec3d9
PH
610
611 if (rc < 0 && errno == EINTR)
612 {
613 DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
85ff3cf9 614
c528cec4 615 /* Watch out, 'continue' jumps to the condition, not to the loops top */
0a5441fc 616 if ((time_left = timelimit - time(NULL)) > 0) continue;
059ec3d9
PH
617 }
618
059ec3d9
PH
619 if (rc <= 0)
620 {
621 errno = ETIMEDOUT;
4e71661f 622 return FALSE;
059ec3d9
PH
623 }
624
c528cec4
HSHR
625 /* Checking the FD_ISSET is not enough, if we're interrupted, the
626 select_inset may still contain the 'input'. */
059ec3d9 627 }
4bd6107d 628while (rc < 0 || !FD_ISSET(fd, &select_inset));
4e71661f
JH
629return TRUE;
630}
631
632/* The timeout is implemented using select(), and we loop to cover select()
633getting interrupted, and the possibility of select() returning with a positive
634result but no ready descriptor. Is this in fact possible?
635
636Arguments:
74f1a423 637 cctx the connection context (socket fd, possibly TLS context)
4e71661f
JH
638 buffer to read into
639 bufsize the buffer size
0a5441fc 640 timelimit the timeout endpoint, seconds-since-epoch
4e71661f
JH
641
642Returns: > 0 => that much data read
643 <= 0 on error or EOF; errno set - zero for EOF
644*/
645
646int
0a5441fc 647ip_recv(client_conn_ctx * cctx, uschar * buffer, int buffsize, time_t timelimit)
4e71661f
JH
648{
649int rc;
650
0a5441fc 651if (!fd_ready(cctx->sock, timelimit))
4e71661f 652 return -1;
059ec3d9
PH
653
654/* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
655close down of the connection), set errno to zero; otherwise leave it alone. */
656
01603eec 657#ifndef DISABLE_TLS
74f1a423
JH
658if (cctx->tls_ctx) /* client TLS */
659 rc = tls_read(cctx->tls_ctx, buffer, buffsize);
660else if (tls_in.active.sock == cctx->sock) /* server TLS */
661 rc = tls_read(NULL, buffer, buffsize);
059ec3d9
PH
662else
663#endif
74f1a423 664 rc = recv(cctx->sock, buffer, buffsize, 0);
059ec3d9
PH
665
666if (rc > 0) return rc;
667if (rc == 0) errno = 0;
668return -1;
669}
670
671
9e4f5962
PP
672
673
674/*************************************************
13363eba
PP
675* Lookup address family of potential socket *
676*************************************************/
677
678/* Given a file-descriptor, check to see if it's a socket and, if so,
679return the address family; detects IPv4 vs IPv6. If not a socket then
680return -1.
681
682The value 0 is typically AF_UNSPEC, which should not be seen on a connected
683fd. If the return is -1, the errno will be from getsockname(); probably
684ENOTSOCK or ECONNRESET.
685
686Arguments: socket-or-not fd
687Returns: address family or -1
688*/
689
690int
691ip_get_address_family(int fd)
692{
693struct sockaddr_storage ss;
694socklen_t sslen = sizeof(ss);
695
696if (getsockname(fd, (struct sockaddr *) &ss, &sslen) < 0)
697 return -1;
698
699return (int) ss.ss_family;
700}
701
702
703
704
705/*************************************************
9e4f5962
PP
706* Lookup DSCP settings for a socket *
707*************************************************/
708
709struct dscp_name_tableentry {
710 const uschar *name;
711 int value;
712};
713/* Keep both of these tables sorted! */
714static struct dscp_name_tableentry dscp_table[] = {
715#ifdef IPTOS_DSCP_AF11
36a3ae5f
PP
716 { CUS"af11", IPTOS_DSCP_AF11 },
717 { CUS"af12", IPTOS_DSCP_AF12 },
718 { CUS"af13", IPTOS_DSCP_AF13 },
719 { CUS"af21", IPTOS_DSCP_AF21 },
720 { CUS"af22", IPTOS_DSCP_AF22 },
721 { CUS"af23", IPTOS_DSCP_AF23 },
722 { CUS"af31", IPTOS_DSCP_AF31 },
723 { CUS"af32", IPTOS_DSCP_AF32 },
724 { CUS"af33", IPTOS_DSCP_AF33 },
725 { CUS"af41", IPTOS_DSCP_AF41 },
726 { CUS"af42", IPTOS_DSCP_AF42 },
727 { CUS"af43", IPTOS_DSCP_AF43 },
728 { CUS"ef", IPTOS_DSCP_EF },
9e4f5962
PP
729#endif
730#ifdef IPTOS_LOWCOST
36a3ae5f 731 { CUS"lowcost", IPTOS_LOWCOST },
9e4f5962 732#endif
36a3ae5f 733 { CUS"lowdelay", IPTOS_LOWDELAY },
9e4f5962 734#ifdef IPTOS_MINCOST
36a3ae5f 735 { CUS"mincost", IPTOS_MINCOST },
9e4f5962 736#endif
36a3ae5f
PP
737 { CUS"reliability", IPTOS_RELIABILITY },
738 { CUS"throughput", IPTOS_THROUGHPUT }
9e4f5962
PP
739};
740static int dscp_table_size =
741 sizeof(dscp_table) / sizeof(struct dscp_name_tableentry);
742
743/* DSCP values change by protocol family, and so do the options used for
2a1b36b3
PP
744setsockopt(); this utility does all the lookups. It takes an unexpanded
745option string, expands it, strips off affix whitespace, then checks if it's
746a number. If all of what's left is a number, then that's how the option will
747be parsed and success/failure is a range check. If it's not all a number,
748then it must be a supported keyword.
9e4f5962
PP
749
750Arguments:
751 dscp_name a string, so far unvalidated
752 af address_family in use
753 level setsockopt level to use
754 optname setsockopt name to use
755 dscp_value value for dscp_name
756
757Returns: TRUE if okay to setsockopt(), else FALSE
2a1b36b3
PP
758
759*level and *optname may be set even if FALSE is returned
9e4f5962
PP
760*/
761
762BOOL
763dscp_lookup(const uschar *dscp_name, int af,
764 int *level, int *optname, int *dscp_value)
765{
2a1b36b3 766uschar *dscp_lookup, *p;
9e4f5962 767int first, last;
2a1b36b3 768long rawlong;
9e4f5962
PP
769
770if (af == AF_INET)
771 {
772 *level = IPPROTO_IP;
773 *optname = IP_TOS;
774 }
bb7b9411 775#if HAVE_IPV6 && defined(IPV6_TCLASS)
9e4f5962
PP
776else if (af == AF_INET6)
777 {
778 *level = IPPROTO_IPV6;
779 *optname = IPV6_TCLASS;
780 }
b301a50b 781#endif
9e4f5962
PP
782else
783 {
784 DEBUG(D_transport)
785 debug_printf("Unhandled address family %d in dscp_lookup()\n", af);
786 return FALSE;
787 }
788if (!dscp_name)
789 {
790 DEBUG(D_transport)
791 debug_printf("[empty DSCP]\n");
792 return FALSE;
793 }
794dscp_lookup = expand_string(US dscp_name);
795if (dscp_lookup == NULL || *dscp_lookup == '\0')
796 return FALSE;
797
2a1b36b3
PP
798p = dscp_lookup + Ustrlen(dscp_lookup) - 1;
799while (isspace(*p)) *p-- = '\0';
800while (isspace(*dscp_lookup) && dscp_lookup < p) dscp_lookup++;
801if (*dscp_lookup == '\0')
802 return FALSE;
803
804rawlong = Ustrtol(dscp_lookup, &p, 0);
805if (p != dscp_lookup && *p == '\0')
806 {
807 /* We have six bits available, which will end up shifted to fit in 0xFC mask.
808 RFC 2597 defines the values unshifted. */
809 if (rawlong < 0 || rawlong > 0x3F)
810 {
811 DEBUG(D_transport)
812 debug_printf("DSCP value %ld out of range, ignored.\n", rawlong);
813 return FALSE;
814 }
815 *dscp_value = rawlong << 2;
816 return TRUE;
817 }
818
9e4f5962
PP
819first = 0;
820last = dscp_table_size;
821while (last > first)
822 {
823 int middle = (first + last)/2;
824 int c = Ustrcmp(dscp_lookup, dscp_table[middle].name);
825 if (c == 0)
826 {
827 *dscp_value = dscp_table[middle].value;
828 return TRUE;
829 }
830 else if (c > 0)
9e4f5962 831 first = middle + 1;
9e4f5962 832 else
9e4f5962 833 last = middle;
9e4f5962
PP
834 }
835return FALSE;
836}
837
36a3ae5f
PP
838void
839dscp_list_to_stream(FILE *stream)
840{
d7978c0f 841for (int i = 0; i < dscp_table_size; ++i)
36a3ae5f
PP
842 fprintf(stream, "%s\n", dscp_table[i].name);
843}
844
9e4f5962 845
059ec3d9 846/* End of ip.c */
8a512ed5
JH
847/* vi: aw ai sw=2
848*/