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