lib/socket-util.c

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