]>
git.proxmox.com Git - mirror_ovs.git/blob - lib/socket-util.c
2 * Copyright (c) 2008, 2009, 2010 Nicira Networks.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include "socket-util.h"
19 #include <arpa/inet.h>
28 #include <sys/resource.h>
31 #include "fatal-signal.h"
35 #define THIS_MODULE VLM_socket_util
37 /* Sets 'fd' to non-blocking mode. Returns 0 if successful, otherwise a
38 * positive errno value. */
40 set_nonblocking(int fd
)
42 int flags
= fcntl(fd
, F_GETFL
, 0);
44 if (fcntl(fd
, F_SETFL
, flags
| O_NONBLOCK
) != -1) {
47 VLOG_ERR("fcntl(F_SETFL) failed: %s", strerror(errno
));
51 VLOG_ERR("fcntl(F_GETFL) failed: %s", strerror(errno
));
56 /* Returns the maximum valid FD value, plus 1. */
60 static int max_fds
= -1;
63 if (!getrlimit(RLIMIT_NOFILE
, &r
)
64 && r
.rlim_cur
!= RLIM_INFINITY
65 && r
.rlim_cur
!= RLIM_SAVED_MAX
66 && r
.rlim_cur
!= RLIM_SAVED_CUR
) {
69 VLOG_WARN("failed to obtain fd limit, defaulting to 1024");
76 /* Translates 'host_name', which must be a string representation of an IP
77 * address, into a numeric IP address in '*addr'. Returns 0 if successful,
78 * otherwise a positive errno value. */
80 lookup_ip(const char *host_name
, struct in_addr
*addr
)
82 if (!inet_aton(host_name
, addr
)) {
83 struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
84 VLOG_ERR_RL(&rl
, "\"%s\" is not a valid IP address", host_name
);
90 /* Returns the error condition associated with socket 'fd' and resets the
91 * socket's error status. */
93 get_socket_error(int fd
)
96 socklen_t len
= sizeof(error
);
97 if (getsockopt(fd
, SOL_SOCKET
, SO_ERROR
, &error
, &len
) < 0) {
98 struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(5, 10);
100 VLOG_ERR_RL(&rl
, "getsockopt(SO_ERROR): %s", strerror(error
));
106 check_connection_completion(int fd
)
112 pfd
.events
= POLLOUT
;
114 retval
= poll(&pfd
, 1, 0);
115 } while (retval
< 0 && errno
== EINTR
);
117 return get_socket_error(fd
);
118 } else if (retval
< 0) {
119 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(5, 10);
120 VLOG_ERR_RL(&rl
, "poll: %s", strerror(errno
));
127 /* Drain all the data currently in the receive queue of a datagram socket (and
128 * possibly additional data). There is no way to know how many packets are in
129 * the receive queue, but we do know that the total number of bytes queued does
130 * not exceed the receive buffer size, so we pull packets until none are left
131 * or we've read that many bytes. */
135 socklen_t rcvbuf_len
;
138 rcvbuf_len
= sizeof rcvbuf
;
139 if (getsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &rcvbuf
, &rcvbuf_len
) < 0) {
140 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(5, 10);
141 VLOG_ERR_RL(&rl
, "getsockopt(SO_RCVBUF) failed: %s", strerror(errno
));
145 /* In Linux, specifying MSG_TRUNC in the flags argument causes the
146 * datagram length to be returned, even if that is longer than the
147 * buffer provided. Thus, we can use a 1-byte buffer to discard the
148 * incoming datagram and still be able to account how many bytes were
149 * removed from the receive buffer.
151 * On other Unix-like OSes, MSG_TRUNC has no effect in the flags
154 #define BUFFER_SIZE 1
156 #define BUFFER_SIZE 2048
158 char buffer
[BUFFER_SIZE
];
159 ssize_t n_bytes
= recv(fd
, buffer
, sizeof buffer
,
160 MSG_TRUNC
| MSG_DONTWAIT
);
161 if (n_bytes
<= 0 || n_bytes
>= rcvbuf
) {
169 /* Reads and discards up to 'n' datagrams from 'fd', stopping as soon as no
170 * more data can be immediately read. ('fd' should therefore be in
171 * non-blocking mode.)*/
173 drain_fd(int fd
, size_t n_packets
)
175 for (; n_packets
> 0; n_packets
--) {
176 /* 'buffer' only needs to be 1 byte long in most circumstances. This
177 * size is defensive against the possibility that we someday want to
178 * use a Linux tap device without TUN_NO_PI, in which case a buffer
179 * smaller than sizeof(struct tun_pi) will give EINVAL on read. */
181 if (read(fd
, buffer
, sizeof buffer
) <= 0) {
187 /* Stores in '*un' a sockaddr_un that refers to file 'name'. Stores in
188 * '*un_len' the size of the sockaddr_un. */
190 make_sockaddr_un(const char *name
, struct sockaddr_un
* un
, socklen_t
*un_len
)
192 un
->sun_family
= AF_UNIX
;
193 strncpy(un
->sun_path
, name
, sizeof un
->sun_path
);
194 un
->sun_path
[sizeof un
->sun_path
- 1] = '\0';
195 *un_len
= (offsetof(struct sockaddr_un
, sun_path
)
196 + strlen (un
->sun_path
) + 1);
199 /* Creates a Unix domain socket in the given 'style' (either SOCK_DGRAM or
200 * SOCK_STREAM) that is bound to '*bind_path' (if 'bind_path' is non-null) and
201 * connected to '*connect_path' (if 'connect_path' is non-null). If 'nonblock'
202 * is true, the socket is made non-blocking. If 'passcred' is true, the socket
203 * is configured to receive SCM_CREDENTIALS control messages.
205 * Returns the socket's fd if successful, otherwise a negative errno value. */
207 make_unix_socket(int style
, bool nonblock
, bool passcred OVS_UNUSED
,
208 const char *bind_path
, const char *connect_path
)
213 fd
= socket(PF_UNIX
, style
, 0);
218 /* Set nonblocking mode right away, if we want it. This prevents blocking
219 * in connect(), if connect_path != NULL. (In turn, that's a corner case:
220 * it will only happen if style is SOCK_STREAM or SOCK_SEQPACKET, and only
221 * if a backlog of un-accepted connections has built up in the kernel.) */
223 int flags
= fcntl(fd
, F_GETFL
, 0);
227 if (fcntl(fd
, F_SETFL
, flags
| O_NONBLOCK
) == -1) {
233 struct sockaddr_un un
;
235 make_sockaddr_un(bind_path
, &un
, &un_len
);
236 if (unlink(un
.sun_path
) && errno
!= ENOENT
) {
237 VLOG_WARN("unlinking \"%s\": %s\n", un
.sun_path
, strerror(errno
));
239 fatal_signal_add_file_to_unlink(bind_path
);
240 if (bind(fd
, (struct sockaddr
*) &un
, un_len
)
241 || fchmod(fd
, S_IRWXU
)) {
247 struct sockaddr_un un
;
249 make_sockaddr_un(connect_path
, &un
, &un_len
);
250 if (connect(fd
, (struct sockaddr
*) &un
, un_len
)
251 && errno
!= EINPROGRESS
) {
252 printf("connect failed with %s\n", strerror(errno
));
257 #ifdef SCM_CREDENTIALS
260 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSCRED
, &enable
, sizeof(enable
))) {
269 error
= errno
== EAGAIN
? EPROTO
: errno
;
271 fatal_signal_remove_file_to_unlink(bind_path
);
278 get_unix_name_len(socklen_t sun_len
)
280 return (sun_len
>= offsetof(struct sockaddr_un
, sun_path
)
281 ? sun_len
- offsetof(struct sockaddr_un
, sun_path
)
286 guess_netmask(uint32_t ip
)
289 return ((ip
>> 31) == 0 ? htonl(0xff000000) /* Class A */
290 : (ip
>> 30) == 2 ? htonl(0xffff0000) /* Class B */
291 : (ip
>> 29) == 6 ? htonl(0xffffff00) /* Class C */
292 : htonl(0)); /* ??? */
295 /* Opens a non-blocking IPv4 socket of the specified 'style' and connects to
296 * 'target', which should be a string in the format "<host>[:<port>]". <host>
297 * is required. If 'default_port' is nonzero then <port> is optional and
298 * defaults to 'default_port'.
300 * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
302 * On success, returns 0 (indicating connection complete) or EAGAIN (indicating
303 * connection in progress), in which case the new file descriptor is stored
304 * into '*fdp'. On failure, returns a positive errno value other than EAGAIN
305 * and stores -1 into '*fdp'.
307 * If 'sinp' is non-null, then on success the target address is stored into
310 inet_open_active(int style
, const char *target_
, uint16_t default_port
,
311 struct sockaddr_in
*sinp
, int *fdp
)
313 char *target
= xstrdup(target_
);
314 char *save_ptr
= NULL
;
315 const char *host_name
;
316 const char *port_string
;
317 struct sockaddr_in sin
;
322 memset(&sin
, 0, sizeof sin
);
323 sin
.sin_family
= AF_INET
;
324 sin
.sin_port
= htons(default_port
);
327 host_name
= strtok_r(target
, ":", &save_ptr
);
328 port_string
= strtok_r(NULL
, ":", &save_ptr
);
330 ovs_error(0, "%s: bad peer name format", target_
);
331 error
= EAFNOSUPPORT
;
335 /* Look up IP, port. */
336 error
= lookup_ip(host_name
, &sin
.sin_addr
);
340 if (port_string
&& atoi(port_string
)) {
341 sin
.sin_port
= htons(atoi(port_string
));
342 } else if (!default_port
) {
343 VLOG_ERR("%s: port number must be specified", target_
);
344 error
= EAFNOSUPPORT
;
348 /* Create non-blocking socket. */
349 fd
= socket(AF_INET
, style
, 0);
351 VLOG_ERR("%s: socket: %s", target_
, strerror(errno
));
355 error
= set_nonblocking(fd
);
361 error
= connect(fd
, (struct sockaddr
*) &sin
, sizeof sin
) == 0 ? 0 : errno
;
362 if (error
== EINPROGRESS
) {
364 } else if (error
&& error
!= EAGAIN
) {
368 /* Success: error is 0 or EAGAIN. */
374 if (!error
|| error
== EAGAIN
) {
386 /* Opens a non-blocking IPv4 socket of the specified 'style', binds to
387 * 'target', and listens for incoming connections. 'target' should be a string
388 * in the format "[<port>][:<ip>]":
390 * - If 'default_port' is -1, then <port> is required. Otherwise, if
391 * <port> is omitted, then 'default_port' is used instead.
393 * - If <port> (or 'default_port', if used) is 0, then no port is bound
394 * and the TCP/IP stack will select a port.
396 * - If <ip> is omitted then the IP address is wildcarded.
398 * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
400 * For TCP, the socket will have SO_REUSEADDR turned on.
402 * On success, returns a non-negative file descriptor. On failure, returns a
403 * negative errno value.
405 * If 'sinp' is non-null, then on success the bound address is stored into
408 inet_open_passive(int style
, const char *target_
, int default_port
,
409 struct sockaddr_in
*sinp
)
411 char *target
= xstrdup(target_
);
412 char *string_ptr
= target
;
413 struct sockaddr_in sin
;
414 const char *host_name
;
415 const char *port_string
;
417 unsigned int yes
= 1;
419 /* Address defaults. */
420 memset(&sin
, 0, sizeof sin
);
421 sin
.sin_family
= AF_INET
;
422 sin
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
423 sin
.sin_port
= htons(default_port
);
425 /* Parse optional port number. */
426 port_string
= strsep(&string_ptr
, ":");
427 if (port_string
&& str_to_int(port_string
, 10, &port
)) {
428 sin
.sin_port
= htons(port
);
429 } else if (default_port
< 0) {
430 VLOG_ERR("%s: port number must be specified", target_
);
431 error
= EAFNOSUPPORT
;
435 /* Parse optional bind IP. */
436 host_name
= strsep(&string_ptr
, ":");
437 if (host_name
&& host_name
[0]) {
438 error
= lookup_ip(host_name
, &sin
.sin_addr
);
444 /* Create non-blocking socket, set SO_REUSEADDR. */
445 fd
= socket(AF_INET
, style
, 0);
448 VLOG_ERR("%s: socket: %s", target_
, strerror(error
));
451 error
= set_nonblocking(fd
);
455 if (style
== SOCK_STREAM
456 && setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &yes
, sizeof yes
) < 0) {
458 VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target_
, strerror(error
));
463 if (bind(fd
, (struct sockaddr
*) &sin
, sizeof sin
) < 0) {
465 VLOG_ERR("%s: bind: %s", target_
, strerror(error
));
470 if (listen(fd
, 10) < 0) {
472 VLOG_ERR("%s: listen: %s", target_
, strerror(error
));
477 socklen_t sin_len
= sizeof sin
;
478 if (getsockname(fd
, (struct sockaddr
*) &sin
, &sin_len
) < 0){
480 VLOG_ERR("%s: getsockname: %s", target_
, strerror(error
));
483 if (sin
.sin_family
!= AF_INET
|| sin_len
!= sizeof sin
) {
484 VLOG_ERR("%s: getsockname: invalid socket name", target_
);
497 return error
? -error
: fd
;
500 /* Returns a readable and writable fd for /dev/null, if successful, otherwise
501 * a negative errno value. The caller must not close the returned fd (because
502 * the same fd will be handed out to subsequent callers). */
506 static int null_fd
= -1;
508 null_fd
= open("/dev/null", O_RDWR
);
511 VLOG_ERR("could not open /dev/null: %s", strerror(error
));
519 read_fully(int fd
, void *p_
, size_t size
, size_t *bytes_read
)
525 ssize_t retval
= read(fd
, p
, size
);
527 *bytes_read
+= retval
;
530 } else if (retval
== 0) {
532 } else if (errno
!= EINTR
) {
540 write_fully(int fd
, const void *p_
, size_t size
, size_t *bytes_written
)
542 const uint8_t *p
= p_
;
546 ssize_t retval
= write(fd
, p
, size
);
548 *bytes_written
+= retval
;
551 } else if (retval
== 0) {
552 VLOG_WARN("write returned 0");
554 } else if (errno
!= EINTR
) {
561 /* Given file name 'file_name', fsyncs the directory in which it is contained.
562 * Returns 0 if successful, otherwise a positive errno value. */
564 fsync_parent_dir(const char *file_name
)
570 dir
= dir_name(file_name
);
571 fd
= open(dir
, O_RDONLY
);
574 if (errno
== EINVAL
|| errno
== EROFS
) {
575 /* This directory does not support synchronization. Not
576 * really an error. */
579 VLOG_ERR("%s: fsync failed (%s)", dir
, strerror(error
));
585 VLOG_ERR("%s: open failed (%s)", dir
, strerror(error
));