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