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