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