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