src/src/ip.c

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