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