src/src/ip.c

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