src/src/ip.c

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