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.
18 #include "qemu/osdep.h"
20 #ifdef CONFIG_AF_VSOCK
21 #include <linux/vm_sockets.h>
22 #endif /* CONFIG_AF_VSOCK */
24 #include "monitor/monitor.h"
25 #include "qapi/clone-visitor.h"
26 #include "qapi/error.h"
27 #include "qemu/sockets.h"
28 #include "qemu/main-loop.h"
29 #include "qapi/clone-visitor.h"
30 #include "qapi/qobject-input-visitor.h"
31 #include "qapi/qobject-output-visitor.h"
32 #include "qapi-visit.h"
33 #include "qemu/cutils.h"
36 # define AI_ADDRCONFIG 0
40 # define AI_V4MAPPED 0
43 #ifndef AI_NUMERICSERV
44 # define AI_NUMERICSERV 0
48 static int inet_getport(struct addrinfo
*e
)
50 struct sockaddr_in
*i4
;
51 struct sockaddr_in6
*i6
;
53 switch (e
->ai_family
) {
55 i6
= (void*)e
->ai_addr
;
56 return ntohs(i6
->sin6_port
);
58 i4
= (void*)e
->ai_addr
;
59 return ntohs(i4
->sin_port
);
65 static void inet_setport(struct addrinfo
*e
, int port
)
67 struct sockaddr_in
*i4
;
68 struct sockaddr_in6
*i6
;
70 switch (e
->ai_family
) {
72 i6
= (void*)e
->ai_addr
;
73 i6
->sin6_port
= htons(port
);
76 i4
= (void*)e
->ai_addr
;
77 i4
->sin_port
= htons(port
);
82 NetworkAddressFamily
inet_netfamily(int family
)
85 case PF_INET6
: return NETWORK_ADDRESS_FAMILY_IPV6
;
86 case PF_INET
: return NETWORK_ADDRESS_FAMILY_IPV4
;
87 case PF_UNIX
: return NETWORK_ADDRESS_FAMILY_UNIX
;
88 #ifdef CONFIG_AF_VSOCK
89 case PF_VSOCK
: return NETWORK_ADDRESS_FAMILY_VSOCK
;
90 #endif /* CONFIG_AF_VSOCK */
92 return NETWORK_ADDRESS_FAMILY_UNKNOWN
;
96 * Matrix we're trying to apply
107 * t t PF_INET6/PF_UNSPEC
109 * NB, this matrix is only about getting the necessary results
110 * from getaddrinfo(). Some of the cases require further work
111 * after reading results from getaddrinfo in order to fully
112 * apply the logic the end user wants.
114 * In the first and last cases, we must set IPV6_V6ONLY=0
115 * when binding, to allow a single listener to potentially
116 * accept both IPv4+6 addresses.
118 int inet_ai_family_from_address(InetSocketAddress
*addr
,
121 if (addr
->has_ipv6
&& addr
->has_ipv4
&&
122 !addr
->ipv6
&& !addr
->ipv4
) {
123 error_setg(errp
, "Cannot disable IPv4 and IPv6 at same time");
126 if ((addr
->has_ipv6
&& addr
->ipv6
) && (addr
->has_ipv4
&& addr
->ipv4
)) {
128 * Some backends can only do a single listener. In that case
129 * we want empty hostname to resolve to "::" and then use the
130 * flag IPV6_V6ONLY==0 to get both protocols on 1 socket. This
131 * doesn't work for addresses other than "", so they're just
132 * inevitably broken until multiple listeners can be used,
133 * and thus we honour getaddrinfo automatic protocol detection
134 * Once all backends do multi-listener, remove the PF_INET6
137 if (!addr
->host
|| g_str_equal(addr
->host
, "")) {
143 if ((addr
->has_ipv6
&& addr
->ipv6
) || (addr
->has_ipv4
&& !addr
->ipv4
)) {
146 if ((addr
->has_ipv4
&& addr
->ipv4
) || (addr
->has_ipv6
&& !addr
->ipv6
)) {
152 static int create_fast_reuse_socket(struct addrinfo
*e
)
154 int slisten
= qemu_socket(e
->ai_family
, e
->ai_socktype
, e
->ai_protocol
);
158 socket_set_fast_reuse(slisten
);
162 static int try_bind(int socket
, InetSocketAddress
*saddr
, struct addrinfo
*e
)
165 return bind(socket
, e
->ai_addr
, e
->ai_addrlen
);
168 * Deals with first & last cases in matrix in comment
169 * for inet_ai_family_from_address().
172 ((!saddr
->has_ipv4
&& !saddr
->has_ipv6
) ||
173 (saddr
->has_ipv4
&& saddr
->ipv4
&&
174 saddr
->has_ipv6
&& saddr
->ipv6
)) ? 0 : 1;
178 if (e
->ai_family
== PF_INET6
) {
179 qemu_setsockopt(socket
, IPPROTO_IPV6
, IPV6_V6ONLY
, &v6only
,
183 stat
= bind(socket
, e
->ai_addr
, e
->ai_addrlen
);
188 /* If we got EADDRINUSE from an IPv6 bind & v6only is unset,
189 * it could be that the IPv4 port is already claimed, so retry
192 if (e
->ai_family
== PF_INET6
&& errno
== EADDRINUSE
&& !v6only
) {
200 static int inet_listen_saddr(InetSocketAddress
*saddr
,
205 struct addrinfo ai
,*res
,*e
;
207 char uaddr
[INET6_ADDRSTRLEN
+1];
209 int rc
, port_min
, port_max
, p
;
212 bool socket_created
= false;
215 memset(&ai
,0, sizeof(ai
));
216 ai
.ai_flags
= AI_PASSIVE
;
217 if (saddr
->has_numeric
&& saddr
->numeric
) {
218 ai
.ai_flags
|= AI_NUMERICHOST
| AI_NUMERICSERV
;
220 ai
.ai_family
= inet_ai_family_from_address(saddr
, &err
);
221 ai
.ai_socktype
= SOCK_STREAM
;
224 error_propagate(errp
, err
);
228 if (saddr
->host
== NULL
) {
229 error_setg(errp
, "host not specified");
232 if (saddr
->port
!= NULL
) {
233 pstrcpy(port
, sizeof(port
), saddr
->port
);
240 unsigned long long baseport
;
241 if (strlen(port
) == 0) {
242 error_setg(errp
, "port not specified");
245 if (parse_uint_full(port
, &baseport
, 10) < 0) {
246 error_setg(errp
, "can't convert to a number: %s", port
);
249 if (baseport
> 65535 ||
250 baseport
+ port_offset
> 65535) {
251 error_setg(errp
, "port %s out of range", port
);
254 snprintf(port
, sizeof(port
), "%d", (int)baseport
+ port_offset
);
256 rc
= getaddrinfo(strlen(saddr
->host
) ? saddr
->host
: NULL
,
257 strlen(port
) ? port
: NULL
, &ai
, &res
);
259 error_setg(errp
, "address resolution failed for %s:%s: %s",
260 saddr
->host
, port
, gai_strerror(rc
));
264 /* create socket + bind/listen */
265 for (e
= res
; e
!= NULL
; e
= e
->ai_next
) {
266 getnameinfo((struct sockaddr
*)e
->ai_addr
,e
->ai_addrlen
,
267 uaddr
,INET6_ADDRSTRLEN
,uport
,32,
268 NI_NUMERICHOST
| NI_NUMERICSERV
);
270 slisten
= create_fast_reuse_socket(e
);
275 socket_created
= true;
276 port_min
= inet_getport(e
);
277 port_max
= saddr
->has_to
? saddr
->to
+ port_offset
: port_min
;
278 for (p
= port_min
; p
<= port_max
; p
++) {
280 rc
= try_bind(slisten
, saddr
, e
);
282 if (errno
== EADDRINUSE
) {
285 error_setg_errno(errp
, errno
, "Failed to bind socket");
289 if (!listen(slisten
, 1)) {
292 if (errno
!= EADDRINUSE
) {
293 error_setg_errno(errp
, errno
, "Failed to listen on socket");
296 /* Someone else managed to bind to the same port and beat us
297 * to listen on it! Socket semantics does not allow us to
298 * recover from this situation, so we need to recreate the
299 * socket to allow bind attempts for subsequent ports:
301 closesocket(slisten
);
302 slisten
= create_fast_reuse_socket(e
);
304 error_setg_errno(errp
, errno
,
305 "Failed to recreate failed listening socket");
310 error_setg_errno(errp
, errno
,
312 "Failed to find an available port" :
313 "Failed to create a socket");
317 closesocket(slisten
);
326 saddr
->host
= g_strdup(uaddr
);
328 saddr
->port
= g_strdup_printf("%d",
329 inet_getport(e
) - port_offset
);
330 saddr
->has_ipv6
= saddr
->ipv6
= e
->ai_family
== PF_INET6
;
331 saddr
->has_ipv4
= saddr
->ipv4
= e
->ai_family
!= PF_INET6
;
338 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
339 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
341 #define QEMU_SOCKET_RC_INPROGRESS(rc) \
342 ((rc) == -EINPROGRESS)
345 static int inet_connect_addr(struct addrinfo
*addr
, Error
**errp
);
347 static int inet_connect_addr(struct addrinfo
*addr
, Error
**errp
)
351 sock
= qemu_socket(addr
->ai_family
, addr
->ai_socktype
, addr
->ai_protocol
);
353 error_setg_errno(errp
, errno
, "Failed to create socket");
356 socket_set_fast_reuse(sock
);
358 /* connect to peer */
361 if (connect(sock
, addr
->ai_addr
, addr
->ai_addrlen
) < 0) {
364 } while (rc
== -EINTR
);
367 error_setg_errno(errp
, errno
, "Failed to connect socket");
375 static struct addrinfo
*inet_parse_connect_saddr(InetSocketAddress
*saddr
,
378 struct addrinfo ai
, *res
;
381 static int useV4Mapped
= 1;
383 memset(&ai
, 0, sizeof(ai
));
385 ai
.ai_flags
= AI_CANONNAME
| AI_ADDRCONFIG
;
386 if (atomic_read(&useV4Mapped
)) {
387 ai
.ai_flags
|= AI_V4MAPPED
;
389 ai
.ai_family
= inet_ai_family_from_address(saddr
, &err
);
390 ai
.ai_socktype
= SOCK_STREAM
;
393 error_propagate(errp
, err
);
397 if (saddr
->host
== NULL
|| saddr
->port
== NULL
) {
398 error_setg(errp
, "host and/or port not specified");
403 rc
= getaddrinfo(saddr
->host
, saddr
->port
, &ai
, &res
);
405 /* At least FreeBSD and OS-X 10.6 declare AI_V4MAPPED but
406 * then don't implement it in their getaddrinfo(). Detect
407 * this and retry without the flag since that's preferrable
410 if (rc
== EAI_BADFLAGS
&&
411 (ai
.ai_flags
& AI_V4MAPPED
)) {
412 atomic_set(&useV4Mapped
, 0);
413 ai
.ai_flags
&= ~AI_V4MAPPED
;
414 rc
= getaddrinfo(saddr
->host
, saddr
->port
, &ai
, &res
);
417 error_setg(errp
, "address resolution failed for %s:%s: %s",
418 saddr
->host
, saddr
->port
, gai_strerror(rc
));
425 * Create a socket and connect it to an address.
427 * @saddr: Inet socket address specification
428 * @errp: set on error
430 * Returns: -1 on error, file descriptor on success.
432 int inet_connect_saddr(InetSocketAddress
*saddr
, Error
**errp
)
434 Error
*local_err
= NULL
;
435 struct addrinfo
*res
, *e
;
438 res
= inet_parse_connect_saddr(saddr
, errp
);
443 for (e
= res
; e
!= NULL
; e
= e
->ai_next
) {
444 error_free(local_err
);
446 sock
= inet_connect_addr(e
, &local_err
);
453 error_propagate(errp
, local_err
);
460 static int inet_dgram_saddr(InetSocketAddress
*sraddr
,
461 InetSocketAddress
*sladdr
,
464 struct addrinfo ai
, *peer
= NULL
, *local
= NULL
;
470 /* lookup peer addr */
471 memset(&ai
,0, sizeof(ai
));
472 ai
.ai_flags
= AI_CANONNAME
| AI_V4MAPPED
| AI_ADDRCONFIG
;
473 ai
.ai_family
= inet_ai_family_from_address(sraddr
, &err
);
474 ai
.ai_socktype
= SOCK_DGRAM
;
477 error_propagate(errp
, err
);
483 if (addr
== NULL
|| strlen(addr
) == 0) {
486 if (port
== NULL
|| strlen(port
) == 0) {
487 error_setg(errp
, "remote port not specified");
491 if ((rc
= getaddrinfo(addr
, port
, &ai
, &peer
)) != 0) {
492 error_setg(errp
, "address resolution failed for %s:%s: %s", addr
, port
,
497 /* lookup local addr */
498 memset(&ai
,0, sizeof(ai
));
499 ai
.ai_flags
= AI_PASSIVE
;
500 ai
.ai_family
= peer
->ai_family
;
501 ai
.ai_socktype
= SOCK_DGRAM
;
506 if (addr
== NULL
|| strlen(addr
) == 0) {
509 if (!port
|| strlen(port
) == 0) {
517 if ((rc
= getaddrinfo(addr
, port
, &ai
, &local
)) != 0) {
518 error_setg(errp
, "address resolution failed for %s:%s: %s", addr
, port
,
524 sock
= qemu_socket(peer
->ai_family
, peer
->ai_socktype
, peer
->ai_protocol
);
526 error_setg_errno(errp
, errno
, "Failed to create socket");
529 socket_set_fast_reuse(sock
);
532 if (bind(sock
, local
->ai_addr
, local
->ai_addrlen
) < 0) {
533 error_setg_errno(errp
, errno
, "Failed to bind socket");
537 /* connect to peer */
538 if (connect(sock
,peer
->ai_addr
,peer
->ai_addrlen
) < 0) {
539 error_setg_errno(errp
, errno
, "Failed to connect socket");
561 /* compatibility wrapper */
562 int inet_parse(InetSocketAddress
*addr
, const char *str
, Error
**errp
)
564 const char *optstr
, *h
;
570 memset(addr
, 0, sizeof(*addr
));
576 if (sscanf(str
, ":%32[^,]%n", port
, &pos
) != 1) {
577 error_setg(errp
, "error parsing port in address '%s'", str
);
580 } else if (str
[0] == '[') {
582 if (sscanf(str
, "[%64[^]]]:%32[^,]%n", host
, port
, &pos
) != 2) {
583 error_setg(errp
, "error parsing IPv6 address '%s'", str
);
587 /* hostname or IPv4 addr */
588 if (sscanf(str
, "%64[^:]:%32[^,]%n", host
, port
, &pos
) != 2) {
589 error_setg(errp
, "error parsing address '%s'", str
);
594 addr
->host
= g_strdup(host
);
595 addr
->port
= g_strdup(port
);
599 h
= strstr(optstr
, ",to=");
602 if (sscanf(h
, "%d%n", &to
, &pos
) != 1 ||
603 (h
[pos
] != '\0' && h
[pos
] != ',')) {
604 error_setg(errp
, "error parsing to= argument");
610 if (strstr(optstr
, ",ipv4")) {
611 addr
->ipv4
= addr
->has_ipv4
= true;
613 if (strstr(optstr
, ",ipv6")) {
614 addr
->ipv6
= addr
->has_ipv6
= true;
621 * Create a blocking socket and connect it to an address.
623 * @str: address string
624 * @errp: set in case of an error
626 * Returns -1 in case of error, file descriptor on success
628 int inet_connect(const char *str
, Error
**errp
)
631 InetSocketAddress
*addr
= g_new(InetSocketAddress
, 1);
633 if (!inet_parse(addr
, str
, errp
)) {
634 sock
= inet_connect_saddr(addr
, errp
);
636 qapi_free_InetSocketAddress(addr
);
640 #ifdef CONFIG_AF_VSOCK
641 static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress
*vaddr
,
642 struct sockaddr_vm
*svm
,
645 unsigned long long val
;
647 memset(svm
, 0, sizeof(*svm
));
648 svm
->svm_family
= AF_VSOCK
;
650 if (parse_uint_full(vaddr
->cid
, &val
, 10) < 0 ||
652 error_setg(errp
, "Failed to parse cid '%s'", vaddr
->cid
);
657 if (parse_uint_full(vaddr
->port
, &val
, 10) < 0 ||
659 error_setg(errp
, "Failed to parse port '%s'", vaddr
->port
);
667 static int vsock_connect_addr(const struct sockaddr_vm
*svm
, Error
**errp
)
671 sock
= qemu_socket(AF_VSOCK
, SOCK_STREAM
, 0);
673 error_setg_errno(errp
, errno
, "Failed to create socket");
677 /* connect to peer */
680 if (connect(sock
, (const struct sockaddr
*)svm
, sizeof(*svm
)) < 0) {
683 } while (rc
== -EINTR
);
686 error_setg_errno(errp
, errno
, "Failed to connect socket");
694 static int vsock_connect_saddr(VsockSocketAddress
*vaddr
, Error
**errp
)
696 struct sockaddr_vm svm
;
699 if (!vsock_parse_vaddr_to_sockaddr(vaddr
, &svm
, errp
)) {
703 sock
= vsock_connect_addr(&svm
, errp
);
708 static int vsock_listen_saddr(VsockSocketAddress
*vaddr
,
711 struct sockaddr_vm svm
;
714 if (!vsock_parse_vaddr_to_sockaddr(vaddr
, &svm
, errp
)) {
718 slisten
= qemu_socket(AF_VSOCK
, SOCK_STREAM
, 0);
720 error_setg_errno(errp
, errno
, "Failed to create socket");
724 if (bind(slisten
, (const struct sockaddr
*)&svm
, sizeof(svm
)) != 0) {
725 error_setg_errno(errp
, errno
, "Failed to bind socket");
726 closesocket(slisten
);
730 if (listen(slisten
, 1) != 0) {
731 error_setg_errno(errp
, errno
, "Failed to listen on socket");
732 closesocket(slisten
);
738 static int vsock_parse(VsockSocketAddress
*addr
, const char *str
,
745 if (sscanf(str
, "%32[^:]:%32[^,]%n", cid
, port
, &n
) != 2) {
746 error_setg(errp
, "error parsing address '%s'", str
);
749 if (str
[n
] != '\0') {
750 error_setg(errp
, "trailing characters in address '%s'", str
);
754 addr
->cid
= g_strdup(cid
);
755 addr
->port
= g_strdup(port
);
759 static void vsock_unsupported(Error
**errp
)
761 error_setg(errp
, "socket family AF_VSOCK unsupported");
764 static int vsock_connect_saddr(VsockSocketAddress
*vaddr
, Error
**errp
)
766 vsock_unsupported(errp
);
770 static int vsock_listen_saddr(VsockSocketAddress
*vaddr
,
773 vsock_unsupported(errp
);
777 static int vsock_parse(VsockSocketAddress
*addr
, const char *str
,
780 vsock_unsupported(errp
);
783 #endif /* CONFIG_AF_VSOCK */
787 static int unix_listen_saddr(UnixSocketAddress
*saddr
,
791 struct sockaddr_un un
;
793 char *pathbuf
= NULL
;
796 sock
= qemu_socket(PF_UNIX
, SOCK_STREAM
, 0);
798 error_setg_errno(errp
, errno
, "Failed to create Unix socket");
802 if (saddr
->path
&& saddr
->path
[0]) {
805 const char *tmpdir
= getenv("TMPDIR");
806 tmpdir
= tmpdir
? tmpdir
: "/tmp";
807 path
= pathbuf
= g_strdup_printf("%s/qemu-socket-XXXXXX", tmpdir
);
810 if (strlen(path
) > sizeof(un
.sun_path
)) {
811 error_setg(errp
, "UNIX socket path '%s' is too long", path
);
812 error_append_hint(errp
, "Path must be less than %zu bytes\n",
813 sizeof(un
.sun_path
));
817 if (pathbuf
!= NULL
) {
819 * This dummy fd usage silences the mktemp() unsecure warning.
820 * Using mkstemp() doesn't make things more secure here
821 * though. bind() complains about existing files, so we have
822 * to unlink first and thus re-open the race window. The
823 * worst case possible is bind() failing, i.e. a DoS attack.
825 fd
= mkstemp(pathbuf
);
827 error_setg_errno(errp
, errno
,
828 "Failed to make a temporary socket %s", pathbuf
);
834 if (unlink(path
) < 0 && errno
!= ENOENT
) {
835 error_setg_errno(errp
, errno
,
836 "Failed to unlink socket %s", path
);
840 memset(&un
, 0, sizeof(un
));
841 un
.sun_family
= AF_UNIX
;
842 strncpy(un
.sun_path
, path
, sizeof(un
.sun_path
));
844 if (bind(sock
, (struct sockaddr
*) &un
, sizeof(un
)) < 0) {
845 error_setg_errno(errp
, errno
, "Failed to bind socket to %s", path
);
848 if (listen(sock
, 1) < 0) {
849 error_setg_errno(errp
, errno
, "Failed to listen on socket");
853 if (update_addr
&& pathbuf
) {
855 saddr
->path
= pathbuf
;
867 static int unix_connect_saddr(UnixSocketAddress
*saddr
, Error
**errp
)
869 struct sockaddr_un un
;
872 if (saddr
->path
== NULL
) {
873 error_setg(errp
, "unix connect: no path specified");
877 sock
= qemu_socket(PF_UNIX
, SOCK_STREAM
, 0);
879 error_setg_errno(errp
, errno
, "Failed to create socket");
883 if (strlen(saddr
->path
) > sizeof(un
.sun_path
)) {
884 error_setg(errp
, "UNIX socket path '%s' is too long", saddr
->path
);
885 error_append_hint(errp
, "Path must be less than %zu bytes\n",
886 sizeof(un
.sun_path
));
890 memset(&un
, 0, sizeof(un
));
891 un
.sun_family
= AF_UNIX
;
892 strncpy(un
.sun_path
, saddr
->path
, sizeof(un
.sun_path
));
894 /* connect to peer */
897 if (connect(sock
, (struct sockaddr
*) &un
, sizeof(un
)) < 0) {
900 } while (rc
== -EINTR
);
903 error_setg_errno(errp
, -rc
, "Failed to connect socket %s",
917 static int unix_listen_saddr(UnixSocketAddress
*saddr
,
921 error_setg(errp
, "unix sockets are not available on windows");
926 static int unix_connect_saddr(UnixSocketAddress
*saddr
, Error
**errp
)
928 error_setg(errp
, "unix sockets are not available on windows");
934 /* compatibility wrapper */
935 int unix_listen(const char *str
, char *ostr
, int olen
, Error
**errp
)
939 UnixSocketAddress
*saddr
;
941 saddr
= g_new0(UnixSocketAddress
, 1);
943 optstr
= strchr(str
, ',');
947 path
= g_malloc(len
+1);
948 snprintf(path
, len
+1, "%.*s", len
, str
);
952 saddr
->path
= g_strdup(str
);
955 sock
= unix_listen_saddr(saddr
, true, errp
);
957 if (sock
!= -1 && ostr
) {
958 snprintf(ostr
, olen
, "%s%s", saddr
->path
, optstr
? optstr
: "");
961 qapi_free_UnixSocketAddress(saddr
);
965 int unix_connect(const char *path
, Error
**errp
)
967 UnixSocketAddress
*saddr
;
970 saddr
= g_new0(UnixSocketAddress
, 1);
971 saddr
->path
= g_strdup(path
);
972 sock
= unix_connect_saddr(saddr
, errp
);
973 qapi_free_UnixSocketAddress(saddr
);
978 SocketAddress
*socket_parse(const char *str
, Error
**errp
)
982 addr
= g_new0(SocketAddress
, 1);
983 if (strstart(str
, "unix:", NULL
)) {
984 if (str
[5] == '\0') {
985 error_setg(errp
, "invalid Unix socket address");
988 addr
->type
= SOCKET_ADDRESS_TYPE_UNIX
;
989 addr
->u
.q_unix
.path
= g_strdup(str
+ 5);
991 } else if (strstart(str
, "fd:", NULL
)) {
992 if (str
[3] == '\0') {
993 error_setg(errp
, "invalid file descriptor address");
996 addr
->type
= SOCKET_ADDRESS_TYPE_FD
;
997 addr
->u
.fd
.str
= g_strdup(str
+ 3);
999 } else if (strstart(str
, "vsock:", NULL
)) {
1000 addr
->type
= SOCKET_ADDRESS_TYPE_VSOCK
;
1001 if (vsock_parse(&addr
->u
.vsock
, str
+ strlen("vsock:"), errp
)) {
1005 addr
->type
= SOCKET_ADDRESS_TYPE_INET
;
1006 if (inet_parse(&addr
->u
.inet
, str
, errp
)) {
1013 qapi_free_SocketAddress(addr
);
1017 int socket_connect(SocketAddress
*addr
, Error
**errp
)
1021 switch (addr
->type
) {
1022 case SOCKET_ADDRESS_TYPE_INET
:
1023 fd
= inet_connect_saddr(&addr
->u
.inet
, errp
);
1026 case SOCKET_ADDRESS_TYPE_UNIX
:
1027 fd
= unix_connect_saddr(&addr
->u
.q_unix
, errp
);
1030 case SOCKET_ADDRESS_TYPE_FD
:
1031 fd
= monitor_get_fd(cur_mon
, addr
->u
.fd
.str
, errp
);
1034 case SOCKET_ADDRESS_TYPE_VSOCK
:
1035 fd
= vsock_connect_saddr(&addr
->u
.vsock
, errp
);
1044 int socket_listen(SocketAddress
*addr
, Error
**errp
)
1048 switch (addr
->type
) {
1049 case SOCKET_ADDRESS_TYPE_INET
:
1050 fd
= inet_listen_saddr(&addr
->u
.inet
, 0, false, errp
);
1053 case SOCKET_ADDRESS_TYPE_UNIX
:
1054 fd
= unix_listen_saddr(&addr
->u
.q_unix
, false, errp
);
1057 case SOCKET_ADDRESS_TYPE_FD
:
1058 fd
= monitor_get_fd(cur_mon
, addr
->u
.fd
.str
, errp
);
1061 case SOCKET_ADDRESS_TYPE_VSOCK
:
1062 fd
= vsock_listen_saddr(&addr
->u
.vsock
, errp
);
1071 void socket_listen_cleanup(int fd
, Error
**errp
)
1073 SocketAddress
*addr
;
1075 addr
= socket_local_address(fd
, errp
);
1077 if (addr
->type
== SOCKET_ADDRESS_TYPE_UNIX
1078 && addr
->u
.q_unix
.path
) {
1079 if (unlink(addr
->u
.q_unix
.path
) < 0 && errno
!= ENOENT
) {
1080 error_setg_errno(errp
, errno
,
1081 "Failed to unlink socket %s",
1082 addr
->u
.q_unix
.path
);
1086 qapi_free_SocketAddress(addr
);
1089 int socket_dgram(SocketAddress
*remote
, SocketAddress
*local
, Error
**errp
)
1094 * TODO SOCKET_ADDRESS_TYPE_FD when fd is AF_INET or AF_INET6
1095 * (although other address families can do SOCK_DGRAM, too)
1097 switch (remote
->type
) {
1098 case SOCKET_ADDRESS_TYPE_INET
:
1099 fd
= inet_dgram_saddr(&remote
->u
.inet
,
1100 local
? &local
->u
.inet
: NULL
, errp
);
1104 error_setg(errp
, "socket type unsupported for datagram");
1111 static SocketAddress
*
1112 socket_sockaddr_to_address_inet(struct sockaddr_storage
*sa
,
1116 char host
[NI_MAXHOST
];
1117 char serv
[NI_MAXSERV
];
1118 SocketAddress
*addr
;
1119 InetSocketAddress
*inet
;
1122 ret
= getnameinfo((struct sockaddr
*)sa
, salen
,
1125 NI_NUMERICHOST
| NI_NUMERICSERV
);
1127 error_setg(errp
, "Cannot format numeric socket address: %s",
1132 addr
= g_new0(SocketAddress
, 1);
1133 addr
->type
= SOCKET_ADDRESS_TYPE_INET
;
1134 inet
= &addr
->u
.inet
;
1135 inet
->host
= g_strdup(host
);
1136 inet
->port
= g_strdup(serv
);
1137 if (sa
->ss_family
== AF_INET
) {
1138 inet
->has_ipv4
= inet
->ipv4
= true;
1140 inet
->has_ipv6
= inet
->ipv6
= true;
1148 static SocketAddress
*
1149 socket_sockaddr_to_address_unix(struct sockaddr_storage
*sa
,
1153 SocketAddress
*addr
;
1154 struct sockaddr_un
*su
= (struct sockaddr_un
*)sa
;
1156 addr
= g_new0(SocketAddress
, 1);
1157 addr
->type
= SOCKET_ADDRESS_TYPE_UNIX
;
1158 if (su
->sun_path
[0]) {
1159 addr
->u
.q_unix
.path
= g_strndup(su
->sun_path
, sizeof(su
->sun_path
));
1166 #ifdef CONFIG_AF_VSOCK
1167 static SocketAddress
*
1168 socket_sockaddr_to_address_vsock(struct sockaddr_storage
*sa
,
1172 SocketAddress
*addr
;
1173 VsockSocketAddress
*vaddr
;
1174 struct sockaddr_vm
*svm
= (struct sockaddr_vm
*)sa
;
1176 addr
= g_new0(SocketAddress
, 1);
1177 addr
->type
= SOCKET_ADDRESS_TYPE_VSOCK
;
1178 vaddr
= &addr
->u
.vsock
;
1179 vaddr
->cid
= g_strdup_printf("%u", svm
->svm_cid
);
1180 vaddr
->port
= g_strdup_printf("%u", svm
->svm_port
);
1184 #endif /* CONFIG_AF_VSOCK */
1187 socket_sockaddr_to_address(struct sockaddr_storage
*sa
,
1191 switch (sa
->ss_family
) {
1194 return socket_sockaddr_to_address_inet(sa
, salen
, errp
);
1198 return socket_sockaddr_to_address_unix(sa
, salen
, errp
);
1201 #ifdef CONFIG_AF_VSOCK
1203 return socket_sockaddr_to_address_vsock(sa
, salen
, errp
);
1207 error_setg(errp
, "socket family %d unsupported",
1215 SocketAddress
*socket_local_address(int fd
, Error
**errp
)
1217 struct sockaddr_storage ss
;
1218 socklen_t sslen
= sizeof(ss
);
1220 if (getsockname(fd
, (struct sockaddr
*)&ss
, &sslen
) < 0) {
1221 error_setg_errno(errp
, errno
, "%s",
1222 "Unable to query local socket address");
1226 return socket_sockaddr_to_address(&ss
, sslen
, errp
);
1230 SocketAddress
*socket_remote_address(int fd
, Error
**errp
)
1232 struct sockaddr_storage ss
;
1233 socklen_t sslen
= sizeof(ss
);
1235 if (getpeername(fd
, (struct sockaddr
*)&ss
, &sslen
) < 0) {
1236 error_setg_errno(errp
, errno
, "%s",
1237 "Unable to query remote socket address");
1241 return socket_sockaddr_to_address(&ss
, sslen
, errp
);
1245 SocketAddress
*socket_address_flatten(SocketAddressLegacy
*addr_legacy
)
1247 SocketAddress
*addr
;
1253 addr
= g_new(SocketAddress
, 1);
1255 switch (addr_legacy
->type
) {
1256 case SOCKET_ADDRESS_LEGACY_KIND_INET
:
1257 addr
->type
= SOCKET_ADDRESS_TYPE_INET
;
1258 QAPI_CLONE_MEMBERS(InetSocketAddress
, &addr
->u
.inet
,
1259 addr_legacy
->u
.inet
.data
);
1261 case SOCKET_ADDRESS_LEGACY_KIND_UNIX
:
1262 addr
->type
= SOCKET_ADDRESS_TYPE_UNIX
;
1263 QAPI_CLONE_MEMBERS(UnixSocketAddress
, &addr
->u
.q_unix
,
1264 addr_legacy
->u
.q_unix
.data
);
1266 case SOCKET_ADDRESS_LEGACY_KIND_VSOCK
:
1267 addr
->type
= SOCKET_ADDRESS_TYPE_VSOCK
;
1268 QAPI_CLONE_MEMBERS(VsockSocketAddress
, &addr
->u
.vsock
,
1269 addr_legacy
->u
.vsock
.data
);
1271 case SOCKET_ADDRESS_LEGACY_KIND_FD
:
1272 addr
->type
= SOCKET_ADDRESS_TYPE_FD
;
1273 QAPI_CLONE_MEMBERS(String
, &addr
->u
.fd
, addr_legacy
->u
.fd
.data
);