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