lib/socket-util.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "socket-util.h"
  19 #include <arpa/inet.h>
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <net/if.h>
  24 #include <netdb.h>
  25 #include <poll.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/resource.h>
  31 #include <sys/socket.h>
  32 #include <sys/stat.h>
  33 #include <sys/uio.h>
  34 #include <sys/un.h>
  35 #include <unistd.h>
  36 #include "dynamic-string.h"
  37 #include "fatal-signal.h"
  38 #include "packets.h"
  39 #include "poll-loop.h"
  40 #include "util.h"
  41 #include "vlog.h"
  42 #if AF_PACKET && LINUX_DATAPATH
  43 #include <linux/if_packet.h>
  44 #endif
  45 #ifdef HAVE_NETLINK
  46 #include "netlink-protocol.h"
  47 #include "netlink-socket.h"
  48 #endif
  49
  50 VLOG_DEFINE_THIS_MODULE(socket_util);
  51
  52 /* #ifdefs make it a pain to maintain code: you have to try to build both ways.
  53  * Thus, this file compiles all of the code regardless of the target, by
  54  * writing "if (LINUX_DATAPATH)" instead of "#ifdef __linux__". */
  55 #ifndef LINUX_DATAPATH
  56 #define LINUX_DATAPATH 0
  57 #endif
  58
  59 #ifndef O_DIRECTORY
  60 #define O_DIRECTORY 0
  61 #endif
  62
  63 static int getsockopt_int(int fd, int level, int option, const char *optname,
  64                           int *valuep);
  65
  66 /* Sets 'fd' to non-blocking mode.  Returns 0 if successful, otherwise a
  67  * positive errno value. */
  68 int
  69 set_nonblocking(int fd)
  70 {
  71     int flags = fcntl(fd, F_GETFL, 0);
  72     if (flags != -1) {
  73         if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1) {
  74             return 0;
  75         } else {
  76             VLOG_ERR("fcntl(F_SETFL) failed: %s", strerror(errno));
  77             return errno;
  78         }
  79     } else {
  80         VLOG_ERR("fcntl(F_GETFL) failed: %s", strerror(errno));
  81         return errno;
  82     }
  83 }
  84
  85 void
  86 xset_nonblocking(int fd)
  87 {
  88     if (set_nonblocking(fd)) {
  89         exit(EXIT_FAILURE);
  90     }
  91 }
  92
  93 int
  94 set_dscp(int fd, uint8_t dscp)
  95 {
  96     int val;
  97
  98     if (dscp > 63) {
  99         return EINVAL;
 100     }
 101
 102     val = dscp << 2;
 103     if (setsockopt(fd, IPPROTO_IP, IP_TOS, &val, sizeof val)) {
 104         return errno;
 105     }
 106
 107     return 0;
 108 }
 109
 110 static bool
 111 rlim_is_finite(rlim_t limit)
 112 {
 113     if (limit == RLIM_INFINITY) {
 114         return false;
 115     }
 116
 117 #ifdef RLIM_SAVED_CUR           /* FreeBSD 8.0 lacks RLIM_SAVED_CUR. */
 118     if (limit == RLIM_SAVED_CUR) {
 119         return false;
 120     }
 121 #endif
 122
 123 #ifdef RLIM_SAVED_MAX           /* FreeBSD 8.0 lacks RLIM_SAVED_MAX. */
 124     if (limit == RLIM_SAVED_MAX) {
 125         return false;
 126     }
 127 #endif
 128
 129     return true;
 130 }
 131
 132 /* Returns the maximum valid FD value, plus 1. */
 133 int
 134 get_max_fds(void)
 135 {
 136     static int max_fds = -1;
 137     if (max_fds < 0) {
 138         struct rlimit r;
 139         if (!getrlimit(RLIMIT_NOFILE, &r) && rlim_is_finite(r.rlim_cur)) {
 140             max_fds = r.rlim_cur;
 141         } else {
 142             VLOG_WARN("failed to obtain fd limit, defaulting to 1024");
 143             max_fds = 1024;
 144         }
 145     }
 146     return max_fds;
 147 }
 148
 149 /* Translates 'host_name', which must be a string representation of an IP
 150  * address, into a numeric IP address in '*addr'.  Returns 0 if successful,
 151  * otherwise a positive errno value. */
 152 int
 153 lookup_ip(const char *host_name, struct in_addr *addr)
 154 {
 155     if (!inet_aton(host_name, addr)) {
 156         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 157         VLOG_ERR_RL(&rl, "\"%s\" is not a valid IP address", host_name);
 158         return ENOENT;
 159     }
 160     return 0;
 161 }
 162
 163 /* Translates 'host_name', which must be a string representation of an IPv6
 164  * address, into a numeric IPv6 address in '*addr'.  Returns 0 if successful,
 165  * otherwise a positive errno value. */
 166 int
 167 lookup_ipv6(const char *host_name, struct in6_addr *addr)
 168 {
 169     if (inet_pton(AF_INET6, host_name, addr) != 1) {
 170         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 171         VLOG_ERR_RL(&rl, "\"%s\" is not a valid IPv6 address", host_name);
 172         return ENOENT;
 173     }
 174     return 0;
 175 }
 176
 177 /* Translates 'host_name', which must be a host name or a string representation
 178  * of an IP address, into a numeric IP address in '*addr'.  Returns 0 if
 179  * successful, otherwise a positive errno value.
 180  *
 181  * Most Open vSwitch code should not use this because it causes deadlocks:
 182  * gethostbyname() sends out a DNS request but that starts a new flow for which
 183  * OVS must set up a flow, but it can't because it's waiting for a DNS reply.
 184  * The synchronous lookup also delays other activity.  (Of course we can solve
 185  * this but it doesn't seem worthwhile quite yet.)  */
 186 int
 187 lookup_hostname(const char *host_name, struct in_addr *addr)
 188 {
 189     struct hostent *h;
 190
 191     if (inet_aton(host_name, addr)) {
 192         return 0;
 193     }
 194
 195     h = gethostbyname(host_name);
 196     if (h) {
 197         *addr = *(struct in_addr *) h->h_addr;
 198         return 0;
 199     }
 200
 201     return (h_errno == HOST_NOT_FOUND ? ENOENT
 202             : h_errno == TRY_AGAIN ? EAGAIN
 203             : h_errno == NO_RECOVERY ? EIO
 204             : h_errno == NO_ADDRESS ? ENXIO
 205             : EINVAL);
 206 }
 207
 208 int
 209 check_connection_completion(int fd)
 210 {
 211     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
 212     struct pollfd pfd;
 213     int retval;
 214
 215     pfd.fd = fd;
 216     pfd.events = POLLOUT;
 217     do {
 218         retval = poll(&pfd, 1, 0);
 219     } while (retval < 0 && errno == EINTR);
 220     if (retval == 1) {
 221         if (pfd.revents & POLLERR) {
 222             ssize_t n = send(fd, "", 1, MSG_DONTWAIT);
 223             if (n < 0) {
 224                 return errno;
 225             } else {
 226                 VLOG_ERR_RL(&rl, "poll return POLLERR but send succeeded");
 227                 return EPROTO;
 228             }
 229         }
 230         return 0;
 231     } else if (retval < 0) {
 232         VLOG_ERR_RL(&rl, "poll: %s", strerror(errno));
 233         return errno;
 234     } else {
 235         return EAGAIN;
 236     }
 237 }
 238
 239 /* Drain all the data currently in the receive queue of a datagram socket (and
 240  * possibly additional data).  There is no way to know how many packets are in
 241  * the receive queue, but we do know that the total number of bytes queued does
 242  * not exceed the receive buffer size, so we pull packets until none are left
 243  * or we've read that many bytes. */
 244 int
 245 drain_rcvbuf(int fd)
 246 {
 247     int rcvbuf;
 248
 249     rcvbuf = get_socket_rcvbuf(fd);
 250     if (rcvbuf < 0) {
 251         return -rcvbuf;
 252     }
 253
 254     while (rcvbuf > 0) {
 255         /* In Linux, specifying MSG_TRUNC in the flags argument causes the
 256          * datagram length to be returned, even if that is longer than the
 257          * buffer provided.  Thus, we can use a 1-byte buffer to discard the
 258          * incoming datagram and still be able to account how many bytes were
 259          * removed from the receive buffer.
 260          *
 261          * On other Unix-like OSes, MSG_TRUNC has no effect in the flags
 262          * argument. */
 263         char buffer[LINUX_DATAPATH ? 1 : 2048];
 264         ssize_t n_bytes = recv(fd, buffer, sizeof buffer,
 265                                MSG_TRUNC | MSG_DONTWAIT);
 266         if (n_bytes <= 0 || n_bytes >= rcvbuf) {
 267             break;
 268         }
 269         rcvbuf -= n_bytes;
 270     }
 271     return 0;
 272 }
 273
 274 /* Returns the size of socket 'sock''s receive buffer (SO_RCVBUF), or a
 275  * negative errno value if an error occurs. */
 276 int
 277 get_socket_rcvbuf(int sock)
 278 {
 279     int rcvbuf;
 280     int error;
 281
 282     error = getsockopt_int(sock, SOL_SOCKET, SO_RCVBUF, "SO_RCVBUF", &rcvbuf);
 283     return error ? -error : rcvbuf;
 284 }
 285
 286 /* Reads and discards up to 'n' datagrams from 'fd', stopping as soon as no
 287  * more data can be immediately read.  ('fd' should therefore be in
 288  * non-blocking mode.)*/
 289 void
 290 drain_fd(int fd, size_t n_packets)
 291 {
 292     for (; n_packets > 0; n_packets--) {
 293         /* 'buffer' only needs to be 1 byte long in most circumstances.  This
 294          * size is defensive against the possibility that we someday want to
 295          * use a Linux tap device without TUN_NO_PI, in which case a buffer
 296          * smaller than sizeof(struct tun_pi) will give EINVAL on read. */
 297         char buffer[128];
 298         if (read(fd, buffer, sizeof buffer) <= 0) {
 299             break;
 300         }
 301     }
 302 }
 303
 304 /* Stores in '*un' a sockaddr_un that refers to file 'name'.  Stores in
 305  * '*un_len' the size of the sockaddr_un. */
 306 static void
 307 make_sockaddr_un__(const char *name, struct sockaddr_un *un, socklen_t *un_len)
 308 {
 309     un->sun_family = AF_UNIX;
 310     ovs_strzcpy(un->sun_path, name, sizeof un->sun_path);
 311     *un_len = (offsetof(struct sockaddr_un, sun_path)
 312                 + strlen (un->sun_path) + 1);
 313 }
 314
 315 /* Stores in '*un' a sockaddr_un that refers to file 'name'.  Stores in
 316  * '*un_len' the size of the sockaddr_un.
 317  *
 318  * Returns 0 on success, otherwise a positive errno value.  On success,
 319  * '*dirfdp' is either -1 or a nonnegative file descriptor that the caller
 320  * should close after using '*un' to bind or connect.  On failure, '*dirfdp' is
 321  * -1. */
 322 static int
 323 make_sockaddr_un(const char *name, struct sockaddr_un *un, socklen_t *un_len,
 324                  int *dirfdp)
 325 {
 326     enum { MAX_UN_LEN = sizeof un->sun_path - 1 };
 327
 328     *dirfdp = -1;
 329     if (strlen(name) > MAX_UN_LEN) {
 330         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
 331
 332         if (LINUX_DATAPATH) {
 333             /* 'name' is too long to fit in a sockaddr_un, but we have a
 334              * workaround for that on Linux: shorten it by opening a file
 335              * descriptor for the directory part of the name and indirecting
 336              * through /proc/self/fd/<dirfd>/<basename>. */
 337             char *dir, *base;
 338             char *short_name;
 339             int dirfd;
 340
 341             dir = dir_name(name);
 342             base = base_name(name);
 343
 344             dirfd = open(dir, O_DIRECTORY | O_RDONLY);
 345             if (dirfd < 0) {
 346                 free(base);
 347                 free(dir);
 348                 return errno;
 349             }
 350
 351             short_name = xasprintf("/proc/self/fd/%d/%s", dirfd, base);
 352             free(dir);
 353             free(base);
 354
 355             if (strlen(short_name) <= MAX_UN_LEN) {
 356                 make_sockaddr_un__(short_name, un, un_len);
 357                 free(short_name);
 358                 *dirfdp = dirfd;
 359                 return 0;
 360             }
 361             free(short_name);
 362             close(dirfd);
 363
 364             VLOG_WARN_RL(&rl, "Unix socket name %s is longer than maximum "
 365                          "%d bytes (even shortened)", name, MAX_UN_LEN);
 366         } else {
 367             /* 'name' is too long and we have no workaround. */
 368             VLOG_WARN_RL(&rl, "Unix socket name %s is longer than maximum "
 369                          "%d bytes", name, MAX_UN_LEN);
 370         }
 371
 372         return ENAMETOOLONG;
 373     } else {
 374         make_sockaddr_un__(name, un, un_len);
 375         return 0;
 376     }
 377 }
 378
 379 /* Binds Unix domain socket 'fd' to a file with permissions 0700. */
 380 static int
 381 bind_unix_socket(int fd, struct sockaddr *sun, socklen_t sun_len)
 382 {
 383     /* According to _Unix Network Programming_, umask should affect bind(). */
 384     mode_t old_umask = umask(0077);
 385     int error = bind(fd, sun, sun_len) ? errno : 0;
 386     umask(old_umask);
 387     return error;
 388 }
 389
 390 /* Creates a Unix domain socket in the given 'style' (either SOCK_DGRAM or
 391  * SOCK_STREAM) that is bound to '*bind_path' (if 'bind_path' is non-null) and
 392  * connected to '*connect_path' (if 'connect_path' is non-null).  If 'nonblock'
 393  * is true, the socket is made non-blocking.
 394  *
 395  * Returns the socket's fd if successful, otherwise a negative errno value. */
 396 int
 397 make_unix_socket(int style, bool nonblock,
 398                  const char *bind_path, const char *connect_path)
 399 {
 400     int error;
 401     int fd;
 402
 403     fd = socket(PF_UNIX, style, 0);
 404     if (fd < 0) {
 405         return -errno;
 406     }
 407
 408     /* Set nonblocking mode right away, if we want it.  This prevents blocking
 409      * in connect(), if connect_path != NULL.  (In turn, that's a corner case:
 410      * it will only happen if style is SOCK_STREAM or SOCK_SEQPACKET, and only
 411      * if a backlog of un-accepted connections has built up in the kernel.)  */
 412     if (nonblock) {
 413         int flags = fcntl(fd, F_GETFL, 0);
 414         if (flags == -1) {
 415             error = errno;
 416             goto error;
 417         }
 418         if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
 419             error = errno;
 420             goto error;
 421         }
 422     }
 423
 424     if (bind_path) {
 425         struct sockaddr_un un;
 426         socklen_t un_len;
 427         int dirfd;
 428
 429         if (unlink(bind_path) && errno != ENOENT) {
 430             VLOG_WARN("unlinking \"%s\": %s\n", bind_path, strerror(errno));
 431         }
 432         fatal_signal_add_file_to_unlink(bind_path);
 433
 434         error = make_sockaddr_un(bind_path, &un, &un_len, &dirfd);
 435         if (!error) {
 436             error = bind_unix_socket(fd, (struct sockaddr *) &un, un_len);
 437         }
 438         if (dirfd >= 0) {
 439             close(dirfd);
 440         }
 441         if (error) {
 442             goto error;
 443         }
 444     }
 445
 446     if (connect_path) {
 447         struct sockaddr_un un;
 448         socklen_t un_len;
 449         int dirfd;
 450
 451         error = make_sockaddr_un(connect_path, &un, &un_len, &dirfd);
 452         if (!error
 453             && connect(fd, (struct sockaddr*) &un, un_len)
 454             && errno != EINPROGRESS) {
 455             error = errno;
 456         }
 457         if (dirfd >= 0) {
 458             close(dirfd);
 459         }
 460         if (error) {
 461             goto error;
 462         }
 463     }
 464
 465     return fd;
 466
 467 error:
 468     if (error == EAGAIN) {
 469         error = EPROTO;
 470     }
 471     if (bind_path) {
 472         fatal_signal_unlink_file_now(bind_path);
 473     }
 474     close(fd);
 475     return -error;
 476 }
 477
 478 int
 479 get_unix_name_len(socklen_t sun_len)
 480 {
 481     return (sun_len >= offsetof(struct sockaddr_un, sun_path)
 482             ? sun_len - offsetof(struct sockaddr_un, sun_path)
 483             : 0);
 484 }
 485
 486 ovs_be32
 487 guess_netmask(ovs_be32 ip_)
 488 {
 489     uint32_t ip = ntohl(ip_);
 490     return ((ip >> 31) == 0 ? htonl(0xff000000)   /* Class A */
 491             : (ip >> 30) == 2 ? htonl(0xffff0000) /* Class B */
 492             : (ip >> 29) == 6 ? htonl(0xffffff00) /* Class C */
 493             : htonl(0));                          /* ??? */
 494 }
 495
 496 /* Parses 'target', which should be a string in the format "<host>[:<port>]".
 497  * <host> is required.  If 'default_port' is nonzero then <port> is optional
 498  * and defaults to 'default_port'.
 499  *
 500  * On success, returns true and stores the parsed remote address into '*sinp'.
 501  * On failure, logs an error, stores zeros into '*sinp', and returns false. */
 502 bool
 503 inet_parse_active(const char *target_, uint16_t default_port,
 504                   struct sockaddr_in *sinp)
 505 {
 506     char *target = xstrdup(target_);
 507     char *save_ptr = NULL;
 508     const char *host_name;
 509     const char *port_string;
 510     bool ok = false;
 511
 512     /* Defaults. */
 513     sinp->sin_family = AF_INET;
 514     sinp->sin_port = htons(default_port);
 515
 516     /* Tokenize. */
 517     host_name = strtok_r(target, ":", &save_ptr);
 518     port_string = strtok_r(NULL, ":", &save_ptr);
 519     if (!host_name) {
 520         VLOG_ERR("%s: bad peer name format", target_);
 521         goto exit;
 522     }
 523
 524     /* Look up IP, port. */
 525     if (lookup_ip(host_name, &sinp->sin_addr)) {
 526         goto exit;
 527     }
 528     if (port_string && atoi(port_string)) {
 529         sinp->sin_port = htons(atoi(port_string));
 530     } else if (!default_port) {
 531         VLOG_ERR("%s: port number must be specified", target_);
 532         goto exit;
 533     }
 534
 535     ok = true;
 536
 537 exit:
 538     if (!ok) {
 539         memset(sinp, 0, sizeof *sinp);
 540     }
 541     free(target);
 542     return ok;
 543 }
 544
 545 /* Opens a non-blocking IPv4 socket of the specified 'style' and connects to
 546  * 'target', which should be a string in the format "<host>[:<port>]".  <host>
 547  * is required.  If 'default_port' is nonzero then <port> is optional and
 548  * defaults to 'default_port'.
 549  *
 550  * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
 551  *
 552  * On success, returns 0 (indicating connection complete) or EAGAIN (indicating
 553  * connection in progress), in which case the new file descriptor is stored
 554  * into '*fdp'.  On failure, returns a positive errno value other than EAGAIN
 555  * and stores -1 into '*fdp'.
 556  *
 557  * If 'sinp' is non-null, then on success the target address is stored into
 558  * '*sinp'.
 559  *
 560  * 'dscp' becomes the DSCP bits in the IP headers for the new connection.  It
 561  * should be in the range [0, 63] and will automatically be shifted to the
 562  * appropriately place in the IP tos field. */
 563 int
 564 inet_open_active(int style, const char *target, uint16_t default_port,
 565                  struct sockaddr_in *sinp, int *fdp, uint8_t dscp)
 566 {
 567     struct sockaddr_in sin;
 568     int fd = -1;
 569     int error;
 570
 571     /* Parse. */
 572     if (!inet_parse_active(target, default_port, &sin)) {
 573         error = EAFNOSUPPORT;
 574         goto exit;
 575     }
 576
 577     /* Create non-blocking socket. */
 578     fd = socket(AF_INET, style, 0);
 579     if (fd < 0) {
 580         VLOG_ERR("%s: socket: %s", target, strerror(errno));
 581         error = errno;
 582         goto exit;
 583     }
 584     error = set_nonblocking(fd);
 585     if (error) {
 586         goto exit;
 587     }
 588
 589     /* The dscp bits must be configured before connect() to ensure that the TOS
 590      * field is set during the connection establishment.  If set after
 591      * connect(), the handshake SYN frames will be sent with a TOS of 0. */
 592     error = set_dscp(fd, dscp);
 593     if (error) {
 594         VLOG_ERR("%s: socket: %s", target, strerror(error));
 595         goto exit;
 596     }
 597
 598     /* Connect. */
 599     error = connect(fd, (struct sockaddr *) &sin, sizeof sin) == 0 ? 0 : errno;
 600     if (error == EINPROGRESS) {
 601         error = EAGAIN;
 602     }
 603
 604 exit:
 605     if (!error || error == EAGAIN) {
 606         if (sinp) {
 607             *sinp = sin;
 608         }
 609     } else if (fd >= 0) {
 610         close(fd);
 611         fd = -1;
 612     }
 613     *fdp = fd;
 614     return error;
 615 }
 616
 617 /* Parses 'target', which should be a string in the format "[<port>][:<ip>]":
 618  *
 619  *      - If 'default_port' is -1, then <port> is required.  Otherwise, if
 620  *        <port> is omitted, then 'default_port' is used instead.
 621  *
 622  *      - If <port> (or 'default_port', if used) is 0, then no port is bound
 623  *        and the TCP/IP stack will select a port.
 624  *
 625  *      - If <ip> is omitted then the IP address is wildcarded.
 626  *
 627  * If successful, stores the address into '*sinp' and returns true; otherwise
 628  * zeros '*sinp' and returns false. */
 629 bool
 630 inet_parse_passive(const char *target_, int default_port,
 631                    struct sockaddr_in *sinp)
 632 {
 633     char *target = xstrdup(target_);
 634     char *string_ptr = target;
 635     const char *host_name;
 636     const char *port_string;
 637     bool ok = false;
 638     int port;
 639
 640     /* Address defaults. */
 641     memset(sinp, 0, sizeof *sinp);
 642     sinp->sin_family = AF_INET;
 643     sinp->sin_addr.s_addr = htonl(INADDR_ANY);
 644     sinp->sin_port = htons(default_port);
 645
 646     /* Parse optional port number. */
 647     port_string = strsep(&string_ptr, ":");
 648     if (port_string && str_to_int(port_string, 10, &port)) {
 649         sinp->sin_port = htons(port);
 650     } else if (default_port < 0) {
 651         VLOG_ERR("%s: port number must be specified", target_);
 652         goto exit;
 653     }
 654
 655     /* Parse optional bind IP. */
 656     host_name = strsep(&string_ptr, ":");
 657     if (host_name && host_name[0] && lookup_ip(host_name, &sinp->sin_addr)) {
 658         goto exit;
 659     }
 660
 661     ok = true;
 662
 663 exit:
 664     if (!ok) {
 665         memset(sinp, 0, sizeof *sinp);
 666     }
 667     free(target);
 668     return ok;
 669 }
 670
 671
 672 /* Opens a non-blocking IPv4 socket of the specified 'style', binds to
 673  * 'target', and listens for incoming connections.  Parses 'target' in the same
 674  * way was inet_parse_passive().
 675  *
 676  * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
 677  *
 678  * For TCP, the socket will have SO_REUSEADDR turned on.
 679  *
 680  * On success, returns a non-negative file descriptor.  On failure, returns a
 681  * negative errno value.
 682  *
 683  * If 'sinp' is non-null, then on success the bound address is stored into
 684  * '*sinp'.
 685  *
 686  * 'dscp' becomes the DSCP bits in the IP headers for the new connection.  It
 687  * should be in the range [0, 63] and will automatically be shifted to the
 688  * appropriately place in the IP tos field. */
 689 int
 690 inet_open_passive(int style, const char *target, int default_port,
 691                   struct sockaddr_in *sinp, uint8_t dscp)
 692 {
 693     struct sockaddr_in sin;
 694     int fd = 0, error;
 695     unsigned int yes = 1;
 696
 697     if (!inet_parse_passive(target, default_port, &sin)) {
 698         return -EAFNOSUPPORT;
 699     }
 700
 701     /* Create non-blocking socket, set SO_REUSEADDR. */
 702     fd = socket(AF_INET, style, 0);
 703     if (fd < 0) {
 704         error = errno;
 705         VLOG_ERR("%s: socket: %s", target, strerror(error));
 706         return -error;
 707     }
 708     error = set_nonblocking(fd);
 709     if (error) {
 710         goto error;
 711     }
 712     if (style == SOCK_STREAM
 713         && setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
 714         error = errno;
 715         VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target, strerror(error));
 716         goto error;
 717     }
 718
 719     /* Bind. */
 720     if (bind(fd, (struct sockaddr *) &sin, sizeof sin) < 0) {
 721         error = errno;
 722         VLOG_ERR("%s: bind: %s", target, strerror(error));
 723         goto error;
 724     }
 725
 726     /* The dscp bits must be configured before connect() to ensure that the TOS
 727      * field is set during the connection establishment.  If set after
 728      * connect(), the handshake SYN frames will be sent with a TOS of 0. */
 729     error = set_dscp(fd, dscp);
 730     if (error) {
 731         VLOG_ERR("%s: socket: %s", target, strerror(error));
 732         goto error;
 733     }
 734
 735     /* Listen. */
 736     if (style == SOCK_STREAM && listen(fd, 10) < 0) {
 737         error = errno;
 738         VLOG_ERR("%s: listen: %s", target, strerror(error));
 739         goto error;
 740     }
 741
 742     if (sinp) {
 743         socklen_t sin_len = sizeof sin;
 744         if (getsockname(fd, (struct sockaddr *) &sin, &sin_len) < 0){
 745             error = errno;
 746             VLOG_ERR("%s: getsockname: %s", target, strerror(error));
 747             goto error;
 748         }
 749         if (sin.sin_family != AF_INET || sin_len != sizeof sin) {
 750             error = EAFNOSUPPORT;
 751             VLOG_ERR("%s: getsockname: invalid socket name", target);
 752             goto error;
 753         }
 754         *sinp = sin;
 755     }
 756
 757     return fd;
 758
 759 error:
 760     close(fd);
 761     return -error;
 762 }
 763
 764 /* Returns a readable and writable fd for /dev/null, if successful, otherwise
 765  * a negative errno value.  The caller must not close the returned fd (because
 766  * the same fd will be handed out to subsequent callers). */
 767 int
 768 get_null_fd(void)
 769 {
 770     static int null_fd = -1;
 771     if (null_fd < 0) {
 772         null_fd = open("/dev/null", O_RDWR);
 773         if (null_fd < 0) {
 774             int error = errno;
 775             VLOG_ERR("could not open /dev/null: %s", strerror(error));
 776             return -error;
 777         }
 778     }
 779     return null_fd;
 780 }
 781
 782 int
 783 read_fully(int fd, void *p_, size_t size, size_t *bytes_read)
 784 {
 785     uint8_t *p = p_;
 786
 787     *bytes_read = 0;
 788     while (size > 0) {
 789         ssize_t retval = read(fd, p, size);
 790         if (retval > 0) {
 791             *bytes_read += retval;
 792             size -= retval;
 793             p += retval;
 794         } else if (retval == 0) {
 795             return EOF;
 796         } else if (errno != EINTR) {
 797             return errno;
 798         }
 799     }
 800     return 0;
 801 }
 802
 803 int
 804 write_fully(int fd, const void *p_, size_t size, size_t *bytes_written)
 805 {
 806     const uint8_t *p = p_;
 807
 808     *bytes_written = 0;
 809     while (size > 0) {
 810         ssize_t retval = write(fd, p, size);
 811         if (retval > 0) {
 812             *bytes_written += retval;
 813             size -= retval;
 814             p += retval;
 815         } else if (retval == 0) {
 816             VLOG_WARN("write returned 0");
 817             return EPROTO;
 818         } else if (errno != EINTR) {
 819             return errno;
 820         }
 821     }
 822     return 0;
 823 }
 824
 825 /* Given file name 'file_name', fsyncs the directory in which it is contained.
 826  * Returns 0 if successful, otherwise a positive errno value. */
 827 int
 828 fsync_parent_dir(const char *file_name)
 829 {
 830     int error = 0;
 831     char *dir;
 832     int fd;
 833
 834     dir = dir_name(file_name);
 835     fd = open(dir, O_RDONLY);
 836     if (fd >= 0) {
 837         if (fsync(fd)) {
 838             if (errno == EINVAL || errno == EROFS) {
 839                 /* This directory does not support synchronization.  Not
 840                  * really an error. */
 841             } else {
 842                 error = errno;
 843                 VLOG_ERR("%s: fsync failed (%s)", dir, strerror(error));
 844             }
 845         }
 846         close(fd);
 847     } else {
 848         error = errno;
 849         VLOG_ERR("%s: open failed (%s)", dir, strerror(error));
 850     }
 851     free(dir);
 852
 853     return error;
 854 }
 855
 856 /* Obtains the modification time of the file named 'file_name' to the greatest
 857  * supported precision.  If successful, stores the mtime in '*mtime' and
 858  * returns 0.  On error, returns a positive errno value and stores zeros in
 859  * '*mtime'. */
 860 int
 861 get_mtime(const char *file_name, struct timespec *mtime)
 862 {
 863     struct stat s;
 864
 865     if (!stat(file_name, &s)) {
 866         mtime->tv_sec = s.st_mtime;
 867
 868 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
 869         mtime->tv_nsec = s.st_mtim.tv_nsec;
 870 #elif HAVE_STRUCT_STAT_ST_MTIMENSEC
 871         mtime->tv_nsec = s.st_mtimensec;
 872 #else
 873         mtime->tv_nsec = 0;
 874 #endif
 875
 876         return 0;
 877     } else {
 878         mtime->tv_sec = mtime->tv_nsec = 0;
 879         return errno;
 880     }
 881 }
 882
 883 void
 884 xpipe(int fds[2])
 885 {
 886     if (pipe(fds)) {
 887         VLOG_FATAL("failed to create pipe (%s)", strerror(errno));
 888     }
 889 }
 890
 891 void
 892 xpipe_nonblocking(int fds[2])
 893 {
 894     xpipe(fds);
 895     xset_nonblocking(fds[0]);
 896     xset_nonblocking(fds[1]);
 897 }
 898
 899 void
 900 xsocketpair(int domain, int type, int protocol, int fds[2])
 901 {
 902     if (socketpair(domain, type, protocol, fds)) {
 903         VLOG_FATAL("failed to create socketpair (%s)", strerror(errno));
 904     }
 905 }
 906
 907 static int
 908 getsockopt_int(int fd, int level, int option, const char *optname, int *valuep)
 909 {
 910     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
 911     socklen_t len;
 912     int value;
 913     int error;
 914
 915     len = sizeof value;
 916     if (getsockopt(fd, level, option, &value, &len)) {
 917         error = errno;
 918         VLOG_ERR_RL(&rl, "getsockopt(%s): %s", optname, strerror(error));
 919     } else if (len != sizeof value) {
 920         error = EINVAL;
 921         VLOG_ERR_RL(&rl, "getsockopt(%s): value is %u bytes (expected %zu)",
 922                     optname, (unsigned int) len, sizeof value);
 923     } else {
 924         error = 0;
 925     }
 926
 927     *valuep = error ? 0 : value;
 928     return error;
 929 }
 930
 931 static void
 932 describe_sockaddr(struct ds *string, int fd,
 933                   int (*getaddr)(int, struct sockaddr *, socklen_t *))
 934 {
 935     struct sockaddr_storage ss;
 936     socklen_t len = sizeof ss;
 937
 938     if (!getaddr(fd, (struct sockaddr *) &ss, &len)) {
 939         if (ss.ss_family == AF_INET) {
 940             struct sockaddr_in sin;
 941
 942             memcpy(&sin, &ss, sizeof sin);
 943             ds_put_format(string, IP_FMT":%"PRIu16,
 944                           IP_ARGS(sin.sin_addr.s_addr), ntohs(sin.sin_port));
 945         } else if (ss.ss_family == AF_UNIX) {
 946             struct sockaddr_un sun;
 947             const char *null;
 948             size_t maxlen;
 949
 950             memcpy(&sun, &ss, sizeof sun);
 951             maxlen = len - offsetof(struct sockaddr_un, sun_path);
 952             null = memchr(sun.sun_path, '\0', maxlen);
 953             ds_put_buffer(string, sun.sun_path,
 954                           null ? null - sun.sun_path : maxlen);
 955         }
 956 #ifdef HAVE_NETLINK
 957         else if (ss.ss_family == AF_NETLINK) {
 958             int protocol;
 959
 960 /* SO_PROTOCOL was introduced in 2.6.32.  Support it regardless of the version
 961  * of the Linux kernel headers in use at build time. */
 962 #ifndef SO_PROTOCOL
 963 #define SO_PROTOCOL 38
 964 #endif
 965
 966             if (!getsockopt_int(fd, SOL_SOCKET, SO_PROTOCOL, "SO_PROTOCOL",
 967                                 &protocol)) {
 968                 switch (protocol) {
 969                 case NETLINK_ROUTE:
 970                     ds_put_cstr(string, "NETLINK_ROUTE");
 971                     break;
 972
 973                 case NETLINK_GENERIC:
 974                     ds_put_cstr(string, "NETLINK_GENERIC");
 975                     break;
 976
 977                 default:
 978                     ds_put_format(string, "AF_NETLINK family %d", protocol);
 979                     break;
 980                 }
 981             } else {
 982                 ds_put_cstr(string, "AF_NETLINK");
 983             }
 984         }
 985 #endif
 986 #if AF_PACKET && LINUX_DATAPATH
 987         else if (ss.ss_family == AF_PACKET) {
 988             struct sockaddr_ll sll;
 989
 990             memcpy(&sll, &ss, sizeof sll);
 991             ds_put_cstr(string, "AF_PACKET");
 992             if (sll.sll_ifindex) {
 993                 char name[IFNAMSIZ];
 994
 995                 if (if_indextoname(sll.sll_ifindex, name)) {
 996                     ds_put_format(string, "(%s)", name);
 997                 } else {
 998                     ds_put_format(string, "(ifindex=%d)", sll.sll_ifindex);
 999                 }
1000             }
1001             if (sll.sll_protocol) {
1002                 ds_put_format(string, "(protocol=0x%"PRIu16")",
1003                               ntohs(sll.sll_protocol));
1004             }
1005         }
1006 #endif
1007         else if (ss.ss_family == AF_UNSPEC) {
1008             ds_put_cstr(string, "AF_UNSPEC");
1009         } else {
1010             ds_put_format(string, "AF_%d", (int) ss.ss_family);
1011         }
1012     }
1013 }
1014
1015
1016 #ifdef LINUX_DATAPATH
1017 static void
1018 put_fd_filename(struct ds *string, int fd)
1019 {
1020     char buf[1024];
1021     char *linkname;
1022     int n;
1023
1024     linkname = xasprintf("/proc/self/fd/%d", fd);
1025     n = readlink(linkname, buf, sizeof buf);
1026     if (n > 0) {
1027         ds_put_char(string, ' ');
1028         ds_put_buffer(string, buf, n);
1029         if (n > sizeof buf) {
1030             ds_put_cstr(string, "...");
1031         }
1032     }
1033     free(linkname);
1034 }
1035 #endif
1036
1037 /* Returns a malloc()'d string describing 'fd', for use in logging. */
1038 char *
1039 describe_fd(int fd)
1040 {
1041     struct ds string;
1042     struct stat s;
1043
1044     ds_init(&string);
1045     if (fstat(fd, &s)) {
1046         ds_put_format(&string, "fstat failed (%s)", strerror(errno));
1047     } else if (S_ISSOCK(s.st_mode)) {
1048         describe_sockaddr(&string, fd, getsockname);
1049         ds_put_cstr(&string, "<->");
1050         describe_sockaddr(&string, fd, getpeername);
1051     } else {
1052         ds_put_cstr(&string, (isatty(fd) ? "tty"
1053                               : S_ISDIR(s.st_mode) ? "directory"
1054                               : S_ISCHR(s.st_mode) ? "character device"
1055                               : S_ISBLK(s.st_mode) ? "block device"
1056                               : S_ISREG(s.st_mode) ? "file"
1057                               : S_ISFIFO(s.st_mode) ? "FIFO"
1058                               : S_ISLNK(s.st_mode) ? "symbolic link"
1059                               : "unknown"));
1060 #ifdef LINUX_DATAPATH
1061         put_fd_filename(&string, fd);
1062 #endif
1063     }
1064     return ds_steal_cstr(&string);
1065 }
1066
1067 /* Returns the total of the 'iov_len' members of the 'n_iovs' in 'iovs'.
1068  * The caller must ensure that the total does not exceed SIZE_MAX. */
1069 size_t
1070 iovec_len(const struct iovec iovs[], size_t n_iovs)
1071 {
1072     size_t len = 0;
1073     size_t i;
1074
1075     for (i = 0; i < n_iovs; i++) {
1076         len += iovs[i].iov_len;
1077     }
1078     return len;
1079 }
1080
1081 /* Returns true if all of the 'n_iovs' iovecs in 'iovs' have length zero. */
1082 bool
1083 iovec_is_empty(const struct iovec iovs[], size_t n_iovs)
1084 {
1085     size_t i;
1086
1087     for (i = 0; i < n_iovs; i++) {
1088         if (iovs[i].iov_len) {
1089             return false;
1090         }
1091     }
1092     return true;
1093 }
1094
1095 /* Sends the 'n_iovs' iovecs of data in 'iovs' and the 'n_fds' file descriptors
1096  * in 'fds' on Unix domain socket 'sock'.  Returns the number of bytes
1097  * successfully sent or -1 if an error occurred.  On error, sets errno
1098  * appropriately.  */
1099 int
1100 send_iovec_and_fds(int sock,
1101                    const struct iovec *iovs, size_t n_iovs,
1102                    const int fds[], size_t n_fds)
1103 {
1104     assert(sock >= 0);
1105     if (n_fds > 0) {
1106         union {
1107             struct cmsghdr cm;
1108             char control[CMSG_SPACE(SOUTIL_MAX_FDS * sizeof *fds)];
1109         } cmsg;
1110         struct msghdr msg;
1111
1112         assert(!iovec_is_empty(iovs, n_iovs));
1113         assert(n_fds <= SOUTIL_MAX_FDS);
1114
1115         memset(&cmsg, 0, sizeof cmsg);
1116         cmsg.cm.cmsg_len = CMSG_LEN(n_fds * sizeof *fds);
1117         cmsg.cm.cmsg_level = SOL_SOCKET;
1118         cmsg.cm.cmsg_type = SCM_RIGHTS;
1119         memcpy(CMSG_DATA(&cmsg.cm), fds, n_fds * sizeof *fds);
1120
1121         msg.msg_name = NULL;
1122         msg.msg_namelen = 0;
1123         msg.msg_iov = CONST_CAST(struct iovec *, iovs);
1124         msg.msg_iovlen = n_iovs;
1125         msg.msg_control = &cmsg.cm;
1126         msg.msg_controllen = CMSG_SPACE(n_fds * sizeof *fds);
1127         msg.msg_flags = 0;
1128
1129         return sendmsg(sock, &msg, 0);
1130     } else {
1131         return writev(sock, iovs, n_iovs);
1132     }
1133 }
1134
1135 /* Sends the 'n_iovs' iovecs of data in 'iovs' and the 'n_fds' file descriptors
1136  * in 'fds' on Unix domain socket 'sock'.  If 'skip_bytes' is nonzero, then the
1137  * first 'skip_bytes' of data in the iovecs are not sent, and none of the file
1138  * descriptors are sent.  The function continues to retry sending until an
1139  * error (other than EINTR) occurs or all the data and fds are sent.
1140  *
1141  * Returns 0 if all the data and fds were successfully sent, otherwise a
1142  * positive errno value.  Regardless of success, stores the number of bytes
1143  * sent (always at least 'skip_bytes') in '*bytes_sent'.  (If at least one byte
1144  * is sent, then all the fds have been sent.)
1145  *
1146  * 'skip_bytes' must be less than or equal to iovec_len(iovs, n_iovs). */
1147 int
1148 send_iovec_and_fds_fully(int sock,
1149                          const struct iovec iovs[], size_t n_iovs,
1150                          const int fds[], size_t n_fds,
1151                          size_t skip_bytes, size_t *bytes_sent)
1152 {
1153     *bytes_sent = 0;
1154     while (n_iovs > 0) {
1155         int retval;
1156
1157         if (skip_bytes) {
1158             retval = skip_bytes;
1159             skip_bytes = 0;
1160         } else if (!*bytes_sent) {
1161             retval = send_iovec_and_fds(sock, iovs, n_iovs, fds, n_fds);
1162         } else {
1163             retval = writev(sock, iovs, n_iovs);
1164         }
1165
1166         if (retval > 0) {
1167             *bytes_sent += retval;
1168             while (retval > 0) {
1169                 const uint8_t *base = iovs->iov_base;
1170                 size_t len = iovs->iov_len;
1171
1172                 if (retval < len) {
1173                     size_t sent;
1174                     int error;
1175
1176                     error = write_fully(sock, base + retval, len - retval,
1177                                         &sent);
1178                     *bytes_sent += sent;
1179                     retval += sent;
1180                     if (error) {
1181                         return error;
1182                     }
1183                 }
1184                 retval -= len;
1185                 iovs++;
1186                 n_iovs--;
1187             }
1188         } else if (retval == 0) {
1189             if (iovec_is_empty(iovs, n_iovs)) {
1190                 break;
1191             }
1192             VLOG_WARN("send returned 0");
1193             return EPROTO;
1194         } else if (errno != EINTR) {
1195             return errno;
1196         }
1197     }
1198
1199     return 0;
1200 }
1201
1202 /* Sends the 'n_iovs' iovecs of data in 'iovs' and the 'n_fds' file descriptors
1203  * in 'fds' on Unix domain socket 'sock'.  The function continues to retry
1204  * sending until an error (other than EAGAIN or EINTR) occurs or all the data
1205  * and fds are sent.  Upon EAGAIN, the function blocks until the socket is
1206  * ready for more data.
1207  *
1208  * Returns 0 if all the data and fds were successfully sent, otherwise a
1209  * positive errno value. */
1210 int
1211 send_iovec_and_fds_fully_block(int sock,
1212                                const struct iovec iovs[], size_t n_iovs,
1213                                const int fds[], size_t n_fds)
1214 {
1215     size_t sent = 0;
1216
1217     for (;;) {
1218         int error;
1219
1220         error = send_iovec_and_fds_fully(sock, iovs, n_iovs,
1221                                          fds, n_fds, sent, &sent);
1222         if (error != EAGAIN) {
1223             return error;
1224         }
1225         poll_fd_wait(sock, POLLOUT);
1226         poll_block();
1227     }
1228 }
1229
1230 /* Attempts to receive from Unix domain socket 'sock' up to 'size' bytes of
1231  * data into 'data' and up to SOUTIL_MAX_FDS file descriptors into 'fds'.
1232  *
1233  *      - Upon success, returns the number of bytes of data copied into 'data'
1234  *        and stores the number of received file descriptors into '*n_fdsp'.
1235  *
1236  *      - On failure, returns a negative errno value and stores 0 in
1237  *        '*n_fdsp'.
1238  *
1239  *      - On EOF, returns 0 and stores 0 in '*n_fdsp'. */
1240 int
1241 recv_data_and_fds(int sock,
1242                   void *data, size_t size,
1243                   int fds[SOUTIL_MAX_FDS], size_t *n_fdsp)
1244 {
1245     union {
1246         struct cmsghdr cm;
1247         char control[CMSG_SPACE(SOUTIL_MAX_FDS * sizeof *fds)];
1248     } cmsg;
1249     struct msghdr msg;
1250     int retval;
1251     struct cmsghdr *p;
1252     size_t i;
1253
1254     *n_fdsp = 0;
1255
1256     do {
1257         struct iovec iov;
1258
1259         iov.iov_base = data;
1260         iov.iov_len = size;
1261
1262         msg.msg_name = NULL;
1263         msg.msg_namelen = 0;
1264         msg.msg_iov = &iov;
1265         msg.msg_iovlen = 1;
1266         msg.msg_control = &cmsg.cm;
1267         msg.msg_controllen = sizeof cmsg.control;
1268         msg.msg_flags = 0;
1269
1270         retval = recvmsg(sock, &msg, 0);
1271     } while (retval < 0 && errno == EINTR);
1272     if (retval <= 0) {
1273         return retval < 0 ? -errno : 0;
1274     }
1275
1276     for (p = CMSG_FIRSTHDR(&msg); p; p = CMSG_NXTHDR(&msg, p)) {
1277         if (p->cmsg_level != SOL_SOCKET || p->cmsg_type != SCM_RIGHTS) {
1278             VLOG_ERR("unexpected control message %d:%d",
1279                      p->cmsg_level, p->cmsg_type);
1280             goto error;
1281         } else if (*n_fdsp) {
1282             VLOG_ERR("multiple SCM_RIGHTS received");
1283             goto error;
1284         } else {
1285             size_t n_fds = (p->cmsg_len - CMSG_LEN(0)) / sizeof *fds;
1286             const int *fds_data = (const int *) CMSG_DATA(p);
1287
1288             assert(n_fds > 0);
1289             if (n_fds > SOUTIL_MAX_FDS) {
1290                 VLOG_ERR("%zu fds received but only %d supported",
1291                          n_fds, SOUTIL_MAX_FDS);
1292                 for (i = 0; i < n_fds; i++) {
1293                     close(fds_data[i]);
1294                 }
1295                 goto error;
1296             }
1297
1298             *n_fdsp = n_fds;
1299             memcpy(fds, fds_data, n_fds * sizeof *fds);
1300         }
1301     }
1302
1303     return retval;
1304
1305 error:
1306     for (i = 0; i < *n_fdsp; i++) {
1307         close(fds[i]);
1308     }
1309     *n_fdsp = 0;
1310     return EPROTO;
1311 }