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