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