src/src/ip.c

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