]>
git.proxmox.com Git - mirror_ovs.git/blob - lib/socket-util.c
2 * Copyright (c) 2008, 2009 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 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
) {
256 #ifdef SCM_CREDENTIALS
259 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSCRED
, &enable
, sizeof(enable
))) {
269 fatal_signal_remove_file_to_unlink(bind_path
);
277 get_unix_name_len(socklen_t sun_len
)
279 return (sun_len
>= offsetof(struct sockaddr_un
, sun_path
)
280 ? sun_len
- offsetof(struct sockaddr_un
, sun_path
)
285 guess_netmask(uint32_t ip
)
288 return ((ip
>> 31) == 0 ? htonl(0xff000000) /* Class A */
289 : (ip
>> 30) == 2 ? htonl(0xffff0000) /* Class B */
290 : (ip
>> 29) == 6 ? htonl(0xffffff00) /* Class C */
291 : htonl(0)); /* ??? */
294 /* Opens a non-blocking IPv4 socket of the specified 'style' and connects to
295 * 'target', which should be a string in the format "<host>[:<port>]". <host>
296 * is required. If 'default_port' is nonzero then <port> is optional and
297 * defaults to 'default_port'.
299 * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
301 * On success, returns 0 (indicating connection complete) or EAGAIN (indicating
302 * connection in progress), in which case the new file descriptor is stored
303 * into '*fdp'. On failure, returns a positive errno value other than EAGAIN
304 * and stores -1 into '*fdp'.
306 * If 'sinp' is non-null, then on success the target address is stored into
309 inet_open_active(int style
, const char *target_
, uint16_t default_port
,
310 struct sockaddr_in
*sinp
, int *fdp
)
312 char *target
= xstrdup(target_
);
313 char *save_ptr
= NULL
;
314 const char *host_name
;
315 const char *port_string
;
316 struct sockaddr_in sin
;
321 memset(&sin
, 0, sizeof sin
);
322 sin
.sin_family
= AF_INET
;
323 sin
.sin_port
= htons(default_port
);
326 host_name
= strtok_r(target
, ":", &save_ptr
);
327 port_string
= strtok_r(NULL
, ":", &save_ptr
);
329 ovs_error(0, "%s: bad peer name format", target_
);
330 error
= EAFNOSUPPORT
;
334 /* Look up IP, port. */
335 error
= lookup_ip(host_name
, &sin
.sin_addr
);
339 if (port_string
&& atoi(port_string
)) {
340 sin
.sin_port
= htons(atoi(port_string
));
341 } else if (!default_port
) {
342 VLOG_ERR("%s: port number must be specified", target_
);
343 error
= EAFNOSUPPORT
;
347 /* Create non-blocking socket. */
348 fd
= socket(AF_INET
, style
, 0);
350 VLOG_ERR("%s: socket: %s", target_
, strerror(errno
));
354 error
= set_nonblocking(fd
);
360 error
= connect(fd
, (struct sockaddr
*) &sin
, sizeof sin
) == 0 ? 0 : errno
;
361 if (error
== EINPROGRESS
) {
363 } else if (error
&& error
!= EAGAIN
) {
367 /* Success: error is 0 or EAGAIN. */
373 if (!error
|| error
== EAGAIN
) {
385 /* Opens a non-blocking IPv4 socket of the specified 'style', binds to
386 * 'target', and listens for incoming connections. 'target' should be a string
387 * in the format "[<port>][:<ip>]". <port> may be omitted if 'default_port' is
388 * nonzero, in which case it defaults to 'default_port'. If <ip> is omitted it
389 * defaults to the wildcard IP address.
391 * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
393 * For TCP, the socket will have SO_REUSEADDR turned on.
395 * On success, returns a non-negative file descriptor. On failure, returns a
396 * negative errno value. */
398 inet_open_passive(int style
, const char *target_
, uint16_t default_port
)
400 char *target
= xstrdup(target_
);
401 char *string_ptr
= target
;
402 struct sockaddr_in sin
;
403 const char *host_name
;
404 const char *port_string
;
406 unsigned int yes
= 1;
408 /* Address defaults. */
409 memset(&sin
, 0, sizeof sin
);
410 sin
.sin_family
= AF_INET
;
411 sin
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
412 sin
.sin_port
= htons(default_port
);
414 /* Parse optional port number. */
415 port_string
= strsep(&string_ptr
, ":");
416 if (port_string
&& atoi(port_string
)) {
417 sin
.sin_port
= htons(atoi(port_string
));
418 } else if (!default_port
) {
419 VLOG_ERR("%s: port number must be specified", target_
);
420 error
= EAFNOSUPPORT
;
424 /* Parse optional bind IP. */
425 host_name
= strsep(&string_ptr
, ":");
426 if (host_name
&& host_name
[0]) {
427 error
= lookup_ip(host_name
, &sin
.sin_addr
);
433 /* Create non-blocking socket, set SO_REUSEADDR. */
434 fd
= socket(AF_INET
, style
, 0);
437 VLOG_ERR("%s: socket: %s", target_
, strerror(error
));
440 error
= set_nonblocking(fd
);
444 if (style
== SOCK_STREAM
445 && setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &yes
, sizeof yes
) < 0) {
447 VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target_
, strerror(error
));
452 if (bind(fd
, (struct sockaddr
*) &sin
, sizeof sin
) < 0) {
454 VLOG_ERR("%s: bind: %s", target_
, strerror(error
));
459 if (listen(fd
, 10) < 0) {
461 VLOG_ERR("%s: listen: %s", target_
, strerror(error
));
471 return error
? -error
: fd
;
474 /* Returns a readable and writable fd for /dev/null, if successful, otherwise
475 * a negative errno value. The caller must not close the returned fd (because
476 * the same fd will be handed out to subsequent callers). */
480 static int null_fd
= -1;
482 null_fd
= open("/dev/null", O_RDWR
);
485 VLOG_ERR("could not open /dev/null: %s", strerror(error
));
493 read_fully(int fd
, void *p_
, size_t size
, size_t *bytes_read
)
499 ssize_t retval
= read(fd
, p
, size
);
501 *bytes_read
+= retval
;
504 } else if (retval
== 0) {
506 } else if (errno
!= EINTR
) {
514 write_fully(int fd
, const void *p_
, size_t size
, size_t *bytes_written
)
516 const uint8_t *p
= p_
;
520 ssize_t retval
= write(fd
, p
, size
);
522 *bytes_written
+= retval
;
525 } else if (retval
== 0) {
526 VLOG_WARN("write returned 0");
528 } else if (errno
!= EINTR
) {