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 "net/socket.h"
26 #include "config-host.h"
29 #include "qemu-char.h"
30 #include "qemu-common.h"
31 #include "qemu-error.h"
32 #include "qemu-option.h"
33 #include "qemu_socket.h"
35 typedef struct NetSocketState
{
38 int state
; /* 0 = getting length, 1 = getting data */
40 unsigned int packet_len
;
42 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
45 typedef struct NetSocketListenState
{
50 } NetSocketListenState
;
52 /* XXX: we consider we can send the whole packet without blocking */
53 static ssize_t
net_socket_receive(VLANClientState
*nc
, const uint8_t *buf
, size_t size
)
55 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
59 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
60 return send_all(s
->fd
, buf
, size
);
63 static ssize_t
net_socket_receive_dgram(VLANClientState
*nc
, const uint8_t *buf
, size_t size
)
65 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
67 return sendto(s
->fd
, (const void *)buf
, size
, 0,
68 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
71 static void net_socket_send(void *opaque
)
73 NetSocketState
*s
= opaque
;
79 size
= qemu_recv(s
->fd
, buf1
, sizeof(buf1
), 0);
82 if (err
!= EWOULDBLOCK
)
84 } else if (size
== 0) {
85 /* end of connection */
87 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
93 /* reassemble a packet from the network */
99 memcpy(s
->buf
+ s
->index
, buf
, l
);
105 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
111 l
= s
->packet_len
- s
->index
;
114 if (s
->index
+ l
<= sizeof(s
->buf
)) {
115 memcpy(s
->buf
+ s
->index
, buf
, l
);
117 fprintf(stderr
, "serious error: oversized packet received,"
118 "connection terminated.\n");
126 if (s
->index
>= s
->packet_len
) {
127 qemu_send_packet(&s
->nc
, s
->buf
, s
->packet_len
);
136 static void net_socket_send_dgram(void *opaque
)
138 NetSocketState
*s
= opaque
;
141 size
= qemu_recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
145 /* end of connection */
146 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
149 qemu_send_packet(&s
->nc
, s
->buf
, size
);
152 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
, struct in_addr
*localaddr
)
163 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
164 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) "
165 "does not contain a multicast address\n",
166 inet_ntoa(mcastaddr
->sin_addr
),
167 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
171 fd
= qemu_socket(PF_INET
, SOCK_DGRAM
, 0);
173 perror("socket(PF_INET, SOCK_DGRAM)");
178 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
179 (const char *)&val
, sizeof(val
));
181 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
185 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
191 /* Add host to multicast group */
192 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
194 imr
.imr_interface
= *localaddr
;
196 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
199 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
200 (const char *)&imr
, sizeof(struct ip_mreq
));
202 perror("setsockopt(IP_ADD_MEMBERSHIP)");
206 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
208 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
209 (const char *)&loop
, sizeof(loop
));
211 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
215 /* If a bind address is given, only send packets from that address */
216 if (localaddr
!= NULL
) {
217 ret
= setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_IF
,
218 (const char *)localaddr
, sizeof(*localaddr
));
220 perror("setsockopt(IP_MULTICAST_IF)");
225 socket_set_nonblock(fd
);
233 static void net_socket_cleanup(VLANClientState
*nc
)
235 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
236 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
240 static NetClientInfo net_dgram_socket_info
= {
241 .type
= NET_CLIENT_TYPE_SOCKET
,
242 .size
= sizeof(NetSocketState
),
243 .receive
= net_socket_receive_dgram
,
244 .cleanup
= net_socket_cleanup
,
247 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
,
250 int fd
, int is_connected
)
252 struct sockaddr_in saddr
;
258 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
259 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
260 * by ONLY ONE process: we must "clone" this dgram socket --jjo
264 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
266 if (saddr
.sin_addr
.s_addr
== 0) {
267 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, "
268 "cannot setup multicast dst addr\n", fd
);
271 /* clone dgram socket */
272 newfd
= net_socket_mcast_create(&saddr
, NULL
);
274 /* error already reported by net_socket_mcast_create() */
278 /* clone newfd to fd, close newfd */
284 "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
285 fd
, strerror(errno
));
290 nc
= qemu_new_net_client(&net_dgram_socket_info
, vlan
, NULL
, model
, name
);
292 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
293 "socket: fd=%d (%s mcast=%s:%d)",
294 fd
, is_connected
? "cloned" : "",
295 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
297 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
301 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
303 /* mcast: save bound address as dst */
304 if (is_connected
) s
->dgram_dst
=saddr
;
309 static void net_socket_connect(void *opaque
)
311 NetSocketState
*s
= opaque
;
312 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
315 static NetClientInfo net_socket_info
= {
316 .type
= NET_CLIENT_TYPE_SOCKET
,
317 .size
= sizeof(NetSocketState
),
318 .receive
= net_socket_receive
,
319 .cleanup
= net_socket_cleanup
,
322 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
,
325 int fd
, int is_connected
)
330 nc
= qemu_new_net_client(&net_socket_info
, vlan
, NULL
, model
, name
);
332 snprintf(nc
->info_str
, sizeof(nc
->info_str
), "socket: fd=%d", fd
);
334 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
339 net_socket_connect(s
);
341 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
346 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
,
347 const char *model
, const char *name
,
348 int fd
, int is_connected
)
350 int so_type
= -1, optlen
=sizeof(so_type
);
352 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
353 (socklen_t
*)&optlen
)< 0) {
354 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n",
360 return net_socket_fd_init_dgram(vlan
, model
, name
, fd
, is_connected
);
362 return net_socket_fd_init_stream(vlan
, model
, name
, fd
, is_connected
);
364 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
365 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
366 return net_socket_fd_init_stream(vlan
, model
, name
, fd
, is_connected
);
371 static void net_socket_accept(void *opaque
)
373 NetSocketListenState
*s
= opaque
;
375 struct sockaddr_in saddr
;
381 fd
= qemu_accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
382 if (fd
< 0 && errno
!= EINTR
) {
384 } else if (fd
>= 0) {
388 s1
= net_socket_fd_init(s
->vlan
, s
->model
, s
->name
, fd
, 1);
392 snprintf(s1
->nc
.info_str
, sizeof(s1
->nc
.info_str
),
393 "socket: connection from %s:%d",
394 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
398 static int net_socket_listen_init(VLANState
*vlan
,
401 const char *host_str
)
403 NetSocketListenState
*s
;
405 struct sockaddr_in saddr
;
407 if (parse_host_port(&saddr
, host_str
) < 0)
410 s
= g_malloc0(sizeof(NetSocketListenState
));
412 fd
= qemu_socket(PF_INET
, SOCK_STREAM
, 0);
417 socket_set_nonblock(fd
);
419 /* allow fast reuse */
421 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
423 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
434 s
->model
= g_strdup(model
);
435 s
->name
= name
? g_strdup(name
) : NULL
;
437 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
441 static int net_socket_connect_init(VLANState
*vlan
,
444 const char *host_str
)
447 int fd
, connected
, ret
, err
;
448 struct sockaddr_in saddr
;
450 if (parse_host_port(&saddr
, host_str
) < 0)
453 fd
= qemu_socket(PF_INET
, SOCK_STREAM
, 0);
458 socket_set_nonblock(fd
);
462 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
464 err
= socket_error();
465 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
466 } else if (err
== EINPROGRESS
) {
469 } else if (err
== WSAEALREADY
|| err
== WSAEINVAL
) {
482 s
= net_socket_fd_init(vlan
, model
, name
, fd
, connected
);
485 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
),
486 "socket: connect to %s:%d",
487 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
491 static int net_socket_mcast_init(VLANState
*vlan
,
494 const char *host_str
,
495 const char *localaddr_str
)
499 struct sockaddr_in saddr
;
500 struct in_addr localaddr
, *param_localaddr
;
502 if (parse_host_port(&saddr
, host_str
) < 0)
505 if (localaddr_str
!= NULL
) {
506 if (inet_aton(localaddr_str
, &localaddr
) == 0)
508 param_localaddr
= &localaddr
;
510 param_localaddr
= NULL
;
513 fd
= net_socket_mcast_create(&saddr
, param_localaddr
);
517 s
= net_socket_fd_init(vlan
, model
, name
, fd
, 0);
521 s
->dgram_dst
= saddr
;
523 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
),
524 "socket: mcast=%s:%d",
525 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
530 int net_init_socket(QemuOpts
*opts
,
535 if (qemu_opt_get(opts
, "fd")) {
538 if (qemu_opt_get(opts
, "listen") ||
539 qemu_opt_get(opts
, "connect") ||
540 qemu_opt_get(opts
, "mcast") ||
541 qemu_opt_get(opts
, "localaddr")) {
542 error_report("listen=, connect=, mcast= and localaddr= is invalid with fd=");
546 fd
= net_handle_fd_param(mon
, qemu_opt_get(opts
, "fd"));
551 if (!net_socket_fd_init(vlan
, "socket", name
, fd
, 1)) {
555 } else if (qemu_opt_get(opts
, "listen")) {
558 if (qemu_opt_get(opts
, "fd") ||
559 qemu_opt_get(opts
, "connect") ||
560 qemu_opt_get(opts
, "mcast") ||
561 qemu_opt_get(opts
, "localaddr")) {
562 error_report("fd=, connect=, mcast= and localaddr= is invalid with listen=");
566 listen
= qemu_opt_get(opts
, "listen");
568 if (net_socket_listen_init(vlan
, "socket", name
, listen
) == -1) {
571 } else if (qemu_opt_get(opts
, "connect")) {
574 if (qemu_opt_get(opts
, "fd") ||
575 qemu_opt_get(opts
, "listen") ||
576 qemu_opt_get(opts
, "mcast") ||
577 qemu_opt_get(opts
, "localaddr")) {
578 error_report("fd=, listen=, mcast= and localaddr= is invalid with connect=");
582 connect
= qemu_opt_get(opts
, "connect");
584 if (net_socket_connect_init(vlan
, "socket", name
, connect
) == -1) {
587 } else if (qemu_opt_get(opts
, "mcast")) {
588 const char *mcast
, *localaddr
;
590 if (qemu_opt_get(opts
, "fd") ||
591 qemu_opt_get(opts
, "connect") ||
592 qemu_opt_get(opts
, "listen")) {
593 error_report("fd=, connect= and listen= is invalid with mcast=");
597 mcast
= qemu_opt_get(opts
, "mcast");
598 localaddr
= qemu_opt_get(opts
, "localaddr");
600 if (net_socket_mcast_init(vlan
, "socket", name
, mcast
, localaddr
) == -1) {
604 error_report("-socket requires fd=, listen=, connect= or mcast=");