4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
28 #include "monitor/monitor.h"
29 #include "qapi/error.h"
30 #include "qemu/error-report.h"
31 #include "qemu/option.h"
32 #include "qemu/sockets.h"
34 #include "qemu/main-loop.h"
36 typedef struct NetSocketState
{
41 unsigned int send_index
; /* number of bytes sent (only SOCK_STREAM) */
42 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
43 IOHandler
*send_fn
; /* differs between SOCK_STREAM/SOCK_DGRAM */
44 bool read_poll
; /* waiting to receive data? */
45 bool write_poll
; /* waiting to transmit data? */
48 static void net_socket_accept(void *opaque
);
49 static void net_socket_writable(void *opaque
);
51 static void net_socket_update_fd_handler(NetSocketState
*s
)
53 qemu_set_fd_handler(s
->fd
,
54 s
->read_poll
? s
->send_fn
: NULL
,
55 s
->write_poll
? net_socket_writable
: NULL
,
59 static void net_socket_read_poll(NetSocketState
*s
, bool enable
)
61 s
->read_poll
= enable
;
62 net_socket_update_fd_handler(s
);
65 static void net_socket_write_poll(NetSocketState
*s
, bool enable
)
67 s
->write_poll
= enable
;
68 net_socket_update_fd_handler(s
);
71 static void net_socket_writable(void *opaque
)
73 NetSocketState
*s
= opaque
;
75 net_socket_write_poll(s
, false);
77 qemu_flush_queued_packets(&s
->nc
);
80 static ssize_t
net_socket_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
82 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
83 uint32_t len
= htonl(size
);
84 struct iovec iov
[] = {
87 .iov_len
= sizeof(len
),
89 .iov_base
= (void *)buf
,
96 remaining
= iov_size(iov
, 2) - s
->send_index
;
97 ret
= iov_send(s
->fd
, iov
, 2, s
->send_index
, remaining
);
99 if (ret
== -1 && errno
== EAGAIN
) {
100 ret
= 0; /* handled further down */
106 if (ret
< (ssize_t
)remaining
) {
107 s
->send_index
+= ret
;
108 net_socket_write_poll(s
, true);
115 static ssize_t
net_socket_receive_dgram(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
117 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
121 if (s
->dgram_dst
.sin_family
!= AF_UNIX
) {
122 ret
= sendto(s
->fd
, buf
, size
, 0,
123 (struct sockaddr
*)&s
->dgram_dst
,
124 sizeof(s
->dgram_dst
));
126 ret
= send(s
->fd
, buf
, size
, 0);
128 } while (ret
== -1 && errno
== EINTR
);
130 if (ret
== -1 && errno
== EAGAIN
) {
131 net_socket_write_poll(s
, true);
137 static void net_socket_send_completed(NetClientState
*nc
, ssize_t len
)
139 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
142 net_socket_read_poll(s
, true);
146 static void net_socket_rs_finalize(SocketReadState
*rs
)
148 NetSocketState
*s
= container_of(rs
, NetSocketState
, rs
);
150 if (qemu_send_packet_async(&s
->nc
, rs
->buf
,
152 net_socket_send_completed
) == 0) {
153 net_socket_read_poll(s
, false);
157 static void net_socket_send(void *opaque
)
159 NetSocketState
*s
= opaque
;
162 uint8_t buf1
[NET_BUFSIZE
];
165 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
167 if (errno
!= EWOULDBLOCK
)
169 } else if (size
== 0) {
170 /* end of connection */
172 net_socket_read_poll(s
, false);
173 net_socket_write_poll(s
, false);
174 if (s
->listen_fd
!= -1) {
175 qemu_set_fd_handler(s
->listen_fd
, net_socket_accept
, NULL
, s
);
180 net_socket_rs_init(&s
->rs
, net_socket_rs_finalize
, false);
181 s
->nc
.link_down
= true;
182 qemu_set_info_str(&s
->nc
, "%s", "");
188 ret
= net_fill_rstate(&s
->rs
, buf
, size
);
195 static void net_socket_send_dgram(void *opaque
)
197 NetSocketState
*s
= opaque
;
200 size
= recv(s
->fd
, s
->rs
.buf
, sizeof(s
->rs
.buf
), 0);
204 /* end of connection */
205 net_socket_read_poll(s
, false);
206 net_socket_write_poll(s
, false);
209 if (qemu_send_packet_async(&s
->nc
, s
->rs
.buf
, size
,
210 net_socket_send_completed
) == 0) {
211 net_socket_read_poll(s
, false);
215 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
,
216 struct in_addr
*localaddr
,
228 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
229 error_setg(errp
, "specified mcastaddr %s (0x%08x) "
230 "does not contain a multicast address",
231 inet_ntoa(mcastaddr
->sin_addr
),
232 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
236 fd
= qemu_socket(PF_INET
, SOCK_DGRAM
, 0);
238 error_setg_errno(errp
, errno
, "can't create datagram socket");
242 /* Allow multiple sockets to bind the same multicast ip and port by setting
243 * SO_REUSEADDR. This is the only situation where SO_REUSEADDR should be set
244 * on windows. Use socket_set_fast_reuse otherwise as it sets SO_REUSEADDR
245 * only on posix systems.
248 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &val
, sizeof(val
));
250 error_setg_errno(errp
, errno
,
251 "can't set socket option SO_REUSEADDR");
255 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
257 error_setg_errno(errp
, errno
, "can't bind ip=%s to socket",
258 inet_ntoa(mcastaddr
->sin_addr
));
262 /* Add host to multicast group */
263 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
265 imr
.imr_interface
= *localaddr
;
267 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
270 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
271 &imr
, sizeof(struct ip_mreq
));
273 error_setg_errno(errp
, errno
,
274 "can't add socket to multicast group %s",
275 inet_ntoa(imr
.imr_multiaddr
));
279 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
281 ret
= setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
282 &loop
, sizeof(loop
));
284 error_setg_errno(errp
, errno
,
285 "can't force multicast message to loopback");
289 /* If a bind address is given, only send packets from that address */
290 if (localaddr
!= NULL
) {
291 ret
= setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_IF
,
292 localaddr
, sizeof(*localaddr
));
294 error_setg_errno(errp
, errno
,
295 "can't set the default network send interface");
300 qemu_socket_set_nonblock(fd
);
308 static void net_socket_cleanup(NetClientState
*nc
)
310 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
312 net_socket_read_poll(s
, false);
313 net_socket_write_poll(s
, false);
317 if (s
->listen_fd
!= -1) {
318 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
319 closesocket(s
->listen_fd
);
324 static NetClientInfo net_dgram_socket_info
= {
325 .type
= NET_CLIENT_DRIVER_SOCKET
,
326 .size
= sizeof(NetSocketState
),
327 .receive
= net_socket_receive_dgram
,
328 .cleanup
= net_socket_cleanup
,
331 static NetSocketState
*net_socket_fd_init_dgram(NetClientState
*peer
,
334 int fd
, int is_connected
,
338 struct sockaddr_in saddr
;
343 SocketAddressType sa_type
;
345 sa
= socket_local_address(fd
, errp
);
350 qapi_free_SocketAddress(sa
);
352 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
353 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
354 * by ONLY ONE process: we must "clone" this dgram socket --jjo
357 if (is_connected
&& mcast
!= NULL
) {
358 if (parse_host_port(&saddr
, mcast
, errp
) < 0) {
362 if (saddr
.sin_addr
.s_addr
== 0) {
363 error_setg(errp
, "can't setup multicast destination address");
366 /* clone dgram socket */
367 newfd
= net_socket_mcast_create(&saddr
, NULL
, errp
);
371 /* clone newfd to fd, close newfd */
377 nc
= qemu_new_net_client(&net_dgram_socket_info
, peer
, model
, name
);
379 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
383 s
->send_fn
= net_socket_send_dgram
;
384 net_socket_rs_init(&s
->rs
, net_socket_rs_finalize
, false);
385 net_socket_read_poll(s
, true);
387 /* mcast: save bound address as dst */
388 if (is_connected
&& mcast
!= NULL
) {
389 s
->dgram_dst
= saddr
;
390 qemu_set_info_str(nc
, "socket: fd=%d (cloned mcast=%s:%d)", fd
,
391 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
393 if (sa_type
== SOCKET_ADDRESS_TYPE_UNIX
) {
394 s
->dgram_dst
.sin_family
= AF_UNIX
;
397 qemu_set_info_str(nc
, "socket: fd=%d %s", fd
,
398 SocketAddressType_str(sa_type
));
408 static void net_socket_connect(void *opaque
)
410 NetSocketState
*s
= opaque
;
411 s
->send_fn
= net_socket_send
;
412 net_socket_read_poll(s
, true);
415 static NetClientInfo net_socket_info
= {
416 .type
= NET_CLIENT_DRIVER_SOCKET
,
417 .size
= sizeof(NetSocketState
),
418 .receive
= net_socket_receive
,
419 .cleanup
= net_socket_cleanup
,
422 static NetSocketState
*net_socket_fd_init_stream(NetClientState
*peer
,
425 int fd
, int is_connected
)
430 nc
= qemu_new_net_client(&net_socket_info
, peer
, model
, name
);
432 qemu_set_info_str(nc
, "socket: fd=%d", fd
);
434 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
438 net_socket_rs_init(&s
->rs
, net_socket_rs_finalize
, false);
440 /* Disable Nagle algorithm on TCP sockets to reduce latency */
441 socket_set_nodelay(fd
);
444 net_socket_connect(s
);
446 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
451 static NetSocketState
*net_socket_fd_init(NetClientState
*peer
,
452 const char *model
, const char *name
,
453 int fd
, int is_connected
,
454 const char *mc
, Error
**errp
)
456 int so_type
= -1, optlen
=sizeof(so_type
);
458 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
459 (socklen_t
*)&optlen
)< 0) {
460 error_setg(errp
, "can't get socket option SO_TYPE");
466 return net_socket_fd_init_dgram(peer
, model
, name
, fd
, is_connected
,
469 return net_socket_fd_init_stream(peer
, model
, name
, fd
, is_connected
);
471 error_setg(errp
, "socket type=%d for fd=%d must be either"
472 " SOCK_DGRAM or SOCK_STREAM", so_type
, fd
);
478 static void net_socket_accept(void *opaque
)
480 NetSocketState
*s
= opaque
;
481 struct sockaddr_in saddr
;
487 fd
= qemu_accept(s
->listen_fd
, (struct sockaddr
*)&saddr
, &len
);
488 if (fd
< 0 && errno
!= EINTR
) {
490 } else if (fd
>= 0) {
491 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
497 s
->nc
.link_down
= false;
498 net_socket_connect(s
);
499 qemu_set_info_str(&s
->nc
, "socket: connection from %s:%d",
500 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
503 static int net_socket_listen_init(NetClientState
*peer
,
506 const char *host_str
,
511 struct sockaddr_in saddr
;
514 if (parse_host_port(&saddr
, host_str
, errp
) < 0) {
518 fd
= qemu_socket(PF_INET
, SOCK_STREAM
, 0);
520 error_setg_errno(errp
, errno
, "can't create stream socket");
523 qemu_socket_set_nonblock(fd
);
525 socket_set_fast_reuse(fd
);
527 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
529 error_setg_errno(errp
, errno
, "can't bind ip=%s to socket",
530 inet_ntoa(saddr
.sin_addr
));
536 error_setg_errno(errp
, errno
, "can't listen on socket");
541 nc
= qemu_new_net_client(&net_socket_info
, peer
, model
, name
);
542 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
545 s
->nc
.link_down
= true;
546 net_socket_rs_init(&s
->rs
, net_socket_rs_finalize
, false);
548 qemu_set_fd_handler(s
->listen_fd
, net_socket_accept
, NULL
, s
);
552 static int net_socket_connect_init(NetClientState
*peer
,
555 const char *host_str
,
559 int fd
, connected
, ret
;
560 struct sockaddr_in saddr
;
562 if (parse_host_port(&saddr
, host_str
, errp
) < 0) {
566 fd
= qemu_socket(PF_INET
, SOCK_STREAM
, 0);
568 error_setg_errno(errp
, errno
, "can't create stream socket");
571 qemu_socket_set_nonblock(fd
);
575 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
577 if (errno
== EINTR
|| errno
== EWOULDBLOCK
) {
579 } else if (errno
== EINPROGRESS
||
583 error_setg_errno(errp
, errno
, "can't connect socket");
592 s
= net_socket_fd_init(peer
, model
, name
, fd
, connected
, NULL
, errp
);
597 qemu_set_info_str(&s
->nc
, "socket: connect to %s:%d",
598 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
602 static int net_socket_mcast_init(NetClientState
*peer
,
605 const char *host_str
,
606 const char *localaddr_str
,
611 struct sockaddr_in saddr
;
612 struct in_addr localaddr
, *param_localaddr
;
614 if (parse_host_port(&saddr
, host_str
, errp
) < 0) {
618 if (localaddr_str
!= NULL
) {
619 if (inet_aton(localaddr_str
, &localaddr
) == 0) {
620 error_setg(errp
, "localaddr '%s' is not a valid IPv4 address",
624 param_localaddr
= &localaddr
;
626 param_localaddr
= NULL
;
629 fd
= net_socket_mcast_create(&saddr
, param_localaddr
, errp
);
634 s
= net_socket_fd_init(peer
, model
, name
, fd
, 0, NULL
, errp
);
639 s
->dgram_dst
= saddr
;
641 qemu_set_info_str(&s
->nc
, "socket: mcast=%s:%d",
642 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
647 static int net_socket_udp_init(NetClientState
*peer
,
656 struct sockaddr_in laddr
, raddr
;
658 if (parse_host_port(&laddr
, lhost
, errp
) < 0) {
662 if (parse_host_port(&raddr
, rhost
, errp
) < 0) {
666 fd
= qemu_socket(PF_INET
, SOCK_DGRAM
, 0);
668 error_setg_errno(errp
, errno
, "can't create datagram socket");
672 ret
= socket_set_fast_reuse(fd
);
674 error_setg_errno(errp
, errno
,
675 "can't set socket option SO_REUSEADDR");
679 ret
= bind(fd
, (struct sockaddr
*)&laddr
, sizeof(laddr
));
681 error_setg_errno(errp
, errno
, "can't bind ip=%s to socket",
682 inet_ntoa(laddr
.sin_addr
));
686 qemu_socket_set_nonblock(fd
);
688 s
= net_socket_fd_init(peer
, model
, name
, fd
, 0, NULL
, errp
);
693 s
->dgram_dst
= raddr
;
695 qemu_set_info_str(&s
->nc
, "socket: udp=%s:%d", inet_ntoa(raddr
.sin_addr
),
696 ntohs(raddr
.sin_port
));
700 int net_init_socket(const Netdev
*netdev
, const char *name
,
701 NetClientState
*peer
, Error
**errp
)
703 const NetdevSocketOptions
*sock
;
705 assert(netdev
->type
== NET_CLIENT_DRIVER_SOCKET
);
706 sock
= &netdev
->u
.socket
;
708 if (!!sock
->fd
+ !!sock
->listen
+ !!sock
->connect
+ !!sock
->mcast
+
710 error_setg(errp
, "exactly one of listen=, connect=, mcast= or udp="
715 if (sock
->localaddr
&& !sock
->mcast
&& !sock
->udp
) {
716 error_setg(errp
, "localaddr= is only valid with mcast= or udp=");
723 fd
= monitor_fd_param(monitor_cur(), sock
->fd
, errp
);
727 ret
= qemu_socket_try_set_nonblock(fd
);
729 error_setg_errno(errp
, -ret
, "%s: Can't use file descriptor %d",
733 if (!net_socket_fd_init(peer
, "socket", name
, fd
, 1, sock
->mcast
,
741 if (net_socket_listen_init(peer
, "socket", name
, sock
->listen
, errp
)
749 if (net_socket_connect_init(peer
, "socket", name
, sock
->connect
, errp
)
757 /* if sock->localaddr is missing, it has been initialized to "all bits
759 if (net_socket_mcast_init(peer
, "socket", name
, sock
->mcast
,
760 sock
->localaddr
, errp
) < 0) {
767 if (!sock
->localaddr
) {
768 error_setg(errp
, "localaddr= is mandatory with udp=");
771 if (net_socket_udp_init(peer
, "socket", name
, sock
->udp
, sock
->localaddr
,