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
= recv(s
->fd
, (void *)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
= recv(s
->fd
, (void *)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
)
157 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
158 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
159 inet_ntoa(mcastaddr
->sin_addr
),
160 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
164 fd
= qemu_socket(PF_INET
, SOCK_DGRAM
, 0);
166 perror("socket(PF_INET, SOCK_DGRAM)");
171 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
172 (const char *)&val
, sizeof(val
));
174 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
178 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
184 /* Add host to multicast group */
185 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
187 imr
.imr_interface
= *localaddr
;
189 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
192 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
193 (const char *)&imr
, sizeof(struct ip_mreq
));
195 perror("setsockopt(IP_ADD_MEMBERSHIP)");
199 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
201 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
202 (const char *)&val
, sizeof(val
));
204 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
208 /* If a bind address is given, only send packets from that address */
209 if (localaddr
!= NULL
) {
210 ret
= setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_IF
, localaddr
, sizeof(*localaddr
));
212 perror("setsockopt(IP_MULTICAST_IF)");
217 socket_set_nonblock(fd
);
225 static void net_socket_cleanup(VLANClientState
*nc
)
227 NetSocketState
*s
= DO_UPCAST(NetSocketState
, nc
, nc
);
228 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
232 static NetClientInfo net_dgram_socket_info
= {
233 .type
= NET_CLIENT_TYPE_SOCKET
,
234 .size
= sizeof(NetSocketState
),
235 .receive
= net_socket_receive_dgram
,
236 .cleanup
= net_socket_cleanup
,
239 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
,
242 int fd
, int is_connected
)
244 struct sockaddr_in saddr
;
250 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
251 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
252 * by ONLY ONE process: we must "clone" this dgram socket --jjo
256 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
258 if (saddr
.sin_addr
.s_addr
==0) {
259 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
263 /* clone dgram socket */
264 newfd
= net_socket_mcast_create(&saddr
, NULL
);
266 /* error already reported by net_socket_mcast_create() */
270 /* clone newfd to fd, close newfd */
275 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
276 fd
, strerror(errno
));
281 nc
= qemu_new_net_client(&net_dgram_socket_info
, vlan
, NULL
, model
, name
);
283 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
284 "socket: fd=%d (%s mcast=%s:%d)",
285 fd
, is_connected
? "cloned" : "",
286 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
288 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
292 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
294 /* mcast: save bound address as dst */
295 if (is_connected
) s
->dgram_dst
=saddr
;
300 static void net_socket_connect(void *opaque
)
302 NetSocketState
*s
= opaque
;
303 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
306 static NetClientInfo net_socket_info
= {
307 .type
= NET_CLIENT_TYPE_SOCKET
,
308 .size
= sizeof(NetSocketState
),
309 .receive
= net_socket_receive
,
310 .cleanup
= net_socket_cleanup
,
313 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
,
316 int fd
, int is_connected
)
321 nc
= qemu_new_net_client(&net_socket_info
, vlan
, NULL
, model
, name
);
323 snprintf(nc
->info_str
, sizeof(nc
->info_str
), "socket: fd=%d", fd
);
325 s
= DO_UPCAST(NetSocketState
, nc
, nc
);
330 net_socket_connect(s
);
332 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
337 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
,
338 const char *model
, const char *name
,
339 int fd
, int is_connected
)
341 int so_type
= -1, optlen
=sizeof(so_type
);
343 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
344 (socklen_t
*)&optlen
)< 0) {
345 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
350 return net_socket_fd_init_dgram(vlan
, model
, name
, fd
, is_connected
);
352 return net_socket_fd_init_stream(vlan
, model
, name
, fd
, is_connected
);
354 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
355 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
356 return net_socket_fd_init_stream(vlan
, model
, name
, fd
, is_connected
);
361 static void net_socket_accept(void *opaque
)
363 NetSocketListenState
*s
= opaque
;
365 struct sockaddr_in saddr
;
371 fd
= qemu_accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
372 if (fd
< 0 && errno
!= EINTR
) {
374 } else if (fd
>= 0) {
378 s1
= net_socket_fd_init(s
->vlan
, s
->model
, s
->name
, fd
, 1);
382 snprintf(s1
->nc
.info_str
, sizeof(s1
->nc
.info_str
),
383 "socket: connection from %s:%d",
384 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
388 static int net_socket_listen_init(VLANState
*vlan
,
391 const char *host_str
)
393 NetSocketListenState
*s
;
395 struct sockaddr_in saddr
;
397 if (parse_host_port(&saddr
, host_str
) < 0)
400 s
= qemu_mallocz(sizeof(NetSocketListenState
));
402 fd
= qemu_socket(PF_INET
, SOCK_STREAM
, 0);
407 socket_set_nonblock(fd
);
409 /* allow fast reuse */
411 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
413 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
424 s
->model
= qemu_strdup(model
);
425 s
->name
= name
? qemu_strdup(name
) : NULL
;
427 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
431 static int net_socket_connect_init(VLANState
*vlan
,
434 const char *host_str
)
437 int fd
, connected
, ret
, err
;
438 struct sockaddr_in saddr
;
440 if (parse_host_port(&saddr
, host_str
) < 0)
443 fd
= qemu_socket(PF_INET
, SOCK_STREAM
, 0);
448 socket_set_nonblock(fd
);
452 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
454 err
= socket_error();
455 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
456 } else if (err
== EINPROGRESS
) {
459 } else if (err
== WSAEALREADY
) {
472 s
= net_socket_fd_init(vlan
, model
, name
, fd
, connected
);
475 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
),
476 "socket: connect to %s:%d",
477 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
481 static int net_socket_mcast_init(VLANState
*vlan
,
484 const char *host_str
,
485 const char *localaddr_str
)
489 struct sockaddr_in saddr
;
490 struct in_addr localaddr
, *param_localaddr
;
492 if (parse_host_port(&saddr
, host_str
) < 0)
495 if (localaddr_str
!= NULL
) {
496 if (inet_aton(localaddr_str
, &localaddr
) == 0)
498 param_localaddr
= &localaddr
;
500 param_localaddr
= NULL
;
503 fd
= net_socket_mcast_create(&saddr
, param_localaddr
);
507 s
= net_socket_fd_init(vlan
, model
, name
, fd
, 0);
511 s
->dgram_dst
= saddr
;
513 snprintf(s
->nc
.info_str
, sizeof(s
->nc
.info_str
),
514 "socket: mcast=%s:%d",
515 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
520 int net_init_socket(QemuOpts
*opts
,
525 if (qemu_opt_get(opts
, "fd")) {
528 if (qemu_opt_get(opts
, "listen") ||
529 qemu_opt_get(opts
, "connect") ||
530 qemu_opt_get(opts
, "mcast") ||
531 qemu_opt_get(opts
, "localaddr")) {
532 error_report("listen=, connect=, mcast= and localaddr= is invalid with fd=\n");
536 fd
= net_handle_fd_param(mon
, qemu_opt_get(opts
, "fd"));
541 if (!net_socket_fd_init(vlan
, "socket", name
, fd
, 1)) {
545 } else if (qemu_opt_get(opts
, "listen")) {
548 if (qemu_opt_get(opts
, "fd") ||
549 qemu_opt_get(opts
, "connect") ||
550 qemu_opt_get(opts
, "mcast") ||
551 qemu_opt_get(opts
, "localaddr")) {
552 error_report("fd=, connect=, mcast= and localaddr= is invalid with listen=\n");
556 listen
= qemu_opt_get(opts
, "listen");
558 if (net_socket_listen_init(vlan
, "socket", name
, listen
) == -1) {
561 } else if (qemu_opt_get(opts
, "connect")) {
564 if (qemu_opt_get(opts
, "fd") ||
565 qemu_opt_get(opts
, "listen") ||
566 qemu_opt_get(opts
, "mcast") ||
567 qemu_opt_get(opts
, "localaddr")) {
568 error_report("fd=, listen=, mcast= and localaddr= is invalid with connect=\n");
572 connect
= qemu_opt_get(opts
, "connect");
574 if (net_socket_connect_init(vlan
, "socket", name
, connect
) == -1) {
577 } else if (qemu_opt_get(opts
, "mcast")) {
578 const char *mcast
, *localaddr
;
580 if (qemu_opt_get(opts
, "fd") ||
581 qemu_opt_get(opts
, "connect") ||
582 qemu_opt_get(opts
, "listen")) {
583 error_report("fd=, connect= and listen= is invalid with mcast=");
587 mcast
= qemu_opt_get(opts
, "mcast");
588 localaddr
= qemu_opt_get(opts
, "localaddr");
590 if (net_socket_mcast_init(vlan
, "socket", name
, mcast
, localaddr
) == -1) {
594 error_report("-socket requires fd=, listen=, connect= or mcast=");