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/un.h>
  34 #include <unistd.h>
  35 #include "dynamic-string.h"
  36 #include "fatal-signal.h"
  37 #include "packets.h"
  38 #include "util.h"
  39 #include "vlog.h"
  40 #if AF_PACKET && __linux__
  41 #include <linux/if_packet.h>
  42 #endif
  43 #ifdef HAVE_NETLINK
  44 #include "netlink-protocol.h"
  45 #include "netlink-socket.h"
  46 #endif
  47
  48 VLOG_DEFINE_THIS_MODULE(socket_util);
  49
  50 /* #ifdefs make it a pain to maintain code: you have to try to build both ways.
  51  * Thus, this file compiles all of the code regardless of the target, by
  52  * writing "if (LINUX)" instead of "#ifdef __linux__". */
  53 #ifdef __linux__
  54 #define LINUX 1
  55 #else
  56 #define LINUX 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 static int
  86 set_dscp(int fd, uint8_t dscp)
  87 {
  88     if (dscp > 63) {
  89         return EINVAL;
  90     }
  91
  92     dscp = dscp << 2;
  93     if (setsockopt(fd, IPPROTO_IP, IP_TOS, &dscp, sizeof dscp)) {
  94         return errno;
  95     }
  96
  97     return 0;
  98 }
  99
 100 static bool
 101 rlim_is_finite(rlim_t limit)
 102 {
 103     if (limit == RLIM_INFINITY) {
 104         return false;
 105     }
 106
 107 #ifdef RLIM_SAVED_CUR           /* FreeBSD 8.0 lacks RLIM_SAVED_CUR. */
 108     if (limit == RLIM_SAVED_CUR) {
 109         return false;
 110     }
 111 #endif
 112
 113 #ifdef RLIM_SAVED_MAX           /* FreeBSD 8.0 lacks RLIM_SAVED_MAX. */
 114     if (limit == RLIM_SAVED_MAX) {
 115         return false;
 116     }
 117 #endif
 118
 119     return true;
 120 }
 121
 122 /* Returns the maximum valid FD value, plus 1. */
 123 int
 124 get_max_fds(void)
 125 {
 126     static int max_fds = -1;
 127     if (max_fds < 0) {
 128         struct rlimit r;
 129         if (!getrlimit(RLIMIT_NOFILE, &r) && rlim_is_finite(r.rlim_cur)) {
 130             max_fds = r.rlim_cur;
 131         } else {
 132             VLOG_WARN("failed to obtain fd limit, defaulting to 1024");
 133             max_fds = 1024;
 134         }
 135     }
 136     return max_fds;
 137 }
 138
 139 /* Translates 'host_name', which must be a string representation of an IP
 140  * address, into a numeric IP address in '*addr'.  Returns 0 if successful,
 141  * otherwise a positive errno value. */
 142 int
 143 lookup_ip(const char *host_name, struct in_addr *addr)
 144 {
 145     if (!inet_aton(host_name, addr)) {
 146         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 147         VLOG_ERR_RL(&rl, "\"%s\" is not a valid IP address", host_name);
 148         return ENOENT;
 149     }
 150     return 0;
 151 }
 152
 153 /* Translates 'host_name', which must be a string representation of an IPv6
 154  * address, into a numeric IPv6 address in '*addr'.  Returns 0 if successful,
 155  * otherwise a positive errno value. */
 156 int
 157 lookup_ipv6(const char *host_name, struct in6_addr *addr)
 158 {
 159     if (inet_pton(AF_INET6, host_name, addr) != 1) {
 160         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 161         VLOG_ERR_RL(&rl, "\"%s\" is not a valid IPv6 address", host_name);
 162         return ENOENT;
 163     }
 164     return 0;
 165 }
 166
 167 /* Translates 'host_name', which must be a host name or a string representation
 168  * of an IP address, into a numeric IP address in '*addr'.  Returns 0 if
 169  * successful, otherwise a positive errno value.
 170  *
 171  * Most Open vSwitch code should not use this because it causes deadlocks:
 172  * gethostbyname() sends out a DNS request but that starts a new flow for which
 173  * OVS must set up a flow, but it can't because it's waiting for a DNS reply.
 174  * The synchronous lookup also delays other activty.  (Of course we can solve
 175  * this but it doesn't seem worthwhile quite yet.)  */
 176 int
 177 lookup_hostname(const char *host_name, struct in_addr *addr)
 178 {
 179     struct hostent *h;
 180
 181     if (inet_aton(host_name, addr)) {
 182         return 0;
 183     }
 184
 185     h = gethostbyname(host_name);
 186     if (h) {
 187         *addr = *(struct in_addr *) h->h_addr;
 188         return 0;
 189     }
 190
 191     return (h_errno == HOST_NOT_FOUND ? ENOENT
 192             : h_errno == TRY_AGAIN ? EAGAIN
 193             : h_errno == NO_RECOVERY ? EIO
 194             : h_errno == NO_ADDRESS ? ENXIO
 195             : EINVAL);
 196 }
 197
 198 /* Returns the error condition associated with socket 'fd' and resets the
 199  * socket's error status. */
 200 int
 201 get_socket_error(int fd)
 202 {
 203     int error;
 204
 205     if (getsockopt_int(fd, SOL_SOCKET, SO_ERROR, "SO_ERROR", &error)) {
 206         error = errno;
 207     }
 208     return error;
 209 }
 210
 211 int
 212 check_connection_completion(int fd)
 213 {
 214     struct pollfd pfd;
 215     int retval;
 216
 217     pfd.fd = fd;
 218     pfd.events = POLLOUT;
 219     do {
 220         retval = poll(&pfd, 1, 0);
 221     } while (retval < 0 && errno == EINTR);
 222     if (retval == 1) {
 223         return get_socket_error(fd);
 224     } else if (retval < 0) {
 225         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
 226         VLOG_ERR_RL(&rl, "poll: %s", strerror(errno));
 227         return errno;
 228     } else {
 229         return EAGAIN;
 230     }
 231 }
 232
 233 /* Drain all the data currently in the receive queue of a datagram socket (and
 234  * possibly additional data).  There is no way to know how many packets are in
 235  * the receive queue, but we do know that the total number of bytes queued does
 236  * not exceed the receive buffer size, so we pull packets until none are left
 237  * or we've read that many bytes. */
 238 int
 239 drain_rcvbuf(int fd)
 240 {
 241     int rcvbuf;
 242
 243     rcvbuf = get_socket_rcvbuf(fd);
 244     if (rcvbuf < 0) {
 245         return -rcvbuf;
 246     }
 247
 248     while (rcvbuf > 0) {
 249         /* In Linux, specifying MSG_TRUNC in the flags argument causes the
 250          * datagram length to be returned, even if that is longer than the
 251          * buffer provided.  Thus, we can use a 1-byte buffer to discard the
 252          * incoming datagram and still be able to account how many bytes were
 253          * removed from the receive buffer.
 254          *
 255          * On other Unix-like OSes, MSG_TRUNC has no effect in the flags
 256          * argument. */
 257         char buffer[LINUX ? 1 : 2048];
 258         ssize_t n_bytes = recv(fd, buffer, sizeof buffer,
 259                                MSG_TRUNC | MSG_DONTWAIT);
 260         if (n_bytes <= 0 || n_bytes >= rcvbuf) {
 261             break;
 262         }
 263         rcvbuf -= n_bytes;
 264     }
 265     return 0;
 266 }
 267
 268 /* Returns the size of socket 'sock''s receive buffer (SO_RCVBUF), or a
 269  * negative errno value if an error occurs. */
 270 int
 271 get_socket_rcvbuf(int sock)
 272 {
 273     int rcvbuf;
 274     int error;
 275
 276     error = getsockopt_int(sock, SOL_SOCKET, SO_RCVBUF, "SO_RCVBUF", &rcvbuf);
 277     return error ? -error : rcvbuf;
 278 }
 279
 280 /* Reads and discards up to 'n' datagrams from 'fd', stopping as soon as no
 281  * more data can be immediately read.  ('fd' should therefore be in
 282  * non-blocking mode.)*/
 283 void
 284 drain_fd(int fd, size_t n_packets)
 285 {
 286     for (; n_packets > 0; n_packets--) {
 287         /* 'buffer' only needs to be 1 byte long in most circumstances.  This
 288          * size is defensive against the possibility that we someday want to
 289          * use a Linux tap device without TUN_NO_PI, in which case a buffer
 290          * smaller than sizeof(struct tun_pi) will give EINVAL on read. */
 291         char buffer[128];
 292         if (read(fd, buffer, sizeof buffer) <= 0) {
 293             break;
 294         }
 295     }
 296 }
 297
 298 /* Stores in '*un' a sockaddr_un that refers to file 'name'.  Stores in
 299  * '*un_len' the size of the sockaddr_un. */
 300 static void
 301 make_sockaddr_un__(const char *name, struct sockaddr_un *un, socklen_t *un_len)
 302 {
 303     un->sun_family = AF_UNIX;
 304     ovs_strzcpy(un->sun_path, name, sizeof un->sun_path);
 305     *un_len = (offsetof(struct sockaddr_un, sun_path)
 306                 + strlen (un->sun_path) + 1);
 307 }
 308
 309 /* Stores in '*un' a sockaddr_un that refers to file 'name'.  Stores in
 310  * '*un_len' the size of the sockaddr_un.
 311  *
 312  * Returns 0 on success, otherwise a positive errno value.  On success,
 313  * '*dirfdp' is either -1 or a nonnegative file descriptor that the caller
 314  * should close after using '*un' to bind or connect.  On failure, '*dirfdp' is
 315  * -1. */
 316 static int
 317 make_sockaddr_un(const char *name, struct sockaddr_un *un, socklen_t *un_len,
 318                  int *dirfdp)
 319 {
 320     enum { MAX_UN_LEN = sizeof un->sun_path - 1 };
 321
 322     *dirfdp = -1;
 323     if (strlen(name) > MAX_UN_LEN) {
 324         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
 325
 326         if (LINUX) {
 327             /* 'name' is too long to fit in a sockaddr_un, but we have a
 328              * workaround for that on Linux: shorten it by opening a file
 329              * descriptor for the directory part of the name and indirecting
 330              * through /proc/self/fd/<dirfd>/<basename>. */
 331             char *dir, *base;
 332             char *short_name;
 333             int dirfd;
 334
 335             dir = dir_name(name);
 336             base = base_name(name);
 337
 338             dirfd = open(dir, O_DIRECTORY | O_RDONLY);
 339             if (dirfd < 0) {
 340                 free(base);
 341                 free(dir);
 342                 return errno;
 343             }
 344
 345             short_name = xasprintf("/proc/self/fd/%d/%s", dirfd, base);
 346             free(dir);
 347             free(base);
 348
 349             if (strlen(short_name) <= MAX_UN_LEN) {
 350                 make_sockaddr_un__(short_name, un, un_len);
 351                 free(short_name);
 352                 *dirfdp = dirfd;
 353                 return 0;
 354             }
 355             free(short_name);
 356             close(dirfd);
 357
 358             VLOG_WARN_RL(&rl, "Unix socket name %s is longer than maximum "
 359                          "%d bytes (even shortened)", name, MAX_UN_LEN);
 360         } else {
 361             /* 'name' is too long and we have no workaround. */
 362             VLOG_WARN_RL(&rl, "Unix socket name %s is longer than maximum "
 363                          "%d bytes", name, MAX_UN_LEN);
 364         }
 365
 366         return ENAMETOOLONG;
 367     } else {
 368         make_sockaddr_un__(name, un, un_len);
 369         return 0;
 370     }
 371 }
 372
 373 /* Binds Unix domain socket 'fd' to a file with permissions 0700. */
 374 static int
 375 bind_unix_socket(int fd, struct sockaddr *sun, socklen_t sun_len)
 376 {
 377     /* According to _Unix Network Programming_, umask should affect bind(). */
 378     mode_t old_umask = umask(0077);
 379     int error = bind(fd, sun, sun_len) ? errno : 0;
 380     umask(old_umask);
 381     return error;
 382 }
 383
 384 /* Creates a Unix domain socket in the given 'style' (either SOCK_DGRAM or
 385  * SOCK_STREAM) that is bound to '*bind_path' (if 'bind_path' is non-null) and
 386  * connected to '*connect_path' (if 'connect_path' is non-null).  If 'nonblock'
 387  * is true, the socket is made non-blocking.  If 'passcred' is true, the socket
 388  * is configured to receive SCM_CREDENTIALS control messages.
 389  *
 390  * Returns the socket's fd if successful, otherwise a negative errno value. */
 391 int
 392 make_unix_socket(int style, bool nonblock, bool passcred OVS_UNUSED,
 393                  const char *bind_path, const char *connect_path)
 394 {
 395     int error;
 396     int fd;
 397
 398     fd = socket(PF_UNIX, style, 0);
 399     if (fd < 0) {
 400         return -errno;
 401     }
 402
 403     /* Set nonblocking mode right away, if we want it.  This prevents blocking
 404      * in connect(), if connect_path != NULL.  (In turn, that's a corner case:
 405      * it will only happen if style is SOCK_STREAM or SOCK_SEQPACKET, and only
 406      * if a backlog of un-accepted connections has built up in the kernel.)  */
 407     if (nonblock) {
 408         int flags = fcntl(fd, F_GETFL, 0);
 409         if (flags == -1) {
 410             error = errno;
 411             goto error;
 412         }
 413         if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
 414             error = errno;
 415             goto error;
 416         }
 417     }
 418
 419     if (bind_path) {
 420         struct sockaddr_un un;
 421         socklen_t un_len;
 422         int dirfd;
 423
 424         if (unlink(bind_path) && errno != ENOENT) {
 425             VLOG_WARN("unlinking \"%s\": %s\n", bind_path, strerror(errno));
 426         }
 427         fatal_signal_add_file_to_unlink(bind_path);
 428
 429         error = make_sockaddr_un(bind_path, &un, &un_len, &dirfd);
 430         if (!error) {
 431             error = bind_unix_socket(fd, (struct sockaddr *) &un, un_len);
 432         }
 433         if (dirfd >= 0) {
 434             close(dirfd);
 435         }
 436         if (error) {
 437             goto error;
 438         }
 439     }
 440
 441     if (connect_path) {
 442         struct sockaddr_un un;
 443         socklen_t un_len;
 444         int dirfd;
 445
 446         error = make_sockaddr_un(connect_path, &un, &un_len, &dirfd);
 447         if (!error
 448             && connect(fd, (struct sockaddr*) &un, un_len)
 449             && errno != EINPROGRESS) {
 450             error = errno;
 451         }
 452         if (dirfd >= 0) {
 453             close(dirfd);
 454         }
 455         if (error) {
 456             goto error;
 457         }
 458     }
 459
 460 #ifdef SCM_CREDENTIALS
 461     if (passcred) {
 462         int enable = 1;
 463         if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable))) {
 464             error = errno;
 465             goto error;
 466         }
 467     }
 468 #endif
 469
 470     return fd;
 471
 472 error:
 473     if (error == EAGAIN) {
 474         error = EPROTO;
 475     }
 476     if (bind_path) {
 477         fatal_signal_unlink_file_now(bind_path);
 478     }
 479     close(fd);
 480     return -error;
 481 }
 482
 483 int
 484 get_unix_name_len(socklen_t sun_len)
 485 {
 486     return (sun_len >= offsetof(struct sockaddr_un, sun_path)
 487             ? sun_len - offsetof(struct sockaddr_un, sun_path)
 488             : 0);
 489 }
 490
 491 ovs_be32
 492 guess_netmask(ovs_be32 ip_)
 493 {
 494     uint32_t ip = ntohl(ip_);
 495     return ((ip >> 31) == 0 ? htonl(0xff000000)   /* Class A */
 496             : (ip >> 30) == 2 ? htonl(0xffff0000) /* Class B */
 497             : (ip >> 29) == 6 ? htonl(0xffffff00) /* Class C */
 498             : htonl(0));                          /* ??? */
 499 }
 500
 501 /* Parses 'target', which should be a string in the format "<host>[:<port>]".
 502  * <host> is required.  If 'default_port' is nonzero then <port> is optional
 503  * and defaults to 'default_port'.
 504  *
 505  * On success, returns true and stores the parsed remote address into '*sinp'.
 506  * On failure, logs an error, stores zeros into '*sinp', and returns false. */
 507 bool
 508 inet_parse_active(const char *target_, uint16_t default_port,
 509                   struct sockaddr_in *sinp)
 510 {
 511     char *target = xstrdup(target_);
 512     char *save_ptr = NULL;
 513     const char *host_name;
 514     const char *port_string;
 515     bool ok = false;
 516
 517     /* Defaults. */
 518     sinp->sin_family = AF_INET;
 519     sinp->sin_port = htons(default_port);
 520
 521     /* Tokenize. */
 522     host_name = strtok_r(target, ":", &save_ptr);
 523     port_string = strtok_r(NULL, ":", &save_ptr);
 524     if (!host_name) {
 525         VLOG_ERR("%s: bad peer name format", target_);
 526         goto exit;
 527     }
 528
 529     /* Look up IP, port. */
 530     if (lookup_ip(host_name, &sinp->sin_addr)) {
 531         goto exit;
 532     }
 533     if (port_string && atoi(port_string)) {
 534         sinp->sin_port = htons(atoi(port_string));
 535     } else if (!default_port) {
 536         VLOG_ERR("%s: port number must be specified", target_);
 537         goto exit;
 538     }
 539
 540     ok = true;
 541
 542 exit:
 543     if (!ok) {
 544         memset(sinp, 0, sizeof *sinp);
 545     }
 546     free(target);
 547     return ok;
 548 }
 549
 550 /* Opens a non-blocking IPv4 socket of the specified 'style' and connects to
 551  * 'target', which should be a string in the format "<host>[:<port>]".  <host>
 552  * is required.  If 'default_port' is nonzero then <port> is optional and
 553  * defaults to 'default_port'.
 554  *
 555  * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
 556  *
 557  * On success, returns 0 (indicating connection complete) or EAGAIN (indicating
 558  * connection in progress), in which case the new file descriptor is stored
 559  * into '*fdp'.  On failure, returns a positive errno value other than EAGAIN
 560  * and stores -1 into '*fdp'.
 561  *
 562  * If 'sinp' is non-null, then on success the target address is stored into
 563  * '*sinp'.
 564  *
 565  * 'dscp' becomes the DSCP bits in the IP headers for the new connection.  It
 566  * should be in the range [0, 63] and will automatically be shifted to the
 567  * appropriately place in the IP tos field. */
 568 int
 569 inet_open_active(int style, const char *target, uint16_t default_port,
 570                  struct sockaddr_in *sinp, int *fdp, uint8_t dscp)
 571 {
 572     struct sockaddr_in sin;
 573     int fd = -1;
 574     int error;
 575
 576     /* Parse. */
 577     if (!inet_parse_active(target, default_port, &sin)) {
 578         error = EAFNOSUPPORT;
 579         goto exit;
 580     }
 581
 582     /* Create non-blocking socket. */
 583     fd = socket(AF_INET, style, 0);
 584     if (fd < 0) {
 585         VLOG_ERR("%s: socket: %s", target, strerror(errno));
 586         error = errno;
 587         goto exit;
 588     }
 589     error = set_nonblocking(fd);
 590     if (error) {
 591         goto exit;
 592     }
 593
 594     /* The dscp bits must be configured before connect() to ensure that the TOS
 595      * field is set during the connection establishment.  If set after
 596      * connect(), the handshake SYN frames will be sent with a TOS of 0. */
 597     error = set_dscp(fd, dscp);
 598     if (error) {
 599         VLOG_ERR("%s: socket: %s", target, strerror(error));
 600         goto exit;
 601     }
 602
 603     /* Connect. */
 604     error = connect(fd, (struct sockaddr *) &sin, sizeof sin) == 0 ? 0 : errno;
 605     if (error == EINPROGRESS) {
 606         error = EAGAIN;
 607     }
 608
 609 exit:
 610     if (!error || error == EAGAIN) {
 611         if (sinp) {
 612             *sinp = sin;
 613         }
 614     } else if (fd >= 0) {
 615         close(fd);
 616     }
 617     *fdp = fd;
 618     return error;
 619 }
 620
 621 /* Parses 'target', which should be a string in the format "[<port>][:<ip>]":
 622  *
 623  *      - If 'default_port' is -1, then <port> is required.  Otherwise, if
 624  *        <port> is omitted, then 'default_port' is used instead.
 625  *
 626  *      - If <port> (or 'default_port', if used) is 0, then no port is bound
 627  *        and the TCP/IP stack will select a port.
 628  *
 629  *      - If <ip> is omitted then the IP address is wildcarded.
 630  *
 631  * If successful, stores the address into '*sinp' and returns true; otherwise
 632  * zeros '*sinp' and returns false. */
 633 bool
 634 inet_parse_passive(const char *target_, int default_port,
 635                    struct sockaddr_in *sinp)
 636 {
 637     char *target = xstrdup(target_);
 638     char *string_ptr = target;
 639     const char *host_name;
 640     const char *port_string;
 641     bool ok = false;
 642     int port;
 643
 644     /* Address defaults. */
 645     memset(sinp, 0, sizeof *sinp);
 646     sinp->sin_family = AF_INET;
 647     sinp->sin_addr.s_addr = htonl(INADDR_ANY);
 648     sinp->sin_port = htons(default_port);
 649
 650     /* Parse optional port number. */
 651     port_string = strsep(&string_ptr, ":");
 652     if (port_string && str_to_int(port_string, 10, &port)) {
 653         sinp->sin_port = htons(port);
 654     } else if (default_port < 0) {
 655         VLOG_ERR("%s: port number must be specified", target_);
 656         goto exit;
 657     }
 658
 659     /* Parse optional bind IP. */
 660     host_name = strsep(&string_ptr, ":");
 661     if (host_name && host_name[0] && lookup_ip(host_name, &sinp->sin_addr)) {
 662         goto exit;
 663     }
 664
 665     ok = true;
 666
 667 exit:
 668     if (!ok) {
 669         memset(sinp, 0, sizeof *sinp);
 670     }
 671     free(target);
 672     return ok;
 673 }
 674
 675
 676 /* Opens a non-blocking IPv4 socket of the specified 'style', binds to
 677  * 'target', and listens for incoming connections.  Parses 'target' in the same
 678  * way was inet_parse_passive().
 679  *
 680  * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
 681  *
 682  * For TCP, the socket will have SO_REUSEADDR turned on.
 683  *
 684  * On success, returns a non-negative file descriptor.  On failure, returns a
 685  * negative errno value.
 686  *
 687  * If 'sinp' is non-null, then on success the bound address is stored into
 688  * '*sinp'.
 689  *
 690  * 'dscp' becomes the DSCP bits in the IP headers for the new connection.  It
 691  * should be in the range [0, 63] and will automatically be shifted to the
 692  * appropriately place in the IP tos field. */
 693 int
 694 inet_open_passive(int style, const char *target, int default_port,
 695                   struct sockaddr_in *sinp, uint8_t dscp)
 696 {
 697     struct sockaddr_in sin;
 698     int fd = 0, error;
 699     unsigned int yes = 1;
 700
 701     if (!inet_parse_passive(target, default_port, &sin)) {
 702         return -EAFNOSUPPORT;
 703     }
 704
 705     /* Create non-blocking socket, set SO_REUSEADDR. */
 706     fd = socket(AF_INET, style, 0);
 707     if (fd < 0) {
 708         error = errno;
 709         VLOG_ERR("%s: socket: %s", target, strerror(error));
 710         return -error;
 711     }
 712     error = set_nonblocking(fd);
 713     if (error) {
 714         goto error;
 715     }
 716     if (style == SOCK_STREAM
 717         && setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
 718         error = errno;
 719         VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target, strerror(error));
 720         goto error;
 721     }
 722
 723     /* Bind. */
 724     if (bind(fd, (struct sockaddr *) &sin, sizeof sin) < 0) {
 725         error = errno;
 726         VLOG_ERR("%s: bind: %s", target, strerror(error));
 727         goto error;
 728     }
 729
 730     /* The dscp bits must be configured before connect() to ensure that the TOS
 731      * field is set during the connection establishment.  If set after
 732      * connect(), the handshake SYN frames will be sent with a TOS of 0. */
 733     error = set_dscp(fd, dscp);
 734     if (error) {
 735         VLOG_ERR("%s: socket: %s", target, strerror(error));
 736         goto error;
 737     }
 738
 739     /* Listen. */
 740     if (style == SOCK_STREAM && listen(fd, 10) < 0) {
 741         error = errno;
 742         VLOG_ERR("%s: listen: %s", target, strerror(error));
 743         goto error;
 744     }
 745
 746     if (sinp) {
 747         socklen_t sin_len = sizeof sin;
 748         if (getsockname(fd, (struct sockaddr *) &sin, &sin_len) < 0){
 749             error = errno;
 750             VLOG_ERR("%s: getsockname: %s", target, strerror(error));
 751             goto error;
 752         }
 753         if (sin.sin_family != AF_INET || sin_len != sizeof sin) {
 754             error = EAFNOSUPPORT;
 755             VLOG_ERR("%s: getsockname: invalid socket name", target);
 756             goto error;
 757         }
 758         *sinp = sin;
 759     }
 760
 761     return fd;
 762
 763 error:
 764     close(fd);
 765     return -error;
 766 }
 767
 768 /* Returns a readable and writable fd for /dev/null, if successful, otherwise
 769  * a negative errno value.  The caller must not close the returned fd (because
 770  * the same fd will be handed out to subsequent callers). */
 771 int
 772 get_null_fd(void)
 773 {
 774     static int null_fd = -1;
 775     if (null_fd < 0) {
 776         null_fd = open("/dev/null", O_RDWR);
 777         if (null_fd < 0) {
 778             int error = errno;
 779             VLOG_ERR("could not open /dev/null: %s", strerror(error));
 780             return -error;
 781         }
 782     }
 783     return null_fd;
 784 }
 785
 786 int
 787 read_fully(int fd, void *p_, size_t size, size_t *bytes_read)
 788 {
 789     uint8_t *p = p_;
 790
 791     *bytes_read = 0;
 792     while (size > 0) {
 793         ssize_t retval = read(fd, p, size);
 794         if (retval > 0) {
 795             *bytes_read += retval;
 796             size -= retval;
 797             p += retval;
 798         } else if (retval == 0) {
 799             return EOF;
 800         } else if (errno != EINTR) {
 801             return errno;
 802         }
 803     }
 804     return 0;
 805 }
 806
 807 int
 808 write_fully(int fd, const void *p_, size_t size, size_t *bytes_written)
 809 {
 810     const uint8_t *p = p_;
 811
 812     *bytes_written = 0;
 813     while (size > 0) {
 814         ssize_t retval = write(fd, p, size);
 815         if (retval > 0) {
 816             *bytes_written += retval;
 817             size -= retval;
 818             p += retval;
 819         } else if (retval == 0) {
 820             VLOG_WARN("write returned 0");
 821             return EPROTO;
 822         } else if (errno != EINTR) {
 823             return errno;
 824         }
 825     }
 826     return 0;
 827 }
 828
 829 /* Given file name 'file_name', fsyncs the directory in which it is contained.
 830  * Returns 0 if successful, otherwise a positive errno value. */
 831 int
 832 fsync_parent_dir(const char *file_name)
 833 {
 834     int error = 0;
 835     char *dir;
 836     int fd;
 837
 838     dir = dir_name(file_name);
 839     fd = open(dir, O_RDONLY);
 840     if (fd >= 0) {
 841         if (fsync(fd)) {
 842             if (errno == EINVAL || errno == EROFS) {
 843                 /* This directory does not support synchronization.  Not
 844                  * really an error. */
 845             } else {
 846                 error = errno;
 847                 VLOG_ERR("%s: fsync failed (%s)", dir, strerror(error));
 848             }
 849         }
 850         close(fd);
 851     } else {
 852         error = errno;
 853         VLOG_ERR("%s: open failed (%s)", dir, strerror(error));
 854     }
 855     free(dir);
 856
 857     return error;
 858 }
 859
 860 /* Obtains the modification time of the file named 'file_name' to the greatest
 861  * supported precision.  If successful, stores the mtime in '*mtime' and
 862  * returns 0.  On error, returns a positive errno value and stores zeros in
 863  * '*mtime'. */
 864 int
 865 get_mtime(const char *file_name, struct timespec *mtime)
 866 {
 867     struct stat s;
 868
 869     if (!stat(file_name, &s)) {
 870         mtime->tv_sec = s.st_mtime;
 871
 872 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
 873         mtime->tv_nsec = s.st_mtim.tv_nsec;
 874 #elif HAVE_STRUCT_STAT_ST_MTIMENSEC
 875         mtime->tv_nsec = s.st_mtimensec;
 876 #else
 877         mtime->tv_nsec = 0;
 878 #endif
 879
 880         return 0;
 881     } else {
 882         mtime->tv_sec = mtime->tv_nsec = 0;
 883         return errno;
 884     }
 885 }
 886
 887 void
 888 xpipe(int fds[2])
 889 {
 890     if (pipe(fds)) {
 891         VLOG_FATAL("failed to create pipe (%s)", strerror(errno));
 892     }
 893 }
 894
 895 static int
 896 getsockopt_int(int fd, int level, int option, const char *optname, int *valuep)
 897 {
 898     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);
 899     socklen_t len;
 900     int value;
 901     int error;
 902
 903     len = sizeof value;
 904     if (getsockopt(fd, level, option, &value, &len)) {
 905         error = errno;
 906         VLOG_ERR_RL(&rl, "getsockopt(%s): %s", optname, strerror(error));
 907     } else if (len != sizeof value) {
 908         error = EINVAL;
 909         VLOG_ERR_RL(&rl, "getsockopt(%s): value is %u bytes (expected %zu)",
 910                     optname, (unsigned int) len, sizeof value);
 911     } else {
 912         error = 0;
 913     }
 914
 915     *valuep = error ? 0 : value;
 916     return error;
 917 }
 918
 919 static void
 920 describe_sockaddr(struct ds *string, int fd,
 921                   int (*getaddr)(int, struct sockaddr *, socklen_t *))
 922 {
 923     struct sockaddr_storage ss;
 924     socklen_t len = sizeof ss;
 925
 926     if (!getaddr(fd, (struct sockaddr *) &ss, &len)) {
 927         if (ss.ss_family == AF_INET) {
 928             struct sockaddr_in sin;
 929
 930             memcpy(&sin, &ss, sizeof sin);
 931             ds_put_format(string, IP_FMT":%"PRIu16,
 932                           IP_ARGS(&sin.sin_addr.s_addr), ntohs(sin.sin_port));
 933         } else if (ss.ss_family == AF_UNIX) {
 934             struct sockaddr_un sun;
 935             const char *null;
 936             size_t maxlen;
 937
 938             memcpy(&sun, &ss, sizeof sun);
 939             maxlen = len - offsetof(struct sockaddr_un, sun_path);
 940             null = memchr(sun.sun_path, '\0', maxlen);
 941             ds_put_buffer(string, sun.sun_path,
 942                           null ? null - sun.sun_path : maxlen);
 943         }
 944 #ifdef HAVE_NETLINK
 945         else if (ss.ss_family == AF_NETLINK) {
 946             int protocol;
 947
 948 /* SO_PROTOCOL was introduced in 2.6.32.  Support it regardless of the version
 949  * of the Linux kernel headers in use at build time. */
 950 #ifndef SO_PROTOCOL
 951 #define SO_PROTOCOL 38
 952 #endif
 953
 954             if (!getsockopt_int(fd, SOL_SOCKET, SO_PROTOCOL, "SO_PROTOCOL",
 955                                 &protocol)) {
 956                 switch (protocol) {
 957                 case NETLINK_ROUTE:
 958                     ds_put_cstr(string, "NETLINK_ROUTE");
 959                     break;
 960
 961                 case NETLINK_GENERIC:
 962                     ds_put_cstr(string, "NETLINK_GENERIC");
 963                     break;
 964
 965                 default:
 966                     ds_put_format(string, "AF_NETLINK family %d", protocol);
 967                     break;
 968                 }
 969             } else {
 970                 ds_put_cstr(string, "AF_NETLINK");
 971             }
 972         }
 973 #endif
 974 #if AF_PACKET && __linux__
 975         else if (ss.ss_family == AF_PACKET) {
 976             struct sockaddr_ll sll;
 977
 978             memcpy(&sll, &ss, sizeof sll);
 979             ds_put_cstr(string, "AF_PACKET");
 980             if (sll.sll_ifindex) {
 981                 char name[IFNAMSIZ];
 982
 983                 if (if_indextoname(sll.sll_ifindex, name)) {
 984                     ds_put_format(string, "(%s)", name);
 985                 } else {
 986                     ds_put_format(string, "(ifindex=%d)", sll.sll_ifindex);
 987                 }
 988             }
 989             if (sll.sll_protocol) {
 990                 ds_put_format(string, "(protocol=0x%"PRIu16")",
 991                               ntohs(sll.sll_protocol));
 992             }
 993         }
 994 #endif
 995         else if (ss.ss_family == AF_UNSPEC) {
 996             ds_put_cstr(string, "AF_UNSPEC");
 997         } else {
 998             ds_put_format(string, "AF_%d", (int) ss.ss_family);
 999         }
1000     }
1001 }
1002
1003
1004 #ifdef __linux__
1005 static void
1006 put_fd_filename(struct ds *string, int fd)
1007 {
1008     char buf[1024];
1009     char *linkname;
1010     int n;
1011
1012     linkname = xasprintf("/proc/self/fd/%d", fd);
1013     n = readlink(linkname, buf, sizeof buf);
1014     if (n > 0) {
1015         ds_put_char(string, ' ');
1016         ds_put_buffer(string, buf, n);
1017         if (n > sizeof buf) {
1018             ds_put_cstr(string, "...");
1019         }
1020     }
1021     free(linkname);
1022 }
1023 #endif
1024
1025 /* Returns a malloc()'d string describing 'fd', for use in logging. */
1026 char *
1027 describe_fd(int fd)
1028 {
1029     struct ds string;
1030     struct stat s;
1031
1032     ds_init(&string);
1033     if (fstat(fd, &s)) {
1034         ds_put_format(&string, "fstat failed (%s)", strerror(errno));
1035     } else if (S_ISSOCK(s.st_mode)) {
1036         describe_sockaddr(&string, fd, getsockname);
1037         ds_put_cstr(&string, "<->");
1038         describe_sockaddr(&string, fd, getpeername);
1039     } else {
1040         ds_put_cstr(&string, (isatty(fd) ? "tty"
1041                               : S_ISDIR(s.st_mode) ? "directory"
1042                               : S_ISCHR(s.st_mode) ? "character device"
1043                               : S_ISBLK(s.st_mode) ? "block device"
1044                               : S_ISREG(s.st_mode) ? "file"
1045                               : S_ISFIFO(s.st_mode) ? "FIFO"
1046                               : S_ISLNK(s.st_mode) ? "symbolic link"
1047                               : "unknown"));
1048 #ifdef __linux__
1049         put_fd_filename(&string, fd);
1050 #endif
1051     }
1052     return ds_steal_cstr(&string);
1053 }