e11aef98580587f6b1a7a094e88fd401eccd12b5
[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         /* seen for with-data, proper TFO opt, with-cookie case */
241     {
242     DEBUG(D_transport|D_v) debug_printf("TFO mode connection attempt, %s data\n",
243       fastopen->len > 0 ? "with"  : "no");
244     tcp_out_fastopen = fastopen->len > 0 ?  2 : 1;
245     }
246   else if (errno == EINPROGRESS)        /* expected if we had no cookie for peer */
247         /* seen for no-data, proper TFO option, both cookie-request and with-cookie cases */
248         /*  apparently no visibility of the diffference at this point */
249         /* seen for with-data, proper TFO opt, cookie-req */
250         /*   with netwk delay, post-conn tcp_info sees unacked 1 for R, 2 for C; code in smtp_out.c */
251         /* ? older Experimental TFO option behaviour ? */
252     {                                   /* queue unsent data */
253     DEBUG(D_transport|D_v) debug_printf("TFO mode sendto, %s data: EINPROGRESS\n",
254       fastopen->len > 0 ? "with"  : "no");
255     if (!fastopen->data)
256       {
257       tcp_out_fastopen = 1;             /* we tried; unknown if useful yet */
258       rc = 0;
259       }
260     else
261       rc = send(sock, fastopen->data, fastopen->len, 0);
262     }
263   else if(errno == EOPNOTSUPP)
264     {
265     DEBUG(D_transport)
266       debug_printf("Tried TCP Fast Open but apparently not enabled by sysctl\n");
267     goto legacy_connect;
268     }
269   }
270 else
271 #endif
272   {
273 legacy_connect:
274   if ((rc = connect(sock, s_ptr, s_len)) >= 0)
275     if (  fastopen && fastopen->data && fastopen->len
276        && send(sock, fastopen->data, fastopen->len, 0) < 0)
277         rc = -1;
278   }
279
280 save_errno = errno;
281 alarm(0);
282
283 /* There is a testing facility for simulating a connection timeout, as I
284 can't think of any other way of doing this. It converts a connection refused
285 into a timeout if the timeout is set to 999999. */
286
287 if (running_in_test_harness  && save_errno == ECONNREFUSED && timeout == 999999)
288   {
289   rc = -1;
290   save_errno = EINTR;
291   sigalrm_seen = TRUE;
292   }
293
294 /* Success */
295
296 if (rc >= 0)
297   return 0;
298
299 /* A failure whose error code is "Interrupted system call" is in fact
300 an externally applied timeout if the signal handler has been run. */
301
302 errno = save_errno == EINTR && sigalrm_seen ? ETIMEDOUT : save_errno;
303 return -1;
304 }
305
306
307
308 /*************************************************
309 *    Create connected socket to remote host      *
310 *************************************************/
311
312 /* Create a socket and connect to host (name or number, ipv6 ok)
313    at one of port-range.
314
315 Arguments:
316   type          SOCK_DGRAM or SOCK_STREAM
317   af            AF_INET6 or AF_INET for the socket type
318   address       the remote address, in text form
319   portlo,porthi the remote port range
320   timeout       a timeout
321   connhost      if not NULL, host_item to be filled in with connection details
322   errstr        pointer for allocated string on error
323   fastopen      with SOCK_STREAM, if non-null, request TCP Fast Open.
324                 Additionally, optional early-data to send
325
326 Return:
327   socket fd, or -1 on failure (having allocated an error string)
328 */
329 int
330 ip_connectedsocket(int type, const uschar * hostname, int portlo, int porthi,
331       int timeout, host_item * connhost, uschar ** errstr, const blob * fastopen)
332 {
333 int namelen, port;
334 host_item shost;
335 host_item *h;
336 int af = 0, fd, fd4 = -1, fd6 = -1;
337
338 shost.next = NULL;
339 shost.address = NULL;
340 shost.port = portlo;
341 shost.mx = -1;
342
343 namelen = Ustrlen(hostname);
344
345 /* Anything enclosed in [] must be an IP address. */
346
347 if (hostname[0] == '[' &&
348     hostname[namelen - 1] == ']')
349   {
350   uschar * host = string_copyn(hostname+1, namelen-2);
351   if (string_is_ip_address(host, NULL) == 0)
352     {
353     *errstr = string_sprintf("malformed IP address \"%s\"", hostname);
354     return -1;
355     }
356   shost.name = shost.address = host;
357   }
358
359 /* Otherwise check for an unadorned IP address */
360
361 else if (string_is_ip_address(hostname, NULL) != 0)
362   shost.name = shost.address = string_copyn(hostname, namelen);
363
364 /* Otherwise lookup IP address(es) from the name */
365
366 else
367   {
368   shost.name = string_copyn(hostname, namelen);
369   if (host_find_byname(&shost, NULL, HOST_FIND_QUALIFY_SINGLE,
370       NULL, FALSE) != HOST_FOUND)
371     {
372     *errstr = string_sprintf("no IP address found for host %s", shost.name);
373     return -1;
374     }
375   }
376
377 /* Try to connect to the server - test each IP till one works */
378
379 for (h = &shost; h; h = h->next)
380   {
381   fd = Ustrchr(h->address, ':') != 0
382     ? fd6 < 0 ? (fd6 = ip_socket(type, af = AF_INET6)) : fd6
383     : fd4 < 0 ? (fd4 = ip_socket(type, af = AF_INET )) : fd4;
384
385   if (fd < 0)
386     {
387     *errstr = string_sprintf("failed to create socket: %s", strerror(errno));
388     goto bad;
389     }
390
391   for(port = portlo; port <= porthi; port++)
392     if (ip_connect(fd, af, h->address, port, timeout, fastopen) == 0)
393       {
394       if (fd != fd6) close(fd6);
395       if (fd != fd4) close(fd4);
396       if (connhost)
397         {
398         h->port = port;
399         *connhost = *h;
400         connhost->next = NULL;
401         }
402       return fd;
403       }
404   }
405
406 *errstr = string_sprintf("failed to connect to any address for %s: %s",
407   hostname, strerror(errno));
408
409 bad:
410   close(fd4); close(fd6); return -1;
411 }
412
413
414 /*XXX TFO? */
415 int
416 ip_tcpsocket(const uschar * hostport, uschar ** errstr, int tmo)
417 {
418 int scan;
419 uschar hostname[256];
420 unsigned int portlow, porthigh;
421
422 /* extract host and port part */
423 scan = sscanf(CS hostport, "%255s %u-%u", hostname, &portlow, &porthigh);
424 if (scan != 3)
425   {
426   if (scan != 2)
427     {
428     *errstr = string_sprintf("invalid socket '%s'", hostport);
429     return -1;
430     }
431   porthigh = portlow;
432   }
433
434 return ip_connectedsocket(SOCK_STREAM, hostname, portlow, porthigh,
435                           tmo, NULL, errstr, NULL);
436 }
437
438 int
439 ip_unixsocket(const uschar * path, uschar ** errstr)
440 {
441 int sock;
442 struct sockaddr_un server;
443
444 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
445   {
446   *errstr = US"can't open UNIX socket.";
447   return -1;
448   }
449
450 callout_address = string_copy(path);
451 server.sun_family = AF_UNIX;
452 Ustrncpy(server.sun_path, path, sizeof(server.sun_path)-1);
453 server.sun_path[sizeof(server.sun_path)-1] = '\0';
454 if (connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0)
455   {
456   int err = errno;
457   (void)close(sock);
458   *errstr = string_sprintf("unable to connect to UNIX socket (%s): %s",
459                 path, strerror(err));
460   return -1;
461   }
462 return sock;
463 }
464
465 int
466 ip_streamsocket(const uschar * spec, uschar ** errstr, int tmo)
467 {
468 return *spec == '/'
469   ? ip_unixsocket(spec, errstr) : ip_tcpsocket(spec, errstr, tmo);
470 }
471
472 /*************************************************
473 *         Set keepalive on a socket              *
474 *************************************************/
475
476 /* Can be called for both incoming and outgoing sockets.
477
478 Arguments:
479   sock       the socket
480   address    the remote host address, for failure logging
481   torf       true for outgoing connection, false for incoming
482
483 Returns:     nothing
484 */
485
486 void
487 ip_keepalive(int sock, const uschar *address, BOOL torf)
488 {
489 int fodder = 1;
490 if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
491     US (&fodder), sizeof(fodder)) != 0)
492   log_write(0, LOG_MAIN, "setsockopt(SO_KEEPALIVE) on connection %s %s "
493     "failed: %s", torf? "to":"from", address, strerror(errno));
494 }
495
496
497
498 /*************************************************
499 *         Receive from a socket with timeout     *
500 *************************************************/
501
502 /*
503 Arguments:
504   fd          the file descriptor
505   timeout     the timeout, seconds
506 Returns:      TRUE => ready for i/o
507               FALSE => timed out, or other error
508 */
509 BOOL
510 fd_ready(int fd, int timeout)
511 {
512 fd_set select_inset;
513 time_t start_recv = time(NULL);
514 int time_left = timeout;
515 int rc;
516
517 if (time_left <= 0)
518   {
519   errno = ETIMEDOUT;
520   return FALSE;
521   }
522 /* Wait until the socket is ready */
523
524 do
525   {
526   struct timeval tv = { .tv_sec = time_left, .tv_usec = 0 };
527   FD_ZERO (&select_inset);
528   FD_SET (fd, &select_inset);
529
530   /*DEBUG(D_transport) debug_printf("waiting for data on fd\n");*/
531   rc = select(fd + 1, (SELECT_ARG2_TYPE *)&select_inset, NULL, NULL, &tv);
532
533   /* If some interrupt arrived, just retry. We presume this to be rare,
534   but it can happen (e.g. the SIGUSR1 signal sent by exiwhat causes
535   select() to exit).
536
537   Aug 2004: Somebody set up a cron job that ran exiwhat every 2 minutes, making
538   the interrupt not at all rare. Since the timeout is typically more than 2
539   minutes, the effect was to block the timeout completely. To prevent this
540   happening again, we do an explicit time test and adjust the timeout
541   accordingly */
542
543   if (rc < 0 && errno == EINTR)
544     {
545     DEBUG(D_transport) debug_printf("EINTR while waiting for socket data\n");
546
547     /* Watch out, 'continue' jumps to the condition, not to the loops top */
548     time_left = timeout - (time(NULL) - start_recv);
549     if (time_left > 0) continue;
550     }
551
552   if (rc <= 0)
553     {
554     errno = ETIMEDOUT;
555     return FALSE;
556     }
557
558   /* Checking the FD_ISSET is not enough, if we're interrupted, the
559   select_inset may still contain the 'input'. */
560   }
561 while (rc < 0 || !FD_ISSET(fd, &select_inset));
562 return TRUE;
563 }
564
565 /* The timeout is implemented using select(), and we loop to cover select()
566 getting interrupted, and the possibility of select() returning with a positive
567 result but no ready descriptor. Is this in fact possible?
568
569 Arguments:
570   sock        the socket
571   buffer      to read into
572   bufsize     the buffer size
573   timeout     the timeout
574
575 Returns:      > 0 => that much data read
576               <= 0 on error or EOF; errno set - zero for EOF
577 */
578
579 int
580 ip_recv(int sock, uschar *buffer, int buffsize, int timeout)
581 {
582 int rc;
583
584 if (!fd_ready(sock, timeout))
585   return -1;
586
587 /* The socket is ready, read from it (via TLS if it's active). On EOF (i.e.
588 close down of the connection), set errno to zero; otherwise leave it alone. */
589
590 #ifdef SUPPORT_TLS
591 if (tls_out.active == sock)
592   rc = tls_read(FALSE, buffer, buffsize);
593 else if (tls_in.active == sock)
594   rc = tls_read(TRUE, buffer, buffsize);
595 else
596 #endif
597   rc = recv(sock, buffer, buffsize, 0);
598
599 if (rc > 0) return rc;
600 if (rc == 0) errno = 0;
601 return -1;
602 }
603
604
605
606
607 /*************************************************
608 *    Lookup address family of potential socket   *
609 *************************************************/
610
611 /* Given a file-descriptor, check to see if it's a socket and, if so,
612 return the address family; detects IPv4 vs IPv6.  If not a socket then
613 return -1.
614
615 The value 0 is typically AF_UNSPEC, which should not be seen on a connected
616 fd.  If the return is -1, the errno will be from getsockname(); probably
617 ENOTSOCK or ECONNRESET.
618
619 Arguments:     socket-or-not fd
620 Returns:       address family or -1
621 */
622
623 int
624 ip_get_address_family(int fd)
625 {
626 struct sockaddr_storage ss;
627 socklen_t sslen = sizeof(ss);
628
629 if (getsockname(fd, (struct sockaddr *) &ss, &sslen) < 0)
630   return -1;
631
632 return (int) ss.ss_family;
633 }
634
635
636
637
638 /*************************************************
639 *       Lookup DSCP settings for a socket        *
640 *************************************************/
641
642 struct dscp_name_tableentry {
643   const uschar *name;
644   int value;
645 };
646 /* Keep both of these tables sorted! */
647 static struct dscp_name_tableentry dscp_table[] = {
648 #ifdef IPTOS_DSCP_AF11
649     { CUS"af11", IPTOS_DSCP_AF11 },
650     { CUS"af12", IPTOS_DSCP_AF12 },
651     { CUS"af13", IPTOS_DSCP_AF13 },
652     { CUS"af21", IPTOS_DSCP_AF21 },
653     { CUS"af22", IPTOS_DSCP_AF22 },
654     { CUS"af23", IPTOS_DSCP_AF23 },
655     { CUS"af31", IPTOS_DSCP_AF31 },
656     { CUS"af32", IPTOS_DSCP_AF32 },
657     { CUS"af33", IPTOS_DSCP_AF33 },
658     { CUS"af41", IPTOS_DSCP_AF41 },
659     { CUS"af42", IPTOS_DSCP_AF42 },
660     { CUS"af43", IPTOS_DSCP_AF43 },
661     { CUS"ef", IPTOS_DSCP_EF },
662 #endif
663 #ifdef IPTOS_LOWCOST
664     { CUS"lowcost", IPTOS_LOWCOST },
665 #endif
666     { CUS"lowdelay", IPTOS_LOWDELAY },
667 #ifdef IPTOS_MINCOST
668     { CUS"mincost", IPTOS_MINCOST },
669 #endif
670     { CUS"reliability", IPTOS_RELIABILITY },
671     { CUS"throughput", IPTOS_THROUGHPUT }
672 };
673 static int dscp_table_size =
674   sizeof(dscp_table) / sizeof(struct dscp_name_tableentry);
675
676 /* DSCP values change by protocol family, and so do the options used for
677 setsockopt(); this utility does all the lookups.  It takes an unexpanded
678 option string, expands it, strips off affix whitespace, then checks if it's
679 a number.  If all of what's left is a number, then that's how the option will
680 be parsed and success/failure is a range check.  If it's not all a number,
681 then it must be a supported keyword.
682
683 Arguments:
684   dscp_name   a string, so far unvalidated
685   af          address_family in use
686   level       setsockopt level to use
687   optname     setsockopt name to use
688   dscp_value  value for dscp_name
689
690 Returns: TRUE if okay to setsockopt(), else FALSE
691
692 *level and *optname may be set even if FALSE is returned
693 */
694
695 BOOL
696 dscp_lookup(const uschar *dscp_name, int af,
697     int *level, int *optname, int *dscp_value)
698 {
699 uschar *dscp_lookup, *p;
700 int first, last;
701 long rawlong;
702
703 if (af == AF_INET)
704   {
705   *level = IPPROTO_IP;
706   *optname = IP_TOS;
707   }
708 #if HAVE_IPV6 && defined(IPV6_TCLASS)
709 else if (af == AF_INET6)
710   {
711   *level = IPPROTO_IPV6;
712   *optname = IPV6_TCLASS;
713   }
714 #endif
715 else
716   {
717   DEBUG(D_transport)
718     debug_printf("Unhandled address family %d in dscp_lookup()\n", af);
719   return FALSE;
720   }
721 if (!dscp_name)
722   {
723   DEBUG(D_transport)
724     debug_printf("[empty DSCP]\n");
725   return FALSE;
726   }
727 dscp_lookup = expand_string(US dscp_name);
728 if (dscp_lookup == NULL || *dscp_lookup == '\0')
729   return FALSE;
730
731 p = dscp_lookup + Ustrlen(dscp_lookup) - 1;
732 while (isspace(*p)) *p-- = '\0';
733 while (isspace(*dscp_lookup) && dscp_lookup < p) dscp_lookup++;
734 if (*dscp_lookup == '\0')
735   return FALSE;
736
737 rawlong = Ustrtol(dscp_lookup, &p, 0);
738 if (p != dscp_lookup && *p == '\0')
739   {
740   /* We have six bits available, which will end up shifted to fit in 0xFC mask.
741   RFC 2597 defines the values unshifted. */
742   if (rawlong < 0 || rawlong > 0x3F)
743     {
744     DEBUG(D_transport)
745       debug_printf("DSCP value %ld out of range, ignored.\n", rawlong);
746     return FALSE;
747     }
748   *dscp_value = rawlong << 2;
749   return TRUE;
750   }
751
752 first = 0;
753 last = dscp_table_size;
754 while (last > first)
755   {
756   int middle = (first + last)/2;
757   int c = Ustrcmp(dscp_lookup, dscp_table[middle].name);
758   if (c == 0)
759     {
760     *dscp_value = dscp_table[middle].value;
761     return TRUE;
762     }
763   else if (c > 0)
764     first = middle + 1;
765   else
766     last = middle;
767   }
768 return FALSE;
769 }
770
771 void
772 dscp_list_to_stream(FILE *stream)
773 {
774 int i;
775 for (i=0; i < dscp_table_size; ++i)
776   fprintf(stream, "%s\n", dscp_table[i].name);
777 }
778
779
780 /* End of ip.c */
781 /* vi: aw ai sw=2
782 */