2 * inet and unix socket functions for qemu
4 * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; under version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * Contributions after 2012-01-13 are licensed under the terms of the
16 * GNU GPL, version 2 or (at your option) any later version.
25 #include "qemu_socket.h"
26 #include "qemu-common.h" /* for qemu_isdigit */
29 # define AI_ADDRCONFIG 0
32 static const int on
=1, off
=0;
34 /* used temporarely until all users are converted to QemuOpts */
35 static QemuOptsList dummy_opts
= {
37 .head
= QTAILQ_HEAD_INITIALIZER(dummy_opts
.head
),
41 .type
= QEMU_OPT_STRING
,
44 .type
= QEMU_OPT_STRING
,
47 .type
= QEMU_OPT_STRING
,
50 .type
= QEMU_OPT_NUMBER
,
53 .type
= QEMU_OPT_BOOL
,
56 .type
= QEMU_OPT_BOOL
,
59 .type
= QEMU_OPT_BOOL
,
65 static int inet_getport(struct addrinfo
*e
)
67 struct sockaddr_in
*i4
;
68 struct sockaddr_in6
*i6
;
70 switch (e
->ai_family
) {
72 i6
= (void*)e
->ai_addr
;
73 return ntohs(i6
->sin6_port
);
75 i4
= (void*)e
->ai_addr
;
76 return ntohs(i4
->sin_port
);
82 static void inet_setport(struct addrinfo
*e
, int port
)
84 struct sockaddr_in
*i4
;
85 struct sockaddr_in6
*i6
;
87 switch (e
->ai_family
) {
89 i6
= (void*)e
->ai_addr
;
90 i6
->sin6_port
= htons(port
);
93 i4
= (void*)e
->ai_addr
;
94 i4
->sin_port
= htons(port
);
99 const char *inet_strfamily(int family
)
102 case PF_INET6
: return "ipv6";
103 case PF_INET
: return "ipv4";
104 case PF_UNIX
: return "unix";
109 int inet_listen_opts(QemuOpts
*opts
, int port_offset
, Error
**errp
)
111 struct addrinfo ai
,*res
,*e
;
114 char uaddr
[INET6_ADDRSTRLEN
+1];
116 int slisten
, rc
, to
, port_min
, port_max
, p
;
118 memset(&ai
,0, sizeof(ai
));
119 ai
.ai_flags
= AI_PASSIVE
| AI_ADDRCONFIG
;
120 ai
.ai_family
= PF_UNSPEC
;
121 ai
.ai_socktype
= SOCK_STREAM
;
123 if ((qemu_opt_get(opts
, "host") == NULL
) ||
124 (qemu_opt_get(opts
, "port") == NULL
)) {
125 fprintf(stderr
, "%s: host and/or port not specified\n", __FUNCTION__
);
126 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
129 pstrcpy(port
, sizeof(port
), qemu_opt_get(opts
, "port"));
130 addr
= qemu_opt_get(opts
, "host");
132 to
= qemu_opt_get_number(opts
, "to", 0);
133 if (qemu_opt_get_bool(opts
, "ipv4", 0))
134 ai
.ai_family
= PF_INET
;
135 if (qemu_opt_get_bool(opts
, "ipv6", 0))
136 ai
.ai_family
= PF_INET6
;
140 snprintf(port
, sizeof(port
), "%d", atoi(port
) + port_offset
);
141 rc
= getaddrinfo(strlen(addr
) ? addr
: NULL
, port
, &ai
, &res
);
143 fprintf(stderr
,"getaddrinfo(%s,%s): %s\n", addr
, port
,
145 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
149 /* create socket + bind */
150 for (e
= res
; e
!= NULL
; e
= e
->ai_next
) {
151 getnameinfo((struct sockaddr
*)e
->ai_addr
,e
->ai_addrlen
,
152 uaddr
,INET6_ADDRSTRLEN
,uport
,32,
153 NI_NUMERICHOST
| NI_NUMERICSERV
);
154 slisten
= qemu_socket(e
->ai_family
, e
->ai_socktype
, e
->ai_protocol
);
156 fprintf(stderr
,"%s: socket(%s): %s\n", __FUNCTION__
,
157 inet_strfamily(e
->ai_family
), strerror(errno
));
159 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
164 setsockopt(slisten
,SOL_SOCKET
,SO_REUSEADDR
,(void*)&on
,sizeof(on
));
166 if (e
->ai_family
== PF_INET6
) {
167 /* listen on both ipv4 and ipv6 */
168 setsockopt(slisten
,IPPROTO_IPV6
,IPV6_V6ONLY
,(void*)&off
,
173 port_min
= inet_getport(e
);
174 port_max
= to
? to
+ port_offset
: port_min
;
175 for (p
= port_min
; p
<= port_max
; p
++) {
177 if (bind(slisten
, e
->ai_addr
, e
->ai_addrlen
) == 0) {
181 fprintf(stderr
,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__
,
182 inet_strfamily(e
->ai_family
), uaddr
, inet_getport(e
),
185 error_set(errp
, QERR_SOCKET_BIND_FAILED
);
189 closesocket(slisten
);
191 fprintf(stderr
, "%s: FAILED\n", __FUNCTION__
);
196 if (listen(slisten
,1) != 0) {
197 error_set(errp
, QERR_SOCKET_LISTEN_FAILED
);
199 closesocket(slisten
);
203 snprintf(uport
, sizeof(uport
), "%d", inet_getport(e
) - port_offset
);
204 qemu_opt_set(opts
, "host", uaddr
);
205 qemu_opt_set(opts
, "port", uport
);
206 qemu_opt_set(opts
, "ipv6", (e
->ai_family
== PF_INET6
) ? "on" : "off");
207 qemu_opt_set(opts
, "ipv4", (e
->ai_family
!= PF_INET6
) ? "on" : "off");
212 int inet_connect_opts(QemuOpts
*opts
, bool *in_progress
, Error
**errp
)
214 struct addrinfo ai
,*res
,*e
;
217 char uaddr
[INET6_ADDRSTRLEN
+1];
222 memset(&ai
,0, sizeof(ai
));
223 ai
.ai_flags
= AI_CANONNAME
| AI_ADDRCONFIG
;
224 ai
.ai_family
= PF_UNSPEC
;
225 ai
.ai_socktype
= SOCK_STREAM
;
228 *in_progress
= false;
231 addr
= qemu_opt_get(opts
, "host");
232 port
= qemu_opt_get(opts
, "port");
233 block
= qemu_opt_get_bool(opts
, "block", 0);
234 if (addr
== NULL
|| port
== NULL
) {
235 fprintf(stderr
, "inet_connect: host and/or port not specified\n");
236 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
240 if (qemu_opt_get_bool(opts
, "ipv4", 0))
241 ai
.ai_family
= PF_INET
;
242 if (qemu_opt_get_bool(opts
, "ipv6", 0))
243 ai
.ai_family
= PF_INET6
;
246 if (0 != (rc
= getaddrinfo(addr
, port
, &ai
, &res
))) {
247 fprintf(stderr
,"getaddrinfo(%s,%s): %s\n", addr
, port
,
249 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
253 for (e
= res
; e
!= NULL
; e
= e
->ai_next
) {
254 if (getnameinfo((struct sockaddr
*)e
->ai_addr
,e
->ai_addrlen
,
255 uaddr
,INET6_ADDRSTRLEN
,uport
,32,
256 NI_NUMERICHOST
| NI_NUMERICSERV
) != 0) {
257 fprintf(stderr
,"%s: getnameinfo: oops\n", __FUNCTION__
);
260 sock
= qemu_socket(e
->ai_family
, e
->ai_socktype
, e
->ai_protocol
);
262 fprintf(stderr
,"%s: socket(%s): %s\n", __FUNCTION__
,
263 inet_strfamily(e
->ai_family
), strerror(errno
));
266 setsockopt(sock
,SOL_SOCKET
,SO_REUSEADDR
,(void*)&on
,sizeof(on
));
268 socket_set_nonblock(sock
);
270 /* connect to peer */
273 if (connect(sock
, e
->ai_addr
, e
->ai_addrlen
) < 0) {
274 rc
= -socket_error();
276 } while (rc
== -EINTR
);
279 if (!block
&& (rc
== -EINPROGRESS
|| rc
== -EWOULDBLOCK
280 || rc
== -WSAEALREADY
)) {
282 if (!block
&& (rc
== -EINPROGRESS
)) {
288 error_set(errp
, QERR_SOCKET_CONNECT_IN_PROGRESS
);
290 if (NULL
== e
->ai_next
)
291 fprintf(stderr
, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__
,
292 inet_strfamily(e
->ai_family
),
293 e
->ai_canonname
, uaddr
, uport
, strerror(errno
));
300 error_set(errp
, QERR_SOCKET_CONNECT_FAILED
);
305 int inet_dgram_opts(QemuOpts
*opts
)
307 struct addrinfo ai
, *peer
= NULL
, *local
= NULL
;
310 char uaddr
[INET6_ADDRSTRLEN
+1];
314 /* lookup peer addr */
315 memset(&ai
,0, sizeof(ai
));
316 ai
.ai_flags
= AI_CANONNAME
| AI_ADDRCONFIG
;
317 ai
.ai_family
= PF_UNSPEC
;
318 ai
.ai_socktype
= SOCK_DGRAM
;
320 addr
= qemu_opt_get(opts
, "host");
321 port
= qemu_opt_get(opts
, "port");
322 if (addr
== NULL
|| strlen(addr
) == 0) {
325 if (port
== NULL
|| strlen(port
) == 0) {
326 fprintf(stderr
, "inet_dgram: port not specified\n");
330 if (qemu_opt_get_bool(opts
, "ipv4", 0))
331 ai
.ai_family
= PF_INET
;
332 if (qemu_opt_get_bool(opts
, "ipv6", 0))
333 ai
.ai_family
= PF_INET6
;
335 if (0 != (rc
= getaddrinfo(addr
, port
, &ai
, &peer
))) {
336 fprintf(stderr
,"getaddrinfo(%s,%s): %s\n", addr
, port
,
341 /* lookup local addr */
342 memset(&ai
,0, sizeof(ai
));
343 ai
.ai_flags
= AI_PASSIVE
;
344 ai
.ai_family
= peer
->ai_family
;
345 ai
.ai_socktype
= SOCK_DGRAM
;
347 addr
= qemu_opt_get(opts
, "localaddr");
348 port
= qemu_opt_get(opts
, "localport");
349 if (addr
== NULL
|| strlen(addr
) == 0) {
352 if (!port
|| strlen(port
) == 0)
355 if (0 != (rc
= getaddrinfo(addr
, port
, &ai
, &local
))) {
356 fprintf(stderr
,"getaddrinfo(%s,%s): %s\n", addr
, port
,
362 sock
= qemu_socket(peer
->ai_family
, peer
->ai_socktype
, peer
->ai_protocol
);
364 fprintf(stderr
,"%s: socket(%s): %s\n", __FUNCTION__
,
365 inet_strfamily(peer
->ai_family
), strerror(errno
));
368 setsockopt(sock
,SOL_SOCKET
,SO_REUSEADDR
,(void*)&on
,sizeof(on
));
371 if (getnameinfo((struct sockaddr
*)local
->ai_addr
,local
->ai_addrlen
,
372 uaddr
,INET6_ADDRSTRLEN
,uport
,32,
373 NI_NUMERICHOST
| NI_NUMERICSERV
) != 0) {
374 fprintf(stderr
, "%s: getnameinfo: oops\n", __FUNCTION__
);
377 if (bind(sock
, local
->ai_addr
, local
->ai_addrlen
) < 0) {
378 fprintf(stderr
,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__
,
379 inet_strfamily(local
->ai_family
), uaddr
, inet_getport(local
));
383 /* connect to peer */
384 if (getnameinfo((struct sockaddr
*)peer
->ai_addr
, peer
->ai_addrlen
,
385 uaddr
, INET6_ADDRSTRLEN
, uport
, 32,
386 NI_NUMERICHOST
| NI_NUMERICSERV
) != 0) {
387 fprintf(stderr
, "%s: getnameinfo: oops\n", __FUNCTION__
);
390 if (connect(sock
,peer
->ai_addr
,peer
->ai_addrlen
) < 0) {
391 fprintf(stderr
, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__
,
392 inet_strfamily(peer
->ai_family
),
393 peer
->ai_canonname
, uaddr
, uport
, strerror(errno
));
411 /* compatibility wrapper */
412 static int inet_parse(QemuOpts
*opts
, const char *str
)
414 const char *optstr
, *h
;
423 if (1 != sscanf(str
,":%32[^,]%n",port
,&pos
)) {
424 fprintf(stderr
, "%s: portonly parse error (%s)\n",
428 } else if (str
[0] == '[') {
430 if (2 != sscanf(str
,"[%64[^]]]:%32[^,]%n",addr
,port
,&pos
)) {
431 fprintf(stderr
, "%s: ipv6 parse error (%s)\n",
435 qemu_opt_set(opts
, "ipv6", "on");
436 } else if (qemu_isdigit(str
[0])) {
438 if (2 != sscanf(str
,"%64[0-9.]:%32[^,]%n",addr
,port
,&pos
)) {
439 fprintf(stderr
, "%s: ipv4 parse error (%s)\n",
443 qemu_opt_set(opts
, "ipv4", "on");
446 if (2 != sscanf(str
,"%64[^:]:%32[^,]%n",addr
,port
,&pos
)) {
447 fprintf(stderr
, "%s: hostname parse error (%s)\n",
452 qemu_opt_set(opts
, "host", addr
);
453 qemu_opt_set(opts
, "port", port
);
457 h
= strstr(optstr
, ",to=");
459 qemu_opt_set(opts
, "to", h
+4);
460 if (strstr(optstr
, ",ipv4"))
461 qemu_opt_set(opts
, "ipv4", "on");
462 if (strstr(optstr
, ",ipv6"))
463 qemu_opt_set(opts
, "ipv6", "on");
467 int inet_listen(const char *str
, char *ostr
, int olen
,
468 int socktype
, int port_offset
, Error
**errp
)
474 opts
= qemu_opts_create(&dummy_opts
, NULL
, 0, NULL
);
475 if (inet_parse(opts
, str
) == 0) {
476 sock
= inet_listen_opts(opts
, port_offset
, errp
);
477 if (sock
!= -1 && ostr
) {
478 optstr
= strchr(str
, ',');
479 if (qemu_opt_get_bool(opts
, "ipv6", 0)) {
480 snprintf(ostr
, olen
, "[%s]:%s%s",
481 qemu_opt_get(opts
, "host"),
482 qemu_opt_get(opts
, "port"),
483 optstr
? optstr
: "");
485 snprintf(ostr
, olen
, "%s:%s%s",
486 qemu_opt_get(opts
, "host"),
487 qemu_opt_get(opts
, "port"),
488 optstr
? optstr
: "");
492 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
498 int inet_connect(const char *str
, bool block
, bool *in_progress
, Error
**errp
)
503 opts
= qemu_opts_create(&dummy_opts
, NULL
, 0, NULL
);
504 if (inet_parse(opts
, str
) == 0) {
506 qemu_opt_set(opts
, "block", "on");
508 sock
= inet_connect_opts(opts
, in_progress
, errp
);
510 error_set(errp
, QERR_SOCKET_CREATE_FAILED
);
518 int unix_listen_opts(QemuOpts
*opts
)
520 struct sockaddr_un un
;
521 const char *path
= qemu_opt_get(opts
, "path");
524 sock
= qemu_socket(PF_UNIX
, SOCK_STREAM
, 0);
526 perror("socket(unix)");
530 memset(&un
, 0, sizeof(un
));
531 un
.sun_family
= AF_UNIX
;
532 if (path
&& strlen(path
)) {
533 snprintf(un
.sun_path
, sizeof(un
.sun_path
), "%s", path
);
535 char *tmpdir
= getenv("TMPDIR");
536 snprintf(un
.sun_path
, sizeof(un
.sun_path
), "%s/qemu-socket-XXXXXX",
537 tmpdir
? tmpdir
: "/tmp");
539 * This dummy fd usage silences the mktemp() unsecure warning.
540 * Using mkstemp() doesn't make things more secure here
541 * though. bind() complains about existing files, so we have
542 * to unlink first and thus re-open the race window. The
543 * worst case possible is bind() failing, i.e. a DoS attack.
545 fd
= mkstemp(un
.sun_path
); close(fd
);
546 qemu_opt_set(opts
, "path", un
.sun_path
);
550 if (bind(sock
, (struct sockaddr
*) &un
, sizeof(un
)) < 0) {
551 fprintf(stderr
, "bind(unix:%s): %s\n", un
.sun_path
, strerror(errno
));
554 if (listen(sock
, 1) < 0) {
555 fprintf(stderr
, "listen(unix:%s): %s\n", un
.sun_path
, strerror(errno
));
566 int unix_connect_opts(QemuOpts
*opts
)
568 struct sockaddr_un un
;
569 const char *path
= qemu_opt_get(opts
, "path");
573 fprintf(stderr
, "unix connect: no path specified\n");
577 sock
= qemu_socket(PF_UNIX
, SOCK_STREAM
, 0);
579 perror("socket(unix)");
583 memset(&un
, 0, sizeof(un
));
584 un
.sun_family
= AF_UNIX
;
585 snprintf(un
.sun_path
, sizeof(un
.sun_path
), "%s", path
);
586 if (connect(sock
, (struct sockaddr
*) &un
, sizeof(un
)) < 0) {
587 fprintf(stderr
, "connect(unix:%s): %s\n", path
, strerror(errno
));
595 /* compatibility wrapper */
596 int unix_listen(const char *str
, char *ostr
, int olen
)
602 opts
= qemu_opts_create(&dummy_opts
, NULL
, 0, NULL
);
604 optstr
= strchr(str
, ',');
608 path
= g_malloc(len
+1);
609 snprintf(path
, len
+1, "%.*s", len
, str
);
610 qemu_opt_set(opts
, "path", path
);
614 qemu_opt_set(opts
, "path", str
);
617 sock
= unix_listen_opts(opts
);
619 if (sock
!= -1 && ostr
)
620 snprintf(ostr
, olen
, "%s%s", qemu_opt_get(opts
, "path"), optstr
? optstr
: "");
625 int unix_connect(const char *path
)
630 opts
= qemu_opts_create(&dummy_opts
, NULL
, 0, NULL
);
631 qemu_opt_set(opts
, "path", path
);
632 sock
= unix_connect_opts(opts
);
639 int unix_listen_opts(QemuOpts
*opts
)
641 fprintf(stderr
, "unix sockets are not available on windows\n");
646 int unix_connect_opts(QemuOpts
*opts
)
648 fprintf(stderr
, "unix sockets are not available on windows\n");
653 int unix_listen(const char *path
, char *ostr
, int olen
)
655 fprintf(stderr
, "unix sockets are not available on windows\n");
660 int unix_connect(const char *path
)
662 fprintf(stderr
, "unix sockets are not available on windows\n");
670 static void socket_cleanup(void)
676 int socket_init(void)
682 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
684 err
= WSAGetLastError();
685 fprintf(stderr
, "WSAStartup: %d\n", err
);
688 atexit(socket_cleanup
);